0xB 写在前面的话

本文档是 Python 数据分析考试的参考/复习资料，涵盖 基本语法、常用函数、简单算法实现 等内容。

• 适用人群：一编程基础的同学（备考）
• 纯粹没过函数的或者自己写过的请不要用本文档，本文档不包含足够例子！
• 作者：Danvei233（@GitHub）
• 第零章是基本语法和纲要（速查）
• 使用GPT-o3润色

0xD 目录

[TOC]

0x0 基本语法与数据类型

0.1 变量与数据类型概览

提示：type(obj) 可查看变量实际类型，isinstance(obj, T) 用于类型判断（推荐），构造函数可以用于转换类型。

0.2 函数及其结构

函数：带名字的可复用代码块，对输入（参数）进行处理并可返回输出（返回值）。

0.2.1 定义语法

1
2
3
4
5

def function_name(param1, param2=default):
    """文档字符串（可选）"""
    # 函数体（4 个空格缩进）
    ...
    return value  # 返回值可省略，相当于 return None

• def 关键字后跟函数名和参数列表，末尾必须有冒号 :。
• 函数体必须统一缩进（推荐 4 个空格）。
• return 没有表达式时等价于 return None。

0.2.2 函数命名规则

• 不与现有标识符重复，区分大小写。
• 以字母或 _ 开头，不能以数字开头，且不含特殊符号。
• 推荐 snake_case 或驼峰 camelCase，关键是自描述。 例如：is_leap_year(year) 一看即知其功能与返回值。

0.2.3 参数类型

1. 位置参数：调用时按顺序一一对应。
2. 默认参数：形参中写 param=value 并放在末尾，可在调用时省略。
3. 可变长度：*args、**kwargs（进阶用法，考试可选）。

参数在函数调用结束后即被销毁，仅在函数体内部可见。

0.2.4 调用函数

1
2
3
4

def is_leap_year(y):
    return (y % 4 == 0 and y % 100 != 0) or (y % 400 == 0)

result = is_leap_year(2024)  # 返回 True

0.2.5 变量作用域

• 局部变量：在函数体内声明，只在该函数内可见。
• 全局变量：在函数外部声明；若需在函数中修改，必须使用 global 关键字。

0.3 对象（class）

一句话： 类是“设计图”，对象是根据设计图做出的“实物”。

0.3.1 代码骨架（从上到下一次写完）

1
2
3
4
5
6
7
8

class MyClass:            # ① class 开头，冒号不能丢
    common_val = 0        # ② 类变量：所有对象共用

    def __init__(self, val):  # ③ 初始化，a = MyClass(10) 时自动调用
        self.val = val        #    self 就是“这台机器”

    def method1(self, x):     # ④ 自定义方法
        print(self.val + x)

写顺序：class ➜ 类变量 ➜ __init__ ➜ 其他 def，全部 4 空格缩进。

0.3.2 实例化（真机到手）

1
2

a = MyClass(10)   # 造一台对象
a.method1(5)      # 输出 15

• 访问属性：a.val 或 MyClass.common_val。
• 改类变量：MyClass.common_val = 99 ➜ 所有对象一起变。

0.3.3 速记要点

1. **self** 必写：缺了会报错 missing 1 required positional argument: 'self'。
2. 类变量 vs 实例变量：类变量大家共用；实例变量(self.xxx)只属于自己。
3. 私有/保护名：
   • _name 单下划线：只是提醒“内部用”。
   • __name 双下划线：Python 会改名混淆，一般外部访问不到。

0.4 包（package）

一句话： 包就是把相关功能组织成文件夹，让项目结构清晰。

0.4.1 包的基本结构

1
2
3
4
5
6

project_folder/
├─ package_name/      # 包（文件夹）
│   ├─ __init__.py    # 标记此目录为包，可为空
│   ├─ module1.py     # 模块（.py 文件）
│   └─ module2.py
└─ main.py            # 使用包的脚本

• 包 (package_name) 是包含 __init__.py 的文件夹。
• 模块 (module1.py) 可以导入、调用其中的变量、函数、类。

