Python 3 基础速查

1
2
3

# macOS / Linux
python3 --version
# 输出格式：Python 3.13.11

1
2
3

# Windows PowerShell
py --version
# 输出格式：Python 3.13.11

1
2
3
4

name = "Python"
print(f"Hello, {name}!")

# 输出：Hello, Python!

1
2
3

# macOS / Linux
python3 hello.py
# 输出：Hello, Python!

1
2
3

# Windows PowerShell
py hello.py
# 输出：Hello, Python!

1
2
3
4
5

# macOS / Linux
# 用当前 python3 创建 .venv，再让当前 shell 优先使用其中的 python 和 pip
python3 -m venv .venv
source .venv/bin/activate
# 成功时通常无输出；当前 shell 的 Python 已切换到 .venv。

1
2
3
4

# Windows PowerShell
py -m venv .venv
.venv\Scripts\Activate.ps1
# 成功时通常无输出；当前 PowerShell 的 Python 已切换到 .venv。

1
2
3
4
5
6

python --version
# 输出格式：Python 3.13.x
python -m pip --version
# 输出格式：pip <版本> from <.venv 路径>/site-packages/pip (python 3.13)
python -m pip install package_name
# 输出：安装日志取决于包、索引和缓存；package_name 需要替换成真实包名。

1
2

deactivate
# 成功时通常无输出；恢复激活前的解释器搜索路径，不会删除 .venv。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

temperature = 28

if temperature >= 30:
    print("炎热")
elif temperature >= 20:
    print("舒适")
else:
    print("偏冷")

# 输出：舒适

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

def area(width: float, height: float) -> float:
    """返回矩形面积。"""
    return width * height  # 单位由调用方约定


print(area(3.0, 4.0))
print(area.__doc__)

message = '''第一行
第二行'''
print(message)

# 输出：
# 12.0
# 返回矩形面积。
# 第一行
# 第二行

1
2
3
4
5
6
7

import keyword

# kwlist 是保留关键字列表，不能用作普通变量名
print(keyword.kwlist)
# softkwlist 是软关键字列表：只在特定语法位置有特殊含义
# 例如 match、case 用于模式匹配，type 用于类型别名；其他位置仍可作为名称
print(keyword.softkwlist)

1
2

# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
# ['_', 'case', 'match', 'type']

1
2
3
4
5
6
7
8
9

value = 42
print(type(value))

value = "forty-two"
print(type(value))

# 输出：
# <class 'int'>
# <class 'str'>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

try:
    total = 1 + "2"
except TypeError as exc:
    print(f"TypeError: {exc}")

# 输出：TypeError: unsupported operand type(s) for +: 'int' and 'str'

total = 1 + int("2")
print(total)

# 输出：3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

first = [1, 2]
second = first
second.append(3)

print(first)
print(first is second)

# 输出：
# [1, 2, 3]
# True

1
2
3
4
5
6
7
8
9

number = complex(1, 2)  # 等价于 1 + 2j
print(number)
print(number.real, number.imag)
print(1j * 1j)

# 输出：
# (1+2j)
# 1.0 2.0
# (-1+0j)

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

editable = {1, 2}
editable.add(3)
fixed = frozenset([1, 2, 2])

print(sorted(editable))
print(sorted(fixed))
print(fixed | {3} == {1, 2, 3})

# 输出：
# [1, 2, 3]
# [1, 2]
# True

1
2
3
4
5
6

items: list[str] = []

if not items:
    print("列表为空")

# 输出：列表为空

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

