Python 变量

在 Python 中，变量是用于在程序中引用值的标识符。变量包含对象的内存地址。它们允许 Python 程序访问其他对象，调用它们的函数或执行其他操作。

Python中定义变量的规则

定义Python变量有一些规则。

• Python 变量名可以包含小写字母 (az)、大写字母 (AZ)、数字 (0-9) 和下划线 (_)。
• 变量名不能以数字开头。
• 我们不能使用保留关键字作为变量名。
• Python变量不能只包含数字。
• Python变量名可以以下划线或字母开头。
• 变量名区分大小写。
• 变量名的长度没有限制。

有效的 Python 变量示例

• abc 是的，我们可以将变量名设为下划线。
• __：是的，多个下划线也是有效的变量名。
• x_yAB
• _abc

无效的 Python 变量示例

• 9abc：变量名不能以数字开头。
• 123：变量名不能只包含数字。
• x-y：变量名中唯一允许的特殊字符是下划线。
• def：变量名无效，因为它是保留关键字。

如何在Python中声明变量？

Python 是一种动态类型语言。声明变量时，我们不需要指定变量的类型。变量用等号定义。等号左侧是变量名，右侧是变量值。

让我们来看一些在 Python 中声明变量的例子。

x = 1  # number
s = "Hello"  # string
t = (1, 2)  # tuple
l = [1, 2, 3]  # list
d = {"1": "A", "2": "B"}  # dictionary

变量的多重赋值

Python 也支持多重赋值。我们可以使用多重赋值一次定义多个变量。

a = b = c = 100
print(a, b, c)  # 100 100 100

我们还可以将一个序列分配给一个变量列表。在这种情况下，序列中的元素个数必须等于变量的个数。

a, b, c = 1, 2, "Hello"
print(a, b, c)  # 1 2 Hello
 
a, b, c = (1, 2, 3)
print(a, b, c)  # 1 2 3
 
a, b, c = [1, 2, 3]
print(a, b, c)  # 1 2 3
 
a, b, c = "098"
print(a, b, c)  # 0 9 8

让我们看看当变量的数量和序列中的元素数量不相等时会发生什么。

>>> a,b = (1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)
>>> 
>>> a,b,c,d = (1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)
>>>

如何在Python中打印变量值？

我们可以使用Python 的 print() 函数来打印变量值。让我们来看一些在 Python 中打印变量值的例子。

x = 1  # number
print(x)
s = "Hello"  # string
print("s value is", s)
t = (1, 2)  # tuple
print("tuple value is", t)
l = [1, 2, 3]  # list
print(l)
d = {"1": "A", "2": "B"}  # dictionary
print("dict value is", d)

Python 程序是按顺序执行的。因此，如果您尝试在变量定义之前访问它，将会得到错误NameError。

print(count)  # NameError: name 'count' is not defined
 
count = 100
 
print(count)  # 100

Python变量命名规范的最佳实践

如果你看一下上面的代码片段，你会发现变量名是随意取的，它们并不能体现变量的含义。在Python中给变量命名时，有一些最佳实践需要遵循。

1. 变量名只能使用小写字母、数字和下划线。
2. 如果变量名包含多个单词，可以用下划线分隔它们。
3. 如果变量作用域是私有的，那么你可以在变量名前加上下划线。
4. 你应该避免使用以下划线开头和结尾的变量名。这是 Python 内置程序的惯例做法。
5. 变量名一定要有意义。它应该能够传达数据类型和变量的预期用途。
6. 变量名长度没有限制。但是，最好使用简短且有意义的名称。
7. 根据以上最佳实践，我们可以修改上面的代码片段，使其具有合适的变量名。

count = 1
str_message = "Hello"
tuple_ints = (1, 2)
list_of_numbers = [1, 2, 3]
numbers_letters_dict = {"1": "A", "2": "B"}

如何打印变量类型？

在Python程序中，我们不需要直接指定变量的类型。我们可以使用type()函数来确定变量的类型。让我们来看一些打印变量类型的例子。

count = 1  # number
print(type(count))
str_message = "Hello"  # string
print("str_message type is", type(str_message))
tuple_ints = (1, 2)  # tuple
print("tuple_ints type is", type(tuple_ints))
list_of_numbers = [1, 2, 3]  # list
print(type(list_of_numbers))
numbers_letters_dict = {"1": "A", "2": "B"}  # dictionary
print("numbers_letters_dict type is", type(numbers_letters_dict))

输出

<class 'int'>
str_message type is <class 'str'>
tuple_ints type is <class 'tuple'>
<class 'list'>
numbers_letters_dict type is <class 'dict'>

Python中变量有哪些不同类型的？

变量的类型就是它所代表的数据类型。Python 是一种面向对象的编程语言。在 Python 中，一切皆对象。因此，Python 变量始终是某个类的实例。

• x = 1：这里变量'x'的类型是'int'。它指的是int类的一个实例。
• message = “Hello” : message 变量的类型为 'str'。

Python中的变量作用域

变量作用域定义了变量在程序中的可访问范围。Python 变量有两种作用域。

1. 局部范围
2. 全局范围

Python中的局部变量

当变量定义在函数或类内部时，它只能在该函数或类内部访问。这类变量被称为局部变量，其作用域仅限于该函数或类的边界。

