文章目录

• 2. 输出：让程序"说话"
• 3. 输入：让程序"倾听"
• 4. 变量：数据的"小盒子"
• 5. 运算符：数据的"加工厂"
• 6. 综合实战：一个简单的计算器
• 7. 总结

1. 引言

本章要点

• 掌握核心概念：理解输入、输出、变量和运算符在Python编程中的基础地位
• 明确学习路径：从"是什么"、“为什么”、"怎么用"三个角度系统学习每个知识点
• 实践导向：通过动手敲代码加深理解，观察输出结果变化
• 打好基础：为后续学习循环、函数、面向对象等更复杂概念奠定坚实基础

欢迎来到 Python 编程的世界！对于零基础的你来说，掌握输入、输出、变量和运算符是开启编程之旅的第一步。它们是构建任何程序的基础积木，就像学习汉语要先学拼音和笔画一样重要。

为什么这些概念如此重要？

• 输出（print）：这是程序与用户沟通的桥梁，没有输出，程序就像哑巴一样，你无法知道它做了什么。
• 输入（input）：让程序能够接收外部信息，实现交互功能，比如登录系统、计算器、游戏等都需要输入。
• 变量：计算机内存中的"储物柜"，用来临时存储数据，是程序处理信息的基础。
• 运算符：对数据进行加工处理的"工具"，没有运算符，变量中的数据就无法被计算和操作。

本文将用最通俗易懂的语言，配合大量实例和实用技巧，带你彻底搞懂这些核心概念。每个知识点都会从"是什么"、“为什么”、"怎么用"三个角度详细解析，确保你不仅会用，还能理解背后的原理。

学习建议：建议边读边动手敲代码，实践是学习编程最快的方式。遇到不理解的地方可以多运行几次代码，观察输出结果的变化。

2. 输出：让程序“说话”

在 Python 中，我们使用 print() 函数来让程序输出信息，就像让程序“说话”一样。

2.1 基本用法

print() 函数是 Python 中最基础、最常用的函数之一。它的作用是将括号内的内容输出到控制台（屏幕）。

语法格式

print(要输出的内容)

详细示例

# 示例1：输出字符串
print("Hello, World!")

# 示例2：输出数字
print(123)
print(3.14)

# 示例3：输出布尔值
print(True)
print(False)

# 示例4：输出空行
print()  # 输出一个空行
print("")  # 输出空字符串，效果类似但略有不同

运行结果分析

print("Hello, World!")

运行这段代码，你会在屏幕上看到：

Hello, World!

技术细节：

• print() 函数会自动在输出内容的末尾添加换行符（\n），所以每次调用 print() 都会在新的一行开始输出。
• 如果要取消自动换行，可以使用 end 参数：print("Hello", end="")，这样就不会换行。

常见错误

# 错误写法：缺少括号（Python 2.x 语法，Python 3.x 已废弃）
print "Hello"  # 会报错：SyntaxError: Missing parentheses

# 正确写法
print("Hello")

练习建议

尝试修改上面的代码：

1. 将 “Hello, World!” 改成其他问候语
2. 尝试输出不同类型的数字（整数、小数）
3. 连续调用多个 print() 函数，观察输出效果

2.2 输出多个内容

print() 函数可以一次输出多个内容，只需要用逗号 , 将它们隔开即可。Python 会自动在它们之间加上一个空格作为分隔符。

基本语法

print(内容1, 内容2, 内容3, ...)

详细示例

# 示例1：混合输出不同类型的数据
print("我的名字是", "小明", "今年", 18, "岁")

# 示例2：输出数学表达式的结果
print("1 + 2 =", 1 + 2)

# 示例3：输出多个变量
name = "张三"
age = 20
score = 95.5
print("学生信息：", "姓名：", name, "年龄：", age, "分数：", score)

# 示例4：输出列表元素
fruits = ["苹果", "香蕉", "橙子"]
print("我喜欢的水果有：", fruits[0], fruits[1], fruits[2])

输出结果：

我的名字是 小明 今年 18 岁
1 + 2 = 3
学生信息： 姓名： 张三 年龄： 20 分数： 95.5
我喜欢的水果有： 苹果 香蕉 橙子

自定义分隔符

默认情况下，print() 用空格分隔多个参数，但你可以通过 sep 参数自定义分隔符：

# 使用逗号作为分隔符
print("2024", "01", "15", sep="-")  # 输出：2024-01-15

