【詳細】Python基礎（二）

前言

1. 在Python基礎（一）中，非常感謝大家的點贊、收藏、評論、關注，
2. 在Python基礎（二）中，盡量用簡潔易懂的方式來梳理知識點，
3. 如果對你的學習有幫助，點個贊支持一下，一鍵三連哦~😄

Python基礎（一）：https://blog.csdn.net/weixin_46818279/article/details/108576298

7. 公共操作

什么是公共操作那？？？

公共操作：資料序列基本上都支持的一些操作

7.1 運算子

運算子：+（合并的作用）

str1 = 'aa'
str2 = 'bb'

list1 = [1,2]
list2 = [10,20]

t1 = (1,2)
t2 = (10,20)

dict1 = {'name':'tom'}
dict2 = {'age':30}

# 1. + : 合并
print(str1+str2)      # 輸出 aabb
print(list1+list2)    # 輸出 [1, 2, 10, 20]
print(t1+t2)          # 輸出 (1, 2, 10, 20)
print(dict1+dict2)    # 報錯：字典不支持合并運算

運算子：*（復制的作用）

str1 = 'a'
list = ['hello']
t1 = ('world',)

#   *:復制   支持字串、串列、元組
print(str1 * 5)  # 輸出aaaaa
print('-' * 10)  # 輸出10個----------
print(list * 5)  # 輸出['hello', 'hello', 'hello', 'hello', 'hello']
print(t1 * 5)    # 輸出 ('world', 'world', 'world', 'world', 'world')

運算子：in、not in（判斷元素是否存在）

str1 = 'abcd'
list1 = [10,20,30]
t1 = (100,200,300)
dict1 = {'name':'Python', 'age':30}
# in 和 not in

# 1. 字符a是否存在
print('a' in str1)  # 輸出 True
print('a' not in str1)  # 輸出 false

# 2. 資料10是否存在
print(10 in list1)   # 輸出True
print(10 not in list1)  # 輸出False

# 3. 100是否存在
print(100 in t1)    # 輸出 True
print(100 not in t1)   # 輸出Fasle

# 4. name是否存在
print(dict1)
print('name' in dict1)   # True
print('name' not in dict1)  # False
print('name' in dict1.keys()) # True
print('name' in dict1.values() ) # False

7.2 公共方法

公共方法之len()、del()、max()、min()、range(start,end,step)、enumerate()
這六個函式的作用以及用法，舉栗子說明

（1）len()：計算容器中元素的個數

str1 = 'abcd'
list1 = [10, 20, 30]
t1 = (100, 200, 300)
dict1 = {'name':'Python', 'age':30}
s1 = {10 , 20}

# len() 計算容器中元素個數
print(len(str1))  # 輸出4
print(len(list1)) # 輸出3
print(len(t1))    # 輸出3
print(len(dict1)) # 輸出2
print(len(s1))    # 輸出2

（2）del()：洗掉

str1 = 'abcd'
list1 = [10, 20, 30]
t1 = (100, 200, 300)
dict1 = {'name':'Python', 'age':30}
s1 = {10 , 20}

# 1. del 目標 或者 del(目標)

# str1字串
del str1      # 洗掉整個字串
print(str1)   # 報錯說明已經洗掉成功

============================================================================
# list1 串列
del(list1)
print(list1) # 報錯說明已經洗掉成功

# del(list1[0])
# print(list1)  # 輸出[20, 30]

# del list1[0]
# print(list1)   # 輸出[20, 30]

==============================================================================

# dict1 字典
del dict1
print(dict1) # 報錯，已經洗掉成功
del dict1['name']
print(dict1)   #  輸出結果為 {'age': 30}

==============================================================================

# s1 集合
del s1
print(s1) # 報錯，已經洗掉成功

（3） max()：回傳容器中元素最大值
min()：回傳容器中元素最小值

str1 = 'abcde'
list1 = [10, 20, 30]

# 1. max()最大值
print(max(str1))  # 輸出e
print(max(list1))  # 輸出30

# 2. min():最小值
print(min(str1))  # 輸出a
print(min(list1)) # 輸出10

（4）range()：生成從start到end的數字，步長為step，供for回圈使用

"""
注意事項：
    1. 如果不寫開始，默認從0開始
    2. 如果不寫步長，默認為1
"""

print(range(1,10,1)) # 輸出 range(1, 10)，回傳的是可迭代的物件，需要配合for回圈才能拿到數字
for i in range(1,10,1):
    # 遍歷可迭代物件，并且拿到了物件內部的這些數字
    print(i)       # 輸出的是1，2，3，4，5，6，7，8，9

