通过这些题目，你将系统掌握函数、循环、条件、字符串与列表操作等核心语法，并逐步训练算法思维。

一、简单练习 I

1. 打印 1～100 的整数

使用循环依次输出 1 到 100。

def printMany():
    for i in range(1, 101):
        print(i)

# 测试
printMany()

2. 每隔 3 打印一次整数

使用 range(1, 101, 3) 每隔 3 输出一个数。

def printEvery3():
    for i in range(1, 89, 3):
        print(i)

# 测试
printEvery3()

3. 查找首个大写字母及其索引位置

def position(s: str):
    for i, ch in enumerate(s):
        if ch.isupper():
            return ch, i
    return -1

# 测试
print(position("abcd"))   # -1
print(position("AbcD"))   # ('A', 0)
print(position("abCD"))   # ('C', 2)

使用循环和 isupper() 检查字符串。

4. 统计比给定数字小的元素数量

遍历列表，用 if 判断并计数。

def findSmallCount(nums: list[int], n: int) -> int:
    return sum(x < n for x in nums)

# 测试
print(findSmallCount([1, 2, 3], 2))       # 1
print(findSmallCount([1, 2, 3, 4, 5], 0)) # 0

5. 求比指定数字小的元素总和

使用条件过滤和 sum()。

def findSmallerTotal(nums: list[int], n: int) -> int:
    return sum(x for x in nums if x < n)

# 测试
print(findSmallerTotal([1, 2, 3], 3))         # 3
print(findSmallerTotal([3, 2, 5, 8, 7], 999)) # 25

6. 返回所有比给定数字小的元素列表

使用列表推导式过滤。

def findAllSmall(nums: list[int], n: int) -> list[int]:
    return [x for x in nums if x < n]

# 测试
print(findAllSmall([1, 2, 3], 10))  # [1, 2, 3]
print(findAllSmall([1, 3, 5, 4, 2], 4))  # [1, 3, 2]

7. 列表求和

使用 sum() 函数计算所有元素之和。

def summ(nums: list[int]) -> int:
    return sum(nums)

# 测试
print(summ([1, 2, 3, 4, 5]))   # 15
print(summ([]))                 # 0
print(summ([-10, -20, -30]))    # -60

二、简单练习 II

1. 打印星号图形（递增）

使用循环，每行打印一个星号，下一行增加一个。

如：

*
**
***

def stars(n: int):
    for i in range(1, n + 1):
        print('*' * i)

# 测试
stars(4)

2. 打印星号图形（递增 + 递减）

先打印递增部分，再打印递减部分。

如：

*
**
***
**
*

def stars2(n: int):
    for i in range(1, n + 1):
        print('*' * i)
    for i in range(n - 1, 0, -1):
        print('*' * i)

# 测试
stars2(4)

3. 打印 n 的乘法表

使用循环打印从 1×n 到 n×n 的结果。

def table(n: int):
    for i in range(1, 10):
        print(f"{n} x {i} = {n * i}")

# 测试
table(3)

4. 打印 1～9 的乘法表

双重循环打印标准九九乘法表。

def table9to9():
    for i in range(1, 10):
        for j in range(1, 10):
            print(f"{i} x {j} = {i * j}")

# 测试
table9to9()

5. 字母大小写互换

实现大小写切换。

def swap(s: str) -> str:
    return ''.join(ch.lower() if ch.isupper() else ch.upper() for ch in s)

# 测试
print(swap("Aloha"))      # aLOHA
print(swap("Love you."))  # lOVE YOU.

也可以使用字符串方法 .swapcase() 实现大小写切换，具体代码如下：

def swap(s: str) -> str:
    return s.swapcase()

# 测试
print(swap("Aloha"))      # aLOHA
print(swap("Love you."))  # lOVE YOU.

6. 求最小值

使用内置函数 min() 返回列表中最小元素。

def findMin(nums: list[int]):
    return min(nums) if nums else None

# 测试
print(findMin([1, 2, 5, 6, 99, 4, 5]))   # 1
print(findMin([]))                       # None
print(findMin([1, 6, 0, 33, 44, 88, -10])) # -10

三、中级练习 I

1. 手写排序（冒泡排序）

通过两层循环比较相邻元素的大小，如果前一个比后一个大则交换位置，直到所有元素有序。

