Python 相关经验与面试手册#

源码 .py → 解析 / 编译 → 代码对象与字节码 → 解释器执行
第三方原生扩展 → .so / .pyd 等二进制模块 → 被 Python 加载

python3 --version
python3 -c "import sys; print(sys.executable)"
python3 -m pip --version

py -3 --version
py -3 -c "import sys; print(sys.executable)"
py -3 -m pip --version

def greet(name: str) -> str:
    """返回一句问候，不负责打印。"""
    return f"你好，{name}"


def main() -> None:
    print(greet("Jobs"))


if __name__ == "__main__":
    main()

a = ["Swift"]
b = a
b.append("Python")
print(a)          # ['Swift', 'Python']
print(a is b)     # True：同一个对象

b = ["OC"]
print(a, b)       # a 没被重新绑定

x = 10
y = x
y += 1
print(x, y)       # 10 11：整数不可变，y 绑定到新结果

from copy import deepcopy

original = [[1], [2]]
shallow = original.copy()
deep = deepcopy(original)

shallow[0].append(9)
print(original)   # [[1, 9], [2]]
print(deep)       # [[1], [2]]
print(shallow is original)       # False
print(shallow[0] is original[0]) # True

left = [1, 2]
right = [1, 2]
print(left == right)  # True：值相等
print(left is right)  # False：不是同一个对象

value = None
if value is None:
    print("没有提供值")

count = 0
print(count or 10)                    # 10：按真假判断
print(10 if count is None else count) # 0：只把 None 当缺省