for i in range(1,10):
    print(i)        # 如果不寫步長，則默認步長是1

for i in range(1,10,2):
    print(i)       # 因為步長是2，所以輸出1，3，5，7，9

for i in range(10):
    print(i)      # 這里的10代表結束，開始不寫，默認從0開始，步長不寫，默認為1， 但是不能不寫結束！

（5）enumerate()：函式用于將一個可遍歷的資料物件（如串列、元組或字串）組合為一個索引序列，同時列出資料和資料下標，一般用于在for回圈當中，

# 1. 語法： enumerate(可遍歷物件，start = 0)
# 2. start引數用來設定遍歷資料的下標的起始值，默認為0

list1 = ['a', 'b', 'c', 'd', 'e']
# enumerate 回傳結果是元組，元組第一個資料是原迭代物件的資料對應的下標，元組第二個資料是原迭代物件的資料
for i in enumerate(list1):
	print(i)
'''
輸出的結果為：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
'''

for i in enumerate(list1,start = 1):
    print(i)
'''
這時的start為1，輸出的結果為：
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')
'''

7.3 容器型別轉換

直接上栗子：

# 已有的資料型別和程式想要的資料型別不一樣，這個時候利用函式做型別的轉換就可以了，

list1 = [10,20,30]
s1 = {100, 200, 300}
t1 = ('a', 'b', 'c')

# tuple():將某個序列轉換成元組
print(tuple(list1))  # 輸出結果為(10, 20, 30)
print(tuple(s1))    # 輸出結果為(200, 100, 300)

# list():轉換成串列
print(list(s1))      # 輸出結果為 [200, 100, 300]
print(list(t1))     # 輸出結果為 ['a', 'b', 'c']

# set():轉換成集合
print(set(list1))   # 輸出結果為{10, 20, 30}
print(set(t1))      # 輸出結果為{'c', 'b', 'a'}

'''
注意：
    1. 集合可以快速完成串列去重
    2. 集合不支持下標（因為沒有順序）
'''

8. 推導式

推導式的作用：簡化代碼

串列推導式會回傳一個串列 ，字典推導式會回傳一個字典，集合推導式會回傳一個集合

8.1 串列推導式

直接上代碼：推導式如何簡化代碼的，如何使用推導式

'''
書寫代碼：
	1. 創建空串列
	2. 回圈將有規律的資料寫入到串列
	
方法實作:
	1. 回圈實作 
	2. 串列推導式（化簡代碼，創建或控制有規律的串列）

得出結論：
	1. 串列推導式代碼量最少，起到了簡化代碼的作用
'''
=========================================================================

# while 實作
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)  # 輸出結果為[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

==========================================================================

# for 實作
# 用for實作比while實作所需的代碼量少
list1 = []
for i in range(10):
    list1.append(i)
print(list1)   # 輸出結果為[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

==========================================================================

# 串列推導式實作
list1 = [i for i in range(10)]  # 中括號里面第一個i,是接收資料的回傳值，然后保存在串列中
print(list)    # 輸出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

再舉個栗子：帶if的串列推導式

# 需求：0-10偶數資料的串列

# 1. 簡單的串列推導式，range()步長實作
list1 = [i for i in range(0,10,2)]
print(list1)        # 輸出結果為 [0, 2, 4, 6, 8]

# 2. for回圈加if 創建有規律的串列
list2 = []
for i in range(10):
    if i % 2 == 0:
        list2.append(i)
print(list2)

# 3. 把for回圈配合if的代碼 改寫 帶if的串列推導式
list3 = [i for i in range(10) if i % 2 == 0]
print(list3)

再來個栗子：

'''
需求：創建串列如下：[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]
1. 用for回圈嵌套的方法進能夠解決
    資料1：1 和 2 range(1,3)
    資料2：0 1 2 用 range(3)
2. 用串列推導式解決：多for的串列推導式等同于for回圈嵌套，就是去掉標點、回車符和縮進，

'''

# 1. 用for回圈嵌套

list1 = []
for i in range(1,3):
    for j in range(3):
        # 串列里面追加元素：回圈前準備一個空串列，然后這里追加元組資料到串列
        list1.append((i,j))
print(list1)   # 輸出結果為[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]


# 2. 多個for實作串列推導式

list2 = [(i,j) for i in range(1,3) for j in range(3)]
print(list2)    # 輸出結果為[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

