Python基礎（下篇）

本篇文章主要內容：例外處理，函式，模塊和包，

在開始正篇之前我們先來看看上一篇可樂留下的題目，

題目：

變數 a= {“name”: “可樂”, “age”: 18, “hello”: “python”}，現在要將 a 所有的 key 放入到 b 串列中，所有的 value 放到 c 串列中，

實作方法有很多種，可樂在這里用兩種方式來實作：

代碼實作1：

a = {"name": "可樂", "age": 18, "hello": "python"}
b = []
c = []
for key, value in a.items():
    b.append(key)
    c.append(value)
print(f"存盤key的b串列是{b}")
print(f"存盤value的c串列是{c}")

代碼實作2：

a = {"name": "可樂", "age": 18, "hello": "python"}
b = [key for key in a.keys()]
c = [value for value in a.values()]
print(f"存盤key的b串列是{b}")
print(f"存盤value的c串列是{c}")

注：第二種是串列推導式，上篇可樂沒有提出來，大家可以自行百度或者私聊可樂，

接下來就是我們本篇的主角例外處理，函式，模塊和包，

一、例外處理

何謂例外呢？ 就是我們IT界鼎鼎有名的 " bug " 兄，bug 也就是指程式沒有按照我們所期望的去運行而出現的一些錯誤情況，比如一個除法運算式 a / b ，如果我們不加處理，那么就會出現 a / 0 的情況，此時程式就會出現例外，那么這就是一個 bug ，

何謂例外處理呢？ 顧名思義就是當程式出現例外的時候，我們針對這些例外進行處理的機制，在 python 中默認的處理方法是出現例外后，程式會在出現例外的地方終止，然而這可能不是我們想要的，所以我們可以通過幾個內置的關鍵字來進行自定義處理方式，

我們先來了解兩個 python 的例外處理類：
- BaseException
- Exception

1.1 BaseException

這個例外處理類是所有 python 例外處理的基類，我們在自定義例外處理時，可以繼承這個類，(官方不推薦)

1.2 Exception

