Python object-oriented

Object-Oriented Panoramica della tecnologia

• Class (Class): usato per descrivere la collezione hanno le stesse proprietà e metodi degli oggetti. Si definisce un insieme di proprietà e metodi comuni a ogni oggetto. Gli oggetti sono istanze di classi.
• variabili di classe: variabili di classe è comune in tutto l'oggetto istanziato. variabili classe definita e all'esterno della funzione nella classe. variabili di classe normalmente non utilizzati come variabili di istanza.
• i membri dati: variabili di classe o variabili di istanza per le classi di elaborazione dati associati e oggetti istanza.
• Sostituzioni: Se non è possibile soddisfare le esigenze di una sottoclasse eredita dalla metodo della classe genitore, può essere riscritta, un processo chiamato metodo di sovrapposizione (override), noto anche come il metodo prevalente.
• Esempi di variabili: variabili definite nel metodo, solo il ruolo della classe dell'istanza corrente.
• Ereditarietà: Questa è una classe derivata (classe derivata) eredita la classe di base () campi ei metodi della classe base. L'ereditarietà consente inoltre un oggetto di classe derivata come un oggetto di piacere classe base. Ad esempio, vi è un tale progetto: un tipo di oggetto che è derivata da una classe Animal Dog, che è un analogo "è un (è-a)" relazione (Fig esempio, è un animale Dog).
• Un'istanza: creare un'istanza di una classe, la classe di oggetto specifico.
• Metodi: Le funzioni di classe definite.
• Oggetto: dati di istanza struttura attraverso la definizione della classe. oggetti dati includono due membri (variabili di classe e di istanza) e metodi.

Crea classe

Utilizzare l'istruzione di classe per creare una nuova classe, dopo le lezioni, e il nome della classe termina con i due punti, i seguenti esempi:

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

classe di Guida può essere visualizzato NomeClasse .__ doc__.

class_suite composto da membri della classe, il metodo, gli attributi dei dati.

Esempi

Quanto segue è un semplice esempio di classe Python:

#!/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

• variabile empCount è una variabile di classe, il suo valore sarà condivisa tra tutte le istanze di questa classe. È possibile utilizzare l'accesso Employee.empCount all'interno della classe o di classe al di fuori.
• Il metodo primo metodo __init __ () è un metodo speciale metodo, costruttore o l'inizializzazione della classe viene chiamato quando si crea un'istanza di questa classe chiamerà il metodo

Creare un'istanza di un oggetto

Per creare un'istanza di una classe, è possibile utilizzare il nome della classe, e ad accettare il metodo parametri __init__.

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

Proprietà di accesso

È possibile utilizzare il punto (.) Proprietà per accedere all'oggetto. Accesso a una variabile di classe con il nome della classe come segue:

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

esempio completo:

#!/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

Eseguire il codice sopra risultati di output sono i seguenti:

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

È possibile aggiungere, eliminare, modificare le proprietà della classe come segue:

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

È inoltre possibile accedere alle proprietà utilizzare le seguenti funzioni:

• getattr (obj, nome [, default]): gli oggetti di accesso di proprietà.
• hasattr (obj, nome): verificare se vi è un attributo.
• setattr (obj, nome, valore): impostare una proprietà. Se la proprietà non esiste, creare una nuova proprietà.
• delattr (obj, nome): eliminare gli attributi.

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

attributo di classe built-in Python

