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语句中