下面我将用 Python 语言 来实现这些经典例题，Python 语法简洁，非常适合用来理解和演示这些算法思想。

我会按照原书的常见顺序,并对其中的部分题目进行优化和补充，使其更符合 Python 的编程习惯和现代编程理念。

Python 实现经典100例

第一部分：基础入门 (1-20)

这部分主要涉及基本的输入输出、变量、数据类型和简单的算术运算。

例1：在屏幕上输出 "Hello, World!"

# Python 的 "Hello, World!" 非常简洁
print("Hello, World!")

例2：通过用户输入计算两个数的和

# Python 3 中 input() 函数返回的是字符串，需要用 int() 或 float() 转换
num1 = float(input("请输入第一个数字: "))
num2 = float(input("请输入第二个数字: "))
sum = num1 + num2
print(f"{num1} + {num2} = {sum}")

例3：计算一个数的平方

num = float(input("请输入一个数字: "))
square = num ** 2  # 使用 ** 运算符求幂
print(f"{num} 的平方是: {square}")

例4：判断一个数是奇数还是偶数

num = int(input("请输入一个整数: "))
if num % 2 == 0:
    print(f"{num} 是偶数")
else:
    print(f"{num} 是奇数")

例5：判断一个年份是否是闰年

year = int(input("请输入一个年份: "))
# 闰年规则：能被4整除但不能被100整除，或者能被400整除
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 是闰年")
else:
    print(f"{year} 不是闰年")

例6：求三个数中的最大值

# 方法一：使用内置函数 max()
a, b, c = map(int, input("请输入三个整数，用空格隔开: ").split())
print(f"最大值是: {max(a, b, c)}")
# 方法二：使用条件判断
# max_val = a
# if b > max_val:
#     max_val = b
# if c > max_val:
#     max_val = c
# print(f"最大值是: {max_val}")

例7：计算阶乘

def factorial(n):
    """计算 n 的阶乘"""
    if n < 0:
        return "阶乘未定义负数"
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result
num = int(input("请输入一个非负整数: "))
print(f"{num} 的阶乘是: {factorial(num)}")

例8：打印斐波那契数列前 n 项

def fibonacci(n):
    """打印斐波那契数列前 n 项"""
    a, b = 0, 1
    print("斐波那契数列前", n, "项是:")
    for _ in range(n):
        print(a, end=" ")
        a, b = b, a + b # Python 的元组解包特性让交换和更新非常方便
    print()
n = int(input("请要打印的项数: "))
fibonacci(n)

例9：检查一个数是否为素数（质数）

def is_prime(n):
    """判断一个数是否为素数"""
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    # 只需检查到平方根即可
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True
num = int(input("请输入一个整数: "))
if is_prime(num):
    print(f"{num} 是素数")
else:
    print(f"{num} 不是素数")

例10：打印九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        # 使用 f-string 格式化输出，保持对齐
        print(f"{j}x{i}={i*j:<2}", end=" ")
    print() # 换行

例11：反转一个字符串

s = input("请输入一个字符串: ")
# 方法一：使用切片 [::-1]
reversed_s = s[::-1]
print(f"反转后的字符串是: {reversed_s}")
# 方法二：使用 reversed() 函数
# reversed_s = ''.join(reversed(s))
# print(f"反转后的字符串是: {reversed_s}")

例12：统计一个字符串中字符的出现次数

s = input("请输入一个字符串: ")
char_count = {}
for char in s:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1
print("字符统计结果:")
for char, count in char_count.items():
    print(f"'{char}': {count}")

例13：从列表中找出最大值和最小值

# Python 有内置函数 max() 和 min()，非常方便
numbers = list(map(int, input("请输入一系列数字，用空格隔开: ").split()))
print(f"列表: {numbers}")
print(f"最大值是: {max(numbers)}")
print(f"最小值是: {min(numbers)}")

例14：对列表进行排序

