orienté objet Python

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.

Créer la classe

Utilisez l'instruction de classe pour créer une nouvelle classe, après la classe, et le nom de la classe se termine par deux points, les exemples suivants:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

classe d'aide peut être consulté par ClassName .__ doc__.

class_suite composé de membres de la classe, la méthode, les attributs de données.

Exemples

Ce qui suit est une instance de la classe Python simple:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• la variable empCount est une variable de classe, sa valeur sera partagée entre toutes les instances de cette classe. Vous pouvez utiliser l'accès Employee.empCount au sein de la classe ou en dehors des cours.
• La méthode première méthode __init __ () est une méthode méthode spéciale, constructeur ou initialisation de classe est appelée lors de la création d'une instance de cette classe va appeler la méthode

Créer une instance d'un objet

Pour créer une instance d'une classe, vous pouvez utiliser le nom de la classe, et d'accepter la méthode paramètres.

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

Propriétés d'accès

Vous pouvez utiliser le point (.) Propriété pour accéder à l'objet. Accès à une variable de classe avec le nom de la classe comme suit:

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Exemple complet:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Exécuter le code au-dessus des résultats de sortie sont les suivantes:

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Vous pouvez ajouter, supprimer, modifier les propriétés de la classe comme suit:

emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性

Vous pouvez également accéder aux propriétés utilisent les fonctions suivantes:

• getattr (obj, nom [, par défaut]): objets d'accès à la propriété.
• hasattr (obj, nom): Vérifiez s'il y a un attribut.
• setattr (obj, name, value): définir une propriété. Si la propriété n'existe pas, créez une nouvelle propriété.
• delattr (obj, nom): supprimer les attributs.

hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(empl, 'age')    # 删除属性 'age'

Python attribut class intégré

• __dict__: attributs de la classe (y compris un dictionnaire, les données d'attribut composition de classe)
• __doc__: class document de chaîne
• __name__: nom de classe
• __module__: module où la définition de classe (le nom complet est ". __main __ className ', si la classe est situé dans un module mymod importé, puis className .__ module__ égale mymod)
• __bases__: Toutes les classes de l'élément parent (comprenant une classe parent composé de tous les tuples)

appelle Python intégré dans les exemples d'attributs de classe sont les suivantes:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Exécuter le code au-dessus des résultats de sortie sont les suivantes:

Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

objet python est détruit (garbage collection)

Comme le langage Java, Python utilise comptage de référence cette technique simple pour suivre des objets en mémoire.

Un variables de suivi internes, appelés un compteur de référence.

Quand un objet est créé, il crée un compte de référence, lorsque l'objet est plus nécessaire, c'est-à-dire, une référence au nombre d'objets devient 0, il est nettoyé. Mais la reprise est pas «immédiatement» par l'interprète au moment opportun, les objets d'ordures occupent la mémoire la récupération d'espace.

a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数

mécanisme de collecte des ordures ménagères non seulement pour le compte de référence d'objet est 0, la même chose peut également prendre en charge le cas de références circulaires. Il se réfère à une référence circulaire, deux objets se réfèrent les uns aux autres, mais pas d'autres références variables eux. Dans ce cas, seul le compteur de référence ne suffit pas. garbage collector de Python est en fait une référence à un compteur de cycle et le garbage collector. Comme un comptage de référence garbage collector supplémentaire accordera une attention à la quantité totale allouée de gros objets (et sans compter ceux détruits par référence). Dans ce cas, l'interprète se met en pause, en essayant de nettoyer tout le cycle déréférencées.

Exemples

Destructor __del__, __ del__ est appelée lorsque l'objet est détruit, lorsque l'objet est plus utilisé, __ méthode del__ à exécuter:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3

Des exemples des résultats ci-dessus sont les suivants:

3083401324 3083401324 3083401324
Point 销毁

Remarque: Habituellement , vous devez définir une classe dans un fichier séparé,

l'héritage de classe

L'un des principaux avantages de la programmation orientée objet est amené à réutiliser la réutilisation du code pour atteindre l'un d'entre eux est à travers le mécanisme d'héritage. Hérité relation de type et sous-type tout à fait compréhensible entre les classes dans.

Caveat: Inheritance Syntaxe classe nom de la classe dérivée (le nom de la classe de base): // ... écrire le nom de la classe de base entre parenthèses, lorsque la classe de base est la définition de classe, parmi les tuples spécifiés.

En python succession de quelques-unes des caractéristiques:

• 1: Dans la configuration suivante (méthode __init __ ()) de classe Cheng Zhongji ne sera pas automatiquement invoquée, elle exige spécialisée personnellement appelé dans le constructeur de sa classe dérivée.
• 2: Lorsque vous appelez la méthode de la classe de base, vous devez ajouter le nom de classe préfixe de la classe de base, et la nécessité d'apporter des variables auto de paramètres. Ne pas besoin d'apporter auto paramètre est différent de l'appel de fonction ordinaire dans la classe
• 3: Python toujours trouver d'abord le type correspondant de l'approche, si elle ne peut pas trouver la méthode correspondante dans une classe dérivée, il a commencé à chercher un par un pour la classe de base. (Première méthode appelle à trouver dans cette classe, seulement pour trouver de trouver la classe de base).

Si la colonne plus d'une classe dans le tuple d'héritage, il est alors appelé "l'héritage multiple."

Syntaxe:

Déclaration de la classe dérivée, semblable à leur classe parent, puis hériter de la liste de la classe de base avec le nom de la classe, comme suit:

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

exemple:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"

   def parentMethod(self):
      print '调用父类方法'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "父类属性 :", Parent.parentAttr

class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"

   def childMethod(self):
      print '调用子类方法 child method'

c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法
c.getAttr()          # 再次调用父类的方法

Le code ci-dessus est exécuté comme suit:

调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200

Vous pouvez hériter de plusieurs classes

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....

Vous pouvez utiliser issubclass () ou la méthode isinstance () pour détecter.

• issubclass () - fonction booléenne pour déterminer si une classe est une sous-classe d'une autre classe ou la syntaxe de classe descendante: issubclass (sub, sup)
• isinstance (obj, classe) fonction booléenne si obj est une instance d'un objet de classe de classe de classe ou instance d'objet est une sous-classe renvoie true.

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 la classe parent dans une sous-classe:

exemple:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

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

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

Exécuter le code au-dessus des résultats de sortie sont les suivantes:

调用子类方法

méthodes de la Fondation surchargé

Le tableau ci-dessous présente quelques-unes des caractéristiques communes que vous pouvez remplacer dans votre classe:

Surcharge de l'opérateur

Python prend également en charge la surcharge des opérateurs, des exemples sont les suivants:

#!/usr/bin/python

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)

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. Les appels de private_methods de soi au sein de la classe

Exemples

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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  # 报错，实例不能访问私有变量

Python en changeant le nom d'inclure le nom de la classe:

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

Python est pas autorisé les données privées d'accès de classe instanciée, mais vous pouvez utiliser des attributs d'accès object._className__attrName, le code suivant va remplacer la dernière ligne de code au- dessus du code:

.........................
print counter._JustCounter__secretCount

Exécuter le code ci-dessus, des résultats d'exécution sont les suivantes:

1
2
2
2