溫馨提示×
您好，登錄后才能下訂單哦！
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
面向?qū)ο缶幊蹋∣bject Oriented Programing，OOP）是一種編程思想，OOP把對(duì)象當(dāng)成程序的一個(gè)基本單元，一個(gè)對(duì)象包含數(shù)據(jù)和操作數(shù)據(jù)的方法。面向?qū)ο缶幊痰娜筇匦匀缦拢?br/>A、封裝，可以隱藏實(shí)現(xiàn)細(xì)節(jié)，使代碼模塊化。
B、繼承，可以通過(guò)擴(kuò)展已存在的類來(lái)實(shí)現(xiàn)代碼重用，避免重復(fù)編寫(xiě)相同的代碼。
C、多態(tài)，封裝和繼承的目的都是為了實(shí)現(xiàn)代碼重用， 而多態(tài)是為了實(shí)現(xiàn)接口重用，使得類在繼承和派生的時(shí)候能夠保證任何一個(gè)類的實(shí)例都能正確調(diào)用約定好的屬性和方法。
面向?qū)ο缶幊掏ㄟ^(guò)封裝、繼承、多態(tài)實(shí)現(xiàn)了軟件工程的重用性、靈活性、擴(kuò)展性三個(gè)目標(biāo)。
類(Class)是用來(lái)描述具有相同的屬性和方法的對(duì)象的集合，定義了集合中每個(gè)對(duì)象所共有的屬性和方法。
對(duì)象是類的實(shí)例，Python中對(duì)象包括兩個(gè)數(shù)據(jù)成員（類變量和實(shí)例變量）和方法。
方法是類中定義的函數(shù)。
類變量在類的所有實(shí)例化對(duì)象中是公用的。類變量定義在類中且在函數(shù)體外。
方法重寫(xiě)：如果從父類繼承的方法不能滿足子類的需求，可以對(duì)其進(jìn)行重寫(xiě)（override）。
繼承是一個(gè)派生類（derived class）繼承基類（base class）的字段和方法。繼承允許把一個(gè)派生類的對(duì)象作為一個(gè)基類對(duì)象對(duì)待。
實(shí)例化：創(chuàng)建一個(gè)類的實(shí)例，類的具體對(duì)象。
在python當(dāng)中一切皆對(duì)象，每個(gè)對(duì)象都有三個(gè)屬性:id、類型type和數(shù)值。id是對(duì)象的地址，id相同則必為同一對(duì)象，不同對(duì)象的值可以相同。
# -*- coding:utf-8 -*-
x = 10
print(id(x))
print(type(x)) # <class 'int'>
print(x)
y = 10
print(id(y))
print(type(y)) # <class 'int'>
print(y)
print(x is y) # True類是一種抽象數(shù)據(jù)類型，是對(duì)現(xiàn)實(shí)世界的一類數(shù)據(jù)及其操作的封裝。
類定義語(yǔ)法格式如下：
class ClassName:
<statement-1>
.
.
.
<statement-N>類實(shí)例化后，可以使用其屬性，創(chuàng)建一個(gè)類后，可以通過(guò)類名訪問(wèn)其類屬性。
Person類有以下3個(gè)屬性：
nationality：國(guó)籍
name：姓名
id：×××號(hào)碼
import uuid
class Person:
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))所有人的國(guó)籍基本都是相同的，且允許直接通過(guò)類或?qū)嵗齺?lái)訪問(wèn)，允許隨意修改。
大部分人的姓名是不同的，且允許直接通過(guò)類的實(shí)例來(lái)訪問(wèn)和隨意修改。
所有人的×××號(hào)碼都是不一樣的，且不允許直接通過(guò)類或?qū)嵗齺?lái)訪問(wèn)或隨意修改。
import Person
bauer = Person.Person("Bauer")
bauer.hello()Python中默認(rèn)所有的成員都是公有成員，但私有成員是以兩個(gè)下劃線開(kāi)頭的名字表示私有成員，私有成員不允許直接訪問(wèn)，只能通過(guò)內(nèi)部方法進(jìn)行訪問(wèn)，私有成員也不允許被繼承。
Python中通過(guò)在類變量、實(shí)例變量、類方法、實(shí)例方法前加__前綴，可以將其對(duì)外進(jìn)行隱藏，變?yōu)轭惖乃接凶兞炕蚝瘮?shù)。由于Python中內(nèi)置變量或函數(shù)使用__前后綴，因此，不推薦私有的變量或函數(shù)加__前后綴，只加__前綴。
Python作為動(dòng)態(tài)語(yǔ)言，允許類或?qū)嵗齽?dòng)態(tài)增加屬性，與類內(nèi)部的私有的屬性并不相同。
Python類維護(hù)了一個(gè)用于保存類的數(shù)據(jù)的字典，字典內(nèi)部Python將私有成員改名為_ClassName + __variable_name，因此在類外通過(guò)訪問(wèn)私有變量新的名稱可以訪問(wèn)相應(yīng)的私有變量。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
print(bauer.__dict__)
print(bauer._Person__id)
"""
output:
{'name': 'Bauer', '_Person__id': 'ed496846-94c7-11e9-80c4-5ce0c5e8bcf0'}
ed496846-94c7-11e9-80c4-5ce0c5e8bcf0
"""直接定義在class下的屬性是公有屬性/類屬性，類屬性是類的所有實(shí)例對(duì)象共同所有的，因此默認(rèn)情況下類屬性值只會(huì)保留一份，而不會(huì)為類的每個(gè)實(shí)例都保存一份。
類屬性可以使用ClassName.VariableName訪問(wèn)，在實(shí)例方法內(nèi)部也可以使用self.__class__.VariableName進(jìn)行訪問(wèn)。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def sayHello(self):
print("Hello,I come from %s" % self.__class__.nationality)
if __name__ == "__main__":
bauer = Person("Bauer")
bauer.sayHello()
jack = Person("Jack")
print(Person.nationality, bauer.nationality, jack.nationality)
bauer.nationality = "USA"
print(Person.nationality, bauer.nationality, jack.nationality)
Person.nationality = "Germany"
print(Person.nationality, bauer.nationality, jack.nationality)
"""
output:
Hello,I come from China
China China China
China USA China
Germany USA Germany
"""類屬性可以通過(guò)類直接訪問(wèn)，也可以直接通過(guò)實(shí)例進(jìn)行訪問(wèn)； 如果通過(guò)類的某個(gè)實(shí)例對(duì)類屬性進(jìn)行修改，本質(zhì)上是為該實(shí)例添加了一個(gè)與類屬性名稱相同的實(shí)例屬性，對(duì)真正的類屬性沒(méi)有影響，因此不會(huì)影響其它實(shí)例獲取類屬性的值； 通過(guò)類對(duì)類屬性進(jìn)行修改，必然會(huì)改變類屬性的值，對(duì)類的所有實(shí)例是都有影響的。
實(shí)例屬性又稱成員屬性或成員變量，是類的每個(gè)實(shí)例對(duì)象單獨(dú)持有的屬性。實(shí)例屬性必須在類的init方法中進(jìn)行聲明。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
jack = Person("Jack")
print(bauer.name, jack.name)
bauer.name = "Jack Bauer"
jack.name = "Chen Jack"
print(bauer.name, jack.name)
#print(Person.name) ## AttributeError: type object 'Person' has no attribute 'name'
"""
output:
Bauer Jack
Jack Bauer Chen Jack
"""通過(guò)類訪問(wèn)成員屬性會(huì)報(bào)錯(cuò)：
print(Person.name)
實(shí)例屬性可以直接通過(guò)實(shí)例對(duì)象來(lái)訪問(wèn)和更改，是每個(gè)實(shí)例對(duì)象獨(dú)有的，某個(gè)實(shí)例對(duì)象的實(shí)例屬性被更改不會(huì)影響其它實(shí)例對(duì)象的相同屬性的值。實(shí)例屬性的值不能通過(guò)類來(lái)訪問(wèn)和修改。
Python作為動(dòng)態(tài)語(yǔ)言，可以在類外部動(dòng)態(tài)增加實(shí)例對(duì)象的屬性。
私有屬性和實(shí)例屬性必須在__init__方法中進(jìn)行聲明，但私有屬性的屬性名需要以雙下劃線__開(kāi)頭，比如Person中的__id屬性。私有屬性是一種特殊的實(shí)例屬性，只允許在實(shí)例對(duì)象的內(nèi)部（成員方法或私有方法中）訪問(wèn)，而不允許在實(shí)例對(duì)象的外部通過(guò)實(shí)例對(duì)象或類來(lái)直接訪問(wèn)，也不能被子類繼承。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
bauer.hello()
# print(bauer.__id) # AttributeError: 'Person' object has no attribute '__id'
# print(Person.__id) # AttributeError: type object 'Person' has no attribute '__id'
"""
output:
Hello, I am Bauer, I come from China, My ID is c0c02dcc-94aa-11e9-972c-5ce0c5e8bcf0
"""私有屬性不能通過(guò)類直接訪問(wèn)，也不能通過(guò)實(shí)例對(duì)象直接訪問(wèn)，但私有屬性可以通過(guò)成員方法進(jìn)行訪問(wèn)。
私有屬性可以通過(guò)成員方法或是實(shí)例對(duì)象._類名__私有變量名的方式來(lái)訪問(wèn)。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def get_id(self):
return self.__id
if __name__ == "__main__":
bauer = Person("Bauer")
bauer.hello()
print(bauer._Person__id)
print(bauer.get_id())
"""
output:
Hello, I am Bauer, I come from China, My ID is c0c02dcc-94aa-11e9-972c-5ce0c5e8bcf0
354547ae-94ab-11e9-a52c-5ce0c5e8bcf0
354547ae-94ab-11e9-a52c-5ce0c5e8bcf0
"""Python的類中有一些內(nèi)置的、特殊的屬性，其名稱以雙下劃線__開(kāi)頭且以雙下劃線__結(jié)尾。特殊屬性不是私有屬性，可以在類的外部通過(guò)實(shí)例對(duì)象去直接訪問(wèn)，且都有著各自特殊的意義。__doc__表示類的描述信息。__module__表示當(dāng)前操作的對(duì)象對(duì)應(yīng)的類的定義所在的模塊名。__class__表示當(dāng)前操作的對(duì)象對(duì)應(yīng)的類名。__dict__是一個(gè)字典，保存類的所有的成員（包括屬性和方法）或?qū)嵗龑?duì)象中的所有成員屬性。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def __hello(self): # 私有方法
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def say_hello(self): # 成員方法/實(shí)例方法
self.__hello()
@classmethod
def get_nationality(cls): # 類方法
return cls.nationality
@staticmethod
def add(a, b): # 靜態(tài)方法
return a + b
@property
def id(self):
return self.__id
if __name__ == "__main__":
bauer = Person("Bauer")
print("Person Object")
print(bauer.__class__)
print(bauer.__doc__)
print(bauer.__dict__)
print(bauer.__module__)
print("Person Class")
print(Person.__class__)
print(Person.__doc__)
print(Person.__dict__)
print(Person.__module__)
"""
output:
Person Object
<class '__main__.Person'>
None
{'name': 'Bauer', '_Person__id': 'f545f99a-94b5-11e9-aa3f-5ce0c5e8bcf0'}
__main__
Person Class
<class 'type'>
None
{'__module__': '__main__', 'nationality': 'China', '__init__': <function Person.__init__ at 0x7f49941d5d90>, '_Person__hello': <function Person.__hello at 0x7f49941d5e18>, 'say_hello': <function Person.say_hello at 0x7f49941d5ea0>, 'get_nationality': <classmethod object at 0x7f499b470be0>, 'add': <staticmethod object at 0x7f499b470c18>, 'id': <property object at 0x7f499b464908>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
__main__
"""實(shí)例對(duì)象.__dict__和 類.__dict__的值是不同的，實(shí)例對(duì)象.__dict__的值中只包含成員屬性和私有屬性，類.__dict__的值中包含類的類屬性和所有方法；__module__和__class__的值可用于反射來(lái)實(shí)例化一個(gè)類的對(duì)象。
成員方法通過(guò)類的實(shí)例對(duì)象去訪問(wèn)，第一個(gè)參數(shù)必須是當(dāng)前實(shí)例對(duì)象，通常寫(xiě)為self；但也可以通過(guò)類名來(lái)調(diào)用成員方法，此時(shí)需要手動(dòng)的傳遞一個(gè)類的實(shí)例對(duì)象給成員方法的self參數(shù)。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
bauer.hello()
Person.hello(bauer)
"""
output:
Hello, I am Bauer, I come from China, My ID is 0e4d0606-94af-11e9-a958-5ce0c5e8bcf0
Hello, I am Bauer, I come from China, My ID is 0e4d0606-94af-11e9-a958-5ce0c5e8bcf0
"""私有方法是以雙下劃線開(kāi)頭的成員方法。私有方法只能在實(shí)例方法內(nèi)部訪問(wèn)，且不能被子類繼承；私有方法的第一個(gè)參數(shù)也必須是當(dāng)前實(shí)例對(duì)象本身，通常寫(xiě)為self。通常，前后加雙下劃線的命名方式用于Python內(nèi)置的方法，不推薦自定義方法使用。如果開(kāi)發(fā)者以前后加雙下劃線的方式命名成員方法，則相應(yīng)成員方法是公有的。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def __hello(self): # 私有方法
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def say_hello(self): # 成員方法/實(shí)例方法
self.__hello()
if __name__ == "__main__":
bauer = Person("Bauer")
bauer.say_hello()
"""
output:
Hello, I am Bauer, I come from China, My ID is 0e4d0606-94af-11e9-a958-5ce0c5e8bcf0
"""?類方法是以@classmethod來(lái)裝飾的成員方法，類方法要求第一個(gè)參數(shù)必須是當(dāng)前類。類方法可通過(guò)實(shí)例對(duì)象進(jìn)行訪問(wèn)，還可以直接通過(guò)類名去訪問(wèn)，且第一個(gè)參數(shù)表示的是當(dāng)前類，通常寫(xiě)為cls。類方法只能訪問(wèn)類屬性，不能訪問(wèn)實(shí)例屬性，因此第一個(gè)參數(shù)傳遞的是代表當(dāng)前類的cls，而不是表示實(shí)例對(duì)象的self。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def __hello(self): # 私有方法
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def say_hello(self): # 成員方法/實(shí)例方法
self.__hello()
@classmethod
def get_nationality(cls): # 類方法
return cls.nationality
if __name__ == "__main__":
bauer = Person("Bauer")
print(bauer.get_nationality())
print(Person.get_nationality())
"""
output:
China
China
"""靜態(tài)方法是以@staticmethod來(lái)裝飾的成員方法，靜態(tài)方法通常通過(guò)類名進(jìn)行訪問(wèn)，也可以通過(guò)類的實(shí)例對(duì)象進(jìn)行訪問(wèn)。本質(zhì)上，靜態(tài)方法已經(jīng)與類沒(méi)有任何關(guān)聯(lián)，因?yàn)殪o態(tài)方法不要求必須傳遞實(shí)例對(duì)象或類參數(shù)。
靜態(tài)方法內(nèi)部可以訪問(wèn)類變量，可以直接使用ClassName.Varaible_Name方式對(duì)類變量進(jìn)行訪問(wèn)。
靜態(tài)方法對(duì)參數(shù)沒(méi)有要求，因此可以任意給靜態(tài)方法定義參數(shù)，如果給靜態(tài)方法定義表示當(dāng)前類的參數(shù)，那么就可以訪問(wèn)類屬性；如果給靜態(tài)方法定義了表示當(dāng)前類的實(shí)例對(duì)象的參數(shù)，那么就可以訪問(wèn)實(shí)例屬性；如果沒(méi)有給靜態(tài)方法定義當(dāng)前類參數(shù)或當(dāng)前實(shí)例參數(shù)，那么就不能訪問(wèn)類或?qū)嵗龑?duì)象的任何屬性。
import uuid
class Person(object):
sum = 0
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
Person.sum += 1
def __hello(self): # 私有方法
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def say_hello(self): # 成員方法/實(shí)例方法
self.__hello()
@classmethod
def get_nationality(cls): # 類方法
return cls.nationality
@staticmethod
def add(a, b): # 靜態(tài)方法
return a + b
@staticmethod #靜態(tài)方法，內(nèi)部使用類變量
def counter():
return Person.sum
@staticmethod
def get_counter(cls): #靜態(tài)方法，傳遞當(dāng)前類
return cls.sum
if __name__ == "__main__":
bauer = Person("Bauer")
print(bauer.add(1, 2))
print(Person.add(1, 2))
print(Person.counter())
print(Person.get_counter(Person))
"""
output:
3
3
1
1
"""屬性方法是以@property來(lái)裝飾的成員方法，是以訪問(wèn)實(shí)例屬性的方式對(duì)實(shí)例屬性進(jìn)行訪問(wèn)的成員方法；屬性方法第一個(gè)參數(shù)必須是當(dāng)前實(shí)例對(duì)象，且屬性方法必須要有返回值。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def __hello(self): # 私有方法
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
def say_hello(self): # 成員方法/實(shí)例方法
self.__hello()
@classmethod
def get_nationality(cls): # 類方法
return cls.nationality
@staticmethod
def add(a, b): # 靜態(tài)方法
return a + b
@property
def id(self):
return self.__id
if __name__ == "__main__":
bauer = Person("Bauer")
print(bauer.id)
# print(bauer.id()) # TypeError: 'str' object is not callable
"""
output:
631baef4-94b3-11e9-babe-5ce0c5e8bcf0
"""Python中屬性方法通常用于在屬性方法內(nèi)部進(jìn)行一系列的邏輯計(jì)算，最終將計(jì)算結(jié)果返回。
類內(nèi)部定義的方法，在沒(méi)有被任何裝飾器修飾的情況下，是為了綁定到對(duì)象的，self關(guān)鍵字含有自動(dòng)傳值的過(guò)程，不管寫(xiě)不寫(xiě)self。 默認(rèn)情況下，在類內(nèi)部定義的方法都是綁定到對(duì)象的方法。 綁定方法綁定到誰(shuí)的身上，誰(shuí)就作為第一個(gè)參數(shù)進(jìn)行傳入，綁定到類的方法給對(duì)象使用是沒(méi)有任何意義的。
綁定到對(duì)象的方法，調(diào)用的時(shí)候會(huì)將對(duì)象參數(shù)自動(dòng)傳入；綁定到類的方法，調(diào)用的時(shí)候會(huì)將類作為參數(shù)自動(dòng)傳入。
靜態(tài)方法是非綁定方法，不與類或?qū)ο蠼壎?，誰(shuí)都可以調(diào)用，沒(méi)有自動(dòng)傳值效果。非綁定方法不與類或?qū)ο蠼壎?，類和?duì)象都可以調(diào)用，但沒(méi)有自動(dòng)傳值。
# -*- coding:utf-8 -*-
import time
import hashlib
import pickle
import os
"""
HOST = "127.1.1.1"
PORT = 3306
DB_PATH = r"/usr/lib/mysql/db"
"""
class MySQL:
HOST = "127.1.1.1"
PORT = 3306
DB_PATH = r"/var/lib/mysql"
@staticmethod
def create_id():
m = hashlib.md5(str(time.perf_counter()).encode("utf-8"))
return m.hexdigest()
def __init__(self,host,port):
self.id = self.create_id()
self.host = host
self.port = port
@classmethod
def from_conf(cls):
return cls.HOST, cls.PORT
def save(self):
file_path = r"%s%s%s"%(MySQL.DB_PATH,os.sep,self.id)
#將對(duì)象以二進(jìn)制的形式寫(xiě)到磁盤
pickle.dump(self,open(file_path,"wb"))
def get(self):
file_path = r"%s%s%s" % (MySQL.DB_PATH, os.sep, self.id)
return pickle.load(open(file_path,"rb"))
if __name__ == '__main__':
conn1 = MySQL("127.0.0.1","3306")
print(conn1.id)
conn1.save()
result = conn1.get()
print(result.id)Python的類中有一些內(nèi)置的、特殊的方法，其名稱是以雙下劃線__開(kāi)頭且以雙下劃線__結(jié)尾。特殊方法不是私有方法，可以在類的外部通過(guò)實(shí)例對(duì)象去直接訪問(wèn)，且都有著各自特殊的意義。
__init__方法是類構(gòu)造函數(shù)，是類的特殊的方法，在創(chuàng)建類對(duì)象時(shí)自動(dòng)調(diào)用，不能有返回值。定義如下：
def __init__(self):
pass__init__方法的第一個(gè)參數(shù)必須是創(chuàng)建的實(shí)例本身，通常推薦使用self。類的實(shí)例屬性、私有屬性必須在__init__方法進(jìn)行聲明。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
print(self.name, "__init__")
if __name__ == "__main__":
bauer = Person("Bauer")
"""
output:
Bauer __init__
"""__del__是類的析構(gòu)方法，當(dāng)對(duì)象在內(nèi)存中被釋放，會(huì)自動(dòng)觸發(fā)執(zhí)行__del__方法，如實(shí)例對(duì)象的作用域退出時(shí)，或者執(zhí)行?del 實(shí)例對(duì)象操作時(shí)。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
print(self.name, "__init__")
def __del__(self):
print(self.name, "__del__")
if __name__ == "__main__":
bauer = Person("Bauer")
del bauer
"""
output:
Bauer __init__
Bauer __del__
"""如果類中定義了__str__方法，那么在打印對(duì)象時(shí)默認(rèn)輸出__str__方法的返回值，否則會(huì)打印出實(shí)例對(duì)象的內(nèi)存地址。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
print(self.name, "__init__")
def __del__(self):
print(self.name, "__del__")
def __str__(self):
return "name: %s, nationality: %s, id: %s" % (self.name, self.nationality, self.__id)
if __name__ == "__main__":
bauer = Person("Bauer")
print(bauer)
"""
output:
Bauer __init__
name: Bauer, nationality: China, id: 0a9a80c2-94c0-11e9-891d-5ce0c5e8bcf0
Bauer __del__
"""__setitem__、__getitem__、__delitem__?用于索引操作，如對(duì)字典的操作，分別表示設(shè)置、獲取、刪除某個(gè)條目、數(shù)據(jù)?？梢酝ㄟ^(guò)__setitem__，__getitem__、__delitem__方法來(lái)定義一個(gè)類對(duì)字典進(jìn)行封裝，從而可以對(duì)字典中key的操作進(jìn)行控制，尤其是刪除操作。
如果一個(gè)類實(shí)現(xiàn)了__setitem__，__getitem__、__delitem__方法，就可以執(zhí)行一些字典操作。
class ChineseDict(object):
def __init__(self, init=None):
self.__dict = init if init is not None else {}
def __setitem__(self, key, value):
print('__setitem__', key)
self.__dict[key] = value
def __getitem__(self, item):
print('__getitem__', item)
return self.__dict.get(item, None)
def __delitem__(self, key):
print('__delitem__', key)
if key is not None and key.startswith('wh'):
print('You can not delete this item ')
return None
return self.__dict.pop(key, None)
if __name__ == "__main__":
dic = ChineseDict(init={'name': 'Bauer', 'nationality': 'China', "age": 23})
print(dic["name"], dic["nationality"], dic["age"])
del dic["age"]
print(dic["age"])
"""
output:
__getitem__ name
__getitem__ nationality
__getitem__ age
Bauer China 23
__delitem__ age
__getitem__ age
None
"""__new__方法會(huì)在__init__方法前被執(zhí)行，會(huì)創(chuàng)建并返回一個(gè)新的實(shí)例對(duì)象，然后傳遞給__init__。__new__不是一個(gè)成員方法，而是一個(gè)靜態(tài)方法。
在Python中，一切皆對(duì)象，在新式類中，為了將類型（int，str，float等）和類統(tǒng)一，所有的類都是type類型的對(duì)象。在類中有一個(gè)屬性 __metaclass__可以指定當(dāng)前類由哪個(gè)類進(jìn)行實(shí)例化。而創(chuàng)建對(duì)象過(guò)程中，構(gòu)造函數(shù)不是__init__方法，而是__new__方法，__new__方法會(huì)返回一個(gè)對(duì)象，即對(duì)象構(gòu)造函數(shù)。
類實(shí)例化對(duì)象內(nèi)部實(shí)現(xiàn)過(guò)程的代碼段：
class PersonType(type):
def __init__(cls, what, bases=None, dic=None):
super(PersonType, cls).__init__(what, bases, dic)
def __call__(cls, *args, **kwargs):
obj = cls.__new__(cls)
cls.__init__(obj, *args, **kwargs)
return obj
class Dog:
__metaclass__ = PersonType
def __init__(self,name,age):
self.name=name
self.age=age
def __new__(cls, *args, **kwargs):
return object.__new__(cls)
if __name__ == "__main__":
obj = Dog("Dog", 3)
print(obj.name, obj.age)
"""
output:
Dog 3
"""類中定義__call__方法時(shí)，類對(duì)象實(shí)例可以作為一個(gè)函數(shù)去調(diào)用，而函數(shù)的調(diào)用方式是函數(shù)名()。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def __call__(self, *args, **kwargs):
print("name: ", self.name, "args: ", *args)
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
bauer("China", 26)
"""
output:
name: Bauer args: China 26
"""Python中類的繼承按照父類中的方法是否已實(shí)現(xiàn)可分為兩種：
實(shí)現(xiàn)繼承?：指直接繼承父類的屬性和已定義并實(shí)現(xiàn)的的方法；
接口繼承?：僅繼承父類類的屬性和方法名稱，子類必須自行實(shí)現(xiàn)方法的具體功能代碼。
如果是根據(jù)要繼承的父類的個(gè)數(shù)來(lái)分，有可以分為：
單繼承：?只繼承1個(gè)父類。
多繼承：?繼承多個(gè)父類。
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print('%s is walking...' % self.name)
def talk(self):
print('%s is talking...' % self.name)
class Teacher(Person):
def __init__(self, name, age, level, salary):
super(Teacher, self).__init__(name, age)
self.level = level
self.salary = salary
def teach(self):
print('%s is teaching...' % self.name)
class Student(Person):
def __init__(self, name, age, class_):
Person.__init__(self, name, age)
self.class_ = class_
def study(self):
print('%s is studying...' % self.name)
if __name__ == "__main__":
t1 = Teacher('Bauer', 33, 'Senior', 20000)
s1 = Student('Jack', 13, 'A class')
t1.talk()
t1.walk()
t1.teach()
s1.talk()
s1.walk()
s1.study()
"""
output:
Bauer is talking...
Bauer is walking...
Bauer is teaching...
Jack is talking...
Jack is walking...
Jack is studying...
"""Teacher類 和Student類都繼承 Person類，因此Teacher和Student是Person的子類/派生類，而Person是Teacher和Student的父類/基類/超類；
Teacher和Student對(duì)Person的繼承屬于實(shí)現(xiàn)繼承，且是單繼承；
Teacher類繼承了Person的name和age屬性，及talk()和walk()方法，并擴(kuò)展了自己的level和salary屬性，及teach()方法；
Student類繼承了Person的name和age屬性，及talk()和walk()方法，并擴(kuò)展了自己的class屬性，及study()方法；
Teacher和Student對(duì)Person類屬性和方法繼承體現(xiàn)了 代碼的重用性， 而Teacher和Student擴(kuò)展的屬性和方法體現(xiàn)了 靈活的擴(kuò)展性；
子類 Teacher 和 Student 也可以在自己的類定義中重新定義父類中的talk()和walk()方法，改變其實(shí)現(xiàn)代碼，即方法重寫(xiě)override。
派生類的構(gòu)造函數(shù)需要顯式調(diào)用父類的構(gòu)造函數(shù)，對(duì)父類的屬性成員進(jìn)行初始化，調(diào)用父類的構(gòu)造函數(shù)時(shí)需要顯式傳遞實(shí)例對(duì)象self。
子類需要在自己的__init__方法中的第一行位置調(diào)用父類的構(gòu)造方法，上述代碼給出了兩種方法：super(子類名, self).__init__(父類構(gòu)造參數(shù))，如super.(Teacher, self).__init__(name, age)，推薦方式。父類名.__init__(self, 父類構(gòu)造參數(shù))，如Person.__init__(self, name, age)。
isinstance可以判斷一個(gè)變量是否是某一種數(shù)據(jù)類型，也可以判斷對(duì)象是否是類的對(duì)象或者是類的子類對(duì)象。
issubclass用來(lái)判斷一個(gè)類是否是某個(gè)類的子類，返回的是一個(gè)bool類型數(shù)據(jù)。
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
class Teacher(Person):
pass
if __name__ == "__main__":
bauer = Teacher("Bauer")
print(isinstance(bauer, Person))
print(issubclass(Teacher, Person))
"""
output:
True
True
"""?Python支持多層父類繼承，子類會(huì)繼承父類所有的屬性和方法，包括父類的父類的所有屬性和方法。Python雖然支持多繼承，但Python對(duì)多繼承的支持的也是有限的。
多繼承時(shí)，使用super只會(huì)調(diào)用第一個(gè)父類的屬性方法，因此，要想調(diào)用特定父類的構(gòu)造器只能顯式調(diào)用父類名.__init__。
如果父類中有相同的方法名，而在子類使用時(shí)未顯式指定調(diào)用的具體賦類的方法，Python會(huì)根據(jù)繼承順序從左至右搜索查找父類中是否包含方法。
class A(object):
def __init__(self):
print("class A")
def hello(self):
print('hello, class A')
def func2(self):
print('class A: func2')
class B(A):
def __init__(self):
A.__init__(self)
print("class B")
def hello(self):
print('hello, class B')
class C(A):
def __init__(self):
A.__init__(self)
print("class C")
def hello(self):
print('hello, class C')
class D(B, C):
def __init__(self):
B.__init__(self)
C.__init__(self)
print("class D")
if __name__ == "__main__":
d = D()
d.hello()
print(D.mro())
"""
output:
class A
class B
class A
class C
class D
hello, class B
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
"""如果子類從多個(gè)父類派生，而子類沒(méi)有自己的構(gòu)造函數(shù)時(shí)，按順序繼承，哪個(gè)父類在最前面且有自己的構(gòu)造函數(shù)，就繼承其構(gòu)造函數(shù)。
class A(object):
def __init__(self):
print("class A")
def hello(self):
print('hello, class A')
def func2(self):
print('class A: func2')
class B(A):
def __init__(self):
A.__init__(self)
print("class B")
def hello(self):
print('hello, class B')
class C(A):
def __init__(self):
A.__init__(self)
print("class C")
def hello(self):
print('hello, class C')
class D(B, C):
pass
if __name__ == "__main__":
d = D()
d.hello()
print(D.mro())
"""
output:
class A
class B
hello, class B
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
"""如果子類從多個(gè)父類派生，而子類沒(méi)有自己的構(gòu)造函數(shù)時(shí)，如果最前面第一個(gè)父類沒(méi)有構(gòu)造函數(shù)，則依次查找后序繼承父類的構(gòu)造函數(shù)。
class A(object):
def __init__(self):
print("class A")
def hello(self):
print('hello, class A')
def func2(self):
print('class A: func2')
class B(A):
def hello(self):
print('hello, class B')
class C(A):
def __init__(self):
A.__init__(self)
print("class C")
def hello(self):
print('hello, class C')
class D(B, C):
pass
if __name__ == "__main__":
d = D()
d.hello()
print(D.mro())
"""
output:
class A
class C
hello, class B
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
"""類的屬性__mro__或者方法mro()都能打印出類的繼承順序，super()在執(zhí)行時(shí)查找MRO列表，到列表當(dāng)前位置的類中去查找其下一個(gè)類。
為了實(shí)現(xiàn)繼承，Python會(huì)在MRO列表上從左到右開(kāi)始查找基類，直到找到第一個(gè)匹配屬性的類為止。
在Python 3.x中無(wú)論是否顯式指定繼承object，所有的類都是新式類，在多繼承的情況下，經(jīng)典類查找父類屬性或方法的順序是深度優(yōu)先，新式類查找父類屬性的順序是廣度優(yōu)先。
super是MRO中的一個(gè)類。MRO全稱Method Resolution Order，代表類的繼承順序。對(duì)于定義的每一個(gè)類，Python會(huì)計(jì)算出一個(gè)方法解析順序(MRO)列表，MRO列表是一個(gè)簡(jiǎn)單的所有基類的線性順序列表。
MRO列表的構(gòu)造是通過(guò)一個(gè)C3線性化算法來(lái)實(shí)現(xiàn)的，MRO會(huì)合并所有父類的MRO列表并遵循如下三條準(zhǔn)則:
A、子類會(huì)先于父類被檢查。
B、多個(gè)父類會(huì)根據(jù)它們?cè)诹斜碇械捻樞虮粰z查。
C、如果對(duì)下一個(gè)類存在兩個(gè)合法的選擇，選擇第一個(gè)父類。
MRO可以保證多繼承情況每個(gè)類只出現(xiàn)一次，super().init相對(duì)于類名.init，在單繼承上用法基本無(wú)差，但在多繼承上，super方法能保證每個(gè)父類的方法只會(huì)執(zhí)行一次，而使用類名的方法會(huì)導(dǎo)致方法被執(zhí)行多次。
單繼承時(shí)，使用super方法，不能全部傳遞，只能傳父類方法所需的參數(shù)，否則會(huì)報(bào)錯(cuò)；多繼承時(shí)，使用類名.init方法需要把每個(gè)父類全部寫(xiě)一遍，而使用super方法只需一條語(yǔ)句便執(zhí)行全部父類的方法，因此多繼承需要全部傳參。
九、類的多態(tài)性
多態(tài)通常是通過(guò)繼承接口的方式實(shí)現(xiàn)的，Python中沒(méi)有接口，但Python中可以通過(guò)在一個(gè)成員方法體中拋出一個(gè)NotImplementedError異常來(lái)強(qiáng)制繼承接口的子類在調(diào)用接口方法前必須先實(shí)現(xiàn)接口方法。
class Animal(object): # Animal Interface
def __init__(self, name):
self.name = name
def walk(self):
raise NotImplemented('Subclass must implement the abstract method by self')
def talk(self):
raise NotImplemented('Subclass must implement the abstract method by self')
class Dog(Animal):
def talk(self):
print('%s is talking：wang wang...' % self.name)
def walk(self):
print('%s is a Dog，walk by 4 legs' % self.name)
class Duck(Animal):
def talk(self):
print('%s is talking: ga ga...' % self.name)
def walk(self):
print('%s is a Duck，walk by 2 legs' % self.name)
if __name__ == "__main__":
dog = Dog('Trump')
dog.talk()
dog.walk()
duck = Duck('Tang')
duck.talk()
duck.walk()
"""
output:
Trump is talking：wang wang...
Trump is a Dog，walk by 4 legs
Tang is talking: ga ga...
Tang is a Duck，walk by 2 legs
"""接口的所有子類必須實(shí)現(xiàn)接口中定義的所有方法；接口的各個(gè)子類在實(shí)現(xiàn)接口中同一個(gè)方法時(shí)，具體的代碼實(shí)現(xiàn)各不相同，即多態(tài)。
Python中反射機(jī)制是通過(guò)hasattr、getattr、setattr、delattr四個(gè)內(nèi)置函數(shù)實(shí)現(xiàn)的，四個(gè)內(nèi)置函數(shù)不僅可以用在類和對(duì)象中，也可以用在模塊等。
hasattr(key)返回的是一個(gè)bool值，判斷某個(gè)成員或者屬性在不在類或者對(duì)象中。
getattr(key,default=xxx)獲取類或者對(duì)象的成員或?qū)傩?，如果不存在，則會(huì)拋出AttributeError異常，如果定義了default那么當(dāng)沒(méi)有屬性的時(shí)候會(huì)返回默認(rèn)值。
setattr(key,value)假如有key屬性，那么更新key屬性，如果沒(méi)有就添加key屬性并賦值value。
delattr(key)刪除某個(gè)屬性。
實(shí)例代碼如下：
import uuid
class Person(object):
nationality = "China"
def __init__(self, name):
self.name = name
self.__id = str(uuid.uuid1())
def hello(self):
print("Hello, I am %s, I come from %s, My ID is %s" %(self.name, self.nationality, self.__id))
if __name__ == "__main__":
bauer = Person("Bauer")
setattr(bauer, "sex", "Man")
print(getattr(bauer, "name"))
print(getattr(bauer, "nationality"))
print(getattr(bauer, "sex"))
helloFunc = getattr(bauer, "hello")
helloFunc()
if hasattr(bauer, "job"):
print(getattr(bauer, "job"))
delattr(bauer, "sex")
print(getattr(bauer, "name"))
print(getattr(bauer, "nationality"))
print(getattr(bauer, "sex")) # AttributeError: 'Person' object has no attribute 'sex'在面向?qū)ο缶幊讨?，單例模式是一個(gè)類只有一個(gè)對(duì)象，所有的操作都通過(guò)單例對(duì)象來(lái)完成，實(shí)現(xiàn)代碼如下：
class Instance:
__instance = None
@classmethod
def get_instance(cls):
if cls.__instance:
return cls.__instance
else:
cls.__instance = Instance
return cls.__instance
obj1 = Instance.get_instance()
print(id(obj1))
obj2 = Instance.get_instance()
print(id(obj2))
# output:
# 35307304
# 35307304Python中使用try except finally組合來(lái)實(shí)現(xiàn)異常撲捉，except中的Exception是所有異常的父類，異常處理的示例如下：
try:
int("12a") #可能出現(xiàn)異常的代碼
except IndexError as e: # 捕捉索引異常的子異常
print("IndexError:",e)
except ValueError as e: # 捕捉value錯(cuò)誤的子異常
print("ValueError:",e)
except Exception as e: # 使用Exception捕獲，Exception能夠捕獲所有的異常
print("Exception:",e)
else: # 如果沒(méi)有異常發(fā)生，執(zhí)行else中的代碼塊
print("true")
finally: # 不管是否發(fā)生異常，在最后都會(huì)執(zhí)行finally中的代碼，假如try里面的代碼正常執(zhí)行，先執(zhí)行else中的代碼，再執(zhí)行finally中的代碼
print("finally")Exception是所有異常的父類，可以自定義Exception的子類，實(shí)現(xiàn)自定義異常處理。
class TypeErrorException(Exception):
def __init__(self, message):
self.message = message
def __str__(self): # 打印異常的時(shí)候會(huì)調(diào)用對(duì)象里面的__str__方法返回一個(gè)字符串
return self.message
if __name__ == "__main__":
try:
raise TypeErrorException("Type error")
except TypeErrorException as e:
print("TypeErrorException:",e)
except Exception as e:
print("Exception:",e)
else:
print("true")
finally:
print("finally")斷言assert一般用在判斷執(zhí)行環(huán)境上，只要斷言的條件不滿足，就拋出異常，后續(xù)代碼不會(huì)被執(zhí)行。
print("Assert test")
ok = True
result = False
assert ok == result
print("Assert test")
# output:
"""
Assert test
Traceback (most recent call last):
File "test.py", line 6, in <module>
assert ok == result
AssertionError
"""免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如果涉及侵權(quán)請(qǐng)聯(lián)系站長(zhǎng)郵箱：is@yisu.com進(jìn)行舉報(bào)，并提供相關(guān)證據(jù)，一經(jīng)查實(shí)，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號(hào)
手機(jī)網(wǎng)站二維碼