一、面向对象三大特性

一.继承

1.什么是继承？

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类（super），新建的类称为派生类或子类

python中继承分为：单继承和多继承

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

查看继承

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

2.继承与3抽象

抽象： 抽象即抽取类似或者说比较像的部分

抽象分成两个层次：

1.将奥巴马和梅西这俩对象比较像的部分抽取成类；

2.将人，猪，狗这三个类比较像的部分抽取成父类。

抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）

继承：是基于抽象的结果，通过编程语言去实现它，肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。

抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类

3.继承与代码的重用性

==========================第一部分
例如

　　猫可以：吃、喝、爬树

　　狗可以：吃、喝、看家

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：


#猫和狗有大量相同的内容
class 猫：

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 爬树(self):
        # do something



class 狗：

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 看家(self):
        #do something


==========================第二部分
上述代码不难看出，吃、喝是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝

　　   猫：爬树（猫继承动物的功能）

　　   狗：看家（狗继承动物的功能）

伪代码如下：
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 爬树(self):
        print '喵喵叫'

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 看家(self):
        print '汪汪叫'


==========================第三部分
#继承的代码实现
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print ("%s 喝 " %self.name)

class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def climb(self):
        print('爬树')

class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed='狗'

    def look_after_house(self):
        print('汪汪叫')


# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

4.派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。叫做重写、覆盖

class Animal:
    '''
    人和狗都是动物，所以创造一个Animal基类
    '''
    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 人和狗都有自己的昵称;
        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
        self.life_value = life_value  # 人和狗都有自己的生命值;

    def eat(self):
        print('%s is eating'%self.name)

class Dog(Animal):
    '''
    狗类，继承Animal类
    '''
    def bite(self, people):
        '''
        派生：狗有咬人的技能
        :param people:  
        '''
        people.life_value -= self.aggressivity

class Person(Animal):
    '''
    人类，继承Animal
    '''
    def attack(self, dog):
        '''
        派生：人有攻击的技能
        :param dog: 
        '''
        dog.life_value -= self.aggressivity

egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)

1.super():调用父类的属性

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha()
        #super(B,self).hahaha()
        #A.hahaha(self)
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

5.继承的顺序

在python2经典类中继承的顺序是： 深度优先

在python3新式类中继承的顺序是： 广度优先

二、多态

多态：一种事务具备多种不同下形态
官方解释：多个不同对象可以响应同一个方法，产生不同的结果

比如：动物有多种形态：人，狗，猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

1.鸭子类型

Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

例子1：类名不一样，类中定义的方法一样：响应同一种方法，产生不同的结果

class Mouse:
    def open(self):
        print("鼠标开机.....")

    def close(self):
        print("鼠标关机了...")

    def read(self):
        print("获取了光标位置....")

    def write(self):
        print("鼠标不支持写入....")



def pc(usb_device):
    usb_device.open()
    usb_device.read()
    usb_device.write()
    usb_device.close()

m = Mouse()
# 将鼠标传给电脑
pc(m)

class KeyBoard:
    def open(self):
        print("键盘开机.....")

    def close(self):
        print("键盘关机了...")

    def read(self):
        print("获取了按键字符....")

    def write(self):
        print("可以写入灯光颜色....")

# 来了一个键盘对象
k = KeyBoard()
pc(k)


class UDisk:

    def open(self):
        print("U盘启动了...")

    def close(self):
        print("U盘关闭了...")

    def read(self):
        print("读出数据")

    def write(self):
        print("写入数据")

u = UDisk()
pc(u)

例子2：二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用

class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

三、封装（最重要）

封装：

? 1.面向对象最重要的是封装

? 2.隐藏对象的属性和实现细节，仅对外提供公共访问方式

1.封装原则

? 1.将不需要对外提供的内容都隐藏起来

? 2.把属性都隐藏，提供公共方法对其访问。

2.封装好处

? 1.讲变化隔离

? 2.便于使用

? 3.提高复用性

? 4.提高安全性

3.私有属性和私有方法

私有属性、私有方法：1.让一些关键的数据，变成私有更加的安全
2.不是随意可以更改的
3.在属性，和方法前面加’__‘,变成私有，那么外界就不可以直接调用修改。
4.但是：在类的内部可以定义一个函数，方法调用修改。使用者直接调用这个函数就可以了。这个函数就是接口
5.可以在这个函数、方法加条件限制，而不是任意的改动

