python這部分的學(xué)習(xí)，我本身是充滿信心的，畢竟本身工作當(dāng)中用到了pandas，但是在學(xué)習(xí)過程中還是發(fā)現(xiàn)了許多不足，例如循環(huán)部分while True，高級函數(shù)用法等這些細(xì)節(jié)知識點(diǎn)，現(xiàn)在通過復(fù)盤再把這些知識點(diǎn)總結(jié)一下，不理解的地方再多思考和練習(xí)，最終達(dá)到鞏固和熟練基礎(chǔ)知識的目的。

一、輸出

1 格式化輸出

常用格式化字符：
%s-----字符串
%d-----有符號十進(jìn)制整數(shù)
%06d-----表示輸出的整數(shù)顯示位數(shù)，不足的地方使用0補(bǔ)全
%-6d------做左對齊
%f-----浮點(diǎn)數(shù)
%.2f-----表示小數(shù)點(diǎn)后只顯示兩位
%%-----%

2 補(bǔ)充和思考

'-' ：指定左對齊。
'+' ：表示數(shù)值總要帶符號，正數(shù)帶“+”號，負(fù)數(shù)帶 “-” 號。
0 ：表示不補(bǔ)充空格，而是補(bǔ)充 0。
示例如下：

num = 39
print("num is: %06d" % num)      #  最小寬度為6，左邊不足的用 0 補(bǔ)充，輸出：num is: 000039
print("pi is: %010.4f" % pi)      # 最小寬度為10位，小數(shù)點(diǎn)后保留4位，右對齊，左邊補(bǔ)0，輸出：pi is: 00003.1416
name = 'Michael'
print("the name is: %.4s" % name)    # 字符串保留4個字符，輸出：the name is: Mich
print("the name is: %8.2s" % name)  # 保留2個字符，最小寬度為8位，輸出：the name is:       Mi

二 if條件和邏輯語句

1 注意知識點(diǎn)1

當(dāng)使用if條件語句時，最后一行打印無論是否滿足條件都會打印。代碼如下：

age = 18
if age >= 18:
    print("可以進(jìn)入網(wǎng)吧嗨皮")
else:
    print("還沒有長大，回家吧")
# 無論條件是否滿足都會執(zhí)行
print("這句代碼什么時候執(zhí)行？")

2 注意知識點(diǎn)2

當(dāng)定義一個布爾型變量 is_employee，編寫代碼判斷是否是本公司員工的寫法如下：

is_employee = False

if not is_employee: # 等于if is_employee is not True:

    print("do not enter")

3 注意知識點(diǎn)3

elif 和 else 都必須和 if 聯(lián)合使用，而不能單獨(dú)使用，
elif 強(qiáng)調(diào)的是 并列的多種結(jié)果，
邏輯運(yùn)算符 強(qiáng)調(diào)的是 與某個結(jié)果有關(guān)的 多個條件

4 注意知識點(diǎn)4

if 條件語句中使用多個條件的邏輯運(yùn)算時要分別用（）括起來：

# 假定電腦就只會出石頭
player = int(input("請出拳 石頭（1）／剪刀（2）／布（3）："))
computer = 1

# player滿足贏的條件，注意用括號分別括起來
if ((player == 1 and computer == 2) or
    (player == 2 and computer == 3) or
    (player == 3 and computer == 1)):

    print("you win")
elif player == computer:
    print("once again")
else:
    print("you lose")

三 循環(huán)語句

1 while 基本語法規(guī)則

變量設(shè)置初始值 # 注意！

while 條件(判斷 變量是否滿足條件):
    條件滿足時，做的事情1
    條件滿足時，做的事情2
    條件滿足時，做的事情3
    ...(省略)...

    修改變量 # 注意！

舉例(注意在變量設(shè)置初始值和修改變量的用法)：

# 1. 定義重復(fù)次數(shù)計數(shù)器
i = 1

# 2. 使用 while 判斷條件
while i <= 10000:
    # 要重復(fù)執(zhí)行的代碼
    print("媳婦兒，我錯了")
    # 處理計數(shù)器 i
    i = i + 1

2 break用法

在循環(huán)過程中，如果 某一個條件滿足后，不再希望循環(huán)繼續(xù)執(zhí)行，可以使用 break 退出循環(huán)

