Python青少年简明教程：变量

Python青少年简明教程：变量

在编程语言中，变量是用于存储数据的命名内存位置。通过变量名访问存储的数据。变量允许程序在运行时动态存储、更新和访问数据。

在Python中，变量本质上是一个名称，用于引用特定的对象。它类似于对象的一个标签或别名。当我们给变量赋值时，实际上是将该名称与一个对象关联起来，可以通过这个名称来引用和操作该对象。

Python作为一种动态类型语言，变量的类型由赋值给它的值决定，而不是在声明时预先指定类型。这种动态类型赋值的特性为Python程序带来了很大的灵活性。

Python中是万物皆对象，无论是数字、字符串，还是函数和模块(module)等，在Python内部都被实现为对象。变量只是引用这些对象的一个方式而已。

【在python官方文档，“变量”（variables）并没有一个专门严格的定义。但有“变量”这种说法。

见官方文档 命名与绑定

https://docs.python.org/zh-cn/3/reference/executionmodel.html#naming-and-binding

提示：在Python的官方文档中更多地使用了“名称”（name）这个术语来。但是在实际的编码和交流中，人们也常常使用“变量”（variable）这个术语来描述Python中的名称。

在 Python 中，变量不需要声明类型，您只需要在使用变量之前为其赋值。此外，因为 Python 是动态类型语言，所以变量的类型可以根据赋予的值在运行时改变。

在 Python 中，变量更像是名字对数据对象的引用。

】

Python 中变量的定义：

Python 中变量是代表存储在计算机存储器中的某个值的名称。

Python是动态类型语言，变量在第一次赋值时声明。无需使用关键字，也不需要指定数据类型，Python 会根据赋值自动推断变量类型。例如：

age = 25  # 声明并初始化一个变量，类型为整数

name = "Alice"  # 声明并初始化一个变量，类型为字符串

pi = 3.14  # 声明并初始化一个变量，类型为浮点数

Python 是一种动态类型语言，变量的类型可以在运行过程中改变。这意味着变量可以在其生命周期内被赋予不同类型的值。例如：

data = 10  # 赋初值为整数

data = "ten"  # 稍后被赋值为字符串

一旦变量被赋值，你就可以在任何需要它的地方使用它，比如在函数计算、条件判断、循环或其他表达式中使用。

Python中的变量实际上是对象的引用。

在Python中，变量实际上是对象的引用。当你创建一个变量并赋值时，Python会在内存中创建一个对象，然后让变量指向（引用）这个对象。关于变量赋值详见下一节。示例：

x = 5

这行代码做了两件事：

在内存中创建一个整数对象，值为5

创建一个名为x的变量，并让它引用这个整数对象

Python的变量命名规则包括以下几条：

允许包括字符、数字以及下划线（_），不能以数字开头。

Python的变量命名不能含有空格和标点符号（下划线 '_' 例外），也不能使用保留字。

除了下划线 _，其他标点符号（如 !, @, #, $, %, ^, &, *, (, ), -, +, =, {, }, [ ], :, ;, '", ``,?,~` 等）都不能用在变量名中。

保留字也称为关键字。保留字是 Python 语言中用于特定目的的单词，不能用作变量名、函数名或任何其他标识符名称。

名称区分大小写，例如"myVar"和"myvar"是两个不同的变量。

以单下划线（_）开头的变量通常用作受保护的变量，表示应该将其视为私有，不建议直接访问。虽然Python没有严格的访问控制，但这是一种约定俗成的做法。

以双下划线（__）开头和结尾的变量是Python中的特殊标识符，具有特殊的意义，如类的私有成员或专用标识符。

Python的变量名应该尽量遵循一定的命名约定（命名习惯），一般遵守蛇形命名法（snake case）：

一般变量命名使用小写字母（Letter），多个单词之间用下划线连接，例如：book_id、book_store_count。

类名首字母大写，如Python内置模块collections.abc中的Iterable类，我们自定义的Book类等。

