1.封装
定义：
数据角度：将基本数据类型复合成一个自定义类型。
作用：可读性更高，将数据与对数据的操作相关联。
行为角度：对类外提供必要的功能，隐藏实现的细节
作用：让调用者不必了解实现代码，也能调用我们写的功能
让调用者操作变得简单。
私有化成员：
定义：变量名双下划线开头
如 self.__name = name
本质：障眼法，可以通过对象._类名__成员名调用。
2.继承
定义：重用现有类的功能，并在此功能上进行扩展。
多个类型有相同的行为，且概念统一，这个时候我们就可以将多个类型统一的行为抽出来做一个类，而这个类就为多个类的父类，当创建子类时继承父类，就可以继承父类中已经有的行为。
通俗一些的讲，就是子类继承父类，就相当于子类复制粘贴了父类代码。
继承语法：
class Person:
pass
class Student(Person):
Pass
# 代码1-1代码1-1中class Person其实就相当于，class Person(object)，python代码中，创建一个类时，当不选择父类时，默认继承object，因此：任何类都直接或间接继承object类。
鸭子原则
其实：默认继承object体现了鸭子原则的精神，关心的是对象的行为，而不是对象的类型，只要对象的行为符合我们的期待，我们就可以将其视为所需要的类型。为什么代码1-1Person后面可以不写object来明确认父，这是一种思想，想告诉写python的程序员，我管你什么类型和继承关系，你给我实现功能就好了。
代码案例：
class Duck:
def quack(self):
print("Quack!")
class Cat:
def meow(self):
print("Meow!")
def sound(animal):
animal.quack() # 调用Duck类中的quack方法
duck = Duck()
cat = Cat()
sound(duck) # 输出 "Quack!"
sound(cat) # 抛出 AttributeError，因为Cat类没有定义quack方法上述代码：
因为Cat类没有定义quack方法，因此才抛出异常，若Cat类中有queck方法则正常输出，
这里就能感受到，python只关心对象的行为，而不关心对象的类型，运行时才确定对象类型。而python中这种思想体现在动态类型语言检测和灵活的面向对象编程上。
总结：鸭子原则时一种思想，我们只关系对象的行为，而不关心对象的类型，而在python中这种思想体现在动态类型语言检测和灵活的面向对象编程上。在动态类型语言检测上，我们是在运行程序时才确定对象类型，因此当我们将一个对象当作参数传入一个函数中时，该对象可以时任何类型，只要能实现函数中的对象就不会抛出异常，反之不能满足函数中对象的行为则会抛出类型中没有此方法的异常。
在面向对象的继承上：
即使你不继承父类，但是你有和父类一样的行为，那么你就有了这个父类的特性，
从而可以在python中就可以达到你就是继承这个父类的效果。
类型判断：isinstance, type
class Animal:
@staticmethod
def eat():
print("我吃吃吃")
class Dog(Animal):
@staticmethod
def run():
print("我跑跑跑")
class Bird(Animal):
@staticmethod
def fly():
print("我飞飞飞")
if __name__ == '__main__':
bird = Bird()
bird.fly()
bird.eat()
dog = Dog()
dog.eat()
dog.eat()
animal = Animal()
print(isinstance(dog, Dog)) # True
print(isinstance(dog, Animal)) # True
print(isinstance(animal, Dog)) # False
print(type(dog) == Dog) # True
print(type(dog) == Animal) # False
print(type(animal) == Dog) # False
# 代码1-2 通过上述代码：我们可以得出结论，type和isinstance的区别，用法上的不同，type是判断一个对象是不是一个类型，是就返回True，不是返回False。而isinstance是判断一个对象是不是属于一种类型，像代码1-2中，dog对象虽然是Dog类型，但是Dog继承了Animal类型，所以dog对象也属于动物类型，用isinstance判断返回的是True。反之，animal对象不属于Dog类型，怎么理解，只有说儿子属于爸爸，没有说爸爸属于儿子，animal对象是Animal类型是Dog类型的父类。
构造函数的继承
若子类没有构造函数，将直接使用父类构造函数。
若子类有构造函数，将覆盖父类的构造函数。
若子类有构造函数，并且想使用父类的构造函数的成员，可以用super().__init__(参数,参数)
python可以多继承，但是我们一般都使用单继承，多实现的思想来设计模型。
继承父类变量的语法与代码
# 继承父类变量
class Car:
def __init__(self, brand="", speed=""):
self.brand = brand
self.speed = speed
class Electric(Car):
def __init__(self, brand="", speed="", capacity="", frequency=""):
super().__init__(brand, speed)
self.capacity = capacity
self.frequency = frequency
electric = Electric("1", "1", "1", "1")
print(electric.capacity, electric.frequency, electric.brand, electric.speed)
# 代码1-3父类中是共性，子类中是个性。
3.多态
概念：对于父类的一个方法，在不同子类上有不同的体现。
重写：目的是张显个性
双下划线开头和双下划线结尾，这些是python的内置函数。
重写内置函数：
重写之前：
class Animal:
def __init__(self, name="", color=""):
self.name = name
self.color = color
animal = Animal("dog", "white")
print(animal) # <__main__.Animal object at 0x000001E829958948>
# 代码1-4
重写之后：
class Animal:
def __init__(self, name="", color=""):
self.name = name
self.color = color
def __str__(self):
return "name: %s, color: %s" % (self.name, self.color)
animal = Animal("dog", "white")
print(animal) # name: dog, color: white
面向接口编程：
先确定用法，后决定做法，这是一种软件架构设计思想，
在1991年python祖师爷就确定了print()的用法，就是打印一个对象__str__方法的返回值。
这里的重写只是语法上，随便百度就能知道，并不值钱，而这里面牵涉到的软件架构思想才是重中之重，非常重要。
下列是经常会重写的内置函数：
算数运算符：
代码案例：
class Animal:
def __init__(self, name="", age=0):
self.name = name
self.age = age
def __str__(self):
return "name: " + self.name + ", age: " + str(self.age)
def __add__(self, other):
if type(other) == int:
return Animal(self.name, self.age + other)
else:
return Animal(self.name, self.age + other.age)
animal = Animal("dog", 2)
print(animal + 1) # name: dog, age: 3
print(animal + animal) # name: dog, age: 4
在python中 animal + 1 相当于 animal.__add__(1)
我们再来看看重写__iadd__
class Animal:
def __init__(self, name="", age=0):
self.name = name
self.age = age
def __str__(self):
return "name: " + self.name + ", age: " + str(self.age)
def __iadd__(self, other):
if type(other) == int:
self.age += other
return self
else:
self.age += other.age
return self
animal = Animal("dog", 2)
print(id(animal)) # 140380752334848
animal += 1
print(id(animal)) # 140380752334848
print(animal) # name: dog, age: 3
而__iadd__则是 +=, 同理加减乘除的累计运算符都是比算数运算符多个i
值得一提的是，当一个对象没有__iadd__时使用 += 对象会调用__add__,但是返回的也是一个新对象。而当一个对象没有__add__时，使用+对象时会抛出异常。
比较运算符对应的内置函数：
这里写两个比较常用的重写的代码案例：
"""
图书列表设计
类：BookModel
数据：书名 - name , 价格 - number
行为1，重写__eq__使其在列表容器中能够实现，remove, in , index等功能。
行为2, 重写__lt__ 或 __gt__ 使其在列表容器中能实现，sort 功能
"""
class BookModel:
def __init__(self, name, price):
self.name = name
self.price = price
def __str__(self):
return self.name + " - " + str(self.price)
def __eq__(self, other):
return self.name == other.name
def __lt__(self, other):
return self.price < other.price
list_book = [
BookModel("Java", 200),
BookModel("Python", 100)
]
list_book.sort()
for item in list_book: # Python - 100 Java - 200
print(item)
list_book.remove(BookModel("Java", 200))
for item in list_book: # Python - 100
print(item)
__lt__:
当自定义类型重写了__lt__方法，自定义类型就可以比较大小，并且放入列表中还能使用列表的方法，如sort(),因为sort的实现代码是迭代列表，取列表中元素，让元素与元素之间比较，当列表中的对象类型没有重写__lt__方法时，会抛出异常。
__eq__:
当自定义类型写__eq__方法，就可以根据自己的业务逻辑来判断自定义对象是否相等，值得一提的是object默认使用对象的内存进行比较，实现这个方法，如果将自定义对象存入列表，将可以使用列表的romove方法，index方法等。
