static method

if inherited method as redefined, decorator @staticmethod must be added

usefulness

• For utility functions related to the class (e.g., calculations, conversions).
• When the method does not need to access the class or instance's data.
• To avoid cluttering the global namespace with independent functions.

examples

class Sentence:
    _call_counter = 0

    @staticmethod
    def call_counter():
        return Sentence._call_counter

    def __init__(self, sentence = ''):
        Sentence._call_counter += 1
        self.sentence = sentence

    def __repr__(self):
        return f"{__class__} called {self.call_counter()}"

class SentenceLower(Sentence):
    _call_counter = 0

    @staticmethod
    def call_counter():
        return SentenceLower._call_counter

    def __init__(self, sentence = ''):
        SentenceLower._call_counter += 1
        self.sentence = sentence.lower()

s1 = Sentence("ma phrase s1")
s2 = SentenceLower("ma phrase s2")
s3 = SentenceLower("ma phrase s3")

print('s1', s1)
>>> s1 <class '__main__.Sentence'> called 1
print('s2', s2)
>>> s2 <class '__main__.Sentence'> called 2
print(s1.call_counter(), Sentence.call_counter())
>>> 1, 1
print(s2.call_counter(), SentenceLower.call_counter())
>>> 2, 2

class method

if inherited method as redefined, decorator @classmethod must be added

usefulness

• Create alternative methods for constructing instances (like factory methods)
• Access or modify class attributes
• Do not depend on a specific instance

class Sentence:
    _call_counter = 0

    @classmethod
    def call_counter(cls):
        return cls._call_counter

    def __init__(self, sentence = ''):
        __class__._call_counter += 1
        self.sentence = sentence

    def __repr__(self):
        return f"{self.__class__} called {self.call_counter()}"

class SentenceLower(Sentence):
    _call_counter = 0

    def __init__(self, sentence = ''):
        __class__._call_counter += 1
        self.sentence = sentence

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__

list of mains specials methods

Special methods (or dunder methods, for double underscore) are methods prefixed and suffixed with __ that define the behavior of objects for built-in operators, built-in functions, or specific protocols (such as iteration or comparison).

Initialization and Destruction

__init__(self, ...) # Object constructor
__del__(self) # Destructor (called when the object is deleted)

Representation and Display

__repr__(self) # "Official" representation of the object (used by repr())
__str__(self) # "Informal" representation (used by str() and print())
__format__(self, format_spec) # Behavior for format() and f-strings
__bytes__(self) # Behavior for bytes()

Accessing Attributes

__getattr__(self, name) # Called when an attribute is not found
__getattribute__(self, name) # Called for all attribute accesses
__setattr__(self, name, value) # Called when an attribute is assigned
__delattr__(self, name) # Called when an attribute is deleted
__dir__(self) # List of accessible attributes (used by dir())

Arithmetic and logical operators

Unary operators

__pos__(self) # +x 
__neg__(self) # -x 
__abs__(self) # abs(x) 
__invert__(self) # ~x (binary inversion)

Binary operators

__add__(self, other) # x + y 
__sub__(self, other) # x - y 
__mul__(self, other) # x * y 
__matmul__(self, other) # x @ y (matrix multiplication) 
__truediv__(self, other) # x / y 
__floordiv__(self, other) # x // y 
__mod__(self, other) # x % y 
__pow__(self, other) # x ** y 
__lshift__(self, other) # x << y 
__rshift__(self, other) # x >> y 
__and__(self, other) # x & y 
__or__(self, other) # x | y 
__xor__(self, other) # x ^ y

Comparison operators

__eq__(self, other) # x == y 
__ne__(self, other) # x != y 
__lt__(self, other) # x < y 
__le__(self, other) # x <= y 
__gt__(self, other) # x > y 
__ge__(self, other) # x >= y

Augmented assignment operators

__iadd__(self, other) # x += y 
__isub__(self, other) # x -= y 
__imul__(self, other) # x *= y 
__imatmul__(self, other) # x @= y 
__itruediv__(self, other) # x /= y 
__ifloordiv__(self, other) # x //= y 
__imod__(self, other) # x %= y 
__ipow__(self, other) # x **= y 
__ilshift__(self, other) # x <<= y 
__irshift__(self, other) # x >>= y 
__iand__(self, other) # x &= y 
__ior__(self, other) # x |= y 
__ixor__(self, other) # x ^= y

Container protocols

