Python变量与常量

?第三章、变量与常量

一、标识符

1、定义

????????在 Python 中，标识符是用来标识变量、函数、类、模块或其他用户定义的对象的名称。标识符是程序员自定义的名称，用于在代码中标识不同的实体，使得代码可读性更强，更易于理解和维护。标识符需要遵循一些规则和约定。

2、规则

• 标识符只能包含字母（大小写都可以）、数字和下划线（_）。
• 标识符不能以数字开头，只能以字母或下划线开头。
• 严格区分大小写
• 标识符不能是 Python 中的关键字（保留字），如 if、for、while、def 等。
• 理论上无长度限制，最好不要太长

3、约定

• Python 代码中的标识符通常使用小写字母，用下划线分隔单词，如 my_variable。
• 类名的标识符通常使用驼峰命名法（Camel Case），即每个单词的首字母大写，如 MyClass。（大驼峰）
• Python 中的私有标识符（私有变量或方法）以一个下划线开头，如 _private_variable。
• 强烈建议遵循 Python 的命名约定，以提高代码的可读性和一致性。

以下是一些有效的 Python 标识符的示例

my_variable = 42
user_name = "John Doe"
total_count = 100
MyClass = MyClass()
_my_private_variable = "private"

????????请注意，虽然标识符是用来标识名称的，但标识符本身并没有任何含义，程序员需要根据具体情况赋予标识符有意义的名称，以便更好地理解代码的含义和逻辑。

二、关键字

????????在 Python 中，关键字（Keyword）是被编程语言保留并具有特定用途的标识符。这些关键字有固定的含义和功能，不能用作变量名、函数名或其他用户自定义标识符的名称。

????????关键字在 Python 解释器中具有特殊的意义，用于构建语法结构和实现核心功能。以下是 Python 的关键字列表：

False  await  else   import  pass
None   break  except in      raise
True   class  finally  is     return
and    continue   for   lambda  try
as     def  from  nonlocal while
assert del  global  not with
async  elif if or  yield

????????请注意，这里列出的关键字适用于 Python 3.x 版本。不同的 Python 版本可能会有不同的关键字集合，所以在不同的 Python 版本中应该注意关键字的差异。关键字不能用作变量名或其他标识符，例如以下的代码将导致语法错误：

for = 10  # 无效，"for" 是关键字，不能用作变量名
def = "hello"  # 无效，"def" 是关键字，不能用作变量名

????????使用合适的标识符和避免与关键字冲突，有助于编写更清晰、可读性更高的代码。如果您不确定某个标识符是否是关键字，您可以查看 Python 官方文档中的关键字列表，或在 Python 解释器中使用 help("keywords") 命令查看关键字列表。

1、help()函数

若是使用字符串作为参数传入help函数的话，help函数会自动提取字符串中的内容，获取对应的帮助信息，如果不传如字符串值的话，除了 __builtins__ 全局命名空间中的属性外，其他均需手动导入，否则不识别

推荐使用字符串往help函数中传值

????????在 Python 中，help() 是一个内置函数，用于获取对象的帮助信息和文档字符串（Docstring）。help() 函数提供了一个简单的交互式方式来查询 Python 对象（如模块、函数、类等）的用法和说明。

????????使用 help() 函数的方式非常简单，只需在交互式 Python 解释器或脚本中调用该函数并传入要查询的对象作为参数。例如：

# 查询内置函数的帮助信息
help(print)

# 查询模块的帮助信息
import math
help(math)

# 查询类的帮助信息
help(list)

# 查询函数的帮助信息
def my_function(x, y):
    """这是一个自定义函数的文档字符串。"""
    return x + y

help(my_function)

?? help() 函数会显示对象的说明、参数列表、返回值以及其他相关信息。对于内置函数、标准库模块以及自定义函数和类，编写良好的文档字符串是一个良好的实践，它有助于提高代码的可读性和维护性，并方便其他开发者了解和使用代码。

??????? 需要注意的是，并不是所有的 Python 对象都有文档字符串或帮助信息。有些对象可能没有相关的文档说明，此时 help() 函数将显示一个简单的默认帮助信息。在编写自己的函数和类时，建议添加清晰的文档字符串，以便其他人可以方便地使用 help() 函数查看相关信息。

三、字面值（常量，变量值）

