"""

1.函数的声明

def 函数名(参数1:类型1, 参数2:类型2...) ->返回值类型:
函数说明文档
函数体

补充：参数列表中，可以通过'参数名:类型名'来指定参数的类型,也可以通过设置默认值来说明参数的类型
说明类型的好处：a.传什么类型的值一目了然 b.实现函数体的时候，可以有相关提示

声明函数的时候不会执行函数体

2.函数的调用

函数名(实参列表)

调用过程：
第一步：回到函数声明的位置
第二步：用实参给形参赋值 --> 传参(保证每个参数都要有值)
第三步：执行函数体
第四步：确定返回值 --> 将函数调用表达式设置为返回值
第五步：回到函数调用的位置，接着往后执行

3.函数的参数

位置参数
关键字参数

参数的默认值 --> 有默认值的参数要放在没有默认值参数的后面

不定长参数

4.返回值

python中所有的函数都有返回值。如果遇到return,函数的返回值就是return后面的值；没有遇到返回值就是None

返回值就是函数调用表达式的值。
调用函数的目的：a.执行函数体 b.获取返回值

return的作用：a.返回返回值 b.结束函数(函数中遇到return函数就结束)
def download(url):
if 没有网:
retrun None
# 有网
请求数据
处理数据
保存数据
"""

def func2(a=0, b=0):
    print(a*b)

print(func2(10, 20))


def func1(a: int, b: int) ->list:
    """
    求两个数的和
    :param a: 数字，整型
    :param b: 数字，整型
    :return: 和
    """
    return [a, b]


re = func1(10, 20)
# re.append(9)
print(re)

"""
补充：不定长参数（面试题）
*参数名: 将位置参数作为元祖的元素。参数就是一个元祖
**参数名: 将关键字参数，一参数名为key，实参为值组合成键值对，作为字典的元素。参数是一个字典

注意：经常将args和kwargs组合在一起使用，但是使用的时候要放在**的前面！

说说*args, **kwargs之间的区别？
"""

def func4(*args):
    print(args)


func4(23, 89, 90)


def func5(**kwargs):
    print(kwargs)


func5(a=12, b=89, c=100, d=34)


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


func6(12, 90)
func6(a=10, b=20, c=30)
func6(12, 34, a=10, b=20)
func6(12, a=23, b=30)

================匿名函数================

"""

1.普通函数:

def 函数名(参数列表):
函数体

2.匿名函数:

函数名 = lambda 参数列表:返回值

说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 -> 参数名1, 参数名2...
: -> 固定的
返回值 -> 相当于只有一个return语句的函数体

匿名函数的调用和普通函数一样：函数名(实参列表),也支持位置参数、关键字参数、参数设置默认值、不定长参数
"""
写一个匿名函数，功能是求两个数的和

sum1 = lambda num1=10, num2=3: num1+num2

print(sum1(10, 20))
print(sum1(num1=100, num2=200))
print(sum1())

sum11 = lambda *nums: sum(nums)
print(sum11(1, 2, 3))

# 相当于上面的匿名函数
# def sum1(num1, num2):
#     return num1+num2

练习：求1+2+3+...+n的和

sum2 = lambda n: sum(range(n+1))
print(sum2(100))

练习：读程序

funcs = []
for item in range(1, 5):
    funcs.append(lambda x: x*item)
print(item)

"""
item = 1 ~ 4
item = 1  [lambda x: x*item]
item = 2  [lambda x: x*item, lambda x: x*item]
item = 3  [lambda x: x*item, lambda x: x*item, lambda x: x*item]
item = 4  [lambda x: x*item, lambda x: x*item, lambda x: x*item, lambda x: x*item]
"""
print(funcs[0](2))  # 2*4   8
print(funcs[1](2))  # 2*4   8

================变量的作用===============

"""

1.变量的作用域

变量的作用域指的是变量能够使用的范围

2.全局变量

全局变量:声明在函数和类的外面的变量都是全局变量；作用域是从声明开始，到整个py文件结束（任何地方都可以使用）
"""

# a 是全局变量
a = 10

# x和b都是全局变量
for x in range(5):
    b = 10
    print(x)

# c是全局变量
for x in range(5):
    for y in range(4):
        c = 100

print(c)

"""

3.局部变量

声明在函数和类中的变量都是局部变量。声明在函数的局部变量，作用域是从声明开始到整个函数结束
"""

全局变量