這個例外處理類是常規處理的基類，但是 Exception 也繼承于 BaseException ，官方推薦我們自定義例外類時，繼承于 Exception ，(官方檔案）

1.3 例外處理關鍵字

關鍵字：

語法 - try、except、else、finally：

try:
　可能例外的代碼
except Error… as e:
　當出現 Error 后處理的代碼
else:
　如果不出現例外，執行的代碼
finally:
　無論是否發生例外都執行的代碼
注意：一般時候只需要 try / except 即可，try 不可以單獨使用，

示例1：

try:
    a = 1 / 0
except Exception as e:
    print(f"例外是{e}")
?
輸出: 例外是division by zero

示例2：

try:
    a = 1 / 0
except Exception as e:
    print(f"例外是{e}")
else:
    print("沒有例外執行")
finally:
    print("執行了finally")
?
輸出: 例外是division by zero（執行了finally）

語法 - raise：

raise 例外類(描述資訊)
注：raise 用于主動拋出例外，

示例：

try:
    a = 2
    raise ValueError("a不能等于2")
except Exception as e:
    print(f"例外是{e}")
?
輸出 例外是a不能等于2

類可樂會在下一篇python高級之面向物件中詳細解釋，

二、函式

2.1 語法

def func_name(引數):
　代碼部分
　return 回傳值
注：函式可以有回傳值，可以沒有回傳值，

我們先來看看一個簡單的示例：在函式當中計算 1 + 2 + … + 9 的和，并且回傳，

2.1.1 無引數，無回傳值

示例：

def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    print(sum)

那么函式寫好后，我們怎么呼叫它呢？

語法：

func_name(引數)

呼叫函式示例：

num_sum()
?
輸出 45

2.1.2 無引數，有回傳值

示例：

?def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    return sum

我們再來列印一下函式回傳的數值：

def num_sum():
    sum = 0
    for i in range(10):
        sum += i
    return sum
print(num_sum)
?
輸出 45

2.1.3 有引數，無回傳值

示例：

def num_sum(number):
    sum = 0
    for i in range(number):
        sum += i
    print(sum)

在上述函式中我們可以實作1到任何數之間所相加的和，只需要把期望的值傳遞給函式即可，

2.1.4 有引數，有回傳值

示例：

def num_sum(number):
    sum = 0
    for i in range(number):
        sum += i
    return sum
total = num_sum(10)
print(total)

在這里我們用一個變數 total 來接收函式 num_sum 的回傳值，

在函式這里有下面一些重點需要注意(每一個注意點可樂都會有一個示例)，

2.2 注意點

2.2.1 全域變數和區域變數

全域變數：在函式外部定義的變數，
區域變數：在函式內部定義的變數，
- 如果區域變數定義的名字和全域變數定義的名字相同，那么在函式體內區域變數會覆寫全域變數，
- 函式體內變數的作用域或者說生命周期，僅在函式體內有，

示例：

def scope():
    name = "可樂"
    print(f"我是函式體內的{name}")
scope()
print(f"我是函式體外的{name}")

結果如下圖：

我們在函式體內定義的 name 變數是可以正常列印的，但是在函式體外拋出了 name 沒有被定義，

2.2.2 修改全域變數

- 如果是不可變型別，需要通過 global 來宣告操作全域變數；
- 如果是可變型別，那么可以直接操作全域變數不需要通過 global 來宣告，

示例：

a = [1, 2, 3]
b = "可樂"
def scope():
    a.append(4)
    print(f"函式體內a的值是{a}")
    global b
    b = "可樂很帥"
    print(f"函式體內b的值是{b}")
scope()
print(f"全域變數a的值是{a}")
print(f"全域變數b的值是{b}")

結果如下圖：

在函式傳參時，實際情況下無論是可變型別還是不可變型別，傳遞的都是參考，但是由于不可變型別改變值后是用新的記憶體地址來存盤，所以網上有很多這樣一個結論：函式接收引數時，如果引數是可變型別，那么傳遞的是引數的參考；如果引數是不可變型別，那么傳遞的是引數的值，

所以結論是：在 python 函式傳參，無論是可變型別還是不可變型別本質上都是參考傳遞，但是由于不可變型別不能直接修改原有的值，所以在表現上不可變型別是傳值，

示例：

a = 10
b = ["可樂"]
?
def scope(change):
    print(f"改變前s_change的記憶體地址是{id(change)}")
    change = 20
    print(f"改變后s_change的記憶體地址是{id(change)}")
    print(f"改變后s_change的值是{change}")
?
def scope2(change):
    print(f"改變前s2_change的記憶體地址是{id(change)}")
    change.append("很帥")
    print(f"改變后s2_change的記憶體地址是{id(change)}")
    print(f"改變后s2_change的值是{change}")
?
scope(a)
print(f"a的值是{a},a的記憶體地址是{id(a)}")
scope2(b)
print(f"b的值是{b},b的記憶體地址是{id(b)}")

結果如下圖：

2.2.3 函式的不定長引數和關鍵字引數

不定長引數：*args
關鍵字引數：**kwargs
在正常情況下，引數接收幾個引數我們就寫幾個引數名就可以了，可是在實際開發中有的函式的引數并不是固定的，那么我們就可以用關鍵字引數和可變引數來替代，

2.2.3.1 不定長引數

示例：

def scope(*args):
    print(args)
scope(1, 2, 3)
?
輸出: (1,2,3)

在這里的時候需要注意，如果我們在呼叫函式的時候傳遞的是一個元組，而不是 1，2，3 這三個引數，那么這個元組就是一個引數，如果需要達到上述函式的效果，需要對他解包，

示例：

a = (1, 2, 3)
def scope(*args):
    print(args)
scope(a)
scope(*a)

結果如下圖：

重申：如果我們在傳遞函式引數時是一個元組、串列、字典等時，如果不對他解包，那么傳遞的是該元組、串列、字典的整體，如果需要對他的每個元素進行分別傳參，則需要對其解包，

2.2.3.2 關鍵字引數

關鍵字引數是針對字典這鍵值對型別的，

示例：

a = {"name": "可樂", "age": 18}
def scope(**kwargs):
    print(kwargs)
scope(name="可樂", age=18)
scope(**a)

注意：函式引數的匹配順序(指定引數名除外)為從左往右，

示例：

?def scope(name1, name2, name3):
    print(name1)
    print(name2)
    print(name3)
scope("可樂", "python", "是可樂呀")
print()
scope(name3="可樂", name2="是可樂呀", name1="python")

結果如下圖：

注意：如果在函式的引數既有不定長引數和關鍵字引數又有普通引數，那么一定要將普通引數放在最前面，

2.2.4 默認引數

顧名思義：默認引數就是如果我們沒有傳值給這個引數的話，那他就是默認值，

示例1：

def scope(name="可樂"):
    print(name)
scope()
?
輸出: 可樂

示例2：

def scope(name="可樂"):
    print(name)
scope("是可樂呀")
?
輸出: 是可樂呀

2.2.5 匿名引數

解釋：匿名函式也就是這個函式是沒有名字的，不過匿名函式的關鍵字不是通過def來定義，而是 lambda ，

語法：

lambda 引數(可以多個) : 運算式(只能有一個)
注：回傳一個新的函式

示例：

b = lambda x, y: y + x
print(b(1, 2))
?
輸出: 3

解讀：① 定義一個匿名函式用來計算 x+y 的值并且回傳，② 匿名函式定義完后回傳新的函式給變數 b，b 呼叫這個匿名函式并且將引數 1，2 傳遞，③ 列印 x+y 運算式的值，

函式更高層次的理解和使用例如：裝飾器，閉包，可樂會在高級部分講解，

三、模塊和包

模塊：我們可以通俗的理解模塊就是一個 py 檔案包（若干個 py 檔案 + ini.py 組成的檔案夾就是一個包），

init.py 檔案的作用：用于初始化這個包，

如下圖：

如果我們有一個函式或者變數需要從另外的一個包當中參考過來，那么我們應該怎么做呢？答案就是導包，

3.1 導包

語法：

① import module_name
② from xxx import module_name
③ from module_name import *

示例如下圖：


輸出：hello world
其他的兩種方式大家可自己線下測驗，

3.2 模塊的搜索路徑順序

當前主目錄 > PTYHONPATH 目錄（開始安裝 python 時設定的環境變數路徑，忘記可往回看 python 安裝） > 標準的連接庫路徑 > .pth 檔案 > 第三方包（site-package 目錄）

我們也可以通過 sys.path 來查看搜索路徑，

如下圖：

注意：我們根據模塊的搜索路徑順序得知，我們在給包或者模塊取名的時候，一定不要和系統包或者第三方包同名，否則會找不到對應的方法，

3.3 相對路徑和絕對路徑

相對路徑：相對于你的作業目錄的路徑
絕對路徑：以系統的根路徑為為根目錄，如：windows C: linux /

到此Python基礎篇的內容就全部結束了，大家在學習程序中遇到疑問可以私聊可樂，可樂看到了都會一一回復的( ?? ω ?? )?，