本系列博文基于廖雪峰老师的官网Python教程，笔者在大学期间已经阅读过廖老师的Python教程，教程相当不错，官网链接： 廖雪峰官方网站.请需要系统学习Python的小伙伴到廖老师官网学习，笔者的编程环境是Anaconda+Pycharm，Python版本：Python3.

1.继承和多态

# 1.在OOP程序设计中，定义一个class时，可以从某个现有的class继承，
# 新的class称为子类(Subclass)，被继承的class称为基类、父类、超类(Base class、Super class);
# 2.继承：子类获得父类的全部功能；
# 实例：
class Animal(object):
    def run(self):
        print("Animal is running...")
        
# 编写Dog和Cat类
# Animal类是Dog类的父类，Dog类是Animal类的子类；
# Animal类是Cat类的父类，Cat类是Animal类的子类；

class Dog(Animal):
    # 改写Animal的run方法
    def run(self):
        print("Dog is running...")
    
    def eat(self):
        print("Eatting meat...")
        
    def sleep(self):
        print("Sleeping...")

# 3.当子类和父类存在相同的方法，如：run()，子类的run()会覆盖父类的run()；
class Cat(Animal):
    def eat(self):
        print("Cat eatting fish...")

# 实例化对象
dog = Dog()
print("Dog类改写了Animal父类的run方法：")
dog.run()

cat = Cat()
print("Cat类保持Animal父类的run方法：")
cat.run()
print("---------------------------------------")

# 4.定义一个class时，实际上定义了一种数据类型；
listEg = list()    # 定义了listEg是list类型；
AnimalEg = Animal()    # 定义了AnimalEg是Animal类型；
DogEg = Dog()      # 定义了DogEg是Dog类型

# 判断一个变量是否是某个类型：isinstance()
# 5.在继承关系中，如果一个实例的数据类型是某个子类，那么该实例的数据类型也可以被看作父类，但反过来不成立；
print("判断listEg是否是list类型：",isinstance(listEg, list))
print("判断AnimalEg是否是Animal类型：",isinstance(AnimalEg, Animal))
print("判断AnimalEg是否是Dog类型：",isinstance(AnimalEg, Dog))
print("判断DogEg是否是Dog类型：",isinstance(DogEg, Dog))
print("判断DogEg是否是Animal类型：",isinstance(DogEg, Animal))
print("判断DogEg是否是Cat类型：",isinstance(DogEg, Cat))
print("---------------------------------------")

# 实例：
def runTwice(animal):
    animal.run()
    animal.run()

print("runTwice()传入Animal实例时打印：")
runTwice(Animal())
print("\n")

print("runTwice()传入Dog实例时打印：")
runTwice(Dog())
print("\n")

# 定义一个Duck类型
class Duck(Animal):
    def run(self):
        print("Duck is running slowly......")
        
print("runTwice()传入Duck实例时打印：")
runTwice(Duck())

# Tips:
# a.新增Animal子类，不需要对runTwice()做修改；
# b.多态好处：当需要传入Dog、Cat、Duck时，只需要接收Animal类即可；
# c.由于Animal类型有run()方法，因此，传入任意类型，只要是Animal类或子类，会自动调用run()方法；

# 开闭原则：
# a.对扩展开放：允许新增Animal子类；
# b.对修改封闭：不需要修改依赖Animal类型的runTwice()等函数；

# 静态语言VS动态语言：
# a.静态语言，如：Java，如果需要传入Animal类型，则传入的对象必须是Animal类型或子类，否则无法调用run()方法；
# b.动态语言，如：Python，不一定需要传入Animal类型，保证传入的对象有一个run()方法即可；

# 结果输出：
Dog类改写了Animal父类的run方法：
Dog is running...
Cat类保持Animal父类的run方法：
Animal is running...
---------------------------------------
判断listEg是否是list类型： True
判断AnimalEg是否是Animal类型： True
判断AnimalEg是否是Dog类型： False
判断DogEg是否是Dog类型： True
判断DogEg是否是Animal类型： True
判断DogEg是否是Cat类型： False
---------------------------------------
runTwice()传入Animal实例时打印：
Animal is running...
Animal is running...


runTwice()传入Dog实例时打印：
Dog is running...
Dog is running...


runTwice()传入Duck实例时打印：
Duck is running slowly......
Duck is running slowly......

2.获取对象信息

# 1.判断对象类型：type()函数
# type()函数返回的是Class类型；
int1 = 100
str1 = "584520"
str2 = "ChenJD"
float1 = 3.1415926

list1 = [1,2,3,5,6,7]
tuple1 = (1,2,3,4,5,6)
dict1 = {"name": "Willard","age": 18}

abs1 = abs

print("int1类型：",type(int1))
print("str1类型：",type(str1))
print("str2类型：",type(str2))
print("float1类型：",type(float1))

print("list1类型：",type(list1))
print("tuple1类型：",type(tuple1))
print("dict1类型：",type(dict1))

print("abs1类型：",type(abs1))

# 结果输出：
int1类型： <class 'int'>
str1类型： <class 'str'>
str2类型： <class 'str'>
float1类型： <class 'float'>
list1类型： <class 'list'>
tuple1类型： <class 'tuple'>
dict1类型： <class 'dict'>
abs1类型： <class 'builtin_function_or_method'>

