青少年软件编程（Python）等级考试 · 知识点手册

# 井号开头是单行注释（注释不会被执行）
print("Hello")   # 注释也可以写在代码后面

"""
三个双引号或三个单引号
可以写成多行注释
"""

# 输入
name = input("请输入你的名字：")
# 处理（把输入的内容拼成一句话）
message = "你好，" + name
# 输出
print(message)

print("hello")     # 正确：双引号
print('hello')     # 正确：单引号
print("""多行
内容""")            # 正确：三引号可换行
print(3 + 4)       # 正确：打印数字 7
# print"hello"     # 错误：漏了括号

a = input()          # a 是字符串，比如 "12"
b = input()          # b 是字符串，比如 "5"
print(a + b)         # 输出 "125"（字符串拼接！不是 17）
print(int(a) + int(b))  # 输出 17（先转成整数再相加）

score = 90        # 合法：字母开头
score_1 = 95      # 合法：包含下划线
# 2score = 10     # 非法：数字开头
# class = 100     # 非法：class 是保留字
# my-name = 5     # 非法：含减号

a = 10            # a 先存 10
a = 20            # 再赋值后，a 存 20，10 被覆盖
print(a)          # 20

s = "3.14"
pi = float(s)      # 3.14（小数）
n = int("100")     # 100（整数）
t = str(3.14)      # "3.14"（字符串）
print(type(pi), type(n), type(t))
# 输出：<class 'float'> <class 'int'> <class 'str'>

import turtle              # 导入库
turtle.pensize(3)          # 画笔粗细
turtle.color("blue")       # 画笔蓝色
for i in range(4):         # 重复 4 次
    turtle.forward(100)    # 前进 100
    turtle.right(90)       # 右转 90 度
turtle.done()              # 保持窗口

import turtle
turtle.penup()                  # 抬笔
turtle.goto(-100, 100)          # 移到正方形左上角
turtle.pendown()                # 落笔
for i in range(4):              # 画边长为 200 的正方形
    turtle.forward(200)
    turtle.right(90)
turtle.penup()
turtle.goto(0, -100)            # 移到圆的起点
turtle.pendown()
turtle.fillcolor("red")         # 填充红色
turtle.begin_fill()
turtle.circle(100)              # 画半径 100 的圆
turtle.end_fill()
turtle.done()

a = 10
a += 5        # 等价于 a = a + 5，现在 a = 15
a *= 2        # 等价于 a = a * 2，现在 a = 30
print(a)      # 30

# 例 1：c = a * b - 5（a=30, b=10）
c = 30 * 10 - 5        # 先乘再减 = 300 - 5 = 295

# 例 2：幂运算优先级高于乘除
x = 2 * 3 ** 2         # 先算 3**2=9，再 2*9=18

# 例 3：and 优先级高于 or
print(3 > 4 or 4 < 3 and 1 == 1)
# 先算 and：4<3 为假，所以整个 and 结果为假值 0 方向 → False
# 再算 or：3>4 为 False，结果 False

a = int(input())      # 输入第 1 个数
b = int(input())      # 输入第 2 个数
print("和是：", a + b)
print("积是：", a * b)

score = int(input("请输入成绩："))
if score >= 60:
    print("及格")      # 只有条件成立才执行
print("程序结束")      # 无条件都会执行

a = []                # 空列表
b = [1, 2, 3, 4, 5]   # 整数列表
c = ["苹果", "香蕉", "梨"]  # 字符串列表
d = [1, "hello", 3.5, True]  # 混合列表
e = list("abc")       # 用 list() 把字符串转成列表 → ['a','b','c']
print(len(b))         # 元素个数：5

b = [10, 20, 30, 40]
print(b[0])     # 10（第一个）
print(b[-1])    # 40（最后一个）
b[1] = 99       # 更新第 2 个元素
print(b)        # [10, 99, 30, 40]
print(99 in b)  # True：判断是否包含某元素
print(100 in b) # False

nums = [5, 2, 8, 1]
nums.sort()          # 原地升序排序 → [1, 2, 5, 8]
nums.sort(reverse=True)  # 降序 → [8, 5, 2, 1]
a = [1, 2]; b = [3, 4]
print(a + b)         # 连接 → [1, 2, 3, 4]（不改变 a、b）

