"""
一、名称空间
名称空间既存放名字与对象映射/绑定关系的地方。对于x=3，Python会申请内存空间
存放对象3，然后将名字x与3的绑定关系存放于名称空间中，del x表示清除该绑定关系
"""
# 在程序执行期间最多会存在三种名称空间
"""
1.1内建名称空间
伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些
内置的名字，比如内建函数名
"""
"""
max
<built-in function max> # built-in内建
"""
"""
1.2全局名称空间
伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件
执行过程中产生的名字都会存放于该名称中，如下名字
"""
# import sys #模块名sys
#
# x=1 #变量名x
#
# if x == 1:
#     y=2 #变量名y
#
# def foo(x): #函数名foo
#     y=1
#     def bar():
#         pass
#
# Class Bar: #类名Bar
#     pass

"""
1.3局部名称空间
伴随函数的调用/结束而临时产生/回收、函数的形参、函数内定义的名字都会被存放
于该名称空间中
"""

# def foo(x):
#     y = 3  # 调用函数时，才会执行函数代码，名字x和y都存放于该函数的局部空间中
"""
名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间、
而查找一个名字，必须从三个名称空间之一找到，
查找顺序为：局部名称空间->全局名称空间->内置名称空间。
"""
"""
二、作用域

2.1 全局作用域和局部作用域
按照名字作用范围的不同可以将三个名称空间划分为两个区域：

1.全局作用域：位于全局名称空间，内建名称空间中的名字属于全局范围，该范围内的名字全局存
活（除非被删除，否则在整个文件执行过程中存活）、全局有效（在任意位置都可以使用）；

2.局部作用域：位于局部名称空间中的名字属于局部范围。该范围内的名字临时存活（既在函数调用
时临时生成，函数调用结束后就释放）、局部有效（只能在函数内使用）

2.2 作用域与名字查找的优先级
在局部作用域查找名字是，起始位置是局部作用域，所以先查找局部名称空间，没有找到，再去
全局作用域查找：先查找全局名称空间，没有找到，在查找内置名称空间，最后都没有找到就会
抛出异常
"""
# x = 100  # 全局作用域的名字x
#
#
# def foo():
#     x = 300  # 局部作用域的名字x
#     print(x)  # 在局部找x
#
#
# foo()  # 结果为300
"""
在全局作用域查找名字是，起始位置是全局作用域，所以先查找全局名称空间，如果没有找到，再查
找内置名称空间，最后都没有找到就会抛出异常（局部作用域只在函数调用时才产生）
"""
# x = 100
#
#
# def foo():
#     x = 300 # 在函数调用时产生局部作用域的名字x
#
#
# foo()
# print(x) # 在全局找x，结果为100
"""
2.2作用域与名字查找的优先级
在局部作用域查找名字时，起始位置是局部作用域，所以查找局部名称空间，没有找到，再去
全局作用域查找：先查找全局作用域，没有找到，在查找内置名称空间，最后都没有找到就会
抛出异常
"""
"""
提示：可以调用内建函数locals()和globals()来分别查看局部作用域和全局作用域的名字，
查看的结果都是以字典格式。在全局作用域查看到的locals()的结果等于globals()
"""
# 函数嵌套
# x = 1
# def outer():
#     x = 2
#     def inner():
#         x = 3
#         print('inner x is :%s' %x)
#     inner()
#     print('outer x is :%s' %x)
# outer()
"""
在函数内，无论嵌套多少层，都可以查看到全局作用域的名字，若要在函数内修改全局名称空间
中的名字的值，当值为不可变类型时，则需要用到global关键字
"""
# x = 1
# def foo():
#     global x # 声明x为全局名称空间的名字
#     x = 2
# foo()
# print(x) # 结果为2

# x = 3
# def foo(i):
#     global x
#     x = i
#     print(x)
# foo(9999)
"""
当实参为可变类型时，函数体内对该值的修改将直接反应到原值
"""
# l = [1,2,3]
# def func(nums):
#     nums.append(5)
# func(l)
# print(l)
#
# l = [1,2,3]
# def foo(nums):
#     nums.append(4)
#     print(l)

# 循环接受非 关键字值
# def func(*args,l=None):
#     if l == None:
#         l = []
#     for line in args:
#         l.append(line)
#     return l
# l = func(1,2,3,4,5)
# print(l)
"""
对于嵌套多层的函数，使用nonlocal关键字可以将名字声明为来自外部嵌套函数定义的作用域
（非全局）
"""
# def f1():
#     x = 2
#     name_f1 = locals()
#     def f2():
#         nonlocal x
#         x = 3
#         name_f2 = locals()
#         print(name_f2)
#     f2() # 调用f2()，修改作用域f1 中 x 的值
#     print(name_f1)
#     print(x)
# f1()
"""
nonlocal x 会从当前函数的外层函数开始一层一层去查找名字x，若是一直到最外层都找不到，
则会抛出异常
"""
"""
====================================================================================================
"""
# 一、名称空间namespace：存放名字的地方，是对栈区的划分
# 有了名称空间之后，就可以在栈区中存放相同的名字，详细的，名称空间
# 分三种


# 1.2 全局名称空间’
# 存放的名字：只要不是函数内定义、也不是内置的都是全局名称空间
# 顶级代码：没有缩进的代码
# 存活周期：python文件执行则产生，python文件运行完毕后销毁
# def func(): # 全局名称空间
#     a = 111 # 局部名称空间
#     b = 222
# 道可道，非常道，名可名，非常名

# 1.3局部名称空间
# 存放的名字：在 调用函数时，运行函数体代码过程中产生的函数内的名字
# 存活周期： 在函数调用时产生，函数调用结束而销毁
# 同一个函数，调用一次产生一个名称空间，局部名称空间有多个，全局，内建名称空间只有一个

# 1.4 名称空间加载的顺序
# 内置名称空间>全局名称空间>局部名称空间
# 1.5 销毁顺序
# 局部名称空间>全局名称空间>内置名称空间

# 名称空间是虚拟的东西，真实存放名字的空间是栈区，名称空间只是把栈区
# 分成了三个
#
# 1.6名字的查找优先级：当前所在的位置，向上查找
# 内置名称空间
# 全局名称空间
# 局部名称空间
# 如果当前在局部名称空间
# 局部>全局>内置

# 如果当前在全局名称空间
# 全局名称空间>内置名称空间>局部名称空间
# print(input)

# 示范2：名称空间的"嵌套"关系是以函数定义阶段为准，与调用位置无关
# x = 1
# def func():
#     print(x)
# def foo():
#     x = 3
#     func()
# foo()
# 示范3 ：函数的嵌套定义
# input = 111
# def f1():
#     def f2():
#         # input = 333
#         print(input)
#     input = 222
#     f2()
# f1()
# 牢牢的记住：名称空间的嵌套关系一定是以定义阶段为基准
# 示范4：
# x = 111
# def func():
#     print(x) # 名称空间的嵌套以定义阶段为基准，x会在局部去找，但是调用时发现
#              # x还没有被创建，所以会直接报错
#     x = 222
# func()

# 二、作用域 -->作用范围
# 全局作用域：内置名称空间、全局名称空间
# 1、全局存活
# 2、全局有效：被所以函数共享


# def foo():
#     func()
#
# def func():
#     print(x)
#
# x = 111

# 局部作用域
# 1、临时存活
# 2、局部有效