Python支持Unicode字符编码，因此，字符（character）不仅包括字母（即英文字母），还包括各种语言的字符，包括汉字。虽然Python允许在变量名中使用汉字或其他非ASCII字符，但实际开发中，还是建议使用英文单词或拼音来命名变量。

特别提示，本节下面的内容，因为涉及到知识点较多，还有些是后来才讲解到的内容，可能不易理解，初学时无需深究，更不要疑惑不前，而应耐心继续，先知道有这些情况即可，等熟悉了相关内容后，再回头看就容易理解了。

Python 变量是通过引用机制来管理的。每个变量名实际上是一个指向对象的引用。对象存储在内存中，而变量名则是这些对象的引用。以下是对 Python 变量引用机制的一些说明（变量引用机制的特点）：

☆多个变量引用同一对象的情况

在 Python 中，一切都是对象。变量只是对象的引用，这意味着变量名指向存储在内存中的对象。例如：

a = [1, 2, 3]
b = a  # b 现在引用与 a 相同的列表对象。修改其中一个变量会影响另一个。
b.append(4)
print(a)  # 输出： [1, 2, 3, 4]

print(ida) == id(b))  # 输出： True。可用id()函数可以查看对象的内存地址

☆可变和不可变对象

可变对象（如列表、字典、集合）在原地修改时会影响所有引用该对象的变量。

不可变对象（如整数、字符串、元组）在修改时会创建一个新的对象，原来的引用不会受到影响。例如：

# 可变对象
a = [1, 2, 3]
b = a
a.append(4)
print(b)  # b 会显示 [1, 2, 3, 4]

# 不可变对象
x = 10
y = x
x = 20
print(y)  # y 仍然是 10

☆共享引用

当多个变量引用同一个可变对象时，对该对象的修改会影响所有引用该对象的变量。例如：

list1 = [1, 2, 3]
list2 = list1
list1[0] = 99
print(list2)  # list2 会显示 [99, 2, 3]

☆深拷贝和浅拷贝

浅拷贝（Shallow Copy）: 创建一个新的对象，但只复制最外层对象的引用，内部元素仍然指向原来的对象。

深拷贝（Deep Copy）: 创建一个新的对象，并递归地复制所有层次的对象，完全独立于原来的对象。

示例：

import copy
original_list = [1, [2, 3], 4]

shallow_copy = copy.copy(original_list)
deep_copy = copy.deepcopy(original_list)

original_list[1][0] = 99

print(shallow_copy)  # 浅拷贝会显示 [1, [99, 3], 4]
print(deep_copy)     # 深拷贝会显示 [1, [2, 3], 4]

☆引用计数

Python 使用引用计数来管理内存。每个对象都会记录有多少个引用指向它。当引用计数为零时，Python 的垃圾回收机制会自动释放这个对象占用的内存。

Python中一切皆对象

在Python中一切皆对象，是一个核心概念，意味着Python中的所有数据类型都是对象。这个理念反映了Python的设计哲学和语言特性。例如：

# 数字是对象
num = 42
print(type(num))  # <class 'int'>

# 函数是对象
def greet():
    print("Hello")

print(type(greet))  # <class 'function'>

# 将函数赋值给变量
say_hello = greet
say_hello()  # 输出: Hello

# 类也是对象
class MyClass:
    pass

print(type(MyClass))  # <class 'type'>

# None也是对象
print(type(None))  # <class 'NoneType'>

对象是Python中数据的基本单位。更具体地说：

对象是数据和操作这些数据的方法的封装。

每个对象都有三个基本特征：身份（identity）、类型（type）和值（value）。

a) 身份（Identity）：

每个对象都有一个唯一的身份标识符。

可以通过 id() 函数获取。

可以理解为对象在内存中的地址。

b) 类型（Type）：

定义了对象可以进行的操作和可能的值。

可以通过 type() 函数获取。

例如：整数、字符串、列表等都是不同的类型。

c) 值（Value）：

对象表示的数据。

对于不可变对象，值是固定的；对于可变对象，值可以改变。

例如：

x = [1, 2, 3]  # 创建一个列表对象

