Python 基础语法：变量、类型、运算符与输入输出详解

2.1 变量定义与使用

语法：变量名 = 数据，= 是赋值运算符（将右侧数据存入左侧变量）。

# 以下代码在求四个数字的方差
average = (67.5 + 73.5 + 54 + 86) / 4
# ** 表示乘方，**2 即求平方
total = (67.5 - average)**2 + (73.5 - average)**2 + (54 - average)**2 + (86 - average)**2
# 除以项数 -1
result = total / 3
print(result)

• average, total, result 均为变量；
• ** 表示乘方，**2 即求平方；
• 变量可重复赋值，新值会覆盖旧值。

a = 10
print(a)  # 输出：10
a = 20
print(a)  # 输出：20

变量可以视为是一块能够容纳数据的空间，这个空间往往对应到'内存'这样的硬件设备上。

2.2 变量命名规则

正确的变量命名示例：

# 合法的命名
a = 10
a1 = 10
a_09 = 9

硬性规则（必须遵守）：

• 由字母、数字、下划线构成，不能以数字开头；
• 不能与 Python 关键字（如 print、if）重复；
• 大小写敏感（num 和 Num 是两个不同变量）。

软性规则（建议遵守）：

• 用有描述性的单词（如 avg 表示平均值，total 表示总和）；
• 多单词用驼峰命名法（如 personInfo、totalCount），首字母小写，后续单词首字母大写；
• 或者用 person_info、total_count 这样的写法（蛇形命名）。

这里我用的变量名还是 a，b 这种是因为场景比较简单，也没啥需要特殊含义的表示。

数据类型：给数据'分类'

变量存储的数据有不同类型，类型决定了数据的存储方式和可执行的操作。Python 无需显式声明类型，赋值时自动确定（动态类型特性）。注意：和 C++/Java 等语言不同，Python 变量的类型不需要显示指定，而是在赋值的时候确定的。

3.1 四大基础类型

（1）整数（int）

• 表示整数，无范围上限（内存足够即可）；
• 用法：a = 10、b = -5、c = 1000000000000。

（2）浮点数（float）

• 表示小数，Python 中只有 float（等价于其他语言的 double，双精度，精确到小数点后 15 位）；
• 用法：a = 0.5、b = 67.5、c = 3.1415926。

（3）字符串（str）

• 表示文本，用单引号 ' ' 或双引号 " " 包裹（两者等价）；
• 核心操作：

a = 'hello'
b = "world"
print(len(a))  # 输出：5（len() 函数获取字符串长度）
print(a + b)   # 输出：helloworld（+ 表示字符串拼接）

• 注意：字符串不能与整数 / 浮点数直接相加。

（4）布尔值（bool）

• 表示'真 / 假'，仅两个取值：True（真）、False（假）；
• 用法：a = True、b = False，常用于逻辑判断。

3.2 类型相关操作

• 查看类型：type(变量) 函数；
• 类型转换：int()、float()、str()、bool()；
• 动态类型特性：变量类型可在运行中改变（双刃剑，灵活但需谨慎）。
  • 对于中小程序，可以大大的减少代码量 (比如写一段代码就可以同时支持多个类型)；
  • 对于大型程序，则提高了模块之间的交互成本 (程序员 A 提供的代码难以被 B 理解)。

a = 10
print(type(a))
b = 0.5
print(type(b))
# 双引号和单引号都可以
c = 'hello'
print(type(c))
d = "hello"
print(type(d))
e = 'My name is "Lotso" '
print(type(e))
f = ''' My 'name' is "Lotso" '''
print(f)
print(len(d))
a1 = 'hello'
a2 = 'world'
print(a1 + a2)
c1 = True
c2 = False
print(type(c1))
print(type(c2))
# 输出结果：<class 'int'><class 'float'><class 'str'><class 'str'><class 'str'> My 'name'is"Lotso"5 helloworld <class 'bool'><class 'bool'>

注释：给代码'加说明'

注释是不执行的代码，用于解释程序逻辑，方便自己和他人理解。

4.1 两种注释语法

（1）单行注释

用 # 开头，注释整行：

# 计算 4 个数字的方差（单行注释）
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4

（2）文档字符串（多行注释）

