面向对象，面向过程。写一个实现matrix里元素相加的类。

class Matrix(object):
    def __init__(self, data, m, n):  #  定义对象属性 data为矩阵。m行，n列
        self.data = data
        self.m = m
        self.n = n
	# +
    def __add__(self, other):   # 定义对象技能
        res = Matrix([0]*self.m*self.n, self.m, self.n)
        if self.m != other.m or self.n != other.n:
            raise Exception('输入的两个矩阵行列不相等!')  # 异常抛出
        for i in range(self.m):
            for j in range(self.n):
                res.data[i*self.n+j] = self.data[i*self.n+j]+other.data[i*self.n+j]  # 一维到二维的转化
        return res
	# -
    def __sub__(self, other):
        pass
	# *
    def __mul__(self, other):
        pass
	# /
    def __divmod__(self, other):
        pass
	
	# 打印输出
    def __str__(self):
        s = ''
        for i in range(self.m):
            s += ' '.join([str(self.data[i*self.n+j]) for j in range(self.n)])
            s += '\n'
        return s

# 主函数 面向过程。
def main():
    m1 = Matrix([1, 2, 1, 2], 2, 2)  # 实例化对象 2行2列
    m2 = Matrix([2, 1, 2, 1], 1, 4)  # 实例化对象 1行4列
    print(m1 + m2)

if __name__ == '__main__':
    main()

# [[1,2,3],[4,5,6],[7,8,9]]

这个是面试欢聚时代的让写的。

这种双下划线的函数表示对象。
_ init _
_ add _
_ str _

相当于我们写类是写一个对象。
调用函数的时候是面向过程。

这里直接总结下面向对象，面向过程。

面向对象和面向过程

面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么

基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式
优点：复杂的过程流程化
缺点：扩展性差

面向对象：核心是对象二字，对象指特征与技能的结合体

基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式
优点：可扩展性强
缺点：编程复杂度高，极容易出现过度设计的问题

类

对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体
在现实生活中：一定是先有一个个具体的对象，后总结出类
在程序中：一定是先定义类，后产生对象

1.封装是面向对象的一大特点
2.面向对象编程的第一步–将属性和方法封装到一个抽象的类当中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部