函数相关知识汇总

一.函数的定义

定义函数的规则：

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

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值

 

二.函数的调用规则

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

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

多个变量接收多返回值：
变量1，变量2，... = 函数名()

 

三.函数的返回值

返回值为None即没有返回值：有以下三种情况

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值，此时的str_len为None
print('str_len : %s'%str_len)

不写return的情况下，会默认返回一个None

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

只写return，后面不写其他内容，也会返回None，有人会奇怪，既然没有要返回的值，完全可以不写return，为什么还要写个return呢？这里我们要说一下return的其他用法，就是一旦遇到return，结束整个函数。

def ret_demo():
    print(111)
    return None
    print(222)

ret = ret_demo()
print(ret)

 return None：和上面的两种情况一样，我们一般不这样写。

 

返回一个值

      只需在return后面写上要返回的内容即可

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

注意：return和返回值之间要有空格，可以返回任意数据类型的值

返回多个值

　　可以返回任意多个、任意数据类型的值

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)

原因：

>>> 1,2  #python中把用逗号分割的多个值就认为是一个元组。
(1, 2)
>>> 1,2,3,4
(1, 2, 3, 4)
>>> (1,2,3,4)
(1, 2, 3, 4)

#序列解压一
>>> a,b,c,d = (1,2,3,4)
>>> a
1
>>> b
2
>>> c
3
>>> d
4
#序列解压二
>>> a,_,_,d=(1,2,3,4)
>>> a
1
>>> d
4
>>> a,*_=(1,2,3,4)
>>> *_,d=(1,2,3,4)
>>> a
1
>>> d
4
#也适用于字符串、列表、字典、集合
>>> a,b = {'name':'eva','age':18} 
>>> a
'name'
>>> b
'age'

 

 

总结：

函数的返回值为None有三种情况
1.不写返回值
2.只写一个return
3.return None （几乎不用）
return的作用：结束一个函数的执行，返回要返回的值

函数的返回值不为None，有返回值
return xxx 返回一个值（一个变量）
return a,b 返回多个值(多个变量)，多个值之间用逗号区分
接收：可以用一个变量接收，以元组的形式返回
 也可以用多个变量接收，返回几个就用几个变量去接收

 

四.函数的参数

函数的参数
     实参和形参
     实参：函数调用的时候传入的参数值
     形参：是函数定义的时候定义的参数名
     参数可以是任意的数据类型
     可以传递0个或多个参数
     位置参数：按顺序定义参数
     默认参数：首先，不要设置可变数据类型的默认参数
                对于变化小的参数可以设置默认参数
                默认参数可以不传，不传的时候用的就是默认值
                如果传，会覆盖默认值
                默认的值是在定义函数的时候就已经确定了的
     调用函数时传参数：
         按照位置传参
         按照关键字传参

位置参数

站在实参角度

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)

2.按照关键字传值

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)

3.位置、关键字形式混着用

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 stu_info(name,sex = "male"):
    """打印学生信息函数，由于班中大部分学生都是男生，
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)


stu_info('alex')
stu_info('eva','female')

　　　　3.参数陷阱：默认参数是一个可变数据类型

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

  注：不要设置可变数据类型的默认参数

 

动态参数

　　按位置传值多余的参数都由args统一接收，保存成一个元组的形式；**kwargs代表把按关键字传来的参数拼成字典

def mysum(*args):
    the_sum = 0
    for i in args:
        the_sum+=i
    return the_sum

the_sum = mysum(1,2,3,4)
print(the_sum)

def stu_info(**kwargs):
    print(kwargs)
    print(kwargs['name'],kwargs['sex'])

stu_info(name = 'alex',sex = 'male')

def fun2(*args):#*args代表把散列的元素拼成元组
    print(args)
t = (1,2,3,4)
l = [1,2,3,4]
# fun2(t[0],t[1],t[2],t[3])
fun2(*t)  #*代表把一个元组、列表拆了
fun2(*l)  #*代表把一个元组、列表拆了

def fun3(**kwargs):#*args代表把按关键字传来的参数拼成字典
    print(kwargs)
fun3(a = 10, b = 20)
d = {'a': 10, 'b': 20}
fun3(**d)  #*代表把一个字典拆了

 

五.小结

面向过程编程的问题：代码冗余、可读性差、可扩展性差(不易修改)

定义函数的规则：

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

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值

调用函数的规则：

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

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

多个变量接收多返回值：
变量1，变量2，... = 函数名()

 

 

六.作用域、闭包函数、装饰器

http://www.cnblogs.com/huchong/p/7725564.html

 

 

 

 

我的博客即将搬运同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=p6ntv3wd7kd7