????????在 Python 中，字面值（Literal）是指直接表示特定值的代码表达式。字面值是数据的固定值，它们是程序中的常量，不可更改。在编程中，您可以直接使用字面值来表示不同类型的数据。以下是 Python 中常见的字面值类型：

1、整数字面值（Integer literals）

表示整数值。例如：42, -10, 0.

2、浮点数字面值（Floating-point literals）

表示浮点数值，即带有小数点的数值。例如：3.14, -2.5, 0.0.

3、字符串字面值（String literals）

表示字符串值，用单引号或双引号括起来。例如：'Hello', "Python", '123'.

4、布尔字面值（Boolean literals）

表示布尔值，只有两个取值：True 和 False.

5、None 字面值

表示空值或空对象，用于表示变量没有被赋值。例如：None.

6、列表字面值（List literals）

表示列表，用方括号括起来，包含多个元素，元素之间用逗号分隔。例如：[1, 2, 3], ['a', 'b', 'c'].

7、元组字面值（Tuple literals）

表示元组，用圆括号括起来，包含多个元素，元素之间用逗号分隔。例如：(1, 2, 3), ('x', 'y', 'z').

8、字典字面值（Dictionary literals）

表示字典，用花括号括起来，包含多个键值对，每个键值对由键和值用冒号分隔。例如：{'name': 'John', 'age': 30}.

9、集合字面值（Set literals）

表示集合，用花括号括起来，包含多个元素，元素之间用逗号分隔。例如：{1, 2, 3}, {'apple', 'orange'}.

????????字面值是 Python 中的基础数据表示形式，它们在代码中直接表示了特定的数据值。在使用字面值时，注意符合正确的语法和数据类型，以便程序正确执行。

Python中不区分单引号和双引号，字符串型字面值和字符型字面值都可以使用单引号或双引号括起来

四、变量概述

不同的数据类型在内存开辟的空间是不一样的，数据类型的作用就是指导在内存中开辟多大的空间

1、定义

• 变量本质上说是内存中的一块空间，这块空间中包含数据类型，变量名，字面值，空间本身的内存地址
• 变量是内存中存储数据的最基本单元
• 变量就是在程序运行时，能存储计算结果或能标示值的抽象概念，简单的说，变量就像盒子，可以存放内容，在程序运行时，记录数据用的

2、变量的组成

• 变量值数据类型
• 变量名称
• 变量中保存的值
• 变量本身的内存地址信息

3、数据类型的作用

• 不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间
• 数据类型是指导程序在运行阶段应该分配多大的内存空间

五、声明变量

1、声明变量要求：无需显示声明类型，自动类型推断，声明变量和赋值必须同时

????????在 Python 中，声明变量是通过给变量名赋值来实现的。Python 是一种动态类型语言，因此在声明变量时无需显式指定变量的类型。变量的类型是根据赋值的数据类型自动确定的。

2、声明或定义变量的语法

变量名 = 值

变量名：符合语法规则的标识符（所有字母小写，多个单词间使用_分隔）

3、变量声明与赋值必须同时

变量名 = 字面值（值）

= 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量

注意：

• 声明变量并赋值时会开辟内存空间，但是变量修改值时不会，在原内存空间中进行修改
• 在同一个作用域中同一个变量名可以多次声明，并且后面的声明会覆盖前面的声明
• 在不同的作用域中，变量名可以相同

4、同一个作用域（例如函数内部或全局作用域）中可以多次声明同一个变量名，并且后面的声明会覆盖前面的声明

理解为：同一作用域下，变量声明一次，可以多次重新赋值，变量的值可变化

????????实际上，在 Python 中，同一个作用域（例如函数内部或全局作用域）中可以多次声明同一个变量名，并且后面的声明会覆盖前面的声明。

????????这意味着，如果在同一个作用域内多次声明同一个变量名，Python 将使用最后一次声明的值作为该变量的值。这与一些其他编程语言不同，例如C或Java，它们不允许在同一个作用域中重复声明同一个变量名。

????????需要注意的是，虽然在同一个作用域内可以多次声明同一个变量名，但这样做可能会使代码变得难以理解和维护，因此最好避免这种做法，尽量使用不同的变量名来表示不同的数据。?

有了变量的概念之后，内存空间得到了重复的使用?

