python中函数与参数的简介

函数
函数就是具有某个具体功能的工具
而使用用函数能提供开发效率，减少代码冗余，提高程序的扩展性。

在Python中，函数有五大要点：分别是def、函数名、函数体、参数、返回值，以及两个英文版符号，分别是括号（括号内为参数）和冒号":"函数内容以冒号起始，并且缩进。

　　def：定义函数的关键字，没它可不行，后接函数标识符名称和圆括号()加":"，任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

　　函数名：函数的名称，不能以关键字起名字，根据函数名调用函数，虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能，函数也应该做到见名知意。

　　函数体：函数中进行一系列的具体操作。

　　参数：为函数体提供数据。

　　返回值：当函数执行完毕后，可以给调用者返回数据。

　　但是在函数中，最重要的是参数和返回值。

如果我们在定义函数的时要候没有想好定义函数的内容可以先用空函数：空函数就是什么事也不做，可以用pass语句。既然“一事不做”，那空函数还有什么用处？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。如此，运行代码程序就不会出现错误了。

1 #空函数
2 def nop():
3   pass

函数必须先定义再调用:

s = [1,2,3,4,5]
def my_len():  # 自定义函数
    n = 0
    for i in s:
        n += 1
    print(n)
res = my_len()

但是用我们自己写的函数现在的问题：

1.没有返回值 只能固定的执行打印操作

2.只能够固定的统计某一个容器类型的长度

函数内要想返回给调用者值 必须用关键字retur：

"""
不写return
只写return
写return None
写return返回一个值
写return返回多个值
"""

# 不写return:函数默认返回None
def func():
   print('hehehehe')
res = func()
print(res)   # hahaha   None


# 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行
# 只写return None  返回的也是None(None就表示什么都没有)
def func():
    l = ['apple','banana','orange']
    while True:
        for i in l:
            if i == 'banana':  # 当i为banana的时候 直接结束函数运行
                return  # 结束整个函数运行
                # print('asdasdkljlsjadl')  # 这一行代码永远都不会运行
            print(i)
res = func()
print(res)  # apple    None


# 写return None:返回的也是None(None就表示什么都没有)跟上面的只写return是一样的
def func():
    return None
res = func()
print(res)  # None


# 写return返回一个值:这个值可以是python任意数据类型
def func():
    return '123'  # 返回的是123
def func1():
    return [1,2,3]  # 返回的是[1,2,3]
def func2():
    return {'cat':'猫'}  # 返回的是{'cat':'猫'}
def func3():
    return (1,2,3)  # 返回的是(1,2,3)
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会自动将多个值以元组的形式返回给调用者,元组不会被修改
def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
res = func()
print(res)

def func1():
    return 'a','b','c'  # 返回的是 ('a', 'b', 'c')
res = func1()
print(res)

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

param 参数：positional arguments:位置参数：

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

"""
函数参数的两大类型
    形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
    实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
    
形参与实参的关系
     形参就相当于变量名,而实参就相当于变量的值
     函数调用传参的过程 就是给形参变量名赋值的过程
    
    注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
    只在函数内部有效 函数外部无任何影响
"""

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

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

# 第一种直接按照位置传  一一对应
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)


# 第二种指名道姓的传  >>>:关键字传参
def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
my_max(y=20,x=10)
my_max(10,y=20)  # 位置和关键字混合使用
my_max(20,y=40)  # 位置必须在前


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

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

def register(username,age,gender='male'):
    print(username,age,gender)  # 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参
register('小明',18)
register('小磊',19)
register('小红',20,"female")
register('小贱',21)
register('小芳',22,'female')

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

# 站在形参的角度 看 *
# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名
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 func1(x,y,*z):
    print(x,y,z)
func1(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func1(1,2,3,4,5,6) func1(*(1,2,3))  # 等价于func(1,2,3)
def func2(x,*z):
    print(x,z)
func2(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的形式 按照关键字参数传递给函数
"""