面向对象编程简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
class Person:
# 类属性
__privateCount = 1 #私有
publicCount = 2 #公共
def __init__(self,name,age):
#创建属性并给属性赋值
self.name = name
self.age = age
def readCount(self):
print('%d 私有变量'%self.__privateCount)
print('%d 公有变量'%self.publicCount)
class Teacher(Person):
def teach(self):
print('老师教学生')
class Student(Person):
# 重载构造方法
def __ init __(self,name,idno):
self.name = name
self.idno = idno
# 重载eat方法
def eat(self):
self.__run()
print('%s吃饭'%self.name)
# 私有方法，外部无法调用
def __run(self):
print('吃完饭跑步')
1.类
类是抽象的模板，通过类实例化无数的对象。就相当于类是工厂里生产的模具，而对象则是模具下生产的商品。
类的声明:
通过class声明一个类，缩进表示一个类的作用域，类名通常是大写开头的单词。如果有继承的类，通过小括号中引用要继承的类。表示该类的继承，如果没有填写继承类，默认继承object类，这是所有类最终都会继承的类。
2.对象
#继承父类构造方法，必须传递父类构造方法中需要传递的参数
teacher = Teacher('王老师','42')
#输出：老师教学生---自己的方法
teacher.teach()
#输出：吃饭 --- 继承父类方法
teacher.eat()
#输出：王老师 ---属性的访问
teacher.name
# age 属性销毁
del teacher.age
student = Student('张三','190614')
#输出：学生吃饭---重载
student.eat()
#输出：190614 ---属性的访问
student.idno
- 对象（实例）属性：
可以通过self或者对象进行创建和访问。在构造函数中self.name和self.age创建name属性和age属性。
创建原则：如果属性不存在，就会创建属性，存在的话，就修改属性值。
属性的创建和访问也可以使用内置函数进行：
setattr(对象名,属性名,属性值)
getattr(对象名,属性名)
- 类属性（变量）：
直接在类中且在函数体外定义的变量,是类属性或者类变量。定义之后虽然这个变量属于类所有，但类的所有对象都可以访问到。
注意：千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性
- self 含义：
在类内部方法中引用的self,表示的是对象而不是类。如方法声明中的第一参数self表示的是对对象的引用，其指向的也是对象的地址。
也可以这样理解self：方法的调用，是通过对象来进行，可以把self,理解为把当前对象当成参数传递到方法内部，进行引用。通过self,在方法内部，访问对象的属性和方法。
注意：类中的方法声明，第一个参数必须显示的引用self,调用时忽略该参数的传递。
- 私有方法和属性的声明：
通过双下划线__来声明,只允许这个类本身进行访问。例如Person类中的__privateCount属性就是私有属性，在该类中可以使用，引用时必须带有双下划线。在外部或者说别的类中，通过对象去引用这个私有变量（属性）会报错，找不到改变量（属性）。
3.继承
继承是面向对象的重要特征之一，通过继承可以实现方法和属性的重用。承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
如：Person类就是父类或者说基类，Teacher 和 Student 类就是子类或者说派生类。
父类的属性和方法都会被子类继承，在子类中可以直接进行使用。如：Teacher 类中，teacher对象可以直接使用eat()方法和name和age属性。
方法的重载：
在父类中继承下来的方法，可以同过重写，来进行改造满足自己的实际需求。这种方式叫做重载。
方法在调用时：如果子类中没有进行方法的重写就会调用父类的方法。重写之后，会直接调用重写后的方法。
注意：子类如果重写了构造函数，那么父类的构造函数失效，在父类构造函数中生成的属性也是失效的。如：Student类，Student中只有name和idno属性，而Teacher类继承了父类的name和age属性。
多重继承：继承多个父类，在类声明中，父类之间用逗号隔开（横向）
多层继承： C类继承自B类，B类继承自A类，以此类推，就是多层继承
4.多态
多态也是面向对象重要的特征之一。通过一个单独的例子，来理解多态。
class Person:
def eat(self):
print('吃饭')
class Teacher(Person):
def eat(self):
print('老师吃饭')
class Student(Person):
def eat(self):
print('学生吃饭')
class Me:
def runEat(self,person):
person.eat()
# 调用演示
teacher = Teacher()
student = Student()
me = Me()
# 输出：老师吃饭
me.runEat(teacher)
#输出：学生吃饭
me.runEat(student)
通过上面的例子可以看到,任何依赖Person 作为参数的函数或者方法都可以不加修改的正常运行，并调用各自类中的eat方法,这就是多态的特性。
无需知道传入的确切类型，由运行时决定，调用方只管调用，不管细节。对于Python这样的动态语言来说，则不一定需要传入Person类型。我们只需要保证传入的对象有一个eat()方法。
动态语言的“鸭子类型”：它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
注：其实我们我们可以把runEat方法的参数person,当成是一个变量，Python中的变量并没有限定其数据类型，都是在运行时决定的，我们只要保证person的实参，有run()方法即可。
与OC 面向对象多态的区别：OC的多态必须有继承关系，而且runEat方法的参数person必须指定数据类型Person,这样才可以形成多态。
由于继承关系，teacher 对象既属于Teacher 类也是属于Person 类的，可以通过isinstance(对象名,类名)来进行验证。
5.引用计数
Python的内存回收机制是通过引用计数来实现的。当对象的引用计数变为0时，它会被回收，但不是立即的，有解释器在适当的时机，将垃圾对象的占用的内存空间回收。
对象被创建时，引用计数为1。该对象每被引用一次引用计数都会加1。当对象的引用减少时，引用计数减1。引用计数为0时，对象释放。
单下划线、双下划线、头尾双下划线说明：
_count: 表示该变量是protected类型，只能在其本身和子类中访问调用。
__count: 表示该变量是private类型，只能在这个类本身中进行访问。
__ init __ :一般是系统保留定义的名字。
