Python3 Object-Oriented

Object-Oriented Présentation de la technologie

• Classe (Class): utilisé pour décrire la collection ont les mêmes propriétés et méthodes des objets. Il définit un ensemble de propriétés et de méthodes communes à chaque objet. Les objets sont des instances de classes.
• Les variables de classe: variables de classe est commun dans tout l'objet instancié. Les variables de classe définies et en dehors de la fonction dans la classe. Les variables de classe ne sont normalement pas utilisés comme variables d'instance.
• membres de données: variables de classe ou des variables d'instance pour les classes de traitement de données associées et des objets d'instance.
• Remplacements: Si vous ne pouvez pas répondre aux besoins d'une sous - classe hérite de la méthode de la classe parent, il peut être réécrite, un processus appelé méthode de superposition (override), également connu comme la méthode dominante.
• Exemples de variables: les variables définies dans la méthode, seul le rôle de la classe de l'instance actuelle.
• Héritage: Cela est une classe dérivée (classe dérivée) hérite des classes de base (classe de base) des champs et des méthodes. L'héritage permet également un objet de classe dérivée comme cadeau d'objet de classe de base. Par exemple, il y a une telle conception: un type d'objet qui est dérivé d'une classe Dog animale, qui est un analogue "est un (est-a)" relation (exemple figure, est un animal de chien).
• Instanciez: créer une instance d'une classe, la classe d'objet spécifique.
• Méthodes: Les fonctions de classe définie.
• Objet: données instance de structure à travers la définition de la classe. Les objets de données comprennent deux membres (variables de classe et d'instance) et des méthodes.

Et d'autres langages de programmation, Python à un minimum de nouvelle syntaxe et la sémantique de la situation à rejoindre le mécanisme de la classe.

Les classes Python dans la programmation orientée objet offre toutes les fonctions de base: le mécanisme d'héritage de classe permet plusieurs classes de base, la classe de base dans les classes dérivées peuvent remplacer toutes les méthodes, vous pouvez appeler la méthode de classe de base du même nom.

Les objets peuvent contenir un nombre quelconque et le type de données.

définition de classe

La syntaxe est la suivante:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Après la classe est instancié, vous pouvez utiliser ses propriétés, en fait, après avoir créé une classe, vous pouvez accéder à ses propriétés via le nom de la classe.

objet Class

objets de classe prennent en charge deux types d'opérations: références d'attributs et instanciation.

Attribut références utilisent Python pour tous les attributs référence à lasyntaxe standard: obj.name.

Une fois l'objet de classe a été créée attribut d'espace de noms de classe tous les noms sont des noms valides. Donc, si la définition de classe ressemble à ceci:

#!/usr/bin/python3

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

Instancier la classe:

# 实例化类
x = MyClass()
# 访问类的属性和方法

crée-dessus une nouvelle instance de la classe et affecte cet objet à la variable locale x, x objet vide.

La sortie du programme ci-dessus est:

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

De nombreuses classes aiment créer des objets dans un état initial connu. Par conséquent, une classe peut définir une __ nommée __init () méthode spéciale (constructeur), comme ceci:

def __init__(self):
    self.data = []

méthode de classe __init définit __ (), l'opérateur d'instanciation de classe appelle automatiquement la méthode __init __ (). Donc, dans cet exemple, il peut consister à créer une nouvelle instance:

x = MyClass()

Bien sûr, la méthode __init __ () peut avoir des arguments, des paramètres __init __ () est passé à l'opérateur d'instanciation de classe. Par exemple:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Les méthodes de classe

A l'intérieur terrestre, l'utilisation def mot-clé peut être définie comme une méthode de classe, des définitions différentes et des fonctions générales, les méthodes de classe doivent inclure le paramètre auto, et comme le premier paramètre:

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('w3big',10,30)
p.speak()

La sortie du programme ci-dessus est:

w3big 说: 我 10 岁。

hériter

Python prend également en charge l'héritage de classe, si une langue ne supporte pas l'héritage, la classe a peu de sens. Définition de la classe dérivée comme suit:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

Notez que l'ordre de la classe de base entre parenthèses, si la classe de base a le même nom de méthode, mais sans préciser les sous-classes, python de gauche à droite méthode de recherche qui ne figure pas dans la sous-classe, de gauche à droite pour trouver classe de base contient des méthodes.

NomClasseDeBase (exemple de nom de la classe de base) doit être définie dans un champ de la classe dérivée. En plus des classes, vous pouvez utiliser l'expression, la classe de base est définie dans un autre module, ce qui est très utile pour:

class DerivedClassName(modname.BaseClassName):

Exemples

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))



