[TOC] ``` 面向過程:(流水線思維方式) 1.讓小哥去買雪碧,他去買雪碧的過程都是精確控制的,從頭到尾一步一步去完成 2.吃烤鴨,自己去養鴨子,殺鴨子,自己烤鴨子.自己吃.中間過程每一個步驟都是自己去實現 特點： 1.過于注重步驟和過程,不注重職責分工 2如果代碼需求很復雜,代碼不便于管理 3.開發復雜項目,沒有固定套路,不適合開發大型項目 面向對象:(上帝式思維方式) 1讓小哥去買雪碧,不需要精確控制買雪碧的過程,由小哥自己去決定 2.吃烤鴨,自己去賣鴨子的店里買烤鴨。烤鴨的制作過程有店里老板完成 我們自己不需要參與 特點： 1注重對象和職責,不同的對象完成不同的功能 2.更加適合復雜的業務需求,尤其是大型項目 3.面向對象的編程思維方式在面向過程的編程思維方式基礎之上 ``` ``` 類:(飛機圖紙-->類) 1.類是一組具有相同特征和行為的統稱,是一個抽象的概念 特征-->屬性-->變量 (飛機的長寬高,飛機的顏色) 行為-->方法-->函數 (飛機的飛翔,飛機的滑翔,飛機的翻轉) 對象:(一架架具體存在的飛機-—>對象) 1.就是由創建出來的一個個具體存在的事物 對象中也具有屬性-->靜態的特征 對象中也有 方法-->動態的行為 人類:(抽象的概念) 特征:姓名,年齡,身高,體重 -->特征-->屬性-->變量 行為:吃,走,睡覺,工作 -->行為-->方法-->函數 ``` ``` 對象:(具體存在的) 坐著的小明 開車的小王 唱歌的小紅 對象中都有自己的屬性和方法 每個對象的屬性和方法的結果可能各不相同 類和對象的關系: 1.類是模板,通過類可以創建出來一個個具體存在的對象 2.先有類,再有對象(對象是由類創建出來的) 3.類一般只有一個，對象可以有多個 4.類中有的屬性和方法，對象也具有屬性和方法 ``` ``` 設計類滿足的三要素： 1.類名,這類事物抽象的統稱,是這類事物的名字 要滿足大駝峰命名法(每個單詞的首字母都要大寫) 2.屬性---這類事物具有的特征--->名詞,靜態的特征 3.方法---這類事物具有的行為--->動詞，動態的行為 ``` ``` #類的設計 小明---->對象 小明---->姓名---->靜態的描述---->屬性 18歲---->年齡---->靜態的描述---->屬性 1.75---->身高---->靜態的描述---->屬性 跑----> 動態的行為---->方法 吃----> 動態的行為---->方法 小美---->對象 小美---->姓名---->靜態的描述---->屬性 17歲---->年齡---->靜態的描述---->屬性 1.65---->身高---->靜態的描述---->屬性 吃----> 動態的行為---->方法 人類： 姓名---->靜態的描述---->屬性 年齡---->靜態的描述---->屬性 身高---->靜態的描述---->屬性 吃 ---->動態的行為---->方法 Person name age high run() eat() ``` ``` dir()函數 1.python中內置的函數 2.可以來查看變量/對象/數據 的所有屬性和方法 常見的魔法方法： 01 __new__ 方法 創建對象時,會被 自動 調用(公司新入職的職工,分配工位,分配空間) 02 __init__ 方法 對象被初始化時,會被 自動 調用(在分配工位的基礎上，配置電腦和辦公工具) 03 __del__ 方法 對象被從內存中銷毀前,會被 自動 調用(從當前公司離職或跳槽，把配置電腦和辦公工具等交還給人事室部門) 04 __str__ 方法 返回對象的描述信息, print函數輸出使用(在公司中對某個職工的概述信息) ``` ``` 重點： 類的定義: 1.語法： class 類名: def 方法名1(self,參數列表): print("---方法執行語句代碼---") def 方法名2(self,參數列表): print("---方法執行語句代碼---") 2.類名要符合大駝峰命名法 3.類是可以封裝函數,是比函數更大的封裝,面向對象三個特性之一就是封裝 類模板創建對象: 對象變量名 = 類名() 訪問方法: 對象名.方法名（參數） 對象變量名保存的是對象內存地址的引用 ``` <details> <summary>01_定義簡單的類.py</summary> ``` # 01_定義簡單的類 # 定義函數 def func(): print("----func--函數--") func() # 定義類模板 class Person: # 當定義方法時，PyCharm自動添加self參數 def run(self): print("-----跑方法------") def eat(self, food): print("------吃方法_吃：%s-----" % food) def sleep(self): print("------睡覺的方法-----") # 使用類模板創建對象 # 對象變量 = 類名() xiao_ming = Person() # 通過對象來調用方法 # 對象變量名.方法名() # 注意：調用方法時，self參數不需要我們傳遞，由python解釋器自動傳遞 xiao_ming.run() xiao_ming.eat("雞腿") ''' 函數和方法的區別： 1.相同點:都是封裝代碼的整體(都是實現某個功能的小工具) 2.不同點: ①.定義位置不同 函數定義在類外部 方法定義在類內部 ②.參數不同 函數沒有self參數 方法有self參數 ③.調用方式不同 函數名(參數) 對象名,方法名(參數) ''' ``` </details> <br /> <details> <summary>02_第一個面向對象程序.py</summary> ``` # 02_第一個面向對象程序 # 探究 類中方法的調用 # 定義類模板 class Cat: '''貓類''' print("------類模板初始化幾次？-----") def eat(self): print("小貓愛吃魚") def drink(self): print("小貓要喝水") tom = Cat() tom.eat() ''' 方法的調用順序總結: 1.定義類模板時, Python解釋器會進入類模板內部掃描一遍,定義方法 不會進入方法內部執行代碼,類模板只被初始化一次 2.當使用類模板創建對象,通過調對象名,方法名()調用方法時, 才會進入方法內部執行代碼 3.方法中的代碼執行完后,回到調用調用的地方,繼續向下執行 ''' ``` </details> <br /> <details> <summary>03_self參數.py</summary> ``` # 03_self參數 class Cat: ''' 當前是貓類，只包含方法 ''' def eat(self): print("小貓愛吃魚", self) def drink(self, water): print("小貓要喝%s" % water) tom_cat = Cat() tom_cat.eat() print("-" * 30) lazy_cat = Cat() lazy_cat.eat() ``` </details> <br /> ``` 地址的進制表示 1.十進制 %d 2.十六進制 %x 獲取變量的引用的內存地址 id(變量) #給對象添加屬性有兩種方式 1.在類外部給對象添加屬性 方式: 對象.屬性名 = 屬性值 添加完屬性后,訪問方式: 1).在類的內部 可以使用self參數訪問屬性 se1f.屬性名 2).在類的外部 通過對象訪問屬性 對象名.屬性名 2.在類內部給對象添加屬性 ---> 待定 3.給對象添加屬性,屬性添加到對象的內存空間中了 重點: self參數的小結 1.self參數保存當前對象的引用地址,(哪個對象調用方法,self參數保存的就是哪個對象的引用地址) 2.在類的內部 訪問屬性 self.屬性名 在類的內部 調用方法 self,方法名(參數) 3.在類的外部 訪問屬性 對象名.屬性名 在類的外部 調用訪問 對象名.方法名(參數) ``` <details> <summary>04_在類的外部給對象添加屬性.py</summary> ``` # 04_在類的外部給對象添加屬性 class Cat: ''' 貓類 ''' def eat(self): # 在類的內部訪問屬性 通過self.屬性名 print( "%s 愛吃魚" % self.name) # 在類的內部訪問方法 通過 self.方法名(參數) self.drink("雪碧") def drink(self, water): print("小貓要喝:%s" % water) tom = Cat() # 在類外給對象添加屬性 # 對象名.屬性名 = 屬性值 tom.name = "湯姆貓" # 在類的外部訪問屬性 # 對象名.屬性名 print(tom.name) # 對象名.方法名() tom.eat() ``` </details> <br /> ``` 初化方法__init__小結: 1.作用:主要用來初始化屬性數據的 2.特點:在使用類模板創建對象時,自動調用 在使用類模板創建對象時,完成了兩個過程： 類名() 1.給對象分配內存空間 2.調用__init__方法初始化屬性數據 ``` <details> <summary>06_初始化__init__方法的使用.py</summary> ``` # 目標：06_初始化__init__方法的使用 class Cat: '''貓類''' def __init__(self): ''' 初始化方法 __init__初始化方法主要用來初始化數據的 初始化屬性數據的 初始化方法在 使用類模板創建對象時自動調用 ''' print("1.__init__初始化方法主要用來初始化數據的") def eat(self): print("小貓愛吃小魚干") tom = Cat() ``` </details> <br /> ``` 在類的內部給對象添加屬性: 在初始化方法的內部添加屬性 1.在__init__方法中,self,屬性名 = 屬性初始值 添加屬性 2.屬性添加到對象的內存空間中了 3.當使用 類模板創建 對象時(類名()),初始化方法__init__會自動調用, 屬性自動添加到對象的內存空間中了 ``` <details> <summary>07_在初始化方法的內部添加屬性.py</summary> ``` # 07_在初始化方法的內部添加屬性 class Cat: '''貓類''' def __init__(self): print("1.__init__初始化方法主要用來初始化數據的") # 在類的內部添加屬性 self.屬性名 = 屬性初始值 self.name = "湯姆貓" print("2.初始化方法在 使用類模板創建對象時自動調用") def eat(self): print("%s 愛吃小魚干" % self.name) tom = Cat() print(tom.name) tom.eat() ``` </details> <br /> ``` 在初始化的同時設置屬性值 1.在__init__()方法中添加形參,__init__(self.形參): 2.在__init__()方法中,把形參保存為屬性 self.屬性名=形參 3.使用 類模板創建對象時,一定要傳遞參數 類名(實參) ``` <details> <summary>08_在初始化的同時設置屬性值.py</summary> ``` # 08_在初始化的同時設置屬性值 class Cat: def __init__(self, new_name): self.name = new_name def eat(self): print("%s 愛吃小魚干" % self.name) tom = Cat("湯姆貓") tom.eat() bosimao = Cat("波斯貓") bosimao.eat() ``` </details> <br /> <br /> ### **初始化方法的小結：** ``` 1.概念:__init__()方法就是初始化方法(魔法方法) 2.作用:就是用來初始化數據的 3.特點:使用類模板創建對象時,會自動調用 4.在__init__方法中添加屬性 self.屬性名 = 屬性值 5.在初始化的同時,設置屬性值 ①.在__init__(self,形參) 方法中添加參數 ②.在_init_(seLf,形參)方法中把參數保存為屬性 self.屬性名=形參 ③.使用類模板創建對象時,一定要傳遞參數 類名(參數) ``` <details> <summary>__del__ 方法.py</summary> ``` # __del__ 方法： # 當前程序退出時，對象從內存空間銷毀前，自動調用 # 作用：清除資源的操作 class Cat: '''貓類''' def __init__(self, name): self.name = name def eat(self): print("%s 愛吃小魚干" % self.name) def __del__(self): '''刪除的魔法方法''' print("當前程序退出時，對象從內存空間銷毀前，自動調用") print("清除資源的操作") tom = Cat("湯姆貓") # 注意：__del__ 魔法方法在程序退出之前自動調用 # __del__ 魔法方法 可以手動調用 del tom ``` </details> <br /> <details> <summary>02_魔法方法__del__的使用場景.py</summary> ``` # 目標：實現 02_魔法方法__del__的使用場景 # 當前程序退出時,對象從內存空間銷毀前,自動調用 # 作用:清除資源的操作,文件的資源,網絡套接字資源,數據庫連接資源 class Cat: '''貓類''' name: object def __init__(self, name): self.name = name def eat(self): # self.food = food print("%s 愛吃小魚干" % self.name) # 局部變量作用范圍只能是當前方法，如果想讓下面的方法訪問到當前的屬性 # 需要把局部變量保存為屬性 self.file = open("cat.txt", 'w', encoding="utf-8") self.file.write("%s 愛吃小魚干" % self.name) def __del__(self): '''刪除的魔法方法''' print("當前程序退出時，對象從內存空間銷毀前，自動調用") print("清除資源的操作") print("---1--文件關閉前---") self.file.close() print("---2--文件關閉后---") tom = Cat("湯姆貓") tom.eat() # 注意：__del__ 魔法方法在程序退出之前自動調用 # __del__ 魔法方法 可以手動調用 del tom ``` </details> <br /> ``` 魔法方法__del__小結: 1.特點:當前程序退出時,對象從內存空間銷毀前,自動調用__del__ 2.作用:清除資源的操作,文件的資源,網絡套接字資源,數據庫連接資源等 對對象的生命周期: 1.從使用類模板創建對象時開始,到自動調用__del()__方法結束 魔法方法 __str__ 1.特點:打印對象時,自動調用, print(對象名) __str__()方法會自動調用 2.作用:打印對象的描述信息 3.注意:__str__方法必須有返回值,只能返回字符串 返回值 返回到 print(對象名) 地方 ``` <details> <summary>03_魔法方法__str__使用.py</summary> ``` # 目標:實現03_魔法方法__str__使用 # __str__方法: # 特點:打印對象時,自動調用 print(對象名)__str__()方法會自動調用 # 作用:打印對象的描述信息 # 注意:__str__方法必須有返回值,只能返回字符串 class Cat: '''貓類''' name: object def __init__(self, name): self.name = name def eat(self): # self.food = food print("%s 愛吃小魚干" % self.name) def __str__(self): '''對象描述信息方法''' print("使用print()方法，打印對象時，自動調用") return "名字是:%s" % self.name # return 100 # Error __str__方法只能返回字符串 # 使用類模板創建對象 big_face_cat = Cat("大臉貓") print(big_face_cat) ``` </details> <br /> <br /> <details> <summary>案例1.py</summary> ``` # 04_小明愛跑步案例 class Person: def __init__(self, name, weight): self.name = name self.weight = weight def __str__(self): return "姓名是：%s 體重是：%.2f" % (self.name, self.weight) def run(self): print("%s 愛跑步，每次跑步減重0.5公斤" % self.name) self.weight -= 0.5 def eat(self): print("%s 是一個吃貨，每次吃東西，體重增加1公斤" % self.name) self.weight += 1 xiaoming = Person("小明", 75.0) print(xiaoming) xiaoming.run() print(xiaoming) xiaoming.eat() print(xiaoming) print("-" * 50) xiaomei = Person('小美', 45.0) xiaomei.run() print(xiaomei) xiaomei.eat() print(xiaomei) 運行結果： 姓名是：小明 體重是：75.00 小明 愛跑步，每次跑步減重0.5公斤 姓名是：小明 體重是：74.50 小明 是一個吃貨，每次吃東西，體重增加1公斤 姓名是：小明 體重是：75.50 -------------------------------------------------- 小美 愛跑步，每次跑步減重0.5公斤 姓名是：小美 體重是：44.50 小美 是一個吃貨，每次吃東西，體重增加1公斤 姓名是：小美 體重是：45.50 ``` </details> <br /> <details> <summary>案例2.py</summary> ``` # 05_擺放家具案例 class HouseItem: '''家具類''' def __init__(self, name, area): self.name = name self.area = area def __str__(self): '''打印家具對象的描述信息''' return "家具名字:%s, 占地面積:%.1f平米" % (self.name, self.area) bed = HouseItem("席夢思", 4) print(bed) chest = HouseItem('衣柜', 2) print(chest) table = HouseItem("餐桌", 1.5) print(table) class House: '''房子類''' def __init__(self, house_type, area): self.house_type = house_type self.area = area self.free_area = area self.item_list = [] def __str__(self): return ("戶型:%s, 總面積:%.1f平方米, 剩余面積:%.1f平方米, 家具名稱列表:%s " % (self.house_type, self.area, self.free_area, self.item_list)) def add_item(self, item): print("item", item) print("item.name", item.name) print("item.area", item.area) # 1.判斷房子的剩余面積和家具的面積大小 # 如果房子的剩余面積小于家具的面積,不能添加,給個提示信息,代碼不再向下執行 if self.free_area < item.area: print("添加 %s 家具的面積太大，無法添加！！" % item.name) return # 如果房子的剩余面積不小于家具的面積,可以添加家具 # 2.更新房子的剩余面積 self.free_area -= item.area # 3.把新添加的家具名稱保存到 家具名稱列表 self.item_list.append(item.name) big_house = House("別墅", 90) print(big_house) big_house.add_item(bed) print(big_house) big_house.add_item(chest) print(big_house) big_house.add_item(table) print(big_house) ---------------------------------------- 打印： 家具名字:席夢思, 占地面積:4.0平米 家具名字:衣柜, 占地面積:2.0平米 家具名字:餐桌, 占地面積:1.5平米 戶型:別墅, 總面積:90.0平方米, 剩余面積:90.0平方米, 家具名稱列表:[] item 家具名字:席夢思, 占地面積:4.0平米 item.name 席夢思 item.area 4 戶型:別墅, 總面積:90.0平方米, 剩余面積:86.0平方米, 家具名稱列表:['席夢思'] item 家具名字:衣柜, 占地面積:2.0平米 item.name 衣柜 item.area 2 戶型:別墅, 總面積:90.0平方米, 剩余面積:84.0平方米, 家具名稱列表:['席夢思', '衣柜'] item 家具名字:餐桌, 占地面積:1.5平米 item.name 餐桌 item.area 1.5 戶型:別墅, 總面積:90.0平方米, 剩余面積:82.5平方米, 家具名稱列表:['席夢思', '衣柜', '餐桌'] ``` </details> <br /> <details> <summary>案例3.py</summary> ``` # 06_士兵突擊_優化 class Gun: '''槍類''' def __init__(self, type): self.type = type # 子彈的數量，新槍默認沒有子彈 self.bullet_count = 0 def add_bullet(self, count): '''添加子彈的方法''' self.bullet_count += count def shoot(self): '''射擊方法''' # 如果沒有子彈，不能射擊，提示添加子彈，代碼不再向下執行 if self.bullet_count <= 0: print("還沒子彈，請先添加子彈！！！") return self.bullet_count -= 1 print("%s biubiubiu...剩余子彈數量：%d" % (self.type, self.bullet_count)) # ak47 = Gun("AK47") # # ak47.add_bullet(50) # # ak47.shoot() # ak47.shoot() class Soldier: '''士兵類''' # gun=None 缺省參數(帶有默認值的參數) def __init__(self, name, gun=None): self.name = name # 士兵的槍支 新兵默認沒有槍支 self.gun = gun def add(self, new_count): '''當前方法是士兵拿著槍添加子彈''' if self.gun is None: print("當前士兵：%s 還沒有槍，不能開火，請分配槍支!!" % self.name) return self.gun.add_bullet(new_count) def fire(self): '''開火的方法''' if self.gun == None: print("當前士兵：%s 還沒有槍，不能開火，請分配槍支!!" % self.name) return self.gun.shoot() ak47 = Gun("AK47") xsd = Soldier("許三多", ak47) xsd.add(50) xsd.fire() xsd.fire() ``` </details> <br /> ### **身份運算符** ``` is 用來判斷兩個變量引用地址是否相同 如果相同返回True,否則返回 False == 用來判斷兩個變量的數據值是否相等 如果相等返回True,否則返回 False Python針對None比較時,建議使用is ``` <br /> ### **私有屬性和私有方法:** ``` 1.有些情況下,類中一些屬性和方法不需要類外直接訪問到,可以把類中的屬性和方法定義為私有 2.前置雙下劃線的屬性和方法就是私有屬性和私有方法, __age 私有屬性, __screat(self) 私有方法 3.私有屬性和私有方法在類外部不能直接訪問 但是可以在類內部訪問到 可以通過self訪問 4.Python中并沒有真正意義上的私有屬性和私有方法, 而是通過名字重整的方式將私有屬性和私有方法改了名字 方式: ①私有屬性名: _類名__私有屬性名 ②私有方法名: _類名__私有方法名 5.可以通過重整后的私有屬性名和私有方法名,間接去訪問 6 Python中的警告: Python中不阻止你去干壞事,一切靠自覺 7.可以通過對外方法間接訪問私有屬性,set_age()/ get_age() ``` <details> <summary>07_私有屬性和私有方法.py</summary> ``` # 07_私有屬性和私有方法 class Woman: '''美女類''' def __init__(self, name): self.name = name # 前置雙下劃線的屬性是私有的屬性 self.__age = 20 def eat(self): '''吃方法''' # 在類的內部可以通過self訪問私有屬性 print("%s 今年%s歲了，是一個吃貨" % (self.name, self.__age)) # 在類的內部可以通過self訪問私有方法 self.__secret() def __secret(self): '''私有方法''' print("個人秘密，不方便透露...") xian_nv = Woman("仙女") print(xian_nv.name) # 在類的外部無法直接訪問私有屬性 # print(xian_nv.__age) xian_nv.eat() # 在類的外部無法直接訪問私有方法 # xian_nv.__srcreate() ``` </details> <br /> <details> <summary>08_偽私有屬性和私有方法.py</summary> ``` # 08_偽私有屬性和私有方法 class Woman: '''美女類''' def __init__(self, name): self.name = name # 前置雙下劃線的屬性是私有的屬性 self.__age = 20 # 對外提供訪問私有屬性的接口(方法) get / set def get_age(self): '''獲取私有屬性值''' return self.__age def set_age(self, new_age): '''設置私有屬性值''' if 0 <= new_age or new_age >= 150: print("您輸入的年齡有誤") return self.__age = new_age def eat(self): '''吃方法''' # 在類的內部可以通過self訪問私有屬性 print("%s 今年%s歲了，是一個吃貨" % (self.name, self.__age)) # 在類的內部可以通過self訪問私有方法 self.__secret() def __secret(self): '''私有方法''' print("個人秘密，不方便透露...") xian_nv = Woman("仙女") print(xian_nv.name) # 在類的外部無法直接訪問私有屬性 # print(xian_nv.__age) # xian_nv.eat() # 在類的外部無法直接訪問私有方法 # xian_nv.__srcreate() print(dir(xian_nv)) # Python中并沒有真正意義上私有,是通過名字重整的方式,把私有屬性和私有方法改了名字 # 私有屬性: __私有屬性名 ---> _類名__私有屬性名 # 私有方法: __私有方法名 ---> _類名__私有方法名 # print(xian_nv._Women__age) # 在類的外部無法直接訪問私有屬性，可以通過名字重整方式，間接訪問 # xian_nv._Woman__secret() # 在類的外部無法直接訪問私有方法，可以通過名字重整方式，間接訪問 ret = xian_nv.get_age() print(ret) xian_nv.set_age(25) ret = xian_nv.get_age() print(ret) ``` </details> <br />