Python 基础语法与常见算法代码示例

每次执行该代码将返回 0 到 9 之间的一个随机整数。这在模拟测试、游戏开发或数据打乱场景中非常有用。

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

使用解包操作符 * 可以将列表中的元素展开为多个独立参数。这对于需要不定数量参数的函数调用特别方便。

my_list = [1, 2, 3, 4]

print(my_list)      # 输出列表对象：[1, 2, 3, 4]
print(*my_list)     # 输出解包后的元素：1 2 3 4

此特性不仅可用于打印，更常用于函数调用，如 func(*args)。

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

这种写法简洁高效，避免了重复声明变量的过程。

7. Python 清空列表

列表对象的 clear() 方法用于移除列表中所有元素，使列表变为空。

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

执行后列表内存被释放但对象依然存在，适合需要复用列表容器的场景。

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

相比使用魔法数字，枚举使得状态管理更加清晰且不易出错。

9. 重复字符串

使用乘法运算符 * 可以直接复制字符串内容。

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

这在生成占位符、分隔线或重复文本格式时非常便捷。

10. 计算每个月天数

calendar 模块提供了处理日期和时间的功能。monthrange(year, month) 返回一个元组，包含当月第一天是星期几以及当月的总天数。

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

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

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)

逻辑说明：大于 1 的数才可能是素数。内部循环尝试用 2 到 num-1 之间的数去除 num，若能整除则不是素数。若内部循环未触发 break，则说明是素数。

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)。

算法思路：首尾对称交换。只需扫描前半部分，将第 i 个元素与倒数第 i 个元素交换。

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[L.length - i - 1] = x;
    }
}

注意：循环条件应为 i < L.length / 2，避免重复交换或越界。

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

从顺序表中删除最小值元素，并用最后一个元素填补空缺。

算法思路：遍历查找最小值及其下标，删除后将末尾元素移至该位置，长度减一。

bool Delete_Min(SqList &L, ElemType &value)
{
    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] 内的所有元素。

算法思路：使用快慢指针。慢指针 k 记录保留元素的位置，快指针 i 遍历数组。若当前元素不在区间内，则复制到 k 位置并递增 k。

void del_xy(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]。此方法保证了 O(n) 的时间复杂度和 O(1) 的空间复杂度。

17. 打印九九乘法表

这是编程入门的经典练习，考察嵌套循环的使用。

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

外层循环控制行数，内层循环控制列数。end='' 参数确保在同一行输出，每行结束后换行。

最佳实践与注意事项

在实际开发中应用上述代码时，建议遵循以下规范以提升代码质量：

1. 变量命名：保持语义清晰，避免使用单字母变量（除循环计数器外），便于团队协作与维护。
2. 边界检查：在处理数组或列表时，务必检查索引是否越界，特别是在涉及动态长度的操作中。
3. 异常处理：在涉及用户输入或外部资源读取时，应添加 try-except 块以防止程序崩溃。
4. 性能优化：对于大规模数据处理，优先选择时间复杂度较低的算法，如使用哈希表替代线性查找。
5. 代码复用：将通用逻辑封装为函数或类，减少重复代码，提高可维护性。

结语

以上代码片段涵盖了 Python 基础语法及常见的线性表算法操作。掌握这些基础模式有助于构建更复杂的程序逻辑。建议在实际项目中结合具体需求灵活应用，并注意边界条件的处理。通过不断练习与总结，开发者能够逐步建立起扎实的编程思维体系。