⚡ Python核心语法速览
Python语法以简洁清晰著称,其设计哲学强调“优雅”、“明确”、“简单”。掌握其基础语法是快速复习的第一步。本节系统梳理变量、数据类型、运算符、控制流等核心语法点,并结合典型示例帮助巩固记忆。
变量与命名规范
Python变量无需声明类型,直接赋值即可。变量命名需遵循:
- 只能包含字母、数字、下划线(不能以数字开头)
- 区分大小写(
name与Name>为不同变量)
- 推荐使用小驼峰(
myVariable)或蛇形(my_variable)命名
示例:count = 10,user_name = "Alice"
数据类型精要
Python内置六大数据类型:数字(int、float、complex)、字符串(str)、列表(list)、元组(tuple)、字典(dict)、集合(set)。其中字符串、列表、元组属于序列类型,支持索引与切片操作。
数字类型包括整型(int)、浮点型(float)和复数(complex)。注意:
- 整型无精度限制(受内存限制)
- 浮点存在精度问题(如
0.1 + 0.2 == 0.3 为 False)
- 复数表示为
a + bj,实部为 a,虚部为 b
print(10 + 3)
print(10 / 3)
print(0.1 + 0.2 == 0.3)
print(3 + 4j)
字符串是不可变序列,支持单引号、双引号、三引号定义。常用操作:
- 拼接:
+ 或 join()
- 格式化:
%、str.format()、f-string(推荐)
- 常用方法:
strip()、split()、replace()、find()
示例:
name = " Alice "
print(name.strip())
print("Hello" + " " + name.strip())
age = 25
print(f"Name: {name.strip()}, Age: {age}")
列表(list)与元组(tuple)均为序列,区别在于:列表可变,元组不可变。切片语法为 [start:end:step](左闭右开)。
lst = [10, 20, 30, 40, 50]
print(lst[1:4])
print(lst[::2])
print(lst[::-1])
tup = ("a", "b", "c")
print(tup[1])
⚠️ 注意:元组的“不可变”指其引用不可变,但若元素为可变对象(如列表),其内容仍可修改:
tup = ([1, 2], "x")
tup[0].append(3)
print(tup)
控制流结构
Python支持 if、for、while 控制结构,注意缩进表示代码块,无大括号。
score = 85
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
else:
grade = "C"
for i in [1, 2, 3]:
print(i * 2)
n = 5
while n > 0:
print(n)
n -= 1
特别注意:Python无原生 switch-case,但可用字典映射模拟:
def handle(cmd):
return {
"start": "Starting...",
"stop": "Stopping...",
"pause": "Paused."
}.get(cmd, "Unknown command")
推导式与生成器
列表推导式、集合推导式、字典推导式是Python高阶写法的核心,显著提升代码简洁性与可读性。
squares = [i ** 2 for i in range(1, 6)]
print(squares)
evens = [i for i in range(10) if i % 2 == 0]
print(evens)
pairs = {i: i ** 2 for i in range(3)}
print(pairs)
gen = (i ** 2 for i in range(5))
print(list(gen))
⚙️ 数据结构深度解析
数据结构是程序设计的核心。Python内置数据结构虽简洁,但其底层实现与操作复杂度直接影响程序性能。本节结合源码思想,详解各结构特性、使用场景及常见陷阱。
列表(list)与元组(tuple)对比
| 特性 |
列表(list) |
元组(tuple) |
| 可变性 |
可变(支持增删改) |
不可变(创建后内容固定) |
| 内存占用 |
较高(预留额外空间) |
较低(紧凑存储) |
| 创建速度 |
较慢 |
更快(常量折叠优化) |
| 典型用途 |
动态集合、需要修改的序列 |
固定数据、字典键、函数返回多值 |
⚠️ 内存优化提示:当数据量大且内容固定时,使用元组可减少约15%内存占用,并提升访问速度。例如:坐标点 (x, y)、RGB颜色值 (r, g, b)。
字典(dict)与集合(set)
字典是Python最强大的内置数据结构之一,基于哈希表实现,平均时间复杂度为 O(1) 的查找。自Python 3.7起,字典保持插入顺序(非哈希序)。
常用操作:
- 创建:空字典
{} 或 dict();字面量 {'a':1, 'b':2}
- 访问:直接索引
d['a'](不存在报错)或 get()(不存在返回默认值)
- 更新:
d.update()、['a'] = new_val
- 遍历:
for k, v in d.items()(键值对)、for k in d(仅键)
d = {"name": "Bob", "age": 30}
print(d.get("height", 0))
d["job"] = "Engineer"
for k, v in d.items():
print(f"{k}: {v}")
集合(set)是无序不重复元素集,支持数学集合运算(交集、并集、差集),常用于去重与成员测试。
s = {1, 2, 2, 3}
print(s)
a = {1, 2, 3}
b = {2, 3, 4}
print(a & b)
print(a | b)
print(a - b)
print(2 in s)
⚠️ 注意:集合元素必须可哈希(不可变对象),因此不能包含列表、字典等。
双端队列(collections.deque)
当需要高效在头部/尾部插入/删除元素时,list 的 pop(0) 操作为 O(n),而 deque 的 appendleft() 和 popleft() 均为 O(1)。
from collections import deque
dq = deque([1, 2, 3])
dq.appendleft(0)
dq.append(4)
dq.popleft()
⚡ 函数式编程核心
Python虽非纯函数式语言,但提供了丰富的函数式编程工具:lambda、map、filter、reduce、sorted 等。掌握这些工具可显著提升代码的表达力与简洁性。
高阶函数与lambda
高阶函数:可接收函数作为参数或返回函数的函数。典型代表:map()、filter()、sorted()。
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, nums))
print(squares)
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)
words = ["apple", "banana", "cherry"]
print(sorted(words, key=lambda w: len(w)))
闭包与装饰器
闭包:内层函数引用外层函数的变量(非全局),形成“记忆”效果。
def outer():
count = 0
def inner():
nonlocal count
count += 1
return count
return inner
counter = outer()
print(counter())
print(counter())
装饰器:本质是闭包,用于在不修改原函数代码的前提下扩展功能(如日志、权限校验)。
def log(func):
def wrapper(*args, **kwargs):
print(f"Calling: {func.__name__}")
return func(*args, **kwargs)
return wrapper
@log
def greet(name):
return f"Hello, {name}!"
print(greet("Alice"))
生成器(yield)
生成器通过 yield 实现惰性计算,避免一次性加载大数据集到内存,适用于流式处理。
def fib(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b
print(list(fib(7)))
⚙️ 面向对象编程(OOP)精要
Python是多范式语言,OOP是其重要组成部分。掌握类定义、继承、魔术方法、描述符等,可构建高内聚、低耦合的代码结构。
类定义与实例化
class Animal:
species = "Animal"
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} makes a sound."
dog = Animal("Buddy")
print(dog.speak())
继承与方法重写
class Dog(Animal):
def speak(self):
return f"{self.name} barks."
cat = Dog("Whiskers")
print(cat.speak())
魔术方法(特殊方法)
以 __ 开头和结尾的方法,用于自定义类行为。常见用法:
__init__ & __str__
比较操作
迭代控制
__init__:构造函数;__str__:定义对象的字符串表示(用于 print());__repr__:调试用的官方字符串表示。
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return f"({self.x}, {self.y})"
p = Point(3, 4)
print(p)
比较操作:__eq__、__lt__、__le__、__gt__、__ge__
class Point:
def __eq__(self, other):
return self.x == other.x and self.y == other.y
p1 = Point(1, 2)
p2 = Point(1, 2)
print(p1 == p2)
迭代控制:__iter__、__next__(需实现迭代器协议)
class Counter:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
return self
def __next__(self):
if self.current > self.end:
raise StopIteration
current = self.current
self.current += 1
return current
for num in Counter(1, 3):
print(num)
属性装饰器(@property)
将方法转为只读属性,实现封装与数据验证。
class Person:
def __init__(self, name, age):
self._name = name
self._age = age
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if value not in range(0, 150):
raise ValueError("Age must be between 0 and 150")
self._age = value
p = Person("Alice", 30)
print(p.age)
p.age = 31
⚡ 异常处理机制
异常处理是程序健壮性的关键。Python通过 try-except-else-finally 结构捕获并处理运行时错误,避免程序崩溃。
def safe_divide(a, b):
try:
result = a / b
except ZeroDivisionError as e:
print("Error: Division by zero")
return None
except TypeError as e:
print("Error: Invalid types")
return None
else:
print("No exceptions")
return result
finally:
print("Cleanup code")
print(safe_divide(10, 2))
print(safe_divide(10, 0))
自定义异常
继承 Exception 类创建自定义异常,用于业务逻辑错误。
class InvalidAgeError(Exception):
pass
def set_age(age):
if age not in range(0, 150):
raise InvalidAgeError("Age out of range")
print("Age set successfully")
try:
set_age(200)
except InvalidAgeError as e:
print(e)
⚙️ 标准库高频模块
Python标准库功能强大,合理使用可避免重复造轮子。本节精选开发者最常用模块,提供核心API速查。
os & pathlib
datetime
json & csv
os 模块提供操作系统接口,pathlib(Python 3.4+)是更现代的路径处理方案。
from pathlib import Path
p = Path("data") / "file.txt"
if p.exists():
print(p.read_text())
Path("logs/2024").mkdir(parents=True, exist_ok=True)
处理日期与时间的核心模块,注意时区处理需结合 zoneinfo(Python 3.9+)。
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))
tomorrow = now + timedelta(days=1)
print(tomorrow.strftime("%Y-%m-%d"))
数据序列化与反序列化:JSON用于轻量级数据交换,CSV用于表格数据。
import json, csv
data = {"name": "Alice", "scores": [95, 88, 92]}
json_str = json.dumps(data, indent=2)
print(json_str)
parsed = json.loads(json_str)
with open("scores.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerow(["Name", "Score"])
writer.writerow(["Alice", 95])
常用第三方库替代方案
当标准库功能不足时,以下第三方库可替代:
- requests:替代
urllib,更简洁的HTTP客户端
- python-dateutil:增强
datetime 功能(相对时间、时区)
- pytz:精准时区处理(Python 3.9+可改用
zoneinfo)
- pandas:结构化数据处理(替代
csv、json 复杂场景)
⚡ 高频面试题精析
根据GitHub、牛客网、LeetCode等平台2024年Python面试题统计,以下问题出现频率最高,附深度解析与参考答案。
Q1: Python GIL是什么?如何规避?
A:GIL(全局解释器锁)是CPython解释器的特性,确保同一时刻只有一个线程执行Python字节码。但I/O操作会释放GIL,因此I/O密集型任务仍可用多线程加速;CPU密集型任务需用多进程(multiprocessing)或C扩展绕过GIL。
Q2: == 与 is 的区别?
A:== 比较值是否相等(调用 __eq__);is 比较对象身份(内存地址是否相同)。例如:1000 == 10**3 为 True,但 1000 is 10**3 可能为 False(整数缓存范围 [-5, 256] 内对象复用)。
Q3: *args 与 **kwargs 用途?
A:*args 接收任意数量位置参数(转为元组);**kwargs 接收任意数量关键字参数(转为字典)。常用于装饰器、函数适配器等。
Q4: 列表推导式 vs map/filter?
A:列表推导式更Pythonic、可读性更高;map/filter 在链式调用时更简洁。性能差异极小,优先选择可读性方案。
Q5: 深拷贝与浅拷贝?
A:copy.copy() 浅拷贝:只复制顶层对象;copy.deepcopy() 深拷贝:递归复制所有嵌套对象。注意:自定义类需实现 __copy__ 和 __deepcopy__ 以支持拷贝。
实战题:实现LRU缓存
使用 collections.OrderedDict 实现经典LRU(Least Recently Used)缓存策略:
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity):
self.cache = OrderedDict()
self.capacity = capacity
def get(self, key):
if key not in self.cache:
return None
self.cache.move_to_end(key)
return self.cache[key]
def put(self, key, value):
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
if len(self.cache) > self.capacity:
self.cache.popitem(last=False)