0.4.2 导入语法示例

1
2
3
4
5
6
7

import package_name             # 导入整个包
import package_name.module1     # 导入模块
from package_name import module2  # 从包里导入模块
from package_name.module1 import func1  # 导入模块中的函数

import package_name as pkg      # 起别名，方便书写
from package_name.module1 import ClassA as CA

• 注意语法顺序：必须写作 from 包名 import 名称，而 **import 名称 from 包名** 是不合法的。
• import ... as 可以给包或模块起简短别名。
• from ... import ... 让调用更直接（无需写全路径）。

0.4.3 常见用途

• 将不同功能拆分到不同模块，保持代码整洁。
• 方便多人协作，每人维护独立模块。

0.5 数字类型计算

0.5.1 数字类别回顾

• int：任意精度整数，如 42、0b1010。
• float：双精度浮点，如 3.14、6.02e23。
• complex：形如 3+4j，含实部和虚部。

0.5.2 一元运算与常用函数

0.5.3 二元运算符

0.5.4 math 标准库速查

1
2
3
4
5
6

import math
math.sqrt(9)          # 3.0 开根
math.ceil(2.3)         # 3 上取整
math.floor(2.9)        # 2 下取整
math.factorial(5)      # 120 阶乘
math.pi, math.e        # 圆周率和自然常数

需要高精度时，使用 from decimal import Decimal；处理分数可用 from fractions import Fraction。

0.5.5 精度陷阱与解决办法

1
2
3

0.1 + 0.1 + 0.1 == 0.3   # False
from decimal import Decimal as D
D('0.1')*3 == D('0.3')   # True

0.5.6 小技巧

• 环绕取模：凯撒偏移 (idx + k) % 26。例2：把输入的数字映射到星期：

  1 2 3

  week = ['日','一','二','三','四','五','六'] i = int(input('输入数字（任意整数）：')) % 7 print('星期' + week[i])

• 取十位：n // 10 % 10；（//留高位 %留低位） 后三位：n % 1000。

• 商余同得：q, r = divmod(n, m)。

0.6 分支控制与循环

0.6.1 比较与逻辑运算符

真值规则：0、None, False 为假，其他皆真。

0.6.2 if / elif / else

1
2
3
4
5
6
7

score = 85
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
else:
    grade = 'C or below'

• 三元表达式：gender = '男' if isBoy(me) else '女'。

0.6.3 循环结构

while

1
2
3
4
5
6
7

n = 1
while n < 100:
    n *= 2
    if n == 64:
        break          # 提前结束循环
else:
    print('正常结束')   # 未被 break 时才执行

for

1
2

for i in range(0, 5,1):
    print(i)  # 0,1,2,3,4

• 遍历字典：for k,v in d.items():(更多请看下面)。

• range(start, stop, step) 不含 stop，step 可为负。

• 同时遍历两个序列：

  1 2	for a, b in zip(list1, list2): ...

推导式

1
2
3

squares = [x*x for x in range(10) if x%2==0]
odd_map = {x: x%2 for x in range(5)}
unique = {c.lower() for c in 'Hello'}

0.6.4 循环相关语句

• break：退出最近一层循环。
• continue：跳过本次迭代，继续下一次。
• pass：占位语句，什么都不做。

0.6.5 常见坑

• 浮点比较：用 abs(a-b) < 1e-9。
• 修改列表时遍历：可先复制 for x in lst[:] 或倒序遍历。
• 死循环：确保循环体内有让条件变假的语句。

后续章节：文件 I/O、Numpy & Pandas 简明指南…

分支（if / elif / else）

1
2
3
4
5
6

if 条件表达式:
    # 代码块
elif 另一个条件:
    # 代码块
else:
    # 代码块

• 条件表达式由比较运算符（== != > < <= >=）和逻辑运算符（not and or）组合而成。
• 禁止在条件中用浮点数判断相等，易出错。必要时用整数或阈值范围判断。
• 可以写 if x in some_list 或 if key in some_dict。