numbers = list(map(int, input("请输入一系列数字，用空格隔开: ").split()))
# 方法一：使用列表的 sort() 方法 (原地排序)
numbers_sorted_asc = sorted(numbers) # sorted() 返回一个新列表
numbers_sorted_desc = sorted(numbers, reverse=True)
print(f"原始列表: {numbers}")
print(f"升序排序: {numbers_sorted_asc}")
print(f"降序排序: {numbers_sorted_desc}")

例15：实现一个简单的计算器

def calculator():
    print("--- 简单计算器 ---")
    try:
        num1 = float(input("请输入第一个数字: "))
        op = input("请输入运算符 (+, -, *, /): ")
        num2 = float(input("请输入第二个数字: "))
        if op == '+':
            print(f"结果: {num1 + num2}")
        elif op == '-':
            print(f"结果: {num1 - num2}")
        elif op == '*':
            print(f"结果: {num1 * num2}")
        elif op == '/':
            if num2 == 0:
                print("错误：除数不能为零！")
            else:
                print(f"结果: {num1 / num2}")
        else:
            print("无效的运算符！")
    except ValueError:
        print("错误：请输入有效的数字！")
calculator()

例16：实现冒泡排序

def bubble_sort(arr):
    """冒泡排序"""
    n = len(arr)
    for i in range(n):
        # 每次遍历后，最大的元素会“冒泡”到最后
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                # 交换元素
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr
numbers = list(map(int, input("请输入一系列数字，用空格隔开: ").split()))
print(f"原始列表: {numbers}")
sorted_numbers = bubble_sort(numbers)
print(f"排序后列表: {sorted_numbers}")

例17：实现选择排序

def selection_sort(arr):
    """选择排序"""
    n = len(arr)
    for i in range(n):
        # 找到未排序部分的最小元素
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        # 将找到的最小元素与未排序部分的第一个元素交换
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr
numbers = list(map(int, input("请输入一系列数字，用空格隔开: ").split()))
print(f"原始列表: {numbers}")
sorted_numbers = selection_sort(numbers)
print(f"排序后列表: {sorted_numbers}")

例18：实现二分查找

def binary_search(arr, target):
    """二分查找（要求数组已排序）"""
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid  # 找到目标，返回索引
        elif arr[mid] < target:
            low = mid + 1  # 目标在右半部分
        else:
            high = mid - 1  # 目标在左半部分
    return -1  # 未找到目标
# 必须先对列表进行排序
numbers = list(map(int, input("请输入一系列数字，用空格隔开: ").split()))
numbers.sort()
print(f"已排序的列表: {numbers}")
target = int(input("请输入要查找的数字: "))
index = binary_search(numbers, target)
if index != -1:
    print(f"数字 {target} 在列表中的索引是: {index}")
else:
    print(f"数字 {target} 不在列表中。")

例19：合并两个有序列表

def merge_sorted_lists(list1, list2):
    """合并两个有序列表"""
    merged = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            merged.append(list1[i])
            i += 1
        else:
            merged.append(list2[j])
            j += 1
    # 将剩余元素添加到合并列表中
    merged.extend(list1[i:])
    merged.extend(list2[j:])
    return merged
list1 = list(map(int, input("请输入第一个有序列表，数字用空格隔开: ").split()))
list2 = list(map(int, input("请输入第二个有序列表，数字用空格隔开: ").split()))
print(f"列表1: {list1}")
print(f"列表2: {list2}")
merged_list = merge_sorted_lists(list1, list2)
print(f"合并后的有序列表: {merged_list}")

例20：实现一个简单的猜数字游戏

import random
def guess_the_number():
    """猜数字游戏"""
    number_to_guess = random.randint(1, 100)
    attempts = 0
    print("我想了一个1到100之间的数字，你能猜到吗？")
    while True:
        try:
            guess = int(input("请输入你的猜测: "))
            attempts += 1
            if guess < number_to_guess:
                print("太小了！")
            elif guess > number_to_guess:
                print("太大了！")
            else:
                print(f"恭喜你！猜对了！你用了 {attempts} 次尝试。")
                break
        except ValueError:
            print("请输入一个有效的整数！")
