Python从入门到实战（二）：数据类型与运算符

目录

一、 输入与输出基础

1. input 函数的运行机制

2. print 函数的基本用法

二、Python 数据类型

1. 数据类型概述与类型检测

2. 整型与数值机制

3. 为什么 4300 位整数会报错？

4. 浮点型

5. 布尔型

三、字符串基础

1. 字符串的定义方式

2. 转义字符

3. 字符串格式化输出

四、数据类型转换

1. 隐式类型转换

2. 显式类型转换

五、Python 运算符

1. 算术运算符

2. 赋值运算符

3. 比较运算符

4. 逻辑运算符

5. 运算符优先级

六、Python 中的进制

1.进制表示

2. 内置进制转换函数

总结

一、 输入与输出基础

在 Python 程序开发中，与用户进行交互是最基础的功能。程序需要接收外部输入的数据，经过内部逻辑处理后，再将结果呈现给用户。这一过程主要依赖于内置函数 input() 和 print()

1. input 函数的运行机制

input() 函数用于阻塞程序运行并等待用户从标准输入（通常是键盘）中读取内容。其基本语法结构如下：

variable = input("提示信息：")

接收标准输入与阻塞机制

当程序执行到 input() 函数时，控制台会显示括号内的提示字符串，并暂停执行（阻塞）。此时，程序会持续等待，直到用户在控制台输入完成并按下回车键。接收到回车信号后，input() 会读取用户输入的所有字符，并将其作为一个整体赋值给左侧的变量，随后程序恢复向下执行

核心原理解析：为什么 input返回值始终为字符串类型

无论用户在控制台输入的是整数、浮点数、布尔值，还是其他任何形式的内容，input() 函数的返回值始终是字符串类型

这是因为在计算机底层，标准输入流是以字符流的形式传输数据的。Python 为了保证安全性和通用性，不会对用户的输入做盲目的隐式类型转换，而是将输入内容原封不动地打包成字符串

我们可以通过以下代码来验证这一行为：

# 即使输入数字 100 user_data = input("请输入一个数字：") print(type(user_data)) # 输出结果：<class 'str'>

由于返回的是字符串，若直接将其用于算术运算，将会引发类型错误（TypeError）。例如，执行 user_data + 10 会导致程序崩溃。因此，在后续处理数值计算时，必须配合显式类型转换使用

2. print 函数的基本用法

print() 函数负责将指定的数据或变量输出到标准输出设备（通常是屏幕控制台）。它可以同时接收多个参数，并支持通过关键字参数自定义输出格式

其常用完整语法如下：

print(value1, value2, ..., sep=' ', end='\n')

• 多对象输出：可以用逗号 , 分隔多个变量或常量，print() 会依次将它们打印在同一行

• sep 参数（分隔符）：用于定义多个输出对象之间的连接字符，默认值是一个空格

• end 参数（结束符）：用于定义输出完毕后的终止字符，默认值是换行符 \n。如果希望连续多次调用 print 却不换行，可以将 end 修改为空字符串或其他字符

基本代码示例：

name = "Alice" age = 25 # 1. 基础输出 print(name) # 2. 输出多个对象，默认以空格分隔 print("姓名：", name, "年龄：", age) # 输出：姓名： Alice 年龄： 25 # 3. 修改分隔符 sep print("2026", "07", "02", sep="-") # 输出：2026-07-02 # 4. 修改结束符 end 避免换行 print("Hello", end=" ") print("World") # 输出：Hello World（两句在同一行显示）

二、Python 数据类型

在 Python 中，变量不需要显式声明类型，类型是在运行时根据赋值自动确定的。这种特性被称为动态类型机制。然而，变量所指向的对象本身具有严格的数据类型，这决定了该对象可以参与哪些运算

1. 数据类型概述与类型检测

为了确保程序逻辑的正确性，Python 提供了内置函数 type()，用于在运行时动态检测对象的数据类型

# 示例：通过 type() 函数获取对象类型 x = 10 y = 3.14 print(type(x)) # 输出：<class 'int'> print(type(y)) # 输出：<class 'float'>

