TYPES

str
unicode
list
tuple
buffer
xrange

PRIORITY ORDER

x in s # True if an item of s is equal to x, else False
x not in s # False if an item of s is equal to x, else True
s + t # the concatenation of s and t
s * n , n * s # n shallow copies of s concatenated
s[i] # i'th item of s, origin 0
s[i:j] # slice of s from i to j
s[i:j:k] # slice of s from i to j with step k
len(s) # length of s  
min(s) # smallest item of s 
max(s) # largest item of s  

METHOD

s.index(str) # return first position of str in s
s.count() # return then number of elements

SLICE

first included, second excluded (even with negative step)

s[start:end:step]

syntax

s[start:]
s[:end]

s[:] # duplicates element
s[start:-end] # from index1 to (index2 from last)
s[-start:-end] # from (index1 from last) to (index2 from last)
s[-start:end] # from (index1 from last) to index2 -> empty
s[-start:end:-step] # from (index1 from last) to (index2 from last)
s[::-1] # reverse
s[start:end:-2] # with start > end else return None # reverse a part with step
s[start;start] = [n] # insert element n in s at position start
s[start:end] = [] # unset elements between start and end (start included & end excluded)

examples

l = [0, 2, 4, 8, 16, 32, 64, 128]
l
l[-1:1:-2]
l[2:4] = [100, 200, 300, 400, 500]
l

https://docs.python.org/3/reference/datamodel.html#specialnames
https://docs.python.org/3/reference/datamodel.html#object.__new__
https://docs.python.org/3/reference/datamodel.html#object.__repr__

__init__ # called after the constructor and implement instance of class
__repr__ # called when the object calls without printing. if missing, use __str__ instead
__str__ # print when print method is called on object 
__bool__ # used for test on object
__len__ # called in place of __bool__ if missing
__add__, __mul__, __sub__, __div__, __and__, ... called by sum, +, *, ... methods
__contains__ # called by 'in' method
__len__ # called by 'len' method
__getitem__ # used by slice, calling element[], make element an iterable
__eq__ # called to compare object '==', 'is'. depends of hash, if __eq__ are implemented __hash__ have to be it also
__hash__ # https://docs.python.org/3/reference/datamodel.html?highlight=__hash__#object.__hash__
__call__ # use instance (object) of class like a function

EXAMPLES

__call__

class PlusClosure:
    def __init__(self, initial):
        self.initial = initial
    def __call__(self, *args):
        return self.initial + sum(args)

plus2 = PlusClosure(2)
plus2(5)

__getattr__

class RPCProxy:

    def __init__(self, url, login, password):
        self.url = url
        self.login = login
        self.password = password

    def __getattr__(self, function):
        """
        Crée à la volée une méthode sur RPCProxy qui correspond
        à la fonction distante 'function'
        """
        def forwarder(*args):
            print(f"Envoi à {self.url}...")
            print(f"de la fonction {function} -- args= {args}")
            return "retour de la fonction " + function
        return forwarder

rpc_proxy = RPCProxy (url='http://cloud.provider.com/JSONAPI',
                      login='dupont',
                      password='***')

# cette partie du code, en tant qu'utilisateur de l'API, est supposée connaître les détails des arguments à passer et de comment utiliser les valeurs de retour
nodes_list = rpc_proxy.GetNodes (
    [ ('phy_mem', '>=', '32G') ] )

# réserver un noeud
node_lease = rpc_proxy.BookNode (
    { 'id' : 1002, 'phy_mem' : '32G' } )

Point

class Point:
    a = 0
    b = 0
    d = [a, b]
    def __init__(self, x=0, y=0, len=0):
        self.x = x
        self.y = y
        self.p = [x, y]
    def __repr__(self):
        return f"Pt[{self.x}, {self.y}]"

class Point_eh(Point):
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __hash__(self):
        return (11 * self.x + self.y)

p1 = Point(0,1)
p2 = Point(0,1)
p3 = Point(0,1)
s = {p1, p2}
p1
s

# __eq__
p1 == p2
peh1 = Point_eh(0,1)
peh2 = Point_eh(0,1)
s = {peh1, peh2}

Matrix

class Matrix:

    def __init__(self, *args):
        """
        le constructeur accepte
        (*) soit les 4 coefficients individuellement
        (*) soit une liste - ou + généralement une séquence - des mêmes
        """
        # on veut pouvoir créer l'objet à partir des 4 coefficients
        # souvenez-vous qu'avec la forme *args, args est toujours un tuple
        if len(args) == 4:
            self.coefs = args
        # ou bien d'une séquence de 4 coefficients
        elif len(args) == 1:
            self.coefs = tuple(*args)

    def __repr__(self):
        "l'affichage"
        return "[" + ", ".join([str(c) for c in self.coefs]) + "]"

    def __add__(self, other):
        """
        l'addition de deux matrices retourne un nouvel objet
        la possibilité de créer une matrice à partir
        d'une liste rend ce code beaucoup plus facile à écrire
        """
        return Matrix([a + b for a, b in zip(self.coefs, other.coefs)])

    def __bool__(self):
        """
        on considère que la matrice est non nulle
        si un au moins de ses coefficients est non nul
        """
        # ATTENTION le retour doit être un booléen
        # ou à la rigueur 0 ou 1
        for c in self.coefs:
            if c:
                return True
        return False