def mySort(nums: list[float]) -> list[float]:
    nums = nums[:]  # 复制一份，避免修改原列表
    for i in range(len(nums)):
        for j in range(len(nums) - i - 1):
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums

# 测试
print(mySort([17, 0, -3, 2, 1, 0.5]))  # [-3, 0, 0.5, 1, 2, 17]

2. 判断质数

用循环判断一个数是否能被 2～√n 的整数整除，如果不能整除则为质数。

def isPrime(n: int) -> bool:
    return n > 1 and all(n % i for i in range(2, int(n ** 0.5) + 1))

# 测试
print(isPrime(1))       # False
print(isPrime(5))       # True
print(isPrime(91))      # False
print(isPrime(1000000)) # False

3. 判断是否为回文字符串

将字符串反转（如用 s[::-1]），若与原字符串相同则为回文。

def palindrome(s: str) -> bool:
    s = s.replace(" ", "")
    return s == s[::-1]

# 测试
print(palindrome("bearaeb"))               # True
print(palindrome("Whatever revetahW"))     # True
print(palindrome("Aloha, how are you?"))   # False

4. 打印金字塔图案

使用嵌套循环控制空格与星号数量，打印居中的金字塔形状。

def pyramid(n: int):
    for i in range(1, n + 1):
        print(' ' * (n - i) + '*' * (2 * i - 1))

# 测试
pyramid(4)

5. 倒金字塔图案

与金字塔相反，星号数量从多到少逐行减少。

def inversePyramid(n: int):
    for i in range(n, 0, -1):
        print(' ' * (n - i) + '*' * (2 * i - 1))

# 测试
inversePyramid(4)

6. 判断是否有相邻的两个 3

遍历列表，如果发现 nums[i] == 3 and nums[i+1] == 3，返回 True。

def has_33(nums: list[int]) -> bool:
    return any(nums[i] == nums[i + 1] == 3 for i in range(len(nums) - 1))

# 测试
print(has_33([1, 5, 7, 3, 3]))  # True
print(has_33([]))               # False
print(has_33([4, 3, 2, 1, 0]))  # False

7. 判断列表中是否包含 0,0,7

程序检查列表中是否按顺序出现数字 0、0、7（中间可以有其他数）。

def spyGame(nums: list[int]) -> bool:
    seq = [0, 0, 7]
    for num in nums:
        if num == seq[0]:
            seq.pop(0)
        if not seq:
            return True
    return False

# 测试
print(spyGame([1, 2, 4, 0, 3, 0, 7])) # True
print(spyGame([1, 2, 5, 0, 3, 1, 7])) # False

通过 seq 记录目标序列，每当匹配到一个目标值就删除队首元素。若 seq 被清空，说明匹配成功。

四、中级练习 II

1. 质因数分解

用最小因数不断整除 n，直到分解完毕，得到所有质因数。
最终以 "x" 连接的字符串形式输出。

def factorPrime(n: int) -> str:
    factors = []
    d = 2
    while n > 1:
        while n % d == 0:
            factors.append(d)
            n //= d
        d += 1
    return " x ".join(map(str, factors))

# 测试
print(factorPrime(120))  # 2 x 2 x 2 x 3 x 5

//= 是 地板除赋值运算符（floor division assignment operator）。
它相当于：

n = n // d

意思是：

• 用 n 除以 d，
• 取整数部分（去掉小数），
• 然后把结果再赋值给变量 n 本身。

2. 两个列表的交集

将两个列表转为集合，求交集 & 得到共同元素，再用 sorted() 排序输出。

def intersection(a: list[int], b: list[int]) -> list[int]:
    return sorted(set(a) & set(b))

# 测试
print(intersection([1, 3, 4, 6, 10], [5, 11, 4, 3, 100])) # [3, 4]

3. 列表扁平化（递归实现）

使用递归处理嵌套列表：

• 如果元素仍是列表，递归展开；
• 否则直接加入结果中。

def flatten(lst: list) -> list:
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

# 测试
print(flatten([1, [[], 2, [0, [1]], [3]], [1, 3, [3], [4, [1]], [2]]]))
# 输出 [1, 2, 0, 1, 3, 1, 3, 3, 4, 1, 2]