函数

s = 'hello'
print(len(s))  # 5 len() 内置函数:python提前给你的写好了的函数  你直接调用即可
def my_len():
    n = 0
    for i in s:
        n += 1
    print(n)        # 5
res = my_len()
print(res)         # None
1.没有返回值，只能固定的执行打印操作
2.只能够固定的统计某一个容器类型的长度

def func():
    print('hahaha')
res = func()
print(res)   #  None
不写return,默认返回的是None

def func():
    l = ['jason','egon','tank']
    while True:
        for i in l:
            if i == 'egon':  # 当i为egon的时候 直接结束函数运行
                return
            print(i)  # jason
res = func()
print(res)  # None
只写return,可以直接结束整个函数的运行，返回的是None

　　return None和return一样

def func():
    return '123'
print(func())  # 123
写return返回一个值，这个值可以是python任意数据类型

def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
res = func()
print(res)

def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)
return返回多个值，return会自动将多个值以元组的形式返回
如果返回的不想是元组，需要手动添加想要返回的数据类型

　　所有函数都有返回值，不管有没有return,不写默认返回的是None

　　只写return或者return None不是为了考虑返回值，而是为了结束函数的运行

def my_len(args):  # 需要一个参数
    print(args)
    n = 0
    for i in args:
        n += 1
    return n
print(my_len('hello'))

函数参数的两大类

　　形参：在函数的定义阶段，括号内写的变量名，叫做该函数的形式参数

　　实参：在函数的调用阶段，括号内实际传入的值，叫做实际参数

形参与实参的关系

　　形参相当于变量名，实参相当于变量的值

　　函数调用传参的过程，就是给形参变量名赋值的过程。

　　形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动解除，只在函数内部有效，函数外部无任何影响。

函数的简易结构

　　def 函数名（形参1，形参2，形参3...）

　　'''

　　‘’‘函数体的注释，用来描述该函数的作用以及各个形参的类型‘’’

　　函数体代码1

　　函数体代码2

　　'''

　　return 函数的返回值

位置参数：在函数定义阶段按照位置从左到右依次书写的变量名，叫做函数位置形参

位置形参在调用的时候，必须为其传参

def my_max(x,y):
    print(x,y)  # 20 10
    if x > y:
        return x
    else:
        return y
res = my_max(20,10)
print(res)  # 20

位置实参：在函数调用阶段，第一种传入的参数会按照位置一一对应给形参，第二种通过关键字传参

　　在函数的调用阶段，位置参数和关键字参数可以混合使用，但是位置参数在关键字参数的其前面, 同一个形参不能多次赋值

默认值参数：在函数的定义阶段，形参已经被赋值了

　　在调用的时候可以不用给默认值形参传值，默认使用定义阶段已经绑定的值,  在调用的时候可以给默认值形参传值，传了就使用自己传的值,  在定义阶段，默认值形参必须放在形参后面

def register(username,age,gender='male'):
    print(username,age,gender)  
register('jason',18)  # jason 18 male
register('tank',28)  # tank 28 male
register('egon',84)  # egon 84 male
register('kevin',58)  # kevin 58 male
register('xiaohou',17,'female')  #xiaohou 17 female

　　当形参接收的值比较单一的时候，通常考虑用默认值形参

def info(username,hobby,l = []):
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study',[])  # jason 的爱好是 ['study']
info('tank','生蚝',[])  # tank 的爱好是 ['生蚝']
info('kevin','喝腰子汤',[])  # kevin 的爱好是 ['喝腰子汤']
info('egon','女教练',[])  # egon 的爱好是 ['女教练']

m = 100
def my_max(x,y=m):
    print(x,y)  # 111 100
m = 222
my_max(111)

　　函数在定义阶段内部所使用的变量都已经初始化完毕了, 不会因为调用的位置的变化，而影响到内部的值

 可变长参数

　　调用函数传递实参的个数不固定，因此，形参也不固定，用*和**接收多余的位置参数和关键字参数,  形参中的*会将多余的位置实参，统一用元组的形式处理，传递给*后面的形参名

def func(x,y,z):
    print(x,y,z)  # 2 4 6
func(2,4,6)

　　实参中*将容器类型打散成位置实参一一传入容器类型只能是列表，元组，集合，字符串

def func(x,y,**z):
    print(x,y,z)
func(x = 1,y = 2,z = 3,a = 5)  # 1 2 {'z': 3, 'a': 5}

　　**会接收所有多余的关键字参数，并将关键字参数转化为字典形式，字典的key就是关键字的名字,  其中的value就是关键字的名字指向的值，将字典交给**后面的变量名

def func(x,y,z):
    print(x,y,z)
d = {'x':1,'y':2,'z':333}
func(**d)  # 等价于func(x=1,y=2,z=333)  **会将字典拆成key = value的形式

　　*在形参中能够接收多余的位置参数，组织成一个元组赋给*后面的变量名

　　**在形参中能够接收多余的关键字参数 组织成一个字典赋给**后面的变量名

　　*在实参中*能够将列表，元组，集合，字符串打散成位置实参的形式传递给函数

　　**在实参中能够将字典打散成key  = value 的形式按照关键字参数传递给函数

def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z = 3)