i = 0
while i < 10:
    # break 某一條件滿足時，退出循環(huán)，不再執(zhí)行后續(xù)重復(fù)的代碼
    # i == 3
    if i == 3:
        break
    print(i)
    i += 1
print("over")

3 continue用法

在循環(huán)過程中，如果 某一個條件滿足后，不希望執(zhí)行本次循環(huán)代碼，但是又不希望退出循環(huán)，可以使用 continue。也就是：在整個循環(huán)中，只有某些條件，不需要執(zhí)行循環(huán)代碼，而其他條件都需要執(zhí)行

i = 0
while i < 10:
    # 當(dāng) i == 7 時，不希望執(zhí)行需要重復(fù)執(zhí)行的代碼
    if i == 7:
        # 在使用 continue 之前，同樣應(yīng)該修改計數(shù)器
        # 否則會出現(xiàn)死循環(huán)
        i += 1
        continue
    # 重復(fù)執(zhí)行的代碼
    print(i)
    i += 1

4 循環(huán)嵌套用法

復(fù)習(xí)例子a

row = 1
while row <= 5:
    # 假設(shè) python 沒有提供字符串 * 操作
    # 在循環(huán)內(nèi)部，再增加一個循環(huán)，實(shí)現(xiàn)每一行的 星星 打印
    col = 1
    while col <= row:
        print("*", end="")
        col += 1
    # 每一行星號輸出完成后，再增加一個換行
    print("")
    row += 1

復(fù)習(xí)例子b

# 定義起始行
row = 1
# 最大打印 9 行
while row <= 9:
    # 定義起始列
    col = 1
    # 最大打印 row 列
    while col <= row:
        # end = ""，表示輸出結(jié)束后，不換行
        # "\t" 可以在控制臺輸出一個制表符，協(xié)助在輸出文本時對齊
        print("%d * %d = %d" % (col, row, row * col), end="\t")
        # 列數(shù) + 1
        col += 1
    # 一行打印完成的換行
    print("")
    # 行數(shù) + 1
    row += 1

5 作業(yè)中注意點(diǎn) while True:

while True:作為無限循環(huán)，經(jīng)常在不知道循環(huán)次數(shù)的時候使用，并且需要在循環(huán)內(nèi)使用break才會停止。采用該語句的核心思想是：如果出現(xiàn)錯誤的話，還可以繼續(xù)循環(huán)，例如在用戶輸入用戶名或密碼錯誤的情況下返回到開始部分，請求繼續(xù)輸入。在作業(yè)中是猜年齡當(dāng)嘗試3次后，還沒猜對，但還想繼續(xù)玩，while True就可以繼續(xù)讓其猜3次，以此往復(fù)。

age_of_oldboy='65'
count=0
while True:
  if count == 3:
      choice=input('繼續(xù)Y/N?: ')
      if choice == 'Y' or choice == 'y':
          count=0
      else:
          break # 重要！！
  guess=input('請輸入年齡: ')

  if guess == age_of_oldboy:
      print('你猜對啦')
      break # 重要?。?
  count+=1

五 列表

1列表的增刪改查

列表.png

a.增加元素

1) 列表.insert(索引，數(shù)據(jù)): 在指定位置插入一個值

2) 列表.append(數(shù)據(jù))：在末尾追加一個值，這個最常用

3) 列表.extend(Iterable)：將另一個列表（也可以）的全部內(nèi)容追加到末尾

注意知識點(diǎn)：使用 append 追加的是將后面的列表作為一個整體追加到最后了，而使用 extend 追加的是將里面的元素依次追加到最后。

b. 刪除元素：

1) del 列表[索引]：刪除指定索引元素

2）列表.remove(數(shù)據(jù))

3）列表.pop()：可指定索引刪除，不指定會刪除最后一個

注意知識點(diǎn)：pop 函數(shù)還有返回值，會返回被刪除的值

c. 修改元素：直接指定索引賦值，就是修改元素內(nèi)容

d. 查詢元素：

1)* 列表[索引]：根據(jù)索引獲取（查詢）值*

2) 列表.index(數(shù)據(jù))：查詢給定值的索引，即想要知道元素的位置，如果查詢元素有多個相同值只會返回第一個值出現(xiàn)的記錄

3) 列表.count(數(shù)據(jù))：查詢值出現(xiàn)的次數(shù)

4) len(列表)：有多少個元素

