🌌 專注Golang，Python語言，云原生，人工智能領域得博主；
💜 過去經歷的意義在于引導你，而非定義你；
📢 歡迎點贊 👍 收藏 ?留言！
前言
- 01-繼承的基本語法
- 02-繼承的分類
- 03-子類重寫父類中的方法
- 04-重寫之后子類呼叫父類的方法
- 05-繼承中的init方法
- 06-多繼承
- 07-多繼承呼叫指定父類中的方法
- 08-私有屬性
- 09-私有方法
- 10-類屬性
- 11-類方法
- 12-靜態方法
- 13-多型
- 14-鴨子型別中的多型
01-繼承的基本語法
# 1. 定義是個 動物類 animal類
class Animal(object):
# 2. 在animal類書寫 play方法,輸出快樂的玩耍....
def play(self):
print('快樂的玩耍....')
# 3. 定義Dog類繼承animal類,
class Dog(Animal):
pass
# 4. 創建dog類物件.呼叫父類的方法
dog = Dog()
dog.play()
02-繼承的分類
"""
單繼承: 如果一個類只有一個父類,把這種繼承關系稱為單繼承
多繼承: 如果一個類有多個父類,把這種繼承關系稱為多繼承
多層繼承: C--> B --> A
"""
# 1. 定義是個 動物類 animal類
class Animal(object): # 對于Animal類和object類來說,單繼承
# 2. 在animal類書寫 play方法,輸出快樂的玩耍....
def play(self):
print('快樂的玩耍....')
# 3. 定義Dog類繼承animal類,
class Dog(Animal): # Dog --> Animal 也是單繼承, Dog --> Animal --> object 這種繼承關系稱為多層繼承
def bark(self):
print('汪汪汪叫.......')
# 定義類 XTQ類, 繼承 Dog類
# 多層繼承中,子類可以使用所有繼承鏈中的類中的方法和屬性
class XTQ(Dog): # XTQ --> Dog 單繼承, XTQ --> Dog --> Animal 類, 多層繼承
pass
xtq = XTQ()
xtq.bark() # 呼叫父類Dog中的方法
xtq.play() # 呼叫爺爺類 animal類中的方法
03-子類重寫父類中的方法
# 1. 定義Dog類, 書寫bark方法, 輸出 汪汪汪叫
class Dog(object):
def bark(self):
print('汪汪汪叫.........')
# 2. 定義XTQ類,繼承Dog類. 重寫父類中的bark方法, 輸出 嗷嗷嗷叫
class XTQ(Dog):
def bark(self):
print('嗷嗷嗷叫--------')
# 創建Dog類物件
dog = Dog()
dog.bark() # 父類自己的
# 創建XTQ類物件
xtq = XTQ()
xtq.bark()
04-重寫之后子類呼叫父類的方法
# 1. 定義Dog類, 書寫bark方法, 輸出 汪汪汪叫
class Dog(object):
def bark(self):
print('汪汪汪叫.........')
# 2. 定義XTQ類,繼承Dog類. 重寫父類中的bark方法, 輸出 嗷嗷嗷叫
class XTQ(Dog):
def bark(self):
print('嗷嗷嗷叫--------')
def see_host(self):
"""看見主人之后,要汪汪汪叫,不能嗷嗷嗷叫"""
print('看見主人了,', end='')
# self.bark()
# 想要在子類中呼叫父類的同名方法
# 方法一: 父類名.方法名(self, 其他引數), 通過實體物件.方法名() 呼叫方法,不需要給self傳遞實參值,
# python解釋器會自動將物件作為實參值傳遞給self形參, 如果是通過類名.方法() 呼叫,python解釋器就
# 不會自動傳遞實參值,需要手動給self形參傳遞實參值
Dog.bark(self)
# 方法二 super(類A, self).方法名(引數) , 會呼叫當類A 的父類中的方法
super(XTQ, self).bark() # 呼叫 XTQ類父類中的bark方法
# 方法三 是方法二的簡寫, super().方法名(引數) ==> super(當前類, self).方法名()
super().bark()
# 創建XTQ類物件
xtq = XTQ()
xtq.see_host()
05-繼承中的init方法
# 1. 定義Dog類
class Dog(object):
def __init__(self, name):
# 添加屬性
self.age = 0
self.name = name
def __str__(self):
return f'名字為:{self.name}, 年齡為{self.age}'
# 2. 定義XTQ類繼承Dog類
class XTQ(Dog):
# 子類重寫了父類的__init__ 方法,默認不再呼叫父類的init方法, 需要手動的呼叫父類的init方法
def __init__(self, name, color):
super().__init__(name)
self.color = color
def __str__(self):
return f'名字為:{self.name}, 年齡為{self.age}, 毛色為:{self.color}'
# 3. 創建XTQ類物件
xtq = XTQ('小黑', '紅色')
print(xtq)
06-多繼承
# 1. 定義Dog類, 定義bark方法,和 eat方法
class Dog(object):
def bark(self):
print('汪汪汪叫.....')
def eat(self):
print('啃骨頭.....')
# 2. 定義God類, 定義 play方法和eat方法
class God(object):
def play(self):
print('在云中飄一會....')
def eat(self):
print('吃蟠桃仙丹....')
# 3. 定義XTQ類, 繼承Dog類和God類
# class XTQ(Dog, God): # XTQ 類有兩個父類,這個繼承關系稱為多繼承,XTQ類物件,可以呼叫兩個父類中的屬性和方法
class XTQ(God, Dog): # XTQ 類有兩個父類,這個繼承關系稱為多繼承,XTQ類物件,可以呼叫兩個父類中的屬性和方法
pass
# 4. 創建XTQ類物件
xtq = XTQ()
xtq.bark() # 呼叫 Dog父類中的方法
xtq.play() # 呼叫 God父類中的方法
xtq.eat() # 兩個父類都存在eat方法,子類物件呼叫的是 第一個父類中的方法
07-多繼承呼叫指定父類中的方法
# 1. 定義Dog類, 定義bark方法,和 eat方法
class Dog(object):
def bark(self):
print('汪汪汪叫.....')
def eat(self):
print('啃骨頭.....')
# 2. 定義God類, 定義 play方法和eat方法
class God(object):
def play(self):
print('在云中飄一會....')
def eat(self):
print('吃蟠桃仙丹....')
# 3. 定義XTQ類, 繼承Dog類和God類
# class XTQ(Dog, God): # XTQ 類有兩個父類,這個繼承關系稱為多繼承,XTQ類物件,可以呼叫兩個父類中的屬性和方法
class XTQ(God, Dog): # XTQ 類有兩個父類,這個繼承關系稱為多繼承,XTQ類物件,可以呼叫兩個父類中的屬性和方法
def eat(self):
print('子類重寫eat方法,呼叫子類自己的方法')
# 呼叫指定父類中的方法
# 方法一 類名.方法名(self, 引數)
# Dog.eat(self)
# God.eat(self)
# 方法二 super(類A, self).方法名(引數) 類A的父類(繼承順序鏈的下一個類)中的方法
# super(XTQ, self).eat() # God 類中的方法
super(God, self).eat() # 呼叫的Dog類中的方法
# super(Dog, self).eat() # 呼叫的object類中的方法,注意: object類中沒有eat方法,代碼報錯
# 4. 創建XTQ類物件
xtq = XTQ()
xtq.bark() # 呼叫 Dog父類中的方法
xtq.play() # 呼叫 God父類中的方法
xtq.eat() # 兩個父類都存在eat方法,子類物件呼叫的是 第一個父類中的方法
# 類名.__mro__ 可以當前類的繼承順序鏈,也叫做方法的呼叫順序
# print(XTQ.__mro__)
08-私有屬性
"""
私有屬性,只需要在原屬性名前加上兩個下劃線,即可
目的: 保證資料的相對安全,
想要訪問和使用私有屬性: 定義一個公有的方法,通過這個方法使用
"""
# 案例需求: 定義People 類, 定義屬性 ICBC_money , 錢不能隨便被修改,必須是合法的終端才可以操作
class People(object):
def __init__(self):
# python中的私有本質是 修改屬性的名字, 在創建物件的時候,會自動的修改屬性名
# 在屬性名的前邊加上 _類名前綴
self.__ICBC_money = 0 # 定義私有屬性
# 定義公有的方法,提供介面,修改余額
def get_money(self):
return self.__ICBC_money
def set_money(self, money):
num = input('輸入金額:')
self.__ICBC_money += int(num)
# self.__ICBC_money += money
# 創建People類物件
xw = People()
# 實體物件.__dict__ 可以查看物件具有的屬性資訊,型別是字典,字典的key是屬性名, 字典的value是屬性值
print('賦值之前:', xw.__dict__)
# print(xw.__ICBC_money)
xw.__ICBC_money = 1000 # 不是修改私有屬性,是重新添加一個公有屬性
print('賦值之后:', xw.__dict__)
print(xw.__ICBC_money)
print('=' * 20)
print(xw.get_money()) # 0
xw.set_money(1000)
print(xw.get_money()) # 1000
xw.set_money(-500)
print(xw.get_money()) # 500
09-私有方法
"""
私有方法: 在方法的前邊加上兩個__ ,就為私有方法
私有方法,不能在類外部訪問
作用: 一般作為類內部的方法使用,不讓在外部直接呼叫, 保證業務邏輯不被破壞
"""
class Dog(object):
def born(self):
"""生小狗的方法, 生一個小狗,休息30天"""
print('生了一只小狗...')
self.__sleep()
def __sleep(self):
print('休息30天')
dog = Dog()
# dog.__sleep()
dog.born()
10-類屬性
"""
物件(實體物件): 通過class定義的類創建的, 即通過類實體化來的, 又稱為實體, 實體物件
實體物件定義的屬性稱為是 實體屬性. 通過實體物件(self) 定義的屬性都是實體屬性
實體屬性: 每個實體物件中都存在一份,并且值可能是不一樣的
類(類物件): 通過class定義的,又稱為 類物件, 是python解釋器在創建類的時候自動創建的
作用: 1. 通過類物件,去定義實體物件 2. 類物件可以保存一些屬性資訊,稱為類屬性
類屬性的定義: 在類內部,方法外部定義的變數就是類屬性
類屬性,字記憶體中只有一份
如何確定一個屬性是該定義為實體屬性還是類屬性?
先假設這個屬性為實體屬性,查看這個屬性值對于不同的實體物件, 屬性值是否都一樣,并且需要同時變化.
如果是, 則可以定義為類屬性
如果不是,則可以定義為實體屬性
"""
class Dog(object):
# 定義類屬性, 類名
class_name = '狗類'
def __init__(self, name, age):
# 定義的都是實體屬性
self.name = name
self.age = age
# 創建Dog 類物件
dog = Dog('大黃', 2)
# print(dog.__dict__) # 列印dog物件具有的屬性
# 類名.__dict__ 查看類物件具有的屬性
# print(Dog.__dict__)
# 訪問類屬性
# 類名.類屬性
print(Dog.class_name)
# 修改類屬性 類名.類屬性 = 屬性值
Dog.class_name = 'Dog類'
print(Dog.class_name)
# 補充, 注意: 如果不存在和實體屬性名相同的類屬性.則可以使用實體物件訪問類屬性的值
# 如果存在重名,則使用實體屬性訪問的一定是實體屬性,不是類屬性
print(dog.class_name)
11-類方法
"""
實體方法: 類中默認定義的方法,就是實體方法, 第一個引數為self,表示實體物件
類方法: 使用 @classmethod 裝飾的方法,稱為類方法, 第一個引數是cls,代表的是類物件自己
什么情況定義為實體方法,什么情況定義為類方法?
1. 如果在方法中使用了實體屬性, 那么該方法必須定義為實體方法
2. 前提:不需要使用實體屬性. 需要使用類屬性,可以將這個方法定義為類方法
"""
class Dog(object):
class_name = '狗類'
def __init__(self, name, age):
self.name = name
self.age = age
def play(self): # 實體方法
print(f"小狗{self.name} 在快樂的玩耍....")
# def get_class_name(self): # 是實體方法, 因為沒有使用實體屬性,所以可以定義為類方法
# return Dog.class_name
@classmethod
def get_class_name(cls): # cls 是類方法的默認形參,在呼叫的時候,不需要手動傳遞,python解釋器會自動傳遞
return cls.class_name
dog = Dog('大黃', 2)
dog.play()
print(dog.get_class_name()) # 物件.類方法()
# 類名.類方法()
print(Dog.get_class_name())
12-靜態方法
"""
實體方法: 類中默認定義的方法,就是實體方法, 第一個引數為self,表示實體物件
類方法: 使用 @classmethod 裝飾的方法,稱為類方法, 第一個引數是cls,代表的是類物件自己
靜態方法: 使用 @staticmethod 裝飾的方法,稱為靜態方法, 對引數沒有特殊要求,可以有,可以沒有
什么情況定義為實體方法,什么情況定義為類方法, 什么情況下靜態方法?
1. 如果在方法中使用了實體屬性, 那么該方法必須定義為實體方法
2. 前提:不需要使用實體屬性. 需要使用類屬性,可以將這個方法定義為類方法
3. 前提:不需要使用實體屬性,同時也不需要使用類屬性, 此時可以將這個方法定義為靜態方法
"""
class Dog(object):
class_name = '狗類'
def __init__(self, name, age):
self.name = name
self.age = age
def play(self): # 實體方法
print(f"小狗{self.name} 在快樂的玩耍....")
@staticmethod # 定義靜態方法
def show_info():
print('這是一個Dog類')
dog = Dog('大黃', 2)
dog.play()
# 物件.方法名()
dog.show_info()
# 類名.方法名()
Dog.show_info()
13-多型
"""
在需要使用父類物件的地方,也可以傳入子類物件,得到不同的結果 ---- 多型
實作步驟:
1. 子類繼承父類
2. 子類重寫父類中的同名方法
3. 定義一個共同的方法, 引數為父類物件.在方法中呼叫子類和父類同名的方法
"""
# 1. 定義DOg類
class Dog(object):
def __init__(self, name):
self.name = name
def play(self):
print(f'小狗{self.name} 在玩耍.......')
# 2. 定義哮天犬類,繼承Dog類
class XTQ(Dog):
# 3. 重寫 play方法
def play(self):
print(f'{self.name} 在天上追云彩.....')
# 4. 定義一個共同的方法,
def play_with_dog(obj_dog):
obj_dog.play()
# 創建Dog類物件@
dog = Dog('大黃')
play_with_dog(dog)
# 創建一個XTQ類的物件
xtq = XTQ('小黑')
play_with_dog(xtq)
14-鴨子型別中的多型
# 1. 定義DOg類
class Dog(object):
def __init__(self, name):
self.name = name
def play(self):
print(f'小狗{self.name} 在玩耍.......')
# 2. 定義哮天犬類,繼承Dog類
class XTQ(Dog):
# 3. 重寫 play方法
def play(self):
print(f'{self.name} 在天上追云彩.....')
class Cat(object):
def __init__(self, name):
self.name = name
def play(self):
print(f'小貓{self.name} 被擼中...')
# 4. 定義一個共同的方法,
def play_with_dog(obj_dog):
obj_dog.play()
# 創建Dog類物件@
dog = Dog('大黃')
play_with_dog(dog)
# 創建一個XTQ類的物件
xtq = XTQ('小黑')
play_with_dog(xtq)
cat = Cat('小花')
play_with_dog(cat)
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/345631.html
標籤：AI