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语言数据模型