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)。


目录

  1. Python 与 C++ 的总体差异
  2. 注释、缩进与代码块
  3. 变量、类型与类型转换
  4. 输入输出(重点)
  5. 运算符
  6. 控制流
  7. 字符串
  8. 容器:list / tuple / dict / set
  9. 函数
  10. 类与对象
  11. 异常处理
  12. 文件读写
  13. 常用 import 汇总
  14. C++ 选手最容易踩的坑
  15. 竞赛模板
  16. 语法速查对照表

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 会对每个参数自动加分隔符,所以不要写 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 运算符优先级(从高到低,节选)

\[\begin{aligned} &\texttt{**} \\ &\texttt{+x,\ -x,\ \sim x} \\ &\texttt{*,\ /,\ //,\ \%} \\ &\texttt{+,\ -} \\ &\texttt{<<,\ >>} \\ &\texttt{\&} \\ &\texttt{\textasciicircum} \\ &\texttt{|} \\ &\texttt{==,\ !=,\ <,\ <=,\ >,\ >=,\ in,\ is} \\ &\texttt{not} \\ &\texttt{and} \\ &\texttt{or} \\ &\texttt{if-else\ 三元} \end{aligned} \]


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++ 选手最容易踩的坑

  1. / 是真除法,整除用 //

    print(7 / 2)    # 3.5
    print(7 // 2)   # 3
    
  2. // 和 % 对负数是向下取整,与 C++ 不同

    print(-7 // 2, -7 % 3)   # -4 2   (C++ 是 -3 -1)
    
  3. 没有 ++ / --

    i += 1     # ✅
    i++        # ❌ 语法错误
    
  4. [[0]*m]*n 是浅拷贝陷阱

    g = [[0] * m for _ in range(n)]   # ✅
    
  5. 赋值是"贴标签",不是拷贝

    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)   # 深拷贝
    
  6. 可变对象不能做 set 元素 / dict key

    s = {(1, 2)}     # ✅ 元组可以
    s = {[1, 2]}     # ❌ 列表不可哈希
    
  7. input() 永远返回字符串

    n = input()          # "5"
    n = int(input())     # 5
    
  8. print(a, " ", b) 会多空格

    print(a, b)          # ✅
    print(f"{a} {b}")    # ✅
    
  9. 默认参数不要用可变对象

    def f(lst=[]): ...   # ❌
    def f(lst=None): ... # ✅
    
  10. 递归深度默认 1000

    import sys
    sys.setrecursionlimit(1 << 20)
    
  11. 字符串不可变,拼接用 join

    s = "".join(parts)   # ✅ O(n)
    s += c               # ❌ 循环中 O(n^2)
    
  12. is 是身份比较,== 是值比较

    a = [1, 2]
    b = [1, 2]
    a == b     # True
    a is b     # False
    x is None  # ✅ 这是 is 的正确用法
    
  13. sort() 原地排序返回 None

    a = a.sort()          # ❌ a 变成 None!
    a.sort()              # ✅
    b = sorted(a)         # ✅ 返回新列表
    
  14. for 循环中修改列表长度会出错

    for x in a:
        a.remove(x)       # ❌ 危险
    # 应该遍历副本:
    for x in a[:]:
        a.remove(x)
    
  15. 整数除法大数精度

    int(10**18 / 3)       # ❌ 浮点丢精度
    10**18 // 3           # ✅
    
  16. round() 是银行家舍入

    round(2.5)    # 2  (不是 3!)
    round(3.5)    # 4
    

    竞赛中需要四舍五入用 int(x + 0.5)(非负时)或 math.floor(x + 0.5)。

  17. bool 是 int 的子类

    True + True   # 2
    
  18. list 的 pop(0)、insert(0, x) 是 O(n)
    队列用 collections.deque。

  19. dict 是无序?不,3.7+ 保证插入顺序,但 set 仍无序。

  20. 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 的关键不是"语法难",而是:

  1. 改掉 C 风格的思维(for(int i...) → for x in ...,{} → 缩进);
  2. 记住 I/O 是完全不同的模型(input().split() + map(int, ...) 要烂熟于心);
  3. 警惕引用语义、可变默认参数、浅拷贝这些 C++ 里不存在或表现不同的坑;
  4. 知道什么时候该用 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 时几乎所有高频坑点:

  1. 未给出 \(n\),需要循环读到停止条件;
  2. 一行三个字段,但 名字是中文;
  3. 停止条件 -1 的判断位置(是名字还是某个数?);
  4. 编号怎么算(记录第几个输入);
  5. 最大值怎么跟踪;
  6. 输入效率(\(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,直接处理即可。

但要注意两点:

  1. 中文名字不能含空格。如果名字里可能带空格(例如"张 三"),就不能用 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!
    
  2. 判断名字是否为 -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 小结

  1. 列表:

    • 赋值是引用,要拷贝用 .copy()、[:]、list();
    • 二维列表必须用列表推导式 [[0]*m for _ in range(n)],不能用 [[0]*m]*n;
    • 切片 a[l:r] 左闭右开,a[::-1] 反转;
    • sort() 原地排序返回 None,sorted() 返回新列表。
  2. 字典:

    • d[k] 在 key 不存在时抛异常(与 C++ map 自动创建 0 完全不同);
    • 用 d.get(k, default)、defaultdict、Counter 避免异常;
    • key 必须可哈希(str、int、tuple 可以,list、set、dict 不行);
    • 3.7+ 的 dict 保持插入顺序。
  3. 未知行数读入:

    • 用 while True: line = read(); if not line: break 处理 EOF;
    • sys.stdin.readline() 读到 EOF 返回 '',不会抛 EOFError(input() 会);
    • 停止条件要明确是哪个字段的 -1;
    • 大输入用 sys.stdin.buffer.read().split() 一次性读入。
  4. 中文名字:

    • Python 3 的 str 天然支持,split()、== 都没有问题;
    • 唯一要注意的是名字里是否有空格——有空格时要 rsplit(maxsplit=2);
    • 用 buffer.read() 得到 bytes 时,需要 decode('utf-8') 才能当字符串处理。
  5. 最大值/最小值跟踪:

    • 初始值用 None 最安全(避免所有值都是负数时错误);
    • 或用 -float('inf') / float('inf');
    • 用严格大于 > 保留先出现的最优解,用 >= 保留后出现的。

掌握这几条,C++ 选手迁移 Python 的"第一桶金"就站稳了。剩下的就是多写、多对拍、多查文档。

后话

  • 基础差不多了
posted @ 2026-08-22 11:42  msjing  阅读(42)  评论(6)    收藏  举报