python 面向对象学习

面向对象

1、面向对象一些基本的定义

• 类（class）：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

接下来用一个例子来说明这些定义：

class Student:              #定义一个名为 Student 的类
    age=20                   #定义 Student 类的属性,公有变量
    __name=''                #私有变量
    def a(self):             #定义 Student 类的方法,self 代表类的实例
        return self.age
class Student1(Student):     #类的继承
    def show(self):
        print(self.age+1)
p=Student1()                #创建了一个类的实例
print(p.a())
p.show()

结果为：

 类还有一些专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

类的三个要素：封装、继承、多态 。

封装 ：根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中。

继承 ：实现代码的重用，相同的代码不需要重复的编写。

多态 ：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度。

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

1、单下划线"_"：

在Python中，通过单下划线"“来实现模块级别的私有化，变量除外。一般约定以单下划线”"开头的函数为模块私有的，也就是说"from moduleName import * “将不会引入以单下划线”_"开头的函数。

2、双下划线"__"：

对于Python中的类属性，可以通过双下划线"__“来实现一定程度的私有化，因为双下划线开头的属性在运行时会被"混淆”。双下划线的另一个重要的目地是，避免子类对父类同名属性的冲突。

总结：
"__“和” _ __"的使用 更多的是一种规范/约定，并没有真正达到限制的目的：

“_”：以单下划线开头的表示的是protected类型的变量，即只能允许其本身与子类进行访问；同时表示弱内部变量标示，如，当使用"from moduleNmae import *"时，不会将以一个下划线开头的对象引入。
“__”：双下划线的表示的是私有类型的变量。只能是允许这个类本身进行访问了，连子类也不可以，这类属性在运行时属性名会加上单下划线和类名。

 

 

设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法代码如下：

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))
x1,y1,z1=map(eval,input("请输入第一个三维向量的坐标：").split(','))
x2,y2,z2=map(eval,input("请输入第二个三维向量的坐标：").split(','))
v1=Vecter3(x1,y1,z1)
v2=Vecter3(x2,y2,z2)
v3 = v1+v2
v3.show()                          
v4=v1-v2
v4.show()                          
n=eval(input("请输入标量n："))
v5=v1*n
v5.show()
v6=v1/n
v6.show()

运行代码后，结果为：

字符串匹配（输入一段英文，输出只有三个字符的单词）：

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=' ')

结果为：