Il miglior tutorial Python object-oriented Nel 2024, in questo tutorial puoi imparare Object-Oriented Panoramica della tecnologia,Crea classe,Creare un'istanza di un oggetto,Proprietà di accesso,attributo di classe built-in Python,oggetto Python viene distrutto (raccolta dei rifiuti),eredità di classe,override del metodo,metodi Fondazione sovraccaricato,L'overloading degli operatori,attributi e metodi di classe,
Python è stato progettato fin dall'inizio è un linguaggio orientato agli oggetti, e come tale, creare una classe e gli oggetti in Python è molto facile. In questa sezione ci saranno i dettagli della programmazione orientata agli oggetti in Python.
Se non si è stati esposti a object-oriented linguaggio di programmazione, quindi potrebbe essere necessario prima capire alcune delle caratteristiche di base di linguaggi orientati agli oggetti, si formano nella mente all'interno di un concetto di base di object-oriented, che consente di imparare più facilmente la Python programmazione orientata agli oggetti.
Quindi, prendiamo un semplice comprensione di object-oriented in alcune caratteristiche di base.
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.
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
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)
È 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:
hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。 getattr(emp1, 'age') # 返回 'age' 属性的值 setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8 delattr(empl, 'age') # 删除属性 'age'
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>}
Come il linguaggio Java, Python usa riferimento contando questa semplice tecnica per tenere traccia degli oggetti in memoria.
In Python record interno di tutti gli oggetti utilizzando i rispettivi numeri di riferimento.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.
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,
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): // it. 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:
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, it.]): '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 itit. class B: # 定义类 B itit. class C(A, B): # 继承类 A 和 B itit.
È possibile utilizzare issubclass () o il metodo isinstance () per rilevare.
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:
调用子类方法
La seguente tabella elenca alcune delle caratteristiche comuni che è possibile sovrascrivere nella classe:
No. | Il metodo, descritto semplicemente chiamare & |
---|---|
1 | __init__ (self [, args it.] ) Basta chiamare ilmetododicostruzione:obj = className (args) |
2 | __del __ (self) Distruttori, eliminare un semplicechiamata almetodooggetto:dell obj |
3 | __repr __ (self) La conversione del modulo per l'interprete di leggere un metodo semplicechiamata:repr (obj) |
4 | __str __ (self) Per il valore in una forma adatta per la lettura umana un metodo semplicechiamata:str (obj) |
5 | __cmp__ (self, x) Oggetto metodo relativamente semplicechiamata:cmp (obj, x) |
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)
__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.
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
__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
#!/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:
itititititititititititit. print counter._JustCounter__secretCount
Eseguire il codice di cui sopra, i risultati di esecuzione sono i seguenti:
1 2 2 2