例子：定义成私有属性，在函数内部可以修改，那么用户调用这个函数也就可以直接修改私有属性，但是可以给这个函数加‘条件’，比如下面：小于300可以修改，否则不能修改

class student:

    def __init__(self, name, max):
        self.name = name
        self.__max = max
        # print(self.__max)

    def max(self, new_max):
        if new_max < 300:   # 增加修改的条件
            print('修改成功')
            self.__max = new_max
            print(self.__max)
        else:
            print('修改失败')

jeff =student('jeff',100)

jeff.max(200)
# jeff.max(500)

1.私有属性

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

***原理: 替换变量名称 方法名 替换为：_类名__方法名***

#其实这仅仅这是一种变形操作
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

2.私有方法

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

#正常情况
class A:
    def fa(self):
        print('from A')
    def test(self):
        self.fa()

class B(A):
    def fa(self):
        print('from B')

b=B()
b.test()
from B
 

#把fa定义成私有的，即__fa
class A:
    def __fa(self): #在定义时就变形为_A__fa
        print('from A')
    def test(self):
        self.__fa() #只会与自己所在的类为准,即调用_A__fa

class B(A):
    def __fa(self):
        print('from B')

b=B()
b.test()
from A

4.封装与扩展性

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

四、小方法

1.自定义比较对象__gt__大于，__lt__小于，__eq__等于

可以利用这三个自定义比较对象：
gt：greater than 大于缩写
lt：less than 小于缩写
eq：equal 等于缩写

class Student(object):
    def __init__(self, name, height, age):
        self.name = name
        self.height = height
        self.age = age

    # 比较大于时触发
    def __gt__(self, other):
        return self.height > other.height

    # 比较小于时触发
    def __lt__(self, other):
        return self.age < other.age

    # 比较等于时触发
    def __eq__(self, other):
        # if self.age == other.age:  # 比较两个对象的年龄
        if self.age == other.age and self.height == other.height:  # 比较年龄和身高
            return '年龄身高一样'
        return '年龄身高不一样'


stu1 = Student("jeff", 170, 25)
stu2 = Student("make", 170, 25)

print(stu1 > stu2)
print(stu1 < stu2)
print(stu1 == stu2)

2.上下文管理__enter__进入文件时，__exit__离开

enter：1.进入文件，开打文件时执行
2.函数应该返回自己self
exit:1.退出文件、报错中断、或者代码执行完时执行
2.可以有返回值,是bool类型

class MyOpen(object):
    def __init__(self, path):
        self.path = path
    
    # 进入文件时触发
    def __enter__(self):
        self.file = open(self.path)
        print("文件打开....")
        return self
    
    # 离开文件时触发
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("文件关闭")
        # print(exc_type,exc_val,exc_tb)
        self.file.close()  # 关闭文件
        return True


with MyOpen('a.txt') as f:
    print(f.file.readline())

# f.file.readline()   # 文件已经关闭了，不能读

3.__str__转字符串时触发__del__删除时触发

str：再转换字符串时触发，转换结果就是该函数的返回值
使用场景：利用该函数自定义，打印格式
del :
执行时机：手动删除时立马执行，或者程序运行结束时自动执行
使用场景：当你的对象使用过程中，打开了不属于解释器的资源；例如，文件，网络端口

1.__str__例子：

1.# __str__例子：
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        # 自定义打印输出
        return "这是一个person对象 name:%s age:%s" % (self.name, self.age)


p = Person("jack", 20)
print(p)

1. __del__例子：

2.# __del__例子：
class A:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print('删除时触发')

    # 删除时关闭
    def __del__(self):
        self.file.close()


jeff = A('jeff')
del jeff
# jeff.name  # 已经删除，无法访问了

4.__slots__优化对象内存

slots：原理，给对象声明只有某些属性，从而删除不必要的内存，不能添加新属性
1.优化对象内存
2.限制属性数量

1.__slots__案例：slots使用

import sys
class Person:
    __slots__ = ['name']  # 声明名称空间只有name属性

    def __init__(self, name):
        self.name = name

p = Person('jeff')
print(sys.getsizeof(p))
#结果：48          #####内存减少了8

面向对象

原文：https://www.cnblogs.com/guyouyin123/p/11354611.html