Python進階–2

面向對象–基礎

• 引入理解

https://blog.csdn.net/shenzixincaiji/article/details/83576687

類、對象、屬性、方法

• 基礎

class student: # 類age = 18 # 類的屬性tall = 175phone = 'huawei'def sleep(self): # 類的方法print('正在睡覺')# basic # 對象lily和對象Tom繼承student類，兩者的數據id一致 lily = student() print(lily.age, lily.tall, lily.phone) print('lily.age的id:', id(lily.age)) lily.sleep() Tom = student() print(Tom.age, Tom.tall, Tom.phone) print('Tom.age的id:', id(Tom.age)) Tom.sleep()print('----------------------------------------') # change 類 student.age = 20 # 第一次改變類屬性，兩個對象的屬性也一起改變 print(lily.age, Tom.age) # 即對兩個對象都有影響 print(id(lily.age), id(Tom.age)) print('----------------------------------------')# change 對象lily lily.age = 19 # 改變對象lily的屬性（對象屬性），創建了動態的對象屬性與起綁定 print(lily.age, Tom.age) # 改變的結果不影響另一個對象的屬性 print(id(lily.age), id(Tom.age)) print('----------------------------------------') # change 類 student.age = 21 # 再次改變類屬性，lily的屬性已經不受影響，Tom的屬性仍會受到影響 print(lily.age, Tom.age) print(id(lily.age), id(Tom.age))

• 高級一點

class student:tall = 'None' # 類屬性，其變化同于基礎部分的講解def __init__(self): # 魔術方法self.name = 'None' # 對象屬性，應用到具體對象都會給定一個初始值，可根據具體需要再做修改self.age = 'None'self.phone = 'None'def sleep(self):print('{}正在睡覺'.format(self.name)) # self就相當于具體的對象# basic lily = student() print(lily.age, lily.name, lily.phone) print('lily.age的id:', id(lily.age)) lily.sleep() # self.name == lily.nameTom = student() print(Tom.age, Tom.name, Tom.phone) print('Tom.age的id:', id(Tom.age)) Tom.sleep() # self.name == Tom.nameprint('----------------------------------') # 初始化后的具體賦值 lily.name = 'lily' lily.age = '15' lily.phone = 'huawei' print(lily.age, lily.name, lily.phone) print('lily.age的id:', id(lily.age)) lily.sleep()print('----------------------------------') Tom.name = 'Tom' Tom.age = '15' Tom.phone = 'iphone' print(Tom.age, Tom.name, Tom.phone) print('Tom.age的id:', id(Tom.age)) Tom.sleep()

• 總結

類屬性

使用同一類創建不同的對象

• 若沒有改變過類屬性，可以通過類屬性改變，來改變對象中對應類屬性的值。一起改變
• 若某一對象更改了類屬性的值，則建立動態對象綁定，此對象中類屬性變為修改后的數值；其他對象的類屬性不變
• 再次改變類屬性，已經動態綁定的對象，其對象的類屬性不會受到影響；對于沒有“私自”更改類屬性的對象，其對應的類屬性仍然會受到影響

對象屬性

對象屬性是依據類創建對象的時候，每個對象都具有的公共屬性

其數值的更改需要通過調用對象屬性賦值來修改，不能通過類屬性更改

總結

類屬性，不允許對象私自修改，有類統一修改，影響所有對象

對象屬性，依據對象的特點，可以自己做出特定的修改。類沒有權限去修改對象屬性

對象方法

• 理解

class student(object):tall = 'tom' # 類屬性，其變化同于基礎部分的講解def __init__(self, nickname): # 魔術方法self.name = nickname # 對象屬性，應用到具體對象都會給定一個初始值，可根據具體需要再做修改self.age = 'None'self.phone = 'None'def run(self):print("{}在跑步".format(self.name)) # 調用對象屬性print("{}在跑步".format(self.tall)) # 調用類屬性self.sleep() # 調用其他對象方法def sleep(self):print('在睡覺')# basic lily = student('dahuang') lily.sleep() lily.run()

在睡覺
dahuang在跑步
tom在跑步
在睡覺

對象方法

可以調用類屬性，也可以調用對象屬性

對象方法中的參數是對象self

對象方法之間可以相互調用

類方法

• 理解

class student(object):tall = 'tom' # 類屬性，其變化同于基礎部分的講解def __init__(self, nickname): # 魔術方法self.name = nickname # 對象屬性，應用到具體對象都會給定一個初始值，可根據具體需要再做修改self.age = 'None'self.phone = 'None'def sleep(self):print('在睡覺')@classmethoddef test(cls):print('只能調用類屬性：',cls.tall)# basic student.test()