# 使用斜杠作为分隔符
print("usr", "local", "bin", sep="/")  # 输出：usr/local/bin

# 不使用分隔符
print("Hello", "World", sep="")  # 输出：HelloWorld

# 使用特殊字符作为分隔符
print("●", "Python", "基础", sep="→")  # 输出：●→Python→基础

同时使用 sep 和 end 参数

# 自定义分隔符和结束符
print("第一行", "内容", sep=" | ", end="\n---\n")
print("第二行", "内容", sep=" | ")

输出：

第一行 | 内容
---
第二行 | 内容

实际应用场景

1. 格式化输出表格数据：

print("姓名", "年龄", "成绩", sep="\t")
print("张三", 20, 95.5, sep="\t")
print("李四", 21, 88.0, sep="\t")

2. 生成文件路径：

folder = "documents"
filename = "report"
extension = "pdf"
print(folder, filename, extension, sep="/", end=".")

注意事项

• 逗号分隔的是 print() 函数的参数，不是字符串的一部分
• 每个参数可以是任意类型（字符串、数字、变量、表达式等）
• 参数之间会自动添加空格，除非通过 sep 参数指定其他分隔符

2.3 格式化输出

在实际编程中，我们经常需要将变量的值嵌入到字符串中一起输出，这就是字符串格式化。Python 提供了多种格式化方法，各有优缺点。

方法一：使用 + 拼接（字符串连接）

这是最直观的方法，适合简单的字符串拼接。

name = "小红"
age = 20
print("她的名字是" + name + "，今年" + str(age) + "岁。")

优点：

• 语法简单，容易理解
• 适合少量字符串拼接

缺点：

• 需要手动转换非字符串类型（如数字）
• 代码可读性差，特别是拼接多个变量时
• 性能相对较低（每次 + 都会创建新的字符串对象）

注意：使用 + 拼接时，数字类型（如 age）需要先用 str() 函数转换成字符串，否则会报错 TypeError: can only concatenate str (not "int") to str。

方法二：使用 % 格式化（旧式格式化）

这是 Python 2 时代的主流方法，现在仍然可用。

name = "小红"
age = 20
score = 95.5

# 基本用法
print("她的名字是%s，今年%d岁。" % (name, age))

# 格式化浮点数
print("她的分数是%.2f分" % score)  # 保留两位小数

# 格式化多个值
print("姓名：%s，年龄：%d，分数：%.1f" % (name, age, score))

格式说明符：

• %s：字符串
• %d：整数
• %f：浮点数
• %.2f：保留两位小数的浮点数

方法三：使用 str.format() 方法（Python 2.6+）

这是 Python 2.6 引入的格式化方法，比 % 格式化更强大。

name = "小红"
age = 20
score = 95.5

# 位置参数
print("她的名字是{}，今年{}岁。".format(name, age))

# 命名参数
print("她的名字是{name}，今年{age}岁。".format(name=name, age=age))

# 格式化数字
print("分数：{:.2f}".format(score))  # 保留两位小数
print("年龄：{:03d}".format(age))    # 补零到3位：020

# 对齐和填充
print("{:<10} | {:>10}".format("左对齐", "右对齐"))
print("{:*^20}".format("居中"))      # 用*填充，居中显示

方法四：使用 f-string（Python 3.6+，推荐）

这是 Python 3.6 以后引入的非常强大的格式化方式。只需在字符串前加上 f 或 F，然后在字符串内部用 {} 包裹变量名即可。

name = "小红"
age = 20
score = 95.5

# 基本用法
print(f"她的名字是{name}，今年{age}岁。")

# 在 {} 内进行运算
a = 10
b = 20
print(f"{a} + {b} = {a + b}")
print(f"{a} 的平方是 {a ** 2}")

# 调用函数和方法
print(f"名字大写：{name.upper()}")
print(f"年龄类型：{type(age)}")

# 格式化数字
print(f"分数：{score:.2f}")      # 保留两位小数
print(f"百分比：{score:.1%}")    # 显示为百分比
print(f"科学计数法：{score:.2e}") # 科学计数法

# 对齐和填充
print(f"{name:<10} | {age:>5}")  # 左对齐10字符，右对齐5字符
print(f"{'居中':*^20}")           # 用*填充，居中显示20字符

# 使用表达式
print(f"明年年龄：{age + 1}")
print(f"是否成年：{'是' if age >= 18 else '否'}")

