初识函数

内容目录　　　　　　　　　　　　
函数的返回值　　　　　　　　
函数的参数　　　　　　　　　
函数的定义　　　　　　　　　
函数的注释　　　　　　　　　
默认函数的陷阱　　　　　　　

函数的返回值　　　　
返回值的3种情况 1、没有返回值 —— 返回None   2、返回1个值   3、返回多个值
没有返回值的2种情况 1、返回None  2、return

 # 没有返回值 —— 返回None
        # 不写return
        # 只写return:结束一个函数的继续
        # return None  —— 不常用
    # 返回1个值
        # 可以返回任何数据类型
        # 只要返回就可以接收到
        # 如果在一个程序中有多个return，那么只执行第一个
    # 返回多个值
        # 用多个变量接收：有多少返回值就用多少变量接收
        # 用一个变量接收: 得到的是一个元组
def fun():
    a = 1
    # return a
print(fun()) #None

    #只写return:结束一个函数的继续
def fun():
    return
print(fun()) #None

    #return None:不常用
def fun():
    return None
print(fun()) #None

#返回一个值
    #可以返回任何数据类型
def fun():
    a = 1
    return a
print(fun()) #1

    #只要返回就能接收到

    #如果在一个程序里有多个return,那么只执行第一个
def fun():
    a = 1
    b = 2
    return a
    return b
print(fun()) #只接受a 1

# 返回多个值
        # 用多个变量接收：有多少返回值就用多少变量接收
def fun():
    a = 1
    b = 2
    return a,b
nu , nm = fun()
print(nu , nm) #1,2

        # 用一个变量接收: 得到的是一个元组
def fun():
    a = 1
    b = 2
    return a,b
num = fun()
print(num)  #(1,2)

函数的参数　　　　　 

#没有参数 --> 定义函数和调用函数时括号里都不写内容
def fun():
    a = 1
    return a
print(fun()) #1


#有一个参数 --> 传什么就是什么  
def fun(n):
    return n
print(fun(2)) #2


 
#有多个参数 --> 位置参数
def my_sum(a,b):
    res = a+b  #result
    return res
ret = my_sum(1,2)
print(ret)         #3

 

  函数的定义　　　　　  

位置参数 ： 直接定义参数
默认参数，关键字参数 ：参数名 = '默认的值'
动态参数 : 可以接受任意多个参数
            参数名之前加*，习惯参数名args，
            参数名之前加**，习惯参数名kwargs
                顺序：位置参数，*args,默认参数,**kwargs

位置参数
    站在实参的角度上：
        按照位置传参
        按照关键字传参
        混着用可以:但是 必须先按照位置传参，再按照关键字传参数
                不能给同一个变量传多个值
    站在形参的角度上：
        位置参数：必须传,且有几个参数就传几个值

# 站在实参的角度上：
        # 按照位置传参
def fun(name,sex):
    print('%s\t%s'%(name,sex))
num = fun('a','b') #a  b

        #按照关键字传
def fun(name,sex):
    print('%s\t%s' % (name, sex))
num = fun(name = 'a',sex = 'b')  #a  b

        #混着用可以:但是 必须先按照位置传参，再按照关键字传参数
                #  不能给同一个变量传多个值
def fun(name,sex):
    print('%s\t%s' % (name, sex))
num = fun('a',sex = 'b')  #a  b

#站在形参的角度上：
        #位置参数：必须传,且有几个参数就传几个值
def fun(name,sex):
    print('%s\t%s' % (name, sex))
num = fun('a',sex = 'b')  #a  b
nu = fun('c',sex = 'd')  #c  d

        #默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的
def fun(name,sex='b'):
    print('%s\t%s' % (name, sex))
num = fun('a')  #a  b    

 

　默认参数

   　　默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

def fun(name,sex='b'):
    print('%s\t%s' % (name, sex))
num = fun('a')  #a  b

动态参数 : 可以接受任意多个参数
                参数名之前加*，习惯参数名args，
                参数名之前加**，习惯参数名kwargs
                    顺序：位置参数，*args,默认参数,**kwargs
            动态参数有两种：可以接受任意个参数
                *args   ： 接收的是按照位置传参的值，组织成一个元组
                **kwargs： 接受的是按照关键字传参的值，组织成一个字典
                args必须在kwargs之前

#站在形参的角度上，给变量加上*，就是组合所有传来的值。
def func(*args):
    print(args)
func(1,2,3,4) #(1, 2, 3, 4)
l = [1,2,3,4,5]
func(*l)  #   (1, 2, 3, 4, 5)  
 #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

def func(**kwargs):
    print(kwargs)
func(a=1,b=2) #{'a': 1, 'b': 2}
d = {'a':1,'b':2}  #定义一个字典d
func(**d)   # {'a': 1, 'b': 2} 
#站在实参的角度上，给一个序列加上*，就是将这个字典按照顺序打散

def func(*args,**kwargs):
    return args,kwargs
print(func(1,2,3,4,a = 1,b = 2))
#((1, 2, 3, 4), {'a': 1, 'b': 2})

 

　函数的注释　　　　　　　　

　　def func():
　　'''
　　这个函数实现了什么功能
　　参数1：
　　参数2：
　　return: 是字符串或者列表的长度
　　'''
　　pass

默认函数的陷阱　　　　　　 

def qqxing(k,l = []):
    l.append(k)
    print(l)

qqxing(1)     #[1]
qqxing(2)     #[1,1]
qqxing(3)     #[1,1,1]
qqxing(4,[1,2]) #[1, 2, 4]

# 如果默认参数的值是一个可变数据类型，
# 那么每一次调用函数的时候，
# 如果不传值就公用这个数据类型的资源