Remarquez que les opérandes sont apparemment inversés dans le sens où pour evaluer 'reel * matrice'

On écrit une méthode qui prend en argument la matrice, puis le réel mais n'oubliez pas qu'on est en fait en train d'écrire une méthode sur la classe Matrix2

def multiplication_scalaire(self, alpha):
    return Matrix2([alpha * coef for coef in self.coefs])

on ajoute la méthode spéciale rmul

Matrix2.__rmul__ = multiplication_scalaire

GLOBAL

https://docs.python.org/3/reference/lexical_analysis.html#reserved-classes-of-identifiers
https://docs.python.org/3/tutorial/classes.html#tut-private

• A Class & class instance is mutable
• Inheritance tree: instance -> class -> parent class....
• Attributes are calculate dynamicaly in time
• Instance & class are shared same attributes
• Self for instance is just a convention

class Test:
    att = 0
t = Test
s = "Here is !"
class Myclass:
    def initia(self, s):
    self.word = s
p = Myclass()

p.initia(s)

Myclass.initia(p,s)

VARS

vars(Myclass) <=> Myclass.__dict__ # return space name 

DYNAMIC OVERLOAD

class Test:
     att = 0

def addatt(self, val):
    self.att = self.att + val

Test.addatt = addatt

PROPERTY

https://docs.python.org/3.6/library/functions.html#property

To use an encapsulation with attributes, use property to define the setters or getters, the calling attributes launch automatically the setters or getters

ATTRIBUTES CLASS VS INSTANCE

• Class attribute defined in class are shared with all instances
• Attributes reference are shared & changed according to whether it is mutable or not

class Point:
    a = 0
    b = 0
    d = [a, b]
    def __init__(self, x=0, y=0, len=0):
        self.x = x
        self.y = y
        self.p = [x, y]
    def __repr__(self):
        return f"Pt[{self.x}, {self.y}]"

# class attribute
t = Point()
print(f"t.d {t.d}", f"t.p {t.p}", f"Point.d {Point.d}", sep="\n")
print(f"Point.p {Point.p}")

# class -> instance
Point.a = 1
t2 = Point()
print(f"Point.a {Point.a}", f"t.a {t.a}", f"t2.a {t2.a}", sep="\n")

# attribute not mutable: instance !-> class
# loose reference
t2.a = 2
print(f"Point.a {Point.a}", f"t.a {t.a}", f"t2.a {t2.a}", sep="\n")
Point.a = 3
print(f"Point.a {Point.a}", f"t.a {t.a}", f"t2.a {t2.a}", sep="\n")

# attribute mutable: instance -> class
t2.d.append(3)
print(f"Point.d {Point.d}", f"t.d {t.d}", f"t2.d {t2.d}", sep="\n")
Point.d.append(4)
print(f"Point.d {Point.d}", f"t.d {t.d}", f"t2.d {t2.d}", sep="\n")

## instance attribute
t = Point()
print(f"t.p {t.p}", f"t2.p {t2.p}", sep="\n")
t.p.append(1)
print(f"t.p {t.p}", f"t2.p {t2.p}", sep="\n")

INSTANCE: ID, NOT VALUES

2 instances are compared by the id not values

p1 = Point1(2, 3)
p2 = Point1(2, 3)
p3 = Point1(2, 3)

Equality test instance id, not class values

p1 == p2

In test instance id, not class values

s = {p1, p2}
p1 in s
p3 in s

See examples in class-special-methods for hash eq__

GETATTR, SETATTR & HASATTR

import math
math.pi
hasattr(math, 'pi')
getattr(math, 'pi')
getattr(math, 'pi2', 'not found')
setattr(math, 'pi', math.pi*2)
math.pi

ENUM

https://docs.python.org/3/library/enum.html

enumeration

from enum import Enum
class Flavour(Enum):
    CHOCOLATE = 1
    VANILLA = 2
    PEAR = 3

chocolate = Flavour['CHOCOLATE']
chocolate
chocolate.name

INTENUM

https://docs.python.org/3/library/enum.html

IntEnum is Enum with comparison

from enum import IntEnum
class HttpError(IntEnum):
    OK = 200
    REDIRECT = 301
    REDIRECT_TMP = 302
    NOT_FOUND = 404
    INTERNAL_ERROR = 500

    def is_redirect(self):
        return 300 

example