# 嵌套使用
width = 10
precision = 2
value = 12.34567
print(f"结果：{value:{width}.{precision}f}")

输出结果：

她的名字是小红，今年20岁。
10 + 20 = 30
10 的平方是 100
名字大写：小红
年龄类型：<class 'int'>
分数：95.50
百分比：95.5%
科学计数法：9.55e+01
小红        |    20
********居中********
明年年龄：21
是否成年：是
结果：     12.35

方法对比总结

方法	优点	缺点	适用场景
+ 拼接	简单直观	需要类型转换，性能差	简单拼接少量字符串
% 格式化	兼容性好	语法较旧，不够灵活	维护旧代码
str.format()	功能强大，灵活	语法稍复杂	Python 2.6-3.5 项目
f-string	简洁高效，可读性好	需要 Python 3.6+	现代 Python 项目首选

高级技巧：多行 f-string

# 多行 f-string
name = "小明"
age = 22
hobbies = ["编程", "读书", "运动"]

message = f"""
个人信息报告
============
姓名：{name}
年龄：{age}
状态：{'成年' if age >= 18 else '未成年'}
爱好：{', '.join(hobbies)}
爱好数量：{len(hobbies)}
"""
print(message)

练习建议

1. 尝试用四种方法格式化同一个字符串，比较它们的写法
2. 练习使用 f-string 的各种格式化选项（对齐、填充、数字格式等）
3. 创建一个包含多个变量的个人信息表，用 f-string 格式化输出

3. 输入：让程序“倾听”

程序不能总是自说自话，它还需要能接收用户输入的信息。在 Python 中，我们使用 input() 函数来实现。

3.1 基本用法

input() 函数会暂停程序的运行，等待用户在键盘上输入内容，然后按回车键结束。它会把用户输入的内容作为字符串返回。

name = input("请输入你的名字：")
print(f"你好，{name}！欢迎来到Python世界。")

运行效果：

请输入你的名字：张三
你好，张三！欢迎来到Python世界。

3.2 输入数字

input() 返回的永远是字符串。如果你需要用户输入一个数字并进行数学运算，必须使用 int() 或 float() 函数进行类型转换。

age_str = input("请输入你的年龄：")
age = int(age_str)  # 将字符串转换为整数
print(f"明年你就{age + 1}岁了。")

更简洁的写法是直接转换：

age = int(input("请输入你的年龄："))
print(f"明年你就{age + 1}岁了。")

4. 变量：数据的“小盒子”

变量是用于存储数据的容器。你可以把它想象成一个带有标签的“小盒子”，标签就是变量名，盒子里装的就是数据。

4.1 变量的命名规则

给变量起名需要遵守一些规则：

1. 只能包含：字母（a-z, A-Z）、数字（0-9）和下划线（_）。
2. 不能以数字开头：1name 是错误的，name1 是正确的。
3. 区分大小写：Name 和 name 是两个不同的变量。
4. 不能使用 Python 的保留关键字：例如 if、for、while、print 等。

推荐命名风格：使用有意义的英文单词，多个单词之间用下划线连接（蛇形命名法），例如 user_name、total_score。

4.2 变量的赋值

使用等号 = 来给变量赋值。等号左边是变量名，右边是要存储的数据。

# 给变量赋值
name = "李四"
age = 25
height = 1.75
is_student = True

# 打印变量
print(name)
print(age)
print(height)
print(is_student)

4.3 变量的类型

Python 是一种动态类型语言，这意味着你不需要事先声明变量的类型，Python 会根据你赋的值自动推断。

常见的数据类型有：

类型	描述	示例
int	整数	10, -5, 0
float	浮点数（小数）	3.14, -0.5, 1.0
str	字符串（文本）	"你好", 'Python'
bool	布尔值（真假）	True, False

你可以使用 type() 函数来查看一个变量的类型：

a = 100
b = 3.14
c = "Hello"
d = True

print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(c))  # <class 'str'>
print(type(d))  # <class 'bool'>

5. 运算符：数据的“加工厂”

有了数据（变量），我们还需要对它们进行各种操作，运算符就是用来完成这些操作的“工具”。

5.1 算术运算符

用于执行基本的数学运算。

运算符	描述	示例	结果
+	加	10 + 3	13
-	减	10 - 3	7
*	乘	10 * 3	30
/	除（结果是浮点数）	10 / 3	3.333...
//	整除（取商的整数部分）	10 // 3	3
%	取余（取余数）	10 % 3	1
**	幂运算	2 ** 3	8

