= Python =
Python is a programming language that lets you work more quickly and integrate your systems more effectively. 

Links:
 * [[http://docs.python.org/2/library/]]
 * [[http://www.tutorialspoint.com/python/]]
 * [[https://learnxinyminutes.com/docs/python/]]
 * https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/lecture-videos/

<<TableOfContents(2)>>

== Python3 ==
=== Install from SlackBuild ===
{{{#!highlight bash
cd /tmp
wget http://slackbuilds.org/slackbuilds/13.1/development/python3.tar.gz
tar xvzf python3.tar.gz
cd python3
wget http://python.org/ftp/python/3.1.3/Python-3.1.3.tar.bz2
./python3.SlackBuild
installpkg /tmp/python3-3.1.1-i486-1_SBo.tgz
}}}

== UTF-8 ==
At the start of source code files:
{{{#!highlight python
# -*- coding: utf-8 -*-
print u"Olá mundo" # hello world in portuguese
}}}

Letter '''á''' is encoded as hexadecimal '''0xC3A1''' in UTF-8 and as '''0x00E1''' in UTF-16.
[[http://www.fileformat.info/info/unicode/char/e1/index.htm]]

Letter '''ú''' is encoded  as hexadecimal '''0xC3BA''' in UTF-8, as '''0x00FA''' in UTF-16 and as '''0xFA''' in latin-1/ISO8859-1/CP-1252.

{{{#!highlight python
#utf-8 data
utf81 ='\xc3\xba' 
# convert from utf-8 to unicode
unic = utf81.decode('utf-8') 

for c in unic:
    print '%04X'%(ord(c))
# convert from unicode to latin1/ISO8859-1 CP-1252
lat1=unic.encode('latin1') 
for c in lat1:
    print '%02X'%(ord(c))
}}}

== Utf-8 and Unicode ==
{{{#!highlight python
utf81='\xe1\xb7\x97' #utf-8 data

unic = utf81.decode('utf-8') #converts from utf-8 to unicode (utf-16)
for c in unic:
    print '%04X'%(ord(c))
type(unic) # unicode, 2 bytes per char
type(utf81) # str, 1 bytes per char
}}}

{{{#!highlight python
# python3 example
a=u'cão' # string in utf-8
x=bytes(a,'utf-8') # convert string in utf-8 to bytes representation
print(dir(a))
print(dir(x))
print(type(a))
print(type(x))
b = x.decode() # convert bytes again to an utf-8 string
print(dir(b))
print(type(b))
}}}

== Time and date ==
{{{#!highlight python
import time
# get seconds since epoch until now in UTC to a string year-month-dayThour:minute:second
strutc = time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime() ) 
# get seconds since epoch until now  in localtime to a string  year-month-dayThour:minute:second
strlocal = time.strftime('%Y-%m-%dT%H:%M:%S', time.localtime() ) 
# number seconds since epoch
nrSeconds = time.mktime(time.gmtime())
nrSeconds = time.time() #usually is UTC on all OS
# from timestamp to string date
import datetime
print(datetime.datetime.fromtimestamp(1284101485).strftime('%Y-%m-%d %H:%M:%S'))
#
def toUTCDateStr(timestamp):
    return datetime.datetime.utcfromtimestamp( timestamp ).strftime('%Y-%m-%d %H:%M:%S ')
# timedelta
import datetime
x=datetime.datetime.fromtimestamp(1284101485)
nowx=datetime.datetime.now()                    
ts=(nowx-x).total_seconds()
print int(ts)
### add , subtract days
import datetime
x = datetime.datetime(2014,1,2)
print x
y = x - datetime.timedelta(days=1)
print y
z = y - datetime.timedelta(days=1)
print z

### convert string with date to time tuple
import time
timeTuple = time.strptime('2014-01-01 10:11:12','%Y-%m-%d %H:%M:%S')
nrSecondsSince1970=time.mktime(timeTuple)
### get seconds since epoch
start = int(datetime.datetime(2014,3,9,0,0,0,0).strftime("%s"))*1000
end = int(datetime.datetime(2014,3,14,23,59,59,999).strftime("%s"))*1000

### string from utc current date
currutc=datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")

import time
help(time.strptime)
tt=time.strptime('Sat Aug 14 20:28:54 UTC 2021','%a %b %d %H:%M:%S %Z %Y')
nrSecondsSince1970=time.mktime(tt)

# email date format
>>> time.strftime('%a, %d %b %Y %H:%M:%S %z (%Z)', time.gmtime() )
'Sun, 27 Feb 2022 14:17:14 +0000 (GMT)'
}}}

== Write and reading data for a plist file ==
A plist file stores data in XML format.

{{{#!highlight python
import plistlib
value = [{'key1':123,'key2':'asdf'},{'keyx1':'testing','keyz1':'yup'}]
# save value in plist file
plistlib.writePlist(value,'/tmp/plist1.plist')
o=plistlib.readPlist('/tmp/plist1.plist')
print o
}}}

Content of the file '''/tmp/plist1.plist'''
{{{#!highlight xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array>
        <dict>
                <key>key1</key>
                <integer>123</integer>
                <key>key2</key>
                <string>asdf</string>
        </dict>
        <dict>
                <key>keyx1</key>
                <string>testing</string>
                <key>keyz1</key>
                <string>yup</string>
        </dict>
</array>
</plist>
}}}

== Threading ==

{{{#!highlight python
#!/usr/bin/python
# timestable.py
# calculates the times table in concurrency
import threading
import time

class TimesTable (threading.Thread):
    def __init__(self, timesTable):
        threading.Thread.__init__(self) #required
        self.timeTable = timesTable
        self.count = 1
    def run(self):
        loop=True
        while loop:
            time.sleep(1) #sleep for 1 second
            result=self.timeTable * self.count
            print "%d*%d=%d"%(self.timeTable,self.count,result)
            if self.count<10:
	        self.count = self.count+1
	    else:
	        self.count=1

# create threads
timesTable2 = TimesTable(2)
timesTable5 = TimesTable(7)

# start the threads
timesTable2.start()
timesTable5.start()
}}}

== unit tests (pyunit) ==
{{{#!highlight python
#filename: unitTest.py
#Run tests: python unitTest.py
#Should fail on testAdd2
import unittest

class SimpleTestCase(unittest.TestCase):
    def setUp(self):
        self.res=4

    def tearDown(self):
        self.res=0

    def testAdd1(self):
        res=2+2
        self.assertEqual(self.res,res,'')       

    def testAdd2(self):
        res=2+3
        self.assertEqual(self.res,res,'')       

    def testAdd3(self):
        res=2+3
        self.assertNotEqual(self.res,res,'')       

if __name__ == '__main__':
    unittest.main()
}}}

== unit tests coverage (pyunit) ==
 * http://coverage.readthedocs.io/en/latest/cmd.html
{{{#!highlight bash
pip install coverage
pip install --user --upgrade coverage 
}}}
'''tests.py'''
{{{#!highlight python
import unittest
from impl import add 
from impl import sub

class TestCase(unittest.TestCase):
    def test_add(self):
        self.assertEqual(5,add(2,3))
#    def test_sub(self):
#        self.assertEqual(1,add(3,2))
if __name__ == '__main__':
    unittest.main()
}}}

'''impl.py'''
{{{#!highlight python
def add(arg1,arg2):
    return arg1+arg2

def sub(arg1,arg2):
    return arg-+arg2
}}}

Steps:
 * coverage erase
 * coverage run tests.py
 * coverage report -m impl.py
 * coverage html impl.py  #in htmlcov folder

== unit tests - mock ==
{{{#!highlight python
from unittest.mock import MagicMock

class X(object):
    def getX(self):
        return 111

if __name__=='__main__':
    x = X()
    print(x.getX())
    x.getX = MagicMock(return_value=999)
    print( x.getX() )
}}}

== cython ==
Installation:
 * su
 * cd /tmp
 * wget http://cython.org/release/Cython-0.19.1.tar.gz
 * tar xvzf Cython-0.19.1.tar.gz 
 * cd Cython-0.19.1
 * python setup.py build
 * python setup.py install

== pymssql ==
Requires cython.
Installation:
{{{#!highlight bash
su
cd /tmp
wget [[http://pymssql.googlecode.com/files/pymssql-2.0.0b1-dev-20111019.tar.gz]]
tar xvvzf pymssql-2.0.0b1-dev-20111019.tar.gz
cd pymssql-2.0.0b1-dev-20111019
python setup.py build
python setup.py install
python
import pymssql
}}}

== pywhois ==
Python module for retrieving WHOIS information of domains [[http://code.google.com/p/pywhois/]].

Fetch code with mercurial:
{{{#!highlight bash
cd /tmp
hg clone https://code.google.com/p/pywhois/
cd pywhois
python setup.py build
python setup.py install
}}}

== Syntax highlighting on Vim for wsgi ==
Edit ~./.vimrc:
{{{#!highlight bash 
syntax on
filetype on
au BufNewFile,BufRead *.wsgi set filetype=python
}}}

== Get file modification time ==
{{{#!highlight python
import os
nrSeconds=os.path.getmtime('/folder/file') # unix epoch, nr secs since 1970-01-01 00:00:00
}}}

== Kill process with PID ==
{{{#!highlight python
import os
import signal
os.kill(pid,signal.SIGTERM) 
}}}

== Log message to /var/log/messages or /var/log/syslog ==
{{{#!highlight python
import syslog
syslog.syslog(syslog.LOG_INFO,'message to syslog')
}}}

{{{#!highlight python
import syslog

syslog.syslog(syslog.LOG_DEBUG,'DEBUG')
syslog.syslog(syslog.LOG_INFO,'INFO')
syslog.syslog(syslog.LOG_WARNING,'WARNING')
syslog.syslog(syslog.LOG_ERR,'ERR')
syslog.syslog(syslog.LOG_CRIT,'CRIT')
}}}

||OS||File||Logged levels||
||Slack64 14||/var/log/messages|| INFO ||
||Slack64 14||/var/log/syslog|| WARNING ERR CRIT ||
||CentOS 6.4||/var/log/messages|| INFO WARNING ERR CRIT ||
||Ubuntu 12.04 Precise||/var/log/syslog||DEBUG INFO WARNING ERR CRIT ||
||Debian 7.0 Wheezy||/var/log/syslog||DEBUG INFO WARNING ERR CRIT ||

== Simple process monitor ==
{{{#!highlight python
# example service, dummyService.py
import time
while True:
    try:
        f=open('filex.log','wb')
        f.write('%f'%(time.time()))
        f.close() 
        time.sleep(5)
    except KeyboardInterrupt:
        quit()
}}}

{{{#!highlight python
#service monitor.py
# * * * * * /usr/bin/python /home/vitor/svc/monitor.py
import os
import syslog
import subprocess

if __name__=="__main__":
    files = os.listdir('/proc')
    script="dummyService.py"
    prefix="dummyService:"

    svcRunning=False

    for file in files:

        if file.isdigit():
            cmdline = open('/proc/%s/cmdline'%(file),'r').read()
            proc = "%s %s "%(file,cmdline)

            if script  in proc :
                svcRunning=True

    if svcRunning==False:
        syslog.syslog(syslog.LOG_INFO,'%s process created '%(prefix) )
        # run exec process on python Popen
        subprocess.Popen(['/usr/bin/python','dummyService.py'],cwd='/home/userx/svc')
}}}

== Read URL content ==
{{{#!highlight python
import urllib2
r=urllib2.urlopen('http://www.sapo.pt')
resp=r.read()
print resp
}}}

== Windows service ==
Install http://sourceforge.net/projects/pywin32/files/pywin32/Build%20218/pywin32-218.win32-py2.5.exe/download for Python 2.5 for Windows.

Adapted from http://ryrobes.com/python/running-python-scripts-as-a-windows-service/
{{{#!highlight python
# C:\cmt\test>python testWinSvc.py install
# C:\cmt\test>python testWinSvc.py start
# C:\cmt\test>python testWinSvc.py stop
# C:\cmt\test>python testWinSvc.py remove
# C:\cmt\test>service.msc
import win32service
import win32serviceutil
import win32api
import win32con
import win32event
import win32evtlogutil
import os, sys, string, time

class aservice(win32serviceutil.ServiceFramework):
   _svc_name_ = "MyServiceShortName"
   _svc_display_name_ = "My Service Long Fancy Name!"
   _svc_description_ = "THis is what my crazy little service does - aka a DESCRIPTION! WHoa!"
         
   def __init__(self, args):
           win32serviceutil.ServiceFramework.__init__(self, args)
           self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)           

   def SvcStop(self):
           self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
           win32event.SetEvent(self.hWaitStop)                    
         
   def SvcDoRun(self):
      import servicemanager      
      servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,servicemanager.PYS_SERVICE_STARTED,(self._svc_name_, ''))       
      self.timeout = 1000     #1 second
      # This is how long the service will wait to run / refresh itself (see script below)

      while 1:
         # Wait for service stop signal, if I timeout, loop again
         rc = win32event.WaitForSingleObject(self.hWaitStop, self.timeout)
         # Check to see if self.hWaitStop happened
         if rc == win32event.WAIT_OBJECT_0:
            # Stop signal encountered
            servicemanager.LogInfoMsg("SomeShortNameVersion - STOPPED!")  #For Event Log
            break
         else:
                 try:
                     handle = open('c:/windows/temp/outx1.txt', "a")
                     handle.write('%s \n' % ('tst svc'))
                     handle.close()
                 except:
                     pass



def ctrlHandler(ctrlType):
   return True
                  
if __name__ == '__main__':   
   win32api.SetConsoleCtrlHandler(ctrlHandler, True)   
   win32serviceutil.HandleCommandLine(aservice)
}}}

== Logging ==

{{{#!highlight python
import logging 
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
                    datefmt='%m-%d %H:%M',
                    filename='/tmp/app.log',
                    filemode='w')
logging.info('Jackdaws love my big sphinx of quartz.')
logging.info('Jackdaws love my big sphinx of quartz.')
logging.info('Jackdaws love my big sphinx of quartz33.')
quit()
# cat /tmp/app.log 
}}}


Adapted from http://docs.python.org/2/howto/logging-cookbook.html#logging-to-multiple-destinations

{{{#!highlight python
import logging

logging.basicConfig(level=logging.DEBUG, \
    format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', \
    datefmt='%Y-%m-%d %H:%M:%S %z', \
    filename='/tmp/myapp.log', \
    filemode='a')
#log to console
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.info('Jackdaws love my big sphinx of quartz.') # using default logger '' 
#other loggers
logger1 = logging.getLogger('myapp.area1')
logger2 = logging.getLogger(__name__)
logger1.debug('Quick zephyrs blow, vexing daft Jim.')
logger1.info('How quickly daft jumping zebras vex.')
logger2.warning('Jail zesty vixen who grabbed pay from quack.')
logger2.error('The five boxing wizards jump quickly.')
}}}


Copied from http://docs.python.org/2/howto/logging-cookbook.html#configuration-server-example
Logging configurable on runtime, receiving new parameters by socket

Server:
{{{#!highlight python
import logging
import logging.config
import time
import os

# read initial config file
logging.config.fileConfig('logging.conf')

# create and start listener on port 9999
t = logging.config.listen(9999)
t.start()

logger = logging.getLogger('simpleExample')

try:
    # loop through logging calls to see the difference
    # new configurations make, until Ctrl+C is pressed
    while True:
        logger.debug('debug message')
        logger.info('info message')
        logger.warn('warn message')
        logger.error('error message')
        logger.critical('critical message')
        time.sleep(5)
except KeyboardInterrupt:
    # cleanup
    logging.config.stopListening()
    t.join()
}}}

Client:
{{{#!highlight python
#!/usr/bin/env python
import socket, sys, struct

with open(sys.argv[1], 'rb') as f:
    data_to_send = f.read()

HOST = 'localhost'
PORT = 9999
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print('connecting...')
s.connect((HOST, PORT))
print('sending config...')
s.send(struct.pack('>L', len(data_to_send)))
s.send(data_to_send)
s.close()
print('complete')
}}}

== Logging with date rotation and email ==
{{{#!highlight python
import logging
from logging.handlers import TimedRotatingFileHandler
from logging.handlers import SMTPHandler

class Logger(object):
    def __init__(self):
        loggerName='appx'
        logFormatter = logging.Formatter('[%(asctime)s %(name)-12s %(levelname)-8s] %(message)s',datefmt='%Y-%m-%d %H:%M:%S %z')
        
        rotatingLogHandler = TimedRotatingFileHandler('%s.log'%(loggerName),when='midnight',utc=True)
        rotatingLogHandler.setFormatter(logFormatter)
        rotatingLogHandler.setLevel(logging.DEBUG)

        smtpLogHandler = SMTPHandler(mailhost='hostx.com', fromaddr='mail@hostx.com', toaddrs='dest@hostx.com', subject=loggerName, \
            credentials=('accountx','12345678'), secure=None)
        smtpLogHandler.setFormatter(logFormatter)
        smtpLogHandler.setLevel(logging.WARNING)
                        
        self.logger = logging.getLogger(loggerName)
        self.logger.addHandler(rotatingLogHandler)
        self.logger.addHandler(smtpLogHandler)
        self.logger.setLevel(logging.DEBUG)
        
    def debug(self,m):
        self.logger.debug(m)

    def info(self,m):
        self.logger.info(m)

    def warning(self,m):
        self.logger.warning(m)
        
    def error(self,m):
        self.logger.error(m)
        
    def critical(self,m):
        self.logger.critical(m)

}}}

== pytz - World Timezone Definitions for Python ==
{{{#!highlight python

import pytz
import datetime

#fmt = '%Y-%m-%d %H:%M:%S %Z%z'
london=pytz.timezone('Europe/London')
lisbon=pytz.timezone('Europe/Lisbon')
paris  =pytz.timezone('Europe/Paris')
utc = pytz.timezone('UTC')
berlin = pytz.timezone('Europe/Berlin')

print
dtx = datetime.datetime(2002, 12, 27, 12, 0, 0,tzinfo=utc ) 
print 
print 'UTC    ' , dtx
print 'London ',dtx.astimezone(london)
print 'Lisbon ',dtx.astimezone(lisbon)
print 'Paris  ',dtx.astimezone(paris)
print 'Berlin ',dtx.astimezone(berlin)


print
dty = datetime.datetime(2002, 8, 27, 13, 0, 0,tzinfo=utc ) 
print 'UTC    ',dty
print 'London ',dty.astimezone(london)
print 'Lisbon ',dty.astimezone(lisbon)
print 'Paris  ',dty.astimezone(paris)
print 'Berlin ',dty.astimezone(berlin)
}}}

== Sort example ==
{{{#!highlight python
class Acme(object):
    def __init__(self,valuex):
        self.valuex=valuex

    def __cmp__(self, other):
        if self.valuex==other.valuex:
            return 0
        if self.valuex>other.valuex:
            return 1
        if self.valuex<other.valuex:
            return -1

    def __repr__(self):
        return self.valuex

if __name__=='__main__':
    listx=[]
    listx.append( Acme('C') )
    listx.append( Acme('A') )
    listx.append( Acme('Z') )
    print 'original:',listx
    print 'sorted asc:',sorted(listx,reverse=False)
    print 'sorted desc:',sorted(listx,reverse=True)
    listx.sort()
    print 'sort:',listx
    listx.reverse()
    print 'reverse:',listx
}}}

== sys.path ==
With sys.path we are able to add new folders which serve as base path to modules. The idea is similar to classpath in Java.

Create file /tmp/testex.py
{{{#!highlight python
def test1()
    print("Alright !!!!")
}}}

Run python interactively:
{{{#!highlight bash
vitor@darkstar[~]$python
Python 2.7.3 (default, Jul  3 2012, 21:16:07) 
[GCC 4.7.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import testex
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named testex
>>> import sys
>>> sys.path.append('/tmp') # add /tmp to modules paths
>>> testex.test1()
Allright !!!!
}}}

By default on Linux systems, modules are also searched in '''~/.local/pythonXX.YY/site-packages'''. If the file testex.py would exist, it would also be used without being necessary to add the folder /tmp to the '''sys.path''' . For the user vitor and python 2.7 the path would be '''/home/vitor/.local/lib/python2.7/site-packages''' .

== Math ==
{{{#!highlight python
# round float to 6 decimal places
nr=1.23456789
print round(nr,6)
# round float to 4 decimal places
nr=1.23456789
print round(nr,4)
}}}

== SMTP ==
{{{#!highlight python
import smtplib

class Smtp(object):
    def __init__(self,server,port,user,passx,appName):
        self.server=server
        self.port=port
        self.user=user
        self.passx=passx
        self.appName=appName

    def send(self,fromx,tox,subjectx,contentType,body):
        s=smtplib.SMTP()
        s.connect(self.server,self.port)
        s.ehlo(self.appName)
        s.login(self.user,self.passx)         
        msg='From: %s\r\nTo: %s\r\nSubject: %s\r\nContent-Type: %s\r\n\r\n%s'%(fromx,tox,subjectx,contentType,body)
        s.sendmail(fromx,tox,msg)
        s.quit()

s=Smtp('mail.example.org',25,'norep@example.org','12345678','TestApp')
# content types: text/plain text/html
s.send('norep@example.org',['user1@example.org','user2@example.org'],'Subject','text/plain','Body mail')
}}}

== JSON serializable ==
{{{#!highlight python
from json import JSONEncoder
import json

class EncoderJSON(JSONEncoder):
    def default(self, o):
        return o.getJSONDict()    
    
class Acme(object):
    def __init__(self,paramx,valuex):
        self.paramx=paramx
        self.valuex=valuex
        
    def getJSONDict(self):
        return {'paramx':self.paramx ,'valuex':self.valuex}
                
    def __repr__(self):
        return '%s %s %s'%(self.paramx ,self.valuex)

if __name__=='__main__':
    listx=[]
    listx.append(Acme('p1','v1'))
    listx.append(Acme('p2','v2'))
    # json.dumps likes lists and dictionaries
    print( json.dumps(listx,cls=EncoderJSON) ) 
    # output [{"valuex": "v1", "paramx": "p1"}, {"valuex": "v2", "paramx": "p2"}]

}}}

== Decorators ==
http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/

Wraps functions with functionality, before, after , changes parameters of the decorated function.

{{{#!highlight python
#decorator logger
def logger(func):
        def inner(*args, **kwargs): # step 1
            print "Arguments were: %s, %s" % (args, kwargs)
            return func(*args, **kwargs) # step 2
        return inner

@logger
def foo1(x, y=1):
    return x * y
if __name__=='__main__':
    foo1(2,2)
}}}

{{{#!highlight python
import sys
from os import path 
#decorator adder
def add_one_args(decoratedFunction):
    def interceptor(*args, **kwargs): # step 1
        print "Arguments were: args %s, kwargs %s" % (args, kwargs)
        index=0
        new_args=[]
        # change input 
        isnotint=False
        for arg in args:
            if isinstance(arg,int):                    
                new_args.append(arg+1)
            else:
                isnotint=True
            index=index+1
                
        if isnotint==False: 
            args=tuple(new_args)

        new_kwargs={}
        for kwarg in kwargs:
            new_kwargs[kwarg] = kwargs[kwarg]+1

        decoratedFuncReturn =  decoratedFunction(*args, **new_kwargs) # step 2
        # change output
        decoratedFuncReturn = decoratedFuncReturn * 2
        return decoratedFuncReturn
    return interceptor

@add_one_args
def foo1(x, y=1):
    print('Got arguments in foo1 %d %d'%(x,y))
    mul = x * y
    print('Multiplication result inside function %d'%(mul))
    return mul

def foo2(**kwargs):
    print('Got arguments in foo1 %d %d'%( kwargs['x'] , kwargs['y']  ))
    mul = kwargs['x'] * kwargs['y']
    print('Multiplication result inside function %d'%(mul))
    return mul

if __name__=='__main__':
    print( foo1(2,y=2) )
    print( foo2( x=3,y=3  ) )
    print( sys.path )
    print( sys.prefix )
    print( sys.exec_prefix )
    here = path.abspath(path.dirname(__file__))
    print(here)
}}}

{{{#!highlight python
def add_one_args(decoratedFunction,xyz=1):
    def interceptor(*args, **kwargs):
        print "Arguments were: args %s, kwargs %s" % (args, kwargs)
        new_args=[]

        for arg in args:
            if isinstance(arg,int): new_args.append(arg+1)
            else: new_args.append(arg)

        args=tuple(new_args)
        decoratedFuncReturn = decoratedFunction(*args, **kwargs) 
        return decoratedFuncReturn
    return interceptor

def subtract_one_args(decoratedFunction,xyz=1):
    def interceptor(*args, **kwargs):
        print "Arguments were: args %s, kwargs %s" % (args, kwargs)
        new_args=[]

        for arg in args:
            if isinstance(arg,int): new_args.append(arg-1)
            else: new_args.append(arg)

        args=tuple(new_args)
        decoratedFuncReturn = decoratedFunction(*args, **kwargs) 
        return decoratedFuncReturn
    return interceptor

class Acme(object):
    def __init__(self):
        self.a = 0
        self.b = 0

    @add_one_args
    @subtract_one_args
    def set(self,a,b):
        self.a=a
        self.b=b
        print self.a, self.b

if __name__=='__main__':
    x = Acme()
    x.set(0,1)
}}}


== Dictionaries ==
{{{#!highlight python
a={} #create dictionary
if 'keyx' in a: print 'ok' #check if key keyx exists
a['keyx']=1 # create key keyx with value 1
if 'keyx' in a: print 'ok' #checks  keyx existence
a['key2']={} # create key key2
if 'keyx' in a['key2']: print 'ok' # check if keyx exists in key2
a['key2']['keyx']=3 # create keyx inside key2
if 'keyx' in a['key2']: print 'ok'
}}}

== Exceptions ==
Example 1
{{{#!highlight python
def dummyMethod(datax):
    try:
        if 'key1' in datax:
            key1 = datax['key1']

            if 'key2' in key1:
                key2 = dvi['key2']
                print('key2 is %s '%(key2))                    

    except Exception,ex:
        print('Error in dummyMethod %s'%( str(ex) ) )
}}}

== Install pip ==
{{{#!highlight bash
easy_install pip
}}}

== Regular expressions ==
{{{#!python
import re
listx=['aa12.txt','a123sss.txt','bs11bb.txt','123aaaa.sql','a12.txt','aaaa12','20ghj','6657']

for item in listx:
    res = re.match('^(\D+)(\d+)(\D+)$',item)
    if res!=None:
        decimal =  int(res.group(2)) + 1
        print('A: mv %s %s%d%s'%(item , res.group(1),decimal , res.group(3) ))
    res = re.match('^(\d+)(\D+)$',item)
    if res!=None:
        decimal =  int(res.group(1)) + 1
        print('B: mv %s %d%s'%(item , decimal,res.group(2)))
    res = re.match('^(\D+)(\d+)$',item)
    if res!=None:
        decimal =  int(res.group(2)) + 1
        print('C: mv %s  %s%d'%(item , res.group(1),decimal))
    res = re.match('^(\d+)$',item)
    if res!=None:
        decimal =  int(res.group(1)) + 1
        print('D: mv %s  %d'%(item , decimal))
'''
#ouput
 python addNumber.py 
A: mv aa12.txt aa13.txt
A: mv a123sss.txt a124sss.txt
A: mv bs11bb.txt bs12bb.txt
B: mv 123aaaa.sql 124aaaa.sql
A: mv a12.txt a13.txt
C: mv aaaa12  aaaa13
B: mv 20ghj 21ghj
D: mv 6657  6658
'''
}}}

{{{#!highlight python
# replace using regex (sub)
import re
a="adasd@gg@g:00-0:0.xml.txt"
print re.sub('[@,:]','',a)
# adasdggg00-00.xml.txt
}}}

== Command line arguments ==
 * import sys
{{{#!highlight python
import sys
# ...
if __name__=='__main__':
    intArgA = int(sys.argv[1])
    intArgB = int(sys.argv[2])
    intArgC = int(sys.argv[3])

}}}

== Run python code in shell without source code file .py ==
{{{#!highlight sh
echo "<log type="typex" other="bbbbb" msgId="bbbbbb" >" | xargs -i echo -e "strx='{}'\nsplitted = strx.split(' ')\nfor spl in splitted:\n\tif 'msgId' in spl:\n\t\tprint spl.split('=')[1]"  | python                         
}}}

{{{#!highlight python
strx='{}' # where xargs value is used
splitted = strx.split(' ')
for spl in splitted:
    if 'msgId' in spl:
        print spl.split('=')[1]
}}}

== Alias identifier inside module ==
{{{#!highlight python
from json import dumps as jsonDumps
jsonDumps({'key':'value'})
# '{"key": "value"}'
print jsonDumps({'key':'value' , 'key2':1234})
# {"key2": 1234, "key": "value"} 
}}}

== Execute process using subprocess ==
{{{#!highlight python
import subprocess 

if __name__=='__main__':
  try:
    args=[]
    args.append('ls')
    args.append('/tmpx')
    out = subprocess.check_output(args, stderr=subprocess.STDOUT, shell=False)
    print( out )
  except subprocess.CalledProcessError as ex1:
    print("Exception command: %s"%(ex1.cmd)  )    
    print("Exception code: %s"%(ex1.returncode)  )    
    print("Exception output: %s"%(ex1.output)  )
  except Exception as ex2:
    print("General exception %s"%(ex2.message) )    
}}}

== Recursion ==
{{{#!highlight python   
def factorial(n):
  if n > 0: return n * factorial(n-1)
  else: return 1

def fibo(n):
  if n==0: return 0
  if n==1: return 1
  if n>1: return fibo(n-1) + fibo(n-2)

def sum(idx,lista):
  if idx<0: return 0
  if idx>=0: return lista[idx] + sum(idx-1,lista)

if __name__=='__main__':
  print( factorial(4) )
  print( fibo(3) )
  lst=[1,2,3,4]
  print( sum(len(lst)-1,lst) )
}}}

== Python3 virtual environment ==
 * https://packaging.python.org/tutorials/installing-packages/#creating-virtual-environments

Python '''Virtual Environments''' allow Python packages to be installed in an isolated location for a particular application, rather than being installed globally.

You can deactivate a virtual environment by typing '''deactivate''' in your shell.

{{{#!highlight bash
sudo apt-get install python3-venv
cd /tmp/
mkdir envTest
cd envTest/
python3 -m venv testVenv
source testVenv/bin/activate
pip install --upgrade pip
# pip install -i https://testpypi.python.org/pypi vbhelloworld
echo -e "vbhelloworld @  https://test-files.pythonhosted.org/packages/d9/89/2ae8e276dc33d1510b8f19e4e1b2b2ca7be95ed40db89125b099609e7e1a/vbhelloworld-1.0.3.1-py2.py3-none-any.whl\n
requests" > requirements.txt
pip install -r requirements.txt
# solve bugs in code
sed -i s/yaml.load/yaml.safe_load/g testVenv/lib/python3.9/site-packages/vbhelloworld/__init__.py
mkdir -p /home/vitor/.local/etc
# invoke comand
testVenv/bin/helloworld
pip uninstall vbhelloworld
deactivate
}}}

 * https://docs.python.org/3/library/venv.html#module-venv

When a virtual environment is active (i.e., the virtual environment’s Python interpreter is running), the attributes sys.prefix and sys.exec_prefix point to the base directory of the virtual environment, whereas sys.base_prefix and sys.base_exec_prefix point to the non-virtual environment Python installation which was used to create the virtual environment. 

If a virtual environment is not active, then sys.prefix is the same as sys.base_prefix and sys.exec_prefix is the same as sys.base_exec_prefix (they all point to a non-virtual environment Python installation).

== List Comprehensions ==
{{{#!highlight python
squares = [x**2 for x in range(10)]
# squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
sequence = [x for x in range(1,9)]
# sequence [1, 2, 3, 4, 5, 6, 7, 8]
range(10)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
squares = [x**2 for x in range(10) if x<= 4]
# squares [0, 1, 4, 9, 16]
}}}

== Python 2 virtual env ==
{{{#!highlight sh
# in windows with powershell
cd ~
pip install virtualenv --user
# add the scripts folder to the user path c:\users\userx\AppData\Roaming\Python\Scripts 
# using cmd
cd %HOME_PATH%
mkdir tmp
cd tmp
virtualenv.exe test_env
cd test_env
Scripts\activate.bat
}}}

{{{#!highlight python
import sys
sys.path
}}}

== Generator functions yield ==
{{{#!highlight python
#test yield
def factorial(val):
    v=val
    res=1
    while v>1:
        res=res*v
        v=v-1
        yield None # v
    yield res

if __name__ == "__main__":
    for i in factorial(3):
        print(i)

    f = factorial(4)
    iterate=True

    while iterate:
        try:
            print( f.next() )
            #print( next(f) )
        except StopIteration as ex:
            iterate=False
}}}

'''Output:'''
{{{#!highlight bash
python test_yeld.py 
None
None
6
None
None
None
24
}}}

== XML parse with minidom ==
 * https://docs.python.org/2/library/xml.dom.minidom.html
{{{#!highlight python
from xml.dom import minidom
print("Hello world")
a="<a><b>aaaa</b><b>bbcc</b></a>"
doc = minidom.parseString(a) # return document 
tags = doc.getElementsByTagName("b")
for t in tags:
  print(t.firstChild.nodeValue)

}}}

== Environment variable ==
{{{#!highlight python
import os
print(os.environ)
}}}


== XSD and objectify XML ==
'''test.py'''
{{{#!highlight python
from lxml import objectify
from StringIO import StringIO
from lxml import etree

f = open('test.xsd')
xsddata=''
for line in f:
    xsddata = xsddata +  line
f.close()

xmlschema_doc = etree.parse(StringIO(xsddata))
xmlschema = etree.XMLSchema(xmlschema_doc)
print xmlschema 

parser = objectify.makeparser(schema=xmlschema)
xml = "<a><b>test</b></a>"
a = objectify.fromstring(xml, parser)
print(a.b)
}}}

'''test.xsd'''
{{{#!highlight xml
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="a" type="AType"/>
  <xsd:complexType name="AType">
       <xsd:sequence>
         <xsd:element name="b" type="xsd:string" />
       </xsd:sequence>
  </xsd:complexType>
</xsd:schema>
}}}

'''Other example ....'''
{{{
@startuml
class AType
class BType
class AcmeType

/' 
<|--  extends 
-- association
..> depends 
<|.. implements / realizes
'/ 

AType : b : String
AType : xx : BType
AcmeType : other : int
BType : c : String

AType ..> BType
AcmeType --|> AType
@enduml
}}}

{{attachment:classes.png}}

'''acme.xsd'''
{{{#!highlight xml
<xs:schema 
    xmlns:xs="http://www.w3.org/2001/XMLSchema" 
    xmlns:bit="http://bitarus.allowed.org/types" 
    xmlns:ot="http://bitarus.allowed.org/othertypes" 
    targetNamespace="http://bitarus.allowed.org/othertypes" 
    elementFormDefault="qualified"
  >
  <xs:import schemaLocation="test.xsd" />  
  <xs:complexType name="AcmeType">  
    <xs:complexContent>
        <xs:extension base="bit:AType">
            <xs:sequence>
                <xs:element name="other" type="xs:int"/>
            </xs:sequence>
        </xs:extension>
    </xs:complexContent>      
  </xs:complexType>
  <xs:element name="at" type="ot:AcmeType"/>
</xs:schema>
}}}

'''test.xsd'''
{{{#!highlight xml
<xsd:schema 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    xmlns:bit="http://bitarus.allowed.org/types" 
    targetNamespace="http://bitarus.allowed.org/types" 
    elementFormDefault="qualified" 
>
  <xsd:complexType name="AType">
       <xsd:sequence>
         <xsd:element name="b" type="xsd:string" />         
         <xsd:element name="xx" type="bit:BType" />
       </xsd:sequence>
  </xsd:complexType>  
  <xsd:complexType name="BType">
      <xsd:sequence>
        <xsd:element name="c" type="xsd:string" />
      </xsd:sequence>
  </xsd:complexType>  
  <xsd:element name="a" type="bit:AType"/>
</xsd:schema>
}}}

'''acme.py'''
{{{#!highlight python
from lxml import objectify
from StringIO import StringIO
from lxml import etree
import os
f = open('acme.xsd')
xsddata=''
for line in f:
    xsddata = xsddata +  line
f.close()

xmlschema = etree.XMLSchema(etree.parse(StringIO(xsddata)))

xml = """
<ot:at xmlns:ot="http://bitarus.allowed.org/othertypes" 
  xsi:schemaLocation="http://bitarus.allowed.org/othertypes other.xsd" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:bit="http://bitarus.allowed.org/types" >
  <bit:b>cccc</bit:b>
  <bit:xx><bit:c>hhjjkk</bit:c></bit:xx>
  <ot:other>1234</ot:other>  
</ot:at>
"""

doc = etree.fromstring(xml, etree.XMLParser(schema=xmlschema) )
# https://lxml.de/api/lxml.etree._Element-class.html
bNode = doc.getchildren()[0]
otherNode = doc.getchildren()[2]
print bNode.text
print otherNode.text
}}}

== XML tree/graph ==
{{{#!highlight python
from lxml import objectify
from lxml import etree
from StringIO import StringIO
import sys

def show_children(parent,node):
    if node.getchildren():
        print parent+"/"+node.tag
        index=1
        for c in node.getchildren():
            show_children(parent+"/"+node.tag, c )
            index=index+1
    else:
        if node.text:
            print parent + "/"+node.tag + "=" + node.text
        else:
            print parent + "/"+node.tag

    if node.attrib:
        for key in node.attrib:
            print parent + "/"+node.tag +"@"+key+"="+node.attrib[key]

if __name__=='__main__':
    f = open(sys.argv[1])
    data=''
    for line in f:
       if line.startswith("<?xml ")==False:  data = data +  line
    f.close()
    # print data
    doc = etree.fromstring( data )
    f.close()
    show_children("",doc)
}}}

== Debugger ==
{{{#!highlight python
# python test.py
# DEBUG=on python test.py  
import os
# ....
if 'DEBUG' in os.environ:
  # breakpoint 
  import pdb; pdb.set_trace()

# commands
# c continue
# q quit
# n next
# l list
# s step
# w stacktrace
}}}

== Remote debugger ==
{{{#!highlight python
# pip install --user rpdb
# cat rpdb_test.py
print("aaa")
# listens in 0.0.0.0 4444
import rpdb; rpdb.set_trace(addr="0.0.0.0")
print("bbb")
print("ccc")
# python3 rpdb_test.py
# docker run (...) -p 4444:4444
# nc localhost 4444
}}}

== Install package in user home folder pointing to other libs ==
 * rpm -ql rpmpackage # check installed RPM package contents
 * pip install  --user --global-option=build_ext --global-option="-L/usr/lib64" package_to_install

== Atom syndication ==
 * https://tools.ietf.org/html/rfc4287
 * https://www.iana.org/assignments/xml-registry/schema/vcard-4.0.xsd 
 * https://www.iana.org/assignments/xml-registry/xml-registry.xhtml

== Identify current function ==
{{{#!highlight python
import inspect
print 'In %s'%( inspect.getframeinfo(inspect.currentframe()).function )
}}}

== Operative system folder path separator ==
{{{#!highlight python
import os
print( os.sep )
help(os)
dir(os)
}}}

== Install package for user with a more recent version ==
{{{#!highlight bash
pip freeze
pip install --user  numpy --upgrade
pip install --user  --upgrade numpy==1.15.1
pip freeze
}}}

== with statement ==
 * https://www.python.org/dev/peps/pep-0343/

{{{
with EXPR as VAR:
    BLOCK
which roughly translates into this:

VAR = EXPR
VAR.__enter__()
try:
    BLOCK
finally:
    VAR.__exit__()
}}}

The open() method returns a file object. The file object has the following methods that fit in the with statement:
 * __enter__(...)
 * __exit__(...)  Closes the file.

{{{#!highlight python
with open('filex') as fx:
    pass
}}}

== reST (ReStructuredText) docstring format ==
 * https://pythonhosted.org/an_example_pypi_project/sphinx.html#restructured-text-rest-resources
 * http://www.sphinx-doc.org/en/1.6/domains.html#the-python-domain
{{{
.. py:function:: send_message(sender, recipient, message_body, [priority=1])

   Send a message to a recipient

   :param str sender: The person sending the message
   :param str recipient: The recipient of the message
   :param str message_body: The body of the message
   :param priority: The priority of the message, can be a number 1-5
   :type priority: integer or None
   :return: the message id
   :rtype: int
   :raises ValueError: if the message_body exceeds 160 characters
   :raises TypeError: if the message_body is not a basestring
}}}

== Static method ==
Adapted from https://stackoverflow.com/questions/735975/static-methods-in-python

{{{#!highlight python
class ClassX(object):
    @staticmethod
    def static(x):
        print(x)

ClassX.static(2) # outputs 2
}}}

== Singleton ==
Adapted from https://www.tutorialspoint.com/python_design_patterns/python_design_patterns_singleton.htm
{{{#!highlight python
class Singleton:
   __instance = None

   @staticmethod 
   def getInstance():
      """ Static access method. """
      if Singleton.__instance == None:
         Singleton()
      return Singleton.__instance

   def __init__(self):
      """ Virtually private constructor. """
      if Singleton.__instance != None:
         raise Exception("This class is a singleton!")
      else:
         Singleton.__instance = self

s = Singleton()
}}}

== Iterate files from a root folder ==
{{{#!highlight python
#!/usr/bin/python

import os
for root, dirs, files in os.walk(".", topdown=False):
   for name in files:
      if name.endswith(".txt"):
          print(os.path.join(root, name))
}}}

== xml pretty print ==
{{{#!highlight python
import lxml
f = open('out.xml')
from lxml import etree
doc = etree.fromstring( f.read() )
out = etree.tostring(doc, pretty_print=True)
f.close()
f = open('out2.xml','wb')
f.write( out ) 
f.flush()
f.close()
quit()
}}}

== docstring sphynx reST ==
 * https://www.sphinx-doc.org/en/master/usage/restructuredtext/domains.html
 * https://www.sphinx-doc.org/en/master/usage/restructuredtext/domains.html?highlight=param#the-python-domain
 * https://www.sphinx-doc.org/en/master/usage/restructuredtext/domains.html?highlight=param#info-field-lists
{{{
Info field lists
New in version 0.4.
Inside Python object description directives, reST field lists with these fields are recognized and formatted nicely:
    param, parameter, arg, argument, key, keyword: Description of a parameter.
    type: Type of a parameter. Creates a link if possible.
    raises, raise, except, exception: That (and when) a specific exception is raised.
    var, ivar, cvar: Description of a variable.
    vartype: Type of a variable. Creates a link if possible.
    returns, return: Description of the return value.
    rtype: Return type. Creates a link if possible.
}}}

== __future__ ==
 * https://docs.python.org/2/library/__future__.html
{{{#!highlight python
from __future__ import absolute_import # 3.0
from __future__ import division # 3.0
from __future__ import generators #2.3
from __future__ import nested_scopes # 2.2
from __future__ import print_function # 3.0
from __future__ import unicode_literals # 3.0
from __future__ import with_statement # 2.6
}}}

== Command line argument parser ==
 * https://docs.python.org/2/library/argparse.html
Parser for command-line options, arguments and sub-commands

== Type checking ==
{{{#!highlight python
assert isinstance(obj,Class)
raise NotImplementedError
}}}

== Private and protected class members ==
{{{#!highlight python
_member # protected member
__member # private member, name mangling 
member # public member
}}}

== Nested class inside a function ==
{{{#!highlight python
def a():

    class X(object):
        CONST=1
        def __init__(self):
            self._c = X.CONST
            print(self._c)

    x=X()

if __name__=='__main__':
    a()
}}}

== List comprehension ==
{{{#!highlight python
(Pdb) [ val for val in range(1,10) if val % 2 == 0]
[2, 4, 6, 8]
}}}

== Change XML values with xpath ==
{{{#!highlight python
from lxml import etree, objectify

xml_data='<a><b><c x="as">def</c></b></a>'

doc = etree.fromstring(xml_data)
print "Original"
print etree.tostring(doc)

elem = doc.xpath('//c', namespaces=doc.nsmap)
elem[0].text = "hhhhh"

node_attr = doc.xpath('/a/b/c', namespaces=doc.nsmap)
node_attr[0].attrib['x']='other_xyz'

print etree.tostring(doc)
}}}

== *args and **kwargs ==
{{{#!highlight python
def x(*args,**kwargs):
  print type(args) # tuple
  print type(kwargs) # dict
  print args[0] # prints 1
  print args[1] # prints 2
  print kwargs['a'] # prints 1234
  print kwargs['b'] # prints 4567

x(1 ,2, a = 1234, b = 4567)
}}}


== json indentation, pretty print ==
{{{#!highlight python
import json

def json_to_string(obj):
    return json.dumps(obj,indent=4,sort_keys=True)

if __name__=='__main__':
    print json_to_string({'a':11,'b':'fffgg'})
}}}

== multiple inheritance - python 2 ==
{{{#!highlight python
#!/usr/local/bin/python2

class A(object):
    def init_A(self):
        print("Called init_A")
        self.a = "aaaa"

    def hello(self):
        return "hello"

    def get_c(self):
        return self.c

class C(object):
    def __init__(self):
        self.c = "cccc"
        print("Called init C")

    def world(self):
        return "world"

class B(C, A):
    """Multiple inheritance from C and A """
    def __init__(self):
        super(B,self).__init__() # calls first class from which is inherited
        super(B,self).init_A()
        print(dir(self))

    def hello(self):
        return super(B,self).hello() + " " + super(B,self).world() + " " + self.c + " " + self.a

if __name__=="__main__":
    b = B()
    print( b.hello() )
}}}

Output
{{{#!highlight sh
./inheritance.py
Called init C
Called init_A
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'c', 'get_c', 'hello', 'init_A', 'world']
hello world cccc aaaa
}}}


== globals ==
 * https://docs.python.org/3/library/functions.html#globals
Return a dictionary representing the current global symbol table. 

== Profiler - cProfile ==
 * profiler: identify files to review using a profiler
 * https://docs.python.org/2/library/profile.html ( cProfile, profile, hotshot)
 * python -m cProfile [-o output_file] [-s sort_order] myscript.py
 * python -m cProfile -o /tmp/profile.bin myscript.py

{{{#!highlight python
import pstats
import sys

filename=sys.argv[1]
p = pstats.Stats(filename)

collection = []

for stat in p.stats.values():
    try:
        mod=stat[4].keys()[0][0]
        item = stat[4].keys()[0][2]
        collection.append({"module":mod,"item":item})
    except:
        print str(stat)
		
for stat in p.stats.keys():
    try:
        mod=stat[0]
        item = stat[2]
        collection.append({"module":mod,"item":item})
    except:
        print str(stat)		
		
for element in collection:
    print "%s:%s"%(element['module'],element['item'])		

}}}

== Get current process PID ==
{{{#!highlight python
import os
print( os.getpid() )
}}}

== AES encryption example ==
 * https://pypi.org/project/pycrypto/
{{{#!highlight python
#crypto.py 
from Crypto.Cipher import AES
iv = '0123456789012345' # IV (init vector) length must be 16 
key = 'Key in the house' # AES key must be either 16, 24, or 32 bytes long
obj = AES.new(key, AES.MODE_CBC, iv)
message = 'If u can see1234' # multiple len of 16
ciphertext = obj.encrypt(message)
print(ciphertext)
obj2 = AES.new(key, AES.MODE_CBC, iv)
decoded= obj2.decrypt(ciphertext)
print(decoded)
assert message == decoded
}}}

== Map, filter, reduce ==
{{{#!highlight python3
# map_filter.py 
from functools import reduce

nrs = range(1,100+1)
even = list( filter( lambda item: item % 2 == 0, nrs ) )
print(even)

nrs10 = range(1,10+1)
total = reduce( (lambda a,b: a+b) , list(nrs10))
print(total)

multiplicationTable2 = list( map( lambda item: item*2 , nrs10 ) )
print(multiplicationTable2)
}}}


== Interface and Abstract classes ==
{{{#!highlight python
interface_test.py 
from abc import ABCMeta, abstractmethod
from  math import pi

class Shape(metaclass=ABCMeta):
    @abstractmethod
    def calculate_area(self):
        raise NotImplementedError

class Square(Shape):
    def __init__(self,side:float):
        self.side = side

    def calculate_area(self):
        return self.side*self.side

class Circle(Shape):
    def __init__(self,radius:float):
        self.radius = radius

    def calculate_area(self):
        return pi*self.radius*self.radius

class AbsX(metaclass=ABCMeta):
    @abstractmethod
    def helloinst(self):
        raise NotImplementedError

class X(AbsX):
    WORLD="world"

    def hello():
        return "hello " + X.WORLD

    @staticmethod
    def hellostatic():
        return "hello static " + X.WORLD

    def helloinst(self):
        return "Hello inst " + X.WORLD

if __name__=='__main__':
    print( X.hello() )
    print( X.hellostatic() )
    print( X().helloinst() )

    objs = []
    objs.append(Square(2))
    objs.append(Circle(3))

    for o in objs:
        #if isinstance(o,Shape):
        #    print(o.calculate_area())
        assert( isinstance(o,Shape) )
        print(o.calculate_area())
}}}