for x in nums:       # 遍历列表
    print(x)

t = (1, 2, 3, 4)
print(t[0])      # 1
print(t[-1])     # 4
print(len(t))    # 4
t2 = (5,)        # 只有一个元素必须加逗号！
for x in t:      # 遍历
    print(x)

# 元组不可修改：
# t[0] = 100     # 报错：TypeError

s = "hello"
print(s[0])      # 'h'
print(s[-1])     # 'o'
print(len(s))    # 长度：5
print(s[1:4])    # 切片 → 'ell'
for ch in s:     # 遍历每个字符
    print(ch)

name = "小明"; score = 95
# 方式一：% 格式化
print("姓名：%s，成绩：%d" % (name, score))
# 方式二：format()
print("姓名：{}，成绩：{}".format(name, score))
# 方式三：f-string（最推荐）
print(f"姓名：{name}，成绩：{score}")
# 三种都输出：姓名：小明，成绩：95

d = {}                  # 空字典
stu = {"name": "小明", "age": 10, "score": 95}
print(stu["name"])      # 用键访问 → 小明
print(len(stu))         # 键值对个数：3
print("age" in stu)     # True：判断是否有某个键

stu = {"name": "小明"}
stu["age"] = 10          # 追加：键不存在则新增
stu["score"] = 95
print(stu)               # {'name':'小明','age':10,'score':95}

del stu["score"]         # 删除指定键
print(stu)               # {'name':'小明','age':10}
score = stu.pop("age")   # 删除并返回对应值 → 10

# 常用方法
print(stu.keys())        # 所有键
print(stu.values())      # 所有值
print(stu.items())       # 所有(键,值)对
print(stu.get("name", "不存在"))  # get() 找不到返回默认值，不报错

stu = {"name": "小明", "age": 10}
for k in stu:            # 遍历键
    print(k, stu[k])
for k, v in stu.items(): # 遍历键值对
    print(k, v)

# 单分支：只判断一次
if score >= 60:
    print("及格")

# 二分支：if...else
if score >= 60:
    print("及格")
else:
    print("不及格")

# 多分支：if...elif...else（从上到下依次判断）
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 遍历 range(n)：0 ~ n-1
for i in range(5):       # 0,1,2,3,4
    print(i)

# range(起, 止, 步长)
for i in range(1, 10, 2):   # 1,3,5,7,9
    print(i)

# 累加求和经典题
total = 0
for i in range(1, 101):  # 1 加到 100
    total += i
print(total)             # 5050

# 条件成立就一直循环
n = 1
while n <= 5:
    print(n)
    n += 1          # 千万别忘改条件，否则死循环

# 输入若干个数，输入 0 结束（经典）
s = 0
while True:
    x = int(input())
    if x == 0:
        break       # 跳出循环
    s += x
print("总和", s)

for i in range(1, 6):
    if i == 3:
        continue     # i=3 时跳过，不打印
    print(i)         # 输出 1 2 4 5

for i in range(1, 6):
    if i == 3:
        break        # i=3 时终止整个循环
    print(i)         # 只输出 1 2

# 例：统计 1~100 中能被 3 整除的数的个数与和
count = 0
total = 0
for i in range(1, 101):
    if i % 3 == 0:      # 条件：能被 3 整除
        count += 1
        total += i
print("个数：", count)   # 33
print("总和：", total)   # 1683

# 例：输入成绩判断等级（多分支）
score = int(input())
if score >= 90: grade = "优秀"
elif score >= 80: grade = "良好"
elif score >= 70: grade = "中等"
elif score >= 60: grade = "及格"
else: grade = "不及格"
print(grade)

print(bin(10))          # 0b1010
print(oct(15))          # 0o17
print(hex(255))         # 0xff
print(int("1010", 2))   # 10（二进制字符串 → 十进制）
print(int("ff", 16))    # 255
print(int("17", 8))     # 15

# 生成 0~9 的平方列表
squares = [x * x for x in range(10)]
print(squares)   # [0,1,4,9,16,25,36,49,64,81]