guess_the_number()

第二部分：进阶与算法 (21-50)

这部分涉及更复杂的数据结构（如链表、栈、队列）和经典算法（如递归、动态规划、贪心等）。

例21：递归实现阶乘

def recursive_factorial(n):
    """递归计算阶乘"""
    if n == 0 or n == 1:
        return 1
    else:
        return n * recursive_factorial(n - 1)
num = int(input("请输入一个非负整数: "))
print(f"{num} 的阶乘是: {recursive_factorial(num)}")

例22：递归实现斐波那契数列

def recursive_fibonacci(n):
    """递归计算斐波那契数列的第 n 项"""
    if n <= 1:
        return n
    else:
        return recursive_fibonacci(n - 1) + recursive_fibonacci(n - 2)
n = int(input("请要计算的项数: "))
print(f"斐波那契数列的第 {n} 项是: {recursive_fibonacci(n)}")
# 注意：此方法效率低下，仅用于演示递归思想。

例23：汉诺塔问题

def hanoi(n, source, auxiliary, target):
    """汉诺塔递归解法"""
    if n == 1:
        print(f"将盘子 1 从 {source} 移动到 {target}")
    else:
        # 将 n-1 个盘子从源柱移动到辅助柱
        hanoi(n - 1, source, target, auxiliary)
        # 将第 n 个盘子从源柱移动到目标柱
        print(f"将盘子 {n} 从 {source} 移动到 {target}")
        # 将 n-1 个盘子从辅助柱移动到目标柱
        hanoi(n - 1, auxiliary, source, target)
n = int(input("请输入汉诺塔的盘子数量: "))
print(f"移动 {n} 个盘子的步骤如下:")
hanoi(n, 'A', 'B', 'C')

例24：实现一个简单的栈

class Stack:
    """使用列表实现栈"""
    def __init__(self):
        self.items = []
    def is_empty(self):
        return not self.items
    def push(self, item):
        self.items.append(item)
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return None
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return None
    def size(self):
        return len(self.items)
# 使用示例
s = Stack()
s.push('a')
s.push('b')
s.push('c')
print(f"栈顶元素是: {s.peek()}") # 输出 c
print(f"栈大小: {s.size()}")    # 输出 3
print(f"出栈: {s.pop()}")       # 输出 c
print(f"出栈: {s.pop()}")       # 输出 b
print(f"栈是否为空: {s.is_empty()}") # 输出 False

例25：实现一个简单的队列

from collections import deque # 使用 deque 实现队列更高效
class Queue:
    """使用 deque 实现队列"""
    def __init__(self):
        self.items = deque()
    def is_empty(self):
        return not self.items
    def enqueue(self, item):
        self.items.append(item)
    def dequeue(self):
        if not self.is_empty():
            return self.items.popleft()
        return None
    def size(self):
        return len(self.items)
# 使用示例
q = Queue()
q.enqueue('a')
q.enqueue('b')
q.enqueue('c')
print(f"队首元素是: {q.items[0]}") # 输出 a
print(f"队列大小: {q.size()}")    # 输出 3
print(f"出队: {q.dequeue()}")     # 输出 a
print(f"出队: {q.dequeue()}")     # 输出 b

例26：实现一个单向链表

class Node:
    """链表节点"""
    def __init__(self, data):
        self.data = data
        self.next = None
class LinkedList:
    """单向链表"""
    def __init__(self):
        self.head = None
    def append(self, data):
        """在链表末尾添加节点"""
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node
    def print_list(self):
        """打印链表"""
        current_node = self.head
        while current_node:
            print(current_node.data, end=" -> ")
            current_node = current_node.next
        print("None")
