學習總結 繼承 self. 自己的 .... fun lse pre nic

1.遞歸函數：自己調用自己
count = 0
def func():
global count
count += 1
print(count)
func()

func() #默認遞歸深度998，可通過sys.setrecursionlimit(100000)修改
##用遞歸解決年齡問題
d:比c大兩歲 4 age(3)+2
c:比b大兩歲 3 age(2)+2
b:比a大兩歲 2 age(1)+2
a:今年23 1 23
def age(n):
if n == 1:
return 23
else:
return age(n-1) + 2

2.二分查找
l1 = [2,3,5,10,15,16]
##不能改變列表的大小，所以需要調整每次的起始位置

def two_search(l,aim,start=0,end=None):
end = len(l) - 1 if end is None else end
if end >= start:
mid_index = (end - start) // 2 + start
if aim > l[mid_index]:
return two_search(l,aim,start=mid_index+1,end=end)
elif aim < l[mid_index]:
return two_search(l,aim,start=start,end=mid_index-1)
elif aim == l[mid_index]:
return mid_index
else:
return ‘沒有此值‘
else:
return ‘沒有此值‘
print(two_search(l1,15))

3.面向對象
類：具有相同屬性和技能的一類事物
對象：實例化的一個類，是類的具體體現
class Person: #class定義類的關鍵字 Person類名，首字母大寫
‘‘‘
類的註釋內容
‘‘‘
animal = ‘高級動物‘ #靜態變量
soup = ‘有思想‘
def init(self,name,sex,eye): #構造方法
self.name = name
self.sex = sex
self.eye = eye
print(111)

def work(self): #動態變量，動態方法，方法
print(‘工作‘)

##通過類查看靜態變量，動態變量（一般不通過類查看，一般都通過對象查看和操作）
#類操作靜態變量
###類名.dict方法（只能查看，不能增刪改）
print(Person.dict) #查看全部
print(Person.dict[‘animal‘]) #查看具體的
###類名.變量名 可增刪改查
print(Person.animal) #查看具體的
Person.kind = ‘有性格‘ #增加一個變量
Person.animal = ‘低等動物‘ #修改原有變量
del Person.kind #刪除一個變量

#類操作方法
###類名.dict[方法名]()
print(Person.dict‘work‘) #操作work方法
###類名.方法名
Person.work(1)

對象： 類名() 實例化一個對象
p1 = Person(‘aa‘,‘男‘,18) #只要實例化一個對象，自動觸發__init___
#實例化一個對象，在內存中產生一個對象空間。
#自動執行init方法，並將這個空間對象傳給self
#通過構造方法裏的代碼給空間對象添加一些屬性，並返回給對象

##通過對象查看靜態變量，動態變量
#對象操作屬性變量
###對象.dict方法（只能查看,不能增刪改）
print(p1.dict) #查看p1的屬性
###對象.變量名 可增刪改查
print(p1.name) #查看name屬性
p1.color = ‘黃皮膚‘ #增加一個屬性
p1.name = ‘cc‘ #改變一個原有屬性
print(p1.animal) #訪問類的靜態變量

#對象操作方法
###對象.方法名()
p1.work() #操作work方法
###類名.方法名(對象)
Person.work(p1) #操作work方法

4.類空間和對象空間
class Person:
animal = ‘高級動物‘ # 靜態變量
soup = ‘有思想‘ # 靜態變量
def init(self,name,age,sex,): # 構造方法
self.age = age
self.name = name # 屬性 self.name屬性名
self.sex = sex

def work(self,job): # 動態變量，動態方法，方法
    # self.job = job
    print(‘人會工作....‘)

p1 = Person(‘aa‘,18，男‘) #實例化一個對象
print(p1.name) #在對象空間查找
print(p1.animal) #通過對象空間的指示牌從類空間查找

5.組合
給一個類對象的屬性 封裝 另一個類的對象
class Game_person: #定義一個類
def init(self,nickname,sex,hp,ad):
self.nickname = nickname
self.sex = sex
self.hp = hp
self.ad = ad

def attack(self,p):
    p.hp -= self.ad
    print(‘%s×××了%s,%s還剩%s血量‘ %(self.nickname,p.nickname,p.nickname,p.hp))
def weapon_attack(self,wuqi):
    self.wuqi = wuqi

class Weapon: #定義一個類
def init(self,name,ad):
self.name = name
self.ad = ad

def fight(self,p1,p2):
    p2.hp -= self.ad
    print(‘%s使用%s打了%s%s血,%s還剩%s血‘ %(p1.nickname,self.name,p2.nickname,self.ad,p2.nickname,p2.hp))

ts = Game_person(‘泰森‘,‘男‘,200,50) #定義一個實例化對象
aa = Game_person(‘aa‘,‘男‘,100,10) #定義一個實例化對象
fuzi = Weapon(‘斧子‘,60) #定義一個實例化對象
ts.attack(aa) #對象調用方法
aa.weapon_attack(fuzi) #aa調用weapon_attack方法將fuzi對象封裝到aa的屬性中
aa.wuqi.fight(aa,ts) #aa.wuqi=fuzi aa.wuqi.fight(aa,ts)=fuzi..fight(aa,ts)

6.繼承
##面向對象三大特點：封裝 繼承 多態
class Animal: #父類 基類
soup = ‘靈魂‘
def init(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color

class Cat(Animal):
pass

class Dog(Animal):
pass

cat1 = Cat(‘波斯貓‘, ‘公‘, ‘橘黃‘) #子類 派生類
dog1=Dog(‘泰迪‘,‘公‘,‘黑色‘) #子類 派生類

##類分為兩種：新式類，經典類。但是python3x中只有新式類，繼承object類的類稱為新式類，python3x 中，所有的類都默認繼承object類。python2x中默認為經典類
新式類 ：遵循的廣度優先
經典類 ：遵循的深度優先
繼承：單繼承，多繼承

##個性化封裝同時繼承父類的屬性
class Animal:
soup = ‘靈魂‘
def init(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color
def eat(self):
print(‘吃‘)

class Bird(Animal):
def init(self,varieties, sex, color,fly):
# Animal.init(self,varieties, sex, color,) # 執行父類的方法第一種方式（不常用）
# super(Animal,self).init(varieties, sex, color,) # 執行父類的方法第二種方式
super().init(varieties, sex, color,) # 執行父類的方法第二種方式 省略寫法（常用）
self.fly = fly # 個性化的封裝
def eat(self):
super().eat()
print(‘鳥吃‘) # 個性化的封裝

b1 = Bird(‘鸚鵡‘,‘公‘, ‘綠色‘,800)
b1.eat() #先執行父類的方法，然後執行自己的方法

##單繼承：一條線
class A:

def func(self):
    print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(B):
pass
def func(self):
print(‘C‘)

c1 = C()
c1.func() #C--B--A

##多繼承:鉆石繼承（新式類） 用最少的次數查找全部的類
class A:
def func(self):
print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(A):
pass
def func(self):
print(‘C‘)

class D(B,C):
pass

d1 = D()
d1.func() #B--C--A
print(D.mro()) #打印查找順序

##多繼承:深度優先（經典類，Python2x中默認為經典類，可通過繼承object修改）
class A:
def func(self):
print(‘A‘)

class B(A):
pass
def func(self):
print(‘B‘)

class C(A):
pass
def func(self):
print(‘C‘)

class D(B,C):
pass

d1 = D()
d1.func() #B--A--C

python第六天學習總結