01.匿名函数
匿名函数本质还是函数，之前函数的所有的内容都适用于它
1.匿名函数的声明：
函数名 = lambda 参数列表:返回值
2.说明：
函数名：变量名
lambda:声明匿名函数的关键字
参数列表：参数名1，参数名2，···
冒号：固定写法
返回值：表达式，表达式的值就是返回值
3.调用
匿名函数的调用和普通函数一样
函数名(实参列表)
# 写一个匿名函数，计算两个数的和：
# 声明一个匿名函数
my_sum = lambda x, y: x + y
# 调用匿名函数
result1 = my_sum(10, 20)
print(result1)
练习：写一个匿名函数，获取指定列表指定下标的值的1/2
#匿名函数的参数可以设默认值
my_sum1 = lambda list1,index=0:list1[index]/2
# 位置参数
print(my_sum1([2,4,5,6,7],3))
# 关键字参数
print(my_sum1(index=1,list1=[12,4,768,98]))
练习2，获取一个列表的所有元素和平均值
（sum函数可以计算一个序列的和）
list_operation = lambda list1:(sum(list1),sum(list1)/len(list1))
sum1,ave=list_operation([1,2,3,4,5,6])
print(sum1,ave)
补充：python中的函数可以有多个返回值的。就是在一个return后返回多个值，多个值之间用逗号隔开
02.变量的作用域
1.函数的调用过程是一个压栈的过程：
每次调用一个函数，系统就会在内存区域中的栈区间去开辟空间，保存函数调用过程中产生的数据，当函数调用完成后，对应的栈区间会自动销毁函数调用时产生的栈区间中保存的数据有：形参、在函数中声明的变量
def func1(a, b):
c = 100
print(a, b, c)
func1(20, 30)
2.什么是作用域：
指的就是一个变量能够使用的范围
3.全局变量和局部变量
a.全局变量：就是声明在函数和类的外面的变量都是全局变量。全局变量的作用域：从声明开始到文件结束(从声明开始到文件结束，任何地方都可以使用)
a = 100 # 全局变量
if a > 10:
b = 20 # 全局变量
print(a, b)
b.局部变量：声明在函数中或者类中的变量就是局部变量。局部变量的作用域：从声明开始到函数或者类结束。
注意：函数的参数是生命在函数中的局部变量
# x,y,z都是局部变量
def func3(x1, y1):
z = 'abc'
print(x1, y1, z)
func3('a', 'b')
# 局部变量只能在声明变量的那个函数中使用，不能在函数外面使用。
# print(x1,y1,z)
# 全局变量
num1 = 100
# 全局变量
num2 = 10
def func4():
# 局部变量
num1 = 200
print(num1) # 如果全局变量和局部变量同名，那局部变量的作用域内使用的是局部变量的值
#想在局部区域内修改全局变量的值
global num2 #说明从此开始，后面的num2都是全局变量
num2=199
print(num2)
func4()
print(num1)
print(num2)
c.global关键字
#nonlocal 不声明局部变量
def func5():
# 局部变量
nn=10
#函数中可以声明函数
def func6():
nonlocal nn #在局部的局部中修改局部变量的值
nn=20
print("func6",nn)
func6()
print("func5", nn)
func5()
03.递归函数
1.
什么是递归函数？就是在函数的函数体中调用函数本身，这样的函数就是递归
2.
while循环能做的事情，递归都可以
#这儿的func1就是递归函数
def func1():
print('aaa')
func1()
#func1()# 死循环
3.怎么写递归函数
第一步：找临界值（找到循环结束的值/找到能够确定函数结果的值）
第二步：假设函数的功能已经实现的前提下，找关系（找f(n)和f(n-1)/当次循环和上次循环的关系）
第三步：根据f(n)和f(n-1)的关系，来通过f(n-1)实现f(n)的效果
#用递归实现1+2+3+···+n
def my_sum(n):
#1.找临界值(在临界值的位置一定要让函数结束)：
if n==0:
return 0
#2.找关系
my_sum(n): 1+2+3+···+n
my_sum(n-1): 1+2+3+···+n
my_sum(n)=my_sum(n-1)+n
#3.使用f(n-1)实现f(n)的效果
return my_sum(n-1)+n
print(my_sum(5))
"""
my_sum(5) n=5 return my_sum(4)+5 10+5
my_sum(4) n=4 return my_sum(3)+4 6+4
my_sum(3) n=3 return my_sum(2)+3 3+3
my_sum(2) n=2 return my_sum(1)+2 1+2
my_sum(1) n=1 return my_sum(0)+1 0+1
my_sum(0) n=0 return 0 0
"""
练习：使用递归计算斐波那契数列中1,1,2,3,5,8,13,21····第n个数
def sequence(n):
if n==1 or n==2:
return 1
#2.找关系
"""
sequence(n): 1,1,2,3,5,8,13···(n-1)+(n-2)
sequence(n)=sequence(n-1)+sequence(n-2)
"""
#3.使用f(n-1)实现f(n)的效果
return sequence(n-1)+sequence(n-2)
print(sequence(5))
"""
se(5) se(4)+se(3)
"""
练习：使用递归完成以下的效果：
"""
n=3
***
**
*
n=5
*****
****
***
**
*
"""
def ftr(n):
if n == 1:
print('*')
return
print('*'*n)
str(n-1)
ftr(6)
"""
4.递归需要不断调用函数开辟空间，消耗内存。
"""
04.模块和包的使用
1.封装：
1).函数：对实现某一特定功能的代码段的封装
2).模块：对变量、函数、类进行封装
模块：一个py文件就是一个模块
def multiply(*numbers):
sum1 = 1
for item in numbers:
sum1 *= item
return sum1
print(multiply(1,2,5))
1.怎么使用其他模块中的内容？
a.import 模块
通过模块.内容的形式去使用模块中的内容（能够使用是全局变量、函数、类）
b.from 模块 import 模块中的内容可以直接使用模块中的内容
c.from 模块 import *----->将模块中的所有内容都导入
#导入系统的math模块
import math
print(math.pi)
# a.
# #导入自定的my_list模块
import my_list
#
#a.使用模块中的全局变量
print(my_list.empty)
#
#b.使用模块中的函数
number=my_list.count([1,2,3,1,2,4,5,1,45,6,2],1)
print(number)
# b.
from my_list import count,empty
print(count([1,2,3,1,2,4,5,1,45,6,2],2))
print(empty)
#c.
from math import *
print(pi)
print(sqrt(4))
2.重命名
import 模块 as 新名字
form 模块 import 内容 as 新名字
import random as RAN
print(RAN.randint(1,10))
将不希望被别的模块导入（执行）的代码放到模块的这个if语句中
if __name__ == '__main__':
每个模块都有一个__name__属性，这个属性的值默认就是当前模块的文件名。
当前模块正在被执行（直接在当前这个模块中点了run）的时候,__name__属性的值是'__main__'
在一个模块中，将不希望被其他模块导入的代码写在if__name__=='__mian__'中。
将希望被导入的放到if外面。
建议：函数的声明、类的声明一般写在if的外面，其他的写在if里面。（想要被外部使用的全局变量也可以写在外面）
