刚开始的函数

为什么要用函数

如果现在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（打散）

定义函数的规则：

查看全文