class Temperature:
    K = 273.16
    RF = 5 / 9
    KF = (K / RF) - 32

    def __init__(self, kelvin=None, celsius=None, fahrenheit=None):
        if kelvin is not None:
            self.kelvin = kelvin
        elif celsius is not None:
            self.celsius = celsius
        elif fahrenheit is not None:
            self.fahrenheit = fahrenheit
        else:
            self.kelvin = 0
            raise ValueError("need to specify at least one unit")

    def __repr__(self):
        return f""

    def __str__(self):
        return f"{self.kelvin:g}K"

    def _get_kelvin(self):
        return self._kelvin

    def _set_kelvin(self, kelvin):
        if kelvin < 0:
            raise ValueError(f"Kelvin {kelvin} must be positive")
        self._kelvin = kelvin

    kelvin = property(_get_kelvin, _set_kelvin)

    # les deux autres properties font la conversion, puis
    # sous-traitent à la property kelvin pour le contrôle de borne
    def _set_celsius(self, celsius):
        # using .kelvin instead of ._kelvin to enforce
        self.kelvin = celsius + self.K

    def _get_celsius(self):
        return self._kelvin - self.K

    celsius = property(_get_celsius, _set_celsius)

    def _set_fahrenheit(self, fahrenheit):
        # using .kelvin instead of ._kelvin to enforce
        self.kelvin = (fahrenheit + self.KF) * self.RF

    def _get_fahrenheit(self):
        return self._kelvin / self.RF - self.KF

    fahrenheit = property(_get_fahrenheit, _set_fahrenheit)
t = Temperature(200)
t
t.kelvin
t.kelvin = -30
t

complete example

class Temperature:

    ## les constantes de conversion
    # kelvin / celsius
    K = 273.16
    # fahrenheit / celsius
    RF = 5 / 9
    KF = (K / RF) - 32

    def __init__(self, kelvin=None, celsius=None, fahrenheit=None):
        """
        Création à partir de n'importe quelle unité
        Il faut préciser exactement une des trois unités
        """
        # on passe par les properties pour initialiser
        if kelvin is not None:
            self.kelvin = kelvin
        elif celsius is not None:
            self.celsius = celsius
        elif fahrenheit is not None:
            self.fahrenheit = fahrenheit
        else:
            self.kelvin = 0
            raise ValueError("need to specify at least one unit")

    # pour le confort
    def __repr__(self):
        return f""

    def __str__(self):
        return f"{self.kelvin:g}K"

    # l'attribut 'kelvin' n'a pas de conversion à faire,
    # mais il vérifie que la valeur est positive
    def _get_kelvin(self):
        return self._kelvin

    def _set_kelvin(self, kelvin):
        if kelvin 

https://docs.python.org/3/reference/simple_stmts.html#the-import-statement

module are:

• are mutable !!
• define a namespace
• is a .py file
• the file are searched first in sys.path (after in local path)
  import are only made on time during a program

IMPORT

import <module>

• import as
• absolute import
• the file are searched first in sys.path (after in local path)

# module_name is a string, it can be a variable
from importlib import module_name
module_othername = module_name('ma'+'th')

# alias
import module_name as module_othername

RELATIVE IMPORT

• local path first (before look in sys.path)
• import global module with namespace reference
• abstract the calling !!

import a module

from . import module_name as module_othername

import just an object from module

# import selected object in module without entire module
from .module_name import object_name as object_othername

• local parent path first
• import global module with namespace reference

import a module

from .. import module_name as module_othername

import just an object from module

# import selected object in module without entire module
from ..module_name import object_name as object_othername

ENTRY POINT

for the entry point of program, _name__ return main and not the filename !
So you can find in the main file

if __name__ == "__main__":
....

Let program make specific codes when apply file is calling directly from interpreter & not from an import when calling a file directly from the interpreter, the entry point sets name to 'main', so it s almost impossible to use relative imports in this situation

To use test envirronement:

python3 -m unittest package_name.module_name

http://sametmax.com/un-gros-guide-bien-gras-sur-les-tests-unitaires-en-python-partie-1/

IMPORTLIB

Use a variable for module name

from importlib import import_module
modulename = "ma" + "th"
loaded = import_module(modulename)
math is loaded

Import math <=> math = import_module('math')

from pathlib import Path
<=>
tmp = import_module('pathlib')
Path = tmp.Path
del tmp

IMPORT / FROM ... IMPORT

import

• import all objects from module
• complete isolation
• access to all objects in module with notation MODULE.OBJECT

From ... import

• import only selected object
• no isolation & iomportation of object in current namespace
• no access to other object in module

RELOAD

Force to reload manualy a module

from importlib import reload
reload(MODULE)

AUTORELOAD

Load magic 'autoreload'

%load_ext autoreload

Enable autoreload

%autoreload 2

ATTRIBUTES

https://docs.python.org/3/tutorial/modules.html#importing-from-a-package

__name__

Module name

__file__

The complete path of package definition file: init.py

__all__

redefine the behavior of import *

PATH

https://docs.python.org/3/tutorial/modules.html#the-module-search-path

Environnement variable

    import os
    os.getcwd() # return current working directory
    os.listdir(path) # return the list of path & files in path (if empty return current path)
    os.environ # dict of full os informations
    os.environ['PATH'] os.environ['PYTHONPATH']
    sorted([i for i in os.environ])

Include paths

import sys
sys.path