# 加 if 条件：只保留偶数
evens = [x for x in range(20) if x % 2 == 0]
print(evens)     # [0,2,4,...,18]

# 双层循环
pairs = [x * y for x in range(1, 4) for y in range(1, 4)]
print(pairs)     # [1,2,3,2,4,6,3,6,9]

# 生成 {数字: 平方} 字典
d = {x: x * x for x in range(1, 5)}
print(d)   # {1:1, 2:4, 3:9, 4:16}

g = (x * 2 for x in range(5))   # 生成器对象，不是列表
print(list(g))   # [0, 2, 4, 6, 8]

a, b, c = (1, 2, 3)      # 元组解包
print(a, b, c)           # 1 2 3
a, b = b, a              # 交换两个变量
first, *rest = [10, 20, 30, 40]
print(first, rest)       # 10 [20, 30, 40]

lst = [0, 1, 2, 3, 4, 5]
print(lst[1:4])     # [1, 2, 3]（含 1 不含 4）
print(lst[:3])      # [0, 1, 2]（从头到 3）
print(lst[::2])     # [0, 2, 4]（步长 2）
print(lst[::-1])    # [5, 4, 3, 2, 1, 0]（倒序）
s = "hello"
print(s[::-1])      # "olleh"（字符串反转）

# 例 1：已知圆的半径求面积（公式解析）
import math
r = 5
area = math.pi * r * r
print(round(area, 2))      # 78.54

# 例 2：等差数列求和：首项 1，公差 2，前 n 项和
n = 10
a1 = 1
an = a1 + (n - 1) * 2      # 通项公式
s = n * (a1 + an) // 2     # 求和公式
print(s)                   # 100

# 例 3：分段计费（出租车）——按区间公式计算
dist = 8.0                 # 公里
if dist <= 3:
    fee = 8
else:
    fee = 8 + (dist - 3) * 2.4
print(round(fee, 1))       # 20.0

# 例 1：求 100~999 的所有水仙花数（各位立方和等于自身）
for n in range(100, 1000):
    a = n // 100          # 百位
    b = n // 10 % 10      # 十位
    c = n % 10            # 个位
    if a**3 + b**3 + c**3 == n:
        print(n)          # 153 370 371 407

# 例 2：鸡兔同笼。笼中 35 个头、94 只脚，求鸡兔各几只
for ji in range(36):      # 枚举鸡的数量
    tu = 35 - ji          # 兔由总数确定
    if ji * 2 + tu * 4 == 94:
        print("鸡", ji, "兔", tu)   # 鸡 23 兔 12

# 例 3：百钱买百鸡（经典三重枚举）
for x in range(0, 21):      # 公鸡 5 元
    for y in range(0, 34):  # 母鸡 3 元
        z = 100 - x - y     # 小鸡 1/3 元
        if 5*x + 3*y + z/3 == 100 and z % 3 == 0:
            print(x, y, z)

def bubble_sort(a):
    n = len(a)
    for i in range(n - 1):          # 轮数
        for j in range(n - 1 - i):  # 每轮比较范围逐步缩小
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]  # 交换

lst = [5, 3, 8, 1, 2]
bubble_sort(lst)
print(lst)   # [1, 2, 3, 5, 8]

def select_sort(a):
    n = len(a)
    for i in range(n - 1):
        min_idx = i                # 假设当前最小
        for j in range(i + 1, n):  # 找真正的最小值下标
            if a[j] < a[min_idx]:
                min_idx = j
        a[i], a[min_idx] = a[min_idx], a[i]  # 放到 i 位置

lst = [5, 3, 8, 1, 2]
select_sort(lst)
print(lst)   # [1, 2, 3, 5, 8]

def insert_sort(a):
    for i in range(1, len(a)):
        key = a[i]                 # 当前要插入的元素
        j = i - 1
        while j >= 0 and a[j] > key:
            a[j + 1] = a[j]        # 大的往后移
            j -= 1
        a[j + 1] = key             # 插入合适位置

lst = [5, 3, 8, 1, 2]
insert_sort(lst)
print(lst)   # [1, 2, 3, 5, 8]

