一、复习
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
有网
请求数据
处理数据
保存数据
二、匿名函数
1.普通函数:
def 函数名（参数列表）
函数体

2.匿名函数:
函数名 = lambda 参数列表：返回值
说明：
函数名 --> 变量名
lambda --> 关键字
参数列表 --> 参数名1，参数名2…
： ---> 固定的
返回值 --> 相当于只有一个return语句的函数体
匿名函数的调用和普通函数一样：函数名（实参列表），也支持位置参数、关键字参数、参数设置默认值、不定长参数

写一个匿名函数，功能是求两个数的和
sum1 = lamdba num1=10, num2=3, num1+num2
print(sum1(10, 20)) # 30
print(sum1(num1=100, num2=200)) # 300
print(sum1()) # 13

sum11 = lamdbanums: sum(nums)
print(sum11(1, 2, 3)) # 6
练习：求1+2+3+…+n的和
sum2 = lambda n: sum(range(n+1))
print(sum2(100)) # 5050
练习：读程序
funcs = []
for item in range (1, 5):
funcs.append(lambda x : xitem)
print(item) # 4
print(funcs0) # 8
print(funcs1) # 8
三、变量的作用域
1.变量的作用域
变量的作用域指的是变量能够使用的范围
2.全局变量
全局变量:声明在函数和类的外面的变量都是全局变量；作用域是从声明开始，到整个py文件结束（任何地方都可以使用）

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

c是全局变量
for x in range(5):
for y in range(4):
c = 100
3.局部变量
声明在函数和类中的变量都是局部变量。声明在函数的局部变量，作用域是从声明开始到整个函数结束

def fun1():
# 局部变量
aa = 100
print(aa, a1)
for xx in range(5):
print(aa+xx)
4.global关键字
在函数中说明一个变量是全局变量
注意：只能在函数中使用

def func2():
global age
age = 18

global name    

说明当前函数中使用的name是全局变量name

name = 'aaa'
print(name)

5.nonlocal关键字
想要在局部的局部中修改局部变量的值

def func3():
abc = 100
def func4():
nonlocal abc
abc = 200
print('f4:', abc)
func4()
print('f3:', abc)
四、函数作为变量
声明函数就是声明一个类型是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(list21)

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)
4.将函数作为返回值
根据运算符号，返回对应的功能

def operation(operator: str):
if operator == '+':
def add(*args, **kwargs):
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 my_sum(*sums):
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) # 204 40.8
print(num[0], num[1]) # 247 49.4
2.函数的调用过程是一个压栈的过程
每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程中产生数据(函数中声明的变量)。
当函数调用完成后，这块内存会自动销毁。

六、递归函数（了解）
1.什么是递归函数
递归函数：函数中调用函数本身，这样的函数就是递归函数(自己调自己)

循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归
2.怎么写递归函数
第一步：确定临界值(循环结束的条件), 让函数结束
第二步：找关系,假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f(n)的功能

写一个递归函数，实现：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)
总结：递归，能不用就不用！！
七、作业
1.写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使 表自带的逆序函数)

def my_num(list1):
new_list =[]
for item in list1[::-1]:
new_list.append(item)
return new_list
list1 = [9, 3, 8, 5, 1, 7]
print(list1,my_num(list1))
结果：[9, 3, 8, 5, 1, 7] [7, 1, 5, 8, 3, 9]
2.写一个函数，提取出字符串中所有奇数位上的字符

def my_function(str1):
str2 = ""
for index in range(0,len(str1),2):
str2 += str1[index]
return str2
str1 =' jvg9o3rqyg90943'
print(str1,my_function(str1))
结果：jgory993
3.写一个匿名函数，判断指定的年是否是闰年

4.使用递归打印:

n = 3的时候
@
@@@
@@@@@

n = 4的时候:
@
@@@
@@@@@
@@@@@@@

5.写函数,利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

6.写一个函数，获取列表中的成绩的平均值，和最高分

def my_num(list1):
sum1 = 0
ave = 0
max list1[0]
for item in list1:
sum1 += item
if max< item:
max = item
ave = sum1/len(list1)
return ave, max
score = [85, 36, 76, 1, 19, 35, 20]
print(my_num(score))
结果:(38.857142857142854, 85)
7.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def new(xulie):
a = []
for index in range(0, len(xulie), 2):
a.append(xulie[index])
return a

a = [1,2,3,6,5,4,8]
b = (6,9,8,5,7,8,415,8)
print(new(a))
print(new(b))
结果： [1, 3, 5, 8]
[6, 8, 7, 415]
8.实现属于自己的字典update方法：用一个字典去更新另一个字典的元素(不能使用自带的update方法)
yt_update(字典1， 字典2)

9.实现属于自己的items方法：将字典转换成列表，字典中的键值对转换成元祖。（不能使用items方法）
yt_items(字典)
例如：{'a': 1, 'b':2, 'c':3} ---> [('a', 1), ('b', 2), ('c', 3)]