type() 的返回值是一个类对象（如 <class 'int'>），它准确反映了当前变量在内存中所指向的数据形态

2. 整型与数值机制

Python 中的整型用于表示不带小数点的正整数、负整数和零。与其他编译型语言（如 C、Java）不同，Python 的整型具有非常独特的内存管理机制

Python 的大整数自动扩容机制

在 C 语言中，整型受到计算机硬件限制，超出范围就会发生溢出。而 Python 3 中的 int 类型是变长对象。其底层实现为一个结构体，内部使用数组来存储数字的位。 这意味着 Python 的整数理论上没有大小限制，只要计算机的内存足够，它就可以自动扩容以存储任意大小的整数

# 计算 2 的 100 次幂，Python 可以直接精确展示 large_num = 2 ** 100 print(large_num) # 输出：1267650600228229401496703205376

3. 为什么 4300 位整数会报错？

既然 Python 理论上支持无限大的整数，那么通过幂运算构建一个极大的数值并打印它，会出现什么结果呢？我们尝试运行以下代码：

a = 9 ** 9999 # 计算 9 的 9999 次方 print(a) # 打印变量 a

运行上述代码后，控制台并没有如预期般输出结果，而是触发了如下错误：

报错信息明确提及了 "Exceeds the limit (4300 digits)"（超过了 4300 位的限制）。但需要特别注意的是：这并不代表 Python 最大只能表示 4300 位的数字

为了验证这一点，如果我们把 print(a) 这一行删掉，只保留纯数学运算：

a = 9 ** 9999 # 9 的 9999 次方 b = a + 100 # 让大整数直接参与数学运算

此时再次运行程序，会发现代码正常运行，没有抛出任何错误。这说明变量 a 在内存中是完全可以被正常存储并参与后续数学运算的

为什么加上 print(a) 就会报错？

导致报错的核心原因在于类型的转换过程：

当调用 print(a) 打印一个整型对象时，Python 底层需要先将该数字的类型转换为字符串类型，然后才能输出到控制台

自 Python 3.11 版本起，为了应对超长数字转换时可能引发的拒绝服务攻击等安全隐患，Python 对 "超大整数转换为字符串" 的长度进行了限制，默认上限即为4300 位。由于 9 ** 9999 计算出的结果远超 4300 位，因此在由 int 转换为 str 的阶段被拦截并报错

扩展知识

在实际开发中，如果确有特殊业务场景需要突破这一安全限制，可以通过标准库中的 sys 模块来解除 4300 位的转换限制：

import sys # 将限制设置为 0，表示不做任何转换长度限制 sys.set_int_max_str_digits(0) x = 9 ** 9999 # 9 的 9999 次方 print(x) # 此时可以正常打印出完整的超大整数

4. 浮点型

浮点型用于表示带有小数部分的数字，在 Python 中统一由双精度浮点数实现

IEEE 754 标准与精度

Python 的 float 底层遵循IEEE 754 双精度浮点数标准（占用 64 位二进制空间）。由于计算机内部使用二进制存储数据，许多十进制有限小数在二进制下是无限循环小数。因此，浮点数运算可能会出现微小的精度偏差

print(0.1 + 0.2) # 输出：0.30000000000000004

在编写程序时，应避免直接使用运算符来判断两个浮点数是否相等。对于高精度计算（如金融数据），应使用 Python 标准库中的 decimal 模块

5. 布尔型

布尔型用于表示逻辑上的真与假，它只有两个字面量值：True 和 False（注意首字母必须大写）

布尔值的本质

在 Python 内部，布尔型（bool）是整型（int）的一个子类。其中 True 的底层数值存储为 1，False 的底层数值存储为 0。这意味着布尔值可以直接参与算术运算，但在实际开发中并不推荐这样做，应当保持其逻辑属性

print(True + 1) # 输出：2 print(False * 5) # 输出：0 # 验证子类关系 print(isinstance(True, int)) # 输出：True

