函数

函数的简介

s='hello'
print(len(s))  # len 内置函数:python提前写好的函数,直接调用就行
n = 0
for i in s:
    n+=1
print(n)  # 5


my_len()  # 函数必须先定义后调用   定义了的函数可以在任意文职调用
s = 'hello'
def my_len():  # 自定义函数
    n = 0
    for i in s:
        n+=1
    print(n)
res = my_len()
print(res)  # 5

我们自己写的函数现在的问题包括以下两点
　　1 没有返回值 只能固定的执行打印操作
　　2 只能够固定的统计某一个容器类型的长度

函数的返回值

# 五种情况
'''
不写return
只写return
写return None
写return 返回一个值
写return 返回多个值
'''

不写return:函数默认返回None

def func():
    print('哈哈哈')  # 哈哈哈
res = func()
print(res)  # None

只写return   return 除了可以返回值之外 还可以直接结束整个函数的运行
只写return   返回的也是None(None就表示什么都没有)

def func():
    l = ['james','egon','tank']
    while True:
        for i in l:
            if i == 'tank':  # 当i为tank时候,直接结束函数运行
                return
  #             return 同缩进之后的代码都不运行
            print(i)
res = func()
print(res)

写return None:和上面的只写return是一样的

def func():
    return None
res = func()
print(res)

写return返回一个值:这个值可以是python任意数据类型  也就是说 return 可后面可以写任意类型的值

def func():
    return '123'  # 123
def func1():
    return [1,2,3]  # [1,2,3]
def func2():
    return {'name':'jason'}  # {'name':'jason'}
def func3():                                        
    return (1,)  # (1,)                                           
def func4():                                                       
    return {1,2,3,4,5}  # {1,2,3,4,5}                         
def func5():                                                          
    return True  # True                                              
print(func(),func1(),func2(),func3(),func4(),func5())                 

return返回多个值 return会自动将多个值以元组的形式方会给调用者         
  1 函数不希望自己处理的结果被修改   元组又是不可变类型               
  2 如果返回值不是元组类型的话    在上面
  3 返回多个值 并且不想让return帮你做处理  自己手动加上你想返回的数据类型符号

def func1():
    return 'a','b','c'  # ('a', 'b', 'c')
res = func1()
print(res)

def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)

def func3():
    return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res2 = func3()
print(res2)

def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)  # [[1,2,3,4],[1,2,3,4],[1,2,34]]

1 所有的函数都有返回值,无论你写不写return
  python 中所有的函数都有返回值,不写的情况下默认范湖None
2 只是写return 或者 return None并不是为了考虑返回值 而是为了结束函数的运行

函数的参数概要

函数参数的两大类型
    形参:在定义函数的阶段 括号里面的写的变量名 叫做该函数的形式参数 简称 形参
    实参:在函数的调用阶段 括号里面是传入的值 叫做该函数的实际参数  简称 实参
    
    形参与实参的关系
        形参就相当于一个变量名,实参就相当于变量的值
        函数调用传参的过程 就是给形参的变量名复制的过程
    ps 形参和实参的绑定关系只是在调用对应函数的阶段才有用,函数运行结束之后他们之间的关系自动解除
       也就是说他们只有在函数内部才有效果  函数外部无任何影响
       
       函数的常见简易结构
       def 函数名(形参1,形参2...):
        ''  函数的注释 用来描述该函数的作用以及各个形参的类型''
        函数体代码一
        函数体代码一
        return  函数的返回值

s = 'hello'
l = [1.2,3,4]
# print(len(s))
# print(len(l))

def my_len(args):  # 需要0个参数
    print(args)
    n = 0
    for i in args:
        n += 1
    return n
# res = my_len()
# print(res)
# my_len(l)  # 给my_len传了一个参数
# my_len('asda')
print(my_len('hello'))
print(my_len('hello world'))
print(my_len([1,2,3,4,5]))

def func(x,y):
    '''
    此处就是介绍下你的函数是什么意思
    :param x: 对形参x的解释
    :param y: 对形参y的解释
    :return: 对函数返回值的解释
    '''
    print('哈哈哈')
    return 'heiheihei'
print(help(func))
print(help(len))

位置参数

    位置参数:在函数定义阶段按照位置从左往右一次书写的变量名 叫做函数的位置形参
    ps   位置形参在调用的时候必须为其传值

def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行

# res = my_max(20,10)

# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
# print(res)


# 第一种直接按照位置传  一一对应

# 第二种指名道姓的传  >>>:关键字传参
# my_max(y=20,x=10)
# my_max(10,y=20)  # 位置和关键字混合使用
# my_max(20,y=40)

注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证
    1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
    2.同一个形参不能被多次赋值

默认值参数

默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
在定义阶段 默认值形参必须放在位置形参的后面

def my_max(x,y=100):
    if x > y:
        return x
    return y
# res = my_max(200)
res1 = my_max(200,1000)
res2 = my_max(y=200,x=1000)
print(res2)

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

默认值参数的应用场景
当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参

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

# 解决方法1
info('jason','study',[])
info('tank','生蚝',[])
info('kevin','喝腰子汤',[])
info('egon','女教练',[])

解决方法2
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')

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



def func(x,y=100):
    print(x,y)

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


函数无论在什么地方被调用
都会跑到函数定义阶段去执行代码
形参中用到的值都是往函数定义阶段代码往上找

可变长参数

站在调用函数传递实参的角度  实参的个数不固定的情况
也就意味形参也不固定
站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

站在形参的角度 看 *
形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

def func(x,y,*z):
    print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)

# 站在实参的角度 看 *
def func(x,y,z):
    print(x,y,z)
l = [1,2,3]
a,b,c = l
func(a,b,c)
func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
func(*(1,2,3))  # 等价于func(1,2,3)
def func(x,*z):
    print(x,z)
func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
*只能将列表 元组 集合 字符串
*的内部你可以看成是for循环

# 站在形参的角度看 **
def func(x,y,**z):
    print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
func(x=1,y=2,z=1,a=1,b=2,c=3)
# **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
# 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名


# 站在实参的角度看 **
def func(x, y, z):
    print(x, y, z)


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

总结 * 和 **

总结 * 与 **
    *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
    **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名


    *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
        (*就看成是for循环取值)
    **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

注意python推荐形参*和**通用的写法

def func2(*args, **kwargs):
    print(args, kwargs)

func2(1, 2, 3, 4, 5, 6, x=1, y=2, z=3)