为什么要用函数
如果现在len方法不能用了，我们可以用for循环语句来实现计算长度的功能
l = [1,2,3,4,5,6]
count = 0
for i in l:
count += 1
print(count)
如果变量的内容变化，就要重新写一遍，而且不能直观的看出他的功能，因此这种做法的可读性差，重复的代码多，因此要用一种方法把代码装起来，也就是定义一个函数，比如
def my_len():
l = [1,2,3,4,5,6]
count = 0
for i in l:
count +=1
print(count)
my_len()
定义函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印
def my_len(): #函数名的定义
l = [1,2,3,4,5,6]
count = 0
for i in l:
count += 1
return count #函数的返回值
ret = my_len() #函数的调用，以及返回值的接收
print(ret)
my_len()
def 函数名(): for i in range(10): if i%3 == 0: print(i) return {'a':'b'},2 print(i) ret,ret2 = 函数名() print(ret) print(ret2)
结果为 0
{'a': 'b'}
2
关于返回值
如果没有返回值，不写return返回的是None，只有一个return返回的也是None，return的作用有两个：
1，返回一个值：直接在return后面加上要返回的内容，中间有空格，可以是任何数据类型
2，终止一个函数的继续
如果返回一个值，可以返回任何数据类型，返回什么，接收什么
如果返回多个值，用一个变量接收返回值，接收到的是一个元组；返回值如果有多个变量接收，那么返回值得个数和接收变量的个数完全一致
def ret_demo1():
'''返回多个值'''
return 1,2,3,4
def ret_demo2():
'''返回多个任意类型的值'''
return 1,['a','b'],3,4
ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)
def ret_demo2():
return 1,['a','b'],3,4
#返回多个值，用一个变量接收
ret2 = ret_demo2()
print(ret2)
#返回多个值，用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)
#用多个值接收返回值：返回几个值，就用几个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)
###python中用逗号隔开的多个值被认为是一个元组
定义def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。
函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。要尽量简短，并能表达函数功能
调用时函数名() 要记得加上括号。
二，函数的参数
def my_len(lst): #参数：接收参数，形式参数，形参
count = 0
for i in lst:
count += 1
return count
l = [1, 2, 3, 4] # 参数：传参数/传参，实际参数，实参l = [1,2,3,4]
len_count = my_len(l)
print(len_count)
len_count2 = my_len('XXX is somebody')
print(len_count2)
练习
1写一个函数，接收参数一个列表或者字符串，2如果这个列表或者字符串的长度大于2，返回True，否则返回False
def func(s_l):
if len(s_l) > 2:
return True
else:
return False
print(func([1,2,3,4])) #True
print(func('12')) #False
参数
形参和实参：
实际的要交给函数的内容，简称实参
定义函数的时候只是一个形式，表示这里有一个参数，简称形参。
传参数可以传任意的数据类型，并且传什么，接受什么
传递多个参数，用逗号隔开
def f2(arg1,arg2,arg3): #站在接受、形参的角度上：位置参数
print(arg1)
print(arg2,arg3)
f2(arg3 = 1,arg2 = 2,arg1 = 3)
站在传参数的角度上看问题：一共有两种传参的方式
第一种：按照位置传参数
第二种：按照关键字传参数
def f(para): #para形式参数
print(para)
f(para = 1)
按照关键字传参数和按照位置传参数是可以混用的
但是，首先传按位置的，再传按关键字的
按照位置传完该接受的参数只能接受一个值，不接受或者重复接收都不行
位置参数：
站在实参角度
按照位置传值：
def mymax(x,y):
#此时x=10,y=20
the_max = x if x > y else y
return the_max
ma = mymax(10,20)
print(ma)
结果：20
按照关键字传值：
def mymax(x,y):
#此时x = 20,y = 10
print(x,y)
the_max = x if x > y else y
return the_max
ma = mymax(y = 10,x = 20)
print(ma)
结果：20
位置，关键字混着用：
def mymax(x,y):
#此时x = 10,y = 20
print(x,y)
the_max = x if x > y else y
return the_max
ma = mymax(10,y = 20)
print(ma)
站在形参角度：
位置参数必须传值：
def mymax(x,y):
#此时x = 10,y = 20
print(x,y)
the_max = x if x > y else y
return the_max
#调用mymax不传递参数
ma = mymax()
print(ma)
#结果
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'
默认参数
1.正常使用
默认参数：将变化比较小的值设置成默认参数
是可以不传的参数
在不传参数的情况下可以使用默认的值
如果传了，就会使用传的值
2.默认参数的定义
def classmate(name,sex='男'):
print('姓名：%s，性别%s'%(name,sex))
classmate('尤悦')
classmate('曹超')
classmate('张建超')
classmate('晓梅','女')
结果：
姓名：尤悦，性别男
姓名：曹超，性别男
姓名：张建超，性别男
姓名：晓梅，性别女
3.参数陷阱：默认参数是一个可变数据类型，但是尽量避免使用可变数据类型
lst = []
def func(l = lst):
l.append(1)
print(l)
func()
func()
func()
func()
结果为：
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
lst = []
def func(l = lst):
l.append(1)
print(l)
func([])
func([])
func([])
func([])
结果为：
[1]
[1]
[1]
[1]
形参
位置参数
默认参数
*****动态参数******
def func(a,b,c,*args,key = "key"): #在参数前面加个*，这个参数就变成动态参数了
print(a,b,c)
print(key)
print(args) #使用的时候，所有接收过来的参数都被组织成一个元组的形式
func(2,4,4,5,"asff",[1,3],key = "alex")
结果：
2 4 4
alex
(5, 'asff', [1, 3])
def func(a,*args,key = "alex",**kwargs):
print("a:",a)
print("args:",args)
print("key:",key)
print("kwargs:",kwargs)
func(5)
# a: 5
# args: ()
# key: alex
# kwargs: {}
func(5,6,7)
# a: 5
# args: (6, 7)
# key: alex
# kwargs: {}
func(5,6,7,b='hahaha',c='hehehe')
# a: 5
# args: (6, 7)
# key: alex
# kwargs: {'b': 'hahaha', 'c': 'hehehe'}
func(5,6,7,key='小小酥',b='hahaha',c='hehehe')
# a: 5
# args: (6, 7)
# key: 小小酥
# kwargs: {'b': 'hahaha', 'c': 'hehehe'}
func(5,b='hahaha',c='hehehe')
# a: 5
# args: ()
# key: alex
# kwargs: {'b': 'hahaha', 'c': 'hehehe'}
用函数实现传入多个数字相加
def my_sum(*args):
sum = 0
for i in args:
sum += i
return sum
ret = my_sum(1,24,5,7) #37
print(ret)
ret2 = my_sum(24,5,7) #36
print(ret2)
def stu_info(**kwargs): #**kwargs按关键字的动态参数
print(kwargs)
print(kwargs['name'],kwargs['sex'])
stu_info(name = 'alex',sex = 'male')
结果
{'name': 'alex', 'sex': 'male'}
alex male
def func(*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,5,key='5')
结果为
(1, 2, 3, 5)
{'key': '5'}
#魔性的用法
def my_sum(*args): #聚合
print(args)
sum_2 = 0
for i in args:
sum_2 += i
return sum_2
l = [1,24,5,7]
ret = my_sum(*l) #按顺序打散
print(ret)
结果
(1, 24, 5, 7)
37
def func(**kwargs):
print(kwargs)
func(b=2,a=1)
dic = {'a':1,'b':2}
func(**dic)
结果：
{'b': 2, 'a': 1}
{'a': 1, 'b': 2}
def func(*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,4,5)
结果：
(1, 2, 3, 4, 5)
{}
动态参数总结：
动态参数
*args ：接收所有按照位置传的参数，接收到的是参数组成的元祖
**kwargs :接收所有按照关键字传的参数，接收到的是参数组成的字典
所有的参数的顺序：位置参数，*args，默认参数，**kwargs
魔性的用法：
在调用函数的时候，可以打散：*l（按顺序打散）、**dic（打散）
定义函数的规则：