三、字符串基础

在 Python 中，字符串是用于存储和表示文本数据的基本数据类型。作为一种序列类型，字符串在日常开发中的文本处理、日志记录和数据输出中被广泛使用

1. 字符串的定义方式

Python 提供了高度灵活的字符串定义方式，允许使用单引号、双引号或三引号来声明文本

• 单引号与双引号：在表达单行文本时，这两者在语法上完全等价

• 三引号（三个单引号 ' ' ' 或三个双引号 " " "）：支持编写多行字符串，并且能够完整保留文本内的换行符和空格格式。此外，三引号也常用于编写函数的类文档字符串

# 单引号与双引号定义 str1 = 'Hello Python' str2 = "Hello Python" # 三引号定义多行文本 str3 = """第一行内容 第二行内容 第三行内容"""

引号的嵌套

如果字符串内部本身包含引号，可以通过交替使用单双引号来避免语法冲突，而不需要使用转义字符。例如：

# 字符串内部含有单引号，外部则使用双引号 sentence = "It's a beautiful day."

2. 转义字符

转义字符用于在字符串中表示一些无法直接输入的特殊字符（如换行、制表符）或者具有特殊语法含义的字符（如引号本身）。转义字符统一以反斜杠开头

常用转义字符表

原始字符串

在处理 Windows 文件路径或正则表达式时，文本中往往包含大量的反斜杠。为了防止这些反斜杠被 Python 误判定为转义字符，可以在字符串的第一个引号前加上字母 r 或 R，将其声明为原始字符串。在原始字符串中，所有的转义字符都将失去特殊含义，转为普通字符输出

# 错误示范：\t 会被识别为制表符 path1 = "C:\user\test\new_file.txt" # 正确做法：使用 r 声明原始字符串 path2 = r"C:\user\test\new_file.txt" print(path2) # 输出：C:\user\test\new_file.txt

3. 字符串格式化输出

在输出文本时，经常需要将变量动态地嵌入到字符串的指定位置。Python 提供了多种格式化输出的机制

传统占位符格式化

这是源自 C 语言 printf 的传统格式化方式。通过在字符串中使用 %s（字符串）、%d（整数）、%f（浮点数）等占位符，并在字符串末尾通过 % 传入具体的变量

name = "张三" age = 18 print("该同学名叫 %s，今年 %d 岁。" % (name, age))

格式化精度控制

在使用占位符或格式化机制时，可以通过数字来精准控制数据的显示宽度和浮点数的小数位数。其标准格式为 %[宽度].[精度]f：

pi = 3.1415926 # 控制保留两位小数（会进行四舍五入） print("圆周率：%.2f" % pi) # 输出：3.14 # 控制总宽度为 8 位，小数保留 2 位（宽度不足时左侧补空格） print("数字：'%8.2f'" % pi) # 输出：' 3.14'

现代格式化机制：f-string (推荐)

自 Python 3.6 版本起，引入了更为高效、直观的 f-string（格式化字符串字面量）。它的写法是在字符串前加上字母 f 或 F，并在字符串内部使用 {variable} 直接引用变量

f-string 不仅代码可读性极高，而且在底层运行效率上也显著优于 % 表达式

name = "李四" score = 92.6 # 基础 f-string 应用 print(f"学生：{name}，期末成绩：{score}") # f-string 中的精度控制 print(f"期末成绩精确到整数：{score:.0f}") # 输出：93

四、数据类型转换

在实际开发中，不同数据类型之间的交互频繁发生。例如，通过 input() 获取的字符串数字无法直接参与数学运算，必须将其转换为数值类型。Python 提供了隐式类型转换与显式类型转换两种机制来解决这一问题

1. 隐式类型转换

隐式类型转换是指 Python 解释器在执行表达式运算时，自动将一种数据类型提升为另一种更为通用的类型，以防止数据精度丢失。这一过程无需开发者手动干预

• 触发场景：通常发生在低精度数值（如 int）与高精度数值（如 float）进行混合算术运算时