用三引号 """ """ 或 ''' ''' 包裹，支持多行：

""" 这是文档字符串（多行注释）
功能：计算 4 个分数的方差
步骤：1. 求平均值 2. 计算平方和 3. 求方差
"""
total = (67.5 - avg)**2 + (89.0 - avg)**2
result = total / 3

4.2 注释规范

• 内容准确：注释内容要和代码一致，匹配，并在代码修改时及时更新；
• 篇幅合理：注释不要太精简也不要太冗长，点到为止；
• 使用中文：国内开发首选中文注释；
• 积极向上：避免负能量内容。

输入输出：与用户交互

程序需要接收用户输入，再展示结果，核心用 input()（输入）和 print()（输出）函数。

• 用户把信息传递给程序的过程，称为'输入'。
• 程序把结果展示给用户的过程，称为'输出'。

输入输出最基本的方法就是控制台，用户通过控制台输入一些字符串，程序再通过控制台打印出一些字符串。

5.1 输出（print 函数）

• 输出变量 / 常量：print(变量名) 或 print(常量)；
• 格式化输出（推荐 f-string，这个就和 C++/Java 不一样了）：用 f'字符串 {变量}' 内嵌变量 / 表达式：

a = 10
print(a)
b = 'hello'
print(b)
c = True
print(c)
a = 10
# 希望使用 print 打印出 "a = 10" 这样的内容
# 我们希望把数字和字符串混在一起打印
print(f"a = {a}")
print(f"a = {a + 10}")

5.2 输入（input 函数）

• 语法：变量 = input('提示信息')；
• 注意：input() 的返回值是字符串类型，需手动转换为其他类型才能进行算术运算：

# 通过控制台，来输入一个数据
# num = input("Enter a number: ")
# # 这个类型始终是一个 str，如果需要计算就要转换
# print(type(num))
# print(f"num = {num}")
# 输入两个数，计算他们相加的结果
a = input('Enter the First number: ')
b = input('Enter the Second number: ')
# a = int(a)
# b = int(b)
# print(f"a + b = {a + b}")
print(f"a + b = {int(a) + int(b)}")

5.3 实操案例：求 4 个小数的平均值

# 输入四个小数，求这四个小数的平均值
a = input('Enter the First number: ')
b = input('Enter the Second number: ')
c = input('Enter the Third number: ')
d = input('Enter the Fourth number: ')
a = float(a)
b = float(b)
c = float(c)
d = float(d)
avg = (a + b + c + d) / 4
print(f"The average is: {avg}")

运算符：Python 的'运算工具库'

除了算术运算符，Python 还有关系运算符、逻辑运算符、赋值运算符等，覆盖各类运算需求。

6.1 算术运算符（补充）

除了 +，-，*，/ 基础运算，还有 3 个常用运算符：

• %：求余数（不是百分数）：print(7 % 2) → 输出 1；
• **：求乘方：print(4 ** 2) → 输出 16，print(4 ** 0.5) → 输出 2.0（开平方）；
• //：取整除法（向下取整，舍弃小数）：print(7 // 2) → 3，print(-7 // 2) → -4。

result = (1 + 2) * 3
print(f"result = {result}")
# 注意一：在 Python 中，0 不能作为除数，否则会抛出异常
# print(f"10 / 0 = {10 / 0}")
# print(f"10 / 0.0 = {10 / 0.0}")
# 报错信息
# Traceback (most recent call last):
# File "D:\Gitee.code\python-fundamentals-\PythonProject\2025--11--18\code10.py", line 5, in <module>
# print(f"10 / 0 = {10 / 0}")
# ~~~^~~
# ZeroDivisionError: division by zero
# 注意二：在 Python 中整数除以整数，结果可能是小数，而不会截断
print(f"1 / 2 = {1 / 2}")
# 注意三：% 表示求余数，余数不可能大于除数
print(f"7 % 3 = {7 % 3}")
# 注意四：** 表示乘方语言，既能支持乘方，也能支持开方
print(f"4 ** 2 = {4 ** 2}")
print(f"4 ** 0.5 = {4 ** 0.5}")
# 注意五：// 地板除法 (取整除法)，会针对计算的结果进行'向下取整'
print(f"7 // 2 = {7 // 2}")
print(f"-7 // 2 = {-7 // 2}")

