Python基礎（一）：https://blog.csdn.net/weixin_46818279/article/details/108576298
什麼是公共操作那？？？
公共操作：資料序列基本上都支援的一些操作
| 運運算元 | 描述 | 支援的容器型別 |
|---|---|---|
| + | 合併 | 字串、列表、元組 |
| * | 複製 | 字串、列表、元組 |
| in | 元素是否存在 | 字串、列表、元組、字典 |
| not in | 元素是否存在 | 字串、列表、元組、字典 |
運運算元：+（合併的作用）
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
公共方法之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')
'''
直接上栗子：
# 已有的資料型別和程式想要的資料型別不一樣，這個時候利用函數做型別的轉換就可以了。
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. 集合不支援下標（因為沒有順序）
'''
推導式的作用：簡化程式碼
列表推導式會返回一個列表 ，字典推導式會返回一個字典，集合推導式會返回一個集合
直接上程式碼：推導式如何簡化程式碼的，如何使用推導式
'''
書寫程式碼：
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)]
經過上面這三個栗子，已經對推導式有一定的瞭解了，那麼繼續學習下面推導式的學習。
直接上栗子：
# 建立字典 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}
這個用的不多，簡單的來個栗子：
# 需求：建立一個集合，資料為下方列表的2次方
list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1) # 輸出 {1, 4}
# 集合有資料去重功能，所以這個集合資料只有兩個資料，分別是1，4
三種推導式書寫的格式
1. 列表推導式
[xx for xx in range]
2. 字典推導式
{xx1 : xx2 for ... in ...}
3. 集合推導式
{xx for xx in ...}
Python函數的使用其實跟C、和Java函數的使用都是大同小異的。
函數的作用： 裝程式碼，高效的程式碼重用
基本使用
# 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下方的所有程式碼（函數體內部）不執行
'''
就是自己書寫函數的時候，可以在函數裡寫一個說明檔案，以後通過這個說明檔案可以直接檢視這個函數什麼作用。
# 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)
來個栗子感受一下巢狀呼叫
# 所謂函數巢狀呼叫指的是一個函數裡面有呼叫了另外一個函數
# 需求：兩個函數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
區域性存取
# 定義一個函數，宣告一個變數：函數體內部存取，函數體外部存取
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函數呼叫了，修改了全域性變數。
返回值作為引數傳遞
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)
位置引數
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
體驗參照
# 變數就是儲存資料的名字而已，這個名字就可以理解為參照，再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) # 這是可變型別資料
小總結：
'''
資料的可變型別：如果對資料進行修改，修改的是原資料，這樣的資料是可變型別
資料的不可變型別：如果資料修改的時候改的不是原資料，這樣的資料是不可變型別。
可變型別：
列表
字典
集合
不可變型別：
整型
浮點型
字串
元組
重點： 作用域、函數多返回值、函數的引數
'''
遞迴函數的應用
# 遞迴函數：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:表示式
'''
根據前面所學的知識，把知識綜合起來，來做一個簡單的學生管理系統。
# 定義功能介面
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迴圈不在一起了，就有可能發生問題的。
高階函數作用： 為了化簡程式碼，增加函數的靈活性
這兩個函數的用法比較簡單，來個栗子就會了。but這兩個函數不是高階函數
# abs() 求絕對值用的
print(abs(-10)) # 10
# round() 四捨五入的計算
print(round(1.2)) # 1
print(round(1.6)) # 2
# abs()和round()不是高階函數
先來體驗一下高階函數
# 需求: 任意兩個數位，先進行數位處理（絕對值或四捨五入）在求和運算
# 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]