2019-04-15 Python中的面向对象学习总结

一.面向对象总结：

　　（1）三要素：封装，继承，多态                                       详细介绍链接：https://www.jianshu.com/p/68ab35298a59

　　　　one.封装：所谓封装，也就是把 客观事物 封装成 抽象的 类，并且 类 可以把自己的数据和方法只让可信的类或者对象操作。 简而言之就是将内容封装到某个地方，以后再去调用被封装在某处的内容

　　　　　　测试代码：

#封装测试例子
class Foo:#定义一个类
    def __init__(self,name,age): #称为构造方法，根据类创建对象时自动执行
        self.name = name      #name和age是对象的 属性
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)

obj.Foo('wupeiqi',18)
obj.detail() 

>>>>输出结果 wupeiqi 17

　　　　two.继承：将多个类共有方法提取到父类，子类仅需继承父类而不必一一实现每个方法         注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。

　　　　　　测试代码：

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)

class son(Foo):#子类继承父类，即拥有了父类的所有方法
    pass
obj = son('wupeiqi',17)
obj.detail()

》》》输出结果wupeiqi 17

　　　　需要说明的是：python可以继承多个类，如果python继承了多个类那么它有两种方式寻找，分别是 深度优先和广度优先。以后再作详细介绍

　　　　three.多态：所谓多态就是指一个类实例的 相同方法 在不同情形有不同 表现形式

　　（2）类成员的修饰符：下划线

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

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

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

　　　　　　__xxx__：系统定义的特殊成员

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

　　（3）名词解析

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

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

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

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

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

　　　  总结：对象的抽象是类，类的具体化就是对象；也可以说类的实例化是对象，对象是类的实例，例如 奥斑马和梅西可以抽象为人（类），人的实例化是奥斑马和梅西，此外，类也可以作为 其父类的实例化，例如：人和猫可以抽象为动物，动物的实例化是人和猫。

　　（4）类的成员：字段，方法，属性

　　　　注：类和对象在内存中如何保存？

　　　　答：类以及类中的方法在内存中只占一份内存，而根据类创建的每一个对象在内存中都需要一份内存。如下图：

　　　　one.字段：分为普通字段和静态字段（本质区别是在内存中保存的位置不同）。注意：在所有成员中，只有字段中的普通字段保存于对象中，因此创建多少个对象在内存中就有几个普通字段；而其他成员都保存在类中，也只占用一份内存空间。

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

　　　　　　1.

　　　　　　2.

　　　　　　3.

　　　　　　4.

　　　　three.属性 其实是普通方法的变种

　　　（5）类的特殊成员

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

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

　　　　　　(3) 类的属性

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

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

　　　　　　(4) 特殊的类属性

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

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

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

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

　　　　　　　　类名.__dict__：类的字典属性

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

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

　　　　（6）self

　　　　　　　　在Python中，在类中定义实例方法时将第一个参数定义为“self”只是一个习惯，而实际上类的实例方法中第一个参数的名字是可以变化的，而不必须使用“self”这个名字，尽管如此，建议编写代码时仍以self作为方法的第一个参数名字。　　　　　　　　

>>> class A:
    def __init__(hahaha, v):
        hahaha.value = v
    def show(hahaha):
        print(hahaha.value)
>>> a = A(3)
>>> a.show()
3

　　　　（7）混入机制

# -*- encoding:utf-8 -*-
''' 实例说明 —— 混入机制 '''
import types
class Stu:                  #定义类
    where = 'China'       #定义类属性，属于静态字段，只保存于类中
    def __init__(self, c):
        self.name = c      #定义实例属性

stu = Stu("wupeiqi")             #实例化对象
print(stu.name, Stu.where)       #查看实例属性和类属性的值
Stu.where = 'Guangdong'                    #修改类属性的值
Stu.age = 18                  #动态增加类属性，属于静态字段，只保存于类中
stu.name = "woshiname"                 #修改实例属性的值
print(Stu.where, Stu.age, stu.name)

def setGender(self, s):
    self.Gender = s

stu.setGender = types.MethodType(setGender, stu) #动态增加成员方法
stu.setGender('boy')                                 #调用成员方法
print(stu.Gender)

#利用特殊的类属性查看类与对象的属性与行为
print("Stu类的属性与行为如下：\n",Stu.__dict__)  #字典属性
print("\n")
print("stu对象的属性与行为如下：\n",stu.__dict__)

》》》输出如下

wupeiqi China
Guangdong 18 woshiname
boy
Stu类的属性与行为如下：
{'__module__': '__main__', 'where': 'Guangdong', '__init__': <function Stu.__init__ at 0x000002CDD020A9D8>, '__dict__': <attribute '__dict__' of 'Stu' objects>, '__weakref__': <attribute '__weakref__' of 'Stu' objects>, '__doc__': None, 'age': 18}

