Python - 变量&变量作用域

变量命名规则

• 变量名必须以字母或下划线字符开头
• 变量名称不能以数字开头
• 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
• 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）

创建变量

Python 的=符号用于赋值，首次为变量赋值时变量就会被创建，可以创建任意类型的变量

# 创建一个整数变量
var_1 = 6

# 创建一个字符串变量
var_2 = "lechang"

# 同时创建多个变量
var_a, var_b, var_c = "张三", "李四", "王五"

# 多个变量分配相同的值
var_x = var_y = var_z = "赵六"

修改变量

重新为变量赋值即可修改变量，可修改为任意类型的变量

# 创建一个整数变量
var_1 = 6

# 修改变量为字符串类型
var_1 = "张三"

输出变量

Python 的print语句用于输出变量

# 创建变量
myname = "彦祖"

# 输出变量到控制台
print(myname)

# 结合文本和变量
print("你的年龄为：" + myname)
print("你的年龄为：", myname)
print("吴%s是你的名字"%myname)
print("你是叫{name}吗？".format(name=myname))

# 控制台输出
>>> 彦祖
>>> 你的年龄为：彦祖
>>> 你的年龄为： 彦祖
>>> 吴彦祖是你的名字
>>> 你是叫彦祖吗？

变量作用域

LEGB原则的含义：

• L - Local：局部作用域
• E - Enclosed： 嵌套作用域
• G - Global： 全局作用域
• B - Built-in： 内置作用域

变量的查找顺序依次就是 L → E → G → B → 报错 。

局部作用域(Local)

在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。

#局部作用域
def fun():
    var_a = "666"
    print("var_a在fun内为：" + var_a)

fun()

# var_a是属于fun()方法里面的变量，在fun()方法外面找不到则会报错
print("var_a在fun外为：" + var_a)

# 控制台输出
>>> var_a在fun内为：666
>>> Traceback (most recent call last):
>>>   File "/Users/lechang/Desktop/PythonCode/变量.py", line 5, in <module>
>>>     print("var_a在fun外为：" + var_a)
>>> NameError: name 'var_a' is not defined

在函数中嵌套函数时，嵌套在里面的函数创建的作用域内一般也是不允许改变外层函数变量的值的，除非是nonlocal关键字声明。如下：

def fun1():
    a = "hello"
    print(a)

    def fun2():
        # a += " python" 	# 直接修改会报错

        nonlocal a  		# 先使用nonlocal声明
        a += " python"  	# 修改成功
        print(a)

    return fun2

temp = fun1()	#调用fun1
temp()			#调用fun2

# 控制台输出：
>>> hello
>>> hello python

嵌套作用域(Enclosed)

嵌套一般是指一个函数嵌套另一个函数的情况，外层函数包含变量的作用范围称为嵌套作用域。

#Enclosed(嵌套)作用域
def fun1():
    b = 2
    print("fun1.a = ", b)

    def fun2():
        print("fun2.b = ", b)

    return fun2

temp = fun1()
temp()

# 控制台输出
>>> fun1.b =  2
>>> fun2.b =  2

全局作用域(Global)

全局作用域范围指的是在一个py文件内部，在模块顶部声明的即成为全局作用域。全局作用域中的变量在函数中一般是不可更改的，例如整数，字符等，但对于列表和字典来说可以更改。如想引用并改变全局变量，可使用global关键字。

"""
1、全局作用域中的 数字、字符、布尔、空值 类型的变量在函数中不可更改
"""
a = 2
b = 1

def func():
    # 调用全局变量 a
    print("在fun()方法中访问全局变量 a = ", a)

    # 修改全局变量 b + 5 会报错，全局变量在函数中不可更改只能访问
    b += 5

print("调用fun()前，函数体外访问全局变量 b = ",b)
func()
print("调用fun()后，函数体外访问全局变量 b = ",b)  # b += 5 报错后这里不再执行

# 控制台输出：
>>> 调用fun()前，函数体外访问全局变量 b =  1
>>> 在fun()方法中访问全局变量 a =  2
>>> Traceback (most recent call last):
>>>   File "/Users/lechang/Desktop/PythonCode/变量.py", line 12, in <module>
>>>     func()
>>>   File "/Users/lechang/Desktop/PythonCode/变量.py", line 9, in func
>>>     b = b - 1
>>> UnboundLocalError: local variable 'b' referenced before assignment

""""
2、全局作用域中的列表和字典可以更改
""""

a = [1, 2, 3, 4]
b = {'name': "lechang", "age": 18}