a1 = 100


def fun1():
    # 局部变量
    aa = 100
    print(aa, a1)
    for xx in range(5):
        print(aa+xx)




fun1()
# print(aa)  # NameError: name 'aa' is not defined

"""

4.global关键字

在函数中说明一个变量是全局变量

注意：只能在函数中使用
"""

全局变量

name = 'abc'


def func2():
    global age
    age = 18

    global name    # 说明当前函数中使用的name是全局变量name
    name = 'aaa'
    print(name)



func2()
print(name)
print(age)

"""

5.nonlocal关键字

想要在局部的局部中修改局部变量的值
"""

def func3():
    abc = 100
    def func4():
        nonlocal abc
        abc = 200
        print('f4:', abc)
    func4()
    print('f3:', abc)

func3()

================函数作为变量=============

"""

声明函数就是声明一个类型是function的变量, 函数名实质就是变量名。

"""

def func1():
    print('====')

print(type(func1))

"""

1.变量可以给其他变量赋值

"""

a = 10
b = a
print(b*10)

list1 = [1, 2]
list2 = list1
list2.append(100)
print(list2)

func1 = lambda x: print(x)
func2 = func1
func2(10)

# 声明一个变量func11，类型是function
def func11():
    print('我是函数')
# 用一个函数给变量a赋值，a也是一个函数
a = func11
a()
print(a)

# 将函数func11的返回值给b，b的值是None
b = func11()
print(b)

"""

2.函数作为列表的元素

"""

a = 10
list1 = [1, a]
print(list1, list1[1]+100)

def func22():
    print('我又是函数')
    return 10

list2 = [1, func22, func22()]
print(list2)

# list2[1]取到一个函数, 通过后面加()调用函数
print(list2[1]())

# list2[2]取到的是整数10
print(list2[2]+100)

"""

3.将函数作为参数

"""

a = 10
def func1(n):
    print(n)

func1(a)


def func11(n):
    # n = func12
    n()  # func12()

def func12():
    print('hello world')


re = func11(func12)

应用：sort的使用

"""
列表.sort(key=None, reverse=False)
使用sort的时候,可以通过给key赋一个函数变量，来规定列表中的元素按照什么标准来排序。
这儿的函数变量要求要有一个参数和一个返回值。参数代表列表中的元素，返回值代表按照那个标准排序
"""

list1 = [1, 45, 8, 89]
list1.sort()
print(list1)

list2 = [
    {'name': '张三', 'age': 20, 'score': 90},
    {'name': '李四', 'age': 28, 'score': 70},
    {'name': '王五', 'age': 18, 'score': 89}
]
# 根据成绩排序
# def get_age(item):
#     return item['score']
# list2.sort(key=get_age)
list2.sort(key=lambda item: item['score'])
print(list2)


list3 = [
    ('a', 20),
    (10, 3),
    ('b', 90)
]
# def second(item):
#     return item[1]
# list3.sort(key=second, reverse=True)
# print(list3)

list3.sort(key=lambda item: item[1])
print(list3)

"""

4.将函数作为返回值

"""

# 根据运算符号，返回对应的功能
def operation(operator: str):
    if operator == '+':
        def add(*args, **kwargs):
            """求和"""
            """
            args=(10, 20)
            kwargs = {'a':2, 'b':3}
            """
            sum1 = 0
            for item in args:
                sum1 += item
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return add

    elif operator == '*':
        def func2(*args, **kwargs):
            """求乘积"""
            sum1 = 1
            for item in args:
                sum1 *= item
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1
        return func2


f1 = operation('+')   # f1就是有两个不定长参数，功能是求和的函数
re = f1(10, 20, a=2, b=3)
print(re)


print(operation('+')(10, 20, a=2, b=3))
print(operation('*')(1, 2, 3, 4))

===============函数的调用================

"""

1.补充：python中的函数可以有多个返回值

"""

# 求多个数的和以及平均值
def yt_sum(*nums):
    sum1 = sum(nums)
    average = sum1 / len(nums)
    return sum1, average   # 同时返回和、平均值


a, b = yt_sum(2, 45, 67, 90, 0)
num = yt_sum(34, 56, 67, 34, 56)
print(a, b)
print(num[0], num[1])

"""

2.函数的调用过程是一个压栈的过程

每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程中产生数据(函数中声明的变量)。

当函数调用完成后，这块内存会自动销毁。

"""

================