面向对象

1. 基本概念

1. 面向过程

(1) 概念：以过程为中心的编程思想，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

(2) 优点：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。因为程序的流程很清楚，按着模块与函数的方法可以很好的组织。

(3) 缺点：只能用来解决一个问题，代码牵一发而动全身。

(4) 应用：用于基本很少改变的场景，著名的例子有Linux内核、git、以及Apache HTTP Server等。

2. 面向对象

(1) 概念：程序设计的核心是对象，面向对象的方法主要是把事物给对象化，对象包括属性与方法。

(2) 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。

(3) 缺点：可控性差，无法像面向过程的程序设计一样可以精准的预测问题的处理流程与结果。

(4) 应用：需求经常变化的软件，一般需求的变化都集中在用户层，如互联网应用、企业内部软件以及游戏等。

2，面向对象的三大特性

1. 封装

   封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

   所以，在使用面向对象的封装特性时，需要：

   将内容封装到某处

   从某处调用被封装的内容

       2.继承

       (1) 概念：继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。

      (2) 多继承

• 注：Python的类可以继承多个类，而Java和C#中则只能继承一个类

       3.多态

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

 举例：

 1 # -*- encoding:utf-8 -*-
 2 ''' 实例说明——面向对象的特征：多态 '''
 3 import abc
 4 
 5 class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
 6 
 7     @abc.abstractmethod
 8     def talk(self):
 9         pass
10 
11 class People(Animal): #动物的形态之一:人
12     def talk(self):
13         print('say hello')
14 
15 class Dog(Animal):    #动物的形态之二:狗
16     def talk(self):
17         print('say wangwang')
18 
19 class Pig(Animal):    #动物的形态之三:猪
20     def talk(self):
21         print('say aoao')
22 
23 
24 peo = People() #创建People类的对象peo
25 dog = Dog()    #创建Dog类的对象dog
26 pig = Pig()    #创建Pig类的对象pig
27 peo.talk()     #分别使用各种的方法
28 dog.talk()
29 pig.talk()

4.对于三维向量的计算

(1) 简述：实现向量的加减法、向量与标量的乘除法。

(2) 代码实现：

#  --coding: gb2312--
''' 三维向量 '''

class vector3:
    def __init__(self, x_ = 0, y_ = 0, z_ = 0): #构造函数
        self.x = x_
        self.y = y_
        self.z = z_

    def __add__(self, obj):      #重载+作为加号
        return vector3(self.x+obj.x, self.y+obj.y, self.z+obj.z)

    def __sub__(self, obj):      #重载-作为减号
        return vector3(self.x-obj.x, self.y-obj.y, self.z-obj.z)

    def __mul__(self,n):         #重载*作为点乘
        return vector3(self.x*n, self.y*n, self.z*n)

    def __truediv__(self, obj):  #重载/作为除法
        return vector3(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())
    v1 = vector3(a,b,c)
    a,b,c = map(int,input("请输入第二个向量：").split())
    v2 = vector3(a,b,c)
    print("两向量的加法：",v1 + v2)
    print("两向量的减法：",v1 - v2)
    print("标量与向量的乘法：",v1 * n)
    print("标量与向量的除法：",v1 / n)

 5.对于英文字符的运算

(1) 简述：用户输入一段英文，得到这段英文中所以长度为3的单词，并去除重复的单词。

 (2) 代码实现：

 1 # -*- encoding:utf-8 -*-
 2 ''' 将一段英文中长度为3的单词输出，并去掉重复的单词 '''
 3 import jieba
 4 class proString:
 5     Str = ""
 6     Dict = {}
 7     Ls = []
 8     def __init__(self,string,length = 3): #初始化
 9         self.string = string
10         self.length = length
11         
12     def SignalWord(self):        #去除重复的单词
13         self.words = jieba.lcut(self.string)   #jieba分词
14         for _ in self.words:                   #与词频算法相似
15             self.Dict[_] = self.Dict.get(_,0) + 1
16         del(self.Dict[' '])                 #删除空格项
17         self.Ls = list(self.Dict.keys())    #字典类型转化成列表类型
18 
19     def StubbenWord(self):       #利用去除重复的单词，得到固定长度的单词
20         for _ in self.Ls:
21             if len(_) == self.length:
22                 self.Str += _ + ' '
23         return self.Str
24             
25 if __name__ == "__main__":
26     str1 = input("请输入字符串：")
27     Po = proString(str1,3)
28     Po.SignalWord()
29     print("处理后的字符串为：" + Po.StubbenWord())