def func():
    a.append(5)
    b.update({"sex": "男"})
    print("func函数中修改后 a = ", a)
    print("func函数中修改后 b = ", b)

print("调用fun()前，函数外 a = ", a)
print("调用fun()前，函数外 b = ", b)
func()
print("调用fun()后，函数外 a = ", a)
print("调用fun()后，函数外 b = ", b)

# 控制台输出：
>>> 调用fun()前，函数外 a =  [1, 2, 3, 4]
>>> 调用fun()前，函数外 b =  {'name': 'lechang', 'age': 18}
>>> func函数中修改后 a =  [1, 2, 3, 4, 5]
>>> func函数中修改后 b =  {'name': 'lechang', 'age': 18, 'sex': '男'}
>>> 调用fun()后，函数外 a =  [1, 2, 3, 4, 5]
>>> 调用fun()后，函数外 b =  {'name': 'lechang', 'age': 18, 'sex': '男'}

"""
3、利用global关键字 引用全局变量
"""
a = 1

def func():
    global a  # 在使用a之前用global
    a += 1
    print("fun函数中修改后的 a = ", a)


print("fun函数外调用fun前全局变量 a = ", a)
func()
print("fun函数外调用fun后全局变量 a = ", a)

# 控制台输出：
>>> fun函数外调用fun前全局变量 a =  1
>>> fun函数中修改后的 a =  2
>>> fun函数外调用fun后全局变量 a =  2

内置作用域(Built-in)

内置作用域是python事先定义的内置变量，程序启动之后由python虚拟机自动加载，在程序的任何地方都可以使用，例如 int、str 等，随着解释器存在或消亡。

print(int)

def func():
    print(int)

func()

# 控制台输出：
>>> <class 'int'>
>>> <class 'int'>

获取指定作用域范围中的变量

1、globals()函数

通过调用globals() 函数，可以得到一个包含全局范围内所有变量的字典，该字典中的每个键值对，键为变量名，值为该变量的值。通过该字典，可以访问指定变量和修改变量的值。

#全局变量
pyname = "Python"
def func():
    #局部变量
    myname = "lechang"

# 全局变量pyname
print("访问全局变量 pyname = ", pyname)
    
# 输出包含所有全局变量的字典
print("包含所有全局变量的字典 = ", globals())

# 输出变量名为pyname的值
print("通过globals()函数访问变量 pyname = ", globals()['pyname'])

# 修改变量名为pyname的值
globals()['pyname'] = "Python变量"

# 全局变量pyname
print("访问通过通过globals()修改后的全局变量 pyname = ", pyname)

# 控制台输出：
>>> 访问全局变量 pyname = Python
>>> 包含所有全局变量的字典 = {...,'pyname': 'Python',...}
>>> 通过globals()函数访问变量 pyname =  Python
>>> 访问通过通过globals()修改后的全局变量 pyname = Python变量

2、locals()函数

通过调用locals() 函数，可以得到一个包含当前作用域内所有变量的字典。这里所谓的“当前作用域”指的是，在函数内部调用 locals() 函数，会获得包含所有局部变量的字典；而在全局范文内调用 locals() 函数，其功能则和 globals() 函数相同。
当使用 locals() 函数获得所有局部变量组成的字典时，可以向 globals() 函数那样，通过指定键访问对应的变量值，但无法对变量值做修改。

# 全局变量
pyname = "Python"
def func():
    #局部变量
    myname = "lechang"
    print("在函数内部使用locals()：")
    print(locals())
    print("局部变量 myname = ", myname)
    print("通过locals()访问 myname = ", locals()['myname'])
    locals()['myname'] = "laomao"  # 修改不会生效
    print("通过locals()修改后的 myname =", myname) # 输出的还是lechang

func()

print("在函数外部使用locals()：")
print(locals())

# 控制台输出：
>>> 在func()函数内部使用locals()：
>>> {'myname': 'lechang'}
>>> 局部变量 myname =  lechang
>>> 通过locals()访问 myname =  lechang
>>> 通过locals()修改后的 myname = lechang
>>> 在func()函数外部使用locals()：
>>> {...,'pyname': 'Python',...}

3、vars(object) 函数

vars() 函数也是 Python 内置函数，其功能是返回一个指定 object 对象范围内所有变量组成的字典。如果不传入object 参数，vars() 和 locals() 的作用完全相同。

pyname = "Python"

class func:
    myname = "lechang"

print("传object = ", vars(func))
print("不传object = ", vars())


# 控制台输出：
>>> 传object =  {...,'myname': 'lechang',...}
不传object =  {...,'pyname': 'Python',...}