• __dict__: attributi della classe (tra cui un dizionario, l'attributo dati di composizione di classe)
• __doc__: classe String documento
• __name__: nome della classe
• __module__: modulo in cui la definizione di classe (il nome completo è '. __main __ className', se la classe si trova in una mymod modulo importato, quindi className .__ module__ pari mymod)
• __bases__: Tutte le classi dell'elemento genitore (che comprendono una classe genitore costituita da tutte le tuple)

Python chiama il built-in esempi di attributi di classe sono i seguenti:

#!/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__

Eseguire il codice sopra risultati di output sono i seguenti:

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

oggetto Python viene distrutto (raccolta dei rifiuti)

Come il linguaggio Java, Python usa riferimento contando questa semplice tecnica per tenere traccia degli oggetti in memoria.

Un variabili di monitoraggio interne, chiamato un contatore di riferimento.

Quando viene creato un oggetto, si crea un conteggio di riferimento, quando non è più necessario l'oggetto, vale a dire, un riferimento conteggio oggetto diventa 0, è garbage collection. Ma il recupero non è "immediatamente" dall'interprete al momento opportuno, gli oggetti immondizia occupano memoria recupero dello spazio.

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

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

meccanismo di garbage collection non solo per il conteggio oggetto di riferimento è 0, lo stesso può anche gestire il caso di riferimenti circolari. Si riferisce ad un riferimento circolare, due oggetti si riferiscono a vicenda, ma nessun altro li riferimenti variabili. In questo caso, solo il numero di riferimento non è sufficiente. garbage collector di Python è in realtà un riferimento a un contatore di cicli e il garbage collector. Come integrativo conteggio di riferimento garbage collector pagherà attenzione alla quantità totale allocato oggetti di grandi dimensioni (e senza contare quelle distrutte per riferimento). In questo caso, l'interprete farà una pausa, cercando di ripulire tutto il ciclo senza riferimenti.

Esempi

Destructor __del__, __ del__ viene chiamato quando l'oggetto viene distrutto, quando l'oggetto non viene più utilizzato, __ metodo del__ per eseguire:

#!/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

Esempi dei risultati di cui sopra sono i seguenti:

3083401324 3083401324 3083401324
Point 销毁

Nota: Di solito è necessario definire una classe in un file separato,

eredità di classe

Uno dei principali vantaggi della programmazione orientata agli oggetti è portato a riutilizzare il riutilizzo del codice per ottenere uno di questi è attraverso il meccanismo di ereditarietà. Ereditato tipo e sottotipo del tutto comprensibile rapporto tra classi in.

Caveat: classe Ereditarietà Sintassi nome della classe derivata (il nome della classe base): // ... scrivendo il nome della classe di base tra parentesi, quando la classe base è la definizione della classe, tra tuple specificate.

In pitone successione di alcune delle caratteristiche:

• 1: Nel seguente configurazione (metodo __init __ ()) classe Cheng Zhongji non verrà richiamato automaticamente, richiede specializzata personalmente chiamato nel costruttore della sua classe derivata.
• 2: Quando si chiama il metodo della classe base, è necessario aggiungere il nome della classe del prefisso della classe base, e la necessità di portare le variabili dei parametri di sé. Non è necessario portare il parametro auto è diversa dalla chiamata di funzione ordinaria nella classe
• 3: Python sempre prima trovare il corrispondente tipo di approccio, se non riesce a trovare il metodo corrispondente in una classe derivata, ha cominciato a guardare uno per uno per la classe di base. (Prima le chiamate di metodo di trovare in questa classe, solo per trovare per trovare la classe base).

Se la colonna più di una classe nella tupla eredità, allora è chiamata "ereditarietà multipla."

sintassi:

Dichiarazione della classe derivata, simile alla loro classe genitore, quindi ereditare la classe base lista con il nome della classe, come segue:

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

esempio:

#!/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()          # 再次调用父类的方法

Il codice di cui sopra viene eseguita come segue:

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

È possibile ereditare più classi

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

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

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

È possibile utilizzare issubclass () o il metodo isinstance () per rilevare.

• issubclass () - funzione booleana per determinare se una classe è una sottoclasse di un'altra classe o di sintassi classe discendente: issubclass (sub, sup)
• isinstance (obj, Class) funzione booleana se obj è un'istanza di una classe di oggetti o di istanza di una classe oggetto di classe è una sottoclasse ritorna vero.

override del metodo

Se la funzione sei il metodo della classe genitore non può soddisfare le vostre esigenze, è possibile riscrivere il metodo classe padre in una sottoclasse:

esempio:

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

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

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

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

Eseguire il codice sopra risultati di output sono i seguenti:

调用子类方法

metodi Fondazione sovraccaricato

La seguente tabella elenca alcune delle caratteristiche comuni che è possibile sovrascrivere nella classe:

L'overloading degli operatori

Python supporta anche l'overloading degli operatori, gli esempi sono i seguenti:

#!/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

I risultati di esecuzione sopra codici sono i seguenti:

Vector(7,8)

attributi e metodi di classe

Classe Proprietà privata

__private_attrs: a cominciare due sottolineature affermando che la proprietà è privata e non può essere utilizzato o accedere direttamente nella classe esternamente. Self .__ private_attrs quando utilizzato all'interno di un metodo di classe.

I metodi di classe

Nell'interno terrestre, uso def parola chiave può essere definito come un metodo di classe con la definizione generale delle diverse funzioni, metodi di classe devono includere il parametro sé, e come primo parametro

metodi privati ​​della classe

__private_method: i primi due di sottolineatura, il metodo è dichiarato come metodi privati della classe non possono chiamare dall'esterno. Le chiamate private_methods self .__ all'interno della classe

Esempi

#!/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 cambiando il nome per includere il nome della 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 non è consentito l'accesso classe istanziata dati privati, ma è possibile utilizzare attributi di accesso object._className__attrName, il seguente codice sostituirà l'ultima riga di codice sopra il codice:

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

Eseguire il codice di cui sopra, i risultati di esecuzione sono i seguenti:

1
2
2
2