正则表达和类的学习

类和正则表达

类的三个基本特征：封装，继承，多态；

封装

 封装就是事物抽象为类，把对外接口暴露，将实现和内部数据隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

实现继承是指使用基类的属性和方法而无需额外编码的能力；

接口继承是指仅使用属性和方法的名称，但是子类必须提供实现的能力；

可视继承是指子类使用基类的外观和实现代码的能力。

多态性

是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关。

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

"单下划线"

 "单下划线" 开始的成员变量叫做保护变量，意思是只有类对象和自类对象自己能访问到这些变量。

例子：以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入。

"双下划线"

"双下划线" 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。

 例子：以双下划线开头的（__foo）代表类的私有成员；以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如 __init__（）代表类的构造函数。

 一个三维向量类

class Vecter3:
    def __init__(self, x=0, y=0, z=0):
        self.X = x
        self.Y = y
        self.Z = z
    def __add__(self, n):
        r = Vecter3()
        r.X = self.X + n.X
        r.Y = self.Y + n.Y
        r.Z = self.Z + n.Z
        return r
    def __sub__(self, n):
        r = Vecter3()
        r.X = self.X - n.X
        r.Y = self.Y - n.Y
        r.Z = self.Z - n.Z
        return r
    def __mul__(self, n):
        r = Vecter3()
        r.X = self.X * n
        r.Y = self.Y * n
        r.Z = self.Z * n
        return r
    def __truediv__(self, n):
        r = Vecter3()
        r.X = self.X / n
        r.Y = self.Y / n
        r.Z = self.Z / n
        return r
    def __floordiv__(self, n):
        r = Vecter3()
        r.X = self.X // n
        r.Y = self.Y // n
        r.Z = self.Z // n
        return r
    def show(self):
        print((self.X,self.Y,self.Z))
        v1 = Vecter3(1,2,3)
        v2 = Vecter3(4,5,6)
        v3 = v1+v2v3.show()
        v4 = v1-v2v4.show()
        v5 = v1*3
        v5.show()
        v6 = v1/2
        v6.show()