day06_雷神_面向對象初識
阿新 • • 發佈：2018-07-05
重復數 turn job 內存地址 加載 個性化 繼承 ini 數據
day_06
遞歸函數
自己用自己。一般遞歸100多次，都沒有解決的問題，放棄遞歸。
count = 0
def func1():
global count
count += 1
print(count)
func1()
func1()
默認遞歸深度：998設置遞歸深度
import sys
sys.setrecursionlimit(20000)
count = 0
def func1():
global count
count += 1
print(count)
func1()
func1()用遞歸解決一個年齡問題：
"" alex 他比佩奇 大兩歲。 4 age(3) + 2 佩奇 他比日天 大兩歲。 3 age(2) + 2 日天 他比太白 大兩歲。 2 age(1) + 2 太白：我今年23. 1 23 """ def age(n): if n == 1: return 23 else: return age(n-1) + 2 print(age(3)) 註意： 必須有return
二分查找
有序的不重復數字列表
l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
print(l.index(3)) # 查詢到66 索引以前查找索引的方法：
for i in range(len(l)):
if l[i] == 66:
print(i)通過遞歸的方法：
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,5))
錯誤的例子：因為每次切片，改變了原列表，進而改變了索引。
l = [2,3,5,10,15,16] def two_search(l,aim): mid_index = len(l) // 2 if aim > l[mid_index]: return two_search(l[mid_index+1:],aim) elif aim < l[mid_index]: return two_search(l[:mid_index],aim) elif aim == l[mid_index]: return mid_index else: return ‘沒有此值‘ print(two_search(l,16))
面向對象初識
實際工作中，python 都是面向對象，寫代碼，或者 面向對象+函數寫代碼。
面向對象編程：上帝式思維。造物者思維。 什麽是類？
類：是具有相同屬性和技能的一類事物。
對象：實例化的一個類，是類的具體體現。
貓就是類，我家樓下那只小花，這是一個對象。基本概念：
class Person: # class 關鍵字，定義了一個類
‘‘‘
類裏面的所有內容
‘‘‘
animal = ‘高級動物‘ # 靜態變量
soup = ‘有思想‘ # 靜態變量
def __init__(self,name,sex,eye,high,weight,): # 構造方法
self.eye = eye # 屬性
self.name = name
self.sex = sex
self.high = high
self.weight = weight
print(666)
def work(self): # 動態變量，動態方法，方法
print(self)
# self.job = ‘IT‘
print(‘人會工作....‘)以類的角度去調用變量：靜態、動態
類操作靜態變量有兩種方式：一般你想查詢全部的靜態變量時，用__dict__ 其他全部都用類名.變量名。
1. 類名.__dict__ 只能查看，不能增刪改
print(Person.__dict__) # 所有的變量，顯示一個字典數據
{‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘\n 類裏面的所有內容\n ‘, ‘animal‘: ‘高級動物‘, ‘soup‘: ‘有思想‘, ‘__init__‘: <function Person.__init__ at 0x000002495E988950>, ‘work‘: <function Person.work at 0x000002495E9889D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>}
print(Person.__dict__[‘animal‘])
2. 類名.變量名 可增刪改
print(Person.animal)
Person.kind = ‘有性格‘
Person.animal = ‘低等動物‘
del Person.kind
print(Person.__dict__)類操作方法有兩種方式：
1，類名.__dict__[方法名]()
print(Person.__dict__[‘work‘](11)) 有一個self形參，隨便傳個實參測試。
2，類名.方法名()
Person.work(11)如果類操作方法：類名.方法名();
只要創建一個類，裏面的內容就已經加載到內存。
對象：類名() 就是實例化一個對象
p1 = Person() # p1 對象，實例化對象，類名()過程就叫做實例化。p1 = Person() # p1 對象，實例化對象，類名()過程就叫做實例化。
內部進行三步：
1，實例化一個對象，在內存中產生一個對象空間。
2，自動執行init方法，並將這個空間對象。 <__main__.Person object at 0x0000000001F5ABE0> 傳給self
3，通過構造方法裏的代碼給空間對象添加一些屬性，並返回給對象。對象操作屬性變量有兩種方式：
1，對象.__dict__方法 只能查看,不能增刪改。
print(p1.__dict__)
2， 對象.變量名 可增刪改查
print(p1.name)
print(p1.eye)
p1.color = ‘黃皮膚‘
print(p1.color)
print(p1, type(p1)) p1是一個對象的內存地址。
print(p1.__dict__)
3， 可以訪問類的靜態變量
print(p1.animal)
print(p1.soup)對象操作方法有兩種方式：
1， 對象.方法名（）
p1 = Person(‘峰哥‘,‘男‘,‘大眼睛‘,176,170)
輸出：666
p1.work()
輸出：
666
<__main__.Person object at 0x000001D8DF0E7B38> 代表self，p1對象的內存地址。
人會工作....
2. 2，類名.方法名(對象)
Person.work(111)
Person.work(p1) 手動將p1傳給self。類空間，對象空間
通過實例化對象查找屬性，先從對象空間找，沒有則通過類對象指針從類空間找。
組合
組合：給一個類對象的屬性 封裝 另一個類的對象。
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,wea):
self.lalala = wea #斧子對象
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)
barry = Game_person(‘太白‘,‘男‘,100,10)
fuzi = Weapon(‘斧子‘,60)
barry.weapon_attack(fuzi) 先把對象fuzi傳進去，即完成另一個類對象的封裝。
barry.wea.fight(barry,ts) barry.wea 相當於對象fuzi繼承
繼承：可以有效的節省代碼。
Animal 父類，基類。
Cat 子類,派生類，python3x 中，所有的類都默認繼承object類,繼承object類的類稱為新式類。python3 沒有經典類。
新式類 ：遵循的廣度優先。
經典類 ：遵循的深度優先。繼承：單繼承，多繼承。 ？？
繼承的問題：
class Animal:
soup = ‘靈魂‘
def __init__(self,varieties, sex, color):
self.varieties = varieties
self.sex = sex
self.color = color
print(666)
def eat(self):
print(‘吃‘)
class Cat(Animal):
a = Animal.eat
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(‘鳥該吃飯了....‘)
cat1 = Cat(‘波斯貓‘, ‘公‘, ‘橘黃‘)
cat1.eat()
問題一：
執行順序，所以執行 貓吃飯.
問題二：
貓，鳥，都有自己獨立屬性，如何使用共同的屬性並且使用獨立的屬性。
b1 = Bird(‘鸚鵡‘,‘公‘, ‘綠色‘,800)
print(b1.__dict__)
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()多繼承，鉆石繼承，遵循廣度優先，（找完B，找C，不會找完B 去找A，那樣是深度優先）
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()
多繼承 鉆石繼承
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()示例2：mro()
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):
pass
# def func(self):
# print(‘D‘)
class E(C):
pass
def func(self):
print(‘E‘)
class F(D,E):
pass
# def func(self):
# print(‘F‘)
print(F.mro())經典類： 深度優先
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
print(D.mro())
d1 = D()
d1.func()
B沒有，會直接去A，不會去C面試題1
class A:
def func(self):
print(‘A‘)
def __init__(self):
self.func()
class B(A):
def func(self):
print(‘B‘)
b1 = B()
此時的self就是b1的內存地址，所以結果是執行 print(‘B‘)，輸出Bday06_雷神_面向對象初識