因为提高了代码的复用性，开发效率高，而且便于扩展迭代，所以成为了主流的开发思想。其中的核心概念就是类，在面向对象的思想中，可以用类来抽象一切的事物
类抽象一类事物为一个模型。用__属性__和__方法__来描述
属性描述一类事物的属性，本质上是类中的变量。包括两种：
实例属性：这个类的对象的一种__个体的属性__
类属性：这个类所有对象的一种__整体的属性__
方法描述一类事物的行为，本质上是类中的函数。包括三种：
实例方法：
self: 实例方法中，自动添加的一个参数，代表调用此方法的对象。
类方法：
cls: 实例方法中，自动添加的一个参数，代表调用此方法的类。用@classmethod装饰
静态方法：
既不使用self，也不使用cls的方法。用@staticmethod装饰
调用方法的两种方式：
-
对象调用方法
-
类名调用方法
是具体的一个一个的事物，由__类__制造而成。
实例化类制造对象的过程
class Person(object): # 创建类
pass
if __name__ == '__main__':
p1 = Person() # 类加括号：实例化一个对象
二：python中的顶级父类及其属性和方法
object：顶级父类，继承的源头，默认继承它
_class_: 查看实例化这个对象的类
_bases_：查看父类
_dict_: 字典形式__显示属性__
dir(类名)：查看类的方法
_new_(): 创建对象
_init_()：初始化对象的属性，创建对象自动调用，可以设置默认参数
_str_()：打印对象信息，必须return字符串，print(对象)的时候
_repr_()：打印对象信息，必须return字符串，print(对象容器)的时候，例如[obj1, obj2,…]
type：顶级元类，实例化的源头，一般了解即可
class Person(object): # 创建类
def __init__(self, name):
self.name = name
def eat(self):
print(self.name, '吃饭')
def __str__(self):
return self.name
if __name__ == '__main__':
p1 = Person('lisi') # 类加括号：实例化一个对象
print('----------------------查看属性和方法-----------------------')
print(p1.__dict__) # 以字典形式打印对象属性
print(dir(Person)) # 打印类的方法
print('-----------------__class__-----__bases__----------------')
print(p1.__class__) # 实例化此对象的类
print(Person.__bases__) # 此类的父类们
print('----------了解---------object-------type-----------------')
print(object.__class__) # 实例化object这个对象的是 type这个顶级元类
print(object.__bases__) # object没有父类
print(type.__class__) # 实例化type这个对象的类是它自己
print(type.__bases__) # type的父类是object这个顶级父类
运行结果
----------------------查看属性和方法-----------------------
{'name': 'lisi'}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'eat']
-----------------__class__-----__bases__------------------
(,)
----------了解---------object-------type----------------------
()
(,)
三：类的三大特性
1 继承
继承：指类与类之间的一种重要关系。
举例说明下，现在有两个类，A类和B类，B类继承了A类，那么B称为A的子类，A称为B的父类。B类实例化的对象可以使用A类的属性和方法
2 多态多态：同一个方法，不用对象来调用，结果不同
实现多态的方式： 在继承的基础上__重写__
重写：当父类的方法不能满足子类使用，子类重新写父类的方法。重写的方法和父类方法，函数名相同
注意：__子类重写__init__()__这个方法，添加新的属性，__需要调用父类的__init__()方法__来初始化从父类继承来的属性，否则父类属性无法使用。下面为调用的两种方法：
super().__init__()
父类名.__init__(self)
class Animal:
def eat(self):
print('动物会吃')
class Cat(Animal):
def eat(self):
print('猫吃鱼')
class Dog(Animal):
def eat(self):
print('狗吃肉')
class Person: # python不继承也可以实现多态
def eat(self):
print('人干饭')
def show(obj):
obj.eat() # 统一调用类的方法
show(Animal())
show(Dog())
show(Cat())
show(Person())
# show(Animal) # 不能把 类名 放进去
# show(Dog)
# show(Cat)
# show(Person)
运行结果
动物会吃 狗吃肉 猫吃鱼 人干饭3 封装
python中，封装属性，方法的办法是：
在属性和方法前面加__两个下滑线__，例如：‘__属性’，‘__方法’
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age # __ 防止在类的外部使用
def show(self):
print(self.name, self.__age)
def __show2(self):
print('测试封装方法')
stu = Student('张三', 23)
stu.show()
# stu.__show2() #AttributeError: 'Student' object has no attribute '__show2'
print(stu.name)
# print(stu.__age) # AttributeError: 'Student' object has no attribute '__age'
print('-----------------------------------------------')
运行结果：
张三 23 张三 -----------------------------------------
封装属性，是为了类来控制+` 对属性的读写。
使用装饰器__@property和@属性名.setter__,可以很好控制属性的访问
class Student:
def __init__(self, name, age):
self.__name = name
self.__age = age
@property
def name(self):
return self.__name
@name.setter
def name(self, new_name):
self.__name = new_name
@property
def age(self):
return self.__age
# 注释掉，就不能外部修改了
# @age.setter
# def age(self, new_age):
# self.__age = new_age
if __name__ == '__main__':
s1 = Student('qq', 12)
print(s1.name)
s1.name = 'hahaha'
print(s1.name)
print(s1.age)
s1.age = 20
print(s1.age)
运行结果：
AttributeError: can't set attribute qq hahaha 12四：类的设计
高内聚，低耦合。尽可能的__精细化设计__，减少相互干扰
开闭原则开闭原则（Open-Closed Principle，OCP）是指一个__软件实体（如类、模块和函数）__应该对扩展开放，对修改关闭。
就是不修改类或函数，而是添加类或函数
实现方法：
1.基于接口而非实现编程，即__父类不实现具体功能__
2.用多态替换if
单一职责原则单一职责原则（Single Responsibility Principle）：一个类（class）只负责一件事。如果一个类承担多个职责，那么它就会变得耦合起来。一个职责的变更会导致另一职责的变更。
注意：该原理不仅适用于类，而且适用于软件组件和微服务。
就是设计类或函数，功能要尽量单一，减少耦合
迪米特原则迪米特原则(Law of Demeter,LoD)， 一个对象应该对其他对象有最少的了解。
就是类尽量封装属性和方法，减少耦合
总结一下类的设计：
父类做接口不实现具体功能
使用多态代替if
类的属性和方法尽量封装
类和方法的功能尽量单一