print(7 / 2)
print(7 // 2)
print(-7 // 2)
print(2 ** 10)

# 输出：
# 3.5
# 3
# -4
# 1024

1
2
3
4
5
6
7
8

import math

print(int(-1.8))
print(math.floor(-1.8))

# 输出：
# -1，int() 向零截断
# -2，math.floor() 向下取整

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

import math

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
# 允许与零的差不超过 0.000000001
print(math.isclose(1e-10, 0.0, abs_tol=1e-9))

# 输出：
# 0.30000000000000004
# False
# True
# True

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

from decimal import Decimal, ROUND_HALF_UP

print(Decimal("0.1") + Decimal("0.2"))
price = Decimal("19.90")
print(price * 3)
# quantize 按指定小数位舍入；这里明确采用 ROUND_HALF_UP
print(Decimal("19.905").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

# 输出：
# 0.3
# 59.70
# 19.91

1
2
3
4
5

age = 24
if 18 <= age < 60:
    print("年龄在目标区间")

# 输出：年龄在目标区间

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

language = "Python"

print(language[0])
print(language[-1])
print(language[1:4])
print(language.lower())

# 输出：
# P
# n
# yth
# python

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

name = "Ada"
score = 95.678
student_id = 7

print(f"{name} 的成绩是 {score:.2f}")
print(f"学号：{student_id:03d}")
print(f"调试值：{score=}")

# 输出：
# Ada 的成绩是 95.68
# 学号：007
# 调试值：score=95.678

1
2
3

print("第一行\n第二行")
# sep 是参数间的分隔符（默认空格）；end 是输出结尾（默认换行）
print("A", "B", "C", sep=" | ", end="\n")

1
2
3

# 第一行
# 第二行
# A | B | C

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

text = "你好，Python"
payload = text.encode("utf-8")
restored = payload.decode("utf-8")

print(payload)
print(restored)

# 输出：
# b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8cPython'
# 你好，Python

1
2
3
4
5
6
7
8

raw_age = input("请输入年龄：").strip()

try:
    age = int(raw_age)
except ValueError:
    print("年龄必须是整数")
else:
    print(f"明年 {age + 1} 岁")

1
2
3
4
5

# 请输入年龄：20
# 明年 21 岁
#
# 请输入年龄：abc
# 年龄必须是整数

1
2
3
4
5
6

import getpass

password = getpass.getpass("请输入密码：")

# 支持隐藏输入的终端中，输出：请输入密码：
# 键入字符不回显，按回车后字符串保存到 password。

1
2
3
4
5
6

import json

settings = json.loads('{"theme": "dark", "page_size": 20}')
print(settings["theme"])

# 输出：dark

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

tasks = ["read", "code"]
tasks.append("review")
tasks.extend(["test", "release"])

point = (10, 20)
x, y = point

print(tasks)
print(x, y)

# 输出：
# ['read', 'code', 'review', 'test', 'release']
# 10 20

1
2
3
4
5
6
7
8

# 错误：两行引用同一个内部列表
# matrix = [[0] * 3] * 2

matrix = [[0] * 3 for _ in range(2)]
matrix[0][0] = 1
print(matrix)

# 输出：[[1, 0, 0], [0, 0, 0]]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

try:
    mapping = {[1, 2, 3]: "abc"}
except TypeError as exc:
    print(f"TypeError: {exc}")

# 输出：TypeError: unhashable type: 'list'

mapping = {(1, 2, 3): "abc"}
print(mapping[(1, 2, 3)])

# 输出：abc

1
2
3
4
5
6
7
8

user = {"name": "Ada", "age": 36}
user["city"] = "London"

for key, value in user.items():
    print(key, value)

email = user.get("email")  # 缺失时返回 None
print(email)

1
2
3
4

# name Ada
# age 36
# city London
# None

1
2
3
4
5
6
7
8

required = {"title", "content"}
provided = {"title", "content", "tags", "author"}

print(required <= provided)
print(provided - required)

# 输出：True
# 示例输出：{'tags', 'author'}，元素顺序不保证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

numbers = range(10)
squares = [number ** 2 for number in numbers if number % 2 == 0]
index = {name: position for position, name in enumerate(["Ada", "Guido"])}

print(squares)
print(index)

# 输出：
# [0, 4, 16, 36, 64]
# {'Ada': 0, 'Guido': 1}

1
2
3
4

total = sum(number ** 2 for number in range(1_000_000))
print(total)

# 输出：333332833333500000

1
2
3
4

names = ["Ada", "Guido", "Grace"]

for position, name in enumerate(names, start=1):
    print(position, name)

1
2
3

# 1 Ada
# 2 Guido
# 3 Grace

1
2
3
4
5

names = ["Ada", "Guido"]
scores = [98, 95]

for name, score in zip(names, scores, strict=True):
    print(f"{name}: {score}")

1
2

# Ada: 98
# Guido: 95

1
2
3
4

remaining = 3
while remaining > 0:
    print(remaining)
    remaining -= 1

1
2
3

# 3
# 2
# 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def describe(command: tuple[str, ...]) -> str:
    match command:  # 选择要匹配的数据
        case ("move", direction, distance):
            # 匹配三元素序列；例如 direction = "东"，distance = "3"
            return f"向 {direction} 移动 {distance}"
        case ("quit",):
            # 匹配唯一元素为 "quit" 的序列；元组中的逗号不能省略
            return "退出"
        case _:
            # _ 匹配任何剩余情况，不保存匹配值，通常放在最后
            return "未知命令"


print(describe(("move", "东", "3")))
print(describe(("quit",)))
print(describe(("status",)))

# 输出：
# 向 东 移动 3
# 退出
# 未知命令

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

from decimal import Decimal


def format_price(amount: Decimal, currency: str = "CNY", *, precision: int = 2) -> str:
    return f"{currency} {amount:.{precision}f}"


print(format_price(Decimal("19.90")))
print(format_price(Decimal("19.90"), precision=1))

# 输出：
# CNY 19.90
# CNY 19.9

1
2
3
4
5
6
7
8

def bounds(values: list[int]) -> tuple[int, int]:
    return min(values), max(values)


lowest, highest = bounds([3, 1, 8])
print(lowest, highest)

# 输出：1 8

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

# list[str] | None 是联合类型：items 可以是字符串列表，也可以是 None
# 这里的 | 表示“或”；末尾 = None 才是参数默认值，不是类型的一部分
def add_item(item: str, items: list[str] | None = None) -> list[str]:
    if items is None:
        items = []
    items.append(item)
    return items


print(add_item("read"))
print(add_item("code"))

# 输出：
# ['read']
# ['code']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def make_multiplier(factor: int):
    def multiply(value: int) -> int:
        return value * factor

    return multiply


double = make_multiplier(2)
print(double(5))

# 输出：10

1
2
3
4
5

records = [{"name": "Ada", "score": 98}, {"name": "Guido", "score": 95}]
records.sort(key=lambda record: record["score"], reverse=True)
print(records)

# 输出：[{'name': 'Ada', 'score': 98}, {'name': 'Guido', 'score': 95}]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def parse_port(raw: str) -> int:
    try:
        port = int(raw)
    except ValueError as exc:
        raise ValueError("端口必须是整数") from exc

    if not 1 <= port <= 65535:
        raise ValueError("端口必须在 1 到 65535 之间")
    return port


for raw in ("8000", "abc", "70000"):
    try:
        print(parse_port(raw))
    except ValueError as exc:
        print(f"ValueError: {exc}")

# 输出（依次对应上面的三个输入）：
# 8000
# ValueError: 端口必须是整数
# ValueError: 端口必须在 1 到 65535 之间

1
2
3
4
5
6

from pathlib import Path

path = Path("notes.txt")
with path.open("r", encoding="utf-8") as file:
    for line in file:
        print(line.rstrip())

1
2

# 第一行
# 第二行

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

from pathlib import Path

data_dir = Path("data")
print(data_dir)
print(repr(data_dir))
print(data_dir.resolve())  # 返回解析后的绝对路径对象，不修改原来的 data_dir
print(data_dir)

# 示例输出（对象类型和绝对路径因系统、启动目录而异）：
# data
# PosixPath('data')
# /Users/you/project/data
# data

1
2
3
4
5
6
7
8
9

from pathlib import Path

data_dir = Path("data")
data_dir.mkdir(parents=True, exist_ok=True)  # 补齐缺失的父目录；目标目录已存在时不报错

report_path = data_dir / "report.txt"
report_path.write_text("第一行\n第二行\n", encoding="utf-8")
content = report_path.read_text(encoding="utf-8")
print(content, end="")

1
2

# 第一行
# 第二行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import json
from pathlib import Path

profile = {"name": "Ada", "skills": ["math", "programming"]}

# 字符串方式：对象 → JSON 字符串 → 对象
text = json.dumps(profile, ensure_ascii=False)
print(text)
print(json.loads(text))

# 文件方式：对象 → profile.json → 对象
path = Path("profile.json")
with path.open("w", encoding="utf-8") as file:
    json.dump(profile, file, ensure_ascii=False, indent=2)
with path.open("r", encoding="utf-8") as file:
    loaded = json.load(file)
print(loaded)

# 输出：
# {"name": "Ada", "skills": ["math", "programming"]}
# {'name': 'Ada', 'skills': ['math', 'programming']}
# {'name': 'Ada', 'skills': ['math', 'programming']}

1
2
3
4
5
6
7
8

price_tool/
├── pyproject.toml
├── src/
│   └── price_tool/
│       ├── __init__.py
│       ├── formatter.py
│       └── __main__.py
└── tests/

1
2
3
4
5
6
7
8

def main() -> None:
    print("程序开始")


if __name__ == "__main__":
    main()

# 作为脚本运行时输出：程序开始

1
2
3
4
5
6
7
8

import math
from pathlib import Path

print(math.sqrt(81))
print(Path.cwd())  # 查看当前工作目录

# 输出：9.0
# 示例输出：/Users/you/project，实际值取决于启动目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from dataclasses import dataclass
from decimal import Decimal


@dataclass  # 自动生成初始化、展示和相等性比较方法
class Product:
    name: str
    price: Decimal
    stock: int = 0

    def reserve(self, quantity: int) -> None:
        if quantity <= 0:
            raise ValueError("数量必须大于零")
        if quantity > self.stock:
            raise ValueError("库存不足")
        self.stock -= quantity


product = Product("Keyboard", Decimal("399.00"), stock=10)  # 自动把参数保存为实例字段
product.reserve(2)
print(product.stock)
print(product)  # 使用自动生成的 __repr__ 展示字段
print(product == Product("Keyboard", Decimal("399.00"), stock=8))

# 输出：
# 8
# Product(name='Keyboard', price=Decimal('399.00'), stock=8)
# True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 假设 notes.txt 依次包含“第一行”、空行和“第二行”
def read_non_empty_lines(path: str):
    with open(path, "r", encoding="utf-8") as file:
        for line in file:
            stripped = line.strip()
            if stripped:
                yield stripped


for line in read_non_empty_lines("notes.txt"):
    print(line)

1
2

# 第一行
# 第二行

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

type UserId = int  # 类型别名：让标注中的用户编号更容易辨认


def active_names(users: dict[UserId, str], disabled: set[UserId]) -> list[str]:
    return [name for user_id, name in users.items() if user_id not in disabled]


user_id: UserId = 1001
print(type(user_id))
print(active_names({1: "Ada", 2: "Guido", 3: "Linus"}, {2}))

# 输出：
# <class 'int'>
# ['Ada', 'Linus']

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

import unittest


def add(left: int, right: int) -> int:
    return left + right


class AddTests(unittest.TestCase):  # 继承测试基类，获得 assertEqual 等方法
    def test_adds_two_integers(self) -> None:
        # 先算出实际值 add(2, 3)，再与期望值 5 比较；不相等时报告测试失败
        self.assertEqual(add(2, 3), 5)


if __name__ == "__main__":
    unittest.main()  # 直接运行本文件时，发现并执行本文件的测试

# 结果：1 项测试通过，耗时因环境而异

1

python -m unittest -v test_example

1
2
3
4
5
6

# test_adds_two_integers (test_example.AddTests.test_adds_two_integers) ... ok
#
# ----------------------------------------------------------------------
# Ran 1 test in 0.000s
#
# OK

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

from collections import Counter
from pathlib import Path
import re
import sys


# 预先编译正则，供逐行匹配复用：
# [A-Za-z]+ 匹配连续英文字母；(?:...) 把内部规则作为一组，不单独返回捕获结果
# 后面的 ? 表示该组可出现零次或一次，因此可识别 don't 这样的单词
WORD_PATTERN = re.compile(r"[A-Za-z]+(?:'[A-Za-z]+)?")


def top_words(path: Path, limit: int = 10) -> list[tuple[str, int]]:
    # Counter 是计数字典：键为单词，值为出现次数
    counts: Counter[str] = Counter()
    with path.open("r", encoding="utf-8") as file:
        for line in file:
            # lower 统一小写，findall 返回本行单词列表，update 为每个单词累计次数
            counts.update(WORD_PATTERN.findall(line.lower()))
    # 返回最多 limit 组 (单词, 次数)，按次数从高到低排列
    return counts.most_common(limit)


def main() -> int:
    # sys.argv[0] 是脚本路径，sys.argv[1] 是用户传入的文本文件路径
    # 共两个元素才说明恰好传入了一个参数
    if len(sys.argv) != 2:
        # .name 只取文件名；错误提示写到 stderr（标准错误流）
        print(f"用法：{Path(sys.argv[0]).name} <文本文件>", file=sys.stderr)
        return 2  # 约定退出码 2 表示参数用法错误

    path = Path(sys.argv[1])
    try:
        results = top_words(path)
    except (OSError, UnicodeError) as exc:  # 分别处理文件访问失败、文本解码失败
        print(f"读取失败：{exc}", file=sys.stderr)
        return 1  # 约定退出码 1 表示读取失败

    for word, count in results:
        # <20 表示左对齐、最小宽度 20；>6 表示右对齐、最小宽度 6
        print(f"{word:<20} {count:>6}")
    return 0  # 退出码 0 表示成功


if __name__ == "__main__":
    raise SystemExit(main())  # 执行 main，并把返回值交给操作系统作为进程退出码

1

python word_count.py sample.txt

1
2
3
4

# python                    2
# is                        2
# simple                    1
# readable                  1