Python 基础语法与数据结构常用代码示例

说明： random.randint(a, b) 返回一个介于 a 和 b 之间（包含两端）的随机整数。

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

使用解包操作符 * 可以将列表元素展开为函数参数。

my_list = [1, 2, 3, 4]

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

扩展： 此方法常用于调用接收不定数量参数的函数。

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

利用序列解包语法提取列表中间部分。

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

说明： _ 代表丢弃首尾元素，* 捕获中间所有元素。

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

Python 支持多重赋值，简洁高效。

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

7. Python 清空列表

使用 clear() 方法移除列表中所有元素。

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

输出：

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

8. 通过 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

说明： 成员可通过身份比较，枚举本身可迭代。

9. 重复字符串

使用乘法运算符 * 可以快速复制字符串。

name = "Banana"
print(name * 4)  # 输出：BananaBananaBananaBanana

10. 计算每个月天数

利用 calendar 模块获取月份信息。

#!/usr/bin/python3
import calendar

monthRange = calendar.monthrange(2016, 9)
print(monthRange)

输出： (3, 30)

说明： 元组第一个元素表示该月第一天是星期几（0-6），第二个元素为该月总天数。

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

判断并输出给定区间内的所有素数。

# 输出指定范围内的素数
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)

注意： 内层循环若无 break 则执行 else 块，即找到素数。

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

二、C 语言数据结构算法示例

以下示例展示了顺序表（SqList）的经典操作，涉及时间复杂度 O(n) 和空间复杂度 O(1) 的要求。

13. 奇数移到偶数前

需求： 将所有奇数移动到偶数之前，要求时间最少，辅助空间最少。 思路： 双指针法，左找偶数，右找奇数，交换。

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. 顺序表元素逆置

需求： 将顺序表 L 中所有元素逆置，空间复杂度 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;
    }
}

修正说明： 原逻辑中 i=L.length/2 已修正为 i < L.length / 2，防止越界。

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 之间的所有数据

需求： 删除顺序表中值在 x 到 y 之间的所有元素，效率优先。

方法一：保留非目标元素

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];
        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()

三、学习建议与总结

编程能力的提升依赖于持续的实践。上述代码涵盖了基础语法控制流、数据结构操作以及经典算法思想。

1. 基础巩固： 熟练掌握 Python 的列表推导、解包、枚举等特性，能显著提升开发效率。
2. 算法思维： C 语言顺序表操作有助于理解内存管理、指针操作及时间复杂度分析。
3. 持续进阶： 在掌握基础后，可进一步探索爬虫、数据分析、机器学习等领域，这些方向均建立在扎实的编程基础之上。

建议读者在实际环境中运行上述代码，修改参数观察输出变化，从而加深理解。编程没有捷径，唯有坚持训练方能融会贯通。