1.复习：

1.函数的声明

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

补充：参数列表中，可以通过'参数名:类型名'来指定参数的类型,也可以通过设置默认值来说明参数的类型

说明类型的好处：
a.传什么类型的值一目了然
b.实现函数体的时候，可以有相关提示

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

2.函数的调用

函数名(实参列表)

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

3.函数的参数

函数的参数
位置参数 （10,20）
关键字参数（a=10,b=20）

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

• 不定长参数 在参数前面加 *

4.返回值

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

2.返回值就是函数调用表达式的值。

调用函数的目的：
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)

2.匿名函数：

1.普通函数:
def 函数名(参数列表):
函数体

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

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

！！！匿名函数的调用和普通函数一样：
函数名(实参列表),也支持位置参数、关键字参数、参数设置默认值、不定长参数

• 1.写一个匿名函数，功能是求两个数的和

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

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

• 2. 求最大值：

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

相当于上面的匿名函数

 def sum1(num1, num2):
     return num1+num2

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

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

注意：range(10） =0,1,2,3,4,5,6,7,8,9

• 4.练习：读程序

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

item = 1 ~ 4
item = 1 [lambda x: xitem]
item = 2 [lambda x: xitem, lambda x: xitem]
item = 3 [lambda x: xitem, lambda x: xitem, lambda x: xitem]
item = 4 [lambda x: xitem, lambda x: xitem, lambda x: xitem, lambda x: xitem]

print(funcs[0](2))  # 2*4   8
print(funcs[1](2))  # 2*4   8

3.变量的作用域：

1.变量的作用域

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

2.全局变量

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

1.a 是全局变量

a = 10

2. x和b都是全局变量

for x in range(5):
    b = 10
    print(x)

3. 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()

4.函数作为变量：

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

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

print(type(func1))

funtion

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))

5.函数的调用：

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.函数的调用过程是一个压栈的过程

• 每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数

  • 执行过程中产生数据(函数中声明的变量)。

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

6.递归函数：

1.什么是递归函数

递归函数：函数中调用函数本身，这样的函数就是递归函数(自己调自己)
循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归

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

2.怎么写递归函数
第一步：确定临界值(循环结束的条件), 让函数结束
第二步：找关系,假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f(n)的功能

yt_sum(5) n=5 5!=1 return yt_sum(4)+5
yt_sum(4) n=4 4!=1 return yt_sum(3) + 4
yt_sum(3) n=3 3!=1 return yt_sum(2) + 3
yt_sum(2) n=2 2!=1 return yt_sum(1) + 2
yt_sum(1) n=1 1==1 return 1

• 写一个递归函数，实现：1+2+3+...n

def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2.找关系
    """
    yt_sum(n) = 1+2+3+...+n
    yt_sum(n-1) = 1+2+3+...+n-1
    yt_sum(n) = yt_sum(n-1)+n
    """
    # 3.用f(n-1)实现f(n)的功能
    return yt_sum(n-1) + n


print(yt_sum(5))

用递归实现以下功能:`
n = 3
***
**
*
n = 4
****
***
**
*

f(n)和f(n-1)的关系：
先打印n颗星

f(n-1)
def print_star(n):
    if n == 1:
        print('*')
        return

    print('*'*n)
    print_star(n-1)


print_star(5)

总结：递归，能不用就不用！！

7.作业：

• 1.写一个函数，求指定列表中，指定的元素的个数 。

def yt_count(list1:list, item):
    count = 0
    for x in list1:
        if x == item:
            count += 1
    return count

print(yt_count([1, 34, 56, 7, 1, 3, 1], 17))

• 2. 编写一个函数，实现摇骰子的功能，打印n个骰子的点数和。
     import random
     from random import randint

def play_dice(n):
    sum1 = 0
    for _ in range(n):
        num = randint(1, 6)
        print(num)
        sum1 += num

    return sum1

print(play_dice(2))

• 3. 编写一个函数，交换指定字典的key和value。
     如:{'a':1, 'b':2, 'c':3} ---> {1:'a', 2:'b', 3:'c'}

def change_key_value(dict1:dict):

    for key in dict1.copy():
        # 通过key拿到值
        value = dict1[key]
        # 删除原来的键值对
        del dict1[key]
        # 将值作为key,键作为value，添加键值对
        dict1[value] = key