循环

1
2
3
4
5
6
7

# while 循环
while 条件:
    # 代码块

# for 循环
for i in iterable:   # iterable 可为字符串、列表、range 等
    # 代码块

• range(start, end, step)：包含 start，不包含 end，步长 step。

• 遍历字典：

  • for k, v in d.items():
  • for k in d.keys():
  • for v in d.values():

• 列表推导式：

  1	new_list = [f(x) for x in iterable if 条件]

0x1 数据结构与文件操作

1.0 字符串

1.0.1 定义字符串

• 单引号或双引号包裹：

  1 2	a = "hello" b = 'world'

• 三引号用于多行文本：

  1 2 3 4

  text = """ 第一行 第二行 """

• 原始字符串（不处理转义）：

  1	path = r"C:ew_folder est"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

- 常用转义符： `
`（换行）、`	`（制表）、`\`（反斜杠本身）。

## 1.0.2 字符串格式化

- **f-string**（Python 3.6+）：
```python
name = "Alice"
score = 95.6789
msg = f"{name} 同学成绩：{score:.2f}"  # 保留两位小数

• **format()** 方法：

  1 2 3

  template = "{0} 同学成绩：{1:.2f}".format(name, score) # 或指定名称 template2 = "{n} 成绩：{s:.1f}".format(n=name, s=score)

• 常见格式说明：

  • :.2f 保留两位小数。
  • :>10 右对齐，占 10 个字符宽度。
  • :<10 左对齐。
  • :^10 居中对齐。

1.0.3 切片与索引获取

• 按索引访问单个字符：

  1 2 3

  s = "python" s[0] # 'p' s[-1] # 'n'

• 切片（[start:stop:step]）：

  1 2 3 4 5 6

  s = "abcdefg" s[1:4] # 'bcd' (包含索引1，不包含4) s[:3] # 'abc' s[3:] # 'defg' s[::2] # 'aceg' (步长2) s[::-1] # 'gfedcba' (反转)

1.0.4 常用字符串方法

重要提示： 字符串在 Python 中是 不可变 的——几乎所有方法都会返回 新字符串，原变量保持不变。别忘了把返回值接收进变量，否则你的修改会“丢失”。

核心方法详解

• len(s) → int
  • 作用：返回长度。
  • 返回值：整数。原字符串不变。
• s.upper() / s.lower() → str
  • 作用：大小写转换。
  • 返回值：新字符串；s 本身不变。
• s.find(sub, start=0, end=len) → int
  • 作用：子串第一次出现的位置。
  • 返回值：索引；未找到返回 -1。
• s.replace(old, new, count=-1) → str
  • 作用：把所有（或前 count 个）old 换成 new。
  • 返回值：新字符串；不会就地修改。
• s.split(sep=None, maxsplit=-1) → list[str]
  • 作用：按分隔符拆成列表；默认按空白拆。
  • 返回值：列表；原字符串不变。
• sep.join(iterable) → str
  • 作用：把迭代器里的元素用 sep 连接。
  • 返回值：新字符串。
  • 小技巧：' '.join(['Hello', 'Python']) → 'Hello Python'。
• s.strip(chars=None) / lstrip / rstrip → str
  • 作用：去掉两端或左/右侧指定字符（默认空白）。
  • 返回值：新字符串。
• 判断类方法（返回 bool）：
  • s.isalpha()：全是字母。
  • s.isdigit()：全是数字。
  • s.isalnum()：字母或数字。
  • s.startswith(prefix) / s.endswith(suffix)：前缀/后缀判断。
• 其他常用格式化/变形：
  • s.title()：每个单词首字母大写。
  • s.capitalize()：首字母大写，其余小写。
  • 切片反转：s[::-1]。
  • s.strip() # 去除首尾空白 s.lstrip() # 去除左侧空白 s.rstrip() # 去除右侧空白

例子汇总

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

s = " hello, python3 "
print(len(s))                # 15
print(s.strip().upper())     # 'HELLO, PYTHON3'
print(s.find('py'))          # 8
print(s.replace('python3', 'world'))  # ' hello, world '
print('-'.join(['A','B','C']))        # 'A-B-C'

