python面向对象学习

提要：

     面向对象三大特征
   1.封装：本质是将事物相关的属性和方法封装在一个类里面
   2.继承:子类（派生类）继承父类（基类）的内容
   3.多态:多态指的是一类事物有多种形态：动物有多种形态：人，狗，猪

 

一、封装

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

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

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处

 self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class Foo:

 

    def __init__(self, name, age):

        self.name = name

        self.age = age

 

obj1 = Foo('wupeiqi', 18)

print obj1.name    # 直接调用obj1对象的name属性

print obj1.age     # 直接调用obj1对象的age属性

 

obj2 = Foo('alex', 73)

print obj2.name    # 直接调用obj2对象的name属性

print obj2.age     # 直接调用obj2对象的age属性

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

class Foo:

  

    def __init__(self, name, age):

        self.name = name

        self.age = age

  

    def detail(self):

        print self.name

        print self.age

  

obj1 = Foo('wupeiqi', 18)

obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

  

obj2 = Foo('alex', 73)

obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

二、继承

（一）、继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

（二）、多继承

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

• 当类是经典类时，多继承情况下，会按照深度优先方式查找
• 当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

 

三、多态 

 Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。

鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’ python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象 也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

 

四、两道例题

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

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+v2
v3.show()
v4 = v1-v2
v4.show()
v5 = v1*3
v5.show()
v6 = v1/2
v6.show()

结果如下：

(2)编写一个程序(类),用户输入一段英文,然后输出这段英文中所有长度为3个字母的单词井且如果单词如果有连续 复了2次,只输出一个【例: This isis a desk,程序输出 his is a desk】,(提示,有re正则匹配来做)
 代码如下：

import re
x = input(" input a string:")
pattern = re.compile(r'\b[a-zA-Z]{3}\b')
list1=pattern.findall(x)
list2 = sorted(set(list1), key=list1.index)
list2.sort(key=list1.index)
print(list2)
# compile函数根据包含的正则表达式的字符串创建模式对象。
#findall()返回的是括号所匹配到的结果
# list1.index决定项目在列表框中的位置，自上而下，第一个为0，往下一次增加

结果如下：