經過上面這三個栗子，已經對推導式有一定的了解了，那么繼續學習下面推導式的學習，

8.2 字典推導式

直接上栗子：

# 創建字典 key是1-4的數字，value是這個數字的平方
dict1 = {i: i**2 for i in range(1,5)}
print(dict1)  # 輸出 {1: 1, 2: 4, 3: 9, 4: 16}

再舉個栗子：合并串列為字典

# 1. 長度一樣的串列合并字典
# list1 = ['name', 'age', 'gender']
# list2 = ['tom', 20, 'man']
# dict1 = {list1[i]: list2[i] for i in range(len(list1))}
# print(dict1)   # 輸出的結果為 {'name': 'tom', 'age': 20, 'gender': 'man'}

# 長度不一樣的串列合并成字典
list3 = ['name', 'age', 'gender', 'id']
list4 = ['tom', 20, 'man']

# 下面的陳述句會報錯，因為不對等，如果取長的串列len(list3)則會報錯
# dict1 = {list3[i]: list4[i] for i in range(len(list3))}

# 下面的陳述句才正確
dict2 = {list3[i]: list4[i] for i in range(len(list4))}
print(dict2)   # 輸出結果為{'name': 'tom', 'age': 20, 'gender': 'man'}

'''
總結：
    1. 如果兩個串列資料個數相同，len統計任何一個串列的長度都可以
    2. 如果兩個串列資料個數不同，len統計資料多的串列資料個數會報錯，len統計資料少的串列資料個數不會報錯
'''

再來個栗子：提取字典中的目標資料

counts = {'MBP': 268, 'HP':125,  'DELL':201, 'Lenovo': 199, 'acer': 99}

'''
1. 需求：提取電腦臺數大于等于200
獲取所有鍵值對資料，判斷v值大于等于200回傳
'''

# 回傳一個迭代器，內部是元組dict_items([('MBP', 268), ('HP', 'DELL'), ('Lenovo', 199), ('acer', 99)])
print(counts.items())

# 提取字典中目標資料，這個用法非常重要！！！
dict1 = {key:value for key,value in counts.items() if value >= 200}
print(dict1)  # {'MBP': 268, 'DELL': 201}

8.3 集合推導式

這個用的不多，簡單的來個栗子：

# 需求：創建一個集合，資料為下方串列的2次方
list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1)   # 輸出 {1, 4}
# 集合有資料去重功能，所以這個集合資料只有兩個資料，分別是1，4

8.4 推導式總結

三種推導式書寫的格式

1. 串列推導式
[xx for xx in range]

2. 字典推導式
{xx1 : xx2  for ... in ...}

3. 集合推導式
{xx for xx in ...}

9. Python函式

Python函式的使用其實跟C、和Java函式的使用都是大同小異的，

函式的作用： 裝代碼，高效的代碼重用

9.1 函式的使用

基本使用

# 1. 定義函式
def sel_func():
    print('I Love Python')

# 2. 函式呼叫
print('恭喜你登錄成功')
sel_func()

'''
注意
	1. 不同的需求，引數可有可無
	2. 在Python中，函式必須先定義后使用
	3. 當呼叫函式的時候，解釋器回到定義函式的地方去執行下方縮進的代碼，當這些代碼執行完，
	   回到呼叫函式的地方繼續向下執行定義函式的時候，函式體內部縮進的代碼并沒有執行
'''

有引數的函式

函式的引數：函式呼叫的時候可以傳入真實資料，增大函式的使用的靈活性
形參：函式定義時書寫的引數（非真實資料）
實參：函式呼叫時書寫的引數（真實資料）

# 引數形式傳入真實資料，做加法運算
# 這里的a、b是形參
def add_num2(a,b):
    result = a + b
    print(result)

# 10，20是實參
add_num2(10,20)  # 輸出30

函式中return的作用

def buy():
    return '煙'
    # print('ok')   #這一行代碼不執行

goods = buy()
print(goods)

'''
return 作用：
			1. 負責函式回傳值
			2. 退出當前函式：導致return下方的所有代碼（函式體內部）不執行
'''

9.2 函式的說明檔案

就是自己書寫函式的時候，可以在函式里寫一個說明檔案，以后通過這個說明檔案可以直接查看這個函式什么作用，

# len是內置函式，早在定義的時候就已經封裝好說明檔案了
# 自己寫的函式沒有說明檔案，為了方便后期查看這種解釋說明的資訊更快捷更方便，定義函式的同時，定義一個說明檔案就可以了
# 函式內部縮進的第一行書寫的多行注釋才是說明檔案，如果敲了回車，則會更詳細的顯示（引數和回傳值），

