类和正则表达（自动更正，和代数运算）

 正则表达式介绍

 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个"规则字符串"，这个"规则字符串"用来表达对字符串的一种过滤逻辑。
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 的re 模块，提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

　　模式字符串使用特殊的语法来表示一个正则表达式：

　　字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

　　多数字母和数字前加一个反斜杠时会拥有不同的含义。

　　标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

　　反斜杠本身需要使用反斜杠转义。

　　由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。

　　

1. 面向过程

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

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

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

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

 

2. 面向对象

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

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

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

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

 

二、面向对象中的名词解析

1. 类：类就是一个模板，模板里可以包含多个函数，每个函数都能实现一些功能。

2. 对象：根据模板(类)创建的实例，通过这个实例(对象)可以执行类中的函数。

3. 属性：类中所定义的变量

4. 方法：类中所定义的函数

5. 实例化：通过类创建对象的过程

6. 总结：对象的抽象是类，类的具体化就是对象；也可以说类的实例化是对象，对象是类的实例。

三、特征

1. 封装

(1) 概念：封装是将对象运行时所需的资源封装在程序对象中。简单来说，就是将内容封装起来，以后再去调用被封装的内容。

(2) 调用封装的内容有2种方法：

——通过对象直接调用

——通过self间接调用

2. 继承

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

(2) 多继承

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

Python的类如果继承了多个类，那么其寻找方法的方式有2种

当类为经典类时会按照深度优先方式查找

当类为新式类时会按照广度优先方式查找

3. 多态

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

四、类的成员

1. 简介：类的成员包括字段、方法和属性。在所有成员中，只有字段中的普通字段保存于对象中，因此创建多少个对象在内存中就有几个普通字段；而其他成员都保存在类中，也只占用一份内存空间。

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

(1) 普通字段保存在对象中

(2) 静态字段保存在类中

3. 方法：包括普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

(1) 公有方法

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

特点：至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self。在此方法中可以访问属于类和对象的成员。

(2) 私有方法

调用：只能在属于对象的方法中通过self调用或在外部通过Python支持的特殊方式来调用。在此方法中可以访问属于类和对象的成员。

(3) 静态方法

调用：可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。

特点：无默认参数。

(4) 类方法

调用：可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。

特点：至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls。

属性：其实是普通方法的变种。
5. 类成员的修饰符：下划线

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

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

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

　　__xxx__：系统定义的特殊成员

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

 

6. 类的特殊成员

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

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

(3) 类的属性

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

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

(4) 特殊的类属性

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

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

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

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

　　类名.__dict__：类的字典属性

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

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

　　

python中以下划线开头的变量名特点：

python中以下划线开头的变量名特点：
公有属性：类内外都可以被访问

私有属性：只能被类内函数调用，以'__'开头

内置属性：系统在定义类时默认的添加，命名格式为'__X__'

例子：

1. def __init__(self):       #此类定义是构造一个函数，在程序启动时自动调用，一般作为实例化对象的初始化

2. def __inaccessible(self):    #私有方法，不能在类外部被访问;方法名以'__'开头（只有一个“_”）

3. if __name__ == '__main__':    #运行的主函数下，这个是系统在定义类时默认的添加

　　

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): #供print打印的字符串
  return str(self.x)+','+str(self.y)+','+str(self.z)
v1 = vector3(1, 2, 3)
v2 = vector3(1, 1, 2)
print (v1 + v2)
print (v1 - v2)
print (v1 * v2)
print (v1 ** v2)

运行结果：

 

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 k in range(0,len(a)):
    print(a[k],end=' ')

运行结果：