6.2 关系运算符（比较运算）

用于比较两个操作数之间的关系，返回布尔值（True/False）：

注意：

• 字符串可比较（按字典序）：'hello' < 'world' → True；
• 支持连续小于或者大于这类写法 a < b < c；
• 浮点数不要用 == 判断相等（存在精度误差，在误差范围内就是 True,False）：

# a = 10
# b = 20
# a = 'hello'
# b = 'world'
# 中文也可以比较，但是没有意义
# a = '你好'
# b = '世界'
# print(a < b)
# print(a > b)
# print(a <= b)
# print(a >= b)
# print(a == b)
# print(a != b)
print(0.1 + 0.2 == 0.3)
print(0.1)
print(0.2)
print(0.1 + 0.2)
print(0.3)
a = 0.1 + 0.2
b = 0.3
# 这个代码是看 a - b 差是否是一个非常小的数字，是否在误差范围之内
# python 是支持这种写法的，C++/Java 都不行
print(-0.000001 < (a - b) < 0.000001)

6.3 逻辑运算符（组合判断）

用于组合多个关系判断，返回布尔值：

• and：并且（一假则假）：10 < 20 and 20 < 30 → True；
• or：或者（一真则真）：10 > 20 or 20 < 30 → True；
• not：逻辑取反：not 10 < 20 → False。

短路求值（很重要，而且 C++ 和 Java 都有这个）：

• and 左侧为 False 时，右侧不再执行；
• or 左侧为 True 时，右侧不再执行：

实战代码：

a = 10
b = 20
c = 30
# 并且 (一假即为假)
# print(a < b and b < c) # 简化
print(a < b < c)
print(a < b and b > c)
# 或者 (一真则为真)
print(a > b or b < c)
print(a < b or b > c)
print(a > b or b < c)
# 逻辑取反
print(not a < b)
print(not a > b)
# 短路规则
# a > b 为假，后面的直接不计算，所以不会报错
print(a > b and 10 / 0 == 1)
# a < b 为真，后面的直接不计算，所以不会报错
print(a < b or 10 / 0 == 1)

6.4 赋值运算符

• 基础赋值：a = 10；
• 链式赋值：a = b = 10（a 和 b 都赋值为 10）；
• 多元赋值：a, b = 10, 20（快速交换变量：a, b = b, a）；
• 复合赋值：a += 1（等价于 a = a + 1），同理还有 -=、*=、/=、%=、**=、//=。

注意： Python 没有 ++、-- 自增 / 自减运算符，用 a += 1、a -= 1 替代。

实操代码：

# # 链式赋值
# a = b = 20
# # 多元赋值
# a, b = 10, 20
a = 10
b = 20
# 实现交换 a,b 的逻辑
# tmp = a
# a = b
# b = tmp
# print(a, b)
# 使用多元赋值，直接一步到位完成交换
a, b = b, a
print(a, b)

a = 10
a = a + 1
a += 1
# -=, *=, /=, **=, %=, //= # ++a # a++ # --a
print(a)

• 当然按除了上述之外，Python 还有一些其他的运算符，比如身份运算符 (is,is not)，成员运算符 (in,not in)，位运算符 (&|~^<<>>) 等，大家感兴趣的可以自己先去了解一下。

常见坑点总结与自测练习

7.1 常见坑点

1. 除法结果默认是小数，需整数结果用 //；
2. 字符串不能与数字直接相加，需先转换类型；
3. 浮点数比较相等用'误差范围'，而非 ==；
4. input() 返回字符串，算术运算前必须转换类型；
5. 变量命名不能以数字开头，不能与关键字重复。

7.2 自测练习

结语

Python 基础语法的核心是'简洁直观'，变量、类型、运算符、输入输出是搭建所有程序的基石。掌握这些内容后，你就能编写简单的计算程序、与用户交互的脚本，为后续学习循环、判断、函数打下基础。建议多动手实操案例，尤其是运算符的避坑场景（如浮点数比较、字符串拼接），通过练习巩固语法记忆。如果遇到报错，先查看变量类型、运算符使用是否正确，大部分入门问题都能快速解决。