Add path when launch python script

PYTHONPATH=/path python script.py

SYS.MODULES

https://docs.python.org/3/library/sys.html#sys.modules

example

import sys

# test on loaded modules
'csv' in sys.modules
import csv
'csv' in sys.modules
csv is sys.modules['csv']

# unload module
del sys.modules['multiple_import']

# A tuple of strings giving the names of all modules that are compiled into this Python interpreter
sys.builtin_module_names

# modules.keys() only lists the imported modules
sys.modules.keys()
'csv' in sys.modules.keys()

CWD

from pathlib import Path
Path.cwd()

IMPORT FILE FROM ANYWHERE

from pathlib import Path
directory_installation = Path(__file__).parent
import sys
sys.path.append(directory_installation)

MODTOOLS

Show_module

from modtools import show_module
import math
show_module(math)

SETUPTOOLS / PYPI

https://pypi.org/project/setuptools/
https://pypi.org/

Deploy setuptools

pip3 install setuptools

PACKAGE

https://docs.python.org/3/tutorial/modules.html#packages

A package are:

• a folder with the same name
• a namespace
• this folder have to contains a mandatory file init.py

import package

import package_name
import package_name as package_othername

Use namespace

package_name.object

not recommended

package_name.module_name.object

Subpackage
Package physically inside another

import package_name.subpackage_name
import package_name.subpackage_name.module_name.element_name

EXCERCISE

import this
def decode_zen(this):
    return ''.join(this.d[i] if i in this.d else i for i in this.s)

# better
def decode_zen(this):
    return ''.join(this.d.get(i) for i in this.s)

https://docs.python.org/fr/3.7/howto/functional.html
https://docs.python.org/3/library/itertools.html

ITERATOR

• iterator allow to calculate data of function only on read it
• builtin function all methods on object

s = {0, 1, 'string1', 3, 'string2',5 , 6}
[x for x in s if type(x) is int]
i = iter(s)
type(i)
dir(i)
next(i)
i.__next__()

ITERABLE

• Object contains a method 'iter', which gives iterator methods
• An object wich on you can use iterator methods

ITERTOOLS

https://docs.python.org/3/library/itertools.html

This module implements a number of iterator building blocks

import itertools

Infinite iterators

count(start, [step])

start, start+step, start+2*step, …
count(10) --> 10 11 12 13 14 ...

cycle(p)

p0, p1, … plast, p0, p1, …
cycle('ABCD') --> A B C D A B C D ...

repeat(elem [,n])

elem, … endlessly or up to n times
repeat(10, 3) --> 10 10 10

Iterators terminating on the shortest input sequence

accumulate(p[,func])

p0, p0+p1, p0+p1+p2, …
accumulate([1,2,3,4,5]) --> 1 3 6 10 15

chain(p, q, …)

p0, p1, … plast, q0, q1, …
chain('ABC', 'DEF') --> A B C D E F

chain.from_iterable(iterable)

p0, p1, … plast, q0, q1, …
chain.from_iterable(['ABC', 'DEF']) --> A B C D E F

compress(data, selectors)

(d[0] if s[0]), (d[1] if s[1]), …
compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F

dropwhile(pred, seq)

seq[n], seq[n+1], starting when pred fails
dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1

filterfalse(pred, seq)

elements of seq where pred(elem) is false
filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8

groupby(iterable[, keyfunc])

sub-iterators grouped by value of keyfunc(v)

islice(seq, [start,] stop [, step])

elements from seq[start:stop:step]
islice('ABCDEFG', 2, None) --> C D E F G

starmap(func, seq)

func(seq[0]), func(seq[1]), …
starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000

takewhile(pred, seq)

seq[0], seq[1], until pred fails
takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4

tee(it, n)

it1, it2, … itn splits one iterator into n

zip_longest(p, q, …)

(p[0], q[0]), (p[1], q[1]), …
zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

Combinatoric iterators

product(p, q, … [repeat=1])

cartesian product, equivalent to a nested for-loop
product('ABCD', repeat=2) -> AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD

permutations(p[, r])

r-length tuples, all possible orderings, no repeated elements
permutations('ABCD', 2) -> AB AC AD BA BC BD CA CB CD DA DB DC

combinations(p, r)

r-length tuples, in sorted order, no repeated elements
combinations('ABCD', 2) -> AB AC AD BC BD CD

combinations_with_replacement(p, r)

r-length tuples, in sorted order, with repeated elements
combinations_with_replacement('ABCD', 2) -> AA AB AC AD BB BC BD CC CD DD

https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions

ages = [10, 120, 110, 25, 30, 40, 50]
l1 = [a+1 if a < 100 else a for a in ages]
l2 = [a+1 for a in ages if a < 100]

ages = {'ana':20, 'EVE':30, 'bob':40}
prenoms = [p.lower() for p, a in ages.items()]

SET

prenoms = ['ana', 'eve', 'ALICE', 'Anne', 'bob']
s = {p.lower() for p in prenoms if p.lower().startswith('a')}

DICT