s = student('ken',10,60,3)
s.speak()

La sortie du programme ci-dessus est:

ken 说: 我 10 岁了，我在读 3 年级

héritage multiple

Python supporte une forme limitée d'héritage multiple. définition de classe multiple d'héritage se présente comme suit:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

Notez que l'ordre entre parenthèses classe parent, si la classe parent ont le même nom de méthode, mais sans préciser les sous-classes, python de gauche à droite méthode de recherche qui ne figure pas dans la sous-classe, de gauche à droite pour trouver classe parente contient des méthodes.

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

La sortie du programme ci-dessus est:

我叫 Tim，我是一个演说家，我演讲的主题是 Python

remplacements Méthode

Si la fonction que vous êtes la méthode de la classe parent ne peut pas répondre à vos besoins, vous pouvez réécrire votre méthode de classe parent dans une sous-classe, les exemples sont les suivants:

#!/usr/bin/python3

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

La sortie du programme ci-dessus est:

调用子类方法

attributs et méthodes de classe

Privé catégorie de biens

__private_attrs: commençant deux soulignement indiquant que la propriété est privée et ne peut être utilisé ou accessible directement dans la classe externe. Self .__ private_attrs lorsqu'il est utilisé dans une méthode de classe.

Les méthodes de classe

A l'intérieur terrestre, l'utilisation def mot-clé peut être définie comme une méthode de classe à la définition générale des différentes fonctions, les méthodes de classe doivent inclure le paramètre auto, et comme le premier paramètre

Les méthodes privées de classe

__private_method: les deux premiers soulignement, la méthode est déclarée comme méthodes privées dans la classe ne peuvent pas appeler à l' extérieur. appel interne classe slef .__ private_methods.

Exemples

instance de propriété privée de la classe comme suit:

#!/usr/bin/python3

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

La sortie du programme ci-dessus est:

1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

Méthode privée instance de la classe comme suit:

#!/usr/bin/python3

class Site:
	def __init__(self, name, url):
		self.name = name       # public
		self.__url = url   # private

	def who(self):
		print('name  : ', self.name)
		print('url : ', self.__url)

	def __foo(self):          # 私有方法
		print('这是私有方法')

	def foo(self):            # 公共方法
		print('这是公共方法')
		self.__foo()

x = Site('本教程', 'www.w3big.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

Les résultats des exemples ci-dessus:

méthodes de propriété de la classe:

• __init__: constructeur est appelé quand un objet est généré
• __del__: destructor, les objets de libération
• __repr__: l' impression, la conversion
• __setitem__: selon l'affectation des index
• __getitem__: Obtient la valeur de l'indice
• __len__: obtenir la longueur
• __cmp__: opération de comparaison
• __call__: appel de fonction
• __add__: ajoutez l' opération
• __sub__: soustraction
• __mul__: Multiplication
• __div__: opération de division
• __mod__: opérateur reste
• __pow__: partie appelée

Surcharge de l'opérateur

Python supporte également la surcharge de l'opérateur, ce que je peux être surchargé méthodes exclusives de classe, les exemples sont les suivants:

#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

Les résultats de l'exécution de codes ci-dessus sont les suivantes:

Vector(7,8)