5、变量在一行上可以声明多个

????????在 Python 中，可以使用逗号将多个变量在一行中进行声明和赋值。这被称为多个变量的同时赋值。在这种方式下，多个变量名用逗号分隔，对应的值也用逗号分隔，从左到右一一对应。

以下是一些示例：

# 一行中声明和赋值多个整数变量
x, y, z = 1, 2, 3

# 一行中声明和赋值多个字符串变量
name, city, country = "John", "New York", "USA"

# 一行中声明和赋值多个列表变量
numbers, fruits, colors = [1, 2, 3], ['apple', 'banana', 'orange'], ['red', 'green', 'blue']

# 一行中声明和赋值多个元组变量
point1, point2 = (10, 20), (30, 40)

# 一行中声明和赋值多个字典变量
person1, person2 = {"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}

????????在这些例子中，我们可以看到在一行中同时声明了多个变量，并且给它们赋予了对应的值。这使得代码更简洁、易读，并且方便同时初始化多个变量。需要注意的是，变量的数量和赋值的值的数量必须一致，否则会导致语法错误。

六、访问变量

1、get形式

第一种：读取变量中保存的具体数据? get

2、set形式

第二种：修改变量中保存的具体数据? set

七、变量的作用域

1、定义

????????变量的作用域其实就是描述变量的有效范围，在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了

2、作用域注意事项

• 在一个方法中声明并赋值了一个变量，在另一个方法中不能访问
• 在类体中声明并赋值一个变量，在所有方法中都可以访问
• 循环中的声明的变量作用域只在循环内，循环结束后，变量的内存就释放了，循环外不能访问；在循环外声明的变量，在循环外可以访问

3、变量的分类

????????在 Python 中，变量可以根据其作用域、生命周期和类型等特性进行分类。以下是 Python 中常见的变量分类：

1、嵌套作用域变量（Enclosing Scope Variables）：

• 嵌套作用域变量是在嵌套的函数中声明的变量。
• 它们可以在嵌套的函数中访问外部函数的变量。
• 这种情况下，变量的作用域嵌套在函数的嵌套层次中。

2、局部变量（Local Variables）：

• 局部变量是在函数内部声明的变量，在函数内部有效。
• 它们的作用域限定在声明它们的函数内部。
• 当函数执行完毕或退出时，局部变量的生命周期结束，它们将被销毁。

3、全局变量（Global Variables）：

• 全局变量是在全局范围内声明的变量，在整个程序中有效。
• 它们的作用域在整个程序中都可见，可以在函数内部和函数外部访问。
• 全局变量的生命周期从定义开始，直到程序结束或被显式删除。

4、作用域分类

????????在 Python 中，变量的作用域指的是变量在程序中可见和可访问的范围。Python 中的变量作用域主要分为四种：

1、嵌套作用域（Enclosing Scope）：

• 嵌套作用域是在包含函数内部的函数中声明的变量的作用域。
• 在一个函数内部定义的另一个函数，后者中的变量可以访问外层函数中的变量，但对于外层函数之外是不可见的。

2、局部作用域（Local Scope）：

• 局部作用域是在函数内部声明的变量的作用域。
• 在函数内部定义的变量只能在该函数内部访问，对于函数外部是不可见的。
• 当函数执行完毕后，局部变量的作用域也就结束了。

3、全局作用域（Global Scope）：

• 全局作用域是在模块（文件）级别声明的变量的作用域。
• 在模块中定义的变量可以在整个模块中访问，但对于模块外的代码是不可见的。

4、内置作用域（Built-in Scope）：

• 内置作用域是 Python 内置的命名空间，包含了 Python 内置的函数和对象。
• 内置作用域的变量可以在任何地方访问，无需导入任何模块。

在哪个作用域中声明的变量，则变量就在哪个作用域中。

同理，将函数也可以看做变量，也有这4个作用域

5、作用域链

当引用一个变量时，Python 解释器会按照以下顺序搜索变量的作用域：

• 首先，Python 会在函数的本地作用域内查找变量。如果找到了同名的局部变量，则使用该局部变量。
• 如果在函数的本地作用域内没有找到同名的局部变量，Python 将会继续在封闭函数（如果有嵌套函数）的作用域中查找变量。这个过程会继续递归，直到在某个封闭函数的作用域中找到同名的局部变量，或者达到全局作用域为止。
• 如果在任何封闭函数的作用域中都没有找到同名的局部变量，Python 将会在全局作用域中查找变量。如果在全局作用域中找到了同名的全局变量，则使用该全局变量。
• 如果在全局作用域中也没有找到同名的变量，Python 将会引发 NameError 错误，指示变量未定义。

1. 首先在当前函数的局部作用域中搜索。
2. 如果没有找到，则在包含当前函数的嵌套作用域中搜索。
3. 如果还没有找到，则在全局作用域中搜索。
4. 最后，如果还是没有找到，则在内置作用域中搜索。

????????如果在以上所有作用域中都找不到变量，将引发 NameError。为了避免出现变量作用域的问题，建议在程序中合理地使用不同作用域的变量，并避免不必要的变量命名冲突。

七、全局命名空间

????????在 Python 中，全局变量并不直接存储在栈内存中，而是存储在一个名为“全局命名空间”（Global Namespace）的字典中。这个字典用于存储全局作用域中定义的所有变量和函数名。

????????当我们在全局作用域中创建一个全局变量时，它会被添加到这个全局命名空间的字典中。这个字典的生命周期与程序的生命周期相同，即从程序启动到程序结束都存在。

????????当程序需要访问一个全局变量时，Python 会在全局命名空间中查找该变量的值。如果找到了对应的变量名，则使用该变量的值。如果没有找到对应的变量名，Python 会引发一个 NameError 错误。

????????需要注意的是，全局变量在整个程序中都可以访问，但如果在函数内部修改全局变量，必须使用 global 关键字声明该变量为全局变量，否则会创建一个新的局部变量，而不是修改全局变量。

以下是一个简单的例子来说明全局变量的工作原理：

# 作   者：JZQ
# 开发时间：2023/12/8 16:14
help("keywords")

# 全局变量在全局命名空间中
global_var = 10

def func():
    # 在函数内部访问全局变量
    print(global_var)

def modify_global_var():
    # 修改全局变量需要使用 global 关键字声明
    global global_var
    global_var = 20

func()  # 输出 10
modify_global_var()
print(global_var)  # 输出 20    不使用global  10
func() #输出20   不使用global  10

????????在这个例子中，global_var 是一个全局变量，它被保存在全局命名空间中。函数 func() 可以直接访问全局变量，而函数 modify_global_var() 使用 global 关键字声明了要修改的全局变量，并成功修改了全局变量的值。

八、变量解构赋值

????????在 Python 中，集合（set）以及其他一些复合数据类型（比如集合、字典、自定义对象等）并不支持直接的解构赋值，因为它们的结构与元组或列表不同。

1、元组与列表的解构赋值

a, b, c = (1, 2, 3)  # 可行，元组的解构赋值
x, y, z = [4, 5, 6]  # 可行，列表的解构赋值

但是，对于集合（set）和字典（dict）来说，它们的结构不是顺序排列的序列，无法像元组或列表那样直接进行解构赋值。

2、集合无法直接解构赋值

# 错误示例
a, b, c = {1, 2, 3}  # TypeError: 'set' object is not iterable

3、字典可以通过特定方法进行解构

# 使用字典的 items() 方法解构赋值
data = {'a': 1, 'b': 2, 'c': 3}
for key, value in data.items():
    print(f"Key: {key}, Value: {value}")
# 输出：
# Key: a, Value: 1
# Key: b, Value: 2
# Key: c, Value: 3

????????对于集合，如果想要进行解构赋值，可以先将集合转换为列表或其他可迭代对象，然后再进行解构操作。但需要注意，集合是无序的，所以解构赋值可能无法准确反映集合中元素的顺序。字典则可以通过其?items()?方法来实现解构赋值。

4、在循环中的解构赋值

# 在循环中使用解构赋值
data_list = [(1, 'a'), (2, 'b'), (3, 'c')]
for num, letter in data_list:
    print(f"Number: {num}, Letter: {letter}")
# 输出：
# Number: 1, Letter: a
# Number: 2, Letter: b
# Number: 3, Letter: c

变量解构赋值能够简化代码，使得对数据结构的操作更加灵活。但要注意，数据结构的长度和解构赋值的变量数量要匹配，否则会引发?ValueError。