Java & Python
前言
- 我为啥在学 \(\text{Java}\)
- \(\text{Upd} \space \text{on} \space 26.10.27\):修改 \(\LaTeX\) 并加入 \(\text{Python}\)
- 本文面向 \(\text{C++}\) 基础雄厚的 \(\text{OIer}\)
\(\text{Java}\)
简介
\(\text{Java}\) 是一门通用的、基于类的、面向对象的编程语言,同时它也是一款跨平台的软件,能够实现“一次编写,到处运行”
——\(\text{baidu}\) 百科
组成
- \(\text{Java}\) 是由 \(\text{class}\)(类)和 \(\text{method}\)(方法)组成的
- 首先,我们需要先像 \(\text{C++}\) 一样写一个主函数
public class Main
- 这个其实并不是主函数,而是一个叫
Main的类 - 然后才是主函数(虽说并不是主函数,为了好理解比成主函数)
public class Main
{
public static void main(String[] args)
}
这个
String[] args是命令行参数
——\(\text{LZY}\)
- 输出的话和 \(\text{C++}\) 差不多
System.out.print/*=printf*/
System.out.println/*=puts*/
- 然后你可以写 \(\text{Hello}\space \text{World}\) 了
public class Main
{
public static void main(String[] args)
{
System.out.printf("Hello World!");
}
}
变量
- 和 \(\text{C++}\) 完全一致
int a;
- 不过好像定义“全局变量”后就不能改了
运算
- 和 \(\text{C++}\) 一样,不过好像不支持
++ - \(\text{Upd}\space \text{on} \space 8.22\):支持
++ - 支持位运算
- 逻辑运算符也一样
读入
- 感觉 \(\text{Java}\) 的读入和快读好像
- \(\text{Java}\) 读入需要一个
Scanner类,像 \(\text{C++}\) 头文件一样,\(\text{Java}\) 读入的类也需要一个“头文件”
import java.util.Scanner;
- 写开头就行
- 然后就是读入,看看代码
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
/*打开输入*/
int x=sc.nextInt();
/*像快读一样的输入*/
sc.close();
/*关掉输入*/
System.out.println(x);
}
}
- 和 \(\text{C++}\) 还挺像的
nextLine()/*string*/
nextInt()/*int*/
nextLine().charAt(0)/*相当于读 char*/
- 我们写一道 \(\text{A+B}\space \text{problem}\)
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int x,y;
x=sc.nextInt();
y=sc.nextInt();
sc.close();
int z=x+y;
System.out.println(z);
}
}
选择结构
- 和 \(\text{C++}\) 没区别
循环结构
- 和 \(\text{C++}\) 没区别
woc好省事a
数组
定义
- 这个和 \(\text{C++}\) 有点区别
int[] s={0,1,1,4,5,1,4};
int[] s=new int [5];
- 二维类似
遍历
- 有俩常用的法
- 你可以像 \(\text{C++}\) 一样直接遍历
int[] s={0,1,1,4,5,1,4};
for (int i=1;i<s.length;i++)
System.out.print(s[i]);
- 或者像遍历
vector一样
int[] s={1,1,4,5,1,4};
for (int i:s)
System.out.print(i);
-
默认从第 \(0\) 位开始
-
字符串差不多,介绍一个方法:
s.charAt(x),返回 \(s\) 的第 \(x\) 位字符
\(\text{Python}\)
简介
\(\text{Python}\) 强调简洁、可读性和一致性,采用极简主义设计,鼓励“用一种方法最好只用一种方法完成任务”
——\(\text{baidu}\) 百科
- 我踏马快被 \(\text{Pytnon}\) 弄似了,怎么会有编程语言是只能读入一行字符串啊。。
- 叫蓝色大肥鱼写了点教程,我现在想直接粘过来。。
- 草,不管了直接粘了,回去刷构造了
- (以下是蓝色大肥鱼写的)
本文假设你已掌握 C++ 基础语法(变量、循环、函数、数组、结构体)。
我们会处处与 C++ 对照,重点讲清 Python 的坑与差异。
文中所有代码均可直接运行(Python 3.8+,洛谷使用 PyPy3 / CPython3)。
目录
- Python 与 C++ 的总体差异
- 注释、缩进与代码块
- 变量、类型与类型转换
- 输入输出(重点)
- 运算符
- 控制流
- 字符串
- 容器:list / tuple / dict / set
- 函数
- 类与对象
- 异常处理
- 文件读写
- 常用 import 汇总
- C++ 选手最容易踩的坑
- 竞赛模板
- 语法速查对照表
1. Python 与 C++ 的总体差异
| 维度 | C++ | Python |
|---|---|---|
| 编译 | 编译型,需 g++ 编译 |
解释型,直接 python a.py 运行 |
| 类型 | 静态类型,必须声明 | 动态类型,变量只是"名字" |
| 语句块 | { } |
缩进(通常 4 空格) |
| 语句结束 | ; |
换行即可 |
| 运行速度 | 快 | 慢(约慢 20~100 倍) |
| 整数溢出 | 有(int / long long) |
无,int 任意精度 |
| 数组 | 定长 int a[100] |
动态 list,可随意增长 |
| 内存管理 | 手动 / RAII | 自动垃圾回收 |
| 布尔值 | true / false |
True / False |
| 空值 | NULL / nullptr |
None |
| 逻辑运算 | && || ! |
and or not |
一句话概括:Python 代码更短、写起来更快,但常数因子大,竞赛中要会用 PyPy、会用 sys.stdin、会写高效代码。
2. 注释、缩进与代码块
2.1 注释
# 这是单行注释,相当于 C++ 的 //
"""
这是多行字符串,
通常被当作多行注释使用。
注意它本质是字符串字面量,不是真正的注释。
"""
C++ 的 /* ... */ 在 Python 中没有对应语法,用 """...""" 代替。
2.2 缩进就是语法
// C++
if (x > 0) {
cout << "positive";
} else {
cout << "non-positive";
}
# Python
if x > 0:
print("positive")
else:
print("non-positive")
要点:
- 冒号
:表示"代码块开始",相当于 C++ 的{; - 缩进减少表示"代码块结束",相当于
}; - 同一代码块缩进必须完全一致(建议全用 4 个空格,不要混用 Tab);
- 空行不影响语义,但会结束"续行"。
2.3 一行多条语句
a = 1; b = 2; print(a, b) # 可以,但不推荐
2.4 长表达式换行
total = a + b + c + \
d + e
# 或者在括号内换行(推荐)
total = (a + b + c
+ d + e)
3. 变量、类型与类型转换
3.1 变量不需要声明
// C++
int a = 10;
double b = 3.14;
string s = "hello";
# Python
a = 10 # int
b = 3.14 # float
s = "hello" # str
flag = True # bool
nothing = None # 空值,类似 nullptr
变量名只是"贴在对象上的标签",可以随时改指向别的类型:
x = 10
x = "now I'm a string" # 合法!C++ 中会报错
3.2 常用内置类型
| 类型 | 说明 | C++ 对应 |
|---|---|---|
int |
任意精度整数 | int + long long + __int128 的超集 |
float |
双精度浮点(就是 C++ 的 double) |
double |
bool |
True / False |
bool |
str |
字符串(不可变) | std::string |
list |
动态数组 | std::vector<T> |
tuple |
定长不可变序列 | std::tuple / std::pair |
dict |
哈希表 | std::unordered_map |
set |
哈希集合 | std::unordered_set |
NoneType |
只有一个值 None |
nullptr |
⚠️ Python 没有单独的
char,单个字符就是长度为 1 的str。
⚠️ Python 没有long long,因为int本身就无限大:print(2**100)完全正常。
3.3 查看类型
print(type(3)) # <class 'int'>
print(type(3.0)) # <class 'float'>
print(isinstance(3, int)) # True
3.4 类型转换
int("123") # 123 字符串 -> 整数
int(3.99) # 3 浮点 -> 整数(向零截断,与 C++ 强转一致)
int("0x1f", 16) # 31 按 16 进制解析
float("3.14") # 3.14
str(123) # "123"
bool(0) # False
bool(1) # True
list("abc") # ['a', 'b', 'c']
⚠️
int("12.5")会抛ValueError,必须先float("12.5")再int()。
这与 C++ 的atoi行为不同(C++ 的atoi("12.5")返回 12)。
3.5 常数
INF = float('inf') # 正无穷,类似 C++ 的 1e18 但更大
NEG_INF = -float('inf')
MOD = 10**9 + 7 # 1e9+7 写成 10**9+7 更清晰
import math
math.inf # 同上
math.pi # 3.141592653589793
math.e # 2.718281828459045
注意:
float('inf')是浮点数,不能做%运算;做整数 INF 时仍建议用10**18。
4. 输入输出(重点)
这是 C++ 选手最需要重新学习的地方。Python 的 I/O 与 C++ 完全不同,没有 cin >> 那种"自动跳空白 + 自动转类型"的机制,需要自己组合。
4.1 print 输出
print("hello") # hello
print(1, 2, 3) # 1 2 3 (默认用空格分隔)
print(1, 2, 3, sep=",") # 1,2,3 (自定义分隔符)
print(1, 2, end="") # 12 (不换行)
print(1, 2, end="\n\n") # 12 后空两行
print(a, b) 等价于 C++ 的:
cout << a << ' ' << b << '\n';
⚠️
print(a, " ", b),那会输出a b(多出两个空格)。
要拼接请用print(a, b)或print(f"{a} {b}")或print(str(a) + " " + str(b))。
4.2 input() 读入一行
s = input()
- 读入一整行(不含末尾换行符
\n); - 返回
str类型,永远是字符串,需要自己做类型转换; - 读到文件末尾(EOF)会抛出
EOFError; - 没有 C++ 的
scanf("%d", &x)那种格式串。
n = int(input()) # 读入一个整数,等价 cin >> n(但读的是整行)
x = float(input()) # 读入一个浮点数
s = input() # 读入一整行字符串(可含空格)
4.3 str.split() —— 按空白/指定字符切分
split() 是 Python 处理输入的核心武器,返回一个 list。
line = "1 2 3"
print(line.split()) # ['1', '2', '3']
line = " a b c " # 前后多余空白
print(line.split()) # ['a', 'b', 'c'] ← 自动忽略空串
line = "1,2,3"
print(line.split(",")) # ['1', '2', '3']
line = "1,2,3,4"
print(line.split(",", 2)) # ['1', '2', '3,4'] ← 最多切 2 次
关键区别:
| 写法 | 行为 | C++ 类比 |
|---|---|---|
s.split() |
按任意连续空白分割,丢弃空串,去除首尾空白 | while (cin >> t) |
s.split(",") |
按 , 分割,保留空串 |
手写 getline(ss, t, ',') |
",a,,b,".split(",") # ['', 'a', '', 'b', ''] 注意空串被保留
"".split() # []
"".split(",") # ['']
4.4 map() —— 批量转换
map(f, iterable) 把函数 f 作用到每个元素上,返回一个迭代器。
line = "1 2 3"
nums = list(map(int, line.split())) # [1, 2, 3]
这一句等价于 C++ 的:
// 读入一整行,按空白切成若干整数
vector<int> nums;
int x;
while (cin >> x) nums.push_back(x);
最常用的读入套路:
# 1) 读入一个整数 n
n = int(input())
# 2) 读入一行若干个整数,存成 list
a = list(map(int, input().split()))
# 3) 读入固定个数的变量
x, y, z = map(int, input().split()) # 要求这一行恰好 3 个数
# 4) 读入 n 行,每行一个整数
a = [int(input()) for _ in range(n)]
# 5) 读入 n 行,每行若干整数(邻接矩阵/网格)
g = [list(map(int, input().split())) for _ in range(n)]
# 6) 读入一行字符串(可含空格),拆成字符数组
s = list(input()) # "abc" -> ['a', 'b', 'c']
# 7) 读入一行字符串,按空格切分成单词
words = input().split()
⚠️
x, y, z = map(...)如果这一行数字个数不等于 3,会抛ValueError。
⚠️a = list(map(int, input().split()))只读一行,如果数据跨多行,必须循环。
4.5 多组数据 / 未知行数
# 情况 A:第一行给 T,表示 T 组数据
T = int(input())
for _ in range(T):
n = int(input())
a = list(map(int, input().split()))
# 情况 B:读到文件末尾(EOF)为止
import sys
for line in sys.stdin:
line = line.strip()
if not line:
continue
nums = list(map(int, line.split()))
# 情况 C:while + try/except
while True:
try:
line = input()
except EOFError:
break
print(line)
# 情况 D:一次读入全部内容(最快!)
import sys
data = sys.stdin.buffer.read().split() # list[bytes]
it = iter(data)
n = int(next(it))
a = [int(next(it)) for _ in range(n)]
4.6 大数据量:sys.stdin 快读
input() 每次调用都有开销,10^6 行输入会明显变慢。竞赛中常用:
import sys
input = sys.stdin.readline # 注意:返回的字符串带 '\n'
n = int(input())
a = list(map(int, input().split()))
s = input().strip() # 读字符串要手动去掉 '\n'
或者用 buffer 版本(更快,返回 bytes):
import sys
data = sys.stdin.buffer.read().split() # 一次性读入全部 token
# data 中每个元素是 bytes,例如 b'123'
n = int(data[0])
a = [int(x) for x in data[1:1 + n]]
⚠️
sys.stdin.readline()保留末尾的\n,读整行字符串时记得.strip()。
int()和split()会自动忽略空白,所以读数字时不用 strip。
对应的快写:
import sys
out = []
for i in range(n):
out.append(str(ans[i]))
sys.stdout.write("\n".join(out))
比逐行 print 快得多(类似 C++ 用 '\n' 代替 endl,或者一次性拼字符串)。
4.7 格式化输出
x = 3.14159265
# 1) f-string(推荐,Python 3.6+)
print(f"{x:.2f}") # 3.14
print(f"{x:.10f}") # 3.1415926500
print(f"{123:05d}") # 00123
print(f"{255:x}") # ff (十六进制)
print(f"{a} {b}") # 最常用
# 2) str.format()
print("{:.2f}".format(x)) # 3.14
print("{0} + {1} = {2}".format(1, 2, 3))
# 3) % 格式化(老式,类似 C 的 printf)
print("%.2f" % x) # 3.14
print("%d %s" % (10, "hi")) # 10 hi
对应 C++ 的 printf("%.2f", x) 就是 print(f"{x:.2f}")。
⚠️ 浮点数格式化是"四舍六入五成双"(银行家舍入)并且受二进制表示误差影响,
2.675输出2.67。竞赛中若要求严格四舍五入,通常加1e-9再输出。
4.8 输入输出对照速查
| 需求 | C++ | Python |
|---|---|---|
| 读一个整数 | cin >> n; |
n = int(input()) |
| 读一行整数 | while(cin>>x) a.push_back(x); |
a = list(map(int, input().split())) |
| 读三个整数 | cin >> a >> b >> c; |
a, b, c = map(int, input().split()) |
| 读一整行(含空格) | getline(cin, s); |
s = input() |
| 读一个单词 | cin >> s; |
s = input().split()[0] |
| 读字符矩阵 | 双重循环 cin >> c |
g = [list(input().strip()) for _ in range(n)] |
| 输出空格分隔 | cout << a << ' ' << b; |
print(a, b) |
| 输出不换行 | cout << x; |
print(x, end='') |
| 输出浮点 2 位 | printf("%.2f", x); |
print(f"{x:.2f}") |
| 大量输出 | 用 '\n' 拼接 |
sys.stdout.write('\n'.join(...)) |
5. 运算符
5.1 算术运算符
| 运算符 | 含义 | C++ 对应 | 注意 |
|---|---|---|---|
+ - * |
加减乘 | 同 | int 不会溢出 |
/ |
真除法,结果总是 float |
无(C++ 的 / 是整除) |
7 / 2 == 3.5 |
// |
整除,向下取整 | /(但 C++ 向零取整) |
-7 // 2 == -4 |
% |
取模,结果符号与除数一致 | % |
-7 % 3 == 2(C++ 是 -1) |
** |
幂运算 | pow() |
2**10 == 1024 |
这是最大的坑之一:
print(7 / 2) # 3.5 ← 不是 3!
print(7 // 2) # 3
print(-7 // 2) # -4 ← C++ 中 -7/2 == -3
print(-7 % 3) # 2 ← C++ 中 -7%3 == -1
要在 Python 中复现 C++ 的"向零取整"整除:
def cpp_div(a, b):
return int(a / b) # 注意大整数会丢精度,不推荐
def cpp_div(a, b):
q = a // b
if (a % b != 0) and ((a < 0) != (b < 0)):
q += 1
return q
竞赛中取模运算请保证操作数非负,或用 (x % MOD + MOD) % MOD。
5.2 复合赋值
a += 1
a -= 1
a *= 2
a //= 2
a **= 2
a %= 10
⚠️ Python 没有
++和--运算符!写i++是语法错误,必须写i += 1。
5.3 比较与逻辑
# 比较
a == b, a != b, a < b, a <= b, a > b, a >= b
# 链式比较(C++ 没有!)
0 <= x < 10 # 等价于 0 <= x and x < 10
a == b == c # 等价于 a == b and b == c
# 逻辑
a and b # 对应 &&
a or b # 对应 ||
not a # 对应 !
# 三元表达式
x if cond else y # 对应 cond ? x : y
and / or 也是短路的,而且返回的是操作数本身(不是 True/False):
print(0 or "default") # default
print("a" and "b") # b
5.4 位运算
a & b # 与
a | b # 或
a ^ b # 异或
~a # 按位取反,注意 ~a == -a-1(因为 Python 整数无限位)
a << k # 左移
a >> k # 右移(对负数也是向下取整)
5.5 身份与成员
a is b # 是否为同一个对象(类似比较指针地址)
a is not b
a in [1, 2, 3] # 成员判断(list / str / dict / set 都支持)
a not in s
⚠️ 判断值相等用
==,不要用is。is只用于和None比较(if x is None:)。
5.6 运算符优先级(从高到低,节选)
6. 控制流
6.1 if / elif / else
// C++
if (x > 0) {
...
} else if (x == 0) {
...
} else {
...
}
# Python
if x > 0:
...
elif x == 0:
...
else:
...
注意是 elif,不是 else if。
6.2 while
while x > 0:
x //= 2
Python 没有 do...while,需要自己写:
while True:
...
if not cond:
break
6.3 for —— 迭代器风格
Python 的 for 是 C++11 的 range-for,不是 C 风格三段式:
// C++
for (int i = 0; i < n; i++) { ... }
for (auto x : a) { ... }
# Python
for i in range(n): # 对应 for(int i = 0; i < n; i++)
...
for x in a: # 对应 for(auto x : a)
...
for i, x in enumerate(a): # 同时拿到下标和值,C++ 里要手动维护
print(i, x)
for i in range(n - 1, -1, -1): # 倒序
...
for i in range(0, n, 2): # 步长为 2
...
for i in range(n - 1): # 枚举到 n-2,常见于相邻对
...
6.4 range 详解
range(stop) # 0, 1, ..., stop-1
range(start, stop) # start, ..., stop-1
range(start, stop, step) # start, start+step, ...
- 左闭右开,和 C++ 的
[l, r)一致; step可以为负;range对象是惰性的,不会真的分配内存(类似 C++20 的views::iota)。
list(range(5)) # [0, 1, 2, 3, 4]
list(range(2, 5)) # [2, 3, 4]
list(range(10, 0, -2)) # [10, 8, 6, 4, 2]
6.5 break / continue
与 C++ 相同:
for x in a:
if x < 0:
break
if x % 2 == 0:
continue
print(x)
6.6 for...else(Python 特有)
else 块在循环没有被 break 中断时执行:
for x in a:
if x == target:
print("found")
break
else:
print("not found") # 只有没 break 才执行
等价于 C++ 里用一个 bool found 标志。
6.7 没有 switch
用 if / elif 链,或者 Python 3.10+ 的 match:
match op:
case "+":
ans = a + b
case "-":
ans = a - b
case _:
ans = 0
洛谷环境可能版本较旧,建议直接用 if / elif。
7. 字符串
7.1 定义
s = "hello"
t = 'world' # 单双引号等价
u = """多行
字符串"""
v = r"C:\new\test" # raw string,反斜杠不转义(正则常用)
7.2 不可变性
Python 的字符串是不可变的(和 C++ 的 std::string 不同):
s = "abc"
# s[0] = 'x' # ❌ TypeError!不能原地改
s = 'x' + s[1:] # ✅ 只能重建
因此
for循环中不断s += c是 \(O(n^2)\) 的,应该用列表收集再"".join(list)。
parts = []
for c in data:
parts.append(c)
s = "".join(parts) # O(n)
7.3 下标与切片
s = "abcdef"
print(s[0]) # a
print(s[-1]) # f ← 负数下标表示从后往前!
print(s[1:4]) # bcd ← [1, 4) 左闭右开
print(s[:3]) # abc
print(s[3:]) # def
print(s[::2]) # ace ← 步长
print(s[::-1]) # fedcba ← 反转字符串(超常用)
print(len(s)) # 6
切片规则与 range 一致:s[start:stop:step],左闭右开,越界自动截断不报错。
对比 C++:
s.substr(pos, len)是"起点 + 长度",Python 是"起点 + 终点",语义不同!
7.4 常用方法
s.upper() # 转大写
s.lower() # 转小写
s.strip() # 去掉两端空白(类似 trim)
s.lstrip() / s.rstrip()
s.split() # 见上文
s.split(',')
",".join(["a", "b"]) # "a,b" ← 与 split 互逆
s.replace("a", "b") # 替换全部
s.find("ab") # 返回下标,找不到返回 -1
s.rfind("ab")
s.index("ab") # 找不到抛 ValueError
s.startswith("ab")
s.endswith("ab")
s.count("ab") # 出现次数
s.isdigit() # 是否全是数字
s.isalpha() # 是否全是字母
s.isalnum()
s.zfill(5) # 左侧补 0 到长度 5
s.center(10)
s.ljust(10) / s.rjust(10)
7.5 字符与编码
ord('a') # 97 字符 -> ASCII
chr(97) # 'a' ASCII -> 字符
ord('a') - ord('a') # 0,常用作字母下标
7.6 字符串比较
按字典序比较,与 C++ 的 std::string 一致:
"abc" < "abd" # True
"abc" == "abc" # True
7.7 遍历
for c in s: # 遍历字符
print(c)
for i in range(len(s)): # 遍历下标
print(s[i])
for i, c in enumerate(s):
print(i, c)
8. 容器:list / tuple / dict / set
8.1 list —— 动态数组
相当于 std::vector<T>,但可以装不同类型(不建议)。
a = [1, 2, 3]
b = list(range(5)) # [0, 1, 2, 3, 4]
c = [0] * 10 # 10 个 0
d = [1, "two", 3.0] # 可以混类型
e = [] # 空列表
访问与修改:
a = [10, 20, 30, 40]
print(a[0]) # 10
print(a[-1]) # 40
a[1] = 99 # [10, 99, 30, 40]
print(len(a)) # 4
切片(返回新列表):
a = [0, 1, 2, 3, 4, 5]
a[1:4] # [1, 2, 3]
a[:3] # [0, 1, 2]
a[3:] # [3, 4, 5]
a[::2] # [0, 2, 4]
a[::-1] # [5, 4, 3, 2, 1] 反转
a[1:4] = [9] # 切片赋值,[0, 9, 4, 5]
常用方法:
a.append(x) # 尾部插入 push_back
a.pop() # 弹出尾部 pop_back
a.pop(i) # 弹出下标 i
a.insert(i, x) # 在下标 i 插入 insert
a.remove(x) # 删除第一个值为 x 的元素(O(n))
a.extend(b) # 拼接 b,等价 a += b
a.index(x) # 查找下标,找不到抛异常
a.count(x) # 计数
a.reverse() # 原地反转
a.sort() # 原地升序排序(O(n log n))
a.sort(reverse=True) # 降序
a.sort(key=lambda x: -x) # 按自定义规则
b = sorted(a) # 返回新列表,不改 a
b = sorted(a, key=lambda p: (p[0], p[1])) # 多关键字
a.clear() # 清空
a.copy() # 浅拷贝
x in a # 成员判断 O(n)
列表推导式(Python 精髓,C++ 没有对应语法):
squares = [x * x for x in range(10)]
evens = [x for x in range(10) if x % 2 == 0]
pairs = [(i, j) for i in range(3) for j in range(3)]
matrix = [[0] * m for _ in range(n)]
⚠️ 深坑:[[0]*m]*n 不是二维数组!
# ❌ 错误:n 行指向同一个列表
g = [[0] * 3] * 2
g[0][0] = 1
print(g) # [[1, 0, 0], [1, 0, 0]] ← 两行都变了!
# ✅ 正确:每行独立创建
g = [[0] * 3 for _ in range(2)]
g[0][0] = 1
print(g) # [[1, 0, 0], [0, 0, 0]]
二维数组遍历:
n, m = 3, 4
g = [[0] * m for _ in range(n)]
for i in range(n):
for j in range(m):
g[i][j] = i * m + j
# 遍历所有元素
for row in g:
for x in row:
print(x)
作为栈使用:
st = []
st.append(1) # push
st.append(2)
top = st[-1] # 取栈顶
st.pop() # pop
作为队列使用:list 的 pop(0) 是 \(O(n)\) 的,队列请用 collections.deque。
8.2 tuple —— 不可变序列
类似 std::pair / std::tuple。
p = (1, 2)
x, y = p # 解包
print(p[0])
# 单元素元组必须带逗号
t = (1,)
元组可哈希,能当 dict 的 key、能放进 set,常用于需要"打包"的场景:
visited = set()
visited.add((x, y)) # 二维坐标去重
8.3 dict —— 哈希表
相当于 std::unordered_map,Python 3.7+ 保证插入顺序。
d = {}
d = {"a": 1, "b": 2}
d["c"] = 3
print(d["a"]) # 1
# print(d["z"]) # ❌ KeyError
print(d.get("z")) # None,不报错
print(d.get("z", 0)) # 0,提供默认值
"a" in d # True,判断 key 是否存在
d.keys() # 所有 key
d.values() # 所有 value
d.items() # 所有 (key, value)
for k in d: # 遍历 key
...
for k, v in d.items(): # 遍历键值对
...
del d["a"] # 删除
d.pop("b", None) # 删除并返回
d.setdefault(k, 0) # 若不存在则设为 0
计数常用写法:
cnt = {}
for x in a:
cnt[x] = cnt.get(x, 0) + 1
更简洁的是 collections.Counter:
from collections import Counter
cnt = Counter(a)
print(cnt[5]) # 出现次数,不存在返回 0
print(cnt.most_common(3)) # 出现最多的 3 个
8.4 set —— 哈希集合
相当于 std::unordered_set,自动去重,查找 \(O(1)\)。
s = set()
s = {1, 2, 3}
s.add(4) # 插入
s.discard(2) # 删除(不存在也不报错)
s.remove(2) # 删除(不存在抛 KeyError)
x in s # 成员判断 O(1)
a | b # 并集
a & b # 交集
a - b # 差集
a ^ b # 对称差
# 去重
a = list(set(a)) # 注意:顺序会丢失!
⚠️
{}是空字典,空集合要写set()。
8.5 collections.deque —— 双端队列
BFS 必须用它(list.pop(0) 是 \(O(n)\))。
from collections import deque
q = deque()
q.append(x) # 入队尾
q.appendleft(x) # 入队头
q.pop() # 出队尾
q.popleft() # 出队头 O(1)
q[0] # 取队头
len(q)
等价于 std::deque。
8.6 heapq —— 优先队列
import heapq
h = []
heapq.heappush(h, x) # 入堆 O(log n)
heapq.heappop(h) # 出堆 O(log n)
h[0] # 堆顶 O(1)
heapq.heapify(a) # 把 list 原地变成堆 O(n)
# 大根堆:存相反数
heapq.heappush(h, -x)
top = -h[0]
# 带优先级的元素:存元组(按第一个元素比较)
heapq.heappush(h, (dist, node))
8.7 bisect —— 二分
import bisect
a = [1, 3, 5, 7]
bisect.bisect_left(a, 5) # 2 第一个 >= 5 的位置
bisect.bisect_right(a, 5) # 3 第一个 > 5 的位置
bisect.insort(a, 4) # 插入并保持有序(O(n))
对应 C++ 的 lower_bound / upper_bound。
8.8 嵌套与二维索引
# 邻接表
g = [[] for _ in range(n)]
g[u].append(v)
g[v].append(u)
for v in g[u]:
...
# 邻接矩阵
mat = [[0] * n for _ in range(n)]
mat[u][v] = w
9. 函数
9.1 定义与调用
// C++
int add(int a, int b) {
return a + b;
}
# Python
def add(a, b):
return a + b
print(add(1, 2)) # 3
要点:
def关键字,冒号,缩进;- 参数不带类型;
return可选,没有则返回None;- 没有函数重载(同名函数后定义覆盖前面的);
- 必须先定义后调用(运行时从上到下执行)。
9.2 返回值
def divmod_cpp(a, b):
return a // b, a % b # 返回元组
q, r = divmod_cpp(7, 2) # 解包
print(q, r) # 3 1
Python 只能 return 一次,多返回值靠元组:
def f():
return 1, 2, 3 # 返回 (1, 2, 3)
9.3 默认参数
def f(a, b=10, c=20):
return a + b + c
f(1) # 31
f(1, 2) # 23
f(1, 2, 3) # 6
⚠️ 默认参数只在函数定义时求值一次,所以不要用可变对象做默认值:
# ❌ 经典陷阱
def f(x, lst=[]):
lst.append(x)
return lst
print(f(1)) # [1]
print(f(2)) # [1, 2] ← 不是 [2]!
# ✅ 正确写法
def f(x, lst=None):
if lst is None:
lst = []
lst.append(x)
return lst
9.4 可变参数
def f(*args, **kwargs):
print(args) # 元组,位置参数
print(kwargs) # 字典,关键字参数
f(1, 2, 3, a=4, b=5)
# (1, 2, 3)
# {'a': 4, 'b': 5}
9.5 作用域
x = 10
def f():
x = 20 # 这里是新的局部变量,不影响外面
print(x) # 20
def g():
global x # 声明使用全局的 x
x = 30
g()
print(x) # 30
⚠️ 函数内只要对变量赋值,它就是局部的,除非用
global(模块级)或nonlocal(嵌套函数)。
但只读全局变量或调用其方法(如list.append)不需要global。
9.6 lambda 匿名函数
f = lambda x: x * x
print(f(5)) # 25
# 常见用法:作为 key 传给 sort / max / min
a.sort(key=lambda x: -x)
a.sort(key=lambda p: (p[0], p[1]))
9.7 递归与深度限制
def dfs(u):
if visited[u]:
return
visited[u] = True
for v in g[u]:
dfs(v)
⚠️ Python 默认递归深度只有 1000 左右,深搜必须设置:
import sys sys.setrecursionlimit(1 << 20) # 约 100 万而且 PyPy 的递归开销大,能写迭代就写迭代。
9.8 记忆化:functools.lru_cache
from functools import lru_cache
@lru_cache(maxsize=None)
def f(n):
if n < 2:
return n
return f(n - 1) + f(n - 2)
print(f(100)) # 354224848179261915075
等价于 C++ 里手写 memo[] 数组。参数必须可哈希(数字、元组、字符串)。
10. 类与对象
10.1 基本定义
// C++
struct Point {
int x, y;
Point(int x, int y) : x(x), y(y) {}
int norm2() { return x*x + y*y; }
};
# Python
class Point:
def __init__(self, x, y): # 构造函数
self.x = x # self 相当于 this,但必须显式写出
self.y = y
def norm2(self): # 方法第一个参数必须是 self
return self.x * self.x + self.y * self.y
p = Point(3, 4)
print(p.x, p.y) # 3 4
print(p.norm2()) # 25
要点:
__init__是构造函数(双下划线,不是__init__()调用时手写);- 没有
new,直接Point(3, 4)创建; - 没有
public/private,靠命名约定:_x表示内部使用; - 属性可以在运行时随意添加(
p.z = 5合法)。
10.2 运算符重载(排序、比较)
class Node:
def __init__(self, w, v):
self.w = w
self.v = v
def __lt__(self, other): # 定义 <
return self.w < other.w
nodes = [Node(3, 1), Node(1, 2), Node(2, 3)]
nodes.sort() # 按 w 升序
常用魔法方法:
| 方法 | 对应运算 |
|---|---|
__init__ |
构造 |
__lt__ |
< |
__eq__ |
== |
__add__ |
+ |
__len__ |
len() |
__getitem__ |
obj[i] |
__str__ |
str() / print() |
__repr__ |
调试输出 |
10.3 dataclass(简化写法)
from dataclasses import dataclass
@dataclass
class Point:
x: int
y: int
p = Point(1, 2)
print(p) # Point(x=1, y=2)
自动生成 __init__、__repr__、__eq__,非常省事。
10.4 与 C++ 结构体的对照
| C++ | Python |
|---|---|
struct P { int x, y; }; |
class P: def __init__(self,x,y): ... |
| 构造函数初始化列表 | __init__ 内赋值 |
p.x |
p.x |
this->x |
self.x |
重载 operator< |
__lt__ |
vector<P> v; sort(v.begin(), v.end()); |
v.sort() |
11. 异常处理
// C++
try {
...
} catch (const std::exception& e) {
...
}
# Python
try:
x = int(input())
except ValueError:
print("not an integer")
except (EOFError, KeyboardInterrupt):
print("interrupted")
except Exception as e: # 捕获所有异常
print("error:", e)
else:
print("no exception") # 没有异常时执行
finally:
print("always runs")
常见内置异常:
| 异常 | 触发场景 |
|---|---|
ValueError |
int("abc") |
IndexError |
a[100] 越界 |
KeyError |
d["不存在的key"] |
ZeroDivisionError |
1 // 0 |
TypeError |
类型不匹配 |
EOFError |
input() 读到末尾 |
RecursionError |
递归过深 |
主动抛出:
raise ValueError("bad input")
12. 文件读写
# 读
with open("in.txt", "r", encoding="utf-8") as f:
data = f.read() # 读全部内容为一个字符串
# 或
lines = f.readlines() # 每行一个字符串(含 '\n')
# 或
for line in f: # 逐行读
print(line.strip())
# 写
with open("out.txt", "w", encoding="utf-8") as f:
f.write("hello\n")
print("world", file=f)
with 会自动关闭文件(相当于 C++ 的 RAII),不要手动 f.close()。
洛谷提交代码时通常用标准输入输出,不需要打开文件。
13. 常用 import 汇总
以下是竞赛/日常最常用的模块。Python 标准库非常庞大,这里只列高频的。
13.1 sys —— 系统相关(输入输出、递归深度)
import sys
sys.stdin.readline() # 快读一行
sys.stdin.buffer.read() # 一次性读入全部(bytes)
sys.stdout.write("...") # 快写
sys.setrecursionlimit(1 << 20) # 设置递归深度
sys.exit(0) # 退出程序
sys.maxsize # 平台最大整数(通常 2^63-1)
sys.float_info.epsilon # 浮点精度
13.2 math —— 数学函数
import math
math.sqrt(x) # 开方(返回 float)
math.isqrt(x) # 整数开方(向下取整,3.8+)
math.pow(a, b) # 浮点幂(一般用 a ** b)
math.gcd(a, b) # 最大公约数(支持多参数)
math.lcm(a, b) # 最小公倍数(3.9+)
math.factorial(n) # 阶乘
math.comb(n, k) # 组合数 C(n,k)(3.8+)
math.perm(n, k) # 排列数 A(n,k)
math.floor(x) # 向下取整
math.ceil(x) # 向上取整
math.log(x) # 自然对数
math.log2(x) # 以 2 为底
math.log10(x)
math.sin / cos / tan / asin / acos / atan / atan2
math.pi
math.e
math.inf
math.isinf(x)
math.isnan(x)
math.fabs(x) # 浮点绝对值(整数用 abs)
竞赛中
a ** b比math.pow更常用;求最大公约数用math.gcd(C++17 的std::gcd)。
13.3 collections —— 容器扩展
from collections import (
deque, # 双端队列,BFS 必备
Counter, # 计数器
defaultdict, # 带默认值的字典
OrderedDict, # 有序字典(3.7+ 普通 dict 已有序,一般不必要)
namedtuple, # 具名元组
)
q = deque()
q.append(1); q.popleft()
cnt = Counter("hello")
cnt.most_common(2)
# defaultdict:访问不存在的 key 自动创建
d = defaultdict(int) # 默认值 0
d[x] += 1 # 不需要判断 key 是否存在!
d = defaultdict(list) # 默认值 []
d[u].append(v)
13.4 heapq —— 堆 / 优先队列
import heapq
heapq.heappush(h, x)
heapq.heappop(h)
heapq.heapify(a)
heapq.nlargest(3, a) # 前 3 大
heapq.nsmallest(3, a)
heapq.heappushpop(h, x)
13.5 bisect —— 二分
import bisect
bisect.bisect_left(a, x) # lower_bound
bisect.bisect_right(a, x) # upper_bound
bisect.insort_left(a, x)
bisect.insort_right(a, x)
13.6 itertools —— 排列组合与迭代工具
import itertools
itertools.permutations(a) # 全排列
itertools.permutations(a, 2) # 部分排列
itertools.combinations(a, 2) # 组合
itertools.combinations_with_replacement(a, 2)
itertools.product(a, b) # 笛卡尔积
itertools.accumulate(a) # 前缀和
itertools.groupby(a) # 分组(需先排序)
itertools.count(0) # 无限计数
示例:
import itertools
for p in itertools.permutations([1, 2, 3]):
print(p)
# (1, 2, 3) (1, 3, 2) (2, 1, 3) ...
13.7 functools
from functools import lru_cache, cmp_to_key, reduce, cache
@lru_cache(maxsize=None) # 记忆化搜索
def f(n): ...
@cache # 3.9+,等价于 lru_cache(None)
def g(n): ...
# 用 C++ 风格的比较函数排序
def cmp(a, b):
if a < b: return -1
if a > b: return 1
return 0
a.sort(key=cmp_to_key(cmp))
# reduce 折叠
reduce(lambda x, y: x + y, [1, 2, 3, 4]) # 10
在洛谷(PyPy)上
lru_cache比较慢,大规模 DP 可考虑手写dict或数组。
13.8 random —— 随机数
import random
random.random() # [0, 1) 浮点
random.randint(1, 6) # [1, 6] 整数
random.randrange(10) # [0, 10) 整数
random.choice(a) # 随机选一个元素
random.shuffle(a) # 原地打乱
random.sample(a, k) # 随机选 k 个不重复
对拍时常用:random.seed(12345)。
13.9 其他常用
import string
string.ascii_lowercase # 'abcdefghijklmnopqrstuvwxyz'
string.digits # '0123456789'
string.ascii_letters
import operator
operator.add, operator.mul # 函数形式的运算符
import re # 正则表达式
re.match(r"\d+", s)
re.findall(r"\d+", s)
re.sub(r"\d+", "#", s)
from fractions import Fraction
Fraction(1, 3) + Fraction(1, 6) # 1/2
from decimal import Decimal
Decimal("0.1") + Decimal("0.2") # 精确十进制
import copy
copy.copy(x) # 浅拷贝
copy.deepcopy(x) # 深拷贝(二维数组/嵌套结构用)
from typing import List, Dict, Set, Tuple # 类型标注(不影响运行)
def f(a: List[int]) -> int: ...
import array
array.array('i', [1, 2, 3]) # 紧凑数组,省内存
import time
time.time() # 时间戳
time.perf_counter() # 高精度计时(测性能)
13.10 import 的几种写法
import math # 用 math.sqrt
import math as m # 用 m.sqrt
from math import sqrt # 直接 sqrt
from math import * # 全部导入(不推荐,易污染命名空间)
洛谷中
import写在文件开头即可,没有 C++ 头文件那种编译开销问题(但有模块加载开销,一般可忽略)。
14. C++ 选手最容易踩的坑
-
/是真除法,整除用//print(7 / 2) # 3.5 print(7 // 2) # 3 -
//和%对负数是向下取整,与 C++ 不同print(-7 // 2, -7 % 3) # -4 2 (C++ 是 -3 -1) -
没有
++/--i += 1 # ✅ i++ # ❌ 语法错误 -
[[0]*m]*n是浅拷贝陷阱g = [[0] * m for _ in range(n)] # ✅ -
赋值是"贴标签",不是拷贝
a = [1, 2, 3] b = a # b 和 a 指向同一个列表! b.append(4) print(a) # [1, 2, 3, 4] b = a.copy() # 浅拷贝 b = a[:] # 浅拷贝 import copy b = copy.deepcopy(a) # 深拷贝 -
可变对象不能做
set元素 /dictkeys = {(1, 2)} # ✅ 元组可以 s = {[1, 2]} # ❌ 列表不可哈希 -
input()永远返回字符串n = input() # "5" n = int(input()) # 5 -
print(a, " ", b)会多空格print(a, b) # ✅ print(f"{a} {b}") # ✅ -
默认参数不要用可变对象
def f(lst=[]): ... # ❌ def f(lst=None): ... # ✅ -
递归深度默认 1000
import sys sys.setrecursionlimit(1 << 20) -
字符串不可变,拼接用
joins = "".join(parts) # ✅ O(n) s += c # ❌ 循环中 O(n^2) -
is是身份比较,==是值比较a = [1, 2] b = [1, 2] a == b # True a is b # False x is None # ✅ 这是 is 的正确用法 -
sort()原地排序返回Nonea = a.sort() # ❌ a 变成 None! a.sort() # ✅ b = sorted(a) # ✅ 返回新列表 -
for循环中修改列表长度会出错for x in a: a.remove(x) # ❌ 危险 # 应该遍历副本: for x in a[:]: a.remove(x) -
整数除法大数精度
int(10**18 / 3) # ❌ 浮点丢精度 10**18 // 3 # ✅ -
round()是银行家舍入round(2.5) # 2 (不是 3!) round(3.5) # 4竞赛中需要四舍五入用
int(x + 0.5)(非负时)或math.floor(x + 0.5)。 -
bool是int的子类True + True # 2 -
list的pop(0)、insert(0, x)是 O(n)
队列用collections.deque。 -
dict是无序?不,3.7+ 保证插入顺序,但set仍无序。 -
PyPy 与 CPython 的差异
洛谷可用 PyPy3:循环快、递归慢、lru_cache慢。提交前可以两种都试试。
15. 竞赛模板
15.1 基础模板(推荐)
import sys
def main():
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
ans = sum(a)
print(ans)
if __name__ == "__main__":
main()
15.2 快速读入全部数据
import sys
def main():
data = sys.stdin.buffer.read().split()
idx = 0
n = int(data[idx]); idx += 1
a = [int(data[idx + i]) for i in range(n)]
idx += n
# ...
main()
15.3 快速输出
import sys
out = []
for i in range(n):
out.append(str(ans[i]))
sys.stdout.write("\n".join(out))
15.4 图论 DFS(迭代版,避免递归过深)
import sys
sys.setrecursionlimit(1 << 20)
n, m = map(int, sys.stdin.readline().split())
g = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = map(int, sys.stdin.readline().split())
g[u].append(v)
g[v].append(u)
visited = [False] * (n + 1)
stack = [1]
visited[1] = True
while stack:
u = stack.pop()
for v in g[u]:
if not visited[v]:
visited[v] = True
stack.append(v)
15.5 BFS 最短路
from collections import deque
dist = [-1] * (n + 1)
dist[1] = 0
q = deque([1])
while q:
u = q.popleft()
for v in g[u]:
if dist[v] == -1:
dist[v] = dist[u] + 1
q.append(v)
15.6 Dijkstra
import heapq
INF = 10**18
dist = [INF] * (n + 1)
dist[s] = 0
pq = [(0, s)]
while pq:
d, u = heapq.heappop(pq)
if d > dist[u]:
continue
for v, w in g[u]:
nd = d + w
if nd < dist[v]:
dist[v] = nd
heapq.heappush(pq, (nd, v))
15.7 并查集
parent = list(range(n + 1))
rank = [0] * (n + 1)
def find(x):
while parent[x] != x:
parent[x] = parent[parent[x]] # 路径压缩
x = parent[x]
return x
def union(a, b):
ra, rb = find(a), find(b)
if ra == rb:
return False
if rank[ra] < rank[rb]:
ra, rb = rb, ra
parent[rb] = ra
if rank[ra] == rank[rb]:
rank[ra] += 1
return True
15.8 记忆化搜索
from functools import lru_cache
import sys
sys.setrecursionlimit(1 << 20)
@lru_cache(maxsize=None)
def dfs(i, j):
if i == n:
return 0
res = 10**18
for k in range(m):
res = min(res, dfs(i + 1, k) + cost[i][k])
return res
15.9 对拍
import random, subprocess
for t in range(1000):
n = random.randint(1, 100)
a = [random.randint(-100, 100) for _ in range(n)]
inp = f"{n}\n{' '.join(map(str, a))}\n"
r1 = subprocess.run(["python", "std.py"], input=inp, capture_output=True, text=True).stdout
r2 = subprocess.run(["python", "brute.py"], input=inp, capture_output=True, text=True).stdout
if r1 != r2:
print("WA:", inp)
print("std:", r1)
print("brute:", r2)
break
else:
print("all ok")
16. 语法速查对照表
16.1 基础语法
| 功能 | C++ | Python |
|---|---|---|
| 输出 | cout << x; |
print(x) |
| 输出换行 | cout << x << '\n'; |
print(x) |
| 不换行 | cout << x; |
print(x, end='') |
| 空格分隔 | cout << a << ' ' << b; |
print(a, b) |
| 输入整数 | cin >> n; |
n = int(input()) |
| 输入一行整数 | while(cin>>x) a.push_back(x); |
a = list(map(int, input().split())) |
| 输入整行 | getline(cin, s); |
s = input() |
| 格式化浮点 | printf("%.2f", x); |
print(f"{x:.2f}") |
| 变量声明 | int a = 1; |
a = 1 |
| 常量 | const int N = 1e5; |
N = 100000 |
| 类型转换 | (int)x |
int(x) |
| 三元 | c ? a : b |
a if c else b |
| 多行注释 | /* */ |
""" """ |
16.2 控制流
| 功能 | C++ | Python |
|---|---|---|
| if | if (c) { } |
if c: |
| else if | else if (c) { } |
elif c: |
| while | while (c) { } |
while c: |
| for 计数 | for(int i=0;i<n;i++) |
for i in range(n): |
| for 倒序 | for(int i=n-1;i>=0;i--) |
for i in range(n-1,-1,-1): |
| for-each | for(auto x:a) |
for x in a: |
| 带下标 | 手动维护 i |
for i, x in enumerate(a): |
| 跳出 | break; |
break |
| 继续 | continue; |
continue |
| 无限循环 | while(true) |
while True: |
16.3 数据结构
| 功能 | C++ | Python |
|---|---|---|
| 数组 | int a[10]; |
a = [0] * 10 |
| 动态数组 | vector<int> v; |
v = [] |
| 尾插 | v.push_back(x); |
v.append(x) |
| 尾删 | v.pop_back(); |
v.pop() |
| 长度 | v.size(); |
len(v) |
| 排序 | sort(v.begin(), v.end()); |
v.sort() |
| 自定义排序 | sort(v.begin(), v.end(), cmp); |
v.sort(key=lambda x: ...) |
| 反转 | reverse(v.begin(), v.end()); |
v.reverse() 或 v[::-1] |
| 二分查找 | lower_bound(...) |
bisect.bisect_left(v, x) |
| 栈 | stack<int> st; |
st = [] |
| 入栈 | st.push(x); |
st.append(x) |
| 出栈 | st.pop(); |
st.pop() |
| 队首 | st.top(); |
st[-1] |
| 队列 | queue<int> q; |
q = deque() |
| 入队 | q.push(x); |
q.append(x) |
| 出队 | q.pop(); |
q.popleft() |
| 优先队列 | priority_queue<int> pq; |
h = [] + heapq |
| 哈希表 | unordered_map<K,V> mp; |
mp = {} |
| 哈希集合 | unordered_set<int> s; |
s = set() |
| 有序集合 | set<int> s; |
无内置,用 sortedcontainers(洛谷不支持) |
| 字符串 | string s; |
s = "" |
| 子串 | s.substr(pos, len) |
s[pos:pos+len] |
| 查找 | s.find(t) |
s.find(t) |
| 拼接 | s + t |
s + t 或 "".join([s, t]) |
16.4 数学
| 功能 | C++ | Python |
|---|---|---|
| 绝对值 | abs(x) |
abs(x) |
| 向下取整 | floor(x) |
math.floor(x) |
| 向上取整 | ceil(x) |
math.ceil(x) |
| 开方 | sqrt(x) |
math.sqrt(x) |
| 整数开方 | (int)sqrt(x) |
math.isqrt(x) |
| 幂 | pow(a,b) |
a ** b 或 pow(a, b) |
| 模幂 | 手写快速幂 | pow(a, b, m) |
| 最大公约数 | __gcd(a,b) |
math.gcd(a, b) |
| 最小公倍数 | a / gcd * b |
math.lcm(a, b) |
| 对数 | log(x) |
math.log(x) |
| 圆周率 | acos(-1) |
math.pi |
结语
对 C++ 选手来说,学 Python 的关键不是"语法难",而是:
- 改掉 C 风格的思维(
for(int i...)→for x in ...,{}→ 缩进); - 记住 I/O 是完全不同的模型(
input().split()+map(int, ...)要烂熟于心); - 警惕引用语义、可变默认参数、浅拷贝这些 C++ 里不存在或表现不同的坑;
- 知道什么时候该用 PyPy、该用
sys.stdin、该用heapq/deque/lru_cache。
写多了你会发现,Python 代码量通常只有 C++ 的 \(1/3 \sim 1/2\),调试也更快,非常适合快速验证思路。祝学习顺利!
附录 A:列表与字典的详细说明
本附录在正文基础上,把
list和dict这两个最常用、也最容易踩坑的容器单独展开。
最后用一道"未知行数 + 中文名字 + 求最值"的综合题,演示如何组合它们解决实际问题。
A.1 列表 list 详解
A.1.1 与 C++ vector 的本质区别
| 维度 | std::vector<T> |
list |
|---|---|---|
| 元素类型 | 固定 T |
任意类型混合(不推荐) |
| 长度 | 定长后扩容 | 随时增长/缩短 |
| 内存 | 连续 | 连续(底层是动态数组) |
| 拷贝语义 | 赋值即深拷贝 | 赋值是引用,不拷贝! |
| 切片 | 需要手写或 vector(begin+1, begin+4) |
原生 a[1:4] |
| 负下标 | 不支持 | 支持 a[-1] |
最致命的一条:
a = [1, 2, 3]
b = a # b 只是 a 的另一个名字,不是拷贝!
b.append(4)
print(a) # [1, 2, 3, 4] ← a 也变了
# 要真正拷贝:
c = a.copy()
c = a[:] # 等价
c = list(a) # 等价
C++ 中 vector<int> b = a; 是深拷贝,Python 中 b = a 是"别名"。这是 C++ 选手最容易出错的地方。
A.1.2 创建列表的各种方式
a = [1, 2, 3] # 字面量
a = [] # 空列表
a = list() # 空列表
a = list(range(5)) # [0,1,2,3,4]
a = [0] * 10 # [0]*10,10 个 0
a = [i * i for i in range(5)] # 列表推导式
a = [1, "two", 3.0, None, True] # 混合类型(合法但少见)
A.1.3 索引与负下标
a = [10, 20, 30, 40, 50]
a[0] # 10
a[4] # 50
a[-1] # 50 ← 最后一个
a[-2] # 40 ← 倒数第二个
a[-5] # 10
# a[5] # ❌ IndexError
# a[-6] # ❌ IndexError
len(a) # 5
负下标是 Python 非常方便的特性:取尾部元素不用 a[len(a)-1]。
A.1.4 切片(Slice)—— 最强大也最容易混的语法
语法:a[start:stop:step]
- 左闭右开:
a[1:4]包含下标 1,2,3,不包含 4; - 省略
start默认 0,省略stop默认len(a),省略step默认 1; - 越界不报错,自动截断;
- 返回新列表(浅拷贝)。
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a[2:5] # [2, 3, 4]
a[:3] # [0, 1, 2]
a[7:] # [7, 8, 9]
a[:] # 整个列表的浅拷贝
a[::2] # [0, 2, 4, 6, 8] 步长 2
a[1::2] # [1, 3, 5, 7, 9]
a[::-1] # [9, 8, ..., 0] 反转
a[::-2] # [9, 7, 5, 3, 1]
a[100:] # [] 越界不报错,返回空列表
a[-3:] # [7, 8, 9] 最后 3 个
a[:-2] # [0,1,...,7] 去掉最后 2 个
切片赋值(C++ 没有对应):
a = [0, 1, 2, 3, 4, 5]
a[1:3] = [9, 9, 9] # 把 [1,2] 换成 [9,9,9]
print(a) # [0, 9, 9, 9, 3, 4, 5]
a[1:3] = [] # 删除 a[1], a[2]
print(a) # [0, 3, 4, 5]
⚠️ 对比 C++ 的
substr:s.substr(pos, len)是"起点 + 长度";
Python 的s[pos:pos+len]是"起点 + 终点"。语义完全不同,这是常见 bug 来源。
A.1.5 增删改查
a = [1, 2, 3]
# 增
a.append(4) # 尾部添加一个元素 push_back
a.extend([5, 6]) # 尾部拼接多个元素 insert(end, ...)
a.insert(1, 99) # 在下标 1 处插入 99 insert
a += [7, 8] # 等价于 extend
# 删
a.pop() # 弹出最后一个,返回它 pop_back
a.pop(0) # 弹出下标 0 的元素(O(n)!)
a.remove(99) # 删除第一个值为 99 的元素(O(n))
del a[0] # 删除下标 0
del a[1:3] # 删除切片
a.clear() # 全部清空
# 改
a[0] = 100
a[1:3] = [10, 20, 30] # 切片赋值
# 查
x in a # 是否存在,O(n)
a.index(x) # 第一个 x 的下标,不存在抛 ValueError
a.count(x) # x 出现次数
A.1.6 排序
a = [3, 1, 4, 1, 5, 9, 2, 6]
a.sort() # 原地升序,返回 None
a.sort(reverse=True) # 原地降序
b = sorted(a) # 返回新列表,a 不变
b = sorted(a, reverse=True)
# 按自定义 key 排序
words = ["apple", "banana", "kiwi"]
words.sort(key=len) # 按长度
words.sort(key=lambda w: w[-1]) # 按最后一个字母
# 多关键字:元组比较(先比第一个,相同再比第二个)
students = [("Alice", 90, 18), ("Bob", 85, 20), ("Carol", 90, 17)]
students.sort(key=lambda s: (-s[1], s[2]))
# 按成绩降序,成绩相同按年龄升序
# 反向稳定排序:先按次关键字升序,再按主关键字降序
students.sort(key=lambda s: s[2]) # 先按年龄升序
students.sort(key=lambda s: s[1], reverse=True) # 再按成绩降序
坑:
a = a.sort()会让a变成None! 因为sort()原地排序无返回值。
正确写法是a.sort()或a = sorted(a)。
A.1.7 列表推导式(List Comprehension)
C++ 没有直接对应的语法,这是 Python 的灵魂。
# 基本形式:[expr for x in iterable if cond]
squares = [x * x for x in range(10)] # [0,1,4,9,...,81]
evens = [x for x in range(10) if x % 2 == 0] # [0,2,4,6,8]
words = [s.upper() for s in ["a", "b", "c"]] # ['A','B','C']
pairs = [(i, j) for i in range(3) for j in range(3)]
matrix = [[0] * m for _ in range(n)] # n 行 m 列
等价的 C++ 写法(需要 vector + 循环):
vector<int> squares;
for (int x = 0; x < 10; x++) squares.push_back(x * x);
同一逻辑,C++ 5 行,Python 1 行。
A.1.8 二维列表(矩阵)的坑
这是 C++ 选手的高频踩坑点。
# ❌ 错误:n 行指向同一个列表
g = [[0] * 3] * 2
g[0][0] = 1
print(g) # [[1, 0, 0], [1, 0, 0]] ← 两行都变了!
# ✅ 正确:每行独立创建
g = [[0] * 3 for _ in range(2)]
g[0][0] = 1
print(g) # [[1, 0, 0], [0, 0, 0]]
原因:[x] * n 是把同一个对象的引用重复 n 次;而列表推导式每次 for 都新建一个列表。
二维数组遍历:
n, m = 3, 4
g = [[0] * m for _ in range(n)]
# 下标遍历
for i in range(n):
for j in range(m):
g[i][j] = i * m + j
# 行遍历 + 元素遍历
for row in g:
for x in row:
print(x, end=" ")
print()
# 同时拿行列号
for i, row in enumerate(g):
for j, x in enumerate(row):
print(i, j, x)
A.1.9 常见操作函数
a = [3, 1, 4, 1, 5]
sum(a) # 14 求和
max(a) # 5 最大值
min(a) # 1 最小值
len(a) # 5 长度
any(a) # True 是否有真值
all(a) # True 是否全为真(0 视为假)
# 解包(unpacking)
x, y, z = [1, 2, 3]
first, *rest = [1, 2, 3, 4] # first=1, rest=[2,3,4]
# 合并
a = [1, 2]; b = [3, 4]
c = a + b # [1, 2, 3, 4]
c = [*a, *b] # 等价
# 翻转
a.reverse() # 原地翻转
b = a[::-1] # 新列表
# zip 并行遍历
names = ["Alice", "Bob"]
scores = [90, 85]
for name, score in zip(names, scores):
print(name, score)
list(zip(names, scores)) # [('Alice', 90), ('Bob', 85)]
A.1.10 复杂度速查
| 操作 | 复杂度 |
|---|---|
a[i] / a[i] = x |
\(O(1)\) |
a.append(x) |
均摊 \(O(1)\) |
a.pop() |
\(O(1)\) |
a.pop(0) / a.insert(0, x) |
\(O(n)\) |
a.remove(x) / x in a |
\(O(n)\) |
a.sort() |
\(O(n \log n)\) |
a[i:j] |
\(O(j-i)\) |
len(a) |
\(O(1)\) |
作为栈用
list,作为队列用collections.deque。
A.2 字典 dict 详解
A.2.1 与 C++ map 的对照
| 维度 | std::map<K,V> |
std::unordered_map<K,V> |
Python dict |
|---|---|---|---|
| 底层 | 红黑树 | 哈希表 | 哈希表(3.7+ 有序) |
| 有序性 | 按 key 有序 | 无序 | 按插入顺序 |
| 查找 | \(O(\log n)\) | 均摊 \(O(1)\) | 均摊 \(O(1)\) |
| 默认构造 | 可指定默认值 | 可指定默认值 | 没有默认值(未访问的 key 抛 KeyError) |
| key 类型 | 需可比较 | 需可哈希 | 需可哈希 |
最大差异:C++ 的 mp[key] 在 key 不存在时会自动创建默认值并返回它;Python 的 d[key] 在 key 不存在时直接抛 KeyError。
// C++:不存在的 key 会创建 0
map<string,int> mp;
mp["notexist"]++; // 自动创建并变成 1
# Python:❌ KeyError
d = {}
# d["notexist"] += 1 # 抛 KeyError!
# ✅ 正确写法 1:get
d["notexist"] = d.get("notexist", 0) + 1
# ✅ 正确写法 2:defaultdict
from collections import defaultdict
d = defaultdict(int)
d["notexist"] += 1 # 自动创建 0 再加 1
# ✅ 正确写法 3:setdefault
d.setdefault("notexist", 0)
d["notexist"] += 1
这是 C++ 选手迁移到 Python 时最容易遇到的字典坑。
A.2.2 创建与基本操作
d = {} # 空字典
d = {"a": 1, "b": 2} # 字面量
d = dict(a=1, b=2) # 关键字构造
d = dict([("a", 1), ("b", 2)]) # 从键值对构造
d = {x: x * x for x in range(3)} # 字典推导式
# 增 / 改
d["c"] = 3
d["a"] = 100
# 查
d["a"] # 100,key 不存在抛 KeyError
d.get("a") # 100
d.get("z") # None
d.get("z", -1) # -1,提供默认值
"a" in d # True
"z" not in d # True
# 删
del d["a"]
d.pop("b") # 删除并返回值
d.pop("z", None) # 不存在也不报错
d.clear() # 清空
len(d) # 键值对数量
A.2.3 遍历
d = {"a": 1, "b": 2, "c": 3}
# 遍历 key(默认)
for k in d:
print(k, d[k])
for k in d.keys():
print(k)
# 遍历 value
for v in d.values():
print(v)
# 遍历键值对(最常用)
for k, v in d.items():
print(k, v)
# 按 key 排序后遍历
for k in sorted(d):
print(k, d[k])
# 按 value 排序后遍历
for k, v in sorted(d.items(), key=lambda kv: kv[1], reverse=True):
print(k, v)
A.2.4 字典推导式
# 把 a 中每个元素映射到它的平方
a = [1, 2, 3]
d = {x: x * x for x in a} # {1: 1, 2: 4, 3: 9}
# 反转字典的键值
d2 = {v: k for k, v in d.items()}
# 带条件
d3 = {x: x * x for x in a if x % 2 == 1} # {1: 1, 3: 9}
A.2.5 常见陷阱
坑 1:key 必须可哈希
d = {}
d[(1, 2)] = "ok" # ✅ 元组可哈希
# d[[1, 2]] = "bad" # ❌ list 不可哈希,TypeError
# d[{1, 2}] = "bad" # ❌ set 不可哈希
如果需要二维坐标当 key,用 (x, y) 元组。
坑 2:.get() 返回值可能和合法值混淆
d = {"a": None}
d.get("a") # None
d.get("z") # None ← 无法区分"值就是 None"和"key 不存在"
# 用 in 判断更安全
if "a" in d:
print(d["a"])
坑 3:遍历时修改字典会报错
d = {"a": 1, "b": 2}
# for k in d: # ❌ RuntimeError
# del d[k]
# 遍历副本
for k in list(d):
del d[k]
坑 4:dict 是可变的,赋值即引用
a = {"x": 1}
b = a # b 和 a 是同一个字典!
b["y"] = 2
print(a) # {'x': 1, 'y': 2}
# 要拷贝:
c = a.copy()
c = dict(a)
A.2.6 defaultdict 与 Counter
from collections import defaultdict, Counter
# defaultdict:访问不存在的 key 时自动创建默认值
dd = defaultdict(int) # 默认 0
for x in [1, 2, 2, 3, 3, 3]:
dd[x] += 1
# dd == {1: 1, 2: 2, 3: 3}
# 分组(默认值是 list)
g = defaultdict(list)
for u, v in edges:
g[u].append(v)
g[v].append(u)
# Counter:计数器
cnt = Counter("hello")
# Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
cnt["l"] # 2
cnt["z"] # 0(不存在也不报错!)
cnt.most_common(2) # [('l', 2), ('h', 1)] 前 2 多
Counter本质就是dict的子类,cnt[k]对不存在的 key 返回 0(不同于普通dict),非常适合计数。
A.2.7 排序字典
d = {"apple": 3, "banana": 1, "cherry": 2}
# 按 key 排序
sorted(d) # ['apple', 'banana', 'cherry']
sorted(d.items()) # [('apple', 3), ...]
# 按 value 排序(降序)
sorted(d.items(), key=lambda kv: -kv[1]) # [('apple', 3), ('cherry', 2), ('banana', 1)]
# 按 value 升序再按 key 升序
sorted(d.items(), key=lambda kv: (kv[1], kv[0]))
A.2.8 复杂度速查
| 操作 | 复杂度 |
|---|---|
d[k] / d[k] = v |
均摊 \(O(1)\) |
k in d / del d[k] |
均摊 \(O(1)\) |
d.get(k) / d.pop(k) |
均摊 \(O(1)\) |
遍历 / len |
\(O(n)\) / \(O(1)\) |
| 排序 | \(O(n \log n)\) |
A.3 综合案例:未知行数 + 中文名字 + 求最值
题目:读入 \(n\) 行(未给出 \(n\)),每行格式为:
名字(中文) 数字x 数字y,三个字段用空格隔开,读到-1停止。
最后输出 \(x \times y\) 最大的人的编号(按读入顺序从 1 开始)和该值,用空格隔开。
这道题看着简单,却综合了 C++ 选手迁移 Python 时几乎所有高频坑点:
- 未给出 \(n\),需要循环读到停止条件;
- 一行三个字段,但 名字是中文;
- 停止条件
-1的判断位置(是名字还是某个数?); - 编号怎么算(记录第几个输入);
- 最大值怎么跟踪;
- 输入效率(\(n\) 大时
input()太慢)。
A.3.1 逐行读入 + 停止条件
先明确:-1 代表什么? 题目常见有三种理解,代码要相应调整:
# 情况 ①:整行就是 "-1" 时停止
# 输入示例:
# 张三 3 4
# 李四 5 6
# -1
line = input().strip()
if line == "-1":
break
# 情况 ②:第一个字段(名字位置)为 "-1" 时停止
# 输入示例:
# 张三 3 4
# 李四 5 6
# -1 0 0
parts = line.split()
if parts[0] == "-1":
break
# 情况 ③:某个数字字段为 -1 时停止
# 输入示例:
# 张三 3 4
# 李四 5 6
# 结束 -1 -1
if int(parts[1]) == -1 or int(parts[2]) == -1:
break
实际比赛中一定要读题:停止条件是"整行 -1"还是"某个字段 -1"?
一般中文题目如果写"读入到 -1 停止"且每行有名字,通常指名字字段为 -1,或者单独一行-1。
下面以"名字为 -1 停止"为主例,其它情况在 A.3.5 给出变体。
A.3.2 中文名字的读取
Python 3 的字符串天然是 Unicode,中文名字不需要特殊处理:
name = "张三"
print(len(name)) # 2
print(name[0]) # 张
在洛谷环境:输入的编码是 UTF-8,Python 3 的 input() 读入后就是 str,直接处理即可。
但要注意两点:
-
中文名字不能含空格。如果名字里可能带空格(例如"张 三"),就不能用
split()简单切分,需要用split(maxsplit=2)或rsplit从右边切:# 名字含空格的情况:名字 数字 数字 # 例如:"张 三 3 4" parts = line.rsplit(maxsplit=2) # 从右往左切 2 次 # ['张 三', '3', '4'] name = parts[0] x = int(parts[1]) y = int(parts[2])# 也可以用 split(maxsplit=2):从左切 2 次 parts = line.split(maxsplit=2) # '张 三 3 4' -> ['张', '三', '3 4'] ❌ # 所以名字含空格时必须用 rsplit! -
判断名字是否为
-1是普通字符串比较,与中文无关:if name == "-1": break
A.3.3 完整解答(主例:名字为 -1 停止)
import sys
def main():
# 用 sys.stdin.readline 快读,大量输入时比 input() 快得多
read = sys.stdin.readline
best_val = None # 当前最大 x*y
best_id = 0 # 对应编号
idx = 0 # 已读入的有效记录数
while True:
line = read()
if not line: # EOF
break
line = line.strip() # 去掉首尾空白和 '\n'
if not line: # 空行跳过
continue
parts = line.split()
# 防御性检查:至少 3 个字段
if len(parts) < 3:
continue
name = parts[0]
if name == "-1": # 停止条件:名字为 -1
break
x = int(parts[1])
y = int(parts[2])
idx += 1 # 编号从 1 开始
val = x * y
# 严格大于才更新(相同值保留先出现的编号)
if best_val is None or val > best_val:
best_val = val
best_id = idx
# 如果一条记录都没有
if best_val is None:
print("-1 -1") # 或按题目要求输出
else:
print(best_id, best_val)
if __name__ == "__main__":
main()
输入示例:
张三 3 4
李四 5 6
王五 2 10
-1 0 0
输出:
2 30
因为 李四:\(5 \times 6 = 30\) 最大,编号是 2。
A.3.4 用字典存储所有记录(如果需要后续处理)
如果题目要求最后再统一处理,用 dict 把记录全存下来:
import sys
def main():
read = sys.stdin.readline
records = {} # 编号 -> (名字, x, y, x*y)
idx = 0
while True:
line = read()
if not line:
break
line = line.strip()
if not line:
continue
parts = line.split()
if parts[0] == "-1":
break
name = parts[0]
x = int(parts[1])
y = int(parts[2])
idx += 1
records[idx] = (name, x, y, x * y)
# 求最大值:遍历字典
best_id = -1
best_val = None
for i, (name, x, y, val) in records.items():
if best_val is None or val > best_val:
best_val = val
best_id = i
print(best_id, best_val)
main()
也可以利用 max() + key 一行求出:
# max 遍历 items,按 value[3](即 x*y)比较
best_id, best_rec = max(records.items(), key=lambda kv: kv[1][3])
print(best_id, best_rec[3])
注意:
max(...)遇到相同值时返回第一个(因为>比较只在严格大于时更新)。这正好和"保留最早编号"的语义一致。
A.3.5 其它停止条件的变体
变体 1:整行为 -1 时停止
while True:
line = read()
if not line:
break
line = line.strip()
if line == "-1":
break
if not line:
continue
parts = line.split()
# ... 后续同主例
变体 2:某个数字字段为 -1 时停止
parts = line.split()
x = int(parts[1])
y = int(parts[2])
if x == -1 or y == -1:
break
name = parts[0]
变体 3:读到 EOF 为止(没有显式停止符)
while True:
line = read()
if not line: # EOF
break
line = line.strip()
if not line:
continue
# ... 处理
变体 4:一次性读入全部数据(最快)
import sys
def main():
data = sys.stdin.buffer.read().split()
# data 是 list[bytes],每个元素形如 b'123'、b'\xe5\xbc\xa0\xe4\xb8\x89'
# 中文名字需要先 decode('utf-8') 才能作为 str 处理
n_records = 0
best_val, best_id = None, 0
i = 0
while i + 2 < len(data):
name_b = data[i]
if name_b == b"-1":
break
name = name_b.decode("utf-8") # bytes -> str
x = int(data[i + 1])
y = int(data[i + 2])
i += 3
n_records += 1
val = x * y
if best_val is None or val > best_val:
best_val = val
best_id = n_records
print(best_id, best_val)
main()
关键点:
sys.stdin.buffer.read()返回的是bytes,中文名字是 UTF-8 字节序列,不能直接当 str 用(判断== b"-1"要用 bytes 字面量b"-1")。需要decode。
如果数据量不大、或者输入中没有中文,用sys.stdin.read().split()(返回str列表)更简单。
A.3.6 常见错误对照
| 错误写法 | 问题 | 正确写法 |
|---|---|---|
for _ in range(n): |
\(n\) 未给出,无法确定次数 | while True: + break |
n = int(input()) |
第一行不是 \(n\),是数据 | 直接 while 循环读行 |
x, y = map(int, input().split()) |
一行有三个字段(含名字),解包数量不匹配 | 先 split() 再取 [1]、[2] |
x, y = input().split()[1:] |
得到的是字符串,x*y 会拼接字符串 |
x = int(parts[1]) 显式转换 |
if x == "-1": break |
字符串与整数比较永远不相等 | if parts[0] == "-1" 或 if int(parts[1]) == -1 |
未做 if not line 判断 |
读到 EOF 后 input() 抛 EOFError |
sys.stdin.readline() 读到 EOF 返回 "",if not line: break |
best_val = 0 初始值 |
如果所有 \(x \times y\) 都是负数,结果错 | 初始值设 None,或设 -float('inf') |
未做 if val > best_val 严格比较 |
相同值时编号被后来的覆盖 | 用 > 严格大于,保留先出现的编号 |
中文名用 len() 判断长度 |
中文 len("张三") 是 2,与字符数一致(Python 3 按码点) |
没问题;但 len 对 Emoji 等可能不一样,一般不必担心 |
name = parts[0].strip() |
.split() 已去掉首尾空白,再 strip 冗余 |
name = parts[0] 即可 |
用 input() 读大输入 |
慢,可能 TLE | sys.stdin.readline 或 sys.stdin.buffer.read().split() |
A.3.7 用 C++ 对照一遍
同样逻辑的 C++ 写法,方便对照理解:
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string name;
int x, y;
int idx = 0;
long long best_val = LLONG_MIN;
int best_id = -1;
while (cin >> name) {
if (name == "-1") break;
cin >> x >> y;
idx++;
long long val = 1LL * x * y;
if (val > best_val) {
best_val = val;
best_id = idx;
}
}
cout << best_id << ' ' << best_val << '\n';
return 0;
}
对照要点:
| 步骤 | C++ | Python |
|---|---|---|
| 读名字 | cin >> name |
parts[0](split() 后) |
| 读数字 | cin >> x >> y |
int(parts[1])、int(parts[2]) |
| 停止判断 | if (name == "-1") |
if name == "-1" |
| 最大值初始 | LLONG_MIN |
None 或 -float('inf') |
| 严格比较 | if (val > best_val) |
if val > best_val |
| 编号 | 手动 idx++ |
手动 idx += 1 |
| 一行读三字段 | 多次 >> 自动跳过空白 |
一次 split() 后按索引取 |
最大的思维差异:C++ 的
cin >>可以混读任意类型并自动跳过空白,Python 没有这种"流式"读入,必须先整行split(),再逐字段转换。这是 C++ 选手迁移 Python 时必须牢牢记住的模式。
A.3.8 一行一行读 vs 一次性读的取舍
| 场景 | 推荐方式 |
|---|---|
| \(n \le 10^4\),数据量小 | input() 或 sys.stdin.readline |
| \(n \le 10^6\),数据量中等 | sys.stdin.readline + 局部变量缓存 |
| \(n \ge 10^6\),数据量很大 | sys.stdin.buffer.read().split() 一次性读 |
| 输入有中文且 \(n\) 很大 | sys.stdin.buffer.read().split() + decode |
更快的读入模板:
import sys
def main():
data = sys.stdin.buffer.read().split()
i = 0
n = int(data[i]); i += 1
a = [0] * n
for k in range(n):
a[k] = int(data[i]); i += 1
# ...
int(bytes) 在 Python 3 中也可以直接用(不需要先 decode),例如 int(b"123") == 123。只有需要当字符串比较或打印时才必须 decode。
A.4 小结
-
列表:
- 赋值是引用,要拷贝用
.copy()、[:]、list(); - 二维列表必须用列表推导式
[[0]*m for _ in range(n)],不能用[[0]*m]*n; - 切片
a[l:r]左闭右开,a[::-1]反转; sort()原地排序返回None,sorted()返回新列表。
- 赋值是引用,要拷贝用
-
字典:
d[k]在 key 不存在时抛异常(与 C++map自动创建 0 完全不同);- 用
d.get(k, default)、defaultdict、Counter避免异常; - key 必须可哈希(
str、int、tuple可以,list、set、dict不行); - 3.7+ 的
dict保持插入顺序。
-
未知行数读入:
- 用
while True: line = read(); if not line: break处理 EOF; sys.stdin.readline()读到 EOF 返回'',不会抛EOFError(input()会);- 停止条件要明确是哪个字段的
-1; - 大输入用
sys.stdin.buffer.read().split()一次性读入。
- 用
-
中文名字:
- Python 3 的
str天然支持,split()、==都没有问题; - 唯一要注意的是名字里是否有空格——有空格时要
rsplit(maxsplit=2); - 用
buffer.read()得到bytes时,需要decode('utf-8')才能当字符串处理。
- Python 3 的
-
最大值/最小值跟踪:
- 初始值用
None最安全(避免所有值都是负数时错误); - 或用
-float('inf')/float('inf'); - 用严格大于
>保留先出现的最优解,用>=保留后出现的。
- 初始值用
掌握这几条,C++ 选手迁移 Python 的"第一桶金"就站稳了。剩下的就是多写、多对拍、多查文档。
后话
- 基础差不多了

浙公网安备 33010602011771号