函数的定义：
def 函数名():
pass
def my_len():
ls = [1,2,3,4,11,18]
for count in ls:
count += 1
print(count)
函数的调用方法：
函数名() # 执行函数 函数名()
函数的优点：
减少代码的重复率；
增强代码的阅读性。
函数到底是什么？函数最主要的目的：封闭一个功能。
函数的返回值: 要用到 return 语句
# 函数的声明： def 函数名(): def my_len(): # 这个函数没有返回值 ls = [1,2,3,4,11,18] for count in ls: count += 1 print(count) my_len() result = my_len() # 函数没有返回值，用一个变量去接收结果，就是：None print(result) # 输出结果： None # 要让函数返回址，就要用到 return 语句， return 值 ；若没有，没有跟值 ，返回值 也是 None # return 后面没有跟值的情况： def demo1(): a = 5 return print(demo1()) # None # return 后面跟一个值 的 情况： def demo2(): a = 5 return a result = demo2() print(result,type(result)) # 5 <class 'int'> def demo3(): tu = (1,3,'abc') return tu result = demo3() print(result,type(result)) # (1, 3, 'abc') <class 'tuple'> # return 后面跟一个值的情况总结：值是什么类型，返回也相应的类型。即原封不动地返回。 # return 后面跟多个值的情况： 值 与 值 之间以‘逗号’分割 def demo4(): x = 5 y = 'hello world' dic = {'name':'chris'} return x,y,dic ret = demo4() # 整体是函数的执行者。在工作中，函数中尽量不要出现print print(ret,type(ret)) # (5, 'hello world', {'name': 'chris'}) <class 'tuple'> # 可见，如果return 返回多个值的情况，将return 后面的值，放进一个元组，整个返回 # 由于返回的是一个元组，可以分别赋值 x,y,dic = demo4() # 分别赋值时， = 号两边的元素个数相同，一一对应 print(x,y,dic) # 5 hello world {'name': 'chris'}
函数的参数：
# 函数的传参： # 实参 # 位置参数： 按照顺序，一一对应 # 关键字参数： 可以不按照顺序，但是必须一一对应 # 混合参数： 关键字参数一定要在位置参数后面 # 形参 # 位置参数：按照顺序，一一对应 # 默认参数： l1 = [1,3,5,7,9,11] s = "jump river haha" def obj_len(argv): # 形式参数，形参 # 函数体 count = 0 for item in argv: count += 1 return count length = obj_len(l1) # 函数的执行者（实参） 实际的参数 print(length) # 6 length = obj_len(s) # 函数的执行者（实参） 实际的参数 print(length) # 15 #实参 之 位置参数： def func1(x,y): print(x,y) func1(1,2) # 通过位置传参数，一一对应， 1 传给形参 x , 2 传给形参 y. # 2个函数，1个函数 求和；2个函数 将大的数给我返回 def sum1(x,y): return x + y a = 10 b = 15 print(sum1(a,b)) def compare(x,y): return x if x > y else y # 三目运算符 x = 3 y = 2001 print(compare(x,y)) # 三元运算符：只针对简单的if else 这样的结构，才可以使用。 # 关键字参数，可以不按照顺序，但是必须一一对应。 def func2(x,y): return x == y # return后面，可以是关系表达式，但不能是赋值表达式 print(func2(y=10,x=7)) # 混合传参： 关键字参数一定要在位置参数后面。 # def func3(a,y,n,x,n): # 在函数的定义中，不能有相同的参数 SyntaxError: duplicate argument 'n' in function definition # return a,y,x,n # name = 'chris' # print(func3(100,200,'chris',x=18,n=28)) # def func3(a,y,n,x,n1): # return a,y,x,n # name = 'chris' # print(func3(100,200,'chris',x=18,n1=28)) # 形参角度 # 位置参数：按照顺序，一一对应 # 默认参数： 给其传值，将原来默认值给覆盖掉，不传值，不报错，使用默认值 # 应用场景：不经常改变的参数，但是一直在用。 def func4(x,y,z=100): return x, y, z print(func4(10,20)) # (10,20,100) print(func4(10,20,150)) # (10,20,150)
形参中的 默认参数：
# def test(x,y=15,z): # 报错：SyntaxError: non-default argument follows default argument # print(x,y,z) # test(10,z=18) # 经过测试，总结出来，在函数定义时，形参中的默认参数，要放在最后，即非默认参数，不能跟随在默认参数后面 def test(x,z,y=15): # 报错：SyntaxError: non-default argument follows default argument print(x,y,z) test(10,y=15,z=18) # 打印10 15 18 def test(x,y=15,z=10): # 报错：SyntaxError: non-default argument follows default argument print(x,y,z) test(10,z=18) # 打印10 15 18 def test(x,y=15,z=10): # 报错：SyntaxError: non-default argument follows default argument print(x,y,z) test(10,18) # 打印 10 18 10
形参中的默认参数陷井：
# 形参中的默认参数陷井 def trap(arg1,arg2=[]): arg2.append(arg1) return arg2 ret1 = trap(15) ret2 = trap(100) ret3 = trap(101) print(ret3) # [15,100,101] print(id(ret1),id(ret2),id(ret3)) # 指向同一个内存地址 2196520805000 2196520805000 2196520805000 # 总结： 当默认参数是可变数据类型时，她始终使用一个
写一个不函数：输入学生信息：
def add_record(name,sex): with open('students',encoding='utf-8',mode='a+') as f1: f1.write(name + "----" + sex + ' ') print("{}-----{} 添加成功".format(name,sex)) f1.close() print("欢迎来到学生信息录入系统！！！") while 1: select = input("请输入，任意键继续，Q退出>>>") # 为了做兼容性，怕用记输入中文的逗号，对接收的字符串作一个替换操作，变为英文的逗号，再以逗号 分割，得到一个列表 if select.upper() != 'Q': name,sex = input("请输入学生的姓名和性别，以逗号作为分割>>>").strip().replace('，',",").split(",") add_record(name,sex) else: break
动态参数，也叫万能参数：
# 你的函数为了拓展，对于传入的实参数量不固定，这时就要用万能参数，又叫动态参数， *args, **kwargs. def function1( *args,**kwargs): print(args) print(kwargs) function1(1,3,[1,3,5],x=10,y=20,name='chris') # (1, 3, [1, 3, 5]) # {'x': 10, 'y': 20, 'name': 'chris'} # 总结一下：在函数定义中，万能参数或叫动态参数 一颗星 或 二颗星 后面的 变量名字，可以任意取， # 只不过，给定俗成取为 args 和 kwargs 。 # 在函数的定义中， 形参中的 星号 是 聚合 的作用。 # 一颗星 将函数调用时，实参中的所有位置参数 ，聚合到一个元组中，然后将该 元组 赋值给 一颗星 后面的变量名 # 二颗星 的作用 是在函数调用时，将实参中的关键字参数，以键值对的形式，聚合到字典中，然后将字典赋值给 二颗星 后面的 变量名 # * 号的魔法作用，在函数调用时， * 的作用是 打散 的作用
一颗星 * 把迭代对象打散成为 实参中的位置参数 ； 二颗星 ** 把字典 打散成 实参中的 关键字参数
l1 = [1,2,3,5] l2 = [11,22,33,'chris'] def func1(*args): return args[0] + args[1] print(func1(l1,l2)) # [1, 2, 3, 5, 11, 22, 33, 'chris'] def func1(*args): # 定义一个聚合实参的位置参数的变量 return args print(func1(*l1,*l2)) # (1, 2, 3, 5, 11, 22, 33, 'chris') # 这里 * 号起到打散的作用，将可迭代对象，打散成一个个元素5 # 相当于 func1(1,2,3,5,11,22,33,'chris') l3 = [[1,2,{'name':'chris'}],99,88] print(func1(*l3)) # ([1, 2, {'name': 'chris'}], 99, 88) 只是将第一层打散 dic = {'name':'chris','age':18,'sex':'male'} print(func1(*dic)) # ('name', 'age', 'sex') 一颗星 ，对字典打散，打散成一个个键 def func2(**kwargs): print(kwargs) dic = {'name':'chris','age':18,'sex':'male'} func2(**dic) # 函数调用时， 二颗星，将后面字典中的键值对，打散成关键字参数传参 # 相当于 func2(name='chris',age=18,sex='male) func2(name='chris',age=18,sex='male') func2(*dic) # 报错： TypeError: func2() takes 0 positional arguments but 3 were given
形参的顺序：
# 位置参数，默认参数，*args,**kwargs # 位置参数，默认参数 # def func(a,b,sex='男'): # # print(a) # print(sex) # func(100,200,) # 位置参数，*args, 默认参数 # def func(a,b,*args,sex='男',): # # print(a) # print(a,b) # print(sex) # print(args) # func(100,200,1,2,34,5,6) # 位置参数，*args, 默认参数 **kwargs # def func(a,b,*args,sex='男',**kwargs,): # print(a,b) # print(sex) # print(args) # print(kwargs) # func(100,200,1,2,34,5,6,sex='nv',name='alex',age=1000)
=========================================================================================================
def test(x,y,z=10,**kwargs):
print(x)
print(y)
print(z)
print(kwargs)
test(11,22,name='jia',age=18)
def test(x,y,**kwargs,): # 两颗星 修饰的 聚合变量 放到形参最后，规则
print(x)
print(y)
print(kwargs)
test(11,22,name='jia',age=18)
def test(x,z,y=100): # 函数定义时，默认参数放在最后
return x + y + z
#print(test(100,2)) # SyntaxError: non-default argument follows default argument 非默认参数不能跟随默认参数后
print(test(x=100,z=100))
print(test(100,200))