print() 在控制臺輸出
input() 獲取控制臺輸?的內(nèi)容
type() 獲取變量的數(shù)據(jù)類型
len() 獲取容器的?度 (元素的個數(shù))
range() ?成?個序列[0, n)
#函數(shù)可以實現(xiàn)?個特定的功能
我們學(xué)習(xí)??如何定義函數(shù), 實現(xiàn)特定的功能 ???
函數(shù): 將多?代碼(可以實現(xiàn)?個特定的功能)放在?塊,并給它起 ?個名字. 在需要使?多?代碼的時候, 可以使?名字代替.
定義函數(shù)的好處: 減少代碼冗余(重復(fù)的代碼不需要多次書寫),提 ?編程效率
函數(shù)必須 先定義 后 調(diào)?
定義：
def 函數(shù)名():
函數(shù)封裝的代碼
……
1. def 是英文 define 的縮寫
2. 處在 def 縮進中的代碼 都屬于這個函數(shù)
3. 函數(shù)名最好能夠表達函數(shù)內(nèi)部封裝的代碼的功能, 方便后續(xù)的獲取調(diào)用[見名知意]
4. 函數(shù)名命名遵循標(biāo)識符命名規(guī)則: 字母, 數(shù)字, 下劃線, 不能以數(shù)字開頭, 不用使用系統(tǒng)關(guān)鍵字
5. def 這?代碼的最后需要?個 冒號
6. 函數(shù)定義 不會執(zhí)?函數(shù)中的代碼,想要執(zhí)?,需要調(diào)?
調(diào)用:
1. 只定義函數(shù), 不調(diào)用函數(shù), 函數(shù)永遠(yuǎn)不會被執(zhí)行
2. 不能將 函數(shù)調(diào)用 放在 函數(shù)定義 的上方，否則將會出現(xiàn)錯誤
函數(shù)名()
演練：
#需求：
#1. 編寫一個打招呼 say_hello 的函數(shù)，封裝三行打招呼的代碼
#2. 在函數(shù)下方調(diào)用打招呼的代碼
def say_hello():
print("hello")
print("hello")
print("hello")
say_hello()
1, 函數(shù)的?檔注釋,本質(zhì)就是注釋, 只不過作?和書寫位置有特定的要求
2, 作?: 是對函數(shù)的作?和使??法進?說明, ?如 有哪些參數(shù), 返回值是什么
3, 書寫位置: 在def 的下?,使? 三對雙引號來書寫
---------------------------------------------------------------------------------------------------------
4, 查看
4.1 在函數(shù)名上,使? 快捷鍵 Ctrl+Q 查看
4.2 在函數(shù)名上,使? 快捷鍵 Ctrl+B 跳轉(zhuǎn)到函數(shù)定義的地?查看
4.3 在函數(shù)名上, 按住 Ctrl 鍵,點擊函數(shù)名,跳轉(zhuǎn)到函數(shù)定義的地?查看
參數(shù): 在函數(shù)定義的時候,在括號中寫?變量,這個變量就稱為是函數(shù)的參數(shù).
形式參數(shù)(形參)在函數(shù)調(diào)?的時候,可以給定義時候的形參傳遞具體的數(shù)據(jù)值,供其使?.
實際參數(shù)(實參)即: 在函數(shù)調(diào)?的時候,會將函數(shù)的實參值傳遞給形參.
好處: 可以讓函數(shù)更加的通?, 函數(shù)中的數(shù)據(jù)值不是固定的,是調(diào)?的時候,你傳遞的.
使?場景: 判斷 函數(shù)中 數(shù)據(jù)值是不是固定不變的, 如果是變化的,就可以使?參數(shù)傳遞
注意點: ?前書寫的函數(shù), 如果存在形參,必須傳遞相同個數(shù)的實參.
def sun_2_num(a, b): # a, b 形參
c = a + b
print(c)
sun_2_num(10, 20) # 10, 20 實參 10 給 a, 20 給 b
sun_2_num(1, 2)
sun_2_num(20, 39)
在一個函數(shù)中調(diào)用另一個函數(shù)。
1，代碼從上到下執(zhí)行的
2，函數(shù)定義不會指定函數(shù)中的代碼
3, 函數(shù)調(diào)?會進?函數(shù)中執(zhí)?函數(shù)中的代碼
4, 函數(shù)中的代碼執(zhí)?結(jié)束,會回到調(diào)?的地?繼續(xù)向下執(zhí)?
# 1. 定義名為test01的函數(shù)，打印當(dāng)前函數(shù)的名稱
def test01():
print(1)
print('func01')
print(2)
# 2. 定義名為test02的函數(shù)，打印當(dāng)前函數(shù)的名稱，并 調(diào)?
test01函數(shù)
def test02():
print(3)
print('func2')
test01()
print(4)
print(5)
test02()
print(6)
# 5 3 1 2 4 6
返回值：函數(shù)執(zhí)行的結(jié)果
print()--->None
input()--->鍵盤輸入的類容，類型：字符串
type() --->變量的數(shù)據(jù)類型
len() --->容器?度
1, 在?個函數(shù)中,想要返回?個數(shù)據(jù)(想要有返回值), 需要使?return 關(guān)鍵字
2, 為什么返回值? 在函數(shù)中可能通過各種代碼,得到的數(shù)據(jù)結(jié)果,想要在函數(shù)外部使?,就需要使?返回值
3, 如果函數(shù)有返回值, ?般在調(diào)?的時候 會使?變量來接收(保存) 返回值, 以便后續(xù)使?
4, return 關(guān)鍵字的作?,
- 將?個數(shù)據(jù)值返回到調(diào)?的地?
- 函數(shù)遇到 return 會結(jié)束函數(shù)的執(zhí)?
5, return 關(guān)鍵字只能?在函數(shù)中
6, 如果?個函數(shù) 沒有寫 return,可以認(rèn)為 返回值是 None
# 設(shè)計?個函數(shù)?于獲取兩個數(shù)中的較?數(shù)，數(shù)據(jù)來?于函數(shù)的
def get_max(a, b):
if a > b:
return a
else:
return b #函數(shù)代碼遇到return，函數(shù)結(jié)束
print('我會執(zhí)?嗎, 不會執(zhí)?') #不會執(zhí)行
num = get_max(10, 20)
print(num) #20
需求:
1. 定義名為 input_username 的函數(shù), 獲取用戶輸入的用戶名
2. 定義名為 input_password 的函數(shù), 獲取用戶輸入的密碼
3. 定義名為 login 的函數(shù), 判斷獲取的用戶名和密碼信息
4. 要求當(dāng)獲取的用戶名為:admin 并且密碼為: 123456 時, 輸出“登錄成功!”，否則提示“用戶名或密碼錯誤!”
def input_username():
username = input("請輸入用戶名：")
return (username)
def input_password():
password = input("請輸入密碼：")
return (password)
def login():
name = input_username()
pwd = input_password()
if name == "admin" and pwd == "123456":
print("登錄成功！")
else:
print("用戶名或密碼錯誤！")
login()
1, 在Python 中, 每個代碼?件 都可以稱為是?個模塊
2, 在模塊中 別?書寫好的功能(變量, 函數(shù), 類),我們可以拿來直接使?
3, 我們??寫的代碼?件, 想要作為模塊讓別?使?, 你的代碼?件名(模塊名) 滿?標(biāo)識符的規(guī)則
4, 想要使? 別?模塊中寫好的功能,需要先導(dǎo)?別?寫好的功能
5, as 關(guān)鍵字 , 可以給模塊或者功能起別名 #from tools import sum2_num as su2 在下面就可以用su2代替
?式?
import 模塊名 # 模塊名 就是代碼?件名 ,不要 .py
# 使?其中的功能
模塊名.功能名 # 功能可以是變量, 函數(shù) 和類
# 多?于 導(dǎo)?系統(tǒng)中的常?的模塊和功能
import random
num = random.randint(1, 10)
print(num)
?式?
from 模塊名 import 功能名 # 導(dǎo)?指定的功能
# 使?
功能名()
# ?式? 多?于導(dǎo)???書寫的,或者是第三?的模塊
# 可以使?快捷鍵 Alt 回?
from random import randint
num = randint(1, 10)
print(num)
1. 定義?個模塊 tools.py , 在模塊中定義?個函數(shù)sum_2_num(), 可以對兩個數(shù)字求和
2. 新定義?個代碼?件, 調(diào)? tools.py ?件中的sum_2_num() 函數(shù), 對 10 和 20 求和
#tolls.py
def sum2_num(a,b):
"""求a+b的和"""
return (a+b)
#新定義?個代碼?件
from tools import sum2_num
print(sum2_num(10,20))
1, 導(dǎo)?模塊的時候, 會執(zhí)?模塊中的代碼
2, 作?: 如果在導(dǎo)?模塊的時候, 模塊中的部分代碼不想被執(zhí)?, 可以使? __name__ 來解決
3, __name__ 變量,是 Python 解釋器內(nèi)置的變量(變量的值是?動維護的), 每個代碼?件中,都有這個變量
當(dāng)被其他模塊導(dǎo)入后運行時, __name__ 屬性值為 模塊名
當(dāng)在模塊內(nèi)運行時, __name__ 屬性值為 __main__
快捷鍵：main
# tolls.py
def sum2_num(a, b):
"""求a+b的和"""
return (a + b)
print(f"myname is {__name__}") # 在模塊和包.py執(zhí)行時myname is tools
if __name__ == '__main__':
# 在這個 if 的縮進中書寫的代碼,導(dǎo)?的時候不會被執(zhí)?
print(f"myname id {__name__}") #myname is __main__
print(sum2_num(100, 200)) #300
#模塊和包.py
from tools import sum2_num
print(sum2_num(10,20))
快捷鍵:main
1, 在導(dǎo)?模塊的時候, 會先從代碼所在的?錄進?導(dǎo)?
2, 如果沒有找到,會去 Python 系統(tǒng)的?錄查找導(dǎo)?
3, 如果沒有找到, 報錯
----------------------------------------------------
注意點: 我們??定義的代碼?件名字 不要和你導(dǎo)?的系統(tǒng)的模
塊?件名?樣
包: 將多個模塊放在?個?錄中集中管理,
并在這個?錄中創(chuàng)建?個 __init__.py ?件(可以什么都不寫), 就是?個包
工程根目錄上鼠標(biāo)右鍵 -> New -> Python Package
# ?式?
import 包名.模塊名
# 使?
包名.模塊名.?具名
# ?式?
from 包名 import 模塊名
# 使?
模塊名.?具名
# ?式三, 使?快捷鍵導(dǎo)包
from 包名.模塊名 import ?具名
# 直接使??具名
?具名
案例一：需求
1. 新建一個 hm_message 的 包
2. 在目錄下，新建兩個文件 send_message 和 receive_message
3. 在 send_message 文件中定義一個 send 函數(shù)
4. 在 receive_message 文件中定義一個 receive 函數(shù)
5. 在外部定義一個 test_message 文件，編寫測試代碼調(diào)用發(fā)消息和收消息的函數(shù)
代碼實現(xiàn)：
#send_message.py
def send():
print("發(fā)送消息")
#receive_message.py
def receive():
print("接收消息")
#test_message.py
from hm_message.send_message import send
from hm_message.receive_message import receive as re
send()
re()
案例二 需求
1. 模擬開發(fā)人員實現(xiàn)登錄功能，定義一個函數(shù)能夠接收用戶輸入的用戶名、密碼、驗證碼，根據(jù)不同的測試數(shù)據(jù)返回不同的驗證結(jié)果
2. 已知正確的登錄信息（用戶名：admin、密碼：123456、驗證碼：8888）
3. 要求1：創(chuàng)建login_service.py模塊開發(fā)登錄功能代碼，并存放到service包中
4. 要求2：創(chuàng)建test_login.py模塊開發(fā)測試代碼，并存放到script包中
5. 要求3：至少測試3種測試場景
答案一(自己寫的)
#test_login.py
def login():
name = input("請輸入用戶名：")
pwd = input("請輸入密碼：")
code = input("請輸入驗證碼：")
return [name, pwd, code]
#login_service.py
from script.test_login import login
test = login()
name, pwd, code = test
if code == "8888":
if name == "admin" and pwd == "123456":
print("登錄成功！")
else:
print("用戶名賬號錯誤")
else:
print("驗證碼錯誤")
答案二（老師的）
#test_login.py
from service.login_service import login
login("admin","123456","8888")
login("root","123456","8888")
login("admin","123456","1234")
login("admin","112233","8888")
#login_service.py
def login(username,password,code)
if code == "8888":
if username == "admin" and password == "123456":
print("登錄成功！")
else:
print("用戶名賬號錯誤")
else:
print("驗證碼錯誤")
變量的進階
- 引用 -- 變量 = 數(shù)據(jù)值 本質(zhì)(了解)
- 可變類型與不可變類型(記住)
- 局部變量和全局變量(理解掌握特點)
range(n) #---> [0, n)
range(start, end, step) #---> [start, end) 步長是 step,默認(rèn) 1
range(1, 5, 2) # [1, 3]
range(1, 101) # 1-100
1, 定義變量的時候, 變量和數(shù)據(jù) 都會在內(nèi)存開辟空間
2, 變量所對應(yīng)的內(nèi)存空間中存儲的是 數(shù)據(jù)所在內(nèi)存的地址 (平時理解為 將數(shù)據(jù)存儲到變量中即可)
3. 變量中保存數(shù)據(jù)的地址,就稱為是引用
4, Python 中所有數(shù)據(jù)的傳遞,傳遞的都是引用(即地址)
5, 賦值運算符(=), 會改變變量的引用, < 即只有 = 可以修改變量的引用 >
6, 可以使用 id(變量) 函數(shù),查看變量的引用
a = 1 # 本質(zhì): 將數(shù)據(jù) 1 的地址保存到變量 a 中, 通常理解: 將 1 保存到 a
b = a # 本質(zhì): 將 變量 a中的引用保存到變量 b中. 通常理解 將 a 的值給 b
print(f"a: {a}, {id(a)}")
print(f"b: {b}, {id(b)}")
a = 2 # 本質(zhì): 將數(shù)據(jù) 2 的地址保存到變量a中, 只是改變 a的引用,即改變 a的值, 沒有改變 b 的引用
print(f"a: {a}, {id(a)}") # 2
print(f"b: {b}, {id(b)}") # 1
my_list = [1, 2, 3]
my_list1 = my_list
print(f'my_list :{my_list}, {id(my_list)}')
print(f'my_list1:{my_list1}, {id(my_list1)}')
my_list[1] = 10 # 修改 列表my_list 中下標(biāo)為 1 位置的引用
print(f'my_list :{my_list}, {id(my_list)}') # [1, 10, 3]
print(f'my_list1:{my_list1}, {id(my_list1)}') # [1, 10, 3]
根據(jù)內(nèi)存中的數(shù)據(jù)是否允許修改,將數(shù)據(jù)類型分為可變類型與不可變類型
簡單理解: 不使用等號,能不能修改數(shù)據(jù)值
可變類型: 可以修改
- 列表(list) list.append()
- 字典(dict ) dict.pop()
- 集合(set)
不可變類型: 不允許修改
- 數(shù)字類型(int , float , bool)
- 字符串(str)
- 元組(tuple)
my_tuple = (1, 2, [10, 20]) # 元組中 存儲的 1 的地址, 2 的地址, 列表的地址
print(my_tuple, id(my_tuple), id(my_tuple[-1]), id(my_tuple[-1][-1]))
my_tuple[-1][-1] = 30 # 修改的列表中最后一個位置的引用
print(my_tuple, id(my_tuple), id(my_tuple[-1]), id(my_tuple[-1][-1]))
根據(jù)變量定義的位置將變量分為局部變量和全局變量
局部變量
1, 在函數(shù)內(nèi)部定義的變量,稱為是局部變量
2, 特點
- 2.1 局部變量,只能在當(dāng)前函數(shù)內(nèi)部使用
- 2.2 可以在不同函數(shù)內(nèi)定義名字相同的局部變量
3, 生命周期(使用范圍)
- 3.1 在函數(shù)執(zhí)行(調(diào)用)的時候被創(chuàng)建
- 3.2 函數(shù)執(zhí)行結(jié)束被銷毀(刪除)
4, 形參可以認(rèn)為是局部變量
5, 如果想要在函數(shù)外部使用局部變量的值, 使用 return 返回
def func1():
num = 10 # 局部變量
print(num)
def func2():
num = 20
print(num)
if __name__ == '__main__':
func1() # 10
func2() # 20
func1() # 10
全局變量
1, 在函數(shù)外部定義的變量
2, 特點
- 2.1 全局變量 可以在任意函數(shù)內(nèi)訪問(讀取)
- 2.2 想要在函數(shù)內(nèi)部修改全局變量的引用,需要使用 global 關(guān)鍵字聲明(使用 global 關(guān)鍵字可以聲明為全局變
量)
- 2.3 如果在函數(shù)內(nèi)部出現(xiàn)和全局變量名字相同的局部變量,在函數(shù)內(nèi)部使用的是局部變量
3, 生命周期
- 代碼執(zhí)行的時候 創(chuàng)建, 執(zhí)行結(jié)束銷毀
函數(shù)中變量獲取順序:
1. 首先查找函數(shù)內(nèi)部是否存在指定名稱的局部變量, 如果有直接使用
2. 內(nèi)部如果沒有, 則查找函數(shù)外部是否存在指定名稱的全局變量, 如果有直接使用
3. 如果還沒有, 則程序報錯
# 定義全局變量
g_num = 10
def func_1():
print(g_num) # 使用全局變量
def func_2():
g_num = 20 # 定義局部變量
print(g_num)
def func_3():
global g_num # 聲明為全局變量
g_num = 30
print(g_num)
if __name__ == '__main__':
print(g_num) # 10
func_1() # 10
func_2() # 20
func_1() # 10
print(g_num) # 10
func_3() # 30 修改了全局變量, 將全局變量的值改為30 了
func_1() # 30
g_num = 100
func_1() # 100 修改全局變量的值
func_2() # 20 局部變量
func_3() # 30 修改了全局變量, 將全局變量的值改為30 了
func_1() # 30
綜合應(yīng)用：<仔細(xì)看-列表>
def func1():
list1.append(10)
def func2():
list1 = [1, 1] # 定義局部變量, 不影響全局變量
list1.append(0)
def func3():
global list1 # 全局變量
list1.pop() # 刪除最后一個數(shù)據(jù)
def func_5():
list1.pop() # 用的全局變量,沒有改引用
def func4():
global list1 # 全局變量
list1 = [1]
if __name__ == '__main__':
list1 = [1, 2]
func1()
print(list1) # ①[1, 2] ②[1, 2, 10](√) ③報錯
func2()
print(list1) # ① [1, 1, 0] ②[1, 2, 10](√) ③報錯
func3()
print(list1) # [1, 2]
# func_5()
# print(list1) # ②[1, 2] ①[1]對
func4()
print(list1) # [1]
函數(shù)的進階
- 函數(shù)返回多個數(shù)據(jù)
- 默認(rèn)參數(shù),缺省參數(shù)(形參)
- 不定長參數(shù),可變參數(shù),多值參數(shù)(形參)
- 匿名函數(shù)(lambda 關(guān)鍵字)
return 關(guān)鍵字兩個作用:
1. 返回數(shù)據(jù)值
2. 結(jié)束函數(shù)的運行
函數(shù)中如果想要返回多個數(shù)據(jù)值, 一般是組成元組進行返回
def calc(a, b):
"""返回兩個數(shù)的和及差"""
return a + b, a - b
result = calc(10, 20)
print(result)
是指如何將 實參的值傳遞給形參
位置傳參
在函數(shù)調(diào)用的時候按照 形參的順序?qū)崊⒌闹祩鬟f給形參
關(guān)鍵字傳參
在函數(shù)調(diào)用的時候, 指定將實參傳遞給哪個形參
混合傳參
1. 位置參數(shù)必須寫在關(guān)鍵字參數(shù)的前邊, 關(guān)鍵字參數(shù)必須放在位置參數(shù)的后邊
2. 同一個形參只能接收一個實參值(不能即使用位置傳參和關(guān)鍵字傳參給同一個形參傳參)
def show_info(name, age):
print(f"name:{name}, age: {age}")
# 位置傳參
show_info('小明', 18)
# 關(guān)鍵字傳參
show_info(age=18, name='張三')
# 混合使用
show_info('李四', age=17) #位置參數(shù)必須寫在關(guān)鍵字參數(shù)的前邊
show_info(name='李四', 17) #錯??
在函數(shù)定義的時候, 給形參一個默認(rèn)的數(shù)據(jù)值,這個參數(shù)就是缺省參數(shù)(默認(rèn)參數(shù))
特點：
在函數(shù)調(diào)用的時候, 缺省參數(shù)可以不用傳遞實參值.
1. 如果不傳實參值, 使用的就是默認(rèn)值
2. 如果傳遞實參值, 使用的就是傳遞的實參值
?缺省參數(shù)必須寫在 普通參數(shù)的后邊
def show_info(name, age=18, sex='保密'):
print(name, age, sex)
# 調(diào)用
show_info('張三', 18, '男') # 張三 18 男
show_info('李四') # 李四 18 保密
show_info('王五', 19) # 王五 19 保密
show_info('趙六', '男') # 趙六 男 保密
show_info('趙六', sex='男') # 趙六 18 男
1, 如果一個函數(shù)能夠處理的參數(shù)個數(shù)是不確定的, 可以考慮使用多值參數(shù)
2, 在普通的參數(shù)前邊加上一個 *, 這個參數(shù)就變?yōu)?多值參數(shù)
3, 這個參數(shù)可以接收任意多個位置傳參的數(shù)據(jù), 類型 元組
4, 這個形參一般寫作 args(arguments), 即 *args
參數(shù)順序
# 普通, 缺省, 多值
def 函數(shù)名(普通, *args, 缺省):
pass
def func(*args):
print(args)
func() # ()
func(1, 2, 3) # (1, 2, 3)
案例
需求:
1. 定義一個函數(shù) sum_numbers，可以接收的 任意多個整數(shù)
2. 功能要求：將傳遞的 所有數(shù)字累加 并且返回累加結(jié)果
def sum_numbers(*args):
s=sum(args)
print(s)
sum_numbers(1,2)
sum_numbers(10,56,48,64,26)
def my_sum(*args): # args 是元組
num = 0
for i in args:
num += i
return num
sum_numbers(1,2)
sum_numbers(10,56,48,64,26)
元組的拆包
元組拆包的方式：在元組變量前，增加一個 *
def sum_numbers(*args):
num = 0
for n in args:
num += n
return num
# 需要將一個元組變量傳遞給函數(shù)對應(yīng)的參數(shù)
nums = (1, 2, 3)
result = sum_numbers(*nums)
print(f"result={result}")
匿名函數(shù)：使用 lambda關(guān)鍵字 定義的表達式，稱為匿名函數(shù)
? 語法
lambda 參數(shù), 參數(shù): 一行代碼 # 只能實現(xiàn)簡單的功能,只能寫一行代碼
# 匿名函數(shù) 一般不直接調(diào)用, 作為函數(shù)的參數(shù)使用的
func = lambda a , b : a+b
print(10,20)
? 練習(xí)
# 1, 定義匿名函數(shù), 參數(shù)為兩個整數(shù)數(shù)字, 求兩個數(shù)字的乘積
lambda a, b: a * b
# 2, 定義匿名函數(shù), 參數(shù)為一個字典, 返回字典中 鍵為 age 的值
lambda x: x.get('age')
lambda x: x['age']
案例1-要求按照年齡傳智教育-黑馬程序員 對用戶信息數(shù)據(jù)進行排序
user_list = [
{'name': '張三', 'age': 22, 'title': '測試工程師'},
{'name': '李四', 'age': 24, 'title': '開發(fā)工程師'},
{'name': '王五', 'age': 21, 'title': '測試工程師'}
]
# user_list.sort() # 只能對數(shù)字,字符串排序
# 根據(jù)字典的 age 鍵 排序
# 想要對列表中的字典排序,需要 key 形參來指定根據(jù)字典中的什么鍵排序
# key 這個參數(shù)需要傳遞一個函數(shù),使用匿名函數(shù)
# 列表.sort(key=lambda x: x['鍵'])
user_list.sort(key=lambda x:x['age'])
print(user_list)
# def func(x):
# return x['age']
#
#
# user_list.sort(key=func)
# print(user_list)
stu_list = []
def make_student():
while True:
name=input("請輸入學(xué)生姓名：")
if name=="no":
print("本次輸入結(jié)束！")
break
age=input("請輸入學(xué)生年齡：")
stu={"name":name,"age":age}
stu_list.append(stu)
return stu_list
def show_info():
print('-' * 5 + "學(xué)生列表信息" + '-' * 5)
j=1
for stu in stu_list:
print(f"{j}\t\t",end=" ")
print(stu.get("name")+"\t\t", end=" ")
print(stu.get("age"),)
print('-' * 21)
def get_counts():
return len(stu_list)
def search_student():
name=input("請輸入學(xué)生姓名：")
for stu in stu_list:
if name==stu.get("name"):
print(f'姓名:{name}, 年齡: {stu.get("age")}')
return
else:
pass
print(f"對不起，名字叫【{name}】的學(xué)生不存在")
if __name__ == '__main__':
# 錄入三個學(xué)生信息
# for i in range(3):
# stu = make_student()
# stu_list.append(stu) # 需要將單個學(xué)生添加到列表
#
# print(stu_list)
# 展示學(xué)生信息
make_student()
show_info()
# 獲取學(xué)生數(shù)量
print('學(xué)生總數(shù)為: ', get_counts())
#查詢-根據(jù)姓名
search_student()
浙公網(wǎng)安備 33010602011771號