只能調用類屬性： tom

類方法

依賴裝飾器，且只能調用類屬性，不能調用對象屬性（會報錯）

類方法中的參數是類，不依賴對象，可以獨立于對象做一些處理

類方法中不能調用對象方法

• 類方法和對象方法的理解

類屬性是公共屬性，對象屬性是私有屬性

類方法只能調用類屬性；而對象方法既能調用對象屬性，也能調用類屬性

靜態方法

class student(object):__tall = 'tom' # 對類屬性進行私有化high = 12def __init__(self, nickname):self.name = nicknameself.age = 'None'self.phone = 'None'def sleep(self):print('在睡覺')@staticmethoddef casual():print('只能調用類屬性tall：', student.__tall)print('只能調用類屬性high：', student.high)# basic student.casual()

只能調用類屬性tall： tom
只能調用類屬性high： 12

也是只能訪問公共類屬性

靜態方法和類方法區別

不同

• 裝飾器不同
• 參數不同，一個有cls，一個無cls

相同

• 都只能訪問類屬性和方法，對象屬性和對象方法無法訪問
• 都可以通過類名調用訪問
• 都可以在對象創建之前調用，不依賴于對象

總結–↑

• 幾種方法都可以接受外部參數

class student(object):__tall = 'tom' # 對類屬性進行私有化high = 12def __init__(self, nickname):self.name = nicknameself.age = 'None'self.phone = 'None'def sleep(self, outer1):print('outer1:', outer1, self.__tall, self.high)@classmethoddef casual(cls, outer2):print('outer2:', outer2, cls.__tall, cls.high)@staticmethoddef casual(outer3):print('outer3:', outer3, student.__tall, student.high)# basic student('dahuang').sleep(1) student.casual(2) student.casual(3)

outer1: 1 tom 12
outer3: 2 tom 12
outer3: 3 tom 12

• 各自特點

對象方法

• 可以調用對象屬性，也可以調用類屬性（私有和非私有的）
• 依賴對象，沒有對象就不能調用對象方法
• 沒有裝飾器
• 必須有self對象參數，也可以有外部參數

類方法

• 只能調用類屬性（私有的和非私有的）
• 不依賴對象，沒有對象也可以調用類方法
• 需要裝飾器，classmethod
• 必須有cls參數，也可以有其他外部參數

靜態方法

• 只能調用類屬性（私有和非私有的）
• 不依賴對象，沒有對象也可以調用靜態方法
• 需要裝飾器，staticmethod
• 不需要任何參數，但是也可以添加外部參數

面向對象–魔術方法

魔術方法

• http://c.biancheng.net/view/7817.html
• https://www.cnblogs.com/zhangboblogs/p/7860929.html
• https://www.cnblogs.com/nmb-musen/p/10861536.html

常用魔術方法

# __new__(self) 和 __init__(self) # 先執行new，再執行init，不要隨便動用new魔術方法class Test:def __init__(self):print("init方法")def __new__(cls, *args, **kwargs):print("重寫new方法")return super().__new__(cls)m = Test()

重寫new方法
init方法

# _del__(self) ：析構器 # 當一個實例被銷毀的時候調用的方法 # 非手動調用時會在程序最后觸發,而手動調用del時則會觸發__del__,并不是程序最后class Test:def __init__(self, name):self.name = namedef __del__(self):print("觸發__del__")t = Test("python") print("end")del t print("end") # __len__class Test:def __init__(self, name):self.name = namedef __len__(self):return len(self.name) # 必須有返回值，且必須為int類型t = Test("mingming") print(len(t))

8

# __str__class Test:def __init__(self, name):self.name = namedef __str__(self):return "hello world" #必須有返回值，且必須為str類型# 調用方法1 t = Test("mingming") print(t)# 調用方法2 print(t.__str__())

hello world

hello world

# __bool__class Test:def __init__(self, name):self.name = namedef __bool__(self):if self.name =="python": # 返回對象必須是True 或 Falsereturn Trueelse:return Falset = Test("python") t1 = Test("java") print(bool(t)) print(bool(t1))

True

False

面向對象–私有化

類屬性的私有化

• 目的

為了防止外部任意修改公共類屬性

私有化的類屬性只能夠被類方法修改

