python---函数作用域，,#变量作用域　　-变

python---函数作用域，,#变量作用域　　-变

#变量作用域

　　-变量有作用范围限制

　　-分类：按照作用域分类

　　　　-全局(global)：在函数外部定义

　　　　-局部(local)：在函数内部定义

　　-变量的作用范围：

　　　　-全局变量：在整个全局范围都有效

　　　　-全局变量在局部可以使用（即函数内部可以访问函数外部定义的变量）

　　　　-全局变量在局部范围可以使用

　　　　-局部变量在全局无法使用

　　-LEGB原则：　　　　-L(Local)：局部作用域

　　　　-E(Enclosing function locale)：外部嵌套函数作用域

　　　　-G(Global module)：函数定义所在模块作用于

　　　　-B(Buildin)：Python内置模块的作用于

#a1是全局的
a1 = 100
def fun():
    print(a1)
    print("I am fun")
    #a2的作用域范围是fun
    a2 = 99
    print(a2)

print(a1)
fun()
# print(a2)无法访问a2

提升局部变量为全局变量

#b1是全局的
b1 = 100
def fun():
    #提升b2为全局变量
    global b2
    print(b1)
    print("I am fun")
    b2 = 90
    print(b2)

print(b1)
fun()
print(b2)

运行结果：

100
100
I am fun
90
90

#globals, locals 函数

　　-可以通过globals和locals显示出局部变量和全局变量

　　-参看以下案例：

#globals 和llcals
a = 1
b = 2
def fun(c, d):
    e = 111
    print("Locals = {0}".format(locals()))
    print("Globals = {0}".format(globals()))

fun(100, 200)

Locals = {‘e‘: 111, ‘d‘: 200, ‘c‘: 100}
Globals = {‘__name__‘: ‘__main__‘, ‘__doc__‘...}


#eval()函数
　　-把一个字符串当成一个表达式来执行，返回表达式执行后的结果
语法：
　　eval(string_code, globals=None, locals=None)

#eval
x = 100
y = 200
z1 = x + y
z2 = eval("x+y")
print(type(z1))
print(z1)
print(type(z2))
print(z2)
运行结果：
　　<class ‘int‘>
　　300
　　<class ‘int‘>
　　300

#exec
　　-跟eval功能类似，但是，不返回结果
　　-语法：
　　　　exec(string_code, globals=None, locals=None)

#exec
x = 100
y = 200
z1 = x + y
z2 = exec("print(‘x+y:‘, x+y)")
z3 = exec("x+y")
print("z1", type(z1))
print("z1:", z1)
print("z2", type(z2))
print("z2", z2)
print("z3", type(z3))
print("z3", z3)

运行结果：
x+y: 300
z1 <class ‘int‘>
z1: 300
z2 <class ‘NoneType‘>
z2 None
z3 <class ‘NoneType‘>
z3 None


#递归函数
　　-函数直接或者间接调用自身
　　-优点：简洁， 理解容易
　　-缺点：对递归深度有限制，消耗资源
　　-python对递归深度有限制，超过限制报错
　　-再写递归程序的时候，一定注意结束条件

x = 0
def fun():
    global x
    x = x + 1
    print(x)
    #函数自己调用自己
    fun()

fun()
.
..
....
RecursionError: maximum recursion depth exceeded while calling a Python object

python---函数作用域