Scripting Python – Memo Avancé

 


 

Les listes

 

Ajouter un élément en fin de liste :
list.append(item)

ex :

>>> a = []
>>> for x in range(1, 9) : a.append(x)
... 
>>> a
[1, 2, 3, 4, 5, 6, 7, 8]

 

Insérer un élément dans une liste :
list.insert(index, item)

ex :

>>> a = list()
>>> for x in range(1, 9) : a.insert(0, x)
... 
>>> a
[8, 7, 6, 5, 4, 3, 2, 1]

 


 

Les dictionnaires

 

Pretty printer des dictionnaires imbriqués :
from pprint import pprint
pprint(dictionnaire, width=1)

ex :

>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Italie': 'Raisin', 'Espagne': 'Bananes'}
>>> pprint(fruits, width=1)
{'Angleterre': {'North West': 'Pommes',
                'South East': 'Prunes'},
 'Espagne': 'Bananes',
 'France': {'Bourgogne': 'Cerises',
            'Picardie': 'Pommes'},
 'Italie': 'Raisin'}
>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Italie': 'Raisin', 'Espagne': 'Bananes'}
>>> pprint(fruits)
{'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'},
 'Espagne': 'Bananes',
 'France': {'Bourgogne': 'Cerises', 'Picardie': 'Pommes'},
 'Italie': 'Raisin'}

 

Accéder à une valeur par sa clé :
dictionnaire['cle']
dictionnaire['cle']['sous-cle']

ex :

