python 矩阵运算以及内置函数构建
本次实验，我把程序分成三个来实现实验要求的功能。
程序 1 （矩阵相关）：
class Matrix:
rows = 0
cols = 0
matrix = []
def __init__(self, r, c):
self.rows = r
self.cols = c
for row in range(0, rows):
row_str = input("请输入第" + (row + 1).__str__() + "行的元素（" + cols.__str__() + "个），以英文逗号分割：")
str_list = row_str.split(",")
if str_list.__len__() != cols:
raise RuntimeError("请输入" + cols.__str__() + "个元素！")
inline_list = []
for item in row_str.split(","):
inline_list.append(int(item))
self.matrix.append(inline_list)
def print(self):
"""
重写print
"""
print(self.matrix)
def to_array(self):
"""
把矩阵输出数组
:return:
"""
nlist = []
for inline_list in self.matrix:
for item in inline_list:
nlist.append(item)
return nlist
def find_max_row(self):
"""
找出矩阵每一行中最大的元素，以列表形式输出。
"""
nlist = []
for inline_list in self.matrix:
nlist.append(max(inline_list))
return nlist
def find_min_col(self):
"""
找出矩阵中每一列最小的元素，以列表形式输出。
"""
nlist = []
clist = []
for c_index in range(0, self.cols):
# 把列取出
for inline_list in self.matrix:
clist.append(inline_list[c_index])
# 取最小元素
nlist.append(min(clist))
clist = []
return nlist
def is_prime(x):
"""
判断输入的整数是否是素数
:param x: 判断数
:return: 是否为素数
"""
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
return False
return True
if __name__ == '__main__':
rows = int(input("请输入行数："))
cols = int(input("请输入列数："))
my_matrix = Matrix(rows, cols)
my_matrix.print()
list = []
for item in set(my_matrix.to_array()):
if is_prime(item):
list.append(item)
print("二维矩阵转列表，去除重复元素再取素数结果为：", list)
print("遍历矩阵，找出矩阵每一行中最大的元素，以列表形式输出：", my_matrix.find_max_row())
print("遍历矩阵，找出矩阵中每一列最小的元素，以列表形式输出：", my_matrix.find_min_col())实现功能为：
- 从键盘输入数，创建一个二维矩阵(矩阵行数列数自己定义)。
- 将二维矩阵转换成列表打印，去除列表中的重复元素，筛选出列表中的素数，并以列表形式输出；
- 遍历矩阵，找出矩阵每一行中最大的元素，以列表形式输出。
- 遍历矩阵，找出矩阵中每一列最小的元素，以列表形式输出。
输出结果：
矩阵的创建，我用了面向对象的特性，矩阵有三个成员变量，行数，列数，矩阵值。这个对象的方法有：打印矩阵，矩阵转列表，找出矩阵每一行中最大的元素，找出矩阵中每一列最小的元素等方法，主要调用细节在 main 函数里，使用者不需要关心 Matrix 类的方法如何实现，体现了面向对象中封装的特性。
程序 2（内置函数相关）：
def my_sum(iterable, start=0):
"""
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为 0。
:rtype: 返回计算结果。
"""
count = 0
for p in iterable:
count += p
return count + start
class Mylist(list):
def sort(self, *args, **kwargs):
# sort作用于list
reverse = False
if 'reverse' in kwargs:
reverse = kwargs['reverse']
# sort直接修改list，不更新结果地址
bubble_sort(self, reverse)
def bubble_sort(iterable, reverse):
"""
冒泡排序
:param iterable:可迭代对象
:param reverse: True为降序,False为升序
"""
max = len(iterable)
for i in range(0, max):
j = 1
while j < max - i:
if ((iterable[j - 1] > iterable[j]) and (reverse is False)) or (
(iterable[j - 1] < iterable[j]) and (reverse is True)):
iterable[j - 1], iterable[j] = iterable[j], iterable[j - 1]
j += 1
i += 1
def sorted(obj: list, reverse=False):
# 以列表为例，实际上内置函数sorted可以作用于所有可迭代对象
bubble_sort(obj, reverse)
# sorted有返回值，返回新的迭代结果
new_obj = []
for item in obj:
new_obj.append(item)
return new_obj
def is_odd(n):
"""
判断是否为偶数
"""
return n % 2 == 1
def my_filter(func, my_list):
"""
用func过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
"""
if func is None:
func = bool
for item in my_list:
if func(item):
yield item
def my_map(func, *seqs):
"""
将func函数的作用用于每个可迭代元素上
"""
for args in zip(*seqs):
yield func(*args)
def add(*args):
return sum(args)
if __name__ == '__main__':
p_list = [2, 1, 4, 6, 2, 3, 5]
print("p_list：", p_list)
print("\n--------------------sum函数--------------------")
print("sum(p_list, 2)：", my_sum(p_list, 2))
print("sum(p_list)：", my_sum(p_list))
print("\n--------------------sort排序--------------------")
# 派生子类Mylist，重写sort方法，无返回值，对列表进行降序排序
my_list = Mylist(p_list)
print("sort排序前 my_list 的地址：", id(my_list))
my_list.sort(reverse=True)
print("sort排序后 my_list 的地址：", id(my_list))
print("sort排序后：", my_list)
print("\n--------------------sorted排序--------------------")
print("sorted排序前 p_list 的地址：", id(p_list))
p_list = sorted(p_list)
print("sorted排序后 p_list 的地址：", id(p_list))
print("sorted排序后：", p_list)
print("\n--------------------filter函数--------------------")
# 验证filter，过滤出列表中是奇数的元素
filter_generator = my_filter(is_odd, my_list)
print("filter返回的是一个生成器：", filter_generator)
new_list = list(filter_generator)
print("filter函数执行结果：", new_list)
print("\n--------------------map函数--------------------")
# 验证map，该段代码作用是将 参数2 的列表对应元素和 参数3 列表对应元素相加
map_generator = my_map(add, [1, 2, 3], range(4, 7))
print("map返回的是一个生成器：", map_generator)
new_list_2 = list(map_generator)
print("map函数执行结果：", new_list_2)运行结果：
函数实现了以下功能：
- 编写函数，模拟内置函数 sum(),并对其调用来测试正确性。
sum() 方法对序列进行求和计算。
其中，第一个参数接受可迭代对象，第二个参数接受数字用于和结果相加。 - 编写函数，模拟内置函数 sort()，sorted(),并通过调用函数来验证。
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作，返回的是对已经存在的列表进行操作，无返回值。
实现 sort 函数的时候，我写了用 Mylist 继承 list，重写了 list 的 sort 方法，用冒泡排序的方式模拟 sort 对类本身的操作。
sorted 方法和 sort 方法类似，但它返回的是一个新的 list，而不是在原来的基础上进行的操作。 - 编写函数，模拟内置函数 filter()，并通过调用来验证。
filter 函数接受两个参数 func、iter（可迭代对象，这里用 my_list 代替），用 func 过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的生成器，可以用 list()转列表。
用 filter 过滤列表中的奇数：
源列表：
- 编写函数，模拟内置函数 map()，并通过调用函数来验证其正确性。
filter 函数接受一个函数，多个可迭代对象 func、iter（可迭代对象），将 func 函数的作用用于每个可迭代元素上。
map 函数执行结果： [5, 7, 9]
可以看到，符合将 参数 2 的列表对应元素和 参数 3 列表对应元素相加的作用，1+4 =5，2+5=7，3+6=9
程序 3（字符串匹配）
import re
# 正则 匹配大小写字母长度为3的字符
pattern1 = re.compile(r'\b[a-zA-Z]{3}\b')
# 正则 匹配长度为1字符为i
pattern2 = re.compile(r'\bi{1}\b')
def find_word_by_length3(string):
# 返回单词列表
return pattern1.findall(string)
def replace_i(string):
# 替换词I
return pattern2.sub('I', string)
if __name__ == '__main__':
string = input('请输入一段英文：')
word_list = find_word_by_length3(string)
print(word_list)
replace_string = "i am a teacher,i am man, and i am 38 years old.I am not a businessman."
print(replace_i(replace_string))- 编写程序，用户输入一段英文，然后输出这段英文中所有长度为 3 个字母的单词。
用正则匹配，匹配大小写字母长度为 3 的字符，findall 返回所有匹配到的字符串作为链表输出。 - 假设有一段英文(‘i am a teacher,i am man, and i am 38 years old.I am not a businessman.’)，其中有单独的字母 I 误写为 i，请编写程序进行纠正。提示，修改后的句子为：‘I am a teacher,I am man, and I am 38 years old.I am not a businessman.’
用正则匹配，匹配长度为 1 字符为 i，sub 用于替换字符串中的匹配项。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