如果我们尝试访问作用域之外的局部变量，我们会发现NameError该变量未定义。

让我们通过一些例子来理解Python局部变量的概念。

def foo():
    foo_var = 1
    print(foo_var)
 
foo()
print(foo_var)

• print()函数内部可以foo()访问该变量，foo_var因为它位于该函数的作用域内。
• print()函数外部无法foo()访问该变量，foo_var因为它超出了该变量的作用域。

我们来看另一个在类内部定义的局部变量的例子。在这个例子中，变量的作用域就是这个类。

class Foo:
    class_foo_var = 1
 
print(class_foo_var)

输出：NameError: name 'class_foo_var' is not defined

Python 全局变量

当变量不在函数或类内部时，它可以从程序的任何位置访问。这些变量称为全局变量。让我们来看一些 Python 全局变量的例子。

lobal_msg = "Hello"
 
def foo():
    print(global_msg)  # 在函数内部使用全局变量
 
class Foo:
    print(global_msg)  # 在类内部使用全局变量
 
if 5 < 10:
    print(global_msg)  # 在代码块中使用全局变量

在诸如 if-else、for 循环、while 循环、try-except 等代码块中定义的变量，如果声明该变量的代码已被执行，则会被添加到全局作用域中。让我们通过一个简单的例子来理解这一点。

>>> if True:
...     var_if = "if"
... else:
...     var_else = "else"
... 
>>> 
>>> print(var_if)
if
>>> print(var_else)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'var_else' is not defined
>>>

var_else 未定义，因为 else 代码块内的代码没有执行。

让我们来看另一个带有try-except 块的例子。

>>> try:
...     var_try = "try"
...     raise TypeError('explicitly throwing')
... except:
...     var_except = "except"
... 
>>> print(var_try)
try
>>> print(var_except)
except
>>>

我们可以访问在 try-except 代码块中定义的变量，因为它们都已被执行。

如何在 Python 中删除变量

我们可以使用语句删除变量del。让我们来看一个简单的例子来删除一个 Python 变量。

>>> count = 100
>>> print(count)
100
>>> del count
>>> 
>>> print(count)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'count' is not defined
>>>

Python静态变量

类中定义的变量可以通过类名访问。它们也称为静态变量，因为它们属于该类。

class Data:
    id = 0
 
print(Data.id)  # static access

这些变量也可以从类对象中访问。但是，建议使用类的静态方法来访问它们。

d1 = Data()
print(d1.id)  # class variable accessed from object

Python 私有变量

Python 编程中没有私有变量的概念。因此，如果您希望将一个变量视为私有变量，通常的做法是在变量名前加上一个下划线。这会提示其他开发者该变量暂时不会被使用，并且其行为将来可能会发生变化。

关于 globals() 和 locals() 函数的简要说明

• globals() 函数返回当前作用域全局变量的字典。
• Python 的 locals() 函数返回当前作用域局部变量的字典。

我们可以在任何代码位置使用这些函数来检查变量在该位置是否可以访问。它们是 Python 的内置函数。

让我们来看一些这些函数的简单示例。

global_var = "global"
 
def foo():
    local_var = "local"
    print('global variables inside foo(): ', globals())
    print('local variables inside foo(): ', locals())
 
print('global variables: ', globals())
print('local variables: ', locals())
foo()

输出：

global variables:  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
local variables:  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
global variables inside foo():  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1006305f8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/hello_world.py', '__cached__': None, 'global_var': 'global', 'foo': <function foo at 0x1006817b8>}
local variables inside foo():  {'local_var': 'local'}

Python 全局关键字

我们可以在函数内部访问全局变量，但不能直接修改它。global要改变函数内部全局变量的值，必须使用关键字。让我们通过一个简单的例子来理解这种行为。

name = "Python"
 
def foo():
    print(name)
 
foo()
print(name)
 
# Output
# Python
# Python

让我们看看尝试在函数内部修改全局变量的值会发生什么。

>>> name = "Python"
>>> def foo():
...     print(name)
...     name = "Java"
... 
>>> 
>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in foo
UnboundLocalError: local variable 'name' referenced before assignment
>>> 
>>> print(name)
Python
>>>

原因很简单。当我们使用赋值运算符改变“name”的值时，它就被视为局部变量。因此，在print()函数内部访问它会抛出错误，因为此时它尚未定义。

让我们使用 global 关键字来修改全局变量的值。

>>> name = "Python"
>>> 
>>> def foo():
...     global name
...     print(name)
...     name = "Java"
... 
>>> print(name)
Python
>>> foo()
Python
>>> print(name)
Java
>>>

Python 非局部关键字

nonlocal 关键字用于访问在代码块作用域之外定义的变量。在嵌套函数中，总是使用 nonlocal 来访问外部定义的变量。变量的查找范围始终在最近的封闭作用域内，但不包括全局变量。

def outer_function():
    scope = "local"
 
    def inner_function():
        nonlocal scope
        scope = "nonlocal"
        print(scope)
 
    inner_function()
    print(scope)

总结

变量在每个程序中都会用到。它们是一种标识符。我们学习了如何定义变量、变量的相关规则，以及如何访问和删除变量。我们还学习了变量的作用域——全局作用域和局部作用域。

下一步是什么

• Python 函数
• Python 数据类型
• Python 列表
• Python 环境变量
• Python 面向对象编程