Python基础快速复习

⚡ 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) # 13 print(10 / 3) # 3.3333333333333335 print(0.1 + 0.2 == 0.3) # False print(3 + 4j) # (3+4j)

字符串是不可变序列,支持单引号、双引号、三引号定义。常用操作:

  • 拼接:+ 或 join()
  • 格式化:%、str.format()、f-string(推荐)
  • 常用方法:strip()、split()、replace()、find()

示例:

name = " Alice " print(name.strip()) # "Alice" print("Hello" + " " + name.strip()) # "Hello Alice" age = 25 print(f"Name: {name.strip()}, Age: {age}") # Name: Alice, Age: 25

列表(list)与元组(tuple)均为序列,区别在于:列表可变,元组不可变。切片语法为 [start:end:step](左闭右开)。

lst = [10, 20, 30, 40, 50] print(lst[1:4]) # [20, 30, 40] print(lst[::2]) # [10, 30, 50] print(lst[::-1]) # [50, 40, 30, 20, 10](反转) tup = ("a", "b", "c") print(tup[1]) # "b"

⚠️ 注意:元组的“不可变”指其引用不可变,但若元素为可变对象(如列表),其内容仍可修改:

tup = ([1, 2], "x") tup[0].append(3) print(tup) # ([1, 2, 3], 'x')

控制流结构

Python支持 if、for、while 控制结构,注意缩进表示代码块,无大括号。

# if-elif-else score = 85 if score >= 90: grade = "A" elif score >= 80: grade = "B" else: grade = "C" # for循环(遍历序列) for i in [1, 2, 3]: print(i * 2) # 2, 4, 6 # while循环 n = 5 while n > 0: print(n) n -= 1 # 5,4,3,2,1

特别注意:Python无原生 switch-case,但可用字典映射模拟:

def handle(cmd): return { "start": "Starting...", "stop": "Stopping...", "pause": "Paused." }.get(cmd, "Unknown command")

推导式与生成器

列表推导式、集合推导式、字典推导式是Python高阶写法的核心,显著提升代码简洁性与可读性。

# 列表推导式:[表达式 for 变量 in 可迭代对象 if 条件] squares = [i ** 2 for i in range(1, 6)] print(squares) # [1, 4, 9, 16, 25] # 带条件过滤 evens = [i for i in range(10) if i % 2 == 0] print(evens) # [0, 2, 4, 6, 8] # 字典推导式 pairs = {i: i ** 2 for i in range(3)} print(pairs) # {0: 0, 1: 1, 2: 4} # 生成器表达式(用圆括号) gen = (i ** 2 for i in range(5)) print(list(gen)) # [0, 1, 4, 9, 16]

⚙️ 数据结构深度解析

数据结构是程序设计的核心。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)) # 0(默认值) d["job"] = "Engineer" # 添加键值对 for k, v in d.items(): print(f"{k}: {v}")

集合(set)是无序不重复元素集,支持数学集合运算(交集、并集、差集),常用于去重与成员测试。

s = {1, 2, 2, 3} print(s) # {1, 2, 3}(自动去重) a = {1, 2, 3} b = {2, 3, 4} print(a & b) # 交集:{2, 3} print(a | b) # 并集:{1, 2, 3, 4} print(a - b) # 差集:{1} # 成员测试:O(1)时间复杂度 print(2 in s) # True

⚠️ 注意:集合元素必须可哈希(不可变对象),因此不能包含列表、字典等。

双端队列(collections.deque)

当需要高效在头部/尾部插入/删除元素时,list 的 pop(0) 操作为 O(n),而 deque 的 appendleft() 和 popleft() 均为 O(1)。

from collections import deque dq = deque([1, 2, 3]) dq.appendleft(0) # [0, 1, 2, 3] dq.append(4) # [0, 1, 2, 3, 4] dq.popleft() # 返回0,dq变为[1, 2, 3, 4]

⚡ 函数式编程核心

Python虽非纯函数式语言,但提供了丰富的函数式编程工具:lambda、map、filter、reduce、sorted 等。掌握这些工具可显著提升代码的表达力与简洁性。

高阶函数与lambda

高阶函数:可接收函数作为参数或返回函数的函数。典型代表:map()、filter()、sorted()。

# map(func, iterable):对每个元素应用函数 nums = [1, 2, 3, 4] squares = list(map(lambda x: x ** 2, nums)) print(squares) # [1, 4, 9, 16] # filter(func, iterable):保留满足条件的元素 evens = list(filter(lambda x: x % 2 == 0, nums)) print(evens) # [2, 4] # sorted(iterable, key=func, reverse=bool) words = ["apple", "banana", "cherry"] print(sorted(words, key=lambda w: len(w))) # ['apple', 'banana', 'cherry'](按长度升序)

闭包与装饰器

闭包:内层函数引用外层函数的变量(非全局),形成“记忆”效果。

def outer(): count = 0 def inner(): nonlocal count count += 1 return count return inner counter = outer() print(counter()) # 1 print(counter()) # 2

装饰器:本质是闭包,用于在不修改原函数代码的前提下扩展功能(如日志、权限校验)。

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")) # Calling: greet # Hello, 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))) # [0, 1, 1, 2, 3, 5, 8]

⚙️ 面向对象编程(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()) # "Buddy makes a sound."

继承与方法重写

class Dog(Animal): def speak(self): # 重写父类方法 return f"{self.name} barks." cat = Dog("Whiskers") print(cat.speak()) # "Whiskers barks."

魔术方法(特殊方法)

以 __ 开头和结尾的方法,用于自定义类行为。常见用法:

__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) # (3, 4)

比较操作:__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) # True

迭代控制:__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) # 1, 2, 3

属性装饰器(@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) # 30(作为属性访问) p.age = 31 # 调用setter

⚡ 异常处理机制

异常处理是程序健壮性的关键。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)) # 输出: No exceptions, Cleanup code, 5.0 print(safe_divide(10, 0)) # 输出: Error: Division by zero, Cleanup code, None

自定义异常

继承 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) # Age out of range

⚙️ 标准库高频模块

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")) # 2024-06-15 14:30:22 # 时间计算 tomorrow = now + timedelta(days=1) print(tomorrow.strftime("%Y-%m-%d"))

数据序列化与反序列化:JSON用于轻量级数据交换,CSV用于表格数据。

import json, csv # JSON data = {"name": "Alice", "scores": [95, 88, 92]} json_str = json.dumps(data, indent=2) print(json_str) # 解析 parsed = json.loads(json_str) # CSV(写入) 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) # 移除最久未使用项