# 使用示例
llist = LinkedList()
llist.append(1)
llist.append(2)
llist.append(3)
print("创建的链表:")
llist.print_list() # 输出 1 -> 2 -> 3 -> None

例27：深度优先搜索

# 使用邻接表表示图
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
def dfs(graph, node, visited=None):
    """深度优先搜索"""
    if visited is None:
        visited = set()
    visited.add(node)
    print(node, end=' ')
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)
print("深度优先搜索的遍历顺序:")
dfs(graph, 'A') # 输出 A B D E F C

例28：广度优先搜索

from collections import deque
def bfs(graph, start_node):
    """广度优先搜索"""
    visited = set()
    queue = deque([start_node])
    while queue:
        node = queue.popleft()
        if node not in visited:
            print(node, end=' ')
            visited.add(node)
            # 将所有未访问的邻居加入队列
            for neighbor in graph[node]:
                if neighbor not in visited:
                    queue.append(neighbor)
print("\n广度优先搜索的遍历顺序:")
bfs(graph, 'A') # 输出 A B C D E F

例29：贪心算法：找零问题

def make_change_greedy(amount, coins):
    """贪心算法找零（假设硬币面额是标准的）"""
    coins.sort(reverse=True)  # 从大到小排序
    change = []
    for coin in coins:
        while amount >= coin:
            amount -= coin
            change.append(coin)
        if amount == 0:
            break
    return change
# 标准硬币面额
coins = [100, 50, 20, 10, 5, 1] # 假设是元、角、分
amount = int(input("请输入需要找零的总金额（以分为单位）: "))
change = make_change_greedy(amount, coins)
print(f"找零方案: {change}")

例30：动态规划：斐波那契数列（优化版）

def dp_fibonacci(n):
    """使用动态规划（记忆化或迭代）计算斐波那契数列，效率高"""
    if n <= 1:
        return n
    # 使用两个变量存储前两个结果
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b
n = int(input("请要计算的项数: "))
print(f"斐波那契数列的第 {n} 项是: {dp_fibonacci(n)}")

第三部分：文件与系统 (51-80)

这部分主要涉及文件读写、目录操作和简单的系统交互。

例51：读取并显示文本文件内容

filename = input("请输入要读取的文件名: ")
try:
    with open(filename, 'r', encoding='utf-8') as f:
        content = f.read()
        print("\n文件内容:")
        print(content)
except FileNotFoundError:
    print(f"错误：文件 '{filename}' 未找到。")
except Exception as e:
    print(f"发生错误: {e}")

例52：写入内容到文本文件

filename = input("请输入要写入的文件名: ")
content = input("请输入要写入的内容: ")
try:
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(content)
    print(f"内容已成功写入到 '{filename}'")
except Exception as e:
    print(f"写入文件时发生错误: {e}")

例53：追加内容到文本文件

filename = input("请输入要追加的文件名: ")
content = input("请输入要追加的内容: ")
try:
    with open(filename, 'a', encoding='utf-8') as f:
        f.write("\n" + content) # 换行再追加
    print(f"内容已成功追加到 '{filename}'")
except Exception as e:
    print(f"追加文件时发生错误: {e}")

例54：逐行读取文件

filename = input("请输入要读取的文件名: ")
try:
    with open(filename, 'r', encoding='utf-8') as f:
        print("\n逐行读取文件内容:")
        for line in f:
            print(line, end='') # print 默认会换行，line自带换行符，所以用 end=''
except FileNotFoundError:
    print(f"错误：文件 '{filename}' 未找到。")

例55：统计文件中的行数、单词数和字符数

import os
def count_file_stats(filename):
    try:
        with open(filename, 'r', encoding='utf-8') as f:
            lines = 0
            words = 0
            chars = 0
            for line in f:
                lines += 1
                words += len(line.split())
                chars += len(line)
            return lines, words, chars
    except FileNotFoundError:
        return None, None, None
