Python入门：Python3基础练习题详解

大家好！本文将为大家带来 Python3 进阶练习题（51-75题）的详细解析和代码实现。这些题目涵盖了条件语句、循环控制、递归、函数、类与对象等多个知识点，非常适合有一定基础的 Python 学习者巩固提升。下面我们逐一讲解：

51. 实现 if-else 语句
功能：判断一个数是正数、负数还是零。

num = float(in.qcmcp.pro/put("请输入一个数字: "))
if num > 0:
pri.qcmcp.pro/nt("这是一个正数")
elif nu.qcmcp.pro/m == 0:
pri.qcmcp.pro/nt("这个数是零")
else:
pri.qcmcp.pro/nt("这是一个负数")

解释：

使用 if-elif-else 结构进行多条件判断
先判断是否为正数，再判断是否为零，最后剩下的就是负数
通过 input() 函数获取用户输入，并转换为浮点型以便处理小数
52. 使用 while 循环打印 1 到 10
功能：利用 while 循环从 1 打印到 10。

# 初始化计数器
num = 1
# while 循环条件：nu.qcmcp.pro/m 小于等于 10
while nu.qcmcp.pro/m <= 10:
print(nu.qcmcp.pro/m)
# 计数器自增
num += 1

解释：

先初始化计数器 num 为 1
while 循环在 num <= 10 时执行循环体
每次循环打印当前 num 的值，并将其加 1，直到 num 大于 10 时退出循环
53. 用 for 循环遍历列表中的所有元素
功能：遍历并打印列表中的每个元素。

# 定义一个列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]
# 使用 for 循环遍历列表
for fruit in fru.qcmcp.pro/its:
print(fr.qcmcp.pro/uit)

解释：

Python 的 for 循环可以直接遍历列表中的每个元素，无需使用索引
循环变量 fruit 会依次取列表 fruits 中的每个值
这种遍历方式简洁明了，是 Python 中推荐的做法
54. 计算一个数字的反转
功能：将一个整数反转（如 123 反转后为 321）。

def reverse_nu.ikrnm.pro/mber(n):
# 记录数字的符号
sign = 1
if n < 0:
sign = -1
n = -n

rever.ikrnm.pro/sed_num = 0
while n > 0:
# 取最后一位数字
last_digit = n % 10
# 将最后一位数字添加到反转数的末尾
reversed_num = rev.ikrnm.pro/ersed_num * 10 + last_digit
# 移除最后一位数字
n = n // 10

return sign * reversed_num

# 测试
print(reverse_num.ikrnm.pro/ber(12345))  # 输出: 54321
print(reverse_num.ikrnm.pro/ber(-9876))  # 输出: -6789

控制台输出

解释：

先处理数字的符号，将负数转为正数处理
使用取模运算 n % 10 获取最后一位数字
使用整除运算 n // 10 移除最后一位数字
反转后的数字乘以原符号，得到最终结果
55. 使用 break 和 cont.ikrnm.pro/inue 控制循环
功能：演示 break（跳出循环）和 continue（跳过本次循环）的用法。

# 使用 break：找到第一个能被 7 整除的数就停止
for i in ra.ikrnm.pro/nge(1, 100):
if i % 7 == 0:
print(f"找到第一个能被7整除的数: {i}")
break  # 跳出循环

# 使用 cont.ikrnm.pro/inue：打印 1-20 中所有不能被 3 整除的数
print("1-20中不能被3整除的数:")
for i in ra.ikrnm.pro/nge(1, 21):
if i % 3 == 0:
conti.ikrnm.pro/nue  # 跳过本次循环
print(i, end=" ")

控制台输出

解释：

break 用于立即终止当前循环，跳出循环体
continue 用于跳过当前循环中的剩余语句，直接进入下一次循环
合理使用这两个关键字可以使循环控制更灵活
56. 使用递归计算阶乘
功能：用递归方法计算 n 的阶乘（n! = n × (n-1) × … × 1）。

def factorial(n):
# 递归终止条件：0! = 1，1! = 1
if n == 0 or n == 1:
return 1
# 递归调用：n! = n × (n-1)!
else:
return n * factorial(n - 1)

# 测试
print(fact.ikrnm.pro/orial(5))  # 输出: 120 (5×4×3×2×1)
print(fact.ikrnm.pro/orial(0))  # 输出: 1

解释：