print(7 / 2)        # 3.5：真除法
print(7 // 2)       # 3：向下取整
print(-7 // 2)      # -4：不是向零截断
print(7 % 2)        # 1
print(2 ** 3)       # 8：幂
print(1 < 2 < 3)    # True：链式比较
print("a" in "cat") # True：成员 / 包含判断

name = "  Jobs  ".strip()
languages = "Swift,OC,Python".split(",")
print(" / ".join(languages))
print(f"{name}: {len(languages)} 门语言")
print("report.py".endswith(".py"))
print("abcdef"[1:4])   # bcd：左闭右开
print("abcdef"[-2:])   # ef
print("abcdef"[::-1])  # fedcba

text = "你好"
payload = text.encode("utf-8")
print(len(text), len(payload)) # 2 6
print(payload.decode("utf-8"))

from decimal import Decimal
from datetime import datetime, timezone
from math import isclose

print(0.1 + 0.2 == 0.3)       # False
print(isclose(0.1 + 0.2, 0.3))# True
print(Decimal("0.1") + Decimal("0.2")) # 0.3
print(datetime.now(timezone.utc).isoformat())

items = ["Swift", "OC"]
items.append("Python")
items.extend(["SQL", "Shell"])
last = items.pop()
print(items, last)

numbers = [3, 1, 2]
ordered = sorted(numbers)
result = numbers.sort()
print(ordered, numbers, result) # [1, 2, 3] [1, 2, 3] None

point = (10, 20)
x, y = point
single = (42,)  # 逗号才使它成为单元素元组
first, *middle, last = [1, 2, 3, 4]
print(x, y, single, middle)

record = (["Swift"], "Jobs")
record[0].append("Python")
print(record)   # 元组中的列表仍可变

profile = {"name": "Jobs", "level": 1}
print(profile["name"])
print(profile.get("city", "未填写"))
profile.update(level=2)

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

counts = {}
for word in ["swift", "python", "python"]:
    counts[word] = counts.get(word, 0) + 1
print(counts)

values = ["Swift", "OC", "Swift", "Python"]
unique = set(values)
ordered_unique = list(dict.fromkeys(values))
print("OC" in unique)
print(ordered_unique) # ['Swift', 'OC', 'Python']
print({1, 2} & {2, 3}) # {2}：交集
print({1, 2} | {2, 3}) # {1, 2, 3}：并集

from collections import Counter, defaultdict, deque

print(Counter(["a", "b", "a"]).most_common(1)) # [('a', 2)]
groups = defaultdict(list)
for language, author in [("Swift", "Jobs"), ("Python", "Jobs")]:
    groups[author].append(language)
print(dict(groups))

queue = deque(["A", "B"])
queue.append("C")
print(queue.popleft()) # A

score = 85
if score >= 90:
    level = "优秀"
elif score >= 60:
    level = "通过"
else:
    level = "待加强"

label = "可用" if score >= 60 else "不可用"
print(level, label)

names = ["Swift", "Python"]
for index, name in enumerate(names, start=1):
    print(index, name)

for name, score in zip(names, [90, 85], strict=True):
    print(name, score)

print(list(range(1, 5))) # [1, 2, 3, 4]

target = "Rust"
for name in ["Swift", "Python"]:
    if name == target:
        print("找到了")
        break
else:
    print("没有找到")

event = {"type": "download", "bytes": 128}
match event:
    case {"type": "download", "bytes": int(size)} if size >= 0:
        print(f"下载了 {size} 字节")
    case {"type": "cancel"}:
        print("取消")
    case _:
        print("未知事件")

values = [1, 2, 3, 4]
squares = [x * x for x in values if x % 2 == 0]
mapping = {x: x * x for x in values}
unique_lengths = {len(x) for x in ["Swift", "Python", "Jobs"]}
print(squares, mapping, unique_lengths)

def double(value: int) -> int:
    return value * 2


def apply(value: int, operation) -> int:
    return operation(value)


action = double
print(apply(3, action)) # 6

def request(path: str, /, *, timeout: float = 5.0) -> str:
    return f"{path}, timeout={timeout}"


def describe(*args, **kwargs):
    print(args)   # tuple
    print(kwargs) # dict


print(request("/users", timeout=2.0))
describe(1, 2, name="Jobs")

options = {"timeout": 3.0}
print(request("/users", **options))

def bad_add(item, items=[]):
    items.append(item)
    return items


print(bad_add("A")) # ['A']
print(bad_add("B")) # ['A', 'B']：共享同一个默认列表


def add(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items


print(add("A"), add("B")) # ['A'] ['B']

def modify(values):
    values.append(2)
    values = [99]
    return values


original = [1]
result = modify(original)
print(original, result) # [1, 2] [99]

def convert(value: int):
    return "整数版本"


def convert(value: str):
    return "后定义的版本"


print(convert(1)) # 后定义的版本；不会自动选择前一个定义

def make_counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment


counter = make_counter()
print(counter(), counter()) # 1 2

bad = [lambda: index for index in range(3)]
good = [lambda value=index: value for index in range(3)]
print([fn() for fn in bad])  # [2, 2, 2]
print([fn() for fn in good]) # [0, 1, 2]

from functools import partial

users = [{"name": "B", "age": 20}, {"name": "A", "age": 18}]
print(sorted(users, key=lambda user: user["age"]))


def greet(name, prefix):
    return f"{prefix}，{name}"


say_hello = partial(greet, prefix="你好")
print(say_hello("Jobs"))

class Counter:
    def __init__(self, initial: int = 0):
        self.value = initial

    def increment(self, amount: int = 1) -> int:
        self.value += amount
        return self.value


first = Counter()
second = Counter(10)
print(first.increment(), second.increment()) # 1 11

class WrongTeam:
    members = []  # 全部实例共享


a = WrongTeam()
b = WrongTeam()
a.members.append("Jobs")
print(b.members)   # ['Jobs']


class Team:
    def __init__(self):
        self.members = []  # 每个实例单独创建

class Temperature:
    def __init__(self, celsius: float):
        self._celsius = celsius

    @property
    def fahrenheit(self) -> float:
        return self._celsius * 1.8 + 32

    @classmethod
    def from_fahrenheit(cls, value: float):
        return cls((value - 32) / 1.8)

    @staticmethod
    def unit_label() -> str:
        return "°C"


t = Temperature.from_fahrenheit(212)
print(round(t.fahrenheit), t.unit_label()) # 212 °C

from dataclasses import dataclass, field, replace


@dataclass(frozen=True)
class User:
    name: str
    tags: tuple[str, ...] = ()


@dataclass
class DownloadBatch:
    paths: list[str] = field(default_factory=list)


user = User("Jobs", ("iOS",))
updated = replace(user, tags=user.tags + ("Python",))
print(user, updated)

a = DownloadBatch()
b = DownloadBatch()
a.paths.append("a.zip")
print(b.paths) # []

class ConsoleWriter:
    def write(self, text: str) -> None:
        print(text)


class ReportService:
    def __init__(self, writer):
        self.writer = writer

    def report(self, count: int) -> None:
        self.writer.write(f"完成 {count} 项")


ReportService(ConsoleWriter()).report(3)

class BaseTask:
    def description(self):
        return "任务"


class DownloadTask(BaseTask):
    def description(self):
        return super().description() + "：下载"


print(DownloadTask().description()) # 任务：下载
print([cls.__name__ for cls in DownloadTask.mro()])

class FileBatch:
    def __init__(self, paths):
        self._paths = tuple(paths)

    def __len__(self):
        return len(self._paths)

    def __iter__(self):
        return iter(self._paths)

    def __repr__(self):
        return f"FileBatch(paths={self._paths!r})"


batch = FileBatch(["a.py", "b.py"])
print(len(batch))  # 2
print(list(batch)) # ['a.py', 'b.py']
print(batch)

from enum import Enum


class DownloadState(Enum):
    READY = "ready"
    RUNNING = "running"
    DONE = "done"


state = DownloadState("running")
print(state is DownloadState.RUNNING) # True
print(state.value)                    # running

class UpperName:
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.name.upper()


class Profile:
    upper_name = UpperName()

    def __init__(self, name):
        self.name = name


print(Profile("Jobs").upper_name) # JOBS

class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x, self.y = x, y


p = Point(1, 2)
print(p.x, hasattr(p, "__dict__")) # 1 False

class User:
    pass


print(type(User).__name__)   # type
print(type(User()).__name__) # User

def chunks(values, size):
    if size <= 0:
        raise ValueError("size 必须大于零")
    for start in range(0, len(values), size):
        yield values[start:start + size]


iterator = chunks([1, 2, 3, 4, 5], 2)
print(next(iterator)) # [1, 2]
print(list(iterator)) # [[3, 4], [5]]
print(list(iterator)) # []：已经耗尽

eager = [x * x for x in range(5)]
lazy = (x * x for x in range(5))
print(eager)     # [0, 1, 4, 9, 16]
print(sum(lazy)) # 30
print(sum(lazy)) # 0：耗尽后没有新元素

def flatten(groups):
    for group in groups:
        yield from group


print(list(flatten([[1, 2], [3]]))) # [1, 2, 3]

from functools import wraps
from time import perf_counter


def timed(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = perf_counter()
        try:
            return func(*args, **kwargs)
        finally:
            print(f"{func.__name__}: {perf_counter() - start:.6f}s")
    return wrapper


@timed
def total(values):
    return sum(values)


print(total([1, 2, 3])) # 打印耗时，然后打印 6
print(total.__name__)   # total

from functools import lru_cache


@lru_cache(maxsize=128)
def normalize(name: str) -> str:
    print("执行转换")
    return name.strip().casefold()


print(normalize(" Jobs "))
print(normalize(" Jobs ")) # 第二次不打印“执行转换”

from contextlib import contextmanager


@contextmanager
def session(label):
    print(f"打开 {label}")
    try:
        yield {"label": label}
    finally:
        print(f"关闭 {label}")


with session("demo") as value:
    print(value["label"])
# 打开 demo → demo → 关闭 demo

def parse_count(text: str) -> int:
    try:
        count = int(text)
    except ValueError as error:
        raise ValueError("数量必须是整数") from error
    else:
        if count < 0:
            raise ValueError("数量不能为负数")
        return count
    finally:
        print("本次解析结束")


print(parse_count("3"))
try:
    parse_count("abc")
except ValueError as error:
    print(error) # 数量必须是整数

import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
logger = logging.getLogger(__name__)
logger.info("完成 %d 个文件", 3)
try:
    int("not-a-number")
except ValueError:
    logger.exception("演示：输入解析失败")

def echo(value: int) -> int:
    return value


print(echo("文字")) # 运行时仍返回“文字”；静态检查器会指出不匹配


def first(values: list[str]) -> str | None:
    return values[0] if values else None


name = first([])
if name is not None:
    print(name.upper())

from typing import Protocol


class Writer(Protocol):
    def write(self, text: str) -> None: ...


class ConsoleWriter:
    def write(self, text: str) -> None:
        print(text)


def send_report(writer: Writer) -> None:
    writer.write("报告已生成")


send_report(ConsoleWriter())

from pydantic import BaseModel, ConfigDict, Field, ValidationError


class JobRequest(BaseModel):
    model_config = ConfigDict(strict=True)
    name: str
    retries: int = Field(ge=0, le=5)


print(JobRequest(name="scan", retries=2).model_dump())
try:
    JobRequest(name="scan", retries="2")
except ValidationError:
    print("严格模式不把字符串自动当整数")

from collections.abc import Sequence
from typing import TypeVar

T = TypeVar("T")


def first_item(values: Sequence[T]) -> T:
    if not values:
        raise ValueError("序列不能为空")
    return values[0]


print(first_item([10, 20]))        # 10；静态结果类型为 int
print(first_item(["Swift", "OC"])) # Swift；静态结果类型为 str

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    root = Path(directory)
    path = root / "notes.txt"
    path.write_text("Swift\nPython\n", encoding="utf-8")
    print(path.name, path.suffix)
    print(path.read_text(encoding="utf-8").splitlines())
    print([item.name for item in root.glob("*.txt")])

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "demo.log"
    path.write_text("INFO start\nERROR failed\n", encoding="utf-8")
    with path.open("r", encoding="utf-8") as stream:
        for line in stream:
            if "ERROR" in line:
                print(line.rstrip()) # ERROR failed

import json

profile = {"name": "Jobs", "enabled": True, "memo": None}
text = json.dumps(profile, ensure_ascii=False)
restored = json.loads(text)
print(text)  # JSON 使用 true / null
print(restored["name"])

import csv
import io

buffer = io.StringIO(newline="")
writer = csv.DictWriter(buffer, fieldnames=["name", "score"])
writer.writeheader()
writer.writerow({"name": "Jobs", "score": 90})
buffer.seek(0)
print(list(csv.DictReader(buffer))) # score 读回来是字符串

import sqlite3

connection = sqlite3.connect(":memory:")
try:
    with connection:
        connection.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
        connection.execute("INSERT INTO users(name) VALUES (?)", ("Jobs",))
    row = connection.execute("SELECT name FROM users WHERE id = ?", (1,)).fetchone()
    print(row[0]) # Jobs
finally:
    connection.close()

import math
from pathlib import Path
import json as json_codec

print(math.sqrt(16))       # 4.0
print(Path("notes.txt").suffix)
print(json_codec.loads('{"ok": true}'))

import importlib
import json

again = importlib.import_module("json")
print(again is json) # True：复用模块对象

选择 Python 版本 → 为项目隔离环境 → 安装并锁定依赖 → 在源码中 import

python3 -m venv .venv
source .venv/bin/activate
python -m pip install httpx
python -c "import httpx; print(httpx.__version__)"

py -3 -m venv .venv
.\.venv\Scripts\python.exe -m pip install httpx
.\.venv\Scripts\python.exe -c "import httpx; print(httpx.__version__)"

python -m pip list
python -m pip show httpx
python -m pip check
python -m pip install -r requirements.txt
python -m pip install -e .

python -m pip freeze > requirements.txt

uv init jobs-python-demo
cd jobs-python-demo
uv add httpx
uv add --dev pytest ruff
uv run python -c "import httpx; print(httpx.__version__)"
uv sync --locked

[project]
name = "jobs-demo"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = ["httpx>=0.28,<1"]

[project.optional-dependencies]
gui = ["PySide6"]

[dependency-groups]
dev = ["pytest", "ruff"]

python -m pip install ".[gui]"

python -m pip install numpy pandas openpyxl

import numpy as np

values = np.array([1, 2, 3], dtype=np.int64)
print(values * 10) # [10 20 30]
print(values.mean()) # 2.0

import pandas as pd

table = pd.DataFrame({"language": ["Swift", "Python", "Python"], "count": [1, 2, 3]})
print(table.groupby("language", sort=True)["count"].sum().to_dict())
# {'Python': 5, 'Swift': 1}

from pathlib import Path
from tempfile import TemporaryDirectory
from openpyxl import Workbook, load_workbook

with TemporaryDirectory() as directory:
    path = Path(directory) / "report.xlsx"
    book = Workbook()
    book.active.append(["name", "count"])
    book.active.append(["Jobs", 3])
    book.save(path)
    loaded = load_workbook(path, read_only=True)
    try:
        print(loaded.active["A2"].value) # Jobs
    finally:
        loaded.close()

import httpx


def respond(request: httpx.Request) -> httpx.Response:
    return httpx.Response(200, json={"name": "Jobs", "path": request.url.path})


with httpx.Client(transport=httpx.MockTransport(respond), timeout=5.0) as client:
    response = client.get("https://example.test/users/1")
    response.raise_for_status()
    print(response.json()) # {'name': 'Jobs', 'path': '/users/1'}

import subprocess
import sys

result = subprocess.run(
    [sys.executable, "-c", "print('child ready')"],
    check=True,
    capture_output=True,
    text=True,
    timeout=5,
)
print(result.stdout.strip()) # child ready

from concurrent.futures import ThreadPoolExecutor
from time import sleep


def fetch_fake(index):
    sleep(0.01) # 模拟阻塞等待，不是真实网络
    return f"item-{index}"


with ThreadPoolExecutor(max_workers=3) as pool:
    results = list(pool.map(fetch_fake, range(5)))
print(results) # item-0 到 item-4，map 按输入顺序返回

from concurrent.futures import ProcessPoolExecutor


def square(value):
    return value * value


def main():
    with ProcessPoolExecutor(max_workers=2) as pool:
        print(list(pool.map(square, [1, 2, 3]))) # [1, 4, 9]


if __name__ == "__main__":
    main()

import asyncio


async def fetch_fake(name):
    await asyncio.sleep(0.01)
    return name.upper()


async def main():
    async with asyncio.TaskGroup() as group:
        first = group.create_task(fetch_fake("swift"))
        second = group.create_task(fetch_fake("python"))
    print(first.result(), second.result()) # SWIFT PYTHON


if __name__ == "__main__":
    asyncio.run(main())

import asyncio


async def main():
    try:
        async with asyncio.timeout(0.01):
            await asyncio.sleep(1)
    except TimeoutError:
        print("超过本次等待时限")


if __name__ == "__main__":
    asyncio.run(main())

from concurrent.futures import ThreadPoolExecutor
from threading import Lock


class Counter:
    def __init__(self):
        self._value = 0
        self._lock = Lock()

    def increment(self):
        with self._lock:
            self._value += 1

    def snapshot(self):
        with self._lock:
            return self._value


counter = Counter()
with ThreadPoolExecutor(max_workers=4) as pool:
    list(pool.map(lambda _: counter.increment(), range(1000)))
print(counter.snapshot()) # 1000

import pytest


def parse_retry(text):
    value = int(text)
    if not 0 <= value <= 5:
        raise ValueError("范围应为 0 到 5")
    return value


@pytest.mark.parametrize("text, expected", [("0", 0), ("3", 3), ("5", 5)])
def test_valid(text, expected):
    assert parse_retry(text) == expected


def test_invalid():
    with pytest.raises(ValueError):
        parse_retry("6")

python -m compileall -q src
python -m pytest -q
ruff check .
ruff format --check .
python -m cProfile -s cumulative app.py

JobsReport.py/
├── README.md
├── 【MacOS】📦生成dmg.command
├── 【Windows】📦生成exe.bat
└── JobsReport/
    ├── pyproject.toml
    ├── uv.lock
    ├── src/
    │   └── jobs_report/
    │       ├── __init__.py
    │       ├── core.py
    │       └── cli.py
    ├── tests/
    ├── assets/
    └── scripts/

import argparse
import json
from pathlib import Path


def summarize(directory: Path) -> dict[str, int]:
    files = [path for path in directory.iterdir() if not path.is_symlink() and path.is_file()]
    return {"count": len(files), "bytes": sum(path.stat().st_size for path in files)}


def main() -> int:
    parser = argparse.ArgumentParser(description="统计一层目录中的文件数量与大小")
    parser.add_argument("directory", type=Path)
    args = parser.parse_args()
    if not args.directory.is_dir():
        parser.error("请输入存在的目录")
    try:
        result = summarize(args.directory)
    except OSError as error:
        parser.exit(1, f"读取失败：{error}\n")
    print(json.dumps(result, ensure_ascii=False))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

python report_cli.py --help
python report_cli.py .

jobs-text-tools/
├── pyproject.toml
├── README.md
└── src/
    └── jobs_text_tools/
        ├── __init__.py
        ├── cli.py
        └── __main__.py

[build-system]
requires = ["hatchling>=1.27"]
build-backend = "hatchling.build"

[project]
name = "jobs-text-tools"
version = "0.1.0"
description = "A small text utility for learning Python packaging"
readme = "README.md"
requires-python = ">=3.11"
dependencies = []

[project.scripts]
jobs-greet = "jobs_text_tools.cli:main"

[tool.hatch.build.targets.wheel]
packages = ["src/jobs_text_tools"]

# Jobs Text Tools

教学用文本工具库，提供 greet(name) 函数和 jobs-greet 命令。
要求 Python 3.11 及以上，空白名字会被拒绝。

def greet(name: str) -> str:
    cleaned = name.strip()
    if not cleaned:
        raise ValueError("name 不能为空")
    return f"你好，{cleaned}"

import argparse
from . import greet


def main() -> int:
    parser = argparse.ArgumentParser(description="打印问候语")
    parser.add_argument("name")
    args = parser.parse_args()
    try:
        print(greet(args.name))
    except ValueError as error:
        parser.error(str(error))
    return 0

from .cli import main

if __name__ == "__main__":
    raise SystemExit(main())

python -m pip install -e .
python -c "from jobs_text_tools import greet; print(greet('Jobs'))"
python -m jobs_text_tools Jobs
jobs-greet Jobs

python -m pip install build twine
python -m build
python -m twine check dist/*

python -m pip install /实际路径/jobs_text_tools-0.1.0-py3-none-any.whl
jobs-greet Jobs

from importlib.resources import files

text = files("jobs_text_tools").joinpath("templates/help.txt").read_text(encoding="utf-8")
print(text)

python -m twine upload --repository testpypi dist/*

python -m pip install pyinstaller
python -m PyInstaller --onedir --name JobsCounter tkinter_demo.py

python -m PyInstaller --onedir --windowed --name JobsCounter tkinter_demo.py

python -m pip install pyinstaller
python -m PyInstaller --onedir --windowed --name JobsCounter tkinter_demo.py

mkdir dmg-root
ditto dist/JobsCounter.app dmg-root/JobsCounter.app
hdiutil create -volname JobsCounter -srcfolder dmg-root -format UDZO dist/JobsCounter.dmg

python -m PyInstaller --onedir --name JobsCounter tkinter_demo.py

python -m PyInstaller --onedir --add-data "assets:assets" app.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/health")
def health():
    return {"status": "ok"}

python -m pip install fastapi uvicorn
python -m uvicorn app:app --host 127.0.0.1 --port 8000

FROM python:3.14-slim
WORKDIR /app
COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt
COPY app.py .
USER 10001
EXPOSE 8000
CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t jobs-api-demo .
docker run --rm -p 127.0.0.1:8000:8000 jobs-api-demo

python -m tkinter

import tkinter as tk
from tkinter import ttk


class CounterWindow(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Jobs Python 计数器")
        self.count = 0
        self.name = tk.StringVar(value="Jobs")
        self.status = tk.StringVar(value="点击按钮开始")
        self.columnconfigure(0, weight=1)

        self.panel = ttk.Frame(self, padding=16)
        self.panel.grid(row=0, column=0, sticky="nsew")
        self.panel.columnconfigure(0, weight=1)

        self.entry = ttk.Entry(self.panel, textvariable=self.name)
        self.entry.grid(row=0, column=0, columnspan=2, sticky="ew", pady=6)
        self.label = ttk.Label(self.panel, textvariable=self.status)
        self.label.grid(row=1, column=0, columnspan=2, sticky="w", pady=6)
        self.add_button = ttk.Button(self.panel, text="加一", command=self.increment)
        self.add_button.grid(row=2, column=0, sticky="ew", padx=(0, 8))
        self.reset_button = ttk.Button(self.panel, text="清零", command=self.reset)
        self.reset_button.grid(row=2, column=1, sticky="ew")

    def refresh(self):
        name = self.name.get().strip() or "匿名"
        self.status.set(f"{name}：{self.count}")

    def increment(self):
        self.count += 1
        self.refresh()

    def reset(self):
        self.count = 0
        self.refresh()


if __name__ == "__main__":
    CounterWindow().mainloop()

import tkinter as tk


def main():
    root = tk.Tk()
    root.title("Canvas 绘图")
    canvas = tk.Canvas(root, width=280, height=100, highlightthickness=0)
    canvas.pack(padx=16, pady=16)
    canvas.create_rectangle(10, 30, 260, 60, outline="#555555")
    canvas.create_rectangle(10, 30, 160, 60, fill="#2878c8", outline="")
    canvas.create_text(135, 80, text="进度 60%")
    root.mainloop()


if __name__ == "__main__":
    main()

import queue
import threading
import tkinter as tk
from tkinter import ttk


def work(events, stop):
    for index in range(20):
        if stop.wait(0.02):
            events.put("已取消")
            return
        events.put(f"进度 {(index + 1) * 5}%")
    events.put("任务完成")


class WorkerWindow(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Tk 后台任务")
        self.events = queue.Queue()
        self.stop = threading.Event()
        self.worker = None
        self.closing = False
        self.status = tk.StringVar(value="等待开始")
        self.label = ttk.Label(self, textvariable=self.status, padding=12)
        self.label.pack()
        self.button = ttk.Button(self, text="开始", command=self.start)
        self.button.pack(padx=12, pady=12)
        self.protocol("WM_DELETE_WINDOW", self.request_close)
        self.after(20, self.poll)

    def start(self):
        if self.worker is not None and self.worker.is_alive():
            return
        self.stop.clear()
        self.button.configure(state="disabled")
        self.worker = threading.Thread(target=work, args=(self.events, self.stop))
        self.worker.start()

    def poll(self):
        while True:
            try:
                self.status.set(self.events.get_nowait())
            except queue.Empty:
                break
        running = self.worker is not None and self.worker.is_alive()
        if self.closing and not running:
            self.destroy()
            return
        if not running and not self.closing:
            self.button.configure(state="normal")
        self.after(20, self.poll)

    def request_close(self):
        self.closing = True
        self.button.configure(state="disabled")
        self.stop.set()


if __name__ == "__main__":
    WorkerWindow().mainloop()