class student(object):__tall = 'tom' # 對類屬性進行私有化high = 12def __init__(self, nickname):self.name = nicknameself.age = 'None'self.phone = 'None'def sleep(self):print('在睡覺')@classmethoddef test(cls):print('只能調用類屬性tall：',cls.__tall)print('只能調用類屬性high：', cls.high)@classmethoddef update(cls):cls.__tall = '把tom改為tttom' # basic student.test() student.high = '修改后' student.tall = '修改后' # 私有屬性，不可外界修改 student.test()student.update() # 使用類方法修改私有屬性 student.test()

只能調用類屬性tall： tom
只能調用類屬性high： 12
只能調用類屬性tall： tom
只能調用類屬性high： 修改后
只能調用類屬性tall： 把tom改為tttom
只能調用類屬性high： 修改后

對象屬性的私有化

• 目的

為了防止對象屬性被不合理的修改

可以通過對象方法來修改私有的對象屬性

class PositiveInteger():def __init__(self):self.__name = 'Tom'self.__age = 15def setName(self, newname):self.__name = newnamedef setAge(self, newage):if 0 < newage < 100:self.__age = newageelse:print('年齡不符合要求')def __str__(self):return '學生的年齡：{}，學生的名字：{}'.format(self.__age, self.__name)i = PositiveInteger()print(i) # i.__name 這是無法修改的 i.setName('TTTTom') i.setAge(150) print(i)

學生的年齡：15，學生的名字：Tom
年齡不符合要求
學生的年齡：15，學生的名字：TTTTom

私有化的本質–↑

• 本質是通過修改內部的名字，讓你無法通過原名字訪問
• 可以找到真實的名字進行訪問，但是不建議這樣用

class PositiveInteger():__name1 = 'lily'def __init__(self):self.__name = 'Tom'self.__age = 15def setName(self, newname):self.__name = newnamedef setAge(self, newage):if 0 < newage < 100:self.__age = newageelse:print('年齡不符合要求')def __str__(self):return '學生的年齡：{}，學生的名字：{}'.format(self.__age, self.__name)i = PositiveInteger()print(dir(PositiveInteger)) print(dir(i)) # 等價于 i.__dir__()print(i) i._PositiveInteger__age = 99 # 不過不建議這樣修改 print(i)

學生的年齡：15，學生的名字：Tom
學生的年齡：99，學生的名字：Tom

@property

• 目的

即想達到對象屬性私有化的目的

又想通過 對象.屬性 的方法來調用和修改私有化后的屬性

class PositiveInteger():def __init__(self):self.name = 'Tom'self.__age = 15@propertydef age(self):return self.__age@age.setterdef age(self, newage):if 0 < newage < 100:self.__age = newageelse:print('年齡不符合要求')def __str__(self):return '學生的年齡：{}，學生的名字：{}'.format(self.__age, self.name)i = PositiveInteger()print(i, i.age) i.age = 99 print(i, i.age)

學生的年齡：15，學生的名字：Tom 15
學生的年齡：99，學生的名字：Tom 99

面向對象–關聯關系

概念辨析

• is a

是一種繼承關系

A is a B B是A的基類（父類）

可以產生代碼上的重用性

比如：兔子 is a 動物

就是說兔子繼承了動物的一些特點：有腿、有耳朵

具體到代碼層面就是說：它可以繼承動物（父）類的一些屬性，如果有需要增加的可以再寫

兔子愛吃的素食有哪些，就是兔子類不能從動物類繼承的屬性，因為有些動物不吃素的

就可以在動物類的基礎上，添加喜歡吃的食物這一屬性

• has a

是一種包含關系

A has a B A包含B

比如：汽車 has a 輪胎，但是不能說汽車 is a 輪胎

包含關系具體到代碼層面就是調用

汽車有很多屬性：輪胎類型、車座類型、價格…

輪胎也有很多屬性：價格、材質、防滑等級…

汽車對象就可以調用輪胎對象里面的一些屬性

寶馬牌汽車的輪胎是米其林材質的，價格是…。防滑等級是…

實例理解

講的是 has a的包含關系

is a的繼承關系在后續有介紹

class Compter:def __init__(self,brand,type,color):self.brand=brandself.type=typeself.color=colordef online(self):print("正在使用電腦上網")def __str__(self):return self.brand + '-------'+self.type+'------'+self.colorclass Book:def __init__(self,bname,number,author):self.bname=bnameself.number=numberself.author=authordef __str__(self):return self.bname+self.author+self.numberclass sudent:def __init__(self,name,compter,book):self.name=nameself.compter=compterself.Book=[]self.Book.append(book)def __str__(self):return self.name+'------->'+str(self.compter)+'-----'+str(self.Book)C=Compter('mac','pro','深灰色') print(C) print(type(C))s = sudent('lilu', C, '盜墓筆記') print(s)

