第一部分 命名空间
命名空间：保存名字的容器
名字：定义函数名字、变量名字、类名字、模块、包...
容器：list,tuple,set
形式：键（名字） 值（内存对象） 对
每个函数、变量都有自己的命名空间
在哪定义？什么时候定义？
函数：第一次def 定义了命名，也会确定了你的命名空间
变量：第一次赋值 定义了命名，确定命名空间
命名空间的位置：python已经针对不同的命名空间划分好了区域
1.命名空间的分类： 内建命名空间、全局命名空间、局部命名空间
# 内建命名空间：在python解释器启动的时候自动创建，exit()之后，就会销毁
# 全局命名空间：在读取模块（一个py文件）定义的时候创建，当程序结束的时候销毁
# 局部命名空间：在函数执行的时候创建，当函数执行结束的时候销毁
# 重要注意：他们之间不是包含关系，区别只在于作用域不同
2. 作用域
# 只要在命名空间的作用域内，都能访问到命名空间内名字
# 内建命名空间：最大，所有的模块都能访问到内建命名空间的名字
# 全局命名空间：在整个py文件内有效
# 局部命名空间：最小，只在当前函数内部有效。出了函数，访问不到定义在局部命名空间下的名字
# 作用域一定注意，不是包含关系，只是大小的问题。
# x是定义在全局命名空间下的变量，存的是变量名
x=1
# fun定义在全局命名空间下的函数，存的是函数名
def f(a):
pass
# a是在局部命名空间下的变量
# p定义在局部命名空间下的变量
p=2
# 定义在局部命名空间下的函数
def inner():
z=2
pass
# 在函数内部（局部命名空间的作用域下访问p）
print(p)
# 在局部命名空间作用域下能不能访问到x？
print("x=",x)
# x=x+1
# 访问
# 在整个py文件中都能访问到全局变量
print(x)
f(1)
# 在整个py文件下访问局部量
# print(p)
3.访问的顺序原则
1. 定义一个全局变量，在函数中修改这个全局变量
y=1
def func():
y=2
print(y)
func()
print(y)
# 问题，定义了一个全局变量之后，在局部函数中暂时不能修改全局变量
# 原因，在局部函数中遇到名字，当做修改（赋值）时候，如果没有声明nonlocal或者global，不会到其他的命名空间查找，只会自己新建
2. 在函数里面，先输出全局变量，然后再修改,编译报错
# python解释器在编译的时候，就已经编译变量，
# 因为下面有y=2，所有认为print中的y是下面y=2的y
# y=1
# def func():
# global #如果想修改
# print(y)
# y=2
# func()
# print(y)
3. 函数内部，对全局变量+1，编译错误(原因跟上面一样）
# y=1
# def func():
# y+=1
# global y 如果想修改
# y=y+1
# func()
# print(y)
4. 当把id函数先赋值成2，发现id函数用不了
y=1
# id=2
print(id(y)) # 会在全局中先找，找到，认为id=2的那个id
# print(ids(y)) # 在全局中先找，再到内建中找，都找不到
# 给函数或者文件起名字，要注意，不要用内建函数中的名字，否根本不会找到内建命名空间中的名字
import random
print(random.random())
4. LEGB原则， 命名空间，作用域
# 查找顺序
# 原则
"""
当遇到一个名字:
1. L: Local : 先到局部命名空间找，如果找到了，会停止搜索，如果没找到
2. E: Encoding: 到外围命名空间找，如果找到了，停止搜索，如果没找到
3. G: Global: 到全局命名空间找，如果找到了，停止搜索，如果没找到
4. B: buildin: 到内建命名空间找，如果找到了，停止搜索，如果没找到，报错
"""
"""
对名称的访问：
1. 读取，按照LEGB原则搜索，都找不到，nameError错误
2. 修改和删除，只会从当前最小的作用域开始找，如果找到则修改，如果找不到，则不会再继续往上找（需要用其他方法）
对于删除来说：只能在当前最小作用域删除，其他任何地方都不能删除命名
"""
# 上面提到的，修改变量，如果在局部命名空间下找不到，
# 会使用下面的关键字，到全局命名或者外围命名空间下寻找
# global
# nonlocal
global： 用来声明外围变量
def globalfunc():
t=1111
def f():
global t
t=2 # 如果不用global t会在当前的局部变量下再创建一个新的
f()
print(t)
nonlocal：用来声明外围变量
def f():
k=1
def inner():
nonlocal k
k=2
inner()
print(k)
f()
# 关于全局命名空间和局部命名空间的函数
# locals函数返回当前命名空间下的所有名字
# globals（）返回全局命名空间下上午所有名字
# 学习的时候会用到
print(locals())
print(globals())
# 练习
info="地址："
def fun1(country):
def fun2(area):
city="上海"
print(info+country+city+area)
city="北京"
fun2("海淀")
fun1("中国")
# 地址：中国 上海 海淀
第二部分 lambda表达式
"""
lambda表达式(λ)
python里面的函数时头等函数。
头等函数？变量和函数类似，函数的名字也可以像变量一样操作，可以被赋值，可以被传递，可以当做返回值
"""
1. 函数名被赋值
def x():
print("hello world")
# x()
y=x
y()
2. 函数名传递，在sort(key=函数名)：相当于把函数名传递到sort函数中，通过key参数
def s(k):
return abs(k)
li=[1,-2,-6,3,4]
li.sort(key=s)
li.sort(key=abs)
print(li)
3. 函数名还可以作为另外一个函数的返回值（闭包）
def outer():
# 外围命名空间
def inner():
print("inner函数内部执行")
# 函数嵌套
# return inner()
# 闭包
return inner
# 函数嵌套的是inner（）在outer中就已经执行
i=outer()
print(i)
# 闭包的时候，只有在outer执行之后，被赋予i，在调用i()，才真正执行inner
# i=outer()
# i()----inner()
对于函数只使用一次，函数体比较简单，使用lambda函数
格式：lambda【传入的参数】：返回值表达式
应用：函数体简单
def s(k):
return k+1
print(s(-20))
f=lambda k:k+1
print(f(-20))
li[1,3,4,6,5]
li.sort(key=f)
li.sort(key=lambda k:k+1)
print(li)
# 写一个lambda表达式：求绝对值的,abs
f=lambda x:abs(x)
第三部分 递归
"""
递归：一个函数调用自身的过程
1. 直接递归： A---A---A
2. 间接递归： A--B--A--B......
"""
# 无限的递归是没有意义的，我们要给递归一个条件，条件成立的时候，终止递归，再得到结果
# 递归：分为递推和回归
# 递推：解决问题，逐层的推理，得到递归的终点
# 回归：利用递推的结果得到终止的条件，一层层返回，最后得到答案
# 年龄
# 递推和循环，有相似度，递推更贴近人的思维，
# 浪费时间和空间
# 循环解决问题思维复杂，节省空间和时间
# 1+...+100
s=0
for i in range(1,101):
s+=i
print(s)
递归
# 1+2+3+...+99 100+A
# 1+2+3+...+98 99+B
# 1+2+3+...+97 98+C
# ...
# 2+1 2+1
# 分界点1 突破点 n=1 1
# n>1 n+(n-1个元素的和）
def r1(n):
if n==1:
return 1
else:
return n+r1(n-1)
print(r1(100))
n的阶乘
# n!=n*(n-1)(n-2)*...*2*1
# =n*(n-1)(n-2)!
def r2(n):
if n==1:
return 1
else:
return n*r2(n-1)
print(r2(10))
斐波那契数列（生兔子）
# 1 1 2 3 5 8 13......
"""
n==1 or n==2:1
f(n-1)+f(n-2)
"""
def f(n):
if n==1 or n==2:
return 1
else:
return f(n-1)+f(n-2)
print(f(20))
汉诺塔
# 参数的意义
# A 起始点
# B 中间借助点
# C 终止点
def hano(n,x,y,z):
if n==1:
print("{}--->{}".format(x,z))
else:
hano(n-1,x,z,y)
print("{}--->{}".format(x,z))
hano(n-1,y,x,z)
hano(3,"A","B","C")