ages = {'ana':20, 'EVE':30, 'bob':40}
d = {p.lower():a + 1 for p, a in ages.items()}

prenoms = ['ana', 'eve', 'ALICE', 'Anne', 'bob']
ages = [10, 20, 30, 40, 50]
d = {p.lower():a + 1 for p, a in zip(prenoms, ages)}

# Some troubles with mixed list & set
prenoms = ['ana', 'eve', 'ALICE', 'Anne', 'bob']
ages = [10, 20, 30, 40, 50]
list(zip(prenoms, ages))

NESTING

flat nesting : 1 level => [n(p(..., ...) ,...)]

[... for ... for ...]
[... >   ... >  ...]
for n ...
  for p ...
    ...
[str(n) + str(p) for n in [2, 4] for p in [10, 20, 30]]

classic "sub"

[... for n in [... p ...] if ...]
for p ...
for n ...

embedded "sub" nesting 2 levels => [p[n... ], ...]

[[... for ...] for ...]
[[... <   ...] <   ...]
for p ...
  for n ...
[[str(n) + str(p) for n in [2, 4]] for p in [10, 20, 30]]

FLAT

[item for sublist in list for item in sublist]
for sublist in list
  for item in sublist
    item 

REPEAT

# compare:
[x + y for x in (1,2,3) for y in (10,20) for z in (0,2)]
[x + y for x in (1,2,3) for z in (0,2) for y in (10,20)]
[x + y for x in (1,2,3) for z in (0,2) for y in (10,20)]

t = (y for y in (x**2 for x in range(1000)) if str(y) == str(y)[::-1])

with restriction

[str(n) + str(p) for n in [2, 4] for p in [10, 20, 30] if n*p >= 40]

BREAK

def end_of_loop():
    raise StopIteration
even = list(end_of_loop() if n == 412 else n for n in numbers if 0 == n % 2)

even = list(next(iter(())) if n == 412 else n for n in numbers if 0 == n % 2)

EXERCISE

1

# flat vs nested
[[str(n) + str(p) for n in (2, 4)] for p in (10, 30, 50)]
[str(n) + str(p) for p in (10, 30, 50) for n in (2, 4)]

# flat vs nested
[[str(n) + str(p) for n in (2, 4)] for p in (10, 30, 50)]
[str(n) + str(p) for p in (10, 30, 50) for n in (2, 4)]

def aplatir(conteneurs):
    return [c2 for c1 in conteneurs for c2 in c1]
def aplatir(conteneurs):
    r=[]
    for c1 in conteneurs:
        for c2 in c1:
             r.append(c2)
    return r
aplatir(((1, [2, 3]), [], 'a', ['b', 'c']))

2

def alternat(c1, c2):
    return [c_2 for c_1 in zip(c1, c2) for c_2 in c_1]
alternat( (1, 2, 3), ('a', 'b', 'c'))

3

def intersect(A, B):
    return {c2 for c1 in ((v1, v2) for i1, v1 in A for i2, v2 in B if i1 == i2) for c2 in c1}
intersect({ (1, 'unA'), (2, 'deux'), (3, 'troisA')}, { (1, 'unB'), (2, 'deux'), (4, 'quatreB')})
# more elegante
def intersect(A, B):
    return {v for dictionnaire in [dict(A),dict(B)] for k,v in dictionnaire.items() if k in dict(A) and k in dict(B)}
def intersect(A, B):
    return { i for item in (dict(A).keys() & dict(B).keys()) for i in (dict(A)[item], dict(B)[item]) }

SCOPE

https://www.programiz.com/python-programming/namespace

Order to interprate variables is LEGB

• Local
• Enclosing
• Global
• Builtin

locals()

return a list of actual local scope variables

globals()

return a list of actual global scope variables

Global scope & function error !!

Because var is referenced like global by "print(var)" & use like local with "var = 'local'"
Solution: remove "print(var)" or remove "var = 'local'" or put it after "var = 'local'"

var = 'global'
def f():
    print(var)
    var = 'local'
f()
print(var)

GLOBAL

to use global variable locally

var = 'global'
def f():
    global var
    var = 'local'
    print(var)
f()
print(var)

NONLOCAL

• To use upper local scope variable locally
• The upper scope local variable is the closest one
• A nonlocal variable have to be a binding variable in upper local scope (in function definition, not in the global scope) else an exception are called

a = 'a global'
def f():
    a = 'a f'
    def g():
        nonlocal a
        a = 'a g'
        print(a)
    g()
    print(a)
f()
print(a)

BUILTINS

import builtins
modules with all builtin functions

dir(builtins)
dir(builtins.str)

To ensure to call a really builtin function
import builtins

with builtins.open(...) as f:

GLOBAL VARIABLES

vars()
globals()

To access object to other namespace

print(dir(spam))
print(dir(spam.__builtins__))

WHILE

Execute the loop while condition is true and execute else:

while condition:
    ...
else:
    ...

continue

Step in a loop to the next loop

break

Break the loop definitively

while true

while true, continual loop with a break to exit

