try except

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

syntax

try:
    ....
# Catch only Error_name
except Error_class as e:
    ...
except Error_class2 as e:
    ...
else
    ...
# Execute always instructions at the end even after a return
finally

Catch all errors

try:
    ...
except:
    ...
...

example

def return_with_finally(number):
    try:
        return 1/number
    except ValueError as e:
        print(f"e.args, {e.args}")
        return("zero-divide")
    except ZeroDivisionError as e:
        print(f"OOPS, {type(e)}, {e}")
        return("zero-divide")
    except TypeError as e:
        # interrupt treatment with the error
        raise
    finally:
        print("always executed even after a return in 'except'")

Raise

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

launch a specific Error Class with text

raise ErrorClass("personalized message")

Main class errors

SyntaxError # Syntax error in the code (missing parentheses, misspelled keyword, etc.).
IndentationError # Indentation problem (incorrect space or tab).
NameError # Undefined variable or function.
TypeError # Operation or function applied to an inappropriate type (e.g., adding an integer to a string).
IndexError # Accessing an index outside the bounds of a list or string.
KeyError # Key not found in a dictionary.
ValueError # Inappropriate value for an operation (e.g., converting a non-numeric string to an integer).
AttributeError # Attribute or method not found for an object.
FileNotFoundError # File not found during an input/output operation.
ZeroDivisionError # Division by zero.
ImportError # Module or function not found during an import.
ModuleNotFoundError # Python module not found. Keyboard Interrupt # Manually interrupts the program (Ctrl+C).
RecursionError # Too many recursions (exceeds the depth limit).
MemoryError # The program has exhausted available memory.
OSError # Error related to the operating system (e.g., permissions problem).
RuntimeError # Generic error not covered by other exceptions.
AssertionError # Assertion (assert) failed.
StopIteration # No more elements to iterate over (raised by the iterators).
NotImplementedError # Unimplemented method or function.

Customize ErrorClass

For module-specific errors, use a prefix: 'class MyModuleError(Exception): ...'
For critical errors, inherit from 'RuntimeError' or 'ValueError'

Inheritance: The class inherits from Exception to be usable as a standard error.

init
Arguments:

• message: Error message (required).
• code: Error code (optional, defaults to 500).
• details: Dictionary for additional information (optional).

str
Displays the error in a readable format.

class CustomError(Exception):
    '''Class for a custom error with arguments'''

    def __init__(self, message: str, code: int = 500, details: dict = None):
        self.message = message
        self.code = code
        self.details = details or {}
        super().__init__(self.message)

    def __str__(self):
        return f"{self.message} (code: {self.code}, details: {self.details})"

example

try:
    raise CustomError("An error has occurred", 404, {"file": "data.txt"})
except CustomError as e:
    print(e) # print: "An error has occurred (code: 404, details: {'file': 'data.txt'})"
    print(e.code) # print: 404
    print(e.details) # print: {'file': 'data.txt'})"

Assertion

If assert condition return False a AssertionError exception is always launched

• Assertions are primarily used during development.
• It is imperative to avoid side effects in assertions because,
  when they are removed, the effect is also removed.
• Assertions can be removed from the bytecode if the -O option is called during compilation.

assert condition, "error_message"

# assert is equal to:
if __debug__ :
    if not <test> :
        raise AssertionError, <values>

try except

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

syntax

try:
    ....
# Catch only Error_name
except Error_class as e:
    ...
except Error_class2 as e:
    ...
else
    ...
# Execute always instructions at the end even after a return
finally

Catch all errors

try:
    ...
except:
    ...
...

example

def return_with_finally(number):
    try:
        return 1/number
    except ValueError as e:
        print(f"e.args, {e.args}")
        return("zero-divide")
    except ZeroDivisionError as e:
        print(f"OOPS, {type(e)}, {e}")
        return("zero-divide")
    except TypeError as e:
        # interrupt treatment with the error
        raise
    finally:
        print("always executed even after a return in 'except'")

Raise

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

launch a specific Error Class with text

raise ErrorClass("personalized message")

Main class errors