help(len)  # help函式作用：查看函式的說明檔案（函式解釋說明的資訊）
# def sum_num(a,b):
#     ''' 求和函式 '''  # 定義函式的說明檔案
#     return a + b
# help(sum_num)

# 函式的說明檔案的高級使用， 就是多行注釋按回車，會出現引數1、2和renturn,說明他們的作用，
def sum_num1(a,b):
    '''
    求和函式sum_num1
    :param a: 引數1
    :param b: 引數2
    :return: 回傳值
    '''
    return a + b
help(sum_num1)

9.3 函式的嵌套呼叫

來個栗子感受一下嵌套呼叫

# 所謂函式嵌套呼叫指的是一個函式里面有呼叫了另外一個函式

# 需求：兩個函式testA 和 testB  ---- 在A里面嵌套呼叫B


def testB():
    print('B函式開始-----')
    print('這是B函式')
    print('B函式結束-----')

def testA():
    print('A函式開始')
    # 嵌套呼叫B
    testB()
    print('A函式結束')

testA()

列印橫線圖形

def print_line():
    print('-' * 20)

# 函式嵌套呼叫，實作多條橫線
def print_lines(num):
    i = 0
    while i < num:
        print_line()
        i += 1

print_lines(5)

任意三個數求平均值

#  任意三個數求平均值
# Python語言當中，做除法運算，不管參與運算的是不是浮點數，只要是除法，結果就是浮點數，

def sum_num(a,b,c):
    return a + b + c
    
def average_num(a, b ,c):
    # 先求和，再除以3
    sumResult = sum_num(a, b, c)
    return sumResult / 3

averageResult = average_num(1, 2, 3)
print(averageResult)   # 輸出結果為 2.0

9.4 變數的作用域

區域訪問

# 定義一個函式，宣告一個變數：函式體內部訪問，函式體外部訪問
def testA():
    a = 100
    print(a)  # 函式體內部訪問，能訪問到a變數

testA()
print(a) # 報錯：a變數是函式內部的變數，函式外部無法訪問，這里的a是一個區域變數

訪問全域變數

# 宣告全域變數：函式體內外都能訪問
a = 100 
print(a)

def testA():
    print(a)

def testB():
    print(a)

testA()
testB()

修改全域變數

# 函式體內修改全域變數

a = 100
print(a)  # 輸出100

def testA():
    print(a)

def testB():
    global a
    a = 200
    print(a)

testA()     # 輸出100
testB()     # 輸出200
print(a)    # 輸出200
'''
總結：
    1. 如果在函式里面直接把變數a = 200賦值，此時的a不是全域變數的修改，而是相當于在函式內部宣告了一個新的區域變數
    2. 函式體內部修改全域變數：先global宣告a為全域變數，然后再變數重新賦值
'''

多函式執行流程

# 1.宣告全域變數 2. 定義兩個函式 3.函式1修改全域變數：函式2訪問全域變數
glo_num = 0

def test1():
    global glo_num
    glo_num = 100

def test2():
    print(glo_num)


 # 疑問：已經再test1中修改了全域變數，為什么這個地方輸出結果不是100？因為進行函式呼叫，沒有執行函式體內的代碼，
print(glo_num)  # 輸出結果為0
test2()  # 輸出的結果為0，還是因為因該全域變數的函式沒有執行

test1()  # 執行了函式體內的代碼
test2()  # 輸出100
print(glo_num)  # 輸出100，因為test1函式呼叫了，修改了全域變數，

9.5 函式回傳值（多回傳值）

回傳值作為引數傳遞

def test1():
    return 50

def test2(num):
    print(num)

# 先得到函式1的回傳值，再把這個回傳值傳入到函式2
result = test1()
test2(result)

函式的回傳值（多回傳值）

# 需求：一個函式有兩個回傳值1和2
# 一個如果有多個return不能都執行，只執行第一個return：無法做到一個函式多個回傳值

# def return_num():
#     return 1
#     return 2
#
# result = return_num()
# print(result)  # 輸出結果為1，第二個return不起作用

'''
1. 下面是一個函式多個回傳值的正確寫法
2. return a,b寫法，回傳多個資料的時候，默認是元組型別
3. return后面可以連接串列、元組或字典，以回傳多個值
'''

def return_num():
    return 1,2   # 回傳值是元組
    # return 后面可以直接寫元組、串列、字典、回傳多個值.
    # return (10,20)  # 回傳的是元組
    # return [100,200]  # 回傳的是串列
    # return {'name':'Python', 'age': 20} # 回傳的是字典