__len__(self) # len(x) (length). 
__getitem__(self, key) # x[key] (access by index/key). 
__setitem__(self, key, value) # x[key] = value. 
__delitem__(self, key) # del x[key]. 
__contains__(self, item) # item in x (membership test). 
__iter__(self) # Returns an iterator for iter(x). 
__next__(self) # Next value for the iterator (used with __iter__)
__reversed__(self) # Returns a reversed iterator for reversed(x)

Context Protocols (Resource Management)

__enter__(self) # Entry into a with block
__exit__(self, exc_type, exc_val, exc_tb) # Exit from a with block

Serialization Protocols

__reduce__(self) # Used by pickle for serialization
__reduce_ex__(self, protocol) # Extended version of __reduce__

Copy Protocols

__copy__(self) # Behavior for copy.copy()
__deepcopy__(self, memo) # Behavior for copy.deepcopy()

Type Conversion Protocols

__int__(self) # Converts to an integer
__float__(self) # Converts to a float
__complex__(self) # Converts to a complex number
__index__(self) # Converts to an integer for indexing (used by lists, tuples, etc.)
__round__(self, n) # Behavior for round(x, n)
__trunc__(self) # Behavior for math.trunc(x)

Hash and Equality Protocols

__hash__(self) # Returns a hash for the object (used in dictionaries and sets)
__eq__(self, other) # Already mentioned in the comparison operators

Call and Instance Protocols

__call__(self, *args, **kwargs) # Allows calling an instance like a function # x()
__instancecheck__(self, instance) # Used by isinstance() (in a metaclass)
__subclasscheck__(self, subclass) # Used by issubclass() (in a metaclass)

Dynamic Attribute Management Protocols

__get__(self, instance, owner) # Behavior for descriptors (used in class properties and methods)
__set__(self, instance, value) # Behavior for writable descriptors
__delete__(self, instance) # Behavior for deleted descriptors

Module Management Protocols

__dir__(self) # List of accessible attributes (already mentioned)
__getattr__(self, name) # Already mentioned

Class Management Protocols

__prepare__(name, bases) # Used in a metaclass to create the class namespace
__new__(cls, *args, **kwargs) # Creates a new instance of the class (before __init__)
__init_subclass__(cls) # Called when a class is subclassed

Coroutine and Async Management Protocols

__await__(self) # Allows the use of an object in an await expression
__aiter__(self) # Returns an asynchronous iterator for aiter(x)
__anext__(self) # Next value for the asynchronous iterator
__aenter__(self) # Enters an async with block
__aexit__(self, exc_type, exc_val, exc_tb) # Exits an async with block

Array and Buffer Management Protocols

__array__(self) # Used by NumPy to convert an object to an array
__buffer__(self, flags) # Used for buffer protocol objects (such as MemoryView)

File and I/O Management Protocols

__fspath__(self) # Returns a file path (used by os.fspath())

Event Handling Protocols

__await__(self) # Already mentioned

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

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 & dir

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

# return attributs & methods
dir(Myclass) <=> Myclass.__dir__()

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"p[{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=" - ")
>>> t.d=[0, 0] - t.p=[0, 0] - Point.d=[0, 0]
try: Point.p
except AttributeError as e: print(f"{type(e)}: {e}")
>>> <class 'AttributeError'>: type object 'Point' has no attribute '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=" - ")
>>> Point.a=1 - t.a=1 - t2.a=1

# 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=" - ")
>>> Point.a=1 - t.a=1 - t2.a=2
Point.a = 3
print(f"Point.a={Point.a}", f"t.a={t.a}", f"t2.a={t2.a}", sep=" - ")
>>> Point.a=3 - t.a=3 - t2.a=2

# 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=" - ")
>>> Point.d=[0, 0, 3] - t.d=[0, 0, 3] - t2.d=[0, 0, 3]
Point.d.append(4)
print(f"Point.d={Point.d}", f"t.d={t.d}", f"t2.d={t2.d}", sep=" - ")
>>> Point.d=[0, 0, 3, 4] - t.d=[0, 0, 3, 4] - t2.d=[0, 0, 3, 4]

## instance attribute
t = Point()
print(f"t.p={t.p}", f"t2.p={t2.p}", sep=" - ")
>>> t.p=[0, 0] - t2.p=[0, 0]
t.p.append(1)
print(f"t.p={t.p}", f"t2.p={t2.p}", sep=" - ")```
>>> t.p=[0, 0, 1] - t2.p=[0, 0]

### instance equality

**instances are compared by the id not values**

```python
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()