filename = input("请输入要统计的文件名: ")
lines, words, chars = count_file_stats(filename)
if lines is not None:
    print(f"文件 '{filename}' 的统计信息:")
    print(f"行数: {lines}")
    print(f"单词数: {words}")
    print(f"字符数: {chars}")
else:
    print(f"错误：文件 '{filename}' 未找到。")

例56：复制一个文件

import shutil
source_file = input("请输入源文件名: ")
destination_file = input("请输入目标文件名: ")
try:
    shutil.copy(source_file, destination_file)
    print(f"文件 '{source_file}' 已成功复制到 '{destination_file}'")
except FileNotFoundError:
    print(f"错误：源文件 '{source_file}' 未找到。")
except Exception as e:
    print(f"复制文件时发生错误: {e}")

例57：列出目录中的所有文件和子目录

import os
directory = input("请输入要列出的目录路径: ")
try:
    print(f"\n目录 '{directory}' 中的内容:")
    for item in os.listdir(directory):
        # os.path.join 用于拼接路径，保证跨平台兼容性
        full_path = os.path.join(directory, item)
        if os.path.isdir(full_path):
            print(f"[目录] {item}")
        else:
            print(f"[文件] {item}")
except FileNotFoundError:
    print(f"错误：目录 '{directory}' 未找到。")
except Exception as e:
    print(f"列出目录时发生错误: {e}")

例58：创建一个新目录

import os
directory_name = input("请输入要创建的目录名: ")
try:
    os.makedirs(directory_name, exist_ok=True) # exist_ok=True 避免目录已存在时报错
    print(f"目录 '{directory_name}' 创建成功。")
except Exception as e:
    print(f"创建目录时发生错误: {e}")

例59：获取当前工作目录

import os
current_dir = os.getcwd()
print(f"当前工作目录是: {current_dir}")

例60：执行系统命令

import subprocess
command = input("请输入要执行的命令 ( dir, ls, ipconfig): ")
try:
    # shell=True 表示通过系统shell执行，可以执行复合命令
    # text=True 自动解码输出为字符串
    result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
    print("\n命令输出:")
    print(result.stdout)
except subprocess.CalledProcessError as e:
    print(f"命令执行失败，返回码: {e.returncode}")
    print(f"错误信息: {e.stderr}")
except Exception as e:
    print(f"执行命令时发生错误: {e}")

第四部分：综合应用 (81-100)

这部分是一些综合性更强、更贴近实际应用的题目。

例81：发送一封简单的电子邮件

import smtplib
from email.mime.text import MIMEText
def send_email(subject, body, to_email, from_email, password):
    """发送电子邮件"""
    msg = MIMEText(body)
    msg['Subject'] = subject
    msg['From'] = from_email
    msg['To'] = to_email
    try:
        # 使用 Gmail 的 SMTP 服务器，需要开启“低安全性应用”访问
        # 或者使用应用专用密码
        with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
            server.login(from_email, password)
            server.sendmail(from_email, to_email, msg.as_string())
        print("邮件发送成功！")
    except Exception as e:
        print(f"邮件发送失败: {e}")
# --- 配置信息 ---
# 注意：实际使用时请替换为你的真实信息，并注意邮箱安全设置
# from_email = "your_email@gmail.com"
# password = "your_app_password" # 对于Gmail，需要使用应用专用密码
# to_email = "recipient_email@example.com"
# subject = "来自Python的问候"
# body = "你好，这是一封通过Python发送的测试邮件。"
# send_email(subject, body, to_email, from_email, password)
print("此示例需要配置真实的邮箱信息才能运行。")

例82：简单的Web爬虫（抓取网页标题）

import requests
from bs4 import BeautifulSoup
def get_webpage_title(url):
    """获取网页标题"""
    try:
        response = requests.get(url, timeout=5)
        # 检查请求是否成功
        response.raise_for_status()
        soup = BeautifulSoup(response.text, 'html.parser')
        if soup.title:
            return soup.title.string
        else:
            return "网页未找到标题"
    except requests.exceptions.RequestException as e:
        return f"请求失败: {e}"
