Python 基础语法与数据结构算法实战示例

解析： 每次执行可能输出 0 到 9 之间的任意整数。该函数常用于模拟、游戏开发或测试数据生成。

4. 将列表中的所有元素作为参数传递给函数

Python 支持解包操作符 *，可以将列表或元组中的元素展开为函数参数。这在需要传递不定数量参数时非常有用。

my_list = [1, 2, 3, 4]

print(my_list)      # [1, 2, 3, 4]
print(*my_list)     # 1 2 3 4

应用： 假设有一个函数 add(a, b, c)，可以通过 add(*my_list) 直接调用，无需手动提取每个元素。

5. 获取列表的所有中间元素

利用序列解包特性，可以方便地忽略首尾元素，直接获取中间部分的数据。这比切片操作在某些场景下更直观。

_, *elements_in_the_middle, _ = [1, 2, 3, 4, 5, 6, 7, 8]
print(elements_in_the_middle)  # [2, 3, 4, 5, 6, 7]

解析： 左侧第一个 _ 接收第一个元素，最后一个 _ 接收最后一个元素，中间的 *elements_in_the_middle 收集剩余所有元素。

6. 使用一行代码赋值多个变量

Python 允许同时给多个变量赋值，这被称为多重赋值或元组解包。它提高了代码的简洁性和可读性。

one, two, three, four = 1, 2, 3, 4

扩展： 也可以用于交换变量值，例如 a, b = b, a。

7. Python 清空列表

列表对象提供了 clear() 方法，用于移除列表中的所有元素，使其变为空列表。这是释放内存或重置状态的高效方式。

RUNOOB = [6, 0, 4, 1]
print('清空前:', RUNOOB)
RUNOOB.clear()
print('清空后:', RUNOOB)

输出：

清空前：[6, 0, 4, 1]
清空后：[]

8. 通过 Enum 枚举同一标签或一系列常量的集合

枚举（Enum）是一种数据类型，由一组命名的常量组成。使用 enum 模块可以定义具有唯一值的符号名称，增强代码的可读性和安全性。

from enum import Enum


class Status(Enum):
    NO_STATUS = -1
    NOT_STARTED = 0
    IN_PROGRESS = 1
    COMPLETED = 2

print(Status.IN_PROGRESS.name)  # IN_PROGRESS
print(Status.COMPLETED.value)   # 2

优势： 相比使用魔法数字（如 0, 1），枚举能明确表达业务含义，防止非法值传入。

9. 重复字符串

字符串乘法运算符 * 可以快速复制字符串内容。这在生成占位符、分隔线或测试数据时非常实用。

name = "Banana"
print(name * 4)  # BananaBananaBananaBanana

10. 计算每个月天数

使用 calendar 模块可以获取指定年月的日历信息。monthrange(year, month) 返回一个元组，包含该月第一天是星期几以及该月的总天数。

#!/usr/bin/python3
import calendar
monthRange = calendar.monthrange(2016, 9)
print(monthRange)

解析： 输出 (3, 30) 表示 2016 年 9 月 1 日是星期四（索引 3），该月共有 30 天。

11. 输出指定范围内的素数

素数是只能被 1 和自身整除的大于 1 的自然数。判断素数的基本方法是试除法，检查从 2 到 num-1 是否有因子。

# 输出指定范围内的素数
lower = int(input("输入区间最小值："))
upper = int(input("输入区间最大值："))
for num in range(lower, upper + 1):
    if num > 1:
        for i in range(2, num):
            if (num % i) == 0:
                break
        else:
            print(num)

优化建议： 对于大范围查询，可优化至只检查到 sqrt(num)。

12. 计算两数差值

定义函数计算差值时，需注意参数顺序对结果的影响。使用命名参数可以避免因位置混淆导致的错误。

def subtract(a, b):
    return a - b

print(subtract(1, 3))  # -2
print(subtract(3, 1))  # 2

