第七天

Posted 2020-11-07 ztx695911088

第一部分 命名空间

 

命名空间：保存名字的容器
名字：定义函数名字、变量名字、类名字、模块、包...
容器：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")