# Retrieves the value of an attribute of an object
getattr(object, name[, default])

# Sets or modifies the value of an object's attribute
setattr(object, name, value)

# Checks if an object has a given attribute
hasattr(object, name)

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

dynamic overload

class Test:
     class_attr = 0

     def __init__(self, value = 0):
        self.attr = value

def class_add(value = 0):
    Test.class_attr += value

def instance_add(self, value):
    self.attr += value

dir(Test)
Test.class_add = class_add
Test.instance_add = instance_add
dir(Test)
Test.class_add(10)
print(Test.class_attr)
>>> 10
t = Test()
t.instance_add(100)
print(t.attr)
>>> 100

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

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

parameters orders

• ordered
• named
• *tuple
• **dict

ordered

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

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

named (default/optionnal) parameters

named parameters have to be placed after positional parameters

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

*tuple

'tuple' parameter catch all undeclared parameters (tuple is unique)
it have to be placed after positional & named parameters

def f(*t):
    ...
def f(arg1, arg2, arg3=opt, *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'])

**dict

'dict' parameter catch all undeclared named parameters (dict is unique)
it have to be placed after all parameters

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)

dictionary 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

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

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

dict

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

init

Syntax

d = {}
d = dict()
d = {key1: value1, key2: value2, ...}
d = dict([(key1, value1), (key2, value2), ...])
d = 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}
print(z)
>>> {'a': 1, 'b': 3, 'c': 4}

del(d), del(d[k])

del(d[key]) # delete a key
del(d) # delete the entire dictionary

existence test

k in d # k in keys
k in d.keys() # k in keys
v in d.values() # v in values
(k, v) in d.items() # pair (key, value) in dictionary

items()

[(k, v) for k, v in d.items()] # return list of tuples (k, v)

#### keys()