mac-------pro------深灰色
<class ‘main.Compter’>
lilu------->mac-------pro------深灰色-----[‘盜墓筆記’]

面向對象–繼承關系

基本繼承

class person():def __init__(self, name, age):self.name = nameself.age = agedef run(self):print('{}歲的{}在跑步'.format(self.age, self.name))class sudent(person):def __init__(self, name, age, classes):super().__init__(name, age )self.classes = classesdef run(self, food):super().run()print('他是{}的，喜歡吃{}'.format(self.classes, food))s = person('lilu', 13) s.run()s = sudent('lilu', 14, '15班') s.run('漢堡')

13歲的lilu在跑步
14歲的lilu在跑步
他是15班的，喜歡吃漢堡

• init問題

子類不定義init，則從父類繼承子類繼承父類，但是也需要自己定義 def __init__(self, name, age, classes):super().__init__(name, age)self.classes = classes

• 對象方法

父類定義eat()對象方法，子類無定義參數結果均同于父類默認搜索原則：先搜索當前類，沒有的話，再搜索父類父類定義eat()方法，子類也定義父類提供的方法無法滿足子類需求，在子類中定義一個同名的方法，就叫做：重寫子類定義的同名方法，可以借助父類中定義的部分def run(self, food):super().run()print('他是{}的，喜歡吃{}'.format(self.classes, food))

• 注意

父類中私有的屬性，子類是無法繼承的

多重繼承

• https://www.cnblogs.com/xpc51/p/11764975.html

class Base():def run(self):print('Base')class A(Base):def run(self):print('Base')class B(Base):def run(self):print('Base')class C(Base):def run(self):print('Base')class D(A, B, C):def run(self):print('Base')print(D.__mro__)----------------------------------------- (<class 'main.D'>, <class 'main.A'>, <class 'main.B'>, <class 'main.C'>, <class 'main.Base'>, <class 'object'>)

多重繼承的順序問題在Python2有這個問題

在Python3中沒有這個問題

面向對象–多態

多態介紹

# 封裝 繼承 多態 ----》 面向對象 class Person:def __init__(self, name):self.name = namedef feed_pet(self, pet): # pet既可以接收cat，也可以接收dog，還可以接收tiger# isinstance(obj,類) ---》 判斷obj是不是類的對象或者判斷obj是不是該類子類的對象if isinstance(pet, Pet):print('{}喜歡養寵物:{}，昵稱是:{}'.format(self.name, pet.role, pet.nickname))else:print('不是寵物類型的。。。。')class Pet:role = 'Pet'def __init__(self, nickname, age):self.nickname = nicknameself.age = agedef show(self):print('昵稱:{},年齡:{}'.format(self.nickname, self.age))class Cat(Pet):role = '貓'def catch_mouse(self):print('抓老鼠....')class Dog(Pet):role = '狗'def watch_house(self):print('看家高手....')class Tiger:def eat(self):print('太可怕了，可以吃人...')# 創建對象 cat = Cat('花花', 2)dog = Dog('大黃', 4)tiger = Tiger()person = Person('家偉')person.feed_pet(cat) person.feed_pet(dog) print('----------------------------') person = Person('pengpeng')person.feed_pet(tiger)# Pet # pet 父類 cat dog 子類 # pet 大類型 cat dog 小類型

• python中沒有嚴格的多態，它的多態實現是通過 isinstance() 函數來實現的

即不能分辨接受對象所屬的類型，所有類型的對象都可以接受

但是可以通過isinstance()函數，來分辨對象的類型，從而做出不同的動作

總結–多態、繼承、封裝

• 基本概念

封裝

根據功能將屬性和方法封裝在一個個類中，然偶基于這些類來創建對象

有些屬性不希望外界隨便更改，就給私有化

留有接受和改變該屬性的方法

但是改變有條件，通過寫在改變該屬性的方法里面

繼承

降低代碼的冗余度，實現了代碼的復用

多態

不同對象調用同一個方法，可能產生不同的結果

python中沒有嚴格的多態，主要是通過isinstance()函數來實現對象類型的判斷分別

• 參考文獻

https://www.jianshu.com/p/f78cab5deb9a

https://blog.csdn.net/simuLeo/article/details/80067619

https://www.liujiangblog.com/course/python/44

https://blog.csdn.net/weixin_48261286/article/details/113747011

總結

以上是生活随笔為你收集整理的知识点 —— Python进阶-2的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。