result = return_num()
print(result)  # return 1,2 輸出結果是(1, 2)

9.6 函式的引數的型別

位置引數

def user_info(name,age,gender):
    print(f'您的姓名是{name},年齡是{age}，性別是{gender}')

user_info('tom',20,'男') # 輸出結果為 您的姓名是tom,年齡是20，性別是男

# 注意：傳遞和定義引數的順序及個數必須一致
# user_info('tom',20) # 個數定義和傳入不一致會報錯
# user_info(20,'tom','男')  # 順序也和定義必須是一致的，否則倒是資料無意義

關鍵字引數

# 函式呼叫，通過"鍵=值"形式加以指定
def user_info(name,age,gender):
    print(f'您的姓名是{name},年齡是{age}，性別是{gender}')

# 1. 呼叫函式傳參
user_info('jack', age=20 , gender='男')   # 您的姓名是jack,年齡是20，性別是男

# 2. 關鍵字引數之間部分先后循序
user_info('jack', gender='男', age=20)   # 您的姓名是jack,年齡是20，性別是男

# 3. 位置引數必須寫在關鍵字引數的前面
# user_info(age=20 , gender='男', 'jack')  # 報錯了，必須關鍵詞放在前面

預設引數

'''
1.預設引數（默認引數）：為了節省用戶的時間成本，提高用戶體驗，可以把一些需求上帶有默認值的這種引數，設定成一個默認值，這樣寫法的引數，叫做預設引數（默認引數），
2. 所有的位置引數必須出現在默認引數的前面
3. 函式呼叫時，如果為預設引數傳值則修改默認引數值；否則使用這個默認值
'''

def user_info(name,age,gender='男'):    # gender='男'是預設引數
    print(f'您的姓名是{name},年齡是{age}，性別是{gender}')

# 沒有為預設引數傳值，表示使用默認值
user_info('tom', 18)  # 您的姓名是tom,年齡是18，性別是男

# 為預設引數傳值，使用了gender='女 '，即修改了默認值
user_info('tom', 18, gender='女') # 您的姓名是tom,年齡是18，性別是女

不定長引數之位置引數

'''
1.不定長引數也叫可變引數，用于不確定呼叫的時候會傳遞多少個引數（不傳也可以）的場景，
  此時可以用包裹位置引數或者包裹關鍵字引數，來進行引數傳遞，
2. 傳進的所有引數都會被args變數收集，它會根據傳進引數的位置合并為一個元組，args是元組型別，這就是包裹位置傳遞
'''

# 接收所有位置引數，回傳一個元組
def user_info(*args):
    print(args)

# 包裹位置傳遞
# 如果是*args接收不定長的位置參資料，可以傳資料，也可以不傳資料，無論傳與不傳，將來接收的都是所有位置引數，回傳的是都是一個元組
user_info()              #  ()
user_info('tom')        #  ('tom',)
user_info('tom', 20)     #  ('tom', 20)
user_info('tom', 20,'男')  #  ('tom', 20, '男')

不定長引數之關鍵字引數

# 收集所有關鍵字引數，回傳一個字典
# 包裹關鍵字傳遞
def user_info(**kwargs):
    print(kwargs)

user_info()
user_info(name='tom')
user_info(name='tom', age=20)

# 無論是包裹位置傳遞還是包裹關鍵字傳遞，都是一個組包的程序

擴展1：拆包

上面說了不定長引數是組包的程序，那就來說一下拆包的程序

# 1. 拆包元組資料
# def return_num():
#     return 100, 200

# result = return_num()
# print(result)    # 輸出 (100, 200)

# num1, num2 = return_num()
# print(num1)   # 輸出 100
# print(num2)   # 輸出 200

# 2. 字典資料拆包：變數存盤的資料是key值
# 先準備字典，然后拆包
dict1 = {'name': 'tom', 'age': 20}
# dict1中有兩個鍵值對，拆包的時候用兩個變數接收資料
a , b = dict1
print(a)     # 輸出name
print(b)     # 輸出age

# 提取value的值
print(dict1[a])     # 輸出tom
print(dict1[b])     # 輸出20
print(dict1['name'])  # 輸出tom

擴展2：交換變數的值

# 方法1：
a= 10
b = 20

c = 0
c = a
a = b
b = c

print(a)   # 20
print(b)   # 10

# 方法2：
a, b = 1, 2
print(a)  # 輸出1
print(b)  # 輸出2

