Python_面向對象_類1
阿新 • • 發佈:2018-10-25
實例化 ima 裏的 person 類定義 ... 自動 super wid
面向對象:減少重復代碼,提高效率,比函數式編程更高效
類的創建:
實例屬性又稱:成員變量,成員屬性(或者字段)
面向對象的三大特性:
一、封裝
把客觀事物封裝為抽象的類,並對外只暴露一個可用接口
使用構造方法將內容封裝到對象中,可通過對象直接或者通過self間接獲取被封裝的內容
# 創建類
class Foo(object):
def __init__(self, name, age): # 構造方法,根據創建的對象自動執行
self.name = name
self.age = age
# 類中的方法A
def A(self):
Foo.name = ‘yeeh‘
print(‘hello!‘, self.name)
print(‘hello!‘, Foo.name)
# 類中的方法B
def B(self):
print(‘word!‘,self.age)
obj = Foo(‘Vera‘, 18)
obj.age = 12
obj.A()
obj.B()
類
hello! Vera
hello! yeeh
word! 12
result
二、繼承
子類擁有父類的全部方法,也可以對父類方法進行重寫,並且可以定義自身的方法(一般到特殊,父類定義一些公共的方法,子類可定義自身特殊的方法)
- 註:Python中一個子類可以繼承多個父類
對於實例屬性要進行 :先重寫,再繼承
# 父類
class People(object):
number = 0
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
self.drink() # 因為繼承,所以調用的時候,都會打印drink ()裏的東西
def eat(self):
print(‘都可以吃東西! ‘)
def drink(self):
People.number += 1
print(‘[%s].[%s] 的年齡是[%s]‘ % (People.number, self.name, self.age))
# 子類1
class good_person(People):
def __init__(self, name, age, sex, goodness): # 先重寫
super(good_person, self).__init__(name, age, sex) # 再繼承
self.goodness = goodness
def good_ness(self):
print(‘善良的[%s]做好事‘ % self.name)
# 子類2
class bad_person(People):
def __init__(self, name, age, sex, sourness):
super(bad_person, self).__init__(name, age, sex)
self.sourness = sourness
def bad_ness(self):
print(‘壞人[%s]做壞事!‘ % self.name)
g1 = good_person(‘花花‘, 23, ‘女‘, ‘做好事‘) # 實例化後因為父類的繼承,所以直接會打印drink()
g1.good_ness()
b1 = bad_person(‘李剛‘, 33, ‘男‘, ‘做了壞事‘)
b1.bad_ness()
b1.eat() # 繼承會繼承父類的所有方法
繼承
[1].[花花] 的年齡是[23]
善良的[花花]做好事
[2].[李剛] 的年齡是[33]
壞人[李剛]做壞事!
都可以吃東西!
result
註:
新式類 繼承的寫法:super(Teacher,self).__init__(name,age,sex) # 利用關鍵字super
舊式(經典)類 繼承的寫法:SchoolMember.__init__(self,name,age,sex)
多繼承:
- 在3.0裏及以後多繼承的經典類和新式類都是采用的廣度優先原則
- 在3.0以下的版本,經典類和新式類就有深度和廣度的區分
經典類:class A: 深度優先:繼承了上一級裏沒有這個方法就直接到上一級的上一級去尋找,找到始祖沒有找到,再從繼承的上一級尋找再到它的始祖
新式類:class A(object): 廣度優先 :繼承的上一級,從左到右依次尋找繼承的類裏有沒有那個方法,如果沒有才再尋找上一級的上一級所繼承的
class A(object):
def f1(self):
print(‘我是 A‘)
class B(A):
def f2(self):
print(‘我是 B‘)
class C(A):
def f3(self):
print(‘我是 C‘)
class D(B, C):
def f4(self):
print(‘我是 D‘)
d = D()
d.f1() # D->B->C->A
d.f2() # D->B
d.f3() # D->B->C
d.f4() # D
新式類多繼承
class A:
def f1(self):
print(‘我是 A‘)
class B(A):
def f2(self):
print(‘我是 B‘)
class C(A):
def f3(self):
print(‘我是 C‘)
class D(B, C):
def f4(self):
print(‘我是 D‘)
d = D()
d.f1() # D->B->A
d.f2() # D->B
d.f3() # D->B->A->C
d.f4() # D
經典類多繼承
我是 A
我是 B
我是 C
我是 D
result
三、多態
多態:當子類和父類都存在相同的方法時,子類的 方法 覆蓋了父類的方法,在代碼運行時,會調用子類的方法(一種調用方式,擁有不同的執行效果),把接口進行統一但(外部調用,內部可以直接轉換到相應方法下)
class Animal(object):
def func(self):
print(‘這是Animal。。‘)
def print_func(slef, animal): # 不知道這裏對不對。。
animal.func()
class dog(Animal):
def func(self):
print(‘這是dog。。‘)
class pig(Animal):
def func(self):
print(‘這是pig。。‘)
def run(self):
print(‘這是pig中的run....‘)
A = Animal()
d = dog()
p = pig()
A.print_func(Animal()) # 對外只暴露一個接口,但是可以直接打印多個不同的東西
A.print_func(dog())
A.print_func(pig())
多態
這是Animal。。
這是dog。。
這是pig。。
result
Python_面向對象_類1