5) if 數(shù)據(jù) in 列表：判斷元素是否在列表中，用作條件語句中

e. 元素排序：list.sort()

注意知識點(diǎn)：sort 方法還有一個參數(shù)，key，這個參數(shù)是傳遞函數(shù)方法名的，可以傳入自定義的函數(shù)名或者是匿名函數(shù)

list=[5,7,9,0,4,'8']
# 這里是使用 int 函數(shù)，意思是將里面可以轉(zhuǎn)換為數(shù)字的字符串轉(zhuǎn)換成數(shù)字來排序，如果轉(zhuǎn)換不成功會報錯，如‘8d’ 顯示是不能轉(zhuǎn)換為數(shù)字類型的
list.sort(key=int,reverse=True)
print(list)

2 列表的循環(huán)遍歷

a while

while循環(huán)實(shí)現(xiàn)列表的遍歷：打印出列表的所有元素，i 是起到循環(huán)得到索引值的作用

i = 0
name_list = ["zhangsan", "lisi", "wangwu"]
list_count = len(name_list)
while i < list_count:
    name = name_list[i]
    print(name)
    i += 1

b for

for 循環(huán)其實(shí)就是專門用來對高級變量進(jìn)行循環(huán)遍歷的（如元組、字典）

for name in name_list:
    循環(huán)內(nèi)部針對列表元素進(jìn)行操作
    print(name)

3 list 應(yīng)用場景

• 列表 一般只存儲相同類型的數(shù)據(jù)
• 通過 for循環(huán)，在循環(huán)體內(nèi)部，針對列表中的每一項(xiàng)元素，執(zhí)行相同的操作

六 元組

注意：元組的元素不能改變,但是，如果元組中的元素如果為列表/字典時，則可以修改列表/字典中的元素的值,數(shù)據(jù)之間使用，分隔。

1 元組的查詢

查詢.png

tuple=(5,7,3,7)

print(tuple)
# 根據(jù)索引查詢值
print(tuple[0])
# 根據(jù)值查詢索引
print(tuple.index(7))
# 求值出現(xiàn)的次數(shù)
print(tuple.count(7))
# 求元組的長度：即元素個數(shù)
print(len(tuple))
# for 遍歷
for n in tuple:
    print(n)

2 應(yīng)用場景：自動組包

自動組包的默認(rèn)類型：組包后是一個元組，可以用來快速交換兩個變量的值

a=3
b=4
# 賦值的右側(cè)有多個數(shù)據(jù)時，會自動組包成元組
# 如果賦值的左側(cè)接收的變量和右側(cè)的變量的個數(shù)一致，就會自動解包，一一對應(yīng)賦值
b,a=a,b
# 注意：右側(cè)組包后相當(dāng)于是變成了一個元組
# b,a=(a,b)
print(a)
print(b)

# 如果個數(shù)不一致左邊就得到一個元組
c=a,b
print(c)
print(type(c))

七 字典

字典使用鍵值對(key、value對)存儲數(shù)據(jù)，鍵值對之間使用,分隔

• 鍵 key 索引：注意索引不再是 0，1，2... 了，雖然可以用數(shù)字，但是一般使用字符串
• 值 value 數(shù)據(jù)
• key:value 之間使用：分隔
• 鍵必須是唯一的：如果有多個，后者會覆蓋前者
• 值 可以取任何數(shù)據(jù)類型，但鍵只能字符串、數(shù)字或元組
• 字典是無序?qū)ο蟮募?/li>

1 字典的增改刪查

字典.png

a 增加元素

1) 字典[鍵] = 數(shù)據(jù)

鍵不存在，會添加鍵值對；鍵存在，會修改鍵值對的值

b 刪除元素

1） del 字典[鍵]

2) 字典.pop(鍵)

注意：pop 刪除成功了會返回被刪除的值

3) 字典.clear

c 修改元素

1) 字典[鍵] = 數(shù)據(jù)

2) 字典.setdefault(鍵，數(shù)據(jù))

3) 字典.update(字典2)

d 查詢元素

1）字典[鍵]：注意不能根據(jù)值來查詢鍵

2）字典.get(鍵)

2 字典的遍歷

• 字典.keys()、字典.values()、
• 字典.items()：返回的是一個元組
• 以上三個都是視圖對象類型，可以用for遍歷，也可以轉(zhuǎn)換為list
• 直接對一個字典進(jìn)行 for 遍歷，取出來的是 鍵

