第十二天函数作用

第十一天函数作用

匿名函数

# 匿名函数的本质还是函数
"""
1）语法
函数名 = lambda 形参列表: 返回值

相当于:
def 函数名(形参列表):
    return 返回值
    
注意：匿名函数除了定义以及参数类型说明和普通函数不一样，其他都是一样的
"""
# 写一个匿名函数求两个数的和
sum1 = lambda num1, num2: num1 + num2

result = sum1(10, 30)
print(result)

result = sum1(12.5, 2)
print(result)

func1 = lambda a, b=20, c=30: a + b + c
result = func1(10)
print(result)

result = func1(a=1, b=2, c=3)
print(result)

result = func1(100, 200, c=300)
print(result)

# 练习：写一个匿名函数判断指定的年是否是闰年
is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(is_leap_year(2000))

调用函数

"""
语法：
函数名(实参列表)

说明：
函数名     -    需要调用的函数的函数名（必须是已经定义过的函数的函数名）
()        -    固定写法
实参列表   -     以 '数据1, 数据2, 数据3,...' 的形式存在
                实参是用来给形参赋值，实参是真正从函数外部传递到函数内部的数据
                
注意：同一个函数可以在需要它的功能的是反复调用
"""

# 2.函数调用过程
"""
1）定义函数不会执行函数体，调用函数的时候才会执行函数体
2）执行过程
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值）
第三步：执行函数体
第四步：确定函数返回值
第五步：回到函数调用的位置，接着往后执行
"""


def func1(x):
    # x = 10
    print('===============')
    print('++++++++++++++++')
    # print('abc'[10])


print('------------------华丽的分隔线-----------------')
func1(10)
print('end')

函数的参数

# 1. 位置参数和关键字参数   -  实参
"""
1）位置参数
以 '数据1, 数据2, 数据3,...' 的形式存在，让实参和形参从位置上一一对应
（第一个实参给第一个形参赋值，第二实参给第二个形参赋值，...）

2）关键字参数
以 '形参1=实参1, 形参2=实参2,...'的形式存在

3）混用
如果位置参数和关键字参数一起用，那么位置参数必须在关键字参数的前面
"""


def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


# 位置参数
func1(10, 20, 30)
func1(20, 10, 30)

# 关键字参数
func1(x=100, y=200, z=300)
func1(y=200, z=300, x=100)

# 位置参数和关键字参数一起用
func1(10, y=20, z=30)
func1(10, z=30, y=20)
func1(10, 20, z=30)
# func1(x=10, 20, z=30)     # SyntaxError: positional argument follows keyword argument


# 2. 参数默认值  -   形参
"""
定义函数的时候可以用 '形参=值' 的方式给参数赋默认值；
调用函数的时候有默认值的参数可以不用传参。

如果定义函数的时候有的参数有默认值，有的参数没有默认值，没有默认值的参数必须在有默认值参数的前面
"""


def func2(x=10, y=20, z=30):
    """func2"""
    print(f'x:{x}, y:{y}, z:{z}')


func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
func2(y=200)
func2(z=300)


def func3(x, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


# def func4(x=10, y=20, z):             # SyntaxError: non-default argument follows default argument
#     print(f'x:{x}, y:{y}, z:{z}')

# def func4(x=10, y, z):             # SyntaxError: non-default argument follows default argument
#     print(f'x:{x}, y:{y}, z:{z}')

# 3. 参数类型说明     -   形参
"""
情况1：没有默认值的参数，在参数后加 ':类型名'
情况2：有默认值的参数，值的类型就是参数的说明类型
"""


def func5(str1: str, list1=[]):
    pass


# 4. *不定长参数 (了解)     -   形参
"""
1）带*的不定长参数
在定义函数的时候可以在某个参数前加*，那么这个带*的参数就是一个不定长参数，可以同时接收多个实参。
带*的参数会自动变成一个元组，接收到实参是元组中的元素。
调用的时候带*的不定长参数必须用位置参数传参

2）带**的不定长参数（了解）
"""


def func6(*x):
    print(x)


func6()
func6(10)
func6(10, 20)
func6(10, 20, 30, 40, 50)


# 思考：一个函数可不可以既有不定长参数又参数？如果可以有没有什么问题存在（需要注意的地方）？
# 定长在不定长前面，都使用位置参数
def func7(x, *y):
    print(f'x:{x}, y:{y}')


func7(10, 20, 30, 40)


# 定长在不定长后面，定长必须使用关键字参数
def func7(*x, y):
    print(f'x:{x}, y:{y}')


func7(10, 20, 30, 40, y=50)


# 这儿*的作用只是强迫调用func8的时候，b和c必须使用关键字参数传参
def func8(a, *, b, c):
    pass


# 练习：定义一个参数可以求多个数的和
# sum1(10, 20)
# sum1(10, 20, 30)
# sum1(90, 8, 78, 27, 17)


def func9(**x):
    print(f'x:{x}')


func9()         # {}
func9(a=10)     # {'a': 10}
func9(m=100, n=200)     # {'m': 100, 'n': 200}
func9(name='余婷', age=19)        # {'name': '余婷', 'age': 19}
func9(name='小明', age=20, gender='男', hobby='篮球')    # {'name': '小明', 'age': 20, 'gender': '男', 'hobby': '篮球'}


# 保证func10调用的时候足够灵活
def func10(*args, **kwargs):
    pass


func10()
func10(10, 20)
func10(a=10, b=23)
func10(10, 20, x=10, y=23)

函数返回值

# 1. 返回值
"""
1）返回值的意义
返回值就是从函数内部传递到函数外部的数据

2）怎么确定函数返回值
返回值就是return关键字后面的表达式值(执行函数体的是如果遇到return，return后面是什么，函数返回值就是什么)
如果没有遇到return，返回值None

3）怎么在函数外部使用函数返回值
函数调用表达式的值就是函数的返回值，所以返回值能做的事情，函数调用表达式都可以做
函数调用表达式  - 调用函数的语句
"""


def func1():
    print('abc')
    return 100


result = 100
result = func1()    # 100
print(f'result: {result}')

print(100, func1())

print(100 * 2, func1()*2)

list1 = [100, func1(), 200]
print(list1)


def func2(x: str):
    # x = 'abc'
    return x*2      # return 'abc'*2  -> return 'abcabc'


func2('abc')        # 'abcabc'
print(func2('abc')[-1])    # 'abcabc'[-1] -> 'c'
# print('abcabc'[-1])


def func3():
    return [10, 20]


result = func3()        # result = [10, 20]
result.append(100)
print(result)

# 2.return的作用
"""
作用1：确定函数返回值
作用2：提前结束函数 -  如果执行函数体的时候遇到return，函数直接结束
"""


def func4(num):
    print('+++')
    if num == 0:
        return 0
    print('----')
    print('====')
    return 100