【Python基础】变量、运算与内存管理全解析

一、删除变量与垃圾回收：内存管理的底层逻辑

在Python中，变量是对象的引用 ，而不是对象本身。当我们不再需要某个变量时，可以用del语句删除它的引用，让垃圾回收机制（GC）自动清理无引用的对象。

1. del语句：删除的是"引用"，不是"对象"

del的作用是断开变量与对象的关联，而不是直接删除对象。例如：

a = [1, 2, 3]  # 变量a引用列表对象[1,2,3]
print(a)  # 输出：[1, 2, 3]

del a  # 删除a对列表的引用
# print(a)  # 报错：NameError: name 'a' is not defined

此时，列表对象[1,2,3]如果没有其他变量引用它，会被GC标记为"可回收"，随后释放内存。

2. 垃圾回收机制：如何清理无引用对象？

Python的GC主要依赖引用计数 （Reference Counting）和分代回收（Generational Garbage Collection）：

• 引用计数 ：每个对象有一个计数器，记录当前有多少个变量引用它。当计数器变为0时，对象立即被回收。

  import sys
  a = [1, 2, 3]
  print(sys.getrefcount(a))  # 输出：2（getrefcount本身会增加一次引用）
  b = a  # b引用同一个对象，计数器+1
  print(sys.getrefcount(a))  # 输出：3
  del b  # 计数器-1
  print(sys.getrefcount(a))  # 输出：2
  del a  # 计数器变为0，对象被回收

• 分代回收 ：解决循环引用 问题（比如两个对象互相引用）。例如：

  class Node:
      def __init__(self):
          self.next = None
  
  a = Node()
  b = Node()
  a.next = b  # a引用b
  b.next = a  # b引用a（循环引用）
  
  del a, b  # 此时a、b的引用计数为1，但无外部引用，分代回收会清理它们

二、常量：Python中的"伪常量"约定

Python没有真正的常量 （无法定义不可修改的变量），但我们可以通过命名规范 约定常量：全大写字母+下划线。例如：

MAX_SCORE = 100  # 考试满分（约定为常量）
PI = 3.1415926   # 圆周率（约定为常量）

注意 ：虽然可以修改这些变量（比如MAX_SCORE = 90），但不推荐------这会破坏程序的可读性和稳定性。

三、赋值的艺术：简化代码的小技巧

Python的赋值语法非常灵活，掌握以下技巧能大幅简化代码：

1. 链式赋值：一次给多个变量赋同一值

x = y = z = 0  # x、y、z都引用0这个整型对象
print(x, y, z)  # 输出：0 0 0

说明 ：链式赋值本质是将同一个对象的引用赋给多个变量，修改其中一个变量不会影响其他（比如x = 10，y仍为0）。

2. 系列解包赋值：快速分配多个变量

将可迭代对象（列表、元组、字符串等）的元素解包给多个变量：

# 基本用法
a, b, c = 10, 20, 30  # 元组解包
print(a, b, c)  # 输出：10 20 30

# 列表解包
d, e = [40, 50]
print(d, e)  # 输出：40 50

# 字符串解包（字符串是可迭代对象）
f, g = "ab"
print(f, g)  # 输出：a b

3. 变量互换：无需临时变量

通过解包赋值，可以快速交换两个变量的值：

a, b = 1, 2
print(a, b)  # 输出：1 2
a, b = b, a  # 右边是元组(b,a)，解包后赋值给a、b
print(a, b)  # 输出：2 1

4. 星号表达式：处理可变长度的可迭代对象

用*符号接收可变数量的元素，返回列表：

# 取第一个元素，剩下的作为列表
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 输出：1
print(rest)   # 输出：[2, 3, 4, 5]

# 取中间元素
*middle, last = [1, 2, 3, 4, 5]
print(middle)  # 输出：[1, 2, 3, 4]
print(last)    # 输出：5

# 取两边元素，中间作为列表
first, *middle, last = [1, 2, 3, 4, 5]
print(first)   # 输出：1
print(middle)  # 输出：[2, 3, 4]
print(last)    # 输出：5

四、变量与对象类型：Python的"动态类型"本质

Python是动态类型语言，其核心特点是：

• 变量无类型：变量只是"引用"，不绑定具体类型。
• 对象有类型：变量的类型由它引用的对象决定。

例如：

a = 10  # a引用整型对象，type(a)→int
print(type(a))  # 输出：<class 'int'>

a = "hello"  # a引用字符串对象，type(a)→str
print(type(a))  # 输出：<class 'str'>

a = [1, 2, 3]  # a引用列表对象，type(a)→list
print(type(a))  # 输出：<class 'list'>

总结：变量是"容器"，装的是对象的地址；对象是"内容"，有固定的类型和值。

五、数字与基本运算符：Python的算术基础

Python支持整数 （int）和浮点数（float）两种基本数字类型，提供了丰富的运算操作。

1. 数字类型说明

• 整数 ：任意大小的整数（比如50、-100、0）。
• 浮点数 ：带小数点的数字（比如3.14、10.0），或科学计数法（比如1.23e2→123.0）。

2. 基本运算符（重点总结）

以下是Python中常用的数字运算符，结合示例说明：

运算符	说明	示例	结果
+	加法	3 + 2	5
-	减法	30 - 5	25
*	乘法	3 * 6	18
/	浮点除法（结果为浮点数）	8 / 2	4.0
//	整数除法（向下取整）	7 // 2	3
%	模运算（取余）	7 % 4	3
**	幂运算	2 ** 3	8

关键说明：

• /与//的区别 ：/返回浮点数（即使整除），//返回整数（向下取整）。例如：

  print(8 / 2)  # 输出：4.0（浮点除法）
  print(7 // 2)  # 输出：3（整数除法，向下取整）
  print(-7 // 2) # 输出：-4（向下取整到更小的整数）

• %的符号规则 ：模运算的结果符号与除数 一致。例如：

  print(7 % 4)   # 输出：3（7 = 4*1 + 3）
  print(7 % -4)  # 输出：-1（7 = (-4)*(-2) + (-1)）

3. divmod()函数：同时获取商和余数

divmod(a, b)接受两个参数，返回一个元组 （商, 余数），其中商由a // b计算，余数由a % b计算。例如：

# 计算7除以2的商和余数
quotient, remainder = divmod(7, 2)
print(quotient)  # 输出：3
print(remainder) # 输出：1

# 计算100除以3的商和余数
q, r = divmod(100, 3)
print(q)  # 输出：33
print(r)  # 输出：1

优势：比分开计算商和余数更高效（只需一次运算）。

六、总结：掌握基础，事半功倍

本文覆盖了Python的核心基础知识点：

• 内存管理 ：del删除引用，GC自动清理无引用对象。
• 常量约定：全大写命名，逻辑上保持不变。
• 赋值技巧：链式赋值、解包赋值、变量互换，简化代码。
• 类型本质：变量是引用，对象有类型，动态类型语言的特点。
• 数字运算 ：基本运算符的用法，divmod()函数的高效性。

这些知识点是Python编程的基石，建议多写代码实践（比如用解包赋值交换变量，用divmod()优化除法运算），体会Python的简洁与高效。

如果本文对你有帮助，欢迎点赞、收藏，评论区留言交流~ 😊