while true:
    ...
    break

example

while liste:
element = liste.pop()
print(element)

FOR

for item in element
    ...
else
    ...

EXCERCISE

1

def pgcd(a, b):
    if a == 0:
        return(b)
    elif b == 0:
        return(a)
    while True:
        if b > a:
            b = b % a
            if b == 0:
                return(a)
        else:
            a = a % b
            if a == 0:
                return(b)

2

def taxes(income):
    taxe = 0
    if income > 150_000:
        taxe += (income - 150_000) * (45/100)
        income = 150_000
    if income > 45_000:
        taxe += (income - 45_000) * (40/100)
        income = 45_000
    if income > 11_500:
        taxe += (income - 11_500) * (20/100)
        income = 11_500
    return (int(taxe))

2 bis

def taxes(income):
    taxe = 0
    limit_rates = (
        (150_000, 45),
        (45_000, 40),
        (11_500, 20)
    )
    for limit, rate in limit_rates:
        if income > limit:
            taxe += (income - limit) * (rate/100)
            income = limit
    return (int(taxe))

GENERAL

Order of parameters

ordered
named
*tuple
**dict

ORDERED

Ordered (mandatory) arguments have to be in first in list of arguments

def f(arg1, arg2, ...):
    ...

default/optionnal parameters

Default parameters have to be placed in last in list of parameters

def f(arg1, arg2, arg3=opt, arg4=opt, ...):
    ...

NAMED

You can give parameters to the function with naming

def f(arg1, arg2, arg3):
    ...
f(arg2=data, arg3=data, arg1=data)

TUPLE

def f(*t):
    ...
def f(arg1, arg2, *t):
    print(f"arg1: {arg1}\narg2: {arg2}\nothers: {t}")

f('nom', 'prenom', list(range(5)), 'et moi', ['etc'])

With optionnal parameters

def f(nom, prenom='henriette', *d):
    print(f"nom: {nom}\nprenom: {prenom}\nd: {d}")

f('louis', 'mom', 20, 'pierre', ['tyt'])

DICTIONNARY

def f(**d):
    print(f"d: {d}")

f(tata='mom', tonton='pierre', maman='tyt')

With optionnal parameters

def f(nom, prenom='henriette', **d):
    print(10*"=" + f"\nnom: {nom}\nprenom: {prenom}\nd: {d}")

f('louis', 'prenom', tata='mom', tonton='pierre', maman='tyt')
f('louis', tata='mom', tonton='pierre', maman='tyt')

UNPACKING

Used to send arguments to a function from a list / tuple / set
With a good lenght of arguments !!

def f(a, b):
    print(10*"-" + f"\na: {a}\nb: {b}")

l = [10, 'toto']
f(*l)
l = (10, 'toto')
f(*l)
l = set([10, 'toto']);
f(*l)

DICTIONNARY SENDING

Use a dictionnary to send arguments to function
Keys names of dictionnary have to be match with arguments names

def f(a, b):
    print(10*"-" + f"\na: {a}\nb: {b}")
{'a': 10, 'b': 'toto'}
f(**d)

Use for print (& wrapping)

pp = {'sep':'-', 'end':' >EOL'}
print(10, 20, **pp)

TRAP

named argument & tuple argument

https://docs.python.org/3/reference/expressions.html#calls

def foo(a, b, c, d):
    print(a, b, c, d)

#good
    foo(1, c=3, *(2,), **{'d':4})

# wrong
foo (1, b=3, *(2,), **{'d':4})

don t use mutable object in default argument

https://docs.python.org/3/faq/programming.html#why-are-default-values-shared-between-objects

import random
def ajouter_un_aleatoire(resultats=[]):
    resultats.append(random.randint(0, 10))
    return resultats
ajouter_un_aleatoire()
ajouter_un_aleatoire()

EXCERCISE

1

def distance(*arg):
    from math import sqrt
    result = sqrt(sum([i**2 for i in arg]))
    return result if result != 0 else 0

2

def numbers(*args):
    return (sum(args), min(args, default=0), max(args, default=0))

https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset

• Usefull to stock only uniq elements
• Set is mutable but element in set ar to be immutable => unable to create a set of set
• Like distionnary, set are not ordered

INIT

s = set()
s = {key1, key2, ...}
s = set([key1, key2, ...])

METHODS

(key) in s

Return true in key is in s

len(s)

Print length of s

s.clear()

Clear elements of s

s.add()

Add a key in set

s.update(s2)

Merge a set into a set

s.discard(key)

Remove elements, no error if not found

s.remove(key)

Remove elements, launch exception if not found

try:
    s.remove(key)
except KeyError as e:
    print("text", e)

s.pop()

Remove last or indexed element but there is no order in a set !

s = [1, 2, 3, 4, 5]

while s:
    s = s.pop()
    print("set", s)
print("set is now empty", s)

OPERATIONS

union

s1 | s2
Return the union of sets

intersection

s1 & s2
Return intersection of sets

difference

s2 - s3
Return difference of two sets

symmetrical difference