# 2.使用isinstance()函数判断class的类型
class Cars(object):
    def carBrand(self):
        print("这是一辆普通的汽车！")
    
    def appearance(self):
        print("这辆普通的汽车有四个轮子！")
        
class BaiduCar(Cars):
    def carBrand(self):
        print("这是搭载了百度Apollo的无人驾驶汽车！")
    
    def apperance(self):
        print("这辆汽车有四个轮子！")
        print("这辆汽车还搭载了很多传感器！")
        print("这辆汽车搭载了多线激光雷达、摄像头、毫米波雷达等！")
        
    def autoLevel(self):
        print("这辆汽车可在特定的路段进行无人驾驶！")
        print("这辆汽车在L4级无人驾驶等级！")
        
class BYDCar(Cars):
    def carBrand(self):
        print("这是比亚迪的汽车！")
    
    def apperance(self):
        print("比亚迪汽车也有四个轮子！")
        print("这辆汽车只搭载了倒车雷达和一些普通汽车传感器！")
        print("比亚迪汽车采用中文操作面板！")
    
    def performance(self):
        print("这是一辆比亚迪生产的电车！")
        print("这辆电车续航能力很强！")
        
# 创建以上三种类型的对象
car = Cars()
baiduCar = BaiduCar()
bydCar = BYDCar()

# 使用isinstance判断
print("判断car是否是Cars类型：", isinstance(car, Cars))
print("判断baiduCar是否是BaiduCar类型：", isinstance(baiduCar, BaiduCar))
print("判断bydCar是否是BYDCar类型：", isinstance(bydCar, BYDCar))
print("------------------------------------------")

print("判断car是否是BaiduCar类型：", isinstance(car, BaiduCar))
print("判断baiduCar是否是Cars类型：", isinstance(baiduCar, Cars))
print("判断bydCar是否是BaiduCar类型：", isinstance(bydCar, BaiduCar))

# 结果输出：
判断car是否是Cars类型： True
判断baiduCar是否是BaiduCar类型： True
判断bydCar是否是BYDCar类型： True
------------------------------------------
判断car是否是BaiduCar类型： False
判断baiduCar是否是Cars类型： True
判断bydCar是否是BaiduCar类型： False
```、
```python
# 3.要获得一个对象的所有属性和方法，使用dir()函数；
numList = [1,2,3,4,5,6]

print("numList所有的属性和方法：\n",dir(numList))

# 结果输出：
numList所有的属性和方法：
 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

# 4.结合getattr()、setattr()、hasattr()，操作对象的状态
class Mul(object):
    def __init__(self):
        self.num = 10
        
    def power(self):
        return self.num * self.num
    
mul = Mul()

# 测试mul对象属性
print("测试mul是否有num属性：",hasattr(mul, "num"))
print("获取mul的num属性值：",mul.num)

print("测试mul是否有number属性：",hasattr(mul, "number"))
print("设置一个number属性：")
setattr(mul, "number", 520)

print("设置后再测试mul是否有number属性：",hasattr(mul, "number"))
print("获取属性number：",getattr(mul, "number"))

print("获取属性'list'，如果不存在，返回默认值404：",getattr(mul, "list", 404))
print("-----------------------------------------------------")

# 测试mul对象方法
print("测试mul是否有power方法：",hasattr(mul, "power"))
print("测试mul是否有add方法：",hasattr(mul, "add"))
print("获取属性'power'：",getattr(mul, "power"))

# 结果输出：
测试mul是否有num属性： True
获取mul的num属性值： 10
测试mul是否有number属性： False
设置一个number属性：
设置后再测试mul是否有number属性： True
获取属性number： 520
获取属性'list'，如果不存在，返回默认值404： 404
-----------------------------------------------------
测试mul是否有power方法： True
测试mul是否有add方法： False
获取属性'power'： <bound method Mul.power of <__main__.Mul object at 0x000002803821B198>>

3.实例属性和类属性

# 1.Python是动态语言，根据类创建的实例可以任意绑定属性；
# 2.给实例绑定属性的方法是通过实例变量，或通过self变量；
# 实例;
class Employee(object):
    def __init__(self, name):
        self.name = name          # 通过self变量
        
employee1 = Employee("Willard")
employee1.salary = 12000          # 通过实例变量

# 3.如果类本身需要绑定一个属性，在class中直接定义，属于类属性
class Employee(object):
    name = "Employee"
    
# 创建实例
employee2 = Employee()

# 打印name属性
print("打印employee2的name属性：",employee2.name)

# 给实例绑定name属性
employee2.name = "ChenJD"
print("打印employee2的实例name属性：",employee2.name)
print("因此，实例属性优先级高于类属性！")

print("通过Employee.name访问类属性：",Employee.name)

# 删除实例的name属性
del employee2.name
print("删除employee2的name属性后，调用name属性：",employee2.name)

# Tips:
# 1.实例属性属于各个实例所有，互不干扰；
# 2.类属性属于类所有，所有实例共享一个属性；
# 3.不要对实例属性和类属性使用相同名字，否则将产生难以发现的错误；

# 结果输出：
打印employee2的name属性： Employee
打印employee2的实例name属性： ChenJD
因此，实例属性优先级高于类属性！
通过Employee.name访问类属性： Employee
删除employee2的name属性后，调用name属性： Employee