url = input("请输入要抓取的网页URL ( http://example.com): ")= get_webpage_title(url)
print(f"网页标题是: {title}")

例83：使用正则表达式验证邮箱格式

import re
def is_valid_email(email):
    """使用正则表达式验证邮箱"""
    # 这是一个简单的正则表达式，不完全覆盖所有有效邮箱格式
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    if re.match(pattern, email):
        return True
    return False
email = input("请输入一个邮箱地址: ")
if is_valid_email(email):
    print(f"'{email}' 是一个有效的邮箱格式。")
else:
    print(f"'{email}' 不是一个有效的邮箱格式。")

例84：实现一个简单的多线程下载器

import requests
import threading
import os
def download_chunk(url, start_byte, end_byte, filename, part_num):
    """下载文件的一个部分"""
    headers = {'Range': f'bytes={start_byte}-{end_byte}'}
    try:
        response = requests.get(url, headers=headers, stream=True)
        response.raise_for_status()
        with open(f"{filename}.part{part_num}", 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)
        print(f"分块 {part_num} 下载完成。")
    except Exception as e:
        print(f"分块 {part_num} 下载失败: {e}")
def multi_thread_download(url, num_threads=4):
    """多线程下载主函数"""
    filename = url.split('/')[-1]
    if not filename:
        filename = "downloaded_file"
    try:
        # 1. 获取文件总大小
        response = requests.head(url)
        file_size = int(response.headers.get('content-length', 0))
        if file_size == 0:
            print("无法获取文件大小，无法进行分块下载。")
            return
        # 2. 计算每个线程下载的大小
        chunk_size = file_size // num_threads
        threads = []
        # 3. 创建并启动线程
        for i in range(num_threads):
            start_byte = i * chunk_size
            end_byte = (i + 1) * chunk_size - 1 if i < num_threads - 1 else file_size - 1
            thread = threading.Thread(target=download_chunk, args=(url, start_byte, end_byte, filename, i))
            threads.append(thread)
            thread.start()
        # 4. 等待所有线程完成
        for thread in threads:
            thread.join()
        # 5. 合并文件
        print("所有分块下载完成，正在合并文件...")
        with open(filename, 'wb') as outfile:
            for i in range(num_threads):
                part_filename = f"{filename}.part{i}"
                if os.path.exists(part_filename):
                    with open(part_filename, 'rb') as infile:
                        outfile.write(infile.read())
                    os.remove(part_filename) # 删除分块文件
        print(f"文件 '{filename}' 下载并合并完成！")
    except Exception as e:
        print(f"下载过程中发生错误: {e}")
# url = "http://example.com/largefile.zip" # 替换为实际的下载链接
# multi_thread_download(url)
print("此示例需要提供一个有效的下载链接才能运行。")

例85：使用Pandas处理CSV数据