abs(-5)         # 绝对值 → 5
divmod(7, 2)    # 商和余数 → (3, 1)
max(1, 5, 3)    # 最大值 → 5
min([4, 2, 8])  # 最小值 → 2
round(3.14159, 2)  # 四舍五入保留 2 位 → 3.14
sum([1, 2, 3])  # 求和 → 6
pow(2, 3)       # 幂 → 8

bool(0)         # False
int("10")       # 10
float("2.5")    # 2.5
str(100)        # "100"
ord("A")        # 字符转 ASCII → 65
chr(65)         # ASCII 转字符 → 'A'
bin(5)          # '0b101'
oct(9)          # '0o11'
hex(15)         # '0xf'
tuple([1,2])    # (1, 2)
list("ab")      # ['a', 'b']
dict([("a",1)]) # {'a': 1}
set([1,1,2])    # {1, 2}（去重）
list(enumerate(["a","b"]))  # [(0,'a'),(1,'b')]

all([1, 2, 3])      # 全真才 True → True
any([0, 1])         # 有真就 True → True
list(filter(lambda x: x > 2, [1,2,3,4]))  # [3, 4] 过滤
list(map(lambda x: x*2, [1,2,3]))         # [2,4,6] 映射
next(iter([1,2]))   # 取下一个 → 1
sorted([3,1,2])     # 返回新排序列表 → [1,2,3]（不修改原列表）

type(10)        # <class 'int'>
format(3.14, ".2f")  # "3.14"（格式化）
print("hi")     # 输出
input("输入：")  # 输入
f = open("a.txt", "w")  # 打开文件（五级详讲）

# 综合题：统计一句话中各字母出现次数（字典+枚举）
text = "hello python"
count = {}
for ch in text:
    if ch.isalpha():          # 只统计字母
        count[ch] = count.get(ch, 0) + 1
print(count)

# 综合题：冒泡排序第 1 轮后的结果（手算）
# 原列表 [5, 3, 8, 1, 2]
# 第 1 轮：5,3 交换 → [3,5,8,1,2]；5,8 不换；8,1 换 → [3,5,1,8,2]；8,2 换 → [3,5,1,2,8]
# 第 1 轮结束：最大的 8 已到最后 → [3, 5, 1, 2, 8]

x = 10                # 全局变量
def demo():
    y = 20            # 局部变量
    print(x)          # 函数内可以读取全局变量 → 10
    print(y)          # 20
demo()
# print(y)            # 报错！y 在函数外不可见

def change():
    global x          # 声明要修改全局变量
    x = 100
change()
print(x)              # 100（全局变量被修改了）

f = lambda a, b: a + b      # 匿名函数
print(f(3, 5))              # 8
# 常配合 sort 的关键字参数使用
lst = [("b", 2), ("a", 3), ("c", 1)]
lst.sort(key=lambda t: t[1])  # 按第二个元素排序
print(lst)                  # [('c',1),('b',2),('a',3)]

# 定义：def 函数名(参数):  缩进为函数体
def add(a, b):
    result = a + b
    return result

# 调用
s = add(3, 5)
print(s)              # 8

# 无返回值示例（只做事）
def greet(name):
    print("你好，", name)
greet("小明")          # 你好， 小明
print(greet("小明"))   # 无 return，打印 None

def power(x, n=2):      # n 有默认值 2
    return x ** n
print(power(3))         # 9（用默认 n=2）
print(power(3, 3))      # 27
print(power(x=2, n=5))  # 32（关键字参数，顺序可换）

def is_prime(n):        # 判断素数
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

def sum_digits(n):      # 求各位数字之和
    return sum(int(ch) for ch in str(n))

print(is_prime(17))     # True
print(sum_digits(123))  # 6

# 求 n!（阶乘）：n! = n × (n-1)!
def fact(n):
    if n == 0:        # 递归出口
        return 1
    return n * fact(n - 1)   # 递归体
print(fact(5))        # 120

# 斐波那契数列：F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)
print(fib(10))        # 55