• 转换规则：Python 会自动将 int 转换为 float，运算结果亦为 float 类型

num_int = 10 # 整型 num_float = 3.5 # 浮点型 # 隐式转换发生，num_int 自动提升为 10.0 参与运算 result = num_int + num_float print(result) # 输出：13.5 print(type(result)) # 输出：<class 'float'>

字符串类型（str）与数值类型（int/float）之间不能触发隐式类型转换。执行 "10" + 5 会直接引发 TypeError

2. 显式类型转换

显式类型转换是指开发者通过调用 Python 的内置构造函数，手动将某个对象强制转换为目标数据类型

① int(x, [base])：转换为整型

用于将其他类型的数据转换为整数

• 浮点数转整型：直接截断小数部分（不进行四舍五入，仅保留整数位）

• 字符串转整型：字符串内部必须是纯纯的合法数字，否则会报错

• 参数 base：若转换对象是字符串，可传入第二个参数表示原数据的进制基数（详见后文进制部分）

print(int(3.9)) # 输出：3（截断小数） print(int("-15")) # 输出：-15 # 错误示范：字符串内含有非数字字符，无法强制转换 # print(int("3.14")) # 报错 ValueError # print(int("abc")) # 报错 ValueError

② float(x)：转换为浮点型

用于将整数或符合数值规范的字符串转换为浮点数。

• 整数转换后会自动在末尾补 .0

print(float(10)) # 输出：10.0 print(float("3.14")) # 输出：3.14 print(float("1e3")) # 输出：1000.0（支持科学计数法字符串）

③ str(x)：转换为字符串型

用于将任何其他数据类型转换为文本字符串格式。这是一个万能转换函数，几乎所有 Python 对象都可以被成功转换为字符串形态

print(str(100)) # 输出："100" print(str(3.14)) # 输出："3.14" print(str(True)) # 输出："True"

④ bool(x)：转换为布尔型

在 Python 中，所有对象在需要逻辑判断的环境下，都会隐式或显式地被识别为 True 或 False。通过 bool() 函数可以检测一个对象的布尔本质

Python 的规则非常简单：绝大多数对象都是 True，只有 "空值" 或 "零值" 会被判定为 False

被判定为 False 的常见核心对象包括：

1. 常量：None、False

2. 数值中的零值：0、0.0

3. 空的容器/序列：""（空字符串）、[]（空列表）、()（空元组）、{}（空字典）

# 以下转换结果均为 False print(bool(0)) print(bool(0.0)) print(bool("")) # 以下转换结果均为 True print(bool(1)) print(bool(" ")) # 包含空格的字符串不是空字串 print(bool("False")) # 这是一个非空字符串

五、Python 运算符

运算符是用于对变量和数据执行特定计算的符号。Python 提供了丰富的运算符，涵盖了从基础算术到复杂的逻辑控制

1. 算术运算符

算术运算符用于执行基本的数学计算。Python 的算术运算符在处理除法时具有特殊的行为

注意：使用 // 对负数进行整除时，同样遵循向下取整原则。例如 -5 // 2 的结果是 -3，而不是 -2

2. 赋值运算符

赋值运算符用于将右侧表达式的值存储到左侧的变量中。除了标准赋值运算符 = 之外，Python 还支持复合赋值运算符，以便简化代码

3. 比较运算符

比较运算符用于判断两个对象之间的大小关系，其计算结果固定为布尔值

4. 逻辑运算符

逻辑运算符用于连接多个布尔表达式，常用于控制流语句的条件判断

短路求值

Python 的 and 和 or 运算符具有短路特性。这意味着它们在运行过程中，一旦能够提前确定整个表达式的结果，就会立即停止后续的计算，并返回最后计算的那个表达式的值（不一定是布尔值）

• and的短路：如果左侧表达式为 False，整个表达式必然为 False，此时系统不再计算右侧表达式，直接返回左侧的值

• or 的短路：如果左侧表达式为 True，整个表达式必然为 True，系统直接返回左侧的值，不再执行右侧代码