3 應(yīng)用

• 使用 多個鍵值對，存儲 描述一個 物體 的相關(guān)信息 —— 描述更復(fù)雜的數(shù)據(jù)信息
• 將 多個字典 放在 一個列表 中，再進(jìn)行遍歷，在循環(huán)體內(nèi)部針對每一個字典進(jìn)行 相同的處理

八 函數(shù)

1 定義

• 定義函數(shù)：在函數(shù)中編寫代碼，實(shí)現(xiàn)功能
• 調(diào)用函數(shù)：執(zhí)行編寫代碼
  定義函數(shù)的格式如下：

def 函數(shù)名():

    函數(shù)封裝的代碼
    ……

函數(shù)的執(zhí)行順序總結(jié)：

? 程序代碼始終都是順序執(zhí)行的，也就是從第一行到最后一行，但在程序執(zhí)行到 def func 定義函數(shù)的語句時不會運(yùn)行函數(shù)，而是將函數(shù)名作為標(biāo)識符添加到內(nèi)存中而不會運(yùn)行函數(shù)里面的代碼。而當(dāng)程序繼續(xù)往下，到調(diào)用函數(shù)的語句時，就會到內(nèi)存中查詢是否有該函數(shù)，如果有就調(diào)用函數(shù)名對應(yīng)的函數(shù)代碼。這里也有一個要注意的事項(xiàng)，就是函數(shù)調(diào)用必須在函數(shù)定義后，不然找不到函數(shù)會報錯。

注意：函數(shù)體相對比較獨(dú)立，函數(shù)定義的上方，應(yīng)該和其他代碼（包括注釋）保留 兩個空行

2 函數(shù)的參數(shù)

a 如何處理只能固定數(shù)值相加的函數(shù)？？

def sum_2_num():

    num1 = 10
    num2 = 20
    result = num1 + num2

    print("%d + %d = %d" % (num1, num2, result))

sum_2_num()

解決：

def sum_2_num(num1, num2):

    result = num1 + num2

    print("%d + %d = %d" % (num1, num2, result))

sum_2_num(50, 20)

總結(jié)：函數(shù)的參數(shù)增加了函數(shù)的通用性，針對相同的數(shù)據(jù)處理邏輯，能適應(yīng)更多的數(shù)據(jù)

• 函數(shù)內(nèi)部，把把參數(shù)當(dāng)做 變量 使用，進(jìn)行需要的數(shù)據(jù)處理
• 函數(shù)調(diào)用時，按照函數(shù)定義的參數(shù)順序，把 希望在函數(shù)內(nèi)部處理的數(shù)據(jù)，通過參數(shù) 傳遞

b 形參和實(shí)參

• 形參：定義 函數(shù)時，小括號中的參數(shù)，是給真實(shí)數(shù)據(jù)占位用的，在函數(shù)內(nèi)部 作為變量使用
• 實(shí)參：調(diào)用 函數(shù)時，小括號中的參數(shù)，是傳遞到 函數(shù)內(nèi)部 的 真實(shí)數(shù)據(jù)

a = 5  

def test1(a): 
    # 這里 a 是形參，是在函數(shù)內(nèi)部定義的，作用域只在函數(shù)內(nèi)部
    a += 1
    print("%d" % a)

test1(2)  
# 這里因?yàn)樾螀⒌淖饔糜虿坏竭@里，所以這個 a 是外面的 a
print("%d" % a)

3 函數(shù)返回值

def sum_2_num(num1, num2):
    """對兩個數(shù)字的求和"""

    return num1 + num2

# 調(diào)用函數(shù)，并使用 result 變量接收計算結(jié)果
result = sum_2_num(10, 20)

print("計算結(jié)果是 %d" % result)

a 關(guān)于return

• return 后面可以不跟值

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)
    return

• 函數(shù)中凡是代碼執(zhí)行到 return 時，都會終止函數(shù)的執(zhí)行，返回到函數(shù)調(diào)用的代碼處。所以可以靈活利用 return 結(jié)束程序

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)

    return
    # 這行代碼不會執(zhí)行了
    print('不會執(zhí)行這行代碼')

res=func_sum()
print(res)

4 四種函數(shù)類型

1 無參數(shù)，無返回值的函數(shù)