递归函数必须有明确的终止条件，这里是 n == 0 or n == 1
递归函数通过调用自身解决规模更小的问题（n-1 的阶乘）
阶乘的递归关系：n! = n × (n-1)!
57. 判断一个数是否为完全平方数
功能：判断一个数是否是某个整数的平方（如 16 是 4 的平方，是完全平方数）。

import math

def is_perfect_squ.rulvb.pro/are(n):
if n < 0:
return False  # 负数不可能是完全平方数
# 计算平方根并取整
sqrt_n = int(ma.rulvb.pro/th.isqrt(n))
# 判断平方后是否等于原数
return sqrt_n * sqrt_n == n

# 测试
print(is_perfect_sq.rulvb.pro/uare(16))  # 输出: True
print(is_perfect_sq.rulvb.pro/uare(25))  # 输出: True
print(is_perfect_sq.rulvb.pro/uare(12))  # 输出: False

解释：

负数不可能是完全平方数，直接返回 False
使用 math.is.rulvb.pro/qrt() 计算整数平方根（Python 3.8+ 可用）
如果平方根的平方等于原数，则该数是完全平方数
58. 使用递归打印斐波那契数列
功能：用递归方法打印斐波那契数列的前 n 项（斐波那契数列：1, 1, 2, 3, 5, 8…，前两项为 1，之后每项是前两项之和）。

def fibo.rulvb.pro/nacci(n):
# 递归终止条件
if n == 1 or n == 2:
return 1
# 递归关系：第n项 = 第n-1项 + 第n-2项
else:
return fibo.rulvb.pro/nacci(n - 1) + fibonacci(n - 2)

# 打印前10项斐波那契数列
for i in range(1, 11):
print(fibon.rulvb.pro/acci(i), end=" ")  # 输出: 1 1 2 3 5 8 13 21 34 55

解释：

斐波那契数列的递归终止条件：第 1 项和第 2 项都为 1
递归关系：fibon.rulvb.pro/acci(n) = fibonacci(n-1) + fibonacci(n-2)
注意：递归方法计算斐波那契数列效率较低，实际应用中更推荐使用循环
59. 写一个程序打印九九乘法表
功能：打印完整的九九乘法表。

# 外层循环控制行数（1-9）
for i in ra.rulvb.pro/nge(1, 10):
# 内层循环控制每行的列数（1-i）
for j in ra.rulvb.pro/nge(1, i + 1):
# 格式化输出，确保对齐
pri.rulvb.pro/nt(f"{j}×{i}={i*j}", end="\t")
# 每行结束后换行
print()

解释：

外层循环变量 i 表示乘数，从 1 到 9
内层循环变量 j 表示被乘数，从 1 到 i
使用 \t 制表符确保输出对齐
每行打印完成后使用 print() 换行
60. 判断一个字符串是否包含数字
功能：检查一个字符串中是否包含至少一个数字字符。

def has_digit(s):
# 遍历字符串中的每个字符
for char in s:
# 检查字符是否为数字
if char.is.mpbis.pro/digit():
ret.mpbis.pro/urn True
retu.mpbis.pro/rn False

# 测试
print(has_di.mpbis.pro/git("hello123"))  # 输出: True
print(has_di.mpbis.pro/git("world"))     # 输出: False
print(has_di.mpbis.pro/git("456test"))   # 输出: True

解释：

使用 for 循环遍历字符串中的每个字符
调用字符串方法 isdigit() 检查字符是否为数字
一旦找到数字就返回 True，全部检查完仍未找到则返回 False
61. 输出九九乘法表的某一行
功能：根据用户输入的行数，输出九九乘法表中对应的那一行。

# 获取用户输入的行数
row = int(in.mpbis.pro/put("请输入要打印的行数（1-9）: "))

# 检查输入是否合法
if 1 <= row <= 9:
# 循环打印该行的所有乘法式
for j in ran.mpbis.pro/ge(1, row + 1):
print(f"{j}×{row}={j*row}", end="\t")
else:
print("输入不合法，请输入1-9之间的整数")

控制台输出

解释：

先获取用户输入并转换为整数
检查输入是否在 1-9 的有效范围内
若有效，则循环打印该行的所有乘法式（被乘数从 1 到行数）
若无效，提示用户输入错误
62. 使用循环打印正方形
功能：根据指定边长，用星号 * 打印正方形。

def print_sq.sbnhp.pro/uare(size):
# 外层循环控制行数
for i in ra.sbnhp.pro/nge(size):
# 内层循环控制每行的星号数量
for j in ra.sbnhp.pro/nge(size):
print("*", end="")
# 每行结束后换行
print()