a, b = 1, 2
a, b = b, a
print(a)  # 輸出2
print(b)  # 輸出1

9.7 參考作實參

體驗參考

# 變數就是存盤資料的名字而已，這個名字就可以理解為參考，再python語言中資料其實傳遞來傳遞去都是通過變數的形式來傳遞的
# 簡單粗暴的理解，參考就是變數名，參考可以當作實參傳入到函式里面

# 1. 不可變型別：int
# 1.1 宣告變數保存整型資料，把這個資料賦值到另一個變數：id()檢測兩個變數的id值（記憶體的十進制值）
a = 1
b = a
print(b)     # 輸出1
# 發現a和b的id值相同的
print(id(a))   # 輸出 140708418216784
print(id(b))    # 輸出 140708418216784

# 修改a的資料測驗id值
a = 2

print(b)   # 輸出1

# 因為修改了a的資料，記憶體要開辟另外一份記憶體存盤2，id()檢測a和b的地址不同
print(id(a))  # 輸出 140708418216816
print(id(b))  # 輸出 140708418216784


============================================================================

# 2. 可變型別：串列

aa = [10, 20] 
bb = aa
print(bb)       # [10, 20]

print(id(aa))    # 2266328490632
print(id(bb))	# 2266328490632

# 增加資料
# 串列是可變型別
aa.append(30)
print(aa)   # [10, 20, 30]
print(bb)   # [10, 20, 30]

print(id(aa))  # 2266328490632  地址值
print(id(bb))  # 2266328490632

參考當作實參

def test(a):
    print(a)
    print(id(a))

    a += a
    print(a)
    print(id(a))

b = 100
test(b)    # 這是不可變型別資料

c = [11, 22]
test(c)    # 這是可變型別資料

9.8 可變和不可變型別匯總

小總結：

'''
資料的可變型別：如果對資料進行修改，修改的是原資料，這樣的資料是可變型別
資料的不可變型別：如果資料修改的時候改的不是原資料，這樣的資料是不可變型別，

可變型別：
    串列
    字典
    集合
不可變型別：
    整型
    浮點型
    字串
    元組
    
重點： 作用域、函式多回傳值、函式的引數

'''

9.9 遞回函式和匿名函式（lambda）

遞回函式的應用

# 遞回函式：1.內部自己呼叫自己  2.必須有出口
# 遞回是一種編程思想，函式是編程的一種體現
# return有兩個作用: 1. 回傳值 2. 退出當前函式

'''
需求：3以內數字累加和3 + 2 + 1 = 6
6 = 3 + 2以內數字累加和
2以內的累加和 = 2 + 1以內的累加和
1以內的累加和 = 1   # 出口
'''

def sum_numbers(num):
    # 2.出口
    if num == 1:
        return 1
    # 1. 當前數字 + 當前數字減一的累加和
    return num + sum_numbers(num - 1)

result = sum_numbers(3)
print(result)

# 如果沒有出口，報錯：超出最大遞回深度

匿名函式lambda，來個栗子感受一下

'''
應用場景：
    1.lambda的作用就是簡化代碼
    2.如果一個函式有一個回傳值，并且只有一句代碼，可以使用lambda簡化
語法：lambda 引數串列 ：運算式
注意：
    lambda運算式的引數可有可無，函式的引數在lambda運算式中完全適用
    lambda運算式能接收多個引數但只能回傳一個運算式的值
'''

# 需求：函式 回傳值100
# 1. 函式
# def fn1():
#     return 100
#
# result = fn1()
# print(result)


# 2. lambda 匿名函式,就是不在用def陳述句定義的函式，如果要宣告匿名函式，則要使用lambda關鍵字
# lambda引數串列：運算式
fn2 = lambda : 100
print(fn2)   # lambda記憶體地址
# 100回傳值 呼叫函式
print(fn2())   # 100

lambda的引數形式

# 1.無引數
# fn1 = lambda: 100
# print(fn1())

# 2. 一個引數
# fn2 = lambda a: a
# print(fn2('hello world'))

# 3. 默認引數/預設引數
# fn3 = lambda a, b, c = 200 : a + b + c
# print(fn3(10, 20))
# print(fn3(10, 20, 300))

# 4. 可變引數：*args
# fn4 = lambda *args: args
# print(fn4(10))
# print(fn4(10, 20))
# print(fn4(10,20,30,40))    # (10, 20, 30, 40)