SyntaxError # Syntax error in the code (missing parentheses, misspelled keyword, etc.).
IndentationError # Indentation problem (incorrect space or tab).
NameError # Undefined variable or function.
TypeError # Operation or function applied to an inappropriate type (e.g., adding an integer to a string).
IndexError # Accessing an index outside the bounds of a list or string.
KeyError # Key not found in a dictionary.
ValueError # Inappropriate value for an operation (e.g., converting a non-numeric string to an integer).
AttributeError # Attribute or method not found for an object.
FileNotFoundError # File not found during an input/output operation.
ZeroDivisionError # Division by zero.
ImportError # Module or function not found during an import.
ModuleNotFoundError # Python module not found. Keyboard Interrupt # Manually interrupts the program (Ctrl+C).
RecursionError # Too many recursions (exceeds the depth limit).
MemoryError # The program has exhausted available memory.
OSError # Error related to the operating system (e.g., permissions problem).
RuntimeError # Generic error not covered by other exceptions.
AssertionError # Assertion (assert) failed.
StopIteration # No more elements to iterate over (raised by the iterators).
NotImplementedError # Unimplemented method or function.

Customize ErrorClass

For module-specific errors, use a prefix: 'class MyModuleError(Exception): ...'
For critical errors, inherit from 'RuntimeError' or 'ValueError'

Inheritance: The class inherits from Exception to be usable as a standard error.

init
Arguments:

• message: Error message (required).
• code: Error code (optional, defaults to 500).
• details: Dictionary for additional information (optional).

str
Displays the error in a readable format.

class CustomError(Exception):
    '''Class for a custom error with arguments'''

    def __init__(self, message: str, code: int = 500, details: dict = None):
        self.message = message
        self.code = code
        self.details = details or {}
        super().__init__(self.message)

    def __str__(self):
        return f"{self.message} (code: {self.code}, details: {self.details})"

example

try:
    raise CustomError("An error has occurred", 404, {"file": "data.txt"})
except CustomError as e:
    print(e) # print: "An error has occurred (code: 404, details: {'file': 'data.txt'})"
    print(e.code) # print: 404
    print(e.details) # print: {'file': 'data.txt'})"

Assertion

If assert condition return False a AssertionError exception is always launched

• Assertions are primarily used during development.
• It is imperative to avoid side effects in assertions because,
  when they are removed, the effect is also removed.
• Assertions can be removed from the bytecode if the -O option is called during compilation.

assert condition, "error_message"

# assert is equal to:
if __debug__ :
    if not <test> :
        raise AssertionError, <values>

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

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

# return attributs & methods
dir(Myclass)

Dynamic overload

class Test:
     att = 0

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

dir(Test)
Test.addatt = add_att
dir(Test)

Properties

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 

examples

class Redirector:

    def __init__(self, id):
        self.id = id

    def __repr__(self):
        return f"Redirector({self.id})"

    def __getattr__(self, name):
        def forwarder(arg):
            return f"{self.id} -> {name}({arg})"
        return forwarder

complete example

