6个案例15分钟让你了解Python套路

​

目录

[1. 打印九九乘法口诀](#1. 打印九九乘法口诀 "#1.%20%E6%89%93%E5%8D%B0%E4%B9%9D%E4%B9%9D%E4%B9%98%E6%B3%95%E5%8F%A3%E8%AF%80")

[2. 计算列表中各数之和](#2. 计算列表中各数之和 "#2.%20%E8%AE%A1%E7%AE%97%E5%88%97%E8%A1%A8%E4%B8%AD%E5%90%84%E6%95%B0%E4%B9%8B%E5%92%8C")

[3. 判断一个数是否为素数](#3. 判断一个数是否为素数 "#3.%20%E5%88%A4%E6%96%AD%E4%B8%80%E4%B8%AA%E6%95%B0%E6%98%AF%E5%90%A6%E4%B8%BA%E7%B4%A0%E6%95%B0")

[4. 斐波那契数列](#4. 斐波那契数列 "#4.%20%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97")

[5. 冒泡排序算法](#5. 冒泡排序算法 "#5.%20%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95")

[6. 汉诺塔问题](#6. 汉诺塔问题 "#6.%20%E6%B1%89%E8%AF%BA%E5%A1%94%E9%97%AE%E9%A2%98")

总结

---

Python以其简洁易读的特点著称，很多程序员都把Python当作"第一门编程语言"来学习。不过，Python虽然语法简单，但想要真正掌握，还需要下一番功夫。今天，我们就通过7个代码小案例，带你快速了解Python编程的套路。

1. 打印九九乘法口诀

对于很多编程初学者来说，打印九九乘法口诀是入门的第一课。下面这个Python代码示例，使用了嵌套循环（for循环嵌套for循环）来打印九九乘法口诀表。

# 打印九九乘法口诀
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}*{i}={i * j}", end="\t")
    print()

代码解读：

• 第一个for循环变量i的取值范围是1到9，代表乘法口诀表的每一行。
• 第二个for循环变量j的取值范围是1到i（包含i），代表每一行中的每一列。
• print函数中的f"{j}*{i}={i * j}"是格式化字符串，用于打印乘法运算式和结果。
• end="\t"参数的作用是在print函数打印完字符串后不换行，而是以制表符（Tab）结尾，这样可以使同一行的内容在同一行显示。
• 最外层的print()函数（没有带任何参数）用于在每一行结束后换行。

2. 计算列表中各数之和

在Python中，计算列表中各数之和有多种方法。下面的代码示例展示了两种常用的方法：使用for循环和使用内置函数sum()。

# 计算列表中各数之和
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
# 方法一：使用for循环
total_sum1 = 0
for number in numbers:
    total_sum1 += number
print(f"使用for循环计算列表之和：{total_sum1}")
 
# 方法二：使用内置函数sum()
total_sum2 = sum(numbers)
print(f"使用sum()函数计算列表之和：{total_sum2}")

代码解读：

• 方法一：首先初始化变量total_sum1为0，然后使用for循环遍历列表numbers中的每一个元素，将元素值累加到total_sum1中，最后打印出总和。
• 方法二：直接使用Python内置的sum()函数来计算列表中各数之和，sum()函数会返回列表中所有元素相加后的总和。

3. 判断一个数是否为素数

素数是指只能被1和自身整除的大于1的自然数。下面的代码示例展示了如何使用Python编写一个函数来判断一个数是否为素数。

# 判断一个数是否为素数
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True
 
# 测试函数
num = 29
if is_prime(num):
    print(f"{num}是素数")
else:
    print(f"{num}不是素数")

代码解读：

• 函数is_prime(n)用于判断一个数n是否为素数。
• 如果n小于等于1，则直接返回False，因为1和负数都不是素数。
• 使用for循环遍历从2到sqrt(n)（包含sqrt(n)）的所有整数，如果n能被其中任何一个整数整除，则说明n不是素数，返回False。
• 如果循环结束后没有找到能整除n的整数，则说明n是素数，返回True。
• 在函数外部，我们调用is_prime函数来测试一个数是否为素数，并根据返回值打印相应的结果。

4. 斐波那契数列

斐波那契数列（Fibonacci sequence）又称黄金分割数列，因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称为"兔子数列"。指的是这样一个数列：1、1、2、3、5、8、13、21、34、......这个数列从第3项开始，每一项都等于前两项之和。下面的代码示例展示了如何使用Python生成斐波那契数列。

# 生成斐波那契数列
def fibonacci(n):
    fib_sequence = [1, 1]
    for i in range(2, n):
        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
    return fib_sequence[:n]
 
# 测试函数
n = 10
fib_sequence = fibonacci(n)
print(f"斐波那契数列的前{n}项是：{fib_sequence}")

代码解读：

• 函数fibonacci(n)用于生成斐波那契数列的前n项。
• 首先初始化列表fib_sequence为[1, 1]，这是斐波那契数列的前两项。
• 然后使用for循环从第3项开始生成斐波那契数列，每一项都等于前两项之和，即fib_sequence[-1] + fib_sequence[-2]。
• 最后返回fib_sequence列表的前n项（切片操作fib_sequence[:n]），因为我们在循环中多生成了一项（为了计算第n项需要知道第n-1项和第n-2项）。

5. 冒泡排序算法

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小（或越大）的元素会经过交换慢慢"浮"到数列的顶端。下面的代码示例展示了如何使用Python实现冒泡排序算法。

# 冒泡排序算法
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        # 提前退出冒泡排序的标志位
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                # 交换元素
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        # 如果没有发生交换，说明数组已经有序，提前退出
        if not swapped:
            break
    return arr
 
# 测试函数
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print(f"排序后的数组是：{sorted_arr}")

代码解读：

• 函数bubble_sort(arr)用于对列表arr进行冒泡排序。
• 首先获取列表arr的长度n。
• 然后使用两层for循环来实现冒泡排序算法。外层循环变量i表示当前已经排序好的元素个数（或者说还需要排序的元素个数），内层循环变量j用于遍历列表中的元素并进行比较和交换。
• 如果在内层循环中没有发生交换操作（即swapped标志位为False），则说明列表已经有序，可以提前退出外层循环。
• 最后返回排序后的列表。

6. 汉诺塔问题

汉诺塔（Tower of Hanoi）是一个源于印度古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。下面的代码示例展示了如何使用Python解决汉诺塔问题。

# 解决汉诺塔问题的递归函数
def hanoi(n, source, auxiliary, target):
    if n == 1:
        print(f"将圆盘1从{source}移动到{target}")
        return
    hanoi(n - 1, source, target, auxiliary)
    print(f"将圆盘{n}从{source}移动到{target}")
    hanoi(n - 1, auxiliary, source, target)
 
# 测试函数
n = 3  # 圆盘数量
hanoi(n, 'A', 'B', 'C')  # A、B、C是三根柱子的名称

代码解读：

• 函数hanoi(n, source, auxiliary, target)是一个递归函数，用于解决汉诺塔问题。其中n表示圆盘的数量，source表示源柱子，auxiliary表示辅助柱子，target表示目标柱子。
• 如果n等于1，则直接将圆盘1从源柱子移动到目标柱子，并打印出相应的操作。
• 如果n大于1，则首先将上面的n-1个圆盘从源柱子借助目标柱子移动到辅助柱子（递归调用hanoi函数），然后将第n个圆盘从源柱子移动到目标柱子，并打印出相应的操作，最后将n-1个圆盘从辅助柱子借助源柱子移动到目标柱子（递归调用hanoi函数）。

总结

Python以其简洁语法和强大功能，成为编程初学者的首选。通过6个经典案例，我们快速领略了Python编程的精髓：从九九乘法口诀的嵌套循环，到列表求和的多种方法；从素数判断的逻辑推理，到斐波那契数列的递归思想；再到冒泡排序和汉诺塔问题的算法实现，这些案例不仅展示了Python的基础语法，更体现了编程思维的重要性。通过实践这些案例，初学者能够加深对Python编程的理解，逐步掌握编程套路，为后续深入学习打下坚实基础。

​