# 字符编码互转
print(ord('A'))              # 65 （字符→码点）
print(chr(9731))             # '☃' （码点→字符）

1.0.5 输入与输出

input()

1
2
3
4
5
6

name = input("请输入姓名：")       # 始终返回 str
age  = int(input("年龄："))      # 转成 int
x, y = input().split()            # 用空格分割成两个变量（str）
a, b = map(float, input().split()) # map(类型, 可迭代) → map 对象，需要再外层转换
nums = list(map(int, input().split()))  # 先 map 再 list 得到整数列表
c, d = eval(input())              # 输入形如 "(3,4)"；⚠️ eval 有安全风险

• map(func, iterable) 会返回 **map** 对象（惰性迭代器），常见用法是再包一层 list()、tuple() 或直接用在 for 循环里：for x in map(int, data): ...。
• input(prompt) 在控制台显示提示文字，等待用户敲回车。
• 返回值永远是字符串，需要时自行用 int() / float() / split() 等转换。

print()

1
2
3
4

print("Hello", "World")                 # 默认空格分隔，换行结束
print("A", "B", "C", sep="-", end="!
")  # 自定义分隔符与结尾
print(f"{name=}")                       # 调试利器，Python 3.8+

• 关键字参数：
  • sep：多个参数之间的分隔符，默认 ' '。
  • end：行尾结束符，默认 ' '；改成 '' 可取消自动换行。
  • file：输出目标，默认 sys.stdout；可重定向到文件对象。
  • flush：True 时立即刷新缓冲区。

小贴士：print(*iterable, sep=' ') 可快速逐行打印列表内容。

1.0.6 map()

1
2
3
4
5
6

python复制编辑# 将用户输入的数字用空格分隔并转换成 int
a, b, c = map(int, input("输入 3 个整数，用空格隔开：").split())
# 说明：
#   map(类型, 可迭代对象) → 返回一个 map 对象（惰性迭代器）
#   想立即得到列表可再套一层 list()
nums = list(map(float, input().split()))

小结

• map() 不会立刻产生新列表，而是返回 map 对象；如果要多次使用，最好 list(map(...))。
• eval(input()) 能一次读多个 Python 表达式并直接变成对应类型，但有 安全隐患；考试能用就用，开发别随便用。

1.1 列表

1.1.1 创建方式

1
2
3
4
5

empty = []                 # 字面量空列表
empty2 = list()            # 构造函数
mix   = [1, 2, "3"]        # 混合类型
copy  = [a, b]             # 存变量时只存“引用”，不会连带修改历史值
matrix = [[0]*3 for _ in range(2)]   # 2×3 二维表，推荐列表推导式

1.1.2 访问与切片

1
2
3
4

v = mix[0]        # 第 1 个，下标从 0 开始
last = mix[-1]    # 倒数第 1 个
sub = mix[1:3]    # [start, end) 切片
rev = mix[::-1]   # 反转

1.1.3 常用统计函数

1
2
3
4
5

n   = len(nums)         # 长度
s   = sum(nums)         # 求和（元素需可相加）
avg = s / n             # 平均值
hi, lo = max(nums), min(nums)
nums_sorted = sorted(nums)      # 返回“新列表”

1.1.4 修改与管理方法

• sort() vs sorted()：lst.sort() 会直接改变原列表且返回 None；sorted(lst) 则生成新列表并保持原列表不变。
• 不可变对象（如字符串）放进列表后，列表里只是存“引用”，若对象本身不可变就安全；可变对象（如另一个列表）若在别处修改，会反映到这里。

这样一来，数字‑字符串‑列表三大“最常用基本类型”就都有完整速查了。 如果还想再补其它容器（如元组、字典）或深入讲 sort() 的自定义 key，随时说！

## 1.2 字典（dict）

### 1.2.1 创建与赋值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 空字典
d1 = {}          # 字面量
d2 = dict()      # 构造函数
d2=zip(list1,list2) #用列表构造 取最短 第一个是键
# 带内容
info = {"name": "Tom", "age": 18}
## 如果重复 后面的会覆盖前面的
# 动态添加 / 修改
info["city"] = "Beijing"    # 如果 key 不存在就创建，存在就改值

# 推导式
squares = {x: x**2 for x in range(5)}   # {0:0, 1:1, 2:4, …}

键必须唯一，而且必须是可哈希的不可变对象（数字、字符串、元组…）。

### 1.2.2 安全取值 直接 d[key] 若键不存在会抛 KeyError。常见两种“稳取”写法：

1
2
3
4

if "age" in info:          # 先判断
    print(info["age"])

print(info.get("score", 0))   # 若无则给默认 0

### 1.2.3 常用方法速查

### 1.2.4 遍历套路

1
2
3
4
5
6
7

# 遍历键
for k in info:
    print(k, info[k])
#！！默认只遍历键
# 同时拿键和值
for k, v in info.items():
    print(f"{k} --> {v}")

### 1.2.5 字典排序

1. 按键排序（最简单）

   1 2	for k in sorted(info): # 默认升序 print(k, info[k])

2. 按值排序

   1 2	# sorted() 接收 key=，返回的是新列表 items = sorted(info.items(), key=lambda kv: kv[1]) # 按 value 升序

3. 多级排序 lambda 返回 元组 → 先比第一项，再比第二项：

   1 2	# 先按 value 降序，再按 key 升序 items = sorted(info.items(), key=lambda kv: (-kv[1], kv[0]))

   如果想对「多级元组排序」再整体反转，请不要写 sorted(..., reverse=True) —— 这样会把所有维度一起翻转； 正确做法：

   1. 先写好带正负号的多级 key；
   2. 或者先排好，再调用一次 items.reverse()。

### 1.2.6 lambda 一口讲清

• lambda 参数: 表达式 → 匿名小函数，用一次就丢。

• 在 sorted, map, filter 等场景下当“回调”最常见。

  1 2	# 把字典按 value 从大到小排 sorted(info.items(), key=lambda kv: kv[1], reverse=True)

小贴士

1. 字典元素无序（Python 3.7+ 保证“插入顺序”但不用于逻辑排序）。
2. pop() / update() 都会修改原字典；想保持原数据别直接动它。
3. 字典很适合当“哈希表”做 O(1) 查询，例如记录字符频次、缓存计算结果等。

## 1.3 文件简单操作

### 1.3.1 open() 基本语法

1

f = open(filepath, mode="r", encoding="utf‑8")

• "w" 会清空旧文件；若想安全一些，先用 "a" 或检查 os.path.exists()。
• 省略 encoding 可能在不同系统读写中文时乱码，最好显式写 "utf‑8"。

### 1.3.2 推荐写法：with … as

1
2
3

with open("data.txt", "r", encoding="utf-8") as f:
    text = f.read()
# 离开 with 块，文件自动 close()

考点：用 *with* 可以自动关闭文件，省去 *f.close()*，也能避免忘关导致数据没落盘。

### 1.3.3 常用读写方法

• 读完后文件指针在末尾，想再读需要 f.seek(0) 把指针移回开头。
• write() 不自动换行，记得手动加 \n。
• 二进制模式 ("rb", "wb") 读写得到/要求 bytes 而非 str。

### 1.3.4 最常见 2 个模板

① 逐行读取并处理

1
2
3
4

with open("score.txt", "r", encoding="utf-8") as f:
    for line in f:              # f 本身就可迭代
        name, score = line.split()
        ...

② 写分析结果

1
2
3
4

with open("result.txt", "w", encoding="utf-8") as f:
    f.write(f"Average {avg:.1f}\n")
    for k, v in top_items:
        f.write(f"{k} {v}\n")

只要记住“with open(...) as f: ➜ f.read / f.write ➜ 自动关闭”，文件 I/O 的基础就够用了。

0x2 数据分析

#此节过于坑爹（半节课讲了4-5节的内容？？） 故附上官方文档以供打印！本文档此处只简单列出基础用法。用于提示！！！！！

NumPy：初学者的绝对基础_Numpy中文网

入门教程 — pandas 2.2.3 文档 - pandas 数据分析库

2.1 NumPy 库

一句话记住： NumPy = 超快多维数组 + 矢量化数学运算。

1	import numpy as np # ⚠️ 别写成 import np as np

2.1.1 数组创建

2.1.1.1 随机数组

2.1.2 数组修改

2.1.2.1 形状 & 类型

2.1.2.2 数据级改动

• 切片换序：a[::-1]、a[:, ::-1]
• 合并：np.concatenate([a,b], axis=…)
• 插入：np.insert(a, index, values, axis=…)

2.1.3 属性查询 & 切片

• 多维切片范式

  1 2	a[:, s:e:step] # 多行部分列 a[i, j] # 单个元素

2.1.4 逻辑运算 & 条件筛

1
2
3

mask = (a >= 5)          # 布尔矩阵
a2   = a[mask]           # ⚠️ mask 必须是 bool 同尺寸
sel  = np.where(mask, x, y)   # 三参缺一不可

⚠️ 逻辑运算符要用 ***\**\*&\*\**\*** / ***\**\*|\*\**\***，并加括号

1	(a > 1) & (a < 5)

2.1.5 广播 (Broadcasting)

• 向量/矩阵乘法

  1 2	np.dot(a, b) # 点乘 np.cross(a, b) # 叉乘

2.1.6 统计 & 聚合

轴解释：axis=0 ⇢ 按行聚合（看成“列方向”）；axis=1 ⇢ 按列聚合。

2.1.7 拷贝语义

2.1.8 删除 & 去重

⚡ 速记清单

1. **import numpy as np**（别写成 import np）。
2. 随机数组：random.random(shape) 只能形状元组，random.randn 直接写维度。
3. 逻辑运算记得 **&**** / ***\*|\**** + 括号**。
4. np.where(cond, x, y) 三个参数不可少。
5. 转置 a.T，改形 a.reshape(new_shape) 不改变元素总数。
6. view() 共享数据，copy() 独立数据。
7. 0**0 == 1；1/0 → inf。
8. np.delete 的 axis 表示在哪个轴上删索引，写错会降维。

2.2 Pandas 库概览

一句话记住： Pandas = “带标签的一维 Series + 二维 DataFrame” + 大量 SQL 风格操作

1	import pandas as pd # ⚠️ 别写成 import pandas as np

2.2.1 读入数据

1
2

df = pd.read_csv("data.csv", sep=",", index_col=0)
df.head(4)          # 预览前 4 行

基本信息速查

1
2
3
4
5

df.shape       # (行, 列)
df.columns     # Index([...])
df.index       # RangeIndex / DatetimeIndex …
df.dtypes      # 每列类型
df.size        # 元素总数

2.2.2 核心数据结构

2.2.2.1 Series 访问

1
2
3

s['label']          # 单元素
s[3:8]              # 切片
s[['a','b']]        # 传列表仍得到 Series

2.2.2.2 DataFrame 访问

⚠️ **.iloc** 不支持布尔 / label，只接受整数；切片右端 包含。

2.2.3 查询（五大套路）

1. **loc** — 最推荐：逻辑、切片、函数一把抓

   1 2 3

   df.loc[(df['name']!='NaN') & (df['age']>18)] df.loc['20240101':'20240131'] df.loc[lambda d: d['score'] > 90]

2. **iloc**：纯数字行列

3. **where**：保持原形，条件不满足处填 NaN

4. **query**：SQL 风格字符串，列名可直接写

   1	df.query("age > 18 and city == 'Beijing'")

5. 布尔索引：mask = (df['x']>0); df[mask]

2.2.4 新增 / 修改列

2.2.5 统计与描述

1
2
3
4
5

df.describe()            # 数值列：均值、四分位…
df['col'].mean()
df['col'].max()
df['col'].min()
df['col'].value_counts() # 类别计数

2.2.6 缺失值处理

2.2.7 排序 & 重排

1

df.sort_values(by=['score','age'], ascending=[False,True], inplace=True)

⚡ 速记清单

1. **read_csv** 参数：**sep**+**header**+**names**+**index_col**；header=True 写法会炸！
2. Series/DataFrame 首字母大写。
3. **loc** 万能：标签、逻辑、函数，且可同时赋值。
4. .iloc 只认整数位；切片右端包含。
5. 新列可直接 df['new'] = …；行级计算记得 axis=1。
6. 缺失值：dropna vs fillna，method='ffill'/'bfill'。
7. value_counts() 计类别；describe() 看全貌。
8. sort_values 支持多列 & 不同升降序：ascending=[…]。

2.3 Matplotlib – pyplot 速查

核心流程

1. plt.figure() 创建画布
2. plt.plot()／plt.scatter() 绘图
3. 设置标题、标签、网格、图例
4. plt.savefig() + plt.show() 输出

2.3.1 画布

1
2
3

import matplotlib.pyplot as plt

plt.figure(figsize=(6, 4), dpi=100)   # 6×4 英寸，100 DPI

• 若不调用 plt.figure()，会默认创建一个新画布。
• fig = plt.gcf() 可以获取当前 Figure 对象。

2.3.2 直线图：plt.plot

1
2
3
4

plt.plot(x, y, fmt,
         linewidth=2,
         alpha=0.8,
         label="Series-A")

• **fmt**** = 颜色 + 标记 + 线型**（顺序不限，可缺省其中任意部分）。

1
2
3

plt.plot(x, y, "ro--")    # red circle + dashed line
plt.plot(x2, y2, "g^:")   # green triangle_up + dotted line
plt.plot(x3, y3, "k*")    # black star, no line

⚠️

• 只要线条、默认蓝色："-" 等同于 "b-"
• 只要标记、无线条："o" 等同于 "bo"
• tri是三角形的意思

2.3.3 散点图：plt.scatter

1
2
3
4
5
6
7

plt.scatter(x, y,
            s=40,            # 点面积
            c="tomato",      # 颜色
            marker="^",      # 标记
            edgecolors="k",  # 边框色
            alpha=0.7,
            label="Points")

• 若要按数值映射颜色，可传入数组给 c= 并指定 cmap。

2.3.4 注释元素

1
2
3
4
5

plt.title("Main Title", fontsize=14)
plt.xlabel("X-Label")
plt.ylabel("Y-Label")
plt.grid(True, linestyle=":", alpha=0.3)
plt.legend(loc="best")     # 显示所有带 label 的图例

2.3.5 保存与显示

1
2

plt.savefig("figure.png", dpi=300, bbox_inches="tight")
plt.show()    # 最后调用，否则在某些环境会清空当前画布

⚡ 速记清单

1. **fmt**** (***\*plt.plot\****)** = 颜色 + 标记 + 线型，任意组合、省略。
2. 直线图 用 plt.plot(x,y, fmt)；散点图 用 plt.scatter(x,y, s, c, marker).
3. label + plt.legend() → 自动生成图例（线对应关系）。
4. 调用 plt.grid(True) 加网格；透明度由 alpha 控制。
5. 先 savefig（dpi≥150），再 show()。

0x3 常用算法与技巧

下面汇总一些在编程竞赛与日常脚本中常见又好用的小技巧，涵盖输入输出、字符串处理、循环套路、常用库、取余妙用和文件操作。复制即可记入笔记。

3.1 输入／输出 技巧

• 批量读入多变量

  1 2	# ⚠️ eval 存在安全风险，仅限竞赛或受信数据 a, b, c = eval(input()) # 输入格式如：1,2,3

• 分割并转类型

  1 2 3

  # 正确写法 a, b, c = map(int, input().split()) # 输入：1 2 3 → 全转为 int # 同理：map(float, …)、map(str, …)

• 字符间隔插入

  1 2	s = input() # e.g. "12345" print(" ".join(s)) # 输出：1 2 3 4 5

• 文本倒置／整数反转

  1 2 3 4 5

  s = input() print(s[::-1]) # 字符串倒置 n = int(input()) rev = int(str(n)[::-1]) # 整数反转

3.2 字符串与编码

• ASCII 码互转

  操作	示例
  字符 → 码点	ord('A') # 65
  码点 → 字符	chr(9731) # '☃'

• 常见范围

  范围	码点区间
  0–9	48 – 57
  A–Z	65 – 90
  a–z	97 – 122

• 切片技巧

  1 2 3 4

  s = "abcdefg" s[2:5] # 从索引 2 到 4，含头不含尾 s[:-1] # 除去最后一位 s[-1] # 仅最后一位

• 首字母／单词大写

  1 2	s.title() # 每个单词首字母大写 s.capitalize() # 仅第一个字符大写

• 空白字符处理

  1 2 3

  s.strip() # 去除首尾空白 s.lstrip() # 去除左侧空白 s.rstrip() # 去除右侧空白

• 常用判别 / 转换

  方法	说明
  s.isdigit()	全部为数字
  s.isalpha()	全部为字母
  s.isnumeric()	数字字符（含中文数字）
  s.upper()	全部转大写
  s.endswith(x)	是否以 x 结尾
  s.startswith(x)	是否以 x 开头
  s.count(sub)	子串出现次数

3.3 循环 常见模板

• 每行打印 n 个数

  1 2 3 4 5 6

  nums = list(range(1, 21)) n = 5 for i, v in enumerate(nums, 1): print(v, end=' ') if i % n == 0: print()

• 简易素数判断（$O(\sqrt n)$）

  1 2 3 4 5 6 7 8

  def is_prime(x): if x < 2: return False i = 2 while i * i <= x: if x % i == 0: return False i += 1 return True

• 乘法表

  1 2 3 4 5

  n = 9 for i in range(1, n+1): for j in range(1, i+1): print(f"{j}×{i}={i*j}", end='\t') print()

• 斐波那契

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  # 指定项数 def fib(n): a, b = 0, 1 for _ in range(n): print(a, end=' ') a, b = b, a + b print() # 指定最大值 def fib_upto(maxv): a, b = 0, 1 while a <= maxv: print(a, end=' ') a, b = b, a + b print()

3.4 取余 (%) 的妙用

• 凯撒密码（字符串循环移位）

  1 2 3 4 5 6 7 8

  def caesar(s, shift): res = [] for ch in s: if 'a' <= ch <= 'z': res.append(chr((ord(ch)-97+shift)%26 + 97)) else: res.append(ch) return ''.join(res)

• 星期循环

  1 2	days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"] idx = (idx + k) % 7

3.5 快速文件操作：with 语句

1
2
3
4

with open("file.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
# 无需手动 close()

Tips：

• 常见算法尽量封装成函数，主流程清晰；
• 注重边界条件（0,1 的特殊处理）；
• 保持代码简洁，适时注释。

3.6 排序

• 列表：lst.sort() → 原地升序；sorted(lst, reverse=True) → 新列表

• 字典：按值排序：

  1	items = sorted(d.items(), key=lambda kv: kv[1], reverse=True)

3.7 常用标准库

3.7.1 datetime

1
2
3
4

import datetime
today = datetime.date.today()
year, month, day = today.year, today.month, today.day
weekday = today.weekday()         # 0=Mon … 6=Sun

• 闰年判断

  1 2	def is_leap(y): return (y%4==0 and y%100!=0) or (y%400==0)

3.7.2 random

1
2
3
4

import random
random.seed(42)
r1 = random.randint(1, 10)        # 包括两端
r2 = random.random()              # [0,1)

3.8 常见英文单词：月份 & 星期

月份（Months）

星期（Weekdays）

⚠️ Tip：

• Python 中可用 datetime 模块获取当前月/星期，并通过以上列表做映射。
• 处理日期字符串时，经常需要识别或输出这些全称/缩写。