Mis a jour le 2024-03-17, 13:2

Classes

Les bases

namespaces et scopes :
Définition de classe :
class MyClass:
    "a simple class"
    n = 0
    def myMethod(self, a):
        return 2 * a * self.myField
  
le code doit être executé avant que la classe ne soit définie (la définition peut très bien être à l'intérieur d'une fonction.
Constructeur : s'il existe, il doit s'appeler __init__ :
Définition d'une méthode :
Instanciation d'une classe :
Appel d'un champ ou d'une méthode : si x est de la classe MyClass :
decorateur @property : permet de convertir une fonction en propriété, pour y accéder comme si c'était un champ :
class C:
    def __init__(self, a):
        self.a = a

    @property
    def A(self):
        return self.a
  
on peut alors faire obj = C(3); obj.A (au lieu de obj.A()) pour accéder au champ a.
On ne peut pas avoir plusieurs méthodes de même nom et de signatures différentes.
Pour voir le constructeur d'une classe MyClass qui est définie dans le module (fichier) MyClass (sans avoir besoin de le qualifier complètement), faire :
from MyClass import MyClass
(mais il peut aussi être défini dans un fichier qui ne s'appelle pas du nom de la classe, par exemple myModule et alors il faut faire : from myModule import MyClass

Membres privés

Membres privés :
Pour avoir le nom de la classe à partir d'une instance : myObj.__class__.__name__

Héritage et reflexion

Héritage :
python supporte l'héritage multiple :
Classe object :
Fonctions pour tester l'appartenance aux classes :
Pour avoir le nom de la classe d'un objet :
Pour trouver la hiérarchie des classes pour un objet donné :
On peut accéder par noms aux champs et méthodes d'un objet :
On peut setter un champ avec : setattr(myObj, 'myField', 'myValue').
getter/setter générique d'une classe : permet d'exécuter du code quand on fixe un attribut de l'objet :
class MyClass:
    def __init__(self):
        pass

    def __getattr__(self, name):
        return self.__dict__[f'_{name}']

    def __setattr__(self, name, value):
        if name not in ['property1', 'property2']:
            raise RuntimeError('Unknown property ' + name)
        self.__dict__[f'_{name}'] = value

myObj = MyClass()
myObj.property1 = 45
print(myObj.property1)
  

Champs et méthodes statiques

Champs statique d'une classe :
Méthode statique d'une classe :
Méthode de classe :
Méthode de classe pour construire un objet (quand constructeurs très divers nécessaires) :
@classmethod
def buildObject(cls, arg1, arg2):
  self = MyClass.__new__(cls)
  self.arg1 = arg1
  self.arg2 = arg2
  
A appeler avec myObj = MyClass.buildObject(arg1, arg2)

Divers

Pour accéder à tous les champs d'un objet : vars(myObj), ou aussi myObj.__dict__
Méthodes et champs rajoutés à une classe ou un objet :
Méthode __new__ :
Classe singleton :
class Singleton(object):
    _instance = None

    def __new__(myClass):
        if Singleton._instance is None:
            Singleton._instance = object.__new__(myClass)

        return Singleton._instance

    def __init__(self):
        self._var = 7

    def getVar(self):
        return self._var

s1 = Singleton()
print(s1.getVar())
print(id(s1))
s2 = Singleton()
print(s2.getVar())
print(id(s2))
  
c'est le même id d'objet qui est récupéré avec les 2 constructions.
Représentation d'un objet sous forme de chaîne de caractère :
Appel au constructeur de la classe de base :
class A(object):
 def __init__(self):
   print("world")

class B(A):
 def __init__(self):
   print("hello")
   super(B, self).__init__()
  
Classe nested :
Définition des opérateurs : une classe peut réimplémenter les opérateurs en implémentant certaines fonctions :
Classe qui retourn un callable :

Copyright python-simple.com
programmer en python, tutoriel python, graphes en python, Aymeric Duclert