# 5. 可變引數: **kwargs
fn5 = lambda **kwargs : kwargs
print(fn5(name = 'Python'))
print(fn5(name = 'Python', age = 30))   # {'name': 'Python', 'age': 30}

帶判斷的lambda

# lambda應用
# 1. lambda 兩個數字比大小，誰大回傳值

fn1 = lambda a, b : a if a > b else b
print(fn1(1000, 500))   # 1000

串列資料排序

'''
students是一個序列名，指代的就是串列序列，key等于一個 lambda的運算式，
這里面就用到了lambda，sort里面有個引數key，如果串列里面有字典，按照字典某個key進行排序用的，
將來要進行升或降序排序的資料，這里指得是字典，回傳值，排序的依據是name key還是age key
里面形參x指代的是所有的字典，
'''
students = [
    {'name':'tom','age':20},
    {'name':'jock','age':21},
    {'name':'rose','age':22}
]

# 1. name key對應的值進行降序排序
students.sort(key=lambda x: x['name'])
print(students)
# 2. age key對應的值進行升序排序
students.sort(key=lambda x: x['age'])
print(students)
# 3. age key對應的值進行降序排序
students.sort(key=lambda x: x['age'],reverse=True)
print(students)

lambda小總結

'''
一、 lambda 
   （1）語法
        lambda 引數串列: 運算式
        
    （2）lambda的引數形式
    
        無引數:
            lambda: 運算式
            
        一個引數(多個引數用逗號隔開):
            lambda 引數:運算式
            
        默認引數:
            lambda key=value:運算式
            
        不定長位置引數:
            lambda *args:運算式
            
        不定長關鍵字引數:
            lambda **kwargs:運算式
'''

10. 學生管理系統

根據前面所學的知識，把知識綜合起來，來做一個簡單的學生管理系統，

# 定義功能界面
def info_print():
    print('請選擇功能------------------')
    print('1. 添加學生')
    print('2. 洗掉學生')
    print('3. 修改學生')
    print('4. 查詢學生')
    print('5. 顯示所有學生')
    print('6. 退出系統')
    print('-' * 20)

info = []
# 所有的功能函式都是操作學生資訊，所有存盤所有學生資訊應該是一個全域變數，資料型別為串列，


#  添加學生資訊的函式
def add_info():
    """添加學生函式"""     # 添加函式的說明檔案
    pass                 # 當我們還不知道函式體內部要寫什么代碼的時候，加一個pass作占位，，避免語法出現錯誤，
    # 1.用戶輸入：學號、姓名、手機號
    new_id = input('請輸入學號：')
    new_name = input('請輸入姓名：')
    new_tel = input('請輸入手機號：')

    # 2. 判斷是否添加這個學生，如果學生姓名已經存在報錯提示；如果姓名不存在則添加資料
    global info

    # 2.1 不允許姓名重復：判斷用戶輸入的姓名 和 串列里面字典的name對應的值相等，提示
    for i in info:
        if new_name == i['name']:
            print('此用戶已經存在')
            # return作用：退出當前函式：準備空字典，字典新增資料，串列追加字典
            return

    # 2.2 如果輸入的姓名不存在，添加資料：準備空字典，字典新增資料，串列追加資料
    info_dict = {}

    # 字典新增資料
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel
    # print(info_dict)

    # 串列追加字典
    info.append(info_dict)
    print(info)


# 洗掉學生
def del_info():
    """洗掉學生"""
    del_name = input('請輸入要洗掉學生的姓名：')
    global info   # 宣告全域變數
    for i in info:      # 遍歷串列
        if del_name == i['name'] :
            # 如果姓名存在，則在串列洗掉資料
            info.remove(i)
            break
    else:        # else的作用：當回圈正常結束要執行的代碼，就是遍歷完串列中的資料，還沒有break，
        print('該學員不存在！！！')
    print(info)



# 修改函式
def modify_info():
    """修改學生資訊"""
    modify_name = input('請輸入要修改的學生的姓名：')
    global info
    for i in info:
        if modify_name == i['name']:
            i['tel'] = input('請輸入新的手機號：')
            break
    else:
        print('該學生不存在！！！')
    # 列印info
    print(info)


# 查詢學員資訊
def search_info():
    """查詢學生資訊"""
    search_name = input('請輸入要查詢的學生的姓名：')
    global info  # 宣告全域變數
    for i in info:
        if search_name == i['name'] :
            print('查詢到的學生資訊如下--------------------------')
            print(f"學生的學號：{i['id']} , 姓名：{i['name']},   手機號：{i['tel']}")
            break
    else:
        print('查無此人.....')


