面向对象学习（python）

面向对象总结

一、面向对象与面向过程的区别

面向过程：根据业务逻辑从上到下写垒代码

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

1.面向过程编程：

概念：发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

2.面向对象编程：

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

二、面向对象的三要素：（封装，继承，多态）

1.封装

概念：就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

（1）直接调用

 class Foo:
     def __init__(self,name,age):
         self.name=name
         self.age=age
 obj1=Foo('liang',18)
 print(obj1.name,end='  ')#直接调用obj1对象的name属性
 print(obj1.age)#直接调用obj1对象的age属性
 obj2=Foo('li',73)
 print(obj2.name,end='  ')
 print(obj2.age)

结果如图所示：

（2）通过self间接调用被封装的内容

 class Foo:
     def __init__(self,name,age):
         self.name=name
         self.age=age
     def detail(self):
         print(self.name)#直接调用对象的name属性
         print(self.age)
 obj1=Foo('liang',18)#将obj1中的数据传给self参数
 obj1.detail()
 obj2=Foo('li',73)
 obj2.detail()

结果如图所示

2.继承

将多个类共有方法提取到父类，子类仅需继承父类而不必一一实现每个方法

注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

（1）当类是经典类时，多继承情况下，会按照深度优先方式查找

（2）当类是新式类时，多继承情况下，会按照广度优先方式查找

（3）当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类

 class Family(object):   #定义Family父类
     def talk(self):       #定义父类的方法
         print("Family can talk.")
 class Son1(Family):  #定义Fanily父类的一个子类，同时是Son1类的父类
     def talkC(self):
         print("Son1 can talk Mandarin.")
 class Son2(Son1):  #类似上
     def people(self):
         print("Son2 are clever and diligent.")
 class sson3(Family):   #定义Family父类的一个子类
     def talkA(self):
         print("sson3 can talk English.")

 S = Son2() #定义父类的子类的子类
 ss = sson3()   #定义父类的子类
 S.talk()         #调用继承Person类的方法
 ss.talkA()        #调用本身的方法
 S.people()       #调用本身的方法

结果如图所示

3.多态

概念：多态指同一个实体同时具有多种形式，在赋值之后，不同的子类对象调用相同的父类方法，产生的执行结果不同。

 import abc
 class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
     @abc.abstractmethod#修饰器，声明类方法
     def talk(self):
         pass
 class People(Animal): #动物的形态之一:人
     def talk(self):
         print('say hello')
 class Dog(Animal):    #动物的形态之二:狗
     def talk(self):
         print('say wangwang')
 class Pig(Animal):    #动物的形态之三:猪
     def talk(self):
         print('say aoao')
 peo = People() #创建People类的对象peo
 dog = Dog()    #创建Dog类的对象dog
 pig = Pig()    #创建Pig类的对象pig
 peo.talk()     #分别使用各种的方法
 dog.talk()
 pig.talk()

结果如图所示

三、面向对象（类的成员）

类的成员可以分为三大类：字段、方法和属性类

注：所有成员中，只有普通字段的内容保存对象中 ，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

1.字段

（1）字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同。

（2）普通字段属于对象，静态字段属于类

2.方法

方法包括：公有方法，私有方法、静态方法和类方法，四种方法在内存中都归属于类，区别在于调用方式不同。

（1）公有方法通过对象名直接调用，如果通过类名来调用属于对象的公有方法，需要显式为该方法的self参数传递一个对象名，用来明确指定访问哪个对象的数据成员。

（2）私有方法不能通过对象名直接调用，只能在属于对象的方法中通过self调用或在外部通过Python支持的特殊方式来调用。

（3）类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