# 用递推（循环）求斐波那契第 n 项
def fib_iter(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a
print(fib_iter(10))   # 55

# 爬楼梯：每次爬 1 或 2 级，到 n 级有多少种方法
# f(n) = f(n-1) + f(n-2)，f(1)=1, f(2)=2
def climb(n):
    if n <= 2:
        return n
    a, b = 1, 2
    for _ in range(3, n + 1):
        a, b = b, a + b
    return b
print(climb(10))      # 89

def binary_search(a, target):
    low, high = 0, len(a) - 1
    while low <= high:
        mid = (low + high) // 2
        if a[mid] == target:
            return mid        # 找到，返回下标
        elif a[mid] < target:
            low = mid + 1     # 目标在右半
        else:
            high = mid - 1    # 目标在左半
    return -1                 # 未找到

a = [1, 3, 5, 7, 9, 11, 13]
print(binary_search(a, 7))    # 3
print(binary_search(a, 4))    # -1

def quicksort(a):
    if len(a) <= 1:
        return a
    pivot = a[0]                        # 基准
    less = [x for x in a[1:] if x <= pivot]
    greater = [x for x in a[1:] if x > pivot]
    return quicksort(less) + [pivot] + quicksort(greater)

print(quicksort([5, 3, 8, 1, 2]))      # [1, 2, 3, 5, 8]

import math
print(math.pi)          # 圆周率 3.14159...
print(math.sqrt(16))    # 开方 → 4.0
print(math.floor(3.7))  # 向下取整 → 3
print(math.ceil(3.2))   # 向上取整 → 4
print(math.fabs(-5))    # 绝对值 → 5.0
print(math.pow(2, 3))   # 幂 → 8.0

import random
print(random.random())          # [0, 1) 的随机小数
print(random.randint(1, 10))    # [1, 10] 的随机整数（含两端）
print(random.randrange(0, 10, 2))  # 0~9 之间的随机偶数
print(random.choice(["a", "b", "c"]))  # 随机选一个
lst = [1, 2, 3, 4]
random.shuffle(lst)             # 原地打乱顺序
print(random.sample(range(1, 50), 6))  # 不重复抽 6 个

# 方式一：最规范（with 自动关闭文件）
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()          # 一次读全部
    print(content)

with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()       # 读成行列表，每行含 \n
    for line in lines:
        print(line.strip())     # strip() 去掉首尾换行

# 方式二：逐行读取（省内存）
f = open("data.txt", "r", encoding="utf-8")
for line in f:
    print(line, end="")
f.close()                       # 记得关闭

# 覆盖写入
with open("out.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")

# 追加写入（不清空原内容）
with open("out.txt", "a", encoding="utf-8") as f:
    f.write("追加的一行\n")

with open("data.txt", "r", encoding="utf-8") as f:
    print(f.tell())     # 当前指针位置
    f.seek(0)           # 把指针移回开头
    print(f.read())

# 把二维数据写入 CSV 文件
data = [["姓名", "成绩"], ["小明", 95], ["小红", 88]]
with open("scores.csv", "w", encoding="utf-8") as f:
    for row in data:
        f.write(",".join(str(x) for x in row) + "\n")

# 读取 CSV 并处理
with open("scores.csv", "r", encoding="utf-8") as f:
    for line in f:
        parts = line.strip().split(",")   # 分割字段
        print(parts)

import pandas as pd
# 用字典创建 DataFrame
df = pd.DataFrame({
    "姓名": ["小明", "小红", "小刚"],
    "语文": [90, 85, 78],
    "数学": [95, 88, 92]
})
print(df)

df = pd.DataFrame({"语文": [90, 85, 78], "数学": [95, 88, 92]})
print(df.mean())        # 各列平均值
print(df["语文"].max()) # 语文最高分 → 90
print(df["数学"].sum()) # 数学总分 → 275
print(df.sort_values("数学", ascending=False))  # 按数学降序
print(df.rename(columns={"语文": "Chinese"}))   # 列重命名

import matplotlib.pyplot as plt

# 折线图 plot
x = [1, 2, 3, 4, 5]
y = [2, 4, 1, 5, 3]
plt.plot(x, y)
plt.title("成绩变化")      # 标题
plt.xlabel("月份")        # x 轴标签
plt.ylabel("分数")        # y 轴标签
plt.show()               # 显示

# 柱状图 bar
plt.bar(["一班", "二班", "三班"], [80, 90, 85])
plt.show()

# 横向柱状图 barh
plt.barh(["一班", "二班", "三班"], [80, 90, 85])
plt.show()

# 散点图 scatter
plt.scatter(x, y)
plt.show()

plt.figure(figsize=(6, 4))     # 画布大小
plt.plot([1, 2, 3], [1, 4, 9], label="平方", color="red")
plt.legend()                   # 显示图例
plt.xlim(0, 4); plt.ylim(0, 10)
plt.title("y = x²")
plt.show()

import sqlite3

# 1. 连接数据库（不存在则自动创建）
conn = sqlite3.connect("school.db")

# 2. 创建游标
cur = conn.cursor()

# 3. 执行 SQL：建表
cur.execute("""CREATE TABLE IF NOT EXISTS student(
    id INTEGER PRIMARY KEY,
    name TEXT,
    score INTEGER)""")

# 插入数据
cur.execute("INSERT INTO student(name, score) VALUES('小明', 95)")
cur.execute("INSERT INTO student(name, score) VALUES('小红', 88)")
conn.commit()          # 4. 提交事务（写操作必须 commit）

# 5. 查询
cur.execute("SELECT * FROM student")
print(cur.fetchone())     # 取一条 → (1, '小明', 95)
cur.execute("SELECT * FROM student")
print(cur.fetchall())     # 取全部 → [(1,'小明',95),(2,'小红',88)]
cur.execute("SELECT * FROM student")
print(cur.fetchmany(1))   # 取指定条数

# 6. 关闭
cur.close()
conn.close()

# 条件查询 / 排序
cur.execute("SELECT * FROM student WHERE score >= 90")
print(cur.fetchall())
cur.execute("SELECT name FROM student ORDER BY score DESC")
print(cur.fetchall())   # 按成绩降序

# 综合示例：读取成绩文件 → 用 pandas 统计 → 画图
import pandas as pd
import matplotlib.pyplot as plt

# 1. 读文件（假设 scores.csv 有 姓名,语文,数学 三列）
df = pd.read_csv("scores.csv", encoding="utf-8")

# 2. 数据处理
print("平均分：")
print(df.mean())                    # 各科平均
top = df.sort_values("数学", ascending=False)
print("数学最高：", df["数学"].max())

# 3. 可视化
plt.bar(df["姓名"], df["语文"], label="语文")
plt.title("语文成绩对比")
plt.xlabel("姓名"); plt.ylabel("分数")
plt.legend()
plt.show()

# 4. 写入数据库
import sqlite3
conn = sqlite3.connect("scores.db")
df.to_sql("score", conn, if_exists="replace", index=False)
conn.close()

class Student:                 # 定义类
    def __init__(self, name, age):   # 构造方法：创建对象时自动调用
        self.name = name       # 实例属性
        self.age = age
    def introduce(self):       # 定义方法
        print(f"我叫{self.name}，今年{self.age}岁")

s1 = Student("小明", 10)       # 创建实例（对象）
s2 = Student("小红", 11)
print(s1.name)                 # 访问属性 → 小明
s1.introduce()                 # 调用方法

class Person:                  # 父类
    def __init__(self, name):
        self.name = name
    def speak(self):
        print(f"{self.name} 在说话")

class Student(Person):         # 子类继承 Person
    def __init__(self, name, grade):
        super().__init__(name) # 调用父类构造方法
        self.grade = grade
    def study(self):
        print(f"{self.name} 上{self.grade}年级")

s = Student("小明", 5)
s.speak()     # 继承的方法 → 小明 在说话
s.study()     # 子类自己的方法

# 创建
arr = [10, 20, 30, 40, 50]
# 访问
print(arr[0], arr[-1])       # 10 50
# 修改
arr[2] = 99
# 插入
arr.insert(1, 15)            # [10, 15, 20, 99, 40, 50]
arr.append(60)               # 末尾追加
# 删除
arr.pop()                    # 删末尾
arr.remove(20)               # 删除值为 20 的元素
del arr[0]                   # 按下标删除
# 合并
b = [1, 2]
print(arr + b)               # 合并成新列表
arr.extend(b)                # 原地合并

# 二维数组（矩阵）
m = [[1, 2, 3], [4, 5, 6]]
print(m[0][1])               # 第 1 行第 2 列 → 2

arr = [3, 7, 1, 9, 5]
print(sum(arr))              # 和 → 25
print(max(arr))              # 最大 → 9
print(min(arr))              # 最小 → 1
print(arr[::-1])             # 反转 → [5, 9, 1, 7, 3]
# 手动求最大（不用内置函数）
mx = arr[0]
for x in arr:
    if x > mx:
        mx = x
print(mx)                    # 9

s = "hello"
# 插入（字符串不可变，需拼接产生新字符串）
s2 = s[:2] + "X" + s[2:]     # 在位置 2 插入 'X' → "heXllo"
# 删除（切片跳过）
s3 = s[:1] + s[2:]           # 删除位置 1 的字符 → "hllo"
# 反转
print(s[::-1])               # "olleh"
# 统计
print(s.count("l"))          # 2
print(s.find("l"))           # 第一次出现下标 → 2
# 判断
print(s.isdigit())           # 是否全数字 → False
print("h" in s)              # True
# 综合：判断回文字符串
def is_palindrome(t):
    return t == t[::-1]
print(is_palindrome("abba"))  # True
print(is_palindrome("hello")) # False

queue = []                # 空队列
# 入队：加到队尾
queue.append("A")
queue.append("B")
queue.append("C")
print(queue)              # ['A', 'B', 'C']
# 出队：从队首取（pop(0)）
first = queue.pop(0)      # 取 'A'
print(first, queue)       # A ['B', 'C']
# 查看队首（不删除）
print(queue[0])           # 'B'
# 判断是否为空
print(len(queue) == 0)    # False

from collections import deque
q = deque()
q.append("A")        # 入队
q.append("B")
print(q.popleft())   # 出队 → 'A'
print(q)             # deque(['B'])

# n 个人围成一圈，从 1 开始报数，报到 k 的人出列，求最后留下的人
def josephus(n, k):
    q = list(range(1, n + 1))
    idx = 0
    while len(q) > 1:
        idx = (idx + k - 1) % len(q)
        q.pop(idx)
    return q[0]
print(josephus(5, 3))   # 4

stack = []            # 空栈
stack.append(1)       # 入栈 push
stack.append(2)
stack.append(3)
print(stack)          # [1, 2, 3]
top = stack.pop()     # 出栈 pop → 3（后进先出）
print(top, stack)     # 3 [1, 2]
print(stack[-1])      # 查看栈顶 → 2（不删除）
print(len(stack) == 0)  # 判断空栈

# 括号匹配：() [] {}
def match(s):
    stack = []
    pairs = {")": "(", "]": "[", "}": "{"}
    for ch in s:
        if ch in "([{":
            stack.append(ch)      # 左括号入栈
        elif ch in ")]}":
            if not stack or stack.pop() != pairs[ch]:
                return False
    return len(stack) == 0
print(match("([{}])"))   # True
print(match("([)]"))     # False

# 十进制转二进制（除 2 取余，倒序输出 → 栈）
def dec2bin(n):
    stack = []
    while n > 0:
        stack.append(n % 2)
        n //= 2
    return "".join(str(x) for x in reversed(stack))
print(dec2bin(13))   # 1101

# 用类表示二叉树节点
class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 构建一棵树：       1
#                  / \
#                 2   3
#                / \
#               4   5
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

# 前序遍历（根左右）：1 2 4 5 3
def preorder(n):
    if n:
        print(n.val, end=" ")
        preorder(n.left)
        preorder(n.right)
# 中序遍历（左根右）：4 2 5 1 3
def inorder(n):
    if n:
        inorder(n.left)
        print(n.val, end=" ")
        inorder(n.right)
# 后序遍历（左右根）：4 5 2 3 1
def postorder(n):
    if n:
        postorder(n.left)
        postorder(n.right)
        print(n.val, end=" ")

preorder(root); print()
inorder(root); print()
postorder(root); print()