# and 短路示例：左侧为 0 (False)，不再看右侧，直接返回 0 print(0 and "hello") # 输出：0 # or 短路示例：左侧为 10 (True)，不再看右侧，直接返回 10 print(10 or "world") # 输出：10

5. 运算符优先级

当一个复杂的表达式中包含多种运算符时，Python 解释器会按照既定的优先级从高到低依次进行计算。

以下是常用运算符的优先级由高到低排列（同一行优先级相同）：

1. （幂运算最高）

2. *, /, //, % （乘除集群）

3. +, - （加减集群）

4. >, <, >=, <=, ==, != （比较运算符）

5. not （逻辑非）

6. and （逻辑与）

7. or （逻辑或最低）

尽管 Python 底层有严格的优先级限制，但在编写包含复杂逻辑的表达式时，强烈建议使用括号显式指定计算顺序。这不仅能避免逻辑错误，还能显著提升代码的可读性。例如，使用
(a > 10) and (b < 5) 比直接书写 a > 10 and b < 5 更为严谨清晰

六、Python 中的进制

在计算机科学中，除了我们日常使用的十进制之外，二进制、八进制和十六进制也是常见的数据表示形式。Python 提供了对多进制数据的原生支持，并内置了便捷的转换函数

1.进制表示

在 Python 代码中，可以直接通过特定的前缀来书写不同进制的整数。Python 会在底层自动将它们识别并存储为整型对象。

• 二进制 (Binary)：使用前缀 0b 或 0B，逢二进一，包含数字 0 和 1

• 八进制 (Octal)：使用前缀 0o 或 0O，逢八进一，包含数字 0 到 7

• 十六进制 (Hexadecimal)：使用前缀 0x 或 0X，逢十六进一，包含数字 0-9 以及字母 a-f（或 A-F，分别代表 10-15）

2. 内置进制转换函数

Python 提供了两组核心的转换工具：一组用于将十进制整数转换为其他进制的字符串；另一组则用于将其他进制的字符串逆向解析为十进制整数

十进制转其他进制 (bin() / oct() / hex())

这三个内置函数接收一个十进制整型作为参数，并返回对应进制的字符串表示（自带进制前缀）

• bin(num)：转换为二进制字符串

• oct(num)：转换为八进制字符串

• hex(num)：转换为十六进制字符串

number = 45 print(bin(number)) # 输出："0b101101" print(oct(number)) # 输出："0o55" print(hex(number)) # 输出："0x2d" # 注意：返回值均为字符串类型 print(type(hex(number))) # 输出：<class 'str'>

其他进制转十进制

在前文数据类型转换中提到，int(string, base) 函数拥有一个隐藏的 base 参数。当我们需要将一个表示特定进制的字符串转换为十进制整数时，可以指定 base 的值（即进制基数）

# 1. 解析二进制字符串（base=2） print(int("101101", 2)) # 输出：45 # 2. 解析十六进制字符串（base=16） print(int("2d", 16)) # 输出：45 # 3. 自动识别前缀：如果字符串自带 0b/0x 等前缀，base 设置为 0 可以让 Python 自动识别 print(int("0x2d", 0)) # 输出：45

总结

我们在本篇详细探讨了 Python 的核心基础语法。我们首先理解了控制台交互的 input() 与 print() 函数，明确了输入流默认返回字符串的底层逻辑。随后，我们深入探讨了 Python 的数据类型形态，包括具有自动扩容机制的整型、在 3.11 版本引入 4300 位转换限制的底层安全考量、遵循 IEEE 754 标准的浮点数，以及本质为整型子类的布尔型

同时，我们掌握了高效率的 f-string 字符串格式化技巧，解析了隐式与显式数据类型的转换，并系统梳理了各类运算符的优先级和短路求值特性

掌握了这些核心数据形态与计算规则后，程序已经具备了处理基础数据的能力。在下一篇教程中，我们将正式跨入流程控制的大门，共同探索 Python 中的条件判断语句与循环结构