>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Italie': 'Raisin', 'Espagne': 'Bananes'}
>>> fruits['France']
{'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}
>>> fruits['Angleterre']['South East']
'Prunes'

 

Redéfinir une valeur par sa clé :
dictionnaire['cle'] = 'nouvelle valeur'

ex :

>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Italie': 'Raisin', 'Espagne': 'Bananes'}
>>> fruits['Angleterre']['South East'] = 'Groseilles'
>>> fruits['Angleterre']['South East']
'Groseilles'

 

Supprimer une clé :
del dictionnaire['cle']

ex :

>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Italie': 'Raisin', 'Espagne': 'Bananes'}
>>> del fruits['Italie']
>>> pprint(fruits)
{'Angleterre': {'North West': 'Pomme', 'South East': 'Groseilles'},
 'Espagne': 'Bananes',
 'France': {'Bourgogne': 'Cerises', 'Picardie': 'Pommes'}}

 

Ajouter une clé :
dictionnaire['cle'] = 'valeur'

ex :

>>> from pprint import pprint
>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Espagne': 'Bananes'}
>>> fruits['Italie'] = 'Raisin'
>>> pprint(fruits)
{'Angleterre': {'North West': 'Pomme', 'South East': 'Groseilles'},
 'Espagne': 'Bananes',
 'France': {'Bourgogne': 'Cerises', 'Picardie': 'Pommes'},
 'Italie': 'Raisin'}

 

Afficher les clés d’un dictionnaire :
dictionnaire.keys()

ex :

>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Espagne': 'Bananes'}
>>> fruits.keys()
['Italie', 'Espagne', 'Angleterre', 'France']
>>> fruits['France'].keys()
['Picardie', 'Bourgogne']

 

Vérifier l’existence d’une clé :
dictionnaire.has_key('cle')

ex :

>>> fruits = {'France': {'Picardie': 'Pommes', 'Bourgogne': 'Cerises'}, 'Angleterre': {'North West': 'Pommes', 'South East': 'Prunes'}, 'Espagne': 'Bananes'}
>>> fruits.has_key('France')
True
>>> fruits['France'].has_key('Picardie')
True
>>> fruits['France'].has_key('Rhone')
False

 


 

Appeler une fonction de classe

 

instance.function(...) = class.function(instance, ...)

ex :

x.m(...)
C.m(x, ...)

 


 

Accès aux attributs d’un instance

 

instance.attribute peut retourner une erreur de type AttributeError si l’attribut n’est pas défini.
La méthode spéciale getattr(instance, "attribute", default_value) renvoie default_value si l’attribut n’est pas défini.
ex :

x.name
getattr(x, "name", "John Doe")

 

class A():

    def __init__(self):
        self.__priv = "I am private"
        self._prot = "I am protected"
        self.pub = "I am public"


if __name__ == "__main__":
    x = A()
    print(x.pub)
    print(x._prot)
    print(x._A__priv)
    print(x.__dict__)

 


 

setter et getter d’une classe

 

class A:

	comment = "Class test for dummies"

    def __init__(self, name=None):
        self.__name = name

    def set_name(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

    def __repr__(self):
        return "A('{}')".format(self.__name)

    def __str__(self):
        return "{"\
            + f"\n\t'name': '{self.__name}'"\
            + "\n}"

>>> from modules.mymod import A
>>> x = A("Gerard")
>>> print(repr(x))
A('Gerard')
>>> print(str(x))
{
        'name': 'Gerard'
}
>>> print(x)
{
        'name': 'Gerard'
}
>>> y = eval(repr(x))
>>> print(y)
{
        'name': 'Gerard'
}
>>> x.__dict__
{'_A__name': 'Gerard'}
>>> x.__class__.__dict__
mappingproxy({'__module__': 'modules.mymod', 'comment': 'Class test for dummies'
, '__init__': , 'set_name': , 'get_name': , '__repr__': , '__str__':
 , '__dict__': , '__weakref__': , '__doc_
_': None})
>>> A.__dict__
mappingproxy({'__module__': 'modules.mymod', 'comment': 'Class test for dummies'
, '__init__': , 'set_name': , 'get_name': , '__repr__': , '__str__':
 , '__dict__': , '__weakref__': , '__doc_
_': None})

 


 

Incrémentation/décrémentation d’un compteur d’instances

 

class A:

    counter = 0

    def __init__(self):
        type(self).counter += 1

    def __del__(self):
        type(self).counter -= 1

OU

class A:

    counter = 0

    def __init__(self):
        C.counter += 1

    def __del__(self):
        C.counter -= 1
		
>>> x = A()
>>> y = A()
>>> z = A()
>>> del x
>>> A.counter
2

 


 

Propriété d’une classe relative à un attribut

 

class A:

    def __init__(self, y):
        self.x = y

    @property
    def x(self):
        return self.__x

    @x.setter
    def x(self, y):
        if y < 0:
            self.__x = 0
        elif y > 1000:
            self.__x = 1000
        else:
            self.__x = y

OU

class A:

    def __init__(self, y):
        self.__set_x(y)

    def __get_x(self):
        return self.__x

    def __set_x(self, y):
        if y < 0:
            self.__x = 0
        elif y > 1000:
            self.__x = 1000
        else:
            self.__x = y

    x = property(__get_x, __set_x)

 


 

Appel de la méthode d’initialisation de la classe parente

 

class A:

    def __init__(self, x, y):
        self.x = x
        self.y = y


class B(A):

    def __init__(self, x, y, z):
        A.__init__(self, x, y)
        self.z = z

OU

class B(A):

    def __init__(self, x, y, z):
        super(B, self).__init__(x, y)
        self.z = z


OU

class B(A):

    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z


 


 

Packing et unpacking

 

def f1(*args):
    print(args)


def f2(x, y, z):
    print(x, y, z)


def f3(**kwargs):
    print(kwargs)


def f4(x, y, z):
    print(x, y, z)


>>> f1(1,2,3)
(1, 2, 3)
>>> f2(1,2,3)
1 2 3
>>> f3(x=1, y=2, z=3)
{'x': 1, 'y': 2, 'z': 3}
>>> f4(**{'x': 1, 'y': 2, 'z': 3})
1 2 3

 


 

Séparer la partie module de la partie exécution

 

# import module

class A:
	...

class B:
	...

def x():
	...

def y():
	...
	
# python module.py

if __name__ == '__main__':
	test1 = A()
	result = x(test1)
	...

 


 

staticmethod et classmethod

 

Cas 1 : sans héritage

class A:
    name = "class A independant"

    def f1(self):
        print("name: {}".format(self.name))


class B:
    name = "class B independant"

    def f1(self):
        A.f1(self)

>>> x = B()
>>> x.f1()
name: class B independant

 

Cas 2 : staticmethod : la méthode s’exécute dans l’environnement de la classe parente où elle est définie

class A:
    name = "superclass"

    @staticmethod
    def f1():
        print("name: {}".format(A.name))
    

class B(A):
    name = "subclass"


>>> x = B()
>>> x.f1()
name: superclass

 

Cas 3 : classmethod : la méthode s’exécute dans l’environnement de la classe fille

class A:
    name = "superclass"

    @classmethod
    def f1(cls):
        print("name: {}".format(cls.name))

		
class B(A):
    name = "subclass"


>>> x = B()
>>> x.f1()
name: subclass

 


 

Operator Overloading

 

class A:

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return A(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return "A({}, {})".format(self.x, self.y)


>>> x = A(10, 30)
>>> y = A(100, 100)
>>> print(x + y)
A(110, 130)
>>> print(x.__add__(y))
A(110, 130)

 

Binary Operators

Operator Method
+ object.__add__(self, other)
object.__sub__(self, other)
* object.__mul__(self, other)
// object.__floordiv__(self, other)
/ object.__truediv__(self, other)
% object.__mod__(self, other)
** object.__pow__(self, other[, modulo])
<< object.__lshift__(self, other)
>> object.__rshift__(self, other)
& object.__and__(self, other)
^ object.__xor__(self, other)
| object.__or__(self, other)

 

Extended Assignments

Operator Method
+= object.__iadd__(self, other)
-= object.__isub__(self, other)
*= object.__imul__(self, other)
/= object.__idiv__(self, other)
//= object.__ifloordiv__(self, other)
%= object.__imod__(self, other)
**= object.__ipow__(self, other[, modulo])
<<= object.__ilshift__(self, other)
>>= object.__irshift__(self, other)
&= object.__iand__(self, other)
^= object.__ixor__(self, other)
|= object.__ior__(self, other)

 

Unary Operators

Operator Method
object.__neg__(self)
+ object.__pos__(self)
abs() object.__abs__(self)
~ object.__invert__(self)
complex() object.__complex__(self)
int() object.__int__(self)
long() object.__long__(self)
float() object.__float__(self)
oct() object.__oct__(self)
hex() object.__hex__(self)

 

Comparison Operators

Operator Method
< object.__lt__(self, other)
<= object.__le__(self, other)
== object.__eq__(self, other)
!= object.__ne__(self, other)
>= object.__ge__(self, other)
> object.__gt__(self, other)

 


 

Éviter l’ajout dynamique d’attributs au dictionnaire de l’instance

 

class A:

    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y


test = A(10, 20)
test.z = 25
=> AttributeError

 


 

Décorateur générique

 

def update(func):
    def inner(*args, **kwargs):
        print("Updating function")
        return func(*args, **kwargs)
    return inner


@update
def original(*args, **kwargs):
    print(args, kwargs)
>>> original(x="un", y="deux", z="trois")
Updating function
() {'x': 'un', 'y': 'deux', 'z': 'trois'}
>>> original(1, 2, 3)
Updating function
(1, 2, 3) {}

 


 

Fermer le menu
error

Si vous aimez ce site, partagez-le !

Facebook75
Twitter65
YouTube19
YouTube