python這部分的學習，我本身是充滿信心的，畢竟本身工作當中用到了pandas，但是在學習過程中還是發現了許多不足，例如循環部分while True，高級函數用法等這些細節知識點，現在通過復盤再把這些知識點總結一下，不理解的地方再多思考和練習，最終達到鞏固和熟練基礎知識的目的。

一、輸出

1 格式化輸出

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

2 補充和思考

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

num = 39
print("num is: %06d" % num)      #  最小寬度為6，左邊不足的用 0 補充，輸出：num is: 000039
print("pi is: %010.4f" % pi)      # 最小寬度為10位，小數點后保留4位，右對齊，左邊補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 注意知識點1

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

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

2 注意知識點2

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

is_employee = False

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

    print("do not enter")

3 注意知識點3

elif 和 else 都必須和 if 聯合使用，而不能單獨使用，
elif 強調的是 并列的多種結果，
邏輯運算符 強調的是 與某個結果有關的 多個條件

4 注意知識點4

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

# 假定電腦就只會出石頭
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")

三 循環語句

1 while 基本語法規則

變量設置初始值 # 注意！

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

    修改變量 # 注意！

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

# 1. 定義重復次數計數器
i = 1

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

2 break用法

在循環過程中，如果 某一個條件滿足后，不再希望循環繼續執行，可以使用 break 退出循環

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

3 continue用法

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

i = 0
while i < 10:
    # 當 i == 7 時，不希望執行需要重復執行的代碼
    if i == 7:
        # 在使用 continue 之前，同樣應該修改計數器
        # 否則會出現死循環
        i += 1
        continue
    # 重復執行的代碼
    print(i)
    i += 1

4 循環嵌套用法

復習例子a

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

復習例子b

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

5 作業中注意點 while True:

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

age_of_oldboy='65'
count=0
while True:
  if count == 3:
      choice=input('繼續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(索引，數據): 在指定位置插入一個值

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

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

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

b. 刪除元素：

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

2）列表.remove(數據)

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

注意知識點：pop 函數還有返回值，會返回被刪除的值

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

d. 查詢元素：

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

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

3) 列表.count(數據)：查詢值出現的次數

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

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

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

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

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

2 列表的循環遍歷

a while

while循環實現列表的遍歷：打印出列表的所有元素，i 是起到循環得到索引值的作用

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 循環其實就是專門用來對高級變量進行循環遍歷的（如元組、字典）

for name in name_list:
    循環內部針對列表元素進行操作
    print(name)

3 list 應用場景

• 列表 一般只存儲相同類型的數據
• 通過 for循環，在循環體內部，針對列表中的每一項元素，執行相同的操作

六 元組

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

1 元組的查詢

查詢.png

tuple=(5,7,3,7)

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

2 應用場景：自動組包

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

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

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

七 字典

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

• 鍵 key 索引：注意索引不再是 0，1，2... 了，雖然可以用數字，但是一般使用字符串
• 值 value 數據
• key:value 之間使用：分隔
• 鍵必須是唯一的：如果有多個，后者會覆蓋前者
• 值 可以取任何數據類型，但鍵只能字符串、數字或元組
• 字典是無序對象的集合

1 字典的增改刪查

字典.png

a 增加元素

1) 字典[鍵] = 數據

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

b 刪除元素

1） del 字典[鍵]

2) 字典.pop(鍵)

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

3) 字典.clear

c 修改元素

1) 字典[鍵] = 數據

2) 字典.setdefault(鍵，數據)

3) 字典.update(字典2)

d 查詢元素

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

2）字典.get(鍵)

2 字典的遍歷

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

3 應用

• 使用 多個鍵值對，存儲 描述一個 物體 的相關信息 —— 描述更復雜的數據信息
• 將 多個字典 放在 一個列表 中，再進行遍歷，在循環體內部針對每一個字典進行 相同的處理

八 函數

1 定義

• 定義函數：在函數中編寫代碼，實現功能
• 調用函數：執行編寫代碼
  定義函數的格式如下：

def 函數名():

    函數封裝的代碼
    ……

函數的執行順序總結：

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

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

2 函數的參數

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

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)

總結：函數的參數增加了函數的通用性，針對相同的數據處理邏輯，能適應更多的數據

• 函數內部，把把參數當做 變量 使用，進行需要的數據處理
• 函數調用時，按照函數定義的參數順序，把 希望在函數內部處理的數據，通過參數 傳遞

b 形參和實參

• 形參：定義 函數時，小括號中的參數，是給真實數據占位用的，在函數內部 作為變量使用
• 實參：調用 函數時，小括號中的參數，是傳遞到 函數內部 的 真實數據

a = 5  

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

test1(2)  
# 這里因為形參的作用域不到這里，所以這個 a 是外面的 a
print("%d" % a)

3 函數返回值

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

    return num1 + num2

# 調用函數，并使用 result 變量接收計算結果
result = sum_2_num(10, 20)

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

a 關于return

• return 后面可以不跟值

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

• 函數中凡是代碼執行到 return 時，都會終止函數的執行，返回到函數調用的代碼處。所以可以靈活利用 return 結束程序

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

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

res=func_sum()
print(res)

4 四種函數類型

1 無參數，無返回值的函數

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

def print_menu():
    print('--------------------------')
    print('      xx涮涮鍋 點菜系統')
    print('')
    print('  1.  羊肉涮涮鍋')
    print('  2.  牛肉涮涮鍋')
    print('  3.  豬肉涮涮鍋')
    print('--------------------------')

2 無參數，有返回值的函數

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

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

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

3 有參數，無返回值的函數

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

4 有參數，有返回值的函數

# 計算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 列表推導式

• 基本方式：
• 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 匿名函數

a 語法： lambda [參數列表]: 表達式

b 要點

lambda 表達式的幾個要點：

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

c 應用

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

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

注意：Lambda函數能接收任何數量的參數但只能返回一個表達式的值，匿名函數不能直接調用print，因為lambda需要一個表達式

d 函數作為參數傳遞

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

# 調用函數
fun(1, 2, lambda x,y:x+y)

e 作為內置函數的參數

# 作為內置函數的參數
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)

九 高級函數

1 局部變量

• 局部變量，就是在 函數內部定義的變量
• 局部變量的作用域只在函數內部

2 全局變量

• 在函數外邊定義的變量叫做 全局變量
• 全局變量能夠在所有的函數中進行訪問

# 定義全局變量
a = 100

def test1():
    print(a)

def test2():
    print(a)

# 調用函數
test1()
test2()

• 函數內修改全局變量: global 聲明

a = 10

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

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

3 函數返回值二

a 多個return

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

b 多個返回值

def func2():
    return 1,1.5

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

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

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

當返回多個數據時，python會自動將數據 組包 成元組,如果使用多個變量接收返回值，python會自動將元組 拆包 成單個數據

4 函數參數二

a 默認參數

• 形參設定默認值 稱為 默認參數
• 調用函數時，如果沒有傳入默認參數對應的實參，則實參使用默認值。

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

# 調用printinfo函數
printinfo("miki")
printinfo("miki", 20)

• 注意：默認參數一定要位于參數列表的最后面。

b 關鍵字參數（缺省參數）

調用函數時，實參可以指定對應的形參，稱為 關鍵字參數

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

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

c 可變參數

1) args 元組可變參數

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

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)

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

2）kwargs 字典可變參數

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

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)

ｄ函數的參數傳遞機制

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

# 傳遞可變參數
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 總結

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