示例：

a = 15
b = 4

print(f"a + b = {a + b}")   # 19
print(f"a - b = {a - b}")   # 11
print(f"a * b = {a * b}")   # 60
print(f"a / b = {a / b}")   # 3.75
print(f"a // b = {a // b}") # 3
print(f"a % b = {a % b}")   # 3
print(f"a ** b = {a ** b}") # 50625

5.2 赋值运算符

用于给变量赋值。除了基本的 =，还有一些复合赋值运算符，可以简化代码。

运算符	描述	示例	等价于
=	简单赋值	x = 5	x = 5
+=	加后赋值	x += 3	x = x + 3
-=	减后赋值	x -= 3	x = x - 3
*=	乘后赋值	x *= 3	x = x * 3
/=	除后赋值	x /= 3	x = x / 3
//=	整除后赋值	x //= 3	x = x // 3
%=	取余后赋值	x %= 3	x = x % 3
**=	幂后赋值	x **= 3	x = x ** 3

示例：

count = 10
count += 5  # 等价于 count = count + 5
print(count) # 15

count *= 2  # 等价于 count = count * 2
print(count) # 30

5.3 比较运算符

用于比较两个值，结果是一个布尔值（True 或 False）。

运算符	描述	示例	结果
==	等于	5 == 5	True
!=	不等于	5 != 3	True
>	大于	5 > 3	True
<	小于	5 < 3	False
>=	大于等于	5 >= 5	True
<=	小于等于	5 <= 3	False

示例：

age = 18
print(age == 18)  # True
print(age > 20)   # False
print(age != 20)  # True

5.4 逻辑运算符

用于组合多个条件，结果也是一个布尔值。

运算符	描述	示例	解释
and	与（且）	条件1 and 条件2	两个条件都为 True，结果才为 True
or	或	条件1 or 条件2	至少一个条件为 True，结果就为 True
not	非（取反）	not 条件	条件为 True 则结果为 False，反之亦然

示例：

score = 85
is_graduated = True

# 判断是否满足获奖条件：分数大于80 且 已毕业
if score > 80 and is_graduated:
    print("恭喜你获得优秀毕业生奖！")

# 判断是否可以进入复试：分数大于90 或 有特殊推荐
if score > 90 or is_graduated:
    print("你已进入复试名单。")

# 判断是否未毕业
if not is_graduated:
    print("你尚未毕业。")

5.5 运算符优先级

当表达式中包含多个运算符时，Python 会按照一定的优先级顺序进行计算。了解运算符优先级可以避免因计算顺序不当导致的错误。

运算符优先级表（从高到低）

优先级	运算符	描述	结合性
1	()	括号	从左到右
2	**	幂运算	从右到左
3	+x, -x	正负号（一元运算符）	从右到左
4	*, /, //, %	乘、除、整除、取余	从左到右
5	+, -	加、减	从左到右
6	==, !=, >, <, >=, <=	比较运算符	从左到右
7	not	逻辑非	从右到左
8	and	逻辑与	从左到右
9	or	逻辑或	从左到右
10	=, +=, -=, *=, /=, //=, %=, **=	赋值运算符	从右到左

记忆口诀：括号 > 幂运算 > 正负号 > 乘除 > 加减 > 比较 > 逻辑非 > 逻辑与 > 逻辑或 > 赋值。

代码示例：优先级如何影响计算结果

示例 1：算术运算符优先级

# 没有括号的情况：先乘除，后加减
result1 = 2 + 3 * 4  # 3 * 4 = 12，然后 2 + 12 = 14
print(f"2 + 3 * 4 = {result1}")  # 输出：14

# 使用括号改变优先级
result2 = (2 + 3) * 4  # 2 + 3 = 5，然后 5 * 4 = 20
print(f"(2 + 3) * 4 = {result2}")  # 输出：20

# 幂运算优先级高于乘除
result3 = 2 ** 3 * 2  # 2 ** 3 = 8，然后 8 * 2 = 16
print(f"2 ** 3 * 2 = {result3}")  # 输出：16

result4 = 2 * 3 ** 2  # 3 ** 2 = 9，然后 2 * 9 = 18
print(f"2 * 3 ** 2 = {result4}")  # 输出：18

示例 2：混合运算符优先级

# 算术 > 比较 > 逻辑
a = 5
b = 10
c = 15

