Python学习之路（四）——Python核心编程3（面向对象、模块_包_异常）
生活随笔
收集整理的這篇文章主要介紹了
Python学习之路（四）——Python核心编程3（面向对象、模块_包_异常）
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
面向對象基礎
一. 理解面向對象
面向對象是一種抽象化的編程思想，很多編程語言中都有的一種思想。
例如：洗衣服
思考：幾種途徑可以完成洗衣服？
答： 手洗 和 機洗。
手洗：找盆 - 放水 - 加洗衣粉 - 浸泡 - 搓洗 - 擰干水 - 倒水 - 漂洗N次 - 擰干 - 晾曬。
機洗：打開洗衣機 - 放衣服 - 加洗衣粉 - 按下開始按鈕 - 晾曬。
思考：對比兩種洗衣服途徑，同學們發現了什么？
答：機洗更簡單
思考：機洗，只需要找到一臺洗衣機，加入簡單操作就可以完成洗衣服的工作，而不需要關心洗衣機內部發生了什么事情。
總結：面向對象就是將編程當成是一個事物，對外界來說，事物是直接使用的，不用去管他內部的情況。而編程就是設置事物能夠做什么事。
二. 類和對象
思考：洗衣機洗衣服描述過程中，洗衣機其實就是一個事物，即對象，洗衣機對象哪來的呢？
答：洗衣機是由工廠工人制作出來。
思考：工廠工人怎么制作出的洗衣機？
答：工人根據設計師設計的功能圖紙制作洗衣機。
總結：圖紙 → 洗衣機 → 洗衣服。
在面向對象編程過程中，有兩個重要組成部分：類 和 對象。
類和對象的關系：用類去創建一個對象。
2.1 理解類和對象
2.1.1 類
類是對一系列具有相同特征和行為的事物的統稱，是一個抽象的概念，不是真實存在的事物。
- 特征即是屬性
- 行為即是方法
類比如是制造洗衣機時要用到的圖紙，也就是說類是用來創建對象。
2.1.2 對象
對象是類創建出來的真實存在的事物，例如：洗衣機。
注意：開發中，先有類，再有對象。
2.2 面向對象實現方法
2.2.1 定義類
Python2中類分為：經典類 和 新式類
- 語法
注意：類名要滿足標識符命名規則，同時遵循大駝峰命名習慣。
- 體驗
- 拓展：經典類
不由任意內置類型派生出的類，稱之為經典類
class 類名:代碼......2.2.2 創建對象
對象又名實例。
- 語法
- 體驗
注意：創建對象的過程也叫實例化對象。
2.2.3 self
self指的是調用該函數的對象。
# 1. 定義類 class Washer():def wash(self):print('我會洗衣服')# <__main__.Washer object at 0x0000024BA2B34240>print(self)# 2. 創建對象 haier1 = Washer() # <__main__.Washer object at 0x0000018B7B224240> print(haier1) # haier1對象調用實例方法 haier1.wash()haier2 = Washer() # <__main__.Washer object at 0x0000022005857EF0> print(haier2)注意：打印對象和self得到的結果是一致的，都是當前對象的內存中存儲地址。
三. 添加和獲取對象屬性
屬性即是特征，比如：洗衣機的寬度、高度、重量…
對象屬性既可以在類外面添加和獲取，也能在類里面添加和獲取。
3.1 類外面添加對象屬性
- 語法
- 體驗
3.2 類外面獲取對象屬性
- 語法
- 體驗
3.3 類里面獲取對象屬性
- 語法
- 體驗
四. 魔法方法
在Python中，__xx__()的函數叫做魔法方法，指的是具有特殊功能的函數。
4.1 __init__()
4.1.1 體驗__init__()
思考：洗衣機的寬度高度是與生俱來的屬性，可不可以在生產過程中就賦予這些屬性呢？
答：理應如此。
__init__()方法的作用：初始化對象。
class Washer():# 定義初始化功能的函數def __init__(self):# 添加實例屬性self.width = 500self.height = 800def print_info(self):# 類里面調用實例屬性print(f'洗衣機的寬度是{self.width}, 高度是{self.height}')haier1 = Washer() haier1.print_info()注意：
- __init__()方法，在創建一個對象時默認被調用，不需要手動調用
- __init__(self)中的self參數，不需要開發者傳遞，python解釋器會自動把當前的對象引用傳遞過去。
4.1.2 帶參數的__init__()
思考：一個類可以創建多個對象，如何對不同的對象設置不同的初始化屬性呢？
答：傳參數。
class Washer():def __init__(self, width, height):self.width = widthself.height = heightdef print_info(self):print(f'洗衣機的寬度是{self.width}')print(f'洗衣機的高度是{self.height}')haier1 = Washer(10, 20) haier1.print_info()haier2 = Washer(30, 40) haier2.print_info()4.2 __str__()
當使用print輸出對象的時候，默認打印對象的內存地址。如果類定義了__str__方法，那么就會打印從在這個方法中 return 的數據。
class Washer():def __init__(self, width, height):self.width = widthself.height = heightdef __str__(self):return '這是海爾洗衣機的說明書'haier1 = Washer(10, 20) # 這是海爾洗衣機的說明書 print(haier1)4.3 __del__()
當刪除對象時，python解釋器也會默認調用__del__()方法。
class Washer():def __init__(self, width, height):self.width = widthself.height = heightdef __del__(self):print(f'{self}對象已經被刪除')haier1 = Washer(10, 20)# <__main__.Washer object at 0x0000026118223278>對象已經被刪除 del haier1五. 綜合應用
5.1 烤地瓜
5.1.1 需求
需求主線：
被烤的時間和對應的地瓜狀態：
0-3分鐘：生的
3-5分鐘：半生不熟
5-8分鐘：熟的
超過8分鐘：烤糊了
添加的調料：
用戶可以按自己的意愿添加調料
5.1.2 步驟分析
需求涉及一個事物： 地瓜，故案例涉及一個類：地瓜類。
5.1.2.1 定義類
-
地瓜的屬性
- 被烤的時間
- 地瓜的狀態
- 添加的調料
-
地瓜的方法
- 被烤
- 用戶根據意愿設定每次烤地瓜的時間
- 判斷地瓜被烤的總時間是在哪個區間，修改地瓜狀態
- 添加調料
- 用戶根據意愿設定添加的調料
- 將用戶添加的調料存儲
- 被烤
-
顯示對象信息
5.1.2.2 創建對象，調用相關實例方法
5.1.3 代碼實現
5.1.3.1 定義類
- 地瓜屬性
- 定義地瓜初始化屬性，后期根據程序推進更新實例屬性
5.1.3.2 定義烤地瓜方法
class SweetPotato():......def cook(self, time):"""烤地瓜的方法"""self.cook_time += timeif 0 <= self.cook_time < 3:self.cook_static = '生的'elif 3 <= self.cook_time < 5:self.cook_static = '半生不熟'elif 5 <= self.cook_time < 8:self.cook_static = '熟了'elif self.cook_time >= 8:self.cook_static = '烤糊了'5.1.3.3 書寫str魔法方法，用于輸出對象狀態
class SweetPotato():......def __str__(self):return f'這個地瓜烤了{self.cook_time}分鐘, 狀態是{self.cook_static}'5.1.3.4 創建對象，測試實例屬性和實例方法
digua1 = SweetPotato() print(digua1) digua1.cook(2) print(digua1)5.1.3.5 定義添加調料方法，并調用該實例方法
class SweetPotato():......def add_condiments(self, condiment):"""添加調料"""self.condiments.append(condiment)def __str__(self):return f'這個地瓜烤了{self.cook_time}分鐘, 狀態是{self.cook_static}, 添加的調料有{self.condiments}'digua1 = SweetPotato() print(digua1)digua1.cook(2) digua1.add_condiments('醬油') print(digua1)digua1.cook(2) digua1.add_condiments('辣椒面兒') print(digua1)digua1.cook(2) print(digua1)digua1.cook(2) print(digua1)5.1.4 代碼總覽
# 定義類 class SweetPotato():def __init__(self):# 被烤的時間self.cook_time = 0# 地瓜的狀態self.cook_static = '生的'# 調料列表self.condiments = []def cook(self, time):"""烤地瓜的方法"""self.cook_time += timeif 0 <= self.cook_time < 3:self.cook_static = '生的'elif 3 <= self.cook_time < 5:self.cook_static = '半生不熟'elif 5 <= self.cook_time < 8:self.cook_static = '熟了'elif self.cook_time >= 8:self.cook_static = '烤糊了'def add_condiments(self, condiment):"""添加調料"""self.condiments.append(condiment)def __str__(self):return f'這個地瓜烤了{self.cook_time}分鐘, 狀態是{self.cook_static}, 添加的調料有{self.condiments}'digua1 = SweetPotato() print(digua1)digua1.cook(2) digua1.add_condiments('醬油') print(digua1)digua1.cook(2) digua1.add_condiments('辣椒面兒') print(digua1)digua1.cook(2) print(digua1)digua1.cook(2) print(digua1)5.2 搬家具
5.2.1 需求
將小于房子剩余面積的家具擺放到房子中
5.2.2 步驟分析
需求涉及兩個事物：房子 和 家具，故被案例涉及兩個類：房子類 和 家具類。
5.2.2.1 定義類
-
房子類
- 實例屬性
- 房子地理位置
- 房子占地面積
- 房子剩余面積
- 房子內家具列表
- 實例方法
- 容納家具
- 顯示房屋信息
- 實例屬性
-
家具類
- 家具名稱
- 家具占地面積
5.2.2.2 創建對象并調用相關方法
5.2.3 代碼實現
5.2.3.1 定義類
- 家具類
-
房子類
5.2.3.2 創建對象并調用實例屬性和方法
bed = Furniture('雙人床', 6) jia1 = Home('北京', 1200) print(jia1)jia1.add_furniture(bed) print(jia1)sofa = Furniture('沙發', 10) jia1.add_furniture(sofa) print(jia1)ball = Furniture('籃球場', 1500) jia1.add_furniture(ball) print(jia1)面向對象-繼承
一. 繼承的概念
生活中的繼承，一般指的是子女繼承父輩的財產。
- 拓展1：經典類或舊式類
不由任意內置類型派生出的類，稱之為經典類。
class 類名:代碼......- 拓展2：新式類
Python面向對象的繼承指的是多個類之間的所屬關系，即子類默認繼承父類的所有屬性和方法，具體如下：
# 父類A class A(object):def __init__(self):self.num = 1def info_print(self):print(self.num)# 子類B class B(A):passresult = B() result.info_print() # 1在Python中，所有類默認繼承object類，object類是頂級類或基類；其他子類叫做派生類。
二. 單繼承
故事主線：一個煎餅果子老師傅，在煎餅果子界摸爬滾打多年，研發了一套精湛的攤煎餅果子的技術。師父要把這套技術傳授給他的唯一的最得意的徒弟。
分析：徒弟是不是要繼承師父的所有技術？
# 1. 師父類 class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')# 2. 徒弟類 class Prentice(Master):pass# 3. 創建對象daqiu daqiu = Prentice() # 4. 對象訪問實例屬性 print(daqiu.kongfu) # 5. 對象調用實例方法 daqiu.make_cake()三. 多繼承
故事推進：daqiu是個愛學習的好孩子，想學習更多的煎餅果子技術，于是，在百度搜索到黑馬程序員，報班學習煎餅果子技術。
所謂多繼承意思就是一個類同時繼承了多個父類。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')# 創建學校類 class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class Prentice(School, Master):passdaqiu = Prentice() print(daqiu.kongfu) daqiu.make_cake()注意：當一個類有多個父類的時候，默認使用第一個父類的同名屬性和方法。
四. 子類重寫父類同名方法和屬性
故事：daqiu掌握了師父和培訓的技術后，自己潛心鉆研出自己的獨門配方的一套全新的煎餅果子技術。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')# 獨創配方 class Prentice(School, Master):def __init__(self):self.kongfu = '[獨創煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')daqiu = Prentice() print(daqiu.kongfu) daqiu.make_cake()print(Prentice.__mro__)子類和父類具有同名屬性和方法，默認使用子類的同名屬性和方法。
五. 子類調用父類的同名方法和屬性
故事：很多顧客都希望也能吃到古法和黑馬的技術的煎餅果子。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class Prentice(School, Master):def __init__(self):self.kongfu = '[獨創煎餅果子配方]'def make_cake(self):# 如果是先調用了父類的屬性和方法，父類屬性會覆蓋子類屬性，故在調用屬性前，先調用自己子類的初始化self.__init__()print(f'運用{self.kongfu}制作煎餅果子')# 調用父類方法，但是為保證調用到的也是父類的屬性，必須在調用方法前調用父類的初始化def make_master_cake(self):Master.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)daqiu = Prentice()daqiu.make_cake()daqiu.make_master_cake()daqiu.make_school_cake()daqiu.make_cake()六. 多層繼承
故事：N年后，daqiu老了，想要把所有技術傳承給自己的徒弟。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class Prentice(School, Master):def __init__(self):self.kongfu = '[獨創煎餅果子配方]'def make_cake(self):self.__init__()print(f'運用{self.kongfu}制作煎餅果子')def make_master_cake(self):Master.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)# 徒孫類 class Tusun(Prentice):passxiaoqiu = Tusun()xiaoqiu.make_cake()xiaoqiu.make_school_cake()xiaoqiu.make_master_cake()七. super()調用父類方法
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(Master):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')# 方法2.1# super(School, self).__init__()# super(School, self).make_cake()# 方法2.2super().__init__()super().make_cake()class Prentice(School):def __init__(self):self.kongfu = '[獨創煎餅果子技術]'def make_cake(self):self.__init__()print(f'運用{self.kongfu}制作煎餅果子')# 子類調用父類的同名方法和屬性：把父類的同名屬性和方法再次封裝def make_master_cake(self):Master.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)# 一次性調用父類的同名屬性和方法def make_old_cake(self):# 方法一：代碼冗余；父類類名如果變化，這里代碼需要頻繁修改# Master.__init__(self)# Master.make_cake(self)# School.__init__(self)# School.make_cake(self)# 方法二: super()# 方法2.1 super(當前類名, self).函數()# super(Prentice, self).__init__()# super(Prentice, self).make_cake()# 方法2.2 super().函數()super().__init__()super().make_cake()daqiu = Prentice()daqiu.make_old_cake()注意：使用super() 可以自動查找父類。調用順序遵循 __mro__ 類屬性的順序。比較適合單繼承使用。
八. 私有權限
8.1 定義私有屬性和方法
在Python中，可以為實例屬性和方法設置私有權限，即設置某個實例屬性或實例方法不繼承給子類。
故事：daqiu把技術傳承給徒弟的同時，不想把自己的錢(2000000個億)繼承給徒弟，這個時候就要為錢這個實例屬性設置私有權限。
設置私有權限的方法：在屬性名和方法名 前面 加上兩個下劃線 __。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class Prentice(School, Master):def __init__(self):self.kongfu = '[獨創煎餅果子配方]'# 定義私有屬性self.__money = 2000000# 定義私有方法def __info_print(self):print(self.kongfu)print(self.__money)def make_cake(self):self.__init__()print(f'運用{self.kongfu}制作煎餅果子')def make_master_cake(self):Master.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)# 徒孫類 class Tusun(Prentice):passdaqiu = Prentice() # 對象不能訪問私有屬性和私有方法 # print(daqiu.__money) # daqiu.__info_print()xiaoqiu = Tusun() # 子類無法繼承父類的私有屬性和私有方法 # print(xiaoqiu.__money) # 無法訪問實例屬性__money # xiaoqiu.__info_print()注意：私有屬性和私有方法只能在類里面訪問和修改。
8.2 獲取和修改私有屬性值
在Python中，一般定義函數名get_xx用來獲取私有屬性，定義set_xx用來修改私有屬性值。
class Master(object):def __init__(self):self.kongfu = '[古法煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class School(object):def __init__(self):self.kongfu = '[黑馬煎餅果子配方]'def make_cake(self):print(f'運用{self.kongfu}制作煎餅果子')class Prentice(School, Master):def __init__(self):self.kongfu = '[獨創煎餅果子配方]'self.__money = 2000000# 獲取私有屬性def get_money(self):return self.__money# 修改私有屬性def set_money(self):self.__money = 500def __info_print(self):print(self.kongfu)print(self.__money)def make_cake(self):self.__init__()print(f'運用{self.kongfu}制作煎餅果子')def make_master_cake(self):Master.__init__(self)Master.make_cake(self)def make_school_cake(self):School.__init__(self)School.make_cake(self)# 徒孫類 class Tusun(Prentice):passdaqiu = Prentice()xiaoqiu = Tusun() # 調用get_money函數獲取私有屬性money的值 print(xiaoqiu.get_money()) # 調用set_money函數修改私有屬性money的值 xiaoqiu.set_money() print(xiaoqiu.get_money())課程：面向對象-其他
一. 面向對象三大特性
- 封裝
- 將屬性和方法書寫到類的里面的操作即為封裝
- 封裝可以為屬性和方法添加私有權限
- 繼承
- 子類默認繼承父類的所有屬性和方法
- 子類可以重寫父類屬性和方法
- 多態
- 傳入不同的對象，產生不同的結果
二. 多態
2.1 了解多態
多態指的是一類事物有多種形態，（一個抽象類有多個子類，因而多態的概念依賴于繼承）。
- 定義：多態是一種使用對象的方式，子類重寫父類方法，調用不同子類對象的相同父類方法，可以產生不同的執行結果
- 好處：調用靈活，有了多態，更容易編寫出通用的代碼，做出通用的編程，以適應需求的不斷變化！
- 實現步驟：
- 定義父類，并提供公共方法
- 定義子類，并重寫父類方法
- 傳遞子類對象給調用者，可以看到不同子類執行效果不同
2.2 體驗多態
class Dog(object):def work(self): # 父類提供統一的方法，哪怕是空方法print('指哪打哪...')class ArmyDog(Dog): # 繼承Dog類def work(self): # 子類重寫父類同名方法print('追擊敵人...')class DrugDog(Dog):def work(self):print('追查毒品...')class Person(object):def work_with_dog(self, dog): # 傳入不同的對象，執行不同的代碼，即不同的work函數dog.work()ad = ArmyDog() dd = DrugDog()daqiu = Person() daqiu.work_with_dog(ad) daqiu.work_with_dog(dd)三. 類屬性和實例屬性
3.1 類屬性
3.1.1 設置和訪問類屬性
- 類屬性就是 類對象 所擁有的屬性，它被 該類的所有實例對象所共有。
- 類屬性可以使用 類對象 或 實例對象 訪問。
類屬性的優點
- 記錄的某項數據 始終保持一致時，則定義類屬性。
- 實例屬性 要求 每個對象 為其 單獨開辟一份內存空間 來記錄數據，而 類屬性 為全類所共有 ，僅占用一份內存，更加節省內存空間。
3.1.2 修改類屬性
類屬性只能通過類對象修改，不能通過實例對象修改，如果通過實例對象修改類屬性，表示的是創建了一個實例屬性。
class Dog(object):tooth = 10wangcai = Dog() xiaohei = Dog()# 修改類屬性 Dog.tooth = 12 print(Dog.tooth) # 12 print(wangcai.tooth) # 12 print(xiaohei.tooth) # 12# 不能通過對象修改屬性，如果這樣操作，實則是創建了一個實例屬性 wangcai.tooth = 20 print(Dog.tooth) # 12 print(wangcai.tooth) # 20 print(xiaohei.tooth) # 123.2 實例屬性
class Dog(object):def __init__(self):self.age = 5def info_print(self):print(self.age)wangcai = Dog() print(wangcai.age) # 5 # print(Dog.age) # 報錯：實例屬性不能通過類訪問 wangcai.info_print() # 5四. 類方法和靜態方法
4.1 類方法
4.1.1 類方法特點
- 需要用裝飾器@classmethod來標識其為類方法，對于類方法，第一個參數必須是類對象，一般以cls作為第一個參數。
4.1.2 類方法使用場景
- 當方法中 需要使用類對象 (如訪問私有類屬性等)時，定義類方法
- 類方法一般和類屬性配合使用
4.2 靜態方法
4.2.1 靜態方法特點
- 需要通過裝飾器@staticmethod來進行修飾，靜態方法既不需要傳遞類對象也不需要傳遞實例對象（形參沒有self/cls）。
- 靜態方法 也能夠通過 實例對象 和 類對象 去訪問。
4.2.2 靜態方法使用場景
- 當方法中 既不需要使用實例對象(如實例對象，實例屬性)，也不需要使用類對象 (如類屬性、類方法、創建實例等)時，定義靜態方法
- 取消不需要的參數傳遞，有利于 減少不必要的內存占用和性能消耗
課程：異常
一. 了解異常
當檢測到一個錯誤時，解釋器就無法繼續執行了，反而出現了一些錯誤的提示，這就是所謂的"異常"。
例如：以r方式打開一個不存在的文件。
open('test.txt', 'r')二. 異常的寫法
2.1 語法
try:可能發生錯誤的代碼 except:如果出現異常執行的代碼2.2 快速體驗
需求：嘗試以r模式打開文件，如果文件不存在，則以w方式打開。
try:f = open('test.txt', 'r') except:f = open('test.txt', 'w')2.3 捕獲指定異常
2.3.1 語法
try:可能發生錯誤的代碼 except 異常類型:如果捕獲到該異常類型執行的代碼2.3.2 體驗
try:print(num) except NameError:print('有錯誤')注意：
2.3.3 捕獲多個指定異常
當捕獲多個異常時，可以把要捕獲的異常類型的名字，放到except 后，并使用元組的方式進行書寫。
try:print(1/0)except (NameError, ZeroDivisionError):print('有錯誤')2.3.4 捕獲異常描述信息
try:print(num) except (NameError, ZeroDivisionError) as result:print(result)2.3.5 捕獲所有異常
Exception是所有程序異常類的父類。
try:print(num) except Exception as result:print(result)2.4 異常的else
else表示的是如果沒有異常要執行的代碼。
try:print(1) except Exception as result:print(result) else:print('我是else，是沒有異常的時候執行的代碼')2.5 異常的finally
finally表示的是無論是否異常都要執行的代碼，例如關閉文件。
try:f = open('test.txt', 'r') except Exception as result:f = open('test.txt', 'w') else:print('沒有異常，真開心') finally:f.close()三. 異常的傳遞
體驗異常傳遞
需求：
? 1. 嘗試只讀方式打開test.txt文件，如果文件存在則讀取文件內容，文件不存在則提示用戶即可。
? 2. 讀取內容要求：嘗試循環讀取內容，讀取過程中如果檢測到用戶意外終止程序，則except捕獲異常并提示用戶。
import time try:f = open('test.txt')try:while True:content = f.readline()if len(content) == 0:breaktime.sleep(2)print(content)except:# 如果在讀取文件的過程中，產生了異常，那么就會捕獲到# 比如 按下了 ctrl+cprint('意外終止了讀取數據')finally:f.close()print('關閉文件') except:print("沒有這個文件")四. 自定義異常
在Python中，拋出自定義異常的語法為raise 異常類對象。
需求：密碼長度不足，則報異常（用戶輸入密碼，如果輸入的長度不足3位，則報錯，即拋出自定義異常，并捕獲該異常）。
# 自定義異常類，繼承Exception class ShortInputError(Exception):def __init__(self, length, min_len):self.length = lengthself.min_len = min_len# 設置拋出異常的描述信息def __str__(self):return f'你輸入的長度是{self.length}, 不能少于{self.min_len}個字符'def main():try:con = input('請輸入密碼：')if len(con) < 3:raise ShortInputError(len(con), 3)except Exception as result:print(result)else:print('密碼已經輸入完成')main()模塊和包
一. 模塊
Python 模塊(Module)，是一個 Python 文件，以 .py 結尾，包含了 Python 對象定義和Python語句。
模塊能定義函數，類和變量，模塊里也能包含可執行的代碼。
1.1. 導入模塊
1.1.1 導入模塊的方式
- import 模塊名
- from 模塊名 import 功能名
- from 模塊名 import *
- import 模塊名 as 別名
- from 模塊名 import 功能名 as 別名
1.1.2 導入方式詳解
1.1.2.1 import
- 語法
- 體驗
1.1.2.2 from…import…
- 語法
- 體驗
1.1.2.3 from … import *
- 語法
- 體驗
1.1.2.4 as定義別名
- 語法
- 體驗
1.2. 制作模塊
在Python中，每個Python文件都可以作為一個模塊，模塊的名字就是文件的名字。也就是說自定義模塊名必須要符合標識符命名規則。
1.2.1 定義模塊
新建一個Python文件，命名為my_module1.py，并定義testA函數。
def testA(a, b):print(a + b)1.2.2 測試模塊
在實際開中，當一個開發人員編寫完一個模塊后，為了讓模塊能夠在項目中達到想要的效果，這個開發人員會自行在py文件中添加一些測試信息.，例如，在my_module1.py文件中添加測試代碼。
def testA(a, b):print(a + b)testA(1, 1)此時，無論是當前文件，還是其他已經導入了該模塊的文件，在運行的時候都會自動執行testA函數的調用。
解決辦法如下：
def testA(a, b):print(a + b)# 只在當前文件中調用該函數，其他導入的文件內不符合該條件，則不執行testA函數調用 if __name__ == '__main__':testA(1, 1)1.2.3 調用模塊
import my_module1 my_module1.testA(1, 1)1.2.4 注意事項
如果使用from .. import ..或from .. import *導入多個模塊的時候，且模塊內有同名功能。當調用這個同名功能的時候，調用到的是后面導入的模塊的功能。
- 體驗
1.3. 模塊定位順序
當導入一個模塊，Python解析器對模塊位置的搜索順序是：
模塊搜索路徑存儲在system模塊的sys.path變量中。變量里包含當前目錄，PYTHONPATH和由安裝過程決定的默認目錄。
- 注意
- 自己的文件名不要和已有模塊名重復，否則導致模塊功能無法使用
- 使用from 模塊名 import 功能的時候，如果功能名字重復，調用到的是最后定義或導入的功能。
1.4. __all__
如果一個模塊文件中有__all__變量，當使用from xxx import *導入時，只能導入這個列表中的元素。
- my_module1模塊代碼
- 導入模塊的文件代碼
二. 包
包將有聯系的模塊組織在一起，即放到同一個文件夾下，并且在這個文件夾創建一個名字為__init__.py 文件，那么這個文件夾就稱之為包。
2.1 制作包
[New] — [Python Package] — 輸入包名 — [OK] — 新建功能模塊(有聯系的模塊)。
注意：新建包后，包內部會自動創建__init__.py文件，這個文件控制著包的導入行為。
2.1.1 快速體驗
2.2 導入包
2.2.1 方法一
import 包名.模塊名包名.模塊名.目標2.2.1.1 體驗
import my_package.my_module1my_package.my_module1.info_print1()2.2.2 方法二
注意：必須在__init__.py文件中添加__all__ = []，控制允許導入的模塊列表。
from 包名 import * 模塊名.目標2.2.2.1 體驗
from my_package import *my_module1.info_print1()總結
以上是生活随笔為你收集整理的Python学习之路（四）——Python核心编程3（面向对象、模块_包_异常）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： @SpringBootTest Cano
- 下一篇： python 模块相互import