Python的数据类型和运算符，是每个学Python的人绕不过去的第一道坎。很多人觉得这块太简单，无非就是整数、浮点数、字符串、布尔值，加上几个加减乘除和比较符号。但我在写代码和帮新手排查问题的时候，见过太多因为基础不牢导致的翻车现场：浮点数精度问题让账目对不上、字符串拼接方式不对导致程序慢到怀疑人生、逻辑运算符优先级搞错让Bug在代码里藏了好几个月。这篇文章就把Python的四大基础数据类型和整套运算符系统完整拆一遍，不单讲语法长什么样，更重要的是把背后的内存原理、执行逻辑和实际场景中的避坑经验都说清楚。不管你是刚入门的新手，还是已经写了一阵子代码但想夯实基础的开发者，这篇都能帮你把地基打牢。
1. 四个基础数据类型：从内存视角理解Python的数据世界
1.1 整数(int)：不只是加减乘除那么简单
Python的整数类型，表面上看起来就是个普通数字，但它的设计跟C语言、Java里的整数有本质区别。最大的不同就是Python的int是可变长度的，理论上可以无限大。你写一个123456789012345678901234567890这种超长数字，Python照样能存，不会像C语言那样溢出报错。这是因为Python的整数在底层用了类似数组的结构来分段存储数值，数字大了就多分配几段，所以不会溢出。
这个特性带来的好处是写代码可以非常放心，不用担心乘法算到一半爆掉。坏处是性能上会比固定长度的整数类型慢一些，因为底层要做额外的判断和分配。不过对于绝大多数业务场景，这个性能差异根本感知不到。
整数类型还有一个需要注意的点是进制。Python里默认是十进制，但也支持二进制（0b开头）、八进制（0o开头）、十六进制（0x开头）的写法。在处理文件权限、网络字节序、颜色值这类场景时，十六进制用得特别多。比如设置一个RGB颜色值，写成0xFF0000就比写成16711680直观多了。
a = 100 # 十进制 b = 0b1100 # 二进制，等于12 c = 0o17 # 八进制，等于15 d = 0xFF # 十六进制，等于255这里有个容易被忽略的细节：Python 3.x里，整数除法/返回的一定是浮点数，哪怕是整除也会返回浮点数。比如4 / 2结果是2.0而不是2。如果你想要整数结果，必须用//整除运算符。这个改动是Python 2到Python 3的一个重要变化，很多从旧版本迁过来的代码，最容易在这里出问题。
1.2 浮点数(float)：精度是永远绕不开的痛
浮点数恐怕是Python基础里最容易被轻视、又最容易出大事的类型。先说结论：Python的float遵循IEEE 754标准的双精度浮点数格式，精度大约是15到16位有效数字。但这不是问题所在，问题在于二进制无法精确表示很多十进制小数。
拿0.1举例。在二进制里，0.1是一个无限循环小数，就像十进制里1/3是无限循环的0.333...一样。计算机只能在有限的位数里截断存储，所以0.1在内存里其实是一个略大于或略小于精确值的近似数。当你做0.1 + 0.2的时候，误差就会显现出来：
print(0.1 + 0.2) # 输出 0.30000000000000004这个问题几乎让每个新手都困惑过，甚至有的线上系统也因为没处理这个精度问题，导致金额计算出了偏差。解决思路有几种：
第一种，直接接受误差，比较时用round()或允许误差范围。比如判断两个浮点数是否相等，不写a == b，而是写abs(a - b) < 1e-9。
第二种，涉及金额计算的场景，坚决不用float，直接用decimal.Decimal，用字符串传入数值，从源头上避免二进制精度问题。
第三种，对性能要求高且知道数据范围的场景，可以考虑用整数以分为单位来存储金额，避免浮点运算。
from decimal import Decimal price = Decimal('19.99') quantity = Decimal('3') total = price * quantity # 精确结果，59.971.3 字符串(str)：最常用也最容易埋坑的类型
字符串是Python里使用频率最高的数据类型。Python的字符串有个核心特性：不可变（immutable）。这意味着你一旦创建了一个字符串，它里面的字符就不能被修改。所有看起来像是修改字符串的操作，比如replace()、upper()、切片重新赋值，实际上都是创建了一个新的字符串对象。
这个特性对性能有直接影响。如果你在一个循环里反复做字符串拼接，比如result = result + item，每次拼接都会创建一个新的字符串对象，旧的对象等着被垃圾回收。循环次数一多，性能会肉眼可见地变差。实测过，拼接一万次字符串，用+操作符的花费时间是用join()方法的几十倍。
# 慢：循环里用 + 拼接 s = "" for i in range(10000): s += str(i) # 快：用列表收集再 join parts = [] for i in range(10000): parts.append(str(i)) s = "".join(parts)字符串的另一个需要注意的点是编码问题。Python 3的字符串是Unicode编码的，每个字符都是一个Unicode码点。但你从文件读数据、从网络收数据的时候，拿到的往往是经过某种编码（比如UTF-8、GBK）的字节串（bytes）。字符串和字节串可以互相转换，但必须明确指定编码格式。
text = "中文测试" byte_data = text.encode('utf-8') # 字符串转字节串 back_to_text = byte_data.decode('utf-8') # 字节串转字符串新手最容易在这块踩坑的是编码不统一。文件是GBK存的，程序按UTF-8读，结果一读就是一屏乱码。这属于经验问题，遇到乱码先别慌，问清楚数据源是什么编码。
1.4 布尔值(bool)：真与假的判断逻辑
布尔值只有两个：True和False。但Python的布尔判断远不止这两个值这么简单。关键点是：Python里有一个"真值测试"的概念，任何对象都可以被当作布尔值来用。在需要布尔判断的上下文里（比如if语句的条件），每个对象都会被测试为True或False。
会被判定为False的值有：None、False、数值0（整数0、浮点数0.0、复数0j）、空字符串''、空列表[]、空元组()、空字典{}、空集合set()。其余所有对象都是True。这个规则极其常用，比如判断一个列表是否为空的惯用写法：
if my_list: # 推荐，空列表为False，非空为True # 处理列表 else: # 列表为空 if len(my_list) > 0: # 不推荐，啰嗦 pass这里有个容易混淆的地方：True和1在数值上是相等的，False和0也是相等的。True == 1结果是True，False == 0结果也是True。这意味着布尔值可以直接参与算术运算，True + 2等于3。但在平时写代码时，不要依赖这个特性去写什么sum(条件列表)之外的技巧性代码，那会让代码变得晦涩难懂。
布尔类型在底层其实是int的子类，这是Python历史设计留下的痕迹。了解这个关系有助于理解为什么isinstance(True, int)返回True。后面讲到类型判断的时候，这个细节可能会坑到你。
2. 运算符全景拆解：Python表达式的底层规则
2.1 算术运算符与运算优先级
Python的算术运算符有六个基础的：加法+、减法-、乘法*、除法/、整除//、取余%，外加一个求幂**。这些符号本身不复杂，但组合在一起的时候，运算优先级就成了重点。
Python的运算符优先级从高到低的顺序里，和算术相关的可以这样记：先算**，再算* / // %，最后算+ -。为什么强调这个？因为日常写代码时，优先级翻车是真实发生过的。比如下面这个例子：
# 容易出错的写法 if x % 2 == 0 and y % 2 == 0: pass # 实际解释为 if (x % 2 == 0) and (y % 2 == 0): pass如果你的本意是判断x和y是否都为偶数，上面两种写法结果一样。但如果有人误解了%和==的优先级，或者不小心改成了x % 2 + y % 2 == 0，结果就完全变味了。
求幂运算符**有个特殊性：它是右结合的，也就是说2 ** 3 ** 2会先算3 ** 2得到9，再算2 ** 9得到512。这个跟小学数学里的从左往右的习惯不一样，容易被忽略。
还有一个细节值得提：负数的整除和取余。Python的//和%遵循的是"结果向负无穷取整"的规则。比如-7 // 2的结果是-4而不是-3（因为-4比-3更接近负无穷），相应的-7 % 2的结果是1而不是-1。这个跟C语言完全不同，算周期性问题、分页逻辑的时候特别容易踩坑。
2.2 比较运算符：连续比较是一个隐藏功能
比较运算符包括==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。这些一眼就能看懂，但Python提供了一个其他语言很少有的特性：连续比较（chained comparison）。
# 判断x是否在区间内 if 0 < x < 10: print("x大于0且小于10")这个写法相当于0 < x and x < 10，但更简洁、更易读，而且只计算一次x的值。在C语言或Java里，你写0 < x < 10会先算0 < x得到一个布尔值，再拿布尔值和10比较，结果完全是另一回事。Python的这个语法糖很贴心，写数值区间判断时应该养成习惯用这种写法。
比较运算符里还有一个经典坑：==和is的区别。==比较的是两个对象的值是否相等，is比较的是两个对象是否是同一个对象（内存地址相同）。对于整数来说，Python有个小整数缓存机制：范围在-5到256之间的整数会被复用，所以a = 256; b = 256; a is b的结果是True。但a = 257; b = 257; a is b的结果就是False，因为257超出缓存范围，每次创建都是新对象。
a = 256 b = 256 print(a is b) # True，小整数缓存 c = 257 d = 257 print(c is d) # False，两个不同的对象 print(c == d) # True，值相等日常开发中，判断值是否相等一律用==，is只用来判断None，比如if item is None:，这是Python社区的通用约定。
2.3 逻辑运算符：短路运算与真值表
逻辑运算有三个：and（与）、or（或）、not（非）。很多人把这三个理解成简单的真值组合，但Python的逻辑运算符有一个重要特性：短路求值。
and运算从左往右计算，如果左边已经是假值，右边的表达式根本不会执行。or运算同理，左边是真值的话，右边就不会执行。这个特性不只是性能优化，更重要的是可以做安全的默认值判断。
# 经典写法：安全地从可能为空的字典取值 value = data_dict.get("key") or "默认值" # 短路防止除零错误 result = denominator > 0 and numerator / denominator > 1第一个例子中，如果data_dict.get("key")返回了None或者其他假值，就取后面的默认值。第二个例子中，如果denominator不大于0，右边的除法根本不会执行，从源头避免了ZeroDivisionError。
很多从Java或C++转来的开发者容易忽略一个细节：Python的and和or返回的不是布尔值，而是参与运算的某个原始值。x and y如果x是假，返回x；否则返回y。同理，x or y如果x是真，返回x；否则返回y。
print(0 and 100) # 0 print(1 and 100) # 100 print(0 or 100) # 100 print(1 or 100) # 1这个行为在用三元表达式替代写法的时候很实用，比如result = x or default，但同时也要求你非常清楚每个值在布尔测试里是真还是假。
not就简单一些，总是返回布尔值。not 0是True，not ""是True，not []是True。在写条件判断时，not配合真值测试可以写出非常清爽的代码。
2.4 位运算、成员运算与身份运算
位运算包括&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）。这些运算符在业务代码里用得不多，但在权限系统、状态标记、图像处理、底层协议解析等场景中非常有用。
举个实际例子：用一个整数的不同位来标记不同的权限状态。
READ = 1 # 0001 WRITE = 2 # 0010 EXECUTE = 4 # 0100 # 给用户授权读和写 permission = READ | WRITE # 0011，值为3 # 判断是否有写权限 has_write = permission & WRITE # 0010，不等于0表示有权限 # 撤销写权限 permission = permission & ~WRITE # 0001，值为1这个手法在数据库字段设计里也常见，一个字段存多个开关状态，节省空间且查询效率高。但要注意：位运算只适用于整数，而且代码可读性偏低，使用前必须写清楚注释。
成员运算有in和not in，用来判断某个元素是否存在于容器里。列表、元组、字符串、字典、集合都支持。字符串里的in判断的是子串是否存在。这里有个性能相关的细节：判断元素是否在列表里是线性遍历，时间复杂度是O(n)；判断元素是否在集合里是哈希查找，时间复杂度是O(1)。如果数据量大，需要频繁做成员判断，把列表转成集合再去判断，性能提升非常明显。
# 慢：列表成员判断 user_ids = [1001, 1002, 1003, ...] # 一万个元素 for uid in some_list: if uid in user_ids: # 每次都是O(n) pass # 快：集合成员判断 user_id_set = set(user_ids) for uid in some_list: if uid in user_id_set: # 每次O(1) pass身份运算就是前面提过的is和is not，用于判断两个变量是否指向同一个对象。日常只用它来判断None，其他场景基本用不上。
3. 类型转换与动态特性：Python灵活性的双刃剑
3.1 隐式转换与显式转换的取舍
Python在运算过程中会自动进行一些类型转换，这叫隐式转换。最常见的隐式转换发生在整数和浮点数一起运算的时候：1 + 2.0结果自动变成浮点数3.0，因为整数转浮点数是安全无损的，Python会自动向更精确的类型靠拢。
但隐式转换也有限制。整数和字符串做+运算，不会自动把数字转成字符串，而是直接报TypeError。这个设计是故意的，目的是防止程序员写出歧义代码：
print(1 + "2") # TypeError: unsupported operand type(s)错误的代驾。想要得到"12"必须显式写str(1) + "2"，想要得到3必须写1 + int("2")。
显式转换是主动调用类型函数，比如int()、float()、str()、bool()。用int()做转换时有两个点要特别注意。第一，int()可以接受字符串形式的整数，但不能接受包含小数点或额外字符的字符串。int("3.14")会报错，必须先float("3.14")再int()，或者用int(float("3.14"))。第二，int()转换时默认是向零取整，int(-3.7)结果是-3而不是-4。
print(int(3.99)) # 3，直接截断小数部分 print(int(-3.7)) # -3，向零取整 print(round(3.5)) # 4，但注意round的银行家舍入问题round()函数的舍入规则是"银行家舍入"（四舍六入五取偶），也就是说恰好是x.5的时候，会舍入到最近的偶数。round(2.5)得到2，round(3.5)得到4。很多金融计算场景因为这个特性吃过亏，务必留意。
3.2 动态类型与鸭子类型
Python是动态类型语言，变量本身没有类型限制，同一个变量可以先后指向整数、字符串、列表。这个灵活性极大提高了编码效率，但也带来了管理成本。代码里到处都是变量，但没人知道某个变量此刻到底是什么类型，这是动态类型的代价。
"鸭子类型"是Python设计哲学的体现：如果它走起路来像鸭子、叫起来像鸭子，那它就是鸭子。也就是说，一个对象能做什么，取决于它有没有对应的方法，而不是它属于哪个类。
def add_one(x): return x + 1 print(add_one(10)) # 11，整数 print(add_one("10")) # "101"，字符串 print(add_one([1, 2])) # [1, 2, 1]，列表同一个函数，传入不同类型的数据，行为完全不同，全凭对象自己怎么实现+运算。这个特性让Python可以写出非常通用的代码，但也要求开发者必须清楚地知道自己在做什么。处理外部输入（用户输入、文件内容、网络请求）时，要主动做类型检查或类型转换，不能把输入当成"理所当然"的类型。
3.3 isinstance与type的实用区别
很多时候我们需要在运行时判断一个变量的类型。多数人会想到type()函数，但其实更推荐用isinstance()函数。type(x) == int这种方式不够灵活，而且处理继承关系时会出问题。isinstance()可以接受一个类型元组，判断x是否是其中任意一种类型：
if isinstance(value, (int, float)): print("数值类型") if isinstance(name, str): print("字符串类型")特别要小心前面提过的布尔值陷阱：True和False是int的子类，所以isinstance(True, int)会返回True。如果你写代码时只想接受普通的整数、不接受布尔值，检查起来会有点麻烦：
def process_number(x): if isinstance(x, bool): # 布尔值虽然是int，但先拦截 raise TypeError("布尔值不允许") if isinstance(x, int): print("整数处理逻辑")这个需求在日常API参数校验里还真的会碰到。比如一个参数序列化时，True会被转成1，但业务上接受0和1却不想接受True和False。这种边缘情况最容易在联调阶段暴露出来。
4. 实操过程：从零搭建一个简单数据处理小工具
4.1 需求与设计
讲了一堆理论，最后用一个完整的实操案例把这些知识点串起来。这个例子的场景很常见：读取一组混合类型的输入数据，做清洗和统计，最后输出结果。虽然不复杂，但能把类型判断、运算符、类型转换、异常处理全用上。
需求是这样的：有一个文本文件，每一行是一个数据记录，格式可能是整数、浮点数、字符串或者空行。我们要统计出有多少数字、多少字符串，计算所有数字的平均值和总和，同时如果出现无法解析的行要记录下来。这个需求看起来简单，但真正写起来牵扯的细节非常多。
设计思路是：逐行读取文件，对每一行做trim处理（去掉首尾空白字符），空行直接跳过。然后尝试依次解析为整数、浮点数。如果都失败，就归类为字符串。统计每种类型的个数，对数字求和求平均。最后格式化输出统计结果。
4.2 核心代码实现
按照这个设计，写出来的代码大概长这样：
def classify_and_stat(file_path): numbers = [] strings = [] invalid_lines = [] total_lines = 0 with open(file_path, "r", encoding="utf-8") as f: for line in f: total_lines += 1 content = line.strip() if not content: continue try: value = int(content) except ValueError: try: value = float(content) except ValueError: value = content if isinstance(value, str): strings.append(value) elif isinstance(value, bool): invalid_lines.append((total_lines, content, "布尔值异常")) elif isinstance(value, (int, float)): numbers.append(value) count_numbers = len(numbers) count_strings = len(strings) total_sum = sum(numbers) avg = total_sum / count_numbers if count_numbers > 0 else 0 print(f"总行数: {total_lines}") print(f"数字个数: {count_numbers}") print(f"字符串个数: {count_strings}") print(f"数字总和: {total_sum}") print(f"数字平均值: {avg}") if invalid_lines: print(f"异常记录: {invalid_lines}")这段代码里用到了几个关键点。第一，int()和float()尝试解析时用try/except捕获ValueError，这是类型转换最常见的实战用法。第二，用isinstance(value, (int, float))做联合类型判断，但提前把bool拦截掉了，因为前面说过布尔值是整数子类。第三，sum(numbers)直接求和，注意numbers列表里可能混合了int和float，Python会自动处理。
4.3 运行效果与优化空间
假设输入文件内容如下：
10 3.14 hello 42 world 25 -8运行后输出的统计结果会显示数字个数为5（10、3.14、42、25、-8），字符串个数为2，总和为72.14，平均值约为14.428。
这个实现已经能干活了，但还有几个可以优化的点。第一个是文件读取方式，如果文件特别大，用for line in f逐行读取比一次性readlines()更省内存。第二个是解析逻辑，当前实现先试整数再试浮点，如果数据量很大而且大量都是浮点数，可以先用正则表达式快速判断文本形态，减少不必要的异常抛出。第三个是统计部分，如果只需要平均值不关注具体列表，可以用累积求和的方式，完全省掉存储numbers列表的内存。
# 更省内存的写法 count = 0 total = 0.0 for line in f: try: value = float(content) count += 1 total += value except ValueError: pass但注意实际取舍：float("10")是能成功转成10.0的，所以如果统一用float()解析，整数和浮点数都会被归为数字，省掉一次int()尝试。只是最终平均值的显示可能会带.0，需要根据需求格式化。
5. 常见问题与排查技巧实录
5.1 浮点数精度问题导致判断失败
这是被问得最多的问题。0.1 + 0.2 != 0.3让无数人摸不着头脑。排查思路很简单：先用print(repr(0.1 + 0.2))看真实值，再用Decimal做精确计算对比。日常写法里，涉及浮点数比较时用math.isclose()函数，它能同时处理绝对误差和相对误差：
import math print(math.isclose(0.1 + 0.2, 0.3)) # True # 自定义容差 print(math.isclose(1000.0, 1000.0001, rel_tol=1e-5)) # Trueisclose有两个参数：rel_tol是相对容差，abs_tol是绝对容差。默认情况下rel_tol=1e-09即十亿分之一的相对误差，对大多数场景够用。如果你在处理特别大或特别小的数，要调整容差数值。
5.2 字符串拼接性能瓶颈
如果你发现一段处理文本的程序运行很慢，先看代码里有没有在循环中用+拼接字符串。一个十几次循环看不出问题，但数据量大到上万、上十万次，差距就是数量级的。排查时可以试试把普通字符串拼接，改成"".join(列表)或者用列表收集再展开。还有第三种方案，用io.StringIO，适用于需要逐步构建大段文本的场景：
from io import StringIO buf = StringIO() for i in range(10000): buf.write(str(i)) buf.write(",") result = buf.getvalue()实际经验是：join()方法最容易读也最容易维护，大部分场景选它就行。StringIO适合需要边写边处理其他逻辑的情况，代码会更啰嗦一些。
5.3 类型判断用了type而不是isinstance
排查线上问题时遇到过这样的情况：一个自定义类继承了内置的int，代码里用type(value) == int判断，结果判断失败，导致逻辑走了错误分支。正确做法是isinstance(value, int)，这样无论是内置类型还是子类实例都能正确识别。同理，判断是否为"数字"时，isinstance(x, (int, float, complex))比type(x) in [int, float, complex]更可靠更简洁。
还有一个相关的坑：从数据库读出来的数值，可能是Decimal类型，也可能是numpy.float64类型，用isinstance(x, float)会漏掉它们。这时要考虑用鸭子类型的思路，检查对象有没有实现对应的数值运算方法，或者统一在数据入口做一次标准化转换。
5.4 布尔值与整数的纠缠
True == 1、isinstance(True, int)这两个现象合在一起，会产生一些意想不到的后果。比如统计一个列表里数字的个数，如果有人往列表里塞了True，sum([1, True, 2])会得到4而不是3。这在处理外部数据时是真实存在的隐患。
data = [1, True, 2, False, 3] print(sum(data)) # 7，因为True按1计，False按0计想只统计整数而忽略布尔值，要写sum(x for x in data if isinstance(x, int) and not isinstance(x, bool))。看起来啰嗦，但这就是Python语言本身特性的真实反映。做数据清洗时如果发现统计结果莫名对不上，查一查数据里是不是混入了布尔值，往往能找到原因。
5.5 运算符优先级翻车实例
一个真实案例：判断一个年份是否为闰年。某开发者的代码写着if year % 4 == 0 and year % 100 != 0 or year % 400 == 0，运行结果看起来很正确，但这段代码对某些边界年份给出了错误结果。原因在于and和or的优先级：and优先级高于or，所以表达式实际上被解析成了(year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)。对于year=2100，这个表达式能给出正确结果，但阅读代码的人极容易理解成year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)，两者的语义完全不同。
这类问题的排查思路很简单：看到混合使用多种运算符号的表达式，一律用括号明确优先级。不要相信自己对运算符优先级表的记忆，更不要相信阅读代码的同事能一次看懂。写清楚括号，比任何注释都有效。
6. 实操中的几个习惯性建议
最后分享几个我在写代码和辅导新人过程中总结的习惯。第一个，所有从外部拿到的数据，进到程序内部的那一刻就做类型标准化。用户输入、文件内容、API返回值，统一转换成你预期的类型和格式，后续所有逻辑就不用再猜类型了。第二个，涉及数值计算先问自己一句：这个场景能不能用整数？能用整数就不要用浮点数。金额用分存整数，秒数用整数存时间戳，能省掉一大批精度问题。第三个，写布尔表达式时，把"常量放右边、变量放左边"的C语言习惯改掉，Python没有这个问题，直接写if x == 10:就好了。
类型和运算符是Python这座大厦的地基，地基不牢，后面学面向对象、函数式编程、异步编程都会觉得处处别扭。把这一章的内容吃透，不是记住语法就完了，而是要把"每个操作符底层在做什么""每个类型在内存里长什么样"刻在脑子里。写代码的时候自然就知道该怎么选、怎么避坑。我在带新人时最常说的一句话是：不要急着学下一个特性，先把今天讲的这些，在不看文档的情况下写一遍，跑一遍，故意写错再改对一遍，比读十遍教程都有用。