（4）静态方法：由类调用；无默认参数；

 class Root:

     __total = 0

     def __init__(self, v):    #构造方法

         self.__value = v

         Root.__total += 1

     def show(self):           #普通实例方法
         print('self.__value:', self.__value)

         print('Root.__total:', Root.__total)

     @classmethod              #修饰器，声明类方法

     def classShowTotal(cls):  #类方法

         print(cls.__total)

     @staticmethod             #修饰器，声明静态方法

     def staticShowTotal():    #静态方法

         print(Root.__total)

 r = Root(3)
 r.classShowTotal()#通过对象来调用类方法
 r.staticShowTotal()#通过对象来调用静态方法
 r.show()
 rr = Root(5)
 Root.classShowTotal()           #通过类名调用类方法

 Root.staticShowTotal()          #通过类名调用静态方法

结果显示如下

3.属性：普通方法的变种

4. 类成员的修饰符：下划线

　　xxx ：公有成员，在任何地方都能访问

　　__xxx  or  ...__xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。

　　_xxx：受保护成员，不能用'from module import *'导入

　　__xxx__：系统定义的特殊成员

注：Python中不存在严格意义上的私有成员

5. 类的特殊成员

(1) __init__：构造方法，通过类创建对象时，自动触发执行。

(2) __del__：析构方法，当对象在内存中被释放时，自动触发执行，此方法一般无需定义。

(3) 类的属性

　　dir(类名)：查出的是一个名字列表

　　类名.__dict__：查出的是一个字典，key为属性名，value为属性值

(4) 特殊的类属性

　　类名.__name__：类的名字(字符串)

　　类名.__doc__：类的文档字符串

　　类名.__base__：类的第一个父类(在讲继承时会讲)

　　类名.__bases__：类所有父类构成的元组(在讲继承时会讲)

　　类名.__dict__：类的字典属性

　　类名.__module__：类定义所在的模块

　　类名.__class__：实例对应的类(仅新式类中)

四、面向对象思想实现基本操作

1. 三维向量类（实现向量的加减法、向量与标量的乘除法。）

 class sanwei:
     def __init__(self,x= 0,y= 0,z= 0): #构造函数
         self.x =x
         self.y =y
         self.z =z

     def __add__(self, obj):      #将两个向量相加
         return sanwei(self.x+obj.x, self.y+obj.y, self.z+obj.z)

     def __sub__(self, obj):      #将两个向量相减
         return sanwei(self.x-obj.x, self.y-obj.y, self.z-obj.z)

     def __mul__(self,n):         #将向量与常数相乘
         return sanwei(self.x*n, self.y*n, self.z*n)

     def __truediv__(self, obj):  #将向量与常数相除
         return sanwei(self.x/n, self.y/n, self.z/n)

     def __str__(self):#返回值的形式（三维向量）
         return '('+str(self.x)+','+str(self.y)+','+str(self.z)+')'

 if __name__ == "__main__":
     n = int(input("请输入一个标量(常数）："))
     a,b,c = map(int,input("请输入第一个向量：").split())
     XL1 = sanwei(a,b,c)
     a,b,c = map(int,input("请输入第二个向量：").split())
     XL2 = sanwei(a,b,c)
     print("两向量的加法：",XL1 + XL2)
     print("两向量的减法：",XL1 - XL2)
     print("标量与向量的乘法：",XL1 * n)
     print("标量与向量的除法：",XL1 / n)

结果如图所示：

（2）英语字符串处理（用户输入一段英文，然后输出这段英文中所有长度为3个字母的单词，如果单词有重复，只输出1个）

 import re
 class zfcl:
     a = []
     def __init__(self, words, length = 3):
         self.words = words
         self.length = length

     def process(self):
         word_list = re.split('[\. ]+',self.words)
         for _ in word_list:
             if len(_) == self.length:
                 if _ not in self.a:
                     self.a.append(_)
             else:
                 continue
         self.printf()

     def printf(self):
         print("处理后的字符串为：", end = '')
         for _ in range(len(self.a)):
             print(self.a[_],end=' ')

 if __name__ == "__main__":
     words = input("请输入字符串：")
     process = zfcl(words, 3)
     process.process()

结果如图所示：