# 先计算算术，再比较，最后逻辑运算
result1 = a + b > c and b * 2 == 20
# 等价于：(5 + 10) > 15 and (10 * 2) == 20
#         15 > 15 and 20 == 20
#         False and True
#         False
print(f"a + b > c and b * 2 == 20: {result1}")  # 输出：False

# 使用括号明确优先级
result2 = (a + b > c) and (b * 2 == 20)
print(f"(a + b > c) and (b * 2 == 20): {result2}")  # 输出：False

# 逻辑非优先级高于逻辑与
flag1 = True
flag2 = False
result3 = not flag1 and flag2  # 先 not flag1 = False，然后 False and flag2 = False
print(f"not flag1 and flag2: {result3}")  # 输出：False

result4 = not (flag1 and flag2)  # 先 flag1 and flag2 = False，然后 not False = True
print(f"not (flag1 and flag2): {result4}")  # 输出：True

最佳实践：使用括号明确优先级

虽然 Python 有明确的运算符优先级规则，但在实际编程中，强烈建议使用括号来明确计算顺序，原因如下：

1. 提高代码可读性：括号让计算顺序一目了然，其他人（包括未来的你）更容易理解代码意图。
2. 避免潜在错误：即使你熟悉优先级规则，复杂的表达式也容易出错。括号可以消除歧义。
3. 减少记忆负担：不需要记住所有优先级规则，用括号明确表达即可。

推荐写法：

# 不推荐的写法（依赖优先级记忆）
result = a + b * c / d - e % f

# 推荐的写法（使用括号明确优先级）
result = a + (b * c / d) - (e % f)

# 更清晰的写法（多级括号）
result = (a + ((b * c) / d)) - (e % f)

实际应用示例：

# 计算圆的面积和周长
import math

radius = 5

# 不使用括号（依赖优先级）
area1 = math.pi * radius ** 2  # 正确：幂运算优先级高于乘法
circumference1 = 2 * math.pi * radius

# 使用括号（更清晰）
area2 = math.pi * (radius ** 2)
circumference2 = 2 * math.pi * radius  # 乘法优先级相同，从左到右计算，括号可选

print(f"半径 {radius} 的圆面积：{area1:.2f}")
print(f"半径 {radius} 的圆周长：{circumference1:.2f}")

# 复杂表达式示例
x = 10
y = 3
z = 5

# 难以理解的写法
result1 = x % y * z + y ** 2 - x / y

# 使用括号明确优先级
result2 = ((x % y) * z) + (y ** 2) - (x / y)

print(f"复杂表达式结果：{result2}")

总结建议：

• 对于简单的表达式，可以依赖默认优先级（如 a + b * c）。
• 对于包含 3 个或更多运算符的表达式，建议使用括号。
• 当混合使用算术、比较和逻辑运算符时，一定要使用括号。
• 不确定优先级时，就用括号！这不会影响性能，只会让代码更清晰。

记住：清晰的代码比聪明的代码更重要。使用括号可以让你的代码更易于阅读和维护。

6. 综合实战：一个简单的计算器

让我们把今天学到的所有知识结合起来，写一个简单的计算器程序。

# 1. 获取用户输入
print("欢迎使用简易计算器！")
num1 = float(input("请输入第一个数字："))
operator = input("请输入运算符（+、-、*、/）：")
num2 = float(input("请输入第二个数字："))

# 2. 进行计算并输出结果
if operator == "+":
    result = num1 + num2
elif operator == "-":
    result = num1 - num2
elif operator == "*":
    result = num1 * num2
elif operator == "/":
    if num2 != 0:
        result = num1 / num2
    else:
        result = "错误：除数不能为0！"
else:
    result = "错误：不支持的运算符！"

# 3. 输出结果
print(f"计算结果：{num1} {operator} {num2} = {result}")

运行示例：

欢迎使用简易计算器！
请输入第一个数字：10
请输入运算符（+、-、*、/）：*
请输入第二个数字：5
计算结果：10.0 * 5.0 = 50.0

7. 总结

恭喜你！你已经掌握了 Python 编程的四大基石：

• 输出 (print())：让程序与你交流。
• 输入 (input())：让程序接收你的指令。
• 变量：存储和操作数据的容器。
• 运算符：对数据进行加工的工具。

这些知识虽然基础，但非常重要。它们是构建更复杂程序（如循环、函数、面向对象编程）的根基。请务必动手敲一遍代码，只有实践才能真正掌握。加油，未来的 Python 大师！