面向对象：
面向对象就不像面向过程那样按照功能划分模块了，它所关注的是软件系统有哪些参与者，把这些参与者称为对象，找出这些软件系统的参与者也就是对象之后，分析这些对象有哪些特征、哪些行为，以及对象之间的关系，所以说面向对象的开发核心是对象
类
类是对象的类型，具有相同属性和行为事物的统称。类是抽象的，在使用的时候通常会找到这个类的一个具体存在
对象
万物皆对象，对象拥有自己的特征和行为。
类和对象的关系
类是对象的类型，对象是类的实例。类是抽象的概念，而对象是一个你能够摸得着，看得到的实体。二者相辅相成，谁也离不开谁
创建和使用类
定义类：
class 类名():
#文档说明
属性
方法
注意：类名要满足标识符命名规则，同时要遵循大驼峰命名习惯
例如：
class Person():
'''这是一个人类'''
country = '中国' #声明类属性，并且赋值
#实例属性同构造方法来声明
#self不是关键字，代表的是当前对象
def __init__(self,name,age,sex): #构造方法
#构造方法不需要调用，在实例化的时候自动调用
self.name = name
self.age = age
self.sex = sex
#创建普通方法
def getName(self):
print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}') #在方法里面使用实例属性
#实例化对象
people01 = Person('joe',18,'男') #在实例化的时候传参
#通过对象调用实例方法
people01.getName()
结果为：
我的名字叫:joe,年龄是:18,性别是:男,我来自:中国
类的属性分类
访问属性
class Person():
country = '中国'
def __init__(self,name,age,sex):
self.name =name
self.age = age
self.sex = sex
def getName(self):
print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')
people01 = Person('joe',18,'男')
print(people01.name) #通过对象名.属性名，访问实例属性(对象属性)
print(people01.age)
print(people01.sex)
结果为：
joe
18
男
针对类的属性的一些方法
可以使用点实例化对象名+.来访问对象的属性，也可以使用以下函数的方式来访问属性
class Person():
country = '中国'
def __init__(self,name,age,sex):
self.name =name
self.age = age
self.sex = sex
def getName(self):
print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')
people01 = Person('joe',18,'男')
1.访问对象的属性 getattr(obj, name[, default])
print(getattr(people01,'name'))
结果为：
joe
2.检查是否存在一个属性hasattr(obj,name)，存在为True，不存在为False
print(hasattr(people01,'name'))
结果为：
True
3.设置一个属性setattr(obj,name,value) 。如果属性不存在，会创建一个新属性
print(setattr(people01,'name','susan')) #不存在返回None
print(people01.name)
结果为：
None
susan
4.删除属性delattr(obj, name)
delattr(people01,'name')
print(people01.name) #在此print执行会报错
注意：name需要加单引号,obj为实例化对象名称
内置属性
class Person():
country = '中国'
def __init__(self,name,age,sex):
self.name =name
self.age = age
self.sex = sex
def getName(self):
print(f'我的名字叫:{self.name},年龄是:{self.age},性别是:{self.sex},我来自:{Person.country}')
people01 = Person('joe',18,'男')
1.__dict__ : 类的属性（包含一个字典，由类的属性名:值组成） 实例化类名.__dict__
print(people01.__dict__)
结果为：
{'name': 'joe', 'age': 18, 'sex': '男'}
2.__doc__ :类的文档字符串 (类名.)实例化类名.__doc__
print(people01.__doc__)
结果为：
这是一个人类
3.__name__: 类名,实现方式 类名.__name__
print(Person.__name__)
结果为：
Person
4.__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
print(Person.__bases__)
结果为：
(<class 'object'>,)
_ _ init _ _()构造方法和self
_ _ init _ ()是一个特殊的方法属于类的专有方法，被称为类的构造函数或初始化方法，方法的前面和后面都有两个下划线。
这是为了避免Python默认方法和普通方法名称的冲突。每当创建类的实例化对象的时候， _ init _ _（）方法都会默认被运行。作用就是初始化已实例化后的对象。
在方法定义中，第一个参数self是必不可少的。类的方法和普通的函数的区别就是self，self并不是Python的关键字，只是按照惯例和标准的规定，推荐使用self。
_ _ name _ _
_ _ name _ _:如果放在Modules模块中，表示的是模块的名字，如果放在class类中，表示的是类的名字
_ _ main _ _:模块，xxx.py文件本身被直接执行时，对应的模块名就是 _ _ main _ _了
可以在 if _ _ name _ _ == " _ _ main _ _":中添加自己想要的，用于测试模块，演示模块用法等代码作为模块，被别的Python程序导入时，模块名就是本身文件名了。
继承
程序中定义一个class的时候，可以从某个现有的class继承，新的class成为子类(Subclass)，而被继承的class称之为基类、父类或超类。子类继承了其父类所有属性和方法，同事还可以定义自己的属性和方法。
例如：
#声明一个父类
class Animal():
def __init__(self,name,food):
self.name = name
self.food = food
def eat(self):
print('%s爱吃%s'%(self.name,self.food))
#声明一个子类继承Animal
class Dog(Animal):
def __init__(self,name,food,drink):
super(Dog,self).__init__(name,food)
#子类自己的属性
self.drink = drink
#子类自己的方法
def drinks(self):
print('%s爱吃%s'(self.name,self.food,self.drink))
class Cat(Animal):
def __init__(self,name,food,drink):
super(Cat,self).__init__(name,food)
#子类自己的属性
self.drink = drink
#子类自己的方法
def drinks(self):
print(f'%s爱吃%s'(self.name,self.food,self.drink))
#重写父类的eat
def eat(self):
print('%s特别爱吃%s'%(self.name,self.food))
dog1 = Dog('金毛','骨头','可乐')
dog1.eat()
dog1.drinks()
cat1 = Cat('波斯猫','鱼','雪碧')
cat1.eat()
cat1.drinks()
结果为：
金毛爱吃骨头
金毛爱喝可乐
波斯猫特别爱吃鱼
波斯猫爱喝雪碧
多继承
语法格式如下：
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
注意：圆括号中父类的顺序，如果继承的父类中有相同的方法名，而在子类中使用时未指定，python将从左到右查找父类中是否包含方法
class A():
def a(self):
print('我是A里面的a方法')
class B():
def b(self):
print('我是B里面的b方法')
def a(self):
print('我是B里面的a方法')
class C():
def c(self):
print('我是C里面的c方法')
class D(A,B,C):
def d(self):
print('我是D里面的d方法')
dd = D()
dd.d() #调用自己的方法
dd.c()
dd.a()
结果为：
我是D里面的d方法
我是C里面的c方法
我是A里面的a方法
super()重写
class Animal():
def __init__(self,name,food):
self.name = name
self.food = food
def eat(self):
print('%s喜欢吃%s'%(self.name,self.food))
def shout(self):
print(self.name,'喵喵')
#编写一个Dog类继承Animal
class Dog(Animal):
def __init__(self,name,food):
super().__init__(name,food)
def shout(self): #重写父类的shout方法，喵喵叫不适合dog的实际情况
print(self.name,'汪汪')
#编写一个Cat类继承Animal
class Cat(Animal):
def __init__(self,name,food):
super().__init__(name,food)
#对于Dog和Cat来说Animal是他们的父类，而Dog和Cat是Animal的子类。
#子类获得了父类的全部功能，自动拥有了父类的eat()方法
dog = Dog('小狗','骨头')
dog.shout()
结果为：
小狗 汪汪
类方法用@classmethod装饰器来表示
类方法可以被类和对象一起访问，而对象方法只可以被对象方法访问
class Dog(object):
tooth = 10 #定义一个类属性
@classmethod #装饰器，添加其他的功能：让对象方法变成类方法
def info_print(self):
print(1)
@classmethod
def info_print1(cls): #cls表示类本身
#在方法里面去使用类本身去调用方法时可以直接使用cls
print(cls.tooth)
wangcai = Dog()
wangcai.info_print() #类方法
Dog.info_print()
Dog.info_print1() #10,用类去调用类属性得到的属性值
结果为：
1
1
10
静态方法
去掉不需要的参数传递，有利于减少不必要的内存占用和性能消耗
静态方法是可以被类和对象一起访问的
class Dog(object):
@staticmethod
def info_print(): #小括号中没有self，也没有cls
print("这是一个静态方法！")
wangcai = Dog()
wangcai.info_print()
Dog.info_print()
结果为：
这是一个静态方法！
这是一个静态方法！