s1 ^ s2
AΔB=(A−B)∪(B−A)=(A∪B)-(A∩B)

equality

s1 == s2

inclusion

s1 <= s2
s1 < s2

Disjoint sets

s.isdisjoint(s2)

FROZENSET

Immutable set to serve to key of dictionnary or element of set

init

fs = frozenset()
fs = frozenset([key1, key2, ...])

Available methods

copy()
isdisjoint()
symmetric_difference()
difference()
issubset()
union()
intersection()
issuperset()

EXCERCISE

1

def read_set(filename):
    s=set()
    with open(filename, "r", encoding='utf-8') as f:
        for line in f:
            #print(line)
            s.update({line.strip()})
    return(s)

2

def search_in_set(filename_reference, filename):
    s = set()
    l = []
    with open(filename_reference, "r", encoding='utf-8') as f_ref:
        for line in f_ref:
            s.update({line.strip()})
    with open(filename, "r", encoding='utf-8') as f_test:
        for line in f_test:
            line = line.strip()
            l.append((line, line in s))
    return(l)

3

def diff(extended, abbreviated):
    # get ships
    ships_ext = set([i[0] for i in extended])
    ships_abb = set([i[0] for i in abbreviated])
    ships_name = {i[0]: i[4] for i in extended}
    # get sets
    id_ext_abb = ships_ext - ships_abb
    id_abb_ext = ships_abb - ships_ext
    id_abb_and_ext = ships_ext & ships_abb
    # get ships name
    name_ext_abb = [ships_name[i] for i in list(id_ext_abb)]
    name_abb_and_ext = [ships_name[i] for i in list(id_abb_and_ext)]
    # return
    return((set(name_ext_abb), set(name_abb_and_ext), set(id_abb_ext)))

PATHLIB

https://docs.python.org/3/library/pathlib.html

exists()

test if file exists

from pathlib import Path
filename = '/tmp/test'
path = Path(filename)
path.exists()
with open(filename, 'w', encoding='utf-8') as f:
    f.write('0123456789\n')
path.exists()

stat()

return statistiques about file

path.stat()
st_mode
st_ino
st_dev
st_nlink
st_uid
st_gid
st_size
st_atime
st_mtime
st_ctime

path.stat().st_size

from datetime import datetime
datetime.fromtimestamp(path.stat().st_mtime)
f"{mtime_datetime:%H:%M}"

unlink()

delete file

try:
    path.unlink()
except FileNotFoundError:
    print("no need to remove")

path = Path('/tmp')
for json in dirpath.glob("*.json"):
    print(json)

CLASS

path = Path('/tmp')
type(path)

from pathlib import PosixPath
issubclass(PosixPath, Path)

isinstance(path, Path)

FILE FORMAT

https://docs.python.org/3/library/fileformats.html

json

https://docs.python.org/3/library/json.html

limitations

Tuple, qui se fait encoder comme une liste / complex, set et frozenset, que l'on ne peut pas encoder du tout (sans étendre la bibliothèque)

pickle

https://docs.python.org/3/library/pickle.html

csv

https://docs.python.org/3/library/csv.html

SYS

import sys
autre_stdout = open('ma_sortie.txt', 'w', encoding='utf-8')
tmp = sys.stdout
print('sur le terminal')

sys.stdout = autre_stdout
print('dans le fichier')

sys.stdout = tmp
autre_stdout.close()

print('de nouveau sur le terminal')

with open("ma_sortie.txt", encoding='utf-8') as check:
    print(check.read())

OS

Old fashion

os.path.join()

ajoute '/' ou '' entre deux morceaux de chemin, selon l'OS

os.path.basename()

trouve le nom de fichier dans un chemin

os.path.dirname()

trouve le nom du directory dans un chemin

os.path.abspath()

calcule un chemin absolu, c'est-à-dire à partir de la racine du filesystem

os.path.exists()

pour savoir si un chemin existe ou pas (fichier ou répertoire)

os.path.isfile .isdir()

Pour savoir si un chemin est un fichier (et un répertoire)

os.path.getsize()

pour obtenir la taille du fichier

os.path.getatime()

et aussi getmtime et getctime pour obtenir les dates de création/modification d'un fichier

os.chdir()

change current directory

os.remove()

(ancien nom os.unlink), qui permet de supprimer un fichier

os.rmdir()

pour supprimer un répertoire (mais qui doit être vide)

os.removedirs()

pour supprimer tout un répertoire avec son contenu, récursivement si nécessaire

os.rename()

pour # renommer un fichier

glob.glob()

comme dans par exemple glob.glob("*.txt")

TRY

https://docs.python.org/3/tutorial/errors.html#handling-exceptions

SYNTAX

try:
    ....
except ...Error as e:
    ...
except ...Error2 as e:
    ...
else
    ...
finally

except:

Catch all errors

except Error_name:

Catch only Error_name

except (Error_name1,Error_name2):

Catch only Error_names

except Error_name, value:

Catch only Error_name with only value Value

else

Execute instruction if except don't catch error

