今天还是继续学习了函数,还有引用相关,以及对一个案例进行了实例。
笔记如下:
# 函数续
def func(a,b,c):
print(f'a:{a}')
print(f'b:{b}')
print(f'c:{c}')
# 函数传参的两种形式
# 位置传参,按照形参的位置顺序将实参的值传递给形参
func(1,2,3)
# 关键字传参,指定实参给到哪个形参,注意:关键字必须是函数的形参名
func(a=10,b=20,c=30)
func(c=10,a=20,b=5)
# 混合使用,先写位置传参,再写关键字传参
func(10,b=20,c=30)
# func(a=20,20,30) 报错!!!
# func(10,a=10,b=20) 报错!不能多有个形参值
# 函数形参
# 缺省参数(默认形参),在函数定义的时候,给形参一个默认值,这个形参就是缺省参数
# 注意:缺省参数要写在普通参数的后面
# 特点:在函数调用时,如果给缺省参数传递实参值,使用的是传递的实参值,如果没有传递,就用,默认值
def func(a,b,c=10): # 形参c是缺省形参
print(f'a:{a}')
print(f'b:{b}')
print(f'c:{c}')
func(1,2) # 没有给c传递实参,使用默认值10
func(1,2,3) # 给c传递实参,使用传递的数据3
# def fun1(a=1,b,c): # 错误写法,缺省参数要在最后面
# pass
# 不定长参数 *args
def func(args,kwargs): # 两个普通的形参
print(args)
print(kwargs)
func(1,2)
print('*'*30)
# 在形参前面加上一个*,该形参变为不定长元组参数,可以接受所有位置的实参,类型是元组
# 加上**号,该形参变为不定长字典形参,可以接受所有关键字实参,类型是字典
def func(*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,5,8,5,6) # 元组(1, 2, 3, 5, 8, 5, 6)
func(a=1,b=2,c=3) # 字典{'a': 1, 'b': 2, 'c': 3}
func(1,2,3,a=5,c=9) # 混合(1, 2, 3) {'a': 5, 'c': 9}
# 应用:求和
def my_sum(*args,**kwargs):
num = 0
for i in args:
num += i
for j in kwargs.values():
num += j
print(f'求和的结果为:{num}')
my_sum(1,2,3,a=1,b=2)
# 函数形参的完整格式
# 普通形参 缺省形参 不定长元组形参 不定长字典形参
def func(a,b=1): # 先普通再缺省
pass
# def func1(a,b=1,*args): 语法上不会报错,但是缺省函数不能使用默认值
def func1(a,*args,b=1,**kwargs): # 普通 不定长元组形参 缺省形参 不定长字典形参
pass
print(1,2,sep='*') # sep默认用空格隔开,否则使用sep中的值隔开
# 组包,将多个数据值给到一个变量,类型是元组
a = 1,2,3
print(a) # 元组类型(1, 2, 3)
def func():
return 1,2 # 组包
# 拆包:将容器中的数据分别给到多个变量
# 数据的个数和变量的个数要保持一致!!!!
b,c,d = a # 拆包
print(b,c,d)
e,f = func()
print(e,f)
a,b = [10,20] # 列表
print(a,b)
my_dict = {'name':'tct','age':18}
a,b = my_dict
print(a,b) # 返回的是key值
# 拆包应用:交换两个变量的值
a = 10
b = 20
# 1.使用临时变量
c = a
a = b
b = c
print(a,b)
# 2. +/-
a = a + b # a:30
b = a - b # b:10
a = a - b # a:20
print(a,b)
# 3.组包和拆包!!!
a,b = b,a
print(a,b)
# 引用
# 可以使用id()查看变量的引用,
# 可以将id值认为是内存地址的别名
# python中数据值的传递传递的是引用
# 赋值运算符可以改变变量的引用
a = 10
# 将变量a中保存的引用地址给到b
b = a
print(a,b) # 打印a,b中引用中存储的值
print(id(a),id(b))
a = 20
print(a,b) # b的值不会改变
print(id(a),id(b))
# 都会一起随之改变,改变是在原列表中进行改变
my_list = [1,2,3] # 列表
my_list1 = my_list
print(my_list,id(my_list))
print(my_list1,id(my_list1))
my_list.append(4) # 向列表中添加数据
print(my_list,id(my_list))
print(my_list1,id(my_list1))
my_list[2] = 5 # 改变数据
print(my_list,id(my_list))
print(my_list1,id(my_list1))
# 类型的可变与不可变,在不改变变量引用的前提下, 能否改变变量中引用中的数据
# 如果能够改变则是可变类型,不能改变就是不可变类型
# int float bool str list tuple dict
# 不可变类型:int(需要重新开辟一块空间),float,bool,str,tuple(元组中的数据不能改变)
# 可变类型:list,dict
a = 10
b = 10
print(id(a),id(b)) # python中的内存优化,对于不可变类型进行的
# 2334561299024 2334561299024
print('*'*30)
my_list = [1,2,3]
my_list1 = [1,2,3]
print(id(my_list),id(my_list1)) # 是不同的 1458877514176 1458877952640
print('*'*30)
my_tuple = (1,2,[1,2])
print(my_tuple)
my_tuple[2][1] = 5 # 不算是修改元组数据,改变的是元组中的列表数据
print(my_tuple)
# 引用做函数参数
# 函数传参传递的也是引用
my_list = [1,2,3] # 全局变量
def func(a):
a.append(4)
def func1():
# 不加globa,因为没有修改my_list中存的引用值
my_list.append(5)
def func2():
global my_list
my_list = [1,2,3] # 修改了全局变量的值
def func3(a):
# += 对于列表来说,类似于extend方法,不会改变变量的引用地址
a += a # 修改了a变量a的引用
# print(a)
func(my_list) # [1,2,3,4]
func1() # [1,2,3,4,5]
func2() # [1,2,3]
print(my_list)
b = 10 # 不可变类型
func3(b)
print(b)
func3(my_list)
print(my_list) # [1, 2, 3, 1, 2, 3]
学生管理系统案例:
# 函数应用;学生管理系统
# 增删改查操作
# 存储学生信息:姓名,年龄,班级......(使用字典存储key-value)
# 存储所有学生的信息:列表[{},{},{}.......]
# 给用户的功能菜单,业务框架
# 1.搭建业务框架
# 2.实现功能
# 2.1 添加学生信息,通过input函数获取学生的信息,姓名,年龄,性别
# 将学生信息转换为字典进行保存
# 将学生字典添加到列表中
# 代码优化,假设名字不能重复,在添加学生的时候进行判断,如果存在则不添加
# 3.删除/修改/查询学生信息
# 都是用 name 对学生进行判断
# 3.1 使用input获取要删除/修改/查询的学生姓名
# 3.2 判断学生信息是否存在
# 3.3 学生存在进行操作,不存在则直接结束
# 定义学生列表
stu_list = []
def show_menu(): # 功能菜单函数
print('1.添加学生')
print('2.删除学生')
print('3.修改学生信息')
print('4.查询单个学生信息')
print('5.查询所有学生信息')
print('6.退出系统')
def insert_stu(): # 添加学生函数
# 输入对应的数值
name = input('请输入学生名字:')
# 判断姓名是否重复,判断字典中的value值是否存在,遍历,(假定名字唯一)
for stu in stu_list:
if stu['name'] == name:
print('---------学生信息存在--------')
return # 结束函数的执行
age = input('请输入年龄:')
gender = input('请输入性别:')
stu_dict = {'name':name,'age':int(age),'gender':gender} # 将数值放入字典中
stu_list.append(stu_dict) # 将字典添加到列表中
print('-------学生信息添加成功---------')
def remove_stu(): # 删除学生
name = input('请输入要操作的学生的名字:')
for stu in stu_list: # 循环遍历列表,若存在于列表中,就将其删除掉,使用remove()函数
if stu['name'] == name:
stu_list.remove(stu)
break
else:
print('-------该学生信息不存在-------')
def modify_stu(): # 修改学生信息
name = input('请输入要操作的学生的名字:')
for stu in stu_list: # 遍历列表
if stu['name'] == name:
stu['age'] = int(input('请输入新的年龄:')) # 进行修改
break
else:
print('-------该学生信息不存在,无法修改-------')
def search_stu(): # 查找学生
name = input('请输入要操作的学生的名字:')
for stu in stu_list: # 遍历
if stu['name'] == name:
print(f'姓名:{stu["name"]},年龄:{stu["age"]},性别:{stu["gender"]}') # 找到的话就将其信息输出
break # 记得break掉循环
else:
print('-------该学生信息不存在-------')
def show_all_info(): # 展示所有信息
if len(stu_list) > 0: # 只有当列表长度不为0时才输出相应信息
for stu in stu_list:
print(f'姓名:{stu["name"]},年龄:{stu["age"]},性别:{stu["gender"]}')
# print(stu)
else:
print('目前没有学生信息')
def main(): # 将整个定义成一个函数
while True: # 多次进行
show_menu()
opt = input('请输入要选择对的操作编号:')
if opt == '1':
insert_stu()
elif opt == '2':
remove_stu()
elif opt == '3':
modify_stu()
elif opt == '4':
search_stu()
elif opt == '5':
show_all_info()
elif opt == '6':
print('6.退出系统')
break
else:
print('输入错误,请重新输入')
continue
input('.......回车键继续操作......')
main() # 直接调用
测试题:
# 1.要求实现一段代码:
# 声明一个函数num,并且在调用函数的时候,不管输入多少个非关键字参数,函数都可以运行,且在函数内部还要把每个参数输出到屏幕上。
def num(*args):
for i in args:
print(i)
num(1,2,3,4,5,6)
# 2.如下所示这是一个字典,{"name":"电脑","price":7000}
# 请定义这样一个函数num,讲上述字典中的键值对传入到函数num中,要求用不定长参数来接收,并在函数中打印键值对输出
# 输出格式为:
# key: name value: 电脑
# key: price value: 700
def num(**kwargs):
for key,value in kwargs.items():
print('key:',key,'value:',value)
num(name='电脑',price=7000)
# 3.对于一个函数num,
# 当调用nun(1,2,a=3,b=4)和调用num(3,4,5,6,a=1)以及num(a=1,b=2)的时候都可以正常运行,
# 并且可以对元组以及字典类型进行遍历输出,对字典类型进行输出字典的键值对(形式为:key:a,value:1),
# 请写出这个函数并完成调用。
def num(*args,**kwargs):
for i in args:
print(i)
for key,value in kwargs.items():
print('key:',key,'value:',value)
num(1,2,a=3,b=4)
昨日课程的测试题:
# 字典测试题
# 1.定义一个空字典my_dict
my_dict = {}
my_dict1 = dict()
print(my_dict)
print(my_dict1)
# 2. 定义一个字典
my_dict2 ={'name':'txt','age':18,'pi':3.14}
print(my_dict2)
# 3.打印类型
print(type(my_dict))
print(type(my_dict2))
# 4. 输出18这个数据
print(my_dict2['age'])
# 5. 求出元素个数
print(len(my_dict2))
# 6. key访问和get访问
print(my_dict2['name'])
print(my_dict2.get('name',5))
# 7.修改age的值为55
my_dict2['age'] = 55
print(my_dict2)
# 8. 添加一个元素
my_dict2['gender'] = '男'
print(my_dict2)
# 9.删除pi的键值对
my_dict2.pop('pi')
print(my_dict2)
# 10.清空给字典数据
my_dict2.clear()
print(my_dict2)
# 11.删除字典变量
del my_dict2
# 12.现在还能使用该变量吗? 不能!!!
# print(my_dict2) 会报错
# 2. 循环打印字典中的键,值,键值对
dict1 = {'name':'soobin','age':18}
for i in dict1.keys():
print(i)
for j in dict1.values():
print(j)
for key,value in dict1.items():
print(key,':',value)
# 3.综合训练
product = [
{'name':'电脑','price':7000},
{'name':'鼠标','price':125},
{'name':'键盘','price':250},
{'name':'耳机','price':300},
]
# 小明有8000元能否买下所有的商品,返回能或者不能
money = 8000
my_sum = 0
for i in product:
my_sum += i['price']
if money > my_sum:
print('能')
else:
print('不能')
# 函数测试题
# 1.定义一个run函数
# 2.想实现1000遍
def run():
print('我在跑步呀')
print('管住嘴')
for i in range(0,1000):
run()
# 3.addnum带有返回值 7,13
def addnum(a,b):
return a + b
result = addnum(7,13)
print(result)