Python之面向对象和正则表达（代数运算和自动更正）

面向对象

一、概念解释

面对对象编程（OOP:object oriented programming）：是一种程序设计范型，同时也是一种程序开发的方法，实现OOP的程序希望能够在程序中包含各种独立而又相互调用的对象，没一个对象又都应该能够接受数据、数据处理并将数据传达给其他对象，因此每一个对象都可以被看做一个小型的机器，而整个程序块系统就是由这些小的机器相互协助、组合构建起来的。

面对对象分析（OOA:objecet ariented analysis):即根据抽象关键的问题域来分解系统

面对对象设计（OOD:object oriented design）：是一种提供符号设计系统的面向对象的实现过程，他用非常接近时机领域属于的方法吧系统构造成现实世界的对象。

类（class）： 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

对象(object)：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

二、三大要素

1.封装性（信息隐藏）

封装性是保证软件部件具有优良的模块性的基础。

面向对象的类是封装良好的模块，类定义将其说明（用户可见的外部接口）与实现（用户不可见的内部实现）显式地分开，其内部实现按其具体定义的作用域提供保护。

对象是封装的最基本单位。封装防止了程序相互依赖性而带来的变动影响。面向对象的封装比传统语言的封装更为清晰、更为有力。

2.继承性

继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。

在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。

在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。

在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重用性。

采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。

3.多态性（多形性）

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

多态性允许每个对象以适合自身的方式去响应共同的消息。

多态性增强了软件的灵活性和重用性。

三、类

1.类属性（python内置）

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

__doc__ :类的文档字符串

__name__: 类名

__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

2.基础功能

功能	简单调用
__init__ ( self [,args...] )：构造函数	obj = className(args)
__del__( self )：析构方法, 删除一个对象	del obj
__repr__( self )：转化为供解释器读取的形式	repr(obj)
__str__( self )：用于将值转化为适于人阅读的形式	str(obj)
__cmp__ ( self, x )：对象比较	cmp(obj, x)

3.单下划线、双下划线、头尾双下划线说明

__foo__: 定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问。

现在设计一个三维向量类，实现向量的加、减、乘、除

输入代码：

 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, obj):

         return vector3(self.x*obj.x, self.y*obj.y, self.z*obj.z)

     def __pow__(self, obj):

         return vector3(self.y*obj.z-obj.y*self.z, self.z*obj.x-self.x*obj.z, self.x*obj.y-obj.x*self.y)

     def __str__(self):

         return str(self.x)+','+str(self.y)+','+str(self.z)

 v1 = vector3(1, 2, 3)

 v2 = vector3(0, 1, 2)

 print (v1 + v2)

 print (v1 - v2)

 print (v1 * v2)

 print (v1 ** v2)

结果：

正则表达

现在我们利用正则表达式来解决一个问题吧~

编写一个程序类，用户输入一段英文，然后输出这段英文中所有长度为3个字母的单词，并且如果单词有连续重复了两次，只输出一个。输入代码如下：

 import re

 a=[]

 words=input("Input the words:")

 l=re.split('[\. ]+',words)

 i=0

 for i in l:

     if len(i)==3:

         if i not in a:

             a.append(i)

     else:

         continue

 for i in range(0,len(a)):

     print(a[i],end=' ')

结果：