class Quaternion:
    '''Dictionary for representation'''
    QR = {0:'', 1:'i', 2:'j', 3:'k'}
    '''
    Array for quaternion multiplication with this references for the result: 1:a 2:i 3:j 4:k
    start at 1 to allow negative values (for integer part)
    '''
    MUL = (             # *  1  i  j  k
        (1, 2, 3, 4),       # 1  1  i  j  k
        (2, -1, 4, -3),     # i  i -1  k -j
        (3, -4, -1, 2),     # j  j -k -1  i
        (4, 3, -2, -1)      # k  k  j -i -1
        )

    @property
    def quaternion(self):
        return self._quaternion

    @quaternion.setter
    def quaternion(self, quaternion):
        self._quaternion = quaternion

    def __init__(self, *args):
        if len(args) == 4:
            self.quaternion = args
        elif len(args) == 1:
            args = args[0]
            if isinstance(args, int):
                self.quaternion = (args, 0, 0, 0)
            if isinstance(args, complex):
                self.quaternion = (int(args.real), int(args.imag), 0, 0)
        else:
            raise TypeError(f"Attribut must be a class: {tuple} of 4 int, {int} or {complex} not: {type(args)}")

    def __add__(self, arg):
        if isinstance(arg, complex) or isinstance(arg, int):
            arg = Quaternion(arg)
        if isinstance(arg, Quaternion):
            new = [i + j for i, j in zip(self._quaternion, arg._quaternion)]
            return Quaternion(*new)
        else:
            raise TypeError(f"Attribut must be a class: {Quaternion}, {int} or {complex} not: {type(arg)}")

    def __radd__(self, arg):
        return self.__add__(arg)

    def __eq__(self, arg):
        if isinstance(arg, complex) or isinstance(arg, int):
            arg = Quaternion(arg)
        if isinstance(arg, Quaternion):
            return all(i == j for i, j in zip(self._quaternion, arg._quaternion))
        else:
            raise TypeError(f"Attribut must be a class: {Quaternion}, {int} or {complex} not: {type(arg)}")

    def __mul__(self, arg):
        if isinstance(arg, complex) or isinstance(arg, int):
            arg = Quaternion(arg)
        if isinstance(arg, Quaternion):
            if self._quaternion == (0, 0, 0, 0) or arg._quaternion == (0, 0, 0, 0):
                return Quaternion(0, 0, 0, 0)
            result = [0] * 4
            for es, cs in enumerate(self._quaternion):
                for ea, ca in enumerate(arg._quaternion):
                    index, coeff = self.get_mul(es, ea, cs, ca)
                    result[index] += coeff
            return Quaternion(*result)
        else:
            raise TypeError(f"Attribut must be a class: {Quaternion}, {int} or {complex} not: {type(arg)}")

    def get_mul(self, es, ea, cs, ca):
        if cs == 0 or ca == 0:
            return (0, 0)
        else:
            index = Quaternion.MUL[es][ea]
            coef = cs * ca if index > 0 else -(cs * ca)
            # remove one because Quaternion.MUL give as result + 1
            return (abs(index) - 1, coef)

    def __repr__(self):
        result = [('+' if c > 0 else '') + str(c) + Quaternion.QR[e] for e, c in enumerate(self.quaternion) if c]
        result = ''.join(result).lstrip('+')
        return f"{result:.1f}" if isinstance(result, float) else f"{result}"```

LAMBDA

Anonym function, to use as an expression

from functools import reduce
from operator import add
def factoriel(x):
    return reduce(lambda x, y: x*y, range(1, x+1), 1)
def fibonacci(x):
    return reduce(operator.add, range(1, x+1), 0)
def fibonacci(x):
    return reduce(add, range(1, x+1), 0)

With comprehension
[(lambda x: x**2)(x) for x in range(10) if x % 2 == 0]

MAP

Return an iterator that applies function to every item of iterable, yielding the results

list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, range(10))))

FILTER

Construct an iterator from those elements of iterable for which function returns true

list(filter(lambda x: x % 2 == 0, range(10)))

EXERCISE

1-1

More efficient, don't duplicate listes

def multi_tri(listes):
    for liste in listes:
        liste.sort()
    return listes
def multi_tri(listes):
    return list(map(sorted, listes))

1-2

More efficient, don't duplicate listes

def multi_tri_reverse(listes, reverses):
    for x,y in zip(listes, reverses):
        x.sort(reverse=y)
    return listes
def multi_tri_reverse(listes, reverses):
    return [sorted(x, reverse=y) for x,y in zip(listes, reverses)]
def multi_tri_reverse(listes, reverses):
    return list(map(lambda x, y: sorted(x, reverse=y), listes, reverses))

2-1

def doubler_premier(f, arg, *args):
    return f(2*arg,*args)
def doubler_premier(f, arg1, *args):
    from functools import reduce
    from operator import add, mul
    return reduce(
        f,
        args + (arg1*2,),
        1 if f is mul else 0
    )

2-2

def doubler_premier_kwds(f, arg, *args, **kwargs):
    return f(2*arg, *args, **kwargs)
def doubler_premier_kwds(f, arg1, *args, y=0, z=0):
    from functools import reduce
    return reduce(
        f,
        [arg for arg in args + (arg1*2,) + (y,) + (z,) if arg],
        1 if f.__name__ == 'mul3' else 0
    )

3-1

def compare_all(f, g, entrees):
    return [f(entree) == g(entree) for entree in entrees]

3-2

def compare_args(f, g, entrees):
    return [f(*entree) == g(*entree) for entree in entrees]

EXPRESSION

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

create an generator of iterator in place of comprehension

(treatment for ... if ...)

carre = (x**2 for x in range(1000))
palin = (x for x in carre if str(x) == str(x)[::-1])
carre
palin
# only now, calculate
list(palin)

GENERATOR FUNCTION

http://python-history.blogspot.fr/2010/06/from-list-comprehensions-to-generator.html

def carre(a, b):
    for i in range(a, b):
        yield i**2

def palin(it):
    for i in it:
        if (isinstance(i, (str, int)) and
            str(i) == str(i)[::-1]):
            yield i

list(palin(x**2 for x in range(1000)))

EXCERCISE

def produit_scalaire(X, Y):
    return sum(x*y for x, y in zip(X, Y))
g = produit_scalaire((1, 2), (3, 4))

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})

do not 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()

Examples

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")

https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

• Dict allow to associate keys and values
• Keeps only uniq keys
• key of dict have to be globally immutable

IMMUTABLE

OK: tuple is immutable
d[(key, value)] = str

KO: list is mutable
d[(key, [key, value])] = str

INDEX

Use dict to index dict

# Example with list comprehension
personnes = [
    {'nom': 'Pierre',  'age': 25, 'email': 'pierre@example.com'},
    {'nom': 'Paul',    'age': 18, 'email': 'paul@example.com'},
    {'nom': 'Jacques', 'age': 52, 'email': 'jacques@example.com'},
]
index_par_nom = {personne['nom']: personne for personne in personnes}

init

Syntax:

dic = {}
dic = dict()
dic = {key1: value1, key2: value2, ...}
dic= dict([(key1, value1), (key2, value2), ...])
dic= dict(key1=value1, key2=value2, ...])

assign

dic[key]
dic.get(key, index)

merge

x = {'a':1, 'b':2}
y = {'b':3, 'c':4}
z = {**x, **y}

del(k), del(d)

delete a key or an entire dictionnary

del(dic[key])
del(dic)

k in d

test the existence of key

k in dic

print()

print dictionnary

print(key in dic)
print(dic[key])

items()

iterate on items

for k, v in dic.items():
    print(f"{k}, value {v}")

#return tuple
for item in dic.items():
    print(f"{item} - type(item)")

keys()

iterate on keys

for k in dic.keys():
    print(f"{k}, {age[k]}")

values()

iterate on values

for v in dic.values():
    print(v)

len()

print length oif dictionnary

len(age)

update()

update (merge) dictionnary

dic.update({'key1':value1, 'key2':value2})

setdefault(key, value)

only append a tuple if not already exists

dic.setdefault(key, value)

COLLECTIONS CLASS

collections.OrderedDict

guarantee of keeping order in collection

from collections import OrderedDict
d = OrderedDict()
for i in [value1, value2, ...]:
    d[i] = i

assign

d = OrderedDict({key1: value1, key2: value2, ...})
d = OrderedDict([(key1, value1), (key1, value1), ...])

collections.defaultdict

merge dict without test of existance

from collections import defaultdict
resultat = defaultdict(list)
for x, y in tuples:
    resultat[x].append(y)
# or with int
from collections import defaultdict
compteurs = defaultdict(int)
phrase = "une phrase dans laquelle on veut compter les caractères"
for c in phrase:
    compteurs[c] += 1

EXCERCISE

1

def graph_dict(filename):
    summits = {}
    with open(filename, "r", encoding='utf-8') as f_in:
        for line in f_in:
            (s1, lenght, s2) = line.split()
            if s1 in summits:
                summits[s1].append((s2, int(lenght)))
            else:
                summits[s1]=[(s2, int(lenght))]
        return summits

2

def index(extended):
    ships={}
    for ship in extended:
        # (id, latitude, longitude, date_heure, nom_bateau, code_pays) = ship
        (id, *_) = ship
        ships[id] = ship
    return ships

3

def merge(extended, abbreviated):
    ships={}
    for ship in extended:
        (id, latitude, longitude, date_heure, nom_bateau, code_pays, *_) = ship
        if id in ships:
            ships[id].append((latitude, longitude, date_heure))
        else:
            ships[id] = [nom_bateau, code_pays, (latitude, longitude, date_heure)]
    for ship2 in abbreviated:
        (id, *data) = ship2
        ships[id].append(tuple(data))
    return ships

https://docs.python.org/3/library/stdtypes.html#string-methods

STRING

text.split(sep)

split string with a separator

'sep'.join(list)

join a list with a separator

text.replace(sch,str,count)

replace text by another with an optionnal counter replace

text.replace(sch,str).replace(sch2,str2)

text.strip()

strip all occurences of space,tab... in string

in text

return boolean, true if string are found in text

not in text

the opposite of in

text.find(sch)

return the first place of first occurence of a string in another (return -1 if not found)

text.rfind(sch)

return the first place of last occurence of a string in another (return -1 if not found)

index()

equal at find but launch an exception if not found

try:
    "abcdefcdefghefghijk".index("zoo")
except Exception as e:
    print("OOPS", type(e), e)

text.count(sch[, start[, end]])

count he number of ocuurences of text in string

text.startswith(sch)

return boolean, true if text are started with string

text.endswith(sch)

return boolean, true if text are ended with string

text.upper()

change all characters to uppercase

text.lower()

change all characters to lowercase

text.swapcase()

swat case for all characters

text.capitalize()

put first character in text in uppercase

text.title()

put first character of each 'words' in text in uppercase

PRINT

https://docs.python.org/3/library/string.html#formatstrings

print()

print any types of elements

print(1, 'a', 12 + 4j, clas)

# replace the EOL by one space
print("une", "autre", end=' '); print('ligne')

F-PRINT

Evaluate {} and return text (don't print)

f"dans 10 ans {prenom} aura {age + 10} ans"
f"nous avons pour l'instant {len(notes)} notes"
f"pi avec seulement 2 chiffres apres la virgule {pi:.2f}"
f"{prenom:<10} -- {nom:^12} -- {solde:>8} €"

Left center right

    < ^ >

FORMAT

Evaluate {} & print

"{} {} a {} ans".format(prenom, nom, age)
"{le_prenom} {le_nom} a {l_age} ans".format(le_nom=nom, le_prenom=prenom, l_age=age)
"pi avec seulement 2 chiffres apres la virgule {flottant:.2f}".format(flottant=pi)

Les données à afficher

comptes = [
 ('Apollin', 'Dupont', 127),
 ('Myrtille', 'Lamartine', 25432),
 ('Prune', 'Soc', 827465),
]
for prenom, nom, solde in comptes:
    print(f"{prenom:<10} -- {nom:^12} -- {solde:>8} €")

%

"%s %s a %s ans" % (prenom, nom, age)
variables = {'le_nom': nom, 'le_prenom': prenom, 'l_age': age}
"%(le_nom)s, %(le_prenom)s, %(l_age)s ans" % variables

INPUT

Get answer always in a string !!

nom_ville = input("Entrez le nom de la ville : ")
print(f"nom_ville={nom_ville}")
int(input("Nombre de lignes ? ")) + 3

A simulator: https://pythex.org

REGEXP - MATCH

import re
import re.MatchObject class

raw-string
raw-string: don't interprete '\' in regexp

re.match(regexp,text)

return the beginning matching of text

regexp = "(.*)-(.*)\.txt"
text = "abc-def.txt"
match = re.match(regexp, text)
print(match[1], match[2])

re.search(regexp,text)

return the matching of text

re.findall(regexp,text)

return all matching sequences

sentences = ['Lacus a donec, vitae gravida proin sociis.', 'Neque ipsum! rhoncus cras quam.']
for sentence in sentences:
    print(f"---- dans >{sentence}<")
    print(re.findall(r"\w*[am]\W", sentence))

re.split(regexp,text)

split string with a regexp

for sentence in sentences:
    print(f"---- dans >{sentence}<")
    print(re.split(r"\W+", sentence))
    print()

re.sub(regexp,replace,text)

replace matching parts

for sentence in sentences:
    print(f"---- dans >{sentence}<")
    print(re.sub(r"(\w+)", r"X\1Y", sentence))
    print()

re.compile(regexp).match(sample)

compile before matching

RESULT

search()

example: (?P<name>) affect name 'name' to matched text

# get
sample = "    Isaac Newton, physicist"
match = re.search(r"(\w+) (?P<name>\w+)", sample)

# group return a list indexed (start at 1) by number & by name with (?P<name>)
# group() or group(0) return complete string
match.group()
match.groups() # list of groups
match.groupdict() # dict of all named groups

match.re()

The regular expression object whose match() or search() method produced this match instance

match.string()

The string passed to match() or search()

expand()

expand format in the string results of match

match.expand(r"last_name \g<name> first_name \1")

span()

span return index of matched text at the index of original text

begin, end = match.span('name')
sample[begin:end]

FLAG

IGNORECASE # ignore case
UNICODE # (alias U), use utf8 properties for \w sequence
LOCALE # (alias L), use current LOCAL for \w sequence
MULTILINE # (alias M), multiline
DOTALL # (alias S), catch all characters with . included EOL \n

regexp = "a*b+"
re_obj = re.compile(regexp, flags=re.IGNORECASE | re.DEBUG)
print(regexp, "->", nice(re_obj.match("AabB")))

SEQUENCE

[number]
Matches the contents of the group of the same number

alphanumeric

\w # Matches Unicode word characters
\W # Matches any character which is not a word character
\b # Matches the empty string, but only at the beginning or end of a word
\B # Matches the empty string, but only when it is not at the beginning or end of a word
\~ # Alphanumeric
\s # Matches whitespace characters including [ \t\n\r\f\v], and also many other characters
\S # Matches any character which is not a whitespace character

number

\d # Matches any decimal digit
\D # Matches any character which is not a decimal digit

others

\A # similar to ^, begining of text else in MULTILINE mode
\Z # similar to $, ending of text

regexp - greedy

by default * + ? match a longest chain found, ? allow to inverse the method to match the shortest string

*?
+?
??

GROUP

(...) # anonymous group
(?P<name>...) # named group
(?:...) # without group, optimize the render by not including content in entries table
(?P=name) # match text using predecessor matched text indexed with 'name'
(?=...)
(?!...)
(?<=...)

example: test the last named group id is equal at the first

regexp3 = "(?P<id>[0-9]+)[A-Za-z]+(?P<needle>[0-9]+)[A-Za-z]+(?P=id)"

examples

regexp_phone = r"(\+33|0)(?P<number>[0-9-]{9})\Z"
regexp_phone = r"(?i)\A(?P<proto>http|https|ftp|ssh)://((?P<user>[a-z]+)(:(?P<password>.+))?@)?(?P<hostname>[\w\._]+)(?P<port>\:\d+)?/(?P<path>[\w/]+)?\Z"

Shebang

# to launch a file directly from terminal console, without interpretor
#!/usr/bin/env python3

IDLE

install

sudo apt install idle && idle &

alt+p

for previous line in history

alt+n

for next line in history

Install

sudo apt install ipython3 && ipython3

Configuration

ipython3 profile create
file=~/.ipython/profile_default/ipython_config.py
[ -f "$file.keep" ] && cp -a "$file" "$file.keep$(date +%s)"
sch="c.InteractiveShell.color_info"; sed -i "/^#\?${sch}/ a ${sch} = True" "$file"
sch="c.InteractiveShell.colors"; sed -i "/^#\?${sch}/ a ${sch} = 'Linux'" "$file"
sch="c.TerminalInteractiveShell.highlighting_style"; sed -i "/^#\?${sch}/ a ${sch} = 'monokai'" "$file"
sch="c.TerminalInteractiveShell.highlight_matching_brackets"; sed -i "/^#\?${sch}/ a ${sch} = True" "$file"

!tail $file # access to bash commands with

Comments

# line
'''one line'''
'''
multiple
lines
'''
"""
multiple
lines
"""

Print

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

print(var)
print("a=",a," b=",b)
print(f"a={a}, b={b}")

Dir

dir(object)

return the list properties & methods of object

Type

isinstance(var,'type')
return instance type

ID

id(x)

return identifier of variable ('is' operator return True if id() is equal

Numeric

# example : 16 == 0x10 == 0o20 == 0b10000
0b      # prefix binary
0o      # prefix octal
0x      # prefix hexadecimal

int     # no size limit
float   # 4.3, 15number 53b
complex # (float)+(float)j
bool    # True 1 / False 0

Cast

int()
float()
complex()
bool()
bin()

Operators

=
+=
-=
/=
*=
**=
%=
<<=
>>=
+
-
*
**
/
//
%

Comparators

==
<
>
<=
>=

CLASS

fraction

from fractions import Fraction
Fraction(3,10) - Fraction(2,10) == Fraction(1,10)

decimal

from decimal import Decimal
Decimal('0.3') - Decimal('0.2') == Decimal('0.1')

Bitwise

operator

~
&
|
^
<<
>>

Mutable / Immutable

immutable

int
float
complex
bool

str
tuple
frozenset
bytes

mutable

list
bytearray

set
dict
class
...

Print code source

import inspect
    lines = inspect.getsource(function)
    print(lines)