刚开始的函数

为什么要用函数

如果现在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 = 0for i in l:count +=1print(count) my_len()

定义函数的时候，要尽量以功能为导向，结果最好不要直接在函数中打印

def my_len(): #函数名的定义l = [1,2,3,4,5,6]count = 0for i in l:count += 1return count #函数的返回值 ret = my_len() #函数的调用，以及返回值的接收 print(ret) my_len() def 函数名():for i in range(10):if i%3 == 0:print(i)return {'a':'b'},2print(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,4def ret_demo2():'''返回多个任意类型的值'''return 1,['a','b'],3,4ret1 = 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 = 0for i in lst:count += 1return countl = [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 Trueelse:return Falseprint(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=20the_max = x if x > y else yreturn the_maxma = mymax(10,20) print(ma)
结果：20

按照关键字传值：

def mymax(x,y):#此时x = 20,y = 10print(x,y)the_max = x if x > y else yreturn the_maxma = mymax(y = 10,x = 20) print(ma)
结果：20

 

位置，关键字混着用：

def mymax(x,y):#此时x = 10,y = 20print(x,y)the_max = x if x > y else yreturn the_maxma = mymax(10,y = 20) print(ma)

站在形参角度：

位置参数必须传值：

def mymax(x,y):#此时x = 10,y = 20print(x,y)the_max = x if x > y else yreturn 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 = 0for i in args:sum += ireturn 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 = 0for i in args:sum_2 += ireturn 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（打散）

定义函数的规则：

1.定义：def 关键词开头，空格之后接函数名称和圆括号()。 2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
　　　　参数可以定义多个，也可以不定义。
　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序 3.注释：函数的第一行语句应该添加注释。 4.函数体：函数内容以冒号起始，并且缩进。 5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 Nonedef 函数名(参数1,参数2,*args,默认参数,**kwargs):"""注释：函数功能和参数说明"""函数体……return 返回值

调用函数的规则：
1.函数名()函数名后面+圆括号就是函数的调用。 2.参数：圆括号用来接收参数。若传入多个参数：应按先位置传值，再按关键字传值具体的传入顺序应按照函数定义的参数情况而定 3.返回值如果函数有返回值，还应该定义“变量”接收返回值如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致无返回值的情况： 函数名()有返回值的情况： 变量 = 函数名()多个变量接收多返回值： 变量1，变量2，... = 函数名() 参数总结：

 

 

转载于:https://www.cnblogs.com/xyhh/p/10833455.html

总结

以上是生活随笔为你收集整理的刚开始的函数的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。