import pandas as pd
# 创建一个示例CSV文件
data = {
    'Name': ['Alice', 'Bob', 'Charlie', 'David'],
    'Age': [25, 30, 35, 28],
    'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df = pd.DataFrame(data)
df.to_csv('people.csv', index=False)
print("创建的CSV文件 'people.csv':")
print(df)
# --- 读取和处理CSV ---
try:
    # 读取CSV文件
    df_read = pd.read_csv('people.csv')
    print("\n从CSV文件读取的数据:")
    print(df_read)
    # 数据筛选
    print("\n年龄大于30的人:")
    print(df_read[df_read['Age'] > 30])
    # 计算平均年龄
    avg_age = df_read['Age'].mean()
    print(f"\n平均年龄: {avg_age:.2f}")
except FileNotFoundError:
    print("错误：CSV文件 'people.csv' 未找到。")
except Exception as e:
    print(f"处理CSV时发生错误: {e}")

例86：使用SQLite进行数据库操作

import sqlite3
# 连接到SQLite数据库（如果不存在则创建）
conn = sqlite3.connect('example.db')
cursor = conn.cursor()
# 创建一个表
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER
)
''')
# 插入数据
users_to_insert = [
    ('Alice', 25),
    ('Bob', 30),
    ('Charlie', 35)
]
cursor.executemany('INSERT INTO users (name, age) VALUES (?, ?)', users_to_insert)
# 提交事务
conn.commit()
# 查询数据
cursor.execute('SELECT * FROM users')
print("数据库中的所有用户:")
for row in cursor.fetchall():
    print(row)
# 更新数据
cursor.execute("UPDATE users SET age = ? WHERE name = ?", (26, 'Alice'))
conn.commit()
# 删除数据
cursor.execute("DELETE FROM users WHERE name = ?", ('Bob',))
conn.commit()
# 再次查询
cursor.execute('SELECT * FROM users')
print("\n更新后的所有用户:")
for row in cursor.fetchall():
    print(row)
# 关闭连接
conn.close()

例87：使用Tkinter创建一个简单的GUI应用

import tkinter as tk
from tkinter import messagebox
def show_message():
    """显示一个消息框"""
    messagebox.showinfo("问候", "你好，欢迎使用Tkinter！")
# 创建主窗口
root = tk.Tk()"我的第一个GUI应用")
root.geometry("300x200")
# 创建一个标签
label = tk.Label(root, text="这是一个Tkinter窗口", font=("Arial", 14))
label.pack(pady=20)
# 创建一个按钮
button = tk.Button(root, text="点击我", command=show_message)
button.pack(pady=10)
# 运行主循环
root.mainloop()

例88：创建一个简单的RESTful API服务器

from flask import Flask, jsonify, request
app = Flask(__name__)
# 模拟一个简单的数据库
books = [
    {'id': 1, 'title': 'Python入门', 'author': '张三'},
    {'id': 2, 'title': 'Flask实战', 'author': '李四'}
]
next_book_id = 3
# GET /api/books - 获取所有书籍
@app.route('/api/books', methods=['GET'])
def get_books():
    return jsonify(books)
# GET /api/books/<int:book_id> - 获取单本书籍
@app.route('/api/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((book for book in books if book['id'] == book_id), None)
    if book is None:
        return jsonify({'error': '书籍未找到'}), 404
    return jsonify(book)
# POST /api/books - 添加一本新书
@app.route('/api/books', methods=['POST'])
def add_book():
    global next_book_id
    if not request.json or 'title' not in request.json or 'author' not in request.json:
        return jsonify({'error': '请求体必须是JSON格式，且包含title和author'}), 400
    new_book = {
        'id': next_book_id,
        'title': request.json['title'],
        'author': request.json['author']
    }
    books.append(new_book)
    next_book_id += 1
    return jsonify(new_book), 201
if __name__ == '__main__':
    # debug=True 可以在代码修改后自动重启服务器
    app.run(debug=True, port=5000)

例89：使用Matplotlib绘制数据图表

import matplotlib.pyplot as plt
# 准备数据
categories = ['A', 'B', 'C', 'D']
values = [15, 30, 45, 10]
# 创建条形图
plt.figure(figsize=(8, 5)) # 设置图表大小
plt.bar(categories, values, color=['skyblue', 'lightgreen', 'salmon', 'gold'])
和标签'不同类别的数值对比')
plt.xlabel('类别')
plt.ylabel('数值')
plt.grid(axis='y', linestyle='--', alpha=0.7) # 添加网格线
# 显示图表
plt.show()

例90：使用Numpy进行数值计算

import numpy as np
# 创建一个Numpy数组
arr = np.array([1, 2, 3, 4, 5])
print("原始数组:", arr)
# 计算数组的属性
print("数组维度:", arr.ndim)
print("数组形状:", arr.shape)