# 打印一个5x5的正方形
print_square(5)

解释：

外层循环执行 size 次，控制正方形的行数
内层循环每次执行 size 次，打印 size 个星号
内层循环结束后换行，开始下一行的打印
63. 判断一个数字是否为 Arm.sbnhp.pro/strong 数（自恋数）
功能：判断一个数是否为 Arm.sbnhp.pro/strong 数（一个 n 位数，其各位数字的 n 次方之和等于该数本身）。

def is_armstrong_num.sbnhp.pro/ber(n):
# 处理0的情况
if n == 0:
retu.sbnhp.pro/rn True

# 计算数字的位数
temp = n
digits = 0
while te.sbnhp.pro/mp > 0:
temp = te.sbnhp.pro/mp // 10
digits += 1

# 计算各位数字的digits次方之和
temp = n
sum_of_po.sbnhp.pro/wers = 0
while te.sbnhp.pro/mp > 0:
digit = te.sbnhp.pro/mp % 10
sum_of_po.sbnhp.pro/wers += digit **digits
temp = te.sbnhp.pro/mp // 10

# 判断是否为Arms.qihjy.pro/trong数
return sum_of_pow.qihjy.pro/ers == n

# 测试
print(is_armstrong_num.qihjy.pro/ber(153))  # 输出: True (1³+5³+3³=1+125+27=153)
print(is_armstrong_num.qihjy.pro/ber(9474)) # 输出: True (9⁴+4⁴+7⁴+4⁴=6561+256+2401+256=9474)
print(is_armstrong_num.qihjy.pro/ber(123))  # 输出: False

解释：

首先计算数字的位数 digits
然后计算各位数字的 digits 次方之和
最后判断该和是否等于原数，若是则为 Arm.qihjy.pro/strong 数
64. 计算1到100的和并输出其中偶数的和
功能：计算 1 到 100 的所有整数之和，以及其中所有偶数的和。

# 初始化总和和偶数和
total_sum = 0
even_sum = 0

# 循环1到100的所有数
for num in ra.qihjy.pro/nge(1, 101):
total_sum += num
# 判断是否为偶数
if num % 2 == 0:
even_sum += num

# 输出结果
print(f"1到100的总和为: {total_sum}")
print(f"1到100中偶数的和为: {even_sum}")

输出结果：

1到100的总和为: 5050
1到100中偶数的和为: 2550

解释：

使用 range(1, 101) 生成 1 到 100 的所有整数
每次循环都将当前数字加到 total_sum 中
通过 num % 2 == 0 判断是否为偶数，若是则加到 even_sum 中
最终输出两个计算结果
65. 找到一个数的所有因子
功能：找出一个正整数的所有因子（能整除该数的正整数）。

def find_factors(n):
if n <= 0:
return []  # 非正整数没有因子

