Python 基础语法
本章将深入介绍 Python 的基础语法，包括变量、数据类型、运算符和字符串操作。这些是 Python 编程的基石，掌握好这些内容对于后续学习至关重要。
变量与赋值
变量是存储数据的容器。Python 的变量系统有几个重要特点：动态类型、强类型、引用语义。
变量创建与赋值
# 基本赋值
age = 18
name = "张三"
price = 19.99
# 多重赋值
a, b, c = 1, 2, 3
# 交换变量值（Python 特有的优雅写法）
a, b = b, a
# 链式赋值
x = y = z = 0
# 解包赋值
coordinates = (10, 20)
x, y = coordinates
变量命名规范
Python 的变量命名遵循 PEP 8 规范：
# 推荐的命名方式
user_name = "张三" # 小写字母 + 下划线（snake_case）
max_connections = 100 # 多个单词用下划线连接
_private_var = "私有" # 单下划线开头表示私有
# 不推荐但合法的命名
userName = "张三" # 驼峰命名（更常见于类名）
# 常量（约定全大写）
MAX_SIZE = 100
PI = 3.14159
# 命名规则
# 1. 只能包含字母、数字、下划线
# 2. 不能以数字开头
# 3. 区分大小写
# 4. 不能使用关键字
Python 关键字列表：
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
动态类型与强类型
Python 是动态类型语言，变量不需要声明类型，且可以随时改变类型：
x = 10 # x 是整数
x = "hello" # x 变成字符串
x = [1, 2, 3] # x 变成列表
Python 同时是强类型语言，不会自动进行不兼容类型的运算：
# 强类型示例
a = "hello"
b = 10
# c = a + b # TypeError: 不能将字符串和整数相加
# 需要显式转换
c = a + str(b) # "hello10"
变量的引用语义
Python 变量存储的是对象的引用（指针），而不是对象本身：
# 可变对象的引用
list1 = [1, 2, 3]
list2 = list1 # list2 指向同一个列表
list2.append(4)
print(list1) # [1, 2, 3, 4] - list1 也被修改了
# 不可变对象
a = 10
b = a
b = 20 # b 指向新对象，a 不变
print(a) # 10
数据类型详解
Python 的数据类型分为两大类：不可变类型和可变类型。
不可变类型
不可变类型的对象创建后，其值不能被修改。
整数（int）
Python 的整数没有大小限制，可以表示任意大的数：
# 普通整数
a = 100
b = -50
# 大整数（Python 自动处理）
big_number = 10 ** 100 # 10 的 100 次方
print(big_number) # 可以正确显示
# 不同进制表示
binary = 0b1010 # 二进制，等于 10
octal = 0o12 # 八进制，等于 10
hexadecimal = 0xA # 十六进制，等于 10
# 进制转换
print(bin(10)) # '0b1010'
print(oct(10)) # '0o12'
print(hex(10)) # '0xa'
浮点数（float）
浮点数遵循 IEEE 754 标准，使用 64 位双精度：
# 浮点数表示
pi = 3.14159
price = 19.99
scientific = 1.5e10 # 科学计数法：15000000000.0
negative = -2.5e-3 # -0.0025
# 浮点数精度问题
print(0.1 + 0.2) # 0.30000000000000004（不是精确的 0.3）
# 精确计算使用 decimal
from decimal import Decimal
a = Decimal('0.1')
b = Decimal('0.2')
print(a + b) # 0.3（精确结果）
字符串（str）
字符串是不可变的字符序列：
# 字符串创建
s1 = 'hello'
s2 = "world"
s3 = '''多行
字符串'''
s4 = """也是多行
字符串"""
# 原始字符串（不转义）
path = r'C:\Users\name' # 反斜杠不需要转义
regex = r'\d+\.\d+' # 正则表达式
# 字节字符串
byte_str = b'hello' # bytes 类型
# 字符串是不可变的
s = "hello"
# s[0] = 'H' # TypeError: 不能修改
s = "Hello" # 创建新字符串，变量重新绑定
元组（tuple）
元组是不可变的序列：
# 元组创建
point = (10, 20)
single = (1,) # 单元素元组需要逗号
empty = ()
# 元组解包
x, y = point
print(x, y) # 10 20
# 命名元组
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y) # 10 20
布尔值（bool）
# 布尔值
is_active = True
is_deleted = False
# 布尔运算
print(True and False) # False
print(True or False) # True
print(not True) # False
# 其他类型转布尔
print(bool(0)) # False
print(bool(1)) # True
print(bool("")) # False
print(bool("hello")) # True
print(bool([])) # False
print(bool([1, 2])) # True
可变类型
可变类型的对象创建后，其值可以被修改。
列表（list）
列表是可变的有序序列：
# 列表创建
fruits = ["苹果", "香蕉", "橙子"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True] # 可以混合类型
# 列表操作
fruits.append("葡萄") # 添加元素
fruits.insert(0, "草莓") # 插入元素
fruits.remove("香蕉") # 删除元素
last = fruits.pop() # 弹出最后一个元素
fruits[0] = "西瓜" # 修改元素
# 列表切片
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4]) # [1, 2, 3]
print(numbers[:3]) # [0, 1, 2]
print(numbers[3:]) # [3, 4, 5]
print(numbers[::2]) # [0, 2, 4]（步长为 2）
print(numbers[::-1]) # [5, 4, 3, 2, 1, 0]（反转）
字典（dict）
字典是键值对的无序集合：
# 字典创建
person = {
"name": "张三",
"age": 25,
"city": "北京"
}
# 访问元素
print(person["name"]) # 张三
print(person.get("job", "无")) # 无（键不存在时返回默认值）
# 添加/修改元素
person["email"] = "[email protected]"
person["age"] = 26
# 删除元素
del person["city"]
email = person.pop("email")
# 遍历
for key in person:
print(key, person[key])
for key, value in person.items():
print(key, value)
集合（set）
集合是无序的不重复元素集合：
# 集合创建
fruits = {"苹果", "香蕉", "橙子"}
numbers = set([1, 2, 2, 3, 3]) # {1, 2, 3}（自动去重）
# 集合操作
fruits.add("葡萄")
fruits.remove("香蕉")
# 集合运算
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b) # 并集: {1, 2, 3, 4}
print(a & b) # 交集: {2, 3}
print(a - b) # 差集: {1}
类型检查与转换
# 类型检查
x = 10
print(type(x)) # <class 'int'>
print(isinstance(x, int)) # True
# 类型转换
print(int("123")) # 123
print(float("3.14")) # 3.14
print(str(123)) # "123"
print(list("hello")) # ['h', 'e', 'l', 'l', 'o']
print(tuple([1, 2, 3])) # (1, 2, 3)
print(set([1, 2, 2])) # {1, 2}
运算符详解
算术运算符
a, b = 10, 3
print(a + b) # 13 - 加法
print(a - b) # 7 - 减法
print(a * b) # 30 - 乘法
print(a / b) # 3.333... - 除法（总是返回浮点数）
print(a // b) # 3 - 整除（向下取整）
print(a % b) # 1 - 取余
print(a ** b) # 1000 - 幂运算
# 整除的特殊行为
print(-7 // 3) # -3（向下取整，不是 -2）
print(7 // -3) # -3
# 取余的特殊行为
print(-7 % 3) # 2（余数与除数同号）
print(7 % -3) # -2
比较运算符
# 基本比较
print(5 == 5) # True
print(5 != 3) # True
print(5 > 3) # True
print(5 < 3) # False
print(5 >= 5) # True
print(5 <= 3) # False
# 链式比较
x = 5
print(1 < x < 10) # True（等价于 1 < x and x < 10）
print(1 < x > 0) # True
# 对象比较
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b) # True（值相等）
print(a is b) # False（不是同一个对象）
print(a is c) # True（同一个对象）
逻辑运算符
# and、or、not
print(True and True) # True
print(True and False) # False
print(True or False) # True
print(not True) # False
# 短路求值
def func():
print("执行了")
return True
False and func() # func() 不会执行
True or func() # func() 不会执行
# 返回实际值（不只是布尔值）
print(0 and "hello") # 0（第一个假值）
print(1 and "hello") # "hello"（第二个值）
print("" or "default") # "default"（第一个假值，返回第二个）
print("hello" or "default") # "hello"（第一个真值）
位运算符
a, b = 5, 3 # 二进制: 5 = 101, 3 = 011
print(a & b) # 1 - 按位与: 001
print(a | b) # 7 - 按位或: 111
print(a ^ b) # 6 - 按位异或: 110
print(~a) # -6 - 按位取反
print(a << 1) # 10 - 左移: 1010
print(a >> 1) # 2 - 右移: 010
# 位运算应用
# 判断奇偶
def is_odd(n):
return n & 1 == 1
# 交换两个数
a, b = 1, 2
a ^= b
b ^= a
a ^= b
print(a, b) # 2 1
运算符优先级
从高到低：
| 优先级 | 运算符 |
|---|---|
| 1 | ** |
| 2 | +x, -x, ~x |
| 3 | *, /, //, % |
| 4 | +, - |
| 5 | <<, >> |
| 6 | & |
| 7 | ^ |
| 8 | | |
| 9 | ==, !=, <, >, <=, >= |
| 10 | not |
| 11 | and |
| 12 | or |
# 建议使用括号明确优先级
result = (2 + 3) * 4 # 20，而不是 14
字符串操作
字符串方法
s = " Hello, World! "
# 大小写转换
print(s.lower()) # " hello, world! "
print(s.upper()) # " HELLO, WORLD! "
print(s.title()) # " Hello, World! "
print(s.capitalize()) # " hello, world! "
# 去除空白
print(s.strip()) # "Hello, World!"
print(s.lstrip()) # "Hello, World! "
print(s.rstrip()) # " Hello, World!"
# 查找和替换
print(s.find("World")) # 9（返回索引）
print(s.replace("World", "Python")) # " Hello, Python! "
# 分割和连接
text = "apple,banana,orange"
fruits = text.split(",") # ['apple', 'banana', 'orange']
print("-".join(fruits)) # "apple-banana-orange"
# 判断方法
print("hello".startswith("he")) # True
print("hello".endswith("lo")) # True
print("123".isdigit()) # True
print("hello".isalpha()) # True
print("hello123".isalnum()) # True
字符串格式化
name = "张三"
age = 25
score = 95.5
# f-string（推荐，Python 3.6+）
print(f"姓名：{name}，年龄：{age}")
print(f"成绩：{score:.1f}") # 保留一位小数
print(f"二进制：{age:b}") # 二进制表示
# format 方法
print("姓名：{}，年龄：{}".format(name, age))
print("姓名：{n}，年龄：{a}".format(n=name, a=age))
# % 格式化（旧式）
print("姓名：%s，年龄：%d" % (name, age))
print("成绩：%.1f" % score)
# 格式化对齐
print(f"{name:>10}") # 右对齐，宽度 10
print(f"{name:<10}") # 左对齐
print(f"{name:^10}") # 居中
print(f"{age:05d}") # 前导零填充：00025
字符串编码
# 字符串与字节转换
text = "你好"
bytes_data = text.encode('utf-8') # 编码
print(bytes_data) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
decoded = bytes_data.decode('utf-8') # 解码
print(decoded) # 你好
# 获取字符编码
print(ord('A')) # 65
print(chr(65)) # 'A'
输入输出
基本输出
# print 函数
print("Hello, World!")
print("Hello", "World", sep="-") # Hello-World
print("Hello", end=" ")
print("World") # Hello World
# 格式化输出
name = "张三"
print(f"你好，{name}！")
基本输入
# input 函数返回字符串
name = input("请输入姓名：")
print(f"你好，{name}！")
# 转换输入类型
age = int(input("请输入年龄："))
price = float(input("请输入价格："))
# 读取多行输入
lines = []
print("请输入多行文本，输入空行结束：")
while True:
line = input()
if line == "":
break
lines.append(line)
小结
本章我们学习了：
- 变量：动态类型、强类型、引用语义
- 数据类型：不可变类型（int、float、str、tuple、bool）和可变类型（list、dict、set）
- 运算符：算术、比较、逻辑、位运算及其优先级
- 字符串操作：方法、格式化、编码
- 输入输出：print 和 input 函数
关键要点：
- 理解可变与不可变类型的区别
- 掌握字符串的各种操作方法
- 熟悉运算符优先级，必要时使用括号
- 使用 f-string 进行字符串格式化
练习
- 编写程序，输入两个数，输出它们的和、差、积、商
- 编写程序，判断一个年份是否是闰年
- 编写程序，将一个列表中的重复元素去除
- 编写程序，统计字符串中各字符出现的次数
- 编写程序，实现简单计算器（加减乘除）