本文主要是介绍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] = 99print(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:passprint(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，如：4561231280s = "hello"
print(id(s)) # 假设输出id：4561231300
s = s + " world" # 创建新字符串对象
print(id(s)) # 输出新的id
当改变一个可变对象的值时，Python 会直接修改原始对象，而不是创建新对象。这是可变对象和不可变对象的关键区别。例如：
lst = [1, 2, 3]
print(id(lst)) # 记录原始 idlst[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
这篇关于Python青少年简明教程：变量的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