stu对象的属性与行为如下：
{'name': 'woshiname', 'setGender': <bound method setGender of <__main__.Stu object at 0x000002CDD0224320>>, 'Gender': 'boy'}

二.面向对象例子

　　First.三维向量类

　　（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):      # +  __add__意味着+号，系统自动识别
        return vecter3(self.x+n.x, self.y+n.y, self.z+n.z)

    def __sub__(self,n):
        return vecter3(self.x-n.x, self.y-n.y, self.z-n.z)

    def __mul__(self,n):
        return vecter3(self.x*n, self.y*n, self.z*n)

    def __truediv__(self, n):
        return vecter3(self.x/n, self.y/n, self.z/n)

    def __str__(self):     ##供print打印的字符串
        return str(self.x)+','+str(self.y)+','+str(self.z)

if __name__ == "__main__":
    n = int (input("请输入一个变量n："))
    a,b,c = map(int,input("请输入第一个向量：").split())
    v1 = vecter3(a,b,c)
    a,b,c = map(int,input("请输入第二个向量：").split())
    v2 = vecter3(a,b,c)
    print("两向量的加法：",v1 + v2)
    print("两向量的减法：",v1 - v2)
    print("标量与向量的乘法：",v1 * n)
    print("标量与向量的除法：",v1 / n)

　　　　（2）if __name__ == '__main__' 如何正确理解

　　　　详细介绍链接：http://blog.konghy.cn/2017/04/24/python-entry-program/

　　Second.字符串处理

　　　　（1）简述：用户输入一段英文，得到这段英文中所以长度为x(用户输入)的单词，并去除重复的单词。

　　　　代码如下（分词法）：

# -*- encoding:utf-8 -*-
''' 将一段英文中长度为x的单词输出，并去掉重复的单词 '''
import jieba
class proString:
    Str = ""
    Dict = {}  #花括号{}：代表dict字典数据类型，字典是Python中唯一内建的映射类型
    Ls = []   #中括号[]：代表list列表数据类型，列表是一种可变序列
    def __init__(self,string,length): #初始化长度固定
        self.string = string
        self.length = length

    def SignalWord(self):        #去除重复的单词
        self.words = jieba.lcut(self.string)   #jieba分词,精确模式返回一个列表 如：['I', ' ', 'a',  'good']
        #print(self.words)
        for i in self.words:                   #与词频算法相似
            self.Dict[i] = self.Dict.get(i,0) + 1  #字典的运用 .get(<key>.<default>)统计词频P167
            print(self.Dict)  #查看字典                  {'I': 2, ' ': 6, 'am': 1, 'a': 1, 'good': 1, 'boy': 1, '!': 1}
        del(self.Dict[' '])                 #删除空格项
        print(self.Dict)   #查看删除空格后的字典 {'I': 2, 'am': 1, 'a': 1, 'good': 1, 'boy': 1, '!': 1}
        self.Ls = list(self.Dict.keys())    #字典类型转化成列表类型
        print(self.Ls)   #查看列表   ['I', 'am', 'a', 'good', 'boy', '!']

    def StubbenWord(self):       #利用去除重复的单词，得到固定长度的单词
        for i in self.Ls:
            if len(i) == self.length:
                self.Str += i +' '   #加空格分隔
        return self.Str

if __name__ == "__main__":
    str1 = input("请输入字符串：")
    n = eval(input("请输入固定单词长度:"))
    Po = proString(str1,n)
    Po.SignalWord()
    print("处理后的字符串为：" + Po.StubbenWord())

　　　　（2）正则表达式法：

　　　　　　代码如下：

import re
class proString:
    Dict = {}  #定义一个字典类型数据
    Ls = []     #列表  静态变量 全局可用

    def __init__(self,string,length):
        self.string = string
        self.length = length

    def Fixed_length_word(self):
        self.words = re.findall(r'\b[a-z/A-Z]{%s}\b'%self.length,self.string)
        #print(self.words)  #输出为 ['Boy', 'Boy', 'boy', 'BOY'] 有重复
        for i in self.words:
            self.Dict[i] = self.Dict.get(i,0) +1     #单词变为 字典类型数据
        self.Ls =  list(self.Dict.keys())   #提取字典中在keys位置的单词（相当于去重复）
        #print(self.Ls)    #输出为  ['Boy', 'boy', 'BOY']
        Str = ""  #定义一个字符串
        for i in self.Ls:    #把上面的列表转换为字符串
            Str += i + ' '   #用空格分隔
        return Str

if __name__ == "__main__":
    str = "I I  am a good Boy Boy boy BOY!"
    leng = eval(input("请输入固定单词长度："))
    Po = proString(str,leng)
    print("处理后的字符串为:"+Po.Fixed_length_word())