# 顯示所有學生資訊
def print_all():
    '''顯示所有學生資訊'''
    print('學號\t姓名\t手機號')
    # 列印所有學生的資料
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")




while True:
# 1. 顯示功能界面
    info_print()

# 2. 用戶輸入功能序號
    user_num = int(input('請輸入功能序號：'))

# 3. 按照用戶輸入的功能序號，執行不同的功能（函式）

    if user_num == 1:
        # print('添加')
        add_info()
    elif user_num == 2:
        # print('洗掉')
        del_info()
    elif user_num == 3:
        # print('修改')
        modify_info()
    elif user_num == 4:
        # print('查詢')
        search_info()
    elif user_num == 5:
        # print('顯示所有')
        print_all()
    elif user_num == 6:
        # 退出系統
        exit_flag = input('確定要退出嗎？yes or no：')
        if exit_flag == 'yes':
            break   # break是最主要的
    else:
        print('輸入的功能序號有誤')

# 這個退出系統功能，不用函式去做，1.代碼比較簡單 2.有一個必要的功能，封裝到函式里面可能會出問題
# 退出系統依賴于break，break是當一定條件成立，終止回圈用的，終止的是就近的這一層回圈，如果把這些代碼封裝
# 一個函式里面去，這個時候跟while True回圈不在一起了，就有可能發生問題的，

11. 高級函式

高階函式作用： 為了化簡代碼，增加函式的靈活性

11.1 abs()和round()函式

這兩個函式的用法比較簡單，來個栗子就會了，but這兩個函式不是高階函式

# abs() 求絕對值用的
print(abs(-10))  # 10


# round()  四舍五入的計算
print(round(1.2))  # 1
print(round(1.6))  # 2

# abs()和round()不是高階函式

11.2 內置高階函式（map、reduce、filter）

先來體驗一下高階函式

# 需求: 任意兩個數字，先進行數字處理（絕對值或四舍五入）在求和運算

# 1. 寫法一
def add_num(a,b):
    # 絕對值
    return abs(a) + abs(b)

result = add_num(-1.1, 1.0)
print(result)    # 2.1

# 2. 寫法二
def sum_num(a, b, f):
    return f(a) + f(b)

result1 = sum_num(-1,-2,abs)
print(result1)  # 3

result2 = sum_num(1.2, 1.4, round)
print(result2)  # 2

# 方法二的代碼更加簡潔，函式靈活性較快
# 函式式編程大量使用函式，減少了代碼的重復，因此程式比較短，開發速度較快
'''
高階函式：把函式作為引數傳入，這樣的函式稱為高階函式，高階函式是函式式編程的體現，函式式編程就是指這種高度抽象的編程范式，
高階函式其實作用就是為了化簡代碼，增加函式的靈活性
'''

map()函式

'''
map(func, lst),將傳入的函式變數func作用到lst變數的每個元素中,并將結果組成新的串列(Python2)/
迭代器(Python3)回傳
'''

# 1. 準備串列資料
list1 = [1, 2, 3, 4, 5]

# 2. 準備2次方計算的函式
def func(x):
    return x ** 2

# 3. 呼叫map
result = map(func, list1)

# 4. 驗收成果
# 在列印迭代器的時候,只能回傳記憶體地址,這時要用list()轉換資料型別
print(result)     # 輸出 <map object at 0x00000208211131D0>
print(list(result))  # [1, 4, 9, 16, 25]

reduce函式

'''
reduce(func, lst),其中func必須有兩個引數. 每次func計算的結果繼續和序列的下一個元素作累計計算.
注意: reduce()傳入的引數func必須接收2個引數
'''

list1 = [1, 2, 3, 4, 5]
# 1. 匯入模塊
import functools

# 2.定義功能模塊
def func(a, b):
    return a + b

# 3. 呼叫reduce. 作用:功能函式計算的結果和序列的下一個資料作累計計算
result = functools.reduce(func, list1)
print(result)    # 輸出結果為 15    

filter()函式

'''
filter(func, lst)函式用于過濾序列,過濾掉不符合條件的元素,回傳一個filter物件. 如果要轉換為串列,可以使用list()來轉換
'''
list1 = [1,2,3,4,5,6,7,8,9,10]

# 1. 定義功能函式:過濾序列中的偶數
def func(x):
    return x % 2 == 0

# 2. 呼叫filter
result = filter(func,list1)
print(result)       # <filter object at 0x000002AEA49031D0>
print(list(result))      # [2, 4, 6, 8, 10]