# 使用命名参数
print(subtract(a=1, b=3))  # -2
print(subtract(b=3, a=1))  # -2

13. 奇数移到偶数前

这是一个经典的数组重排问题。要求时间复杂度 O(n)，空间复杂度 O(1)。采用双指针法，左指针找偶数，右指针找奇数，相遇前交换。

void move(SqList &L)
{
    int i = 0, j = L.length - 1, k;
    ElemType temp;
    while (i < j)
    {
        // 奇数从前向后找
        while (L.data[i] % 2 == 1)
            i++; // 指向偶数
        // 偶数从后往前找
        while (L.data[j] % 2 == 0)
            j--; // 指向奇数
        if (i < j)
        {
            temp = L.data[i];
            L.data[i] = L.data[j];
            L.data[j] = temp;
        }
    }
}

算法分析： 该方法只需遍历一次数组，通过原地交换完成排序，效率极高。

14. 顺序表元素逆置

将线性表中的元素顺序反转。同样要求空间复杂度 O(1)，通常采用首尾对称交换的方法。

void reverse(SqList &L)
{
    int i;
    ElemType x;
    // 只扫描前半部分
    for (i = 0; i < L.length / 2; i++)
    {
        x = L.data[i];
        // L.data[i] 后半部分对应元素为 L.data[L.length-i-1]
        L.data[i] = L.data[L.length - i - 1];
        L.data[L.length - i - 1] = x;
    }
}

说明： 修正了原逻辑中的比较符号错误，确保循环正确终止。例如长度为 7 的表，只需交换前 3 对元素。

15. 删除顺序表最小值元素

查找最小值并用末尾元素填补空缺，最后缩短表长。此操作需保证最小值唯一或仅删除其中一个。

bool Delete_Min(SqList &L, ElemType &value)
{
    // 表长为 0 不成立
    if (L.length == 0)
        return false;
    // 假设第一个元素为最小值
    value = L.data[0];
    // 记录最小值元素下标
    int pos = 0;
    int i;
    // 从第二个元素开始比较
    for (i = 1; i < L.length; i++)
    {
        if (L.data[i] < value)
        {
            value = L.data[i];
            pos = i;
        }
    }
    // 删除位置的元素用最后一个元素取代
    L.data[pos] = L.data[L.length - 1];
    // 表长减一
    L.length--;
    return true;
}

16. 删除值在 x~y 之间的所有数据

从顺序表中删除指定范围内的所有元素。为了保持 O(1) 空间复杂度，不能开辟新数组，需原地移动元素。

方法一：保留非目标元素

void del_xy(SqList &L, ElemType x, ElemType y)
{
    int i, k = 0;
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] >= x && L.data[i] <= y)
        {
            // 跳过
        }
        else
        {
            L.data[k++] = L.data[i];
        }
    }
    L.length = k;
}

方法二：统计删除个数

void del_xy_v2(SqList &L, ElemType x, ElemType y)
{
    int i = 0, k = 0;
    while (i < L.length)
    {
        if (L.data[i] >= x && L.data[i] <= y)
           k++;
        else
           L.data[i - k] = L.data[i];
    }
    L.length = L.length - k;
}

注意： 原文本中 L.data[j] 已修正为 L.data[i]，逻辑已优化为更清晰的保留非目标元素写法。

17. 打印九九乘法表

嵌套循环是打印矩阵类数据的典型应用。外层控制行，内层控制列，利用格式化输出对齐。

for i in range(1, 10):
    for j in range(1, i + 1):
        print('{}x{}={}	'.format(j, i, i * j), end='')
    print()

效果： 输出标准的直角三角形乘法表，便于记忆和展示。

总结

以上示例覆盖了编程语言中常见的控制结构、数据结构操作及基础算法思想。无论是 Python 的动态特性还是 C/C++ 的底层内存管理，理解这些核心片段都有助于解决实际问题。建议读者在本地环境复现代码，并尝试修改参数观察变化，以加深理解。