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

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

说明：
函数名：变量名
lambda:声明匿名函数的关键字
参数列表：参数名1，参数名2，....
冒号：固定写法
返回值：表达式，表达式的值就是返回值

调用
匿名函数的调用和普通函数一样
函数名(实参列表)

#匿名函数计算两个数的和

my_sum = lambda x,y: x+y
print(my_sum(10,2))

# 练习：写一个匿名函数，获取指定的数字列表，指定的下标的值的1/2
#练习2：获取一个列表的所有元素的和和平均值(sum函数可以计算一个序列的值)

my_sum1 = lambda lst,index: lst[index]/2
my_sum2 = lambda lst: sum(lst)

print(my_sum1([1,2,3,4,5,6],4))
print(my_sum2([1,2,3,4,5,6]))

#补充：python中的函数可以有多个返回值，一个return后有多个返回值，多个值之间用逗号隔开
#多个值返回是一个元组
def lit(list1:list):
  return sum(list1),sum(list1)/len(list1)
print(lit([12,3,4,54]))

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

每次调用一个函数，系统就会在内存区域中的栈区间去开辟空间，保存函数调用过程中产生的数据
当函数调用完了，对应的栈区间会自动销毁

函数调用时产生的栈区间中保存的数据有哪些：形参，在函数中声明的变量

def func1(a,b):
  c = 100
  print(a,b,c)

func1(20,30)

什么是作用域：
指的是一个变量能够使用的范围

全局变量和局部变量
python全局变量：
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(15,23)
#局部变量只能在声明变量的函数使用，不能再函数外面使用，也不能再别的函数使用
#print(x1,z)

c. global 关键字：是在函数中声明的全局变量
global 变量名
变量名 = 值

num1 = 100
num2 = 200
def func4():
  num1 = 200
  print(num1)
  global num2#声明num2是全局的变量，
  num2 = 300
func4()
print(num1)
print(num2)

def func5():
  nn = 10
  print(nn)
  def func6():
      # nonlocal nn#在函数中的函数中声明一个对于局部的全局变量，只可以在函数中有效
      nn = 20
      print(nn)

  func6()
  print(nn)

func5()

# 1.
def func():
  a = []
  for i in range(5):
      def G():
          print(i)
      a.append(lambda x:x*i)

  return a
a1 = func()
print(a1[0])
print(a1[0](1),a1[2](2),a1[3](2))

递归函数

什么是递归函数
在函数的函数体中调用函数本身，这样的函数时递归函数

# while循环能够在的事情，递归都可以做
def sum1(items):
  head,*tail = items
  print(head,tail)
  return head + sum(tail) if tail else head
print(sum1([1,2,3,4,]))

print(1 if 3 > 2 else 3)# 如果为真就执行前面的表达式，否则将else的值赋值给前面的表达式

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

# 1+2+3+4+......+100
sum2 = 0
for x in range(101):
  sum2 += x
print(sum2)
# 用递归实现1+2+3+4+......+100
def my_sum(n):
  # 1.找临界值（在临界值的位置让函数结束）
  if n == 1:
      return 1
  #找关系
  """
  my_sum(n):1+2+3+...+n
  my_sum(n-1):1+2+3+4+...n
  my_sum(n) = mys_sum(n-1)+ n
  """
  # 3. 使用f(n-1)实现f(n)的效果
  return my_sum(n-1)+n

print(my_sum(100))

# 练习： 使用递归计算斐波拉数列1,1,2,3,5,8,13,21,...第n个数

def num(n):
  # 1.找临界值
  if n == 1 or n == 2:
      return 1

  # 2. 找关系
  """
  num(n) = num(n-1) + num(n-1)
  """
  return num(n-1) + num(n-2)
print(num(5))


#使用递归完成下面效果

def Pdd (n) :
  if n == 1:
      print('*')
      return

  print('*'*n)
  Pdd(n-1)
Pdd(5)

封装：

函数：对实现某一特定功能的代码段的封装

模块：对变量，函数，类进行封装
模块：一个py文件就是一个模块

怎么去使用其它模块中的内容？
a. import 模块
通过模块.内容（能够使用的是全局变量，函数，类）
b.form 模块 import 模块中的内容
直接使用模块的内容
c.from 模块 import * ---->将模块中的所有内容都导入

#导入系统模块
import cmath
print(cmath.pi)

# #导入自定义模块
# import my_list
# print(my_list.empty)
# number = my_list.count([1,2,3,4,5,61,1,1,1,1],1)
# print(number)
import my_list
from my_list import count
number = count([1,2,3,4,5,61,1,1,1,1],1)
print(number)

print(cmath)

重命名
import 模块 as 新名字（对模块重命名）
from 模块 import 内容 as 新名字（对模块中的内容重命名）
每个模块都有一个name属性，这个属性的值默认是当前模块的文件名
当前模块正在被执行时（直接执行这个模块本身）的时候，name属性的值是'main'
建议：函数的声明，类的声明一般写在if的外面，其他的写在if里面,(想要被外部使用的全局变量也可以在写在外面)

#直接输入 main 就会弹出 if __name__ == '__main__':
#将不希望别人导入（执行的）的代码放在这个if语句中
if __name__ == '__main__':
  print('ddddd')
print(my_list.__name__)#导入模块的名字