```python
[k for k in d.keys()] # return list of keys

values()

[v for v in d.values()] # return list of values

update()

d.update(d2) # update d with values from d2
d.update({'key1':value1, 'key2':value2}) # update d with values

setdefault(key, value)

d.setdefault(key, value) # only append a tuple if not already exists

Collections

namedtuple

Named tuples are very similar to tuples, from which they inherit. They simply add the ability to reference tuple fields by name rather than by index, for improved readability.

Point2D = namedtuple('Point2D', ['x', 'y'])
p = Point2D(3, 5)
p.x
>>> 3
p.y
>>> 5
p[0]
>>> 3

deque

'collections.deque' (double-ended queue) is a data structure optimized for adding or removing elements from both ends (left or right). It is more efficient than lists for these operations (O(1) time).

usefulness

• Queues (FIFO) or stacks (LIFO)
• Algorithms such as BFS (Breadth-first search)
• Management of buffers or circular logs

Limitations

• Random access is slower than a list (d[0] is O(1), but d[i] is O(n) for i far from the edges)
• Less suitable for searching or sorting

Main features

• Thread-safe: suitable for queues in multi-threaded environments.
• Dynamic size: can automatically expand or shrink.

Key methods

append(x) # adds x to the right
appendleft(x) # adds x to the left
pop() # removes and returns the element on the right
popleft() # removes and returns the element on the left
extend(iterable) # adds multiple elements to the right
extendleft(iterable) # adds multiple elements to the left (in reverse order)
rotate(n) # rotates the elements by n positions (positive = right, negative = left)
clear() # clears the deque

example

d = deque([1, 2, 3])
d.append(4)
d.appendleft(0)
>>> deque([0, 1, 2, 3, 4])

The deques can also be limited in size by removing the rightmost elements when inserting them from the left, and vice versa. This allows for the creation of circular stamps.

d = deque([2], 2)
d.append(3)
>>> deque([2, 3], maxlen=2)
d.appendleft(1)
>>> deque([1, 2], maxlen=2)

d = deque(range(10), 7)
>>> deque([3, 4, 5, 6, 7, 8, 9], maxlen=7)
d.rotate(2)
>>> deque([8, 9, 3, 4, 5, 6, 7], maxlen=7)
d.rotate(-3)
>>> deque([4, 5, 6, 7, 8, 9, 3], maxlen=7)

chainmap

ChainMap allows to group multiple dictionaries or mappable objects into a single logical view.
modifications on chainmap are also made in originals dictionary

usefulness

• Overlapping contexts (for example, default and specific parameters)
• Preventing dictionary duplication while combining their keys
• Prioritizing access: keys are searched in the order of the provided dictionaries

d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4}
c = ChainMap(d1, d2)
c['a'] = 10
print(d1, d2, '/', c)
>>> {'a': 10, 'b': 2} / ChainMap({'a': 10, 'b': 2}, {'b': 3, 'c': 4})
print(c['b'])
>>> 2
print(d1, d2, '/', c)
>>> {'a': 10, 'b': 2, 'c': 6} {'b': 3, 'c': 4} / ChainMap({'a': 10, 'b': 2, 'c': 6}, {'b': 3, 'c': 4})
c.new_child({'v':1, 'w':2})
print(c)
>>> ChainMap({'v': 1, 'w': 2}, {'a': 10, 'b': 2, 'c': 6}, {'b': 3, 'c': 4})
c.parents
>>> ChainMap({'b': 3, 'c': 4})
dict(c)
>>> {'b': 2, 'c': 6, 'a': 10}

counter

'collections.Counter' is a subclass of dict specifically designed to count hashable objects (such as elements in a list, words in a text, etc.). It is optimized for counting operations and offers practical methods.

usefulness

• Count the occurrences of elements in a sequence (list, string, etc.)
• Find the most frequent elements
• Perform mathematical operations between counters (addition, subtraction, intersection)

Key methods

most_common(n) # Returns the n most frequent elements
elements() # Returns an iterator over the repeated elements based on their count
update(iterable) # Updates the counter with the elements of an iterable
subtract(iterable) # Subtracts the counts from an iterable

# Addition: elements present in counter1 and in counter2
counter1 + counter2
# Subtraction: elements present in counter1 but not in counter2
counter1 - counter2
# Intersection: minimum count
counter1 & counter2
# Return only positive counts
+c
# Return only -(negative counts)
-c

Common Error Cases

Non-hashable elements: If you try to count a non-hashable element (such as a list), a TypeError will be thrown

example

c = Counter([1, 2, 3, 1, 3, 1, 5])
>>> Counter({1: 3, 3: 2, 2: 1, 5: 1})
c[3]
>>> 2
c[4]
>>> 0
c[5] += 1
>>> Counter({1: 3, 3: 2, 5: 2, 2: 1})
c + Counter({1: 2, 2: 3})
>>> Counter({1: 5, 2: 4, 3: 2, 5: 2})
c - Counter({1: 2, 2: 3})
>>> Counter({3: 2, 5: 2, 1: 1})
c.most_common(2)
>>> [(1, 3), (3, 2)]
c.update({5: 1})
>>> Counter({1: 3, 3: 2, 5: 2, 2: 1})
c.subtract({2: 4, 3: 6})
>>> Counter({1: 3, 5: 2, 2: -3, 3: -4})
+c
>>> Counter({1: 3, 5: 2})
-c
>>> Counter({3: 4, 2: 3})

OrderedDict

'collections.OrderedDict' is a subclass of dict that preserves the insertion order of keys

Here are its main features and uses:

main features

- Guaranteed Ordering # Unlike a standard `dict` (since Python 3.7+, the order is also guaranteed for regular dictionaries, but `OrderedDict` offers additional methods for manipulating the order)
- Compatibility # Works like a regular dictionary, but with methods dedicated to ordering
- Performance # Slightly slower than a standard `dict` for basic operations, but useful for specific cases

specific methods

move_to_end(key, last=True) # Moves a key to the end (`last=True`) or the beginning (`last=False`) of the order
popitem(last=True) # Deletes and returns an element: the last (last=True) or the first (last=True=False)

defaultdict

'ollections.defaultdict' is a subclass of 'dict' that allows you to define a default value for non-existent keys. Here's how to use it and its main features:

Possible default values:

- int # returns 0
- list # returns an empty list []
- str # an empty string ""
- set # returns an empty set set()
- a custom function (e.g., lambda: "default_value")

Notes

Thread-safe: defaultdict is not thread-safe. For multithreaded use, use a dict with a lock or other synchronization.

Performance: Slightly slower than a classic dict for simple accesses, but much more practical for cases where keys are dynamic.

example

d = defaultdict(int)
d["apples"] += 1 # if "apples" doesn't exist, the default value is 0

d = defaultdict(list)
d["fruits"].append("apple")

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)