print(id(x))    # 输出对象的身份
print(type(x))  # 输出对象的类型（<class 'list'>）
print(x)        # 输出对象的值

x.append(4)     # 修改可变对象的值
print(x)        # 输出： [1, 2, 3, 4]
print(id(x))    # 输出的id与之前相同，因为是同一个对象

不可变对象（immutable objects）和可变对象（mutable objects）

在 Python 中，对象分为不可变对象（immutable objects）和可变对象（mutable objects）。

不可变对象（Immutable Objects）

定义：创建后其内容不能被改变的对象。

特点：

当你修改这些对象时，实际上是创建了一个新对象。

它们可以作为字典的键或集合的元素。

不可变对象一旦创建，其值就不能被改变。这类对象包括：

数字类型：int, float, complex

字符串（str）

元组（tuple）

冻结集合（frozenset）

布尔值（bool）

示例：

# 整数是不可变对象
a = 5
print(id(a))  # 输出对象的内存地址

a = a + 1
print(id(a))  # 输出新的内存地址，不同于之前的地址

# 字符串是不可变对象
s = "hello"
print(id(s))  # 输出对象的内存地址

s = s + " world"
print(id(s))  # 输出新的内存地址，不同于之前的地址

在上述示例中，每次对不可变对象的修改都会创建一个新对象，而不是修改原来的对象。

可变对象（Mutable Objects）

定义：创建后可以修改其内容的对象。

可变对象的值可以在原地被改变。这类对象包括：

列表（list）

字典（dict）

集合（set）

自定义类的实例（默认情况下）

特点：

可以直接修改对象的内容，而不是创建新对象。

不能作为字典的键或集合的元素（除非实现了特定方法）。

示例：

# 列表是可变对象
lst = [1, 2, 3]
print(id(lst))  # 输出对象的内存地址

lst.append(4)
print(id(lst))  # 内存地址不变，列表被修改

# 字典是可变对象
d = {'a': 1, 'b': 2}
print(id(d))  # 输出对象的内存地址

d['c'] = 3
print(id(d))  # 内存地址不变，字典被修改

在上述示例中，对可变对象的修改是在原地进行的，不会创建新的对象，内存地址保持不变。

不可变对象和可变对象的区别

不可变对象在修改时会创建新的对象，旧对象的内存会被垃圾回收。

可变对象在修改时直接在原对象上进行，不会创建新的对象。

你试图改变一个不可变对象的值时，Python不会修改原始对象，而是创建一个新的对象来存储新的值。原始对象保持不变，变量会指向新创建的对象。例如：

x = 5
print(id(x))  # 假设输出id：4561231248
x = x + 1  # 看似修改x，实际上创建新对象
print(id(x))  # 输出新的id，如：4561231280

s = "hello"
print(id(s))  # 假设输出id：4561231300
s = s + " world"  # 创建新字符串对象
print(id(s))  # 输出新的id

当改变一个可变对象的值时，Python 会直接修改原始对象，而不是创建新对象。这是可变对象和不可变对象的关键区别。例如：

lst = [1, 2, 3]
print(id(lst))  # 记录原始 id

lst[1] = 5  # 直接修改列表的第二个元素
print(lst)  # 输出： [1, 5, 3]
print(id(lst))  # id 保持不变
lst.append(4)  # 添加元素
print(lst)  # 输出： [1, 5, 3, 4]
print(id(lst))  # id 仍然不变

作为函数参数传递时：Python函数参数传递的始终对象的引用，而不是对象的值，这种引用的行为受参数对象类型（可变或不可变）的影响：

不可变对象作为函数参数传递时，函数内部的修改不会影响外部的对象。

可变对象作为函数参数传递时，函数内部的修改会影响外部的对象。

具体情况参见“函数”一节。

附、Python变量的认识理解 https://blog.csdn.net/cnds123/article/details/116768499

Python语言数据模型

英文https://docs.python.org/3/reference/datamodel.html

中文https://docs.python.org/zh-cn/3/reference/datamodel.html