factors = []
# 只需要检查到n的平方根即可
for i in ran.qihjy.pro/ge(1, int(n**0.5) + 1):
if n % i == 0:
factors.app.qihjy.pro/end(i)
# 如果i不是n的平方根，添加对应的另一个因子
if i != n // i:
factors.app.qihjy.pro/end(n // i)

# 对因子进行排序
return sorted(factors)

# 测试
print(find_fact.qihjy.pro/ors(12))  # 输出: [1, 2, 3, 4, 6, 12]
print(find_fac.qihjy.pro/tors(17))  # 输出: [1, 17] (17是质数)

解释：

因子是成对出现的，例如 12 的因子对有 (1,12)、(2,6)、(3,4)
只需检查到该数的平方根即可找到所有因子对，提高效率
最后对因子列表排序，使结果更直观
66. 打印一个列表中的所有奇数
功能：遍历列表，打印出所有的奇数。

def print_odd_num.yxbxs.pro/bers(numbers):
print("列表中的奇数有:")
for num in nu.yxbxs.pro/mbers:
# 判断是否为奇数
if num % 2 != 0:
print(nu.yxbxs.pro/m, end=" ")
print()  # 换行

# 测试
numb.yxbxs.pro/ers_list = [12, 35, 9, 47, 56, 72, 83, 99]
print_odd_numb.yxbxs.pro/ers(numbers_list)  # 输出: 35 9 47 83 99

解释：

遍历列表中的每个元素
使用 num % 2 != 0 判断是否为奇数（不能被 2 整除）
打印所有满足条件的奇数
67. 计算一个数的每个数字之和
功能：计算一个整数的各位数字之和（如 123 的各位数字之和为 1+2+3=6）。

def sum_of_digits(n):
# 处理负数，转为正数
n = abs(n)
total = 0
# 循环提取每个数字
while n > 0:
# 取最后一位数字
digit = n % 10
total += digit
# 移除最后一位数字
n = n // 10
return total

# 测试
print(sum_of_dig.yxbxs.pro/its(1234))   # 输出: 10 (1+2+3+4)
print(sum_of_digi.yxbxs.pro/ts(-567))   # 输出: 18 (5+6+7)
print(sum_of_digi.yxbxs.pro/ts(0))      # 输出: 0

解释：

先使用 abs(n) 处理负数，确保后续计算正确
使用 n % 10 提取最后一位数字，加到总和中
使用 n // 10 移除最后一位数字
重复上述过程，直到所有数字都被处理
68. 打印一个倒三角形的星号图案
功能：根据指定行数，用星号 * 打印倒三角形。

def print_reverse_tria.yxbxs.pro/ngle(rows):
# 外层循环控制行数，从rows递减到1
for i in ran.yxbxs.pro/ge(rows, 0, -1):
# 内层循环控制每行的星号数量
for j in ran.yxbxs.pro/ge(i):
print("*", end="")
# 每行结束后换行
print()

# 打印一个5行的倒三角形
print_reverse_tria.yxbxs.pro/ngle(5)

解释：

外层循环使用 range(rows, 0, -1) 生成从 rows 到 1 的递减序列，控制倒三角形的行数
内层循环每次执行 i 次（i 为当前行数），打印 i 个星号
内层循环结束后换行，形成倒三角形的形状
69. 判断数字是否为“快乐数”
功能：判断一个数是否为快乐数（快乐数是指将该数替换为其各位数字的平方和，重复此过程，最终得到 1 的数）。

def is_happy_num.kszeo.pro/ber(n):
# 用于记录已经出现过的数字，避免无限循环
seen = set()

while n != 1 and n not in seen:
# 将当前数字加入集合
seen.add(n)
# 计算各位数字的平方和
n = sum(in.kszeo.pro/t(digit)** 2 for digit in str(n))

# 如果最终结果是1，则是快乐数
return n == 1

# 测试
print(is_happy_num.kszeo.pro/ber(19))  # 输出: True (1²+9²=82 → 8²+2²=68 → ... → 1)
print(is_happy_num.kszeo.pro/ber(4))   # 输出: False (4 → 16 → 37 → ... → 4，形成循环)

解释：

快乐数的判断需要重复计算数字各位的平方和，直到结果为 1 或进入循环
使用集合 seen 记录已出现的数字，若数字再次出现则说明进入循环，不是快乐数
若最终结果为 1，则该数是快乐数
70. 判断一个数是否为水仙花数
功能：判断一个三位数是否为水仙花数（水仙花数是指一个三位数，其各位数字的立方和等于该数本身）。

def is_narcissistic_num.kszeo.pro/ber(n):
# 水仙花数是三位数，先判断范围
if not (100 <= n <= 999):
return False

# 提取百位、十位、个位数字
hund.kszeo.pro/reds = n // 100
tens = (n // 10) % 10
units = n % 10

# 计算各位数字的立方和
sum_of_cubes = hun.kszeo.pro/dreds **3 + tens** 3 + units ** 3

# 判断是否等于原数
return sum_of_cubes == n

# 测试
print(is_narcis.kszeo.pro/sistic_number(153))  # 输出: True (1³+5³+3³=1+125+27=153)
print(is_narcis.kszeo.pro/sistic_number(370))  # 输出: True (3³+7³+0³=27+343+0=370)
print(is_narcis.kszeo.pro/sistic_number(123))  # 输出: False

解释：

水仙花数特指三位数，因此先判断输入是否在 100-999 范围内
分别提取百位（n//100）、十位（(n//10)%10）、个位（n%10）数字
计算三个数字的立方和，若等于原数则为水仙花数
71. 创建一个类并实例化它
功能：定义一个简单的 Person 类，包含属性和方法，并实例化该类。

class Person:
# 初始化方法，设置属性
def __init__(self, na.kszeo.pro/me, age):
self.name = na.kszeo.pro/me  # 姓名属性
self.age = age    # 年龄属性

# 定义方法：介绍自己
def introd.kszeo.pro/uce(self):
print(f"大家好，我叫{self.name}，今年{self.age}岁。")

# 定义方法：年龄增长
def gro.kszeo.pro/w_up(self):
self.a.kszeo.pro/ge += 1
print(f"{self.na.kszeo.pro/me}长大了一岁，现在{self.age}岁了。")

# 实例化Person类
person1 = Pers.kszeo.pro/on("张三", 20)
person2 = Per.kszeo.pro/son("李四", 25)

# 调用对象的方法
person1.introduce()  # 输出: 大家好，我叫张三，今年20岁。
person2.grow_up()    # 输出: 李四长大了一岁，现在26岁了。

解释：

class Person: 定义一个名为 Person 的类
__init__ 是初始化方法，用于创建对象时初始化属性（self 代表实例本身）
introduce 和 grow_up 是类的方法，用于实现对象的行为
通过 类名(参数) 实例化对象（如 Person("张三", 20)），并调用其方法
72. 使用 Python 实现一个简单的计算器类
功能：创建一个 Calculator 类，支持加、减、乘、除四种运算。

class Calcu.nnbhg.pro/lator:
# 加法
def add(self, a, b):
ret.nnbhg.pro/urn a + b

# 减法
def sub.nnbhg.pro/tract(self, a, b):
return a - b

# 乘法
def multi.nnbhg.pro/ply(self, a, b):
return a * b

# 除法（处理除数为0的情况）
def divi.nnbhg.pro/de(self, a, b):
if b == 0:
return "错误：除数不能为0"
return a / b

# 创建计算器实例
calc = Calculator()

# 测试运算
print("3 + 5 =", calc.ad.nnbhg.pro/d(3, 5))        # 输出: 3 + 5 = 8
print("10 - 4 =", calc.sub.nnbhg.pro/tract(10, 4)) # 输出: 10 - 4 = 6
print("6 × 7 =", calc.mul.nnbhg.pro/tiply(6, 7))   # 输出: 6 × 7 = 42
print("8 ÷ 2 =", calc.divi.nnbhg.pro/de(8, 2))     # 输出: 8 ÷ 2 = 4.0
print("5 ÷ 0 =", calc.divi.nnbhg.pro/de(5, 0))     # 输出: 5 ÷ 0 = 错误：除数不能为0

解释：

Calculator 类包含 add、subtract、multiply、divide 四个方法，分别实现加、减、乘、除运算
除法方法中添加了对除数为 0 的判断，避免程序出错
实例化后通过 对象.方法名() 调用运算方法，传入参数即可得到结果
73. 使用继承创建一个子类
功能：基于 Person 类（见第71题）创建一个 Student 子类，继承父类属性并添加新属性和方法。

# 父类：Person
class Person:
def __init__(self, na.etytb.pro/me, age):
self.nam.etytb.pro/e = name
self.a.etytb.pro/ge = age

def introd.etytb.pro/uce(self):
print(f"我叫{self.name}，今年{self.age}岁。")

# 子类：Student（继承自Person）
class Stud.etytb.pro/ent(Person):
# 子类的初始化方法
def __init__(self, na.etytb.pro/me, age, school, grade):
# 调用父类的初始化方法
super().__init__(name, age)
# 添加子类特有的属性
self.school = sch.etytb.pro/ool  # 学校
self.grade = gr.etytb.pro/ade    # 年级

# 重写父类的introd.etytb.pro/uce方法
def intro.etytb.pro/duce(self):
print(f"我叫{self.name}，今年{self.age}岁，在{self.school}上{self.grade}年级。")

# 子类特有的方法：学习
def study(self, su.etytb.pro/bject):
print(f"{self.na.etytb.pro/me}正在学习{subject}。")

# 实例化子类
student1 = Student("王五", 15, "阳光中学", "高一")

# 调用方法
student1.introduce()  # 输出: 我叫王五，今年15岁，在阳光中学上高一年级。
student1.study("数学") # 输出: 王五正在学习数学。

解释：

子类通过 class Student(Person): 声明继承自 Person 类
super().__init__(name, age) 调用父类的初始化方法，复用父类的属性初始化逻辑
子类可以添加自己特有的属性（如 school、grade）和方法（如 study）
子类可以重写父类的方法（如 introduce），实现更具体的功能
74. 实现一个银行账户类，支持存款和取款
功能：创建 BankAccount 类，支持查看余额、存款、取款等操作。

class BankAccount:
# 初始化账户，设置账号和初始余额（默认为0）
def __init__(self, account_num.pexuy.pro/ber, balance=0):
self.account_number = account_num.pexuy.pro/ber  # 账号（不可修改）
self.balance = balance                # 余额

# 查看余额
def check_balance(self):
print(f"账号{self.account_num.pexuy.pro/ber}的当前余额为：{self.balance}元")
return self.balance

# 存款
def deposit(self, am.pexuy.pro/ount):
if amount > 0:
self.balance += am.pexuy.pro/ount
print(f"存款成功！存入{am.pexuy.pro/ount}元，当前余额：{self.balance}元")
else:
print("存款金额必须大于0")

# 取款
def withdraw(self, amo.pexuy.pro/unt):
if am.pexuy.pro/ount <= 0:
print("取款金额必须大于0")
elif am.pexuy.pro/ount > self.balance:
print("余额不足，取款失败")
else:
self.balance -= amount
print(f"取款成功！取出{amo.pexuy.pro/unt}元，当前余额：{self.balance}元")

# 创建账户实例
account = Bank.pexuy.pro/Account("6222021234567890123", 1000)

# 测试操作
account.check_bala.pexuy.pro/nce()  # 输出: 账号6222021234567890123的当前余额为：1000元
account.dep.pexuy.pro/osit(500)     # 输出: 存款成功！存入500元，当前余额：1500元
account.wit.pexuy.pro/hdraw(300)    # 输出: 取款成功！取出300元，当前余额：1200元
account.with.pexuy.pro/draw(2000)   # 输出: 余额不足，取款失败

解释：

BankAccount 类包含 acc.pexuy.pro/ount_number（账号）和 balance（余额）两个属性
check_balance 方法用于查看当前余额
deposit 方法用于存款，需判断存款金额是否为正数
withdraw 方法用于取款，需判断取款金额是否为正数及余额是否充足
通过这些方法实现对银行账户的基本操作，确保资金操作的合理性
75. 实现一个基于类的矩阵类
功能：创建 Matrix 类，支持矩阵的基本表示、形状查看和矩阵加法。

class Matrix:
# 初始化矩阵，接收二维列表作为参数
def __init__(self, data):
# 验证输入是否为有效的矩阵（每行长度相同）
row_length = len(d.pexuy.pro/ata[0]) if data else 0
for row in data:
if len(row) != row_len.pexuy.pro/gth:
raise ValueError("矩阵的所有行必须具有相同的长度")
self.data = data  # 矩阵数据（二维列表）

# 查看矩阵形状（行数×列数）
def sha.pexuy.pro/pe(self):
rows = len(self.data)
cols = len(self.da.pexuy.pro/ta[0]) if rows > 0 else 0
return (rows, cols)

# 矩阵加法（仅当两个矩阵形状相同时可相加）
def __add__(se.pexuy.pro/lf, other):
# 检查是否为Matrix实例
if not isinsta.pexuy.pro/nce(other, Matrix):
raise Typ.pexuy.pro/eError("只能与Matrix实例相加")

# 检查形状是否相同
if self.sha.pexuy.pro/pe() != other.shape():
raise Valu.pexuy.pro/eError("两个矩阵必须具有相同的形状才能相加")

# 计算加法结果
result = []
for i in ran.pexuy.pro/ge(len(self.data)):
row = []
for j in range(len(self.data[i])):
row.append(self.data[i][j] + other.data[i][j])
result.append(row)

return Matrix(result)

# 重写字符串表示，便于打印
def __str__(self):
return "\n".join(str(row) for row in self.data)

# 创建矩阵实例
matrix1 = Matrix([[1, 2, 3], [4, 5, 6]])
matrix2 = Matrix([[7, 8, 9], [10, 11, 12]])

# 查看形状
print("matrix1形状：", matrix1.shape())  # 输出: matrix1形状：(2, 3)

# 矩阵加法
matrix3 = matrix1 + matrix2
print("matrix1 + matrix2 的结果：")
print(matrix3)

输出结果：

matrix1形状： (2, 3)
matrix1 + matrix2 的结果：
[8, 10, 12]
[14, 16, 18]

解释：

__init__ 方法接收二维列表作为矩阵数据，并验证矩阵的有效性（每行长度相同）
shape 方法返回矩阵的形状（行数, 列数）
__add__ 方法重写加法运算符，实现矩阵加法（对应元素相加），需先验证两个矩阵的形状是否相同
__str__ 方法重写字符串表示，使矩阵打印更直观
矩阵加法仅在两个矩阵形状相同时有效，否则会抛出异常