匿名函数本质还是函数，之前函数的所有适用于它

匿名函数的声明
匿名函数=lambda 参数列表：返回值

说明：
函数名：变量名
lambda：声明匿名函数的关键字
参数列表：参数名1，参数名2，......
冒号：固定写法

返回值：表达式，表达式的值就是返回值

匿名函数可用位置参数 也可以用关键字参数

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

每次调用一个函数，系统就会在内存区域中栈区间去开辟空间，保存函数调用过程中生成数据

当函数调用完成后，对应的栈区间会的销毁

函数调用时生产的站区间中保存的数据有：形参、在函数中声明的变量

def func1(a，b)：
  c=100
print（a，b，c）
func1（20，30）

什么事作用域

指的是以变量能够使用的范围
全局变量和局部变量
全局变量Global：就是声明在函数和类的外面的变量都是全局变量。
全局变量的作用域：从声明开始到文件结束（从声明任何地方都可以用）
局部变量local：声明在函数中或者类中的变量就是局部变量
局部变量的作用域：从声明开始到函数结束或者是从声明开始到类结束
注意：函数的参数是声明在函数中的局部变量
def func3(x,y):
  z='abc'

递归函数

在函数的函数体中调用函数本身，这样的函数就是递归函数。

def func1（）：
    print（‘aaa’）
    func（）
func1（）
怎么写递归函数
第一步：找临界值找到让循环结束的值/找到能确定幻术结果值
第二步：假设函数的功能已经实现的前提下找关系（找f（n）和f（n-1）/当次循环和上次循环的关系）
第三步;根据f（n）和f（n-1）的关系，来通过f（n-1）实现f（n）的效果

临界值是（在临界值的位一定要让函数结束）
在实际开发，递归是能不用就不要用
递归需要不断调用函数，开辟几件，消耗内存
封装：
函数：对实现某一特定功能的代码daunt的封装
模块：对变量、函数、类进行封装
模块：一个py文件就是一个模块
def multiply（*numbers）：
    sum1=1
    for item innumbers：
        sum1*= item
    return sum1
print（multiply（1,2,5））

怎么使用其他模块中的内容？

impot 模块

from_impot 模块中的内容
通过模块，内容的形式去使用模块中的内容（能够使用是全局变量）

1.写一个函数将一个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])(注意：不要使用列表自带的逆序函数)

方法一

def change_line(list):
    count = len(list)
    list2 = list[:]
    for i in list[:]:
        list2[count-1] = i
        count -= 1
        if count == 0:
            break
    return list2
print('逆序为：',change_line([1, 2, 3, 4]))

result:
逆序为： [4, 3, 2, 1]

#方法二

def chang_line(list):
    list2 = list[-1::-1]
    return list2
print('逆序为：',chang_line([1, 2, 3, 4]))

result：
逆序为： [4, 3, 2, 1]

2.写一个函数，提取出字符串中所有奇数位上的字符

def get_str(str1:str):
    list1 = list(str1)[::2]
    str1 = ''
    for i in list1:
        str1 += i
    return str1      
print('奇数位上的字符是',get_str('abcdefg'))

result：
奇数位上的字符是 aceg

3.写一个匿名函数，判断指定的年是否是闰年

maybe = lambda year:not year % 4 and year % 100
maybe1 = maybe(2012)
if maybe1:
    print('闰年')
elif not maybe1:
    print('平年')

result：
闰年

4.使用递归打印如下效果：

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

a = []
#将打印个数作为递归结果输入为一个列表
def print_n (n):
    if n == 1:
        return a.append(1)
    a.append(n)
    print_n(n-1)
print_n(4)
for item in a[-1::-1]:
    print('@'*item)

result：
@
@@
@@@
@@@@

5.写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def len_2(list:list):
    if len(list) <= 2:
        print('列表长度小于2，列表不变：',end='')
        return list
    else:
        print('列表长度大于2，只保留2个长度内容，新列表是：',end='')
        return list[0:2]
print(len_2([2, 3, 4, 5, 6]))

result：

列表长度大于2，只保留2个长度内容，新列表是：[2, 3]

6.写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。（自己背着写）

def fib(n):
    if n == 1 or n == 2:
        return 1
    return fib(n-1) + fib(n-2)
print('斐波那契数列第十个数是：',fib(10))

result：
斐波那契数列第十个数是： 55

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

def value_mix(list1:list):
    a = []
    list1.sort()
    a.append(sum(list1)/len(list1))
    a.append(list1[-1])
    return a
print('平均值、最高分分别是：',end='')
print(value_mix([13,36,24.5,23])[0],value_mix([13,36,24.5,23])[1])

result：
平均值、最高分分别是：24.125 36

8.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def uneven_number(list1):
    return list1[::2]
print('奇数元素对应的新列表是：',uneven_number([1,2,3,4,5]))

result：
奇数元素对应的新列表是： [1, 3, 5]

9.写一个属于自己的数学模块(封装自己认为以后常用的数学相关的函数和变量)和列表模块（封装自己认为以后常用的列表相关的操作）

def Multiplication(n):
    求1~n的乘积
    :param n:
    :return:
    multiplication = 1
    for i in range(1,n+1):
        multiplication *= i
    print(n,end='')
    return multiplication
print('的累乘：%d'%Multiplication(5))
result：
5的累乘：120