finally

Execute always instruction at the end even after a return

def return_with_finally(number):
try:
    return 1/number
except ZeroDivisionError as e:
    print(f"OOPS, {type(e)}, {e}")
    return("zero-divide")
finally:
    print("on passe ici même si on a vu un return")

RAISE

http://www.python.50webs.com/CHAP_8/chap_8.html

raise Error_name

Launch an exception

raise Error_name, value

Launch an exception with specific value

Exceptions under Class & Class instance
raise can take 5 forms:

• raise
• raise String
• raise String, value
• raise Class, instance

for class or parent class

• raise instance.class, instance
• raise instance

L'utilité est que, lorsque l'on gère une grande quantité d'exceptions, il n'est pas nécessaire de mettre de nom après "except", car le nom de l'exception levée sera traité dans la classe. De plus il est possible de rajouter des sous-classes afin de compléter un domaine d'exception et ceci sans toucher au code existant dans la classe parente.

ASSERT

• Les assertions peuvent être enlevées du byte code si l'option -O est appelée lors de la compilation
• Les assertions sont principalement utilisées pendant le développement
• Il est impératif d'éviter les effets de bord dans les assertions car,
  lors de leurs suppressions, l'effet est aussi enlevé

assert TEST

Assert launch always a AssertionError exception

assert TEST, VALUES

Equal to:

if __debug__ :
    if not <test> :
        raise AssertionError, <values>

https://pypi.org/
https://pypi.org/project/autopep8/

INDENTATION

• prefere space than tabulation
• use 4 spaces by indentation
• use : after commands if else elif def

x = y + z

def foo(x, y):
def foo(
    x,
    y
):

foo(x, y, z)
foo(
    x,
    y
)

x=[
    : 0,
    : 1,
]

pass

Do nothing but in a accepted syntax, void foo

def foo():
    pass

while condition:
    pass

if condition:
    pass
else:
    foo()

COMMENTS

# single line

""" single line """

"""
multiple
lines
"""

VARIABLES

authorized characters for name
a-z A-Z 0-9 _

authorized characters for the beginning of name
a-z A-Z

And as assert break class continue def del elif else except false finally for from global if import in is lambda none nonlocal not or pass raise return true try while with yield

STRING

s[start:end:step]

manipulate string by indexes, first included, second excluded (even with negative step)

s[start:] # from index to end
s[:end] # fro mstart to index
s[:] # duplicates element
s[start:-end] # from start to (end from last)
s[-start:-end] # from (start from last) to (end from last)
s[-start:end] # from (start from last) to end -> empty
s[-start:end:-step] # from (start from last) to (end from start) by rollback
s[::-1] # reverse

s[start;start] = [n] # insert element n in s at position start
s[start:end] = [] # unset elements between start and end (start included & end excluded)

LIST

Manipulate list with slice

l = [0, 2, 4, 8, 16, 32, 64, 128]
l
l[-1:1:-2]
l[2:4] = [100, 200, 300, 400, 500]
l

NUMPY

import numpy as np

un_cinq = np.array([1, 2, 3, 4, 5])
un_cinq

array = 10 * un_cinq[:, np.newaxis] + un_cinq
array

centre = array[1:4, 1:4]
centre

coins = array[::4, ::4]
coins

tete_en_bas = array[::-1,:]
tete_en_bas

https://docs.python.org/3/tutorial/datastructures.html#more-on-lists

INIT

l = [] # empty list
l= [e1, e2, e3, ..., en]
vec = [e] * n # n values
matrix = [[0]*n for i in range(n)] # n dimensions at n values
l = list(tuple)  # cast

METHODS

l.append(element) # append only one elment at the end
l.extend([element1,element2]) # append elments of list at the end
l.insert(index,element) <=> l[index:index]=[element] # insert one element at index
l.remove(element) # remove the first occurence of the element
l.element=pop(index) # remove element at index & return element
l.reverse() # reverse elements
l.sort() # sort elements
l.sort(reverse=True) # sort items by reversing order
ls=sorted(l) # return a new sorted list of list passed in argument
[[l1.element1, l2.element1, ...], [l1.element2, l2.element2, ...] ] # associate lists 
zip(l1, l2, ...) # return an iterator that aggregates elements from each of the iterables

COMPREHENSION

list2 = [treatment for i in list if cond]

receive string with numbers and other characters in multiple lines
have to be return a list of square separate by ':'

def carre(ligne):
    import re
    l = re.findall('(\d+)',ligne)
    l = [int(i)**2 for i in l]
    l = [str(i) for i in l]
    return(':'.join(l))

received a list of numbers
return result of polynomial function

def P(x):
    return(2*x**2 -3*x -2)
def liste_P(liste_x):
    return([P(x) for x in liste_x])

graph

import numpy as np
import matplotlib.pyplot as plt
# un échantillon des X entre -10 et 10
X = np.linspace(-10, 10)
# et les Y correspondants
Y = liste_P(X)
# on n'a plus qu'à dessiner
plt.plot(X, Y)
plt.show()