此類函數(shù)，不能接收參數(shù)，也沒有返回值，一般情況下，打印提示燈類似的功能，使用這類的函數(shù)

def print_menu():
    print('--------------------------')
    print('      xx涮涮鍋 點(diǎn)菜系統(tǒng)')
    print('')
    print('  1.  羊肉涮涮鍋')
    print('  2.  牛肉涮涮鍋')
    print('  3.  豬肉涮涮鍋')
    print('--------------------------')

2 無參數(shù)，有返回值的函數(shù)

此類函數(shù)，不能接收參數(shù)，但是可以返回某個數(shù)據(jù)，一般情況下，像采集數(shù)據(jù)，用此類函數(shù)

# 獲取溫度
def get_temperature():
    # 這里是獲取溫度的一些處理過程
    # 為了簡單起見，先模擬返回一個數(shù)據(jù)
    return 24

temperature = get_temperature()
print('當(dāng)前的溫度為:%d' % temperature)

3 有參數(shù)，無返回值的函數(shù)

此類函數(shù)，能接收參數(shù)，但不可以返回數(shù)據(jù)，一般情況下，對某些變量設(shè)置數(shù)據(jù)而不需結(jié)果時，用此類函數(shù)

4 有參數(shù)，有返回值的函數(shù)

# 計算1~num的累積和
def calculate_num(num):
    result = 0
    i = 1
    while i < =num:
        result = result + i
        i += 1
    return result

result = calculate_num(100)
print('1~100的累積和為:%d' % result)

5 列表推導(dǎo)式

• 基本方式：
• a=[x for x in range(4)]
• b=[x for x in range(1,7) if x%2!=0]
• d=[(x,y) for x in range(1,4) for y in range(3,5)]

6 匿名函數(shù)

a 語法： lambda [參數(shù)列表]: 表達(dá)式

b 要點(diǎn)

lambda 表達(dá)式的幾個要點(diǎn)：

• lambda 表達(dá)式必須使用 lambda 關(guān)鍵字定義。
• 在 lambda 關(guān)鍵字之后、冒號左邊的是參數(shù)列表，可以不給參數(shù)，也可以給多個參數(shù)。多個參數(shù)用逗號分隔，冒號右邊是 lambda 表達(dá)的返回值。
• lambda 表達(dá)式也叫做匿名函數(shù)，也是單行函數(shù)體的函數(shù)。

c 應(yīng)用

• 對于單行函數(shù)，使用 lambda 表達(dá)式更簡潔，省去定義函數(shù)的過程。
• 對于不需要多次復(fù)用的函數(shù)，使用 lambda 表達(dá)式可以在用完之后立即釋放，提高性能。

# 計算平方
x = map(lambda x: x * x, range(5))
 print([i for i in x])
# 計算偶數(shù)的平方
y = map(lambda x: x * x if x % 2 ==0 else 0, range(5))
print([i for i in y])

注意：Lambda函數(shù)能接收任何數(shù)量的參數(shù)但只能返回一個表達(dá)式的值，匿名函數(shù)不能直接調(diào)用print，因?yàn)閘ambda需要一個表達(dá)式

d 函數(shù)作為參數(shù)傳遞

# 定義一個函數(shù)
def fun(a, b, opt):
     print("a = %s" % a)
     print("b = %s" % b)
     print("result =%s" % opt(a, b))

# 調(diào)用函數(shù)
fun(1, 2, lambda x,y:x+y)

e 作為內(nèi)置函數(shù)的參數(shù)

# 作為內(nèi)置函數(shù)的參數(shù)
stus = [
    {"name": "zhangsan", "age": 18},
    {"name": "lisi", "age": 19},
    {"name": "wangwu", "age": 17}
]
# 字典中每個key
a = map(lambda x: x['name'],stus)
print([i for i in a])
# 按name排序
stus.sort(key=lambda x:x['name'])
print(stus)
# 按age排序
stus.sort(key=lambda x:x['age'])
print(stus)

九 高級函數(shù)

1 局部變量

• 局部變量，就是在 函數(shù)內(nèi)部定義的變量
• 局部變量的作用域只在函數(shù)內(nèi)部

2 全局變量

• 在函數(shù)外邊定義的變量叫做 全局變量
• 全局變量能夠在所有的函數(shù)中進(jìn)行訪問

# 定義全局變量
a = 100

def test1():
    print(a)

def test2():
    print(a)

# 調(diào)用函數(shù)
test1()
test2()

• 函數(shù)內(nèi)修改全局變量: global 聲明

a = 10

def test():
    global a
    a = 5  # 修改全局變量
    print("函數(shù)內(nèi)a：%d" %a)

test()
print("函數(shù)外a：%d" %a)

3 函數(shù)返回值二

a 多個return

def is_even_num(num):
    """判斷奇偶數(shù)"""
    if num % 2 == 0:
        return True
    else:
        return False

b 多個返回值

def func2():
    return 1,1.5

#返回多個數(shù)據(jù)時，自動將數(shù)據(jù)組包成元組
a = func2()
print(a)

#用多個變量接收返回值，python會自動將元組 拆包 成單個數(shù)據(jù)
a,b = func2()
print(a)
print(b)

a,b,c = 1,1.5,"hello"
print(a)
print(b)
print(c)

當(dāng)返回多個數(shù)據(jù)時，python會自動將數(shù)據(jù) 組包 成元組,如果使用多個變量接收返回值，python會自動將元組 拆包 成單個數(shù)據(jù)

4 函數(shù)參數(shù)二

a 默認(rèn)參數(shù)

• 形參設(shè)定默認(rèn)值 稱為 默認(rèn)參數(shù)
• 調(diào)用函數(shù)時，如果沒有傳入默認(rèn)參數(shù)對應(yīng)的實(shí)參，則實(shí)參使用默認(rèn)值。

def printinfo(name, age = 35):
   # 打印任何傳入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

# 調(diào)用printinfo函數(shù)
printinfo("miki")
printinfo("miki", 20)

• 注意：默認(rèn)參數(shù)一定要位于參數(shù)列表的最后面。

b 關(guān)鍵字參數(shù)（缺省參數(shù)）

調(diào)用函數(shù)時，實(shí)參可以指定對應(yīng)的形參，稱為 關(guān)鍵字參數(shù)

def printinfo(name, age):
   # 打印任何傳入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

printinfo(age=9,name="miki" )

c 可變參數(shù)

1) args 元組可變參數(shù)

• 函數(shù)可以定義 可變參數(shù)，用于接收任意數(shù)量的參數(shù)
• 可變參數(shù)的前邊需要添加*，用于提示python解釋器該參數(shù)為可變參數(shù)
• 使用可變參數(shù)直接用args即可（不需要加*）
• 可變參數(shù)的本質(zhì)是 將傳遞的參數(shù)包裝成了元組

def sum_num(a, b, *args):  
    result = a + b
    for temp in args:
        result += temp

    return result

sum_num(1, 2, 3, 4, 5, 6)

# 關(guān)鍵字參數(shù)一旦使用，所有實(shí)參都要使用，除非該實(shí)參對應(yīng)的是可變參數(shù)
# sum_num(1, 2, 3, 4, a=5)
# sum_num(a=5, b=4)

2）kwargs 字典可變參數(shù)

• 字典可變參數(shù)：可以接受多余的關(guān)鍵字參數(shù)
• 字典可變參數(shù)必須要放在形參的最后面
• 定義參數(shù)時需要在變量名前添加兩個*
• 這種可變參數(shù)會將 不存在的關(guān)鍵字參數(shù)包裝成字典

def sum_num(a, b, *args, **kwargs):  
    print(a)
    print(b)
    print(args)
    print(kwargs)

sum_num(1, 2, 3, 4, 5, 6, mm=5, nn=6)

ｄ函數(shù)的參數(shù)傳遞機(jī)制

Python 中函數(shù)的參數(shù)傳遞機(jī)制都是“值傳遞”，就是將實(shí)際參數(shù)值的副本（復(fù)制品）傳入函數(shù)，而參數(shù)本身不會受到任何影響。示例如下：

# 傳遞可變參數(shù)
def sum_num(a, b, *args, **kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)

def test(*args, **kwargs):
    print(args)
    print(kwargs)

sum_num(1, 2, 3, 4, 5, 6, 7, mm=5, nn=6)

5 總結(jié)

Python 中的函數(shù)是“一等公民”，因此函數(shù)本身也是一個對象，函數(shù)即可用于賦值，也可用作其函數(shù)的參數(shù)，還可作為其他函數(shù)的返回值。