面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。
而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：
std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }
而处理学生成绩可以通过函数实现，比如打印学生的成绩：
def print_score(std):
print('%s: %s' % (std['name'], std['score']))
如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))
给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()
类与实例：
面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
仍以Student类为例，在Python中，定义类是通过class关键字：
class Student(object):
pass
class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：
>>> bart = Student()
>>> bart
<__main__.Student object at 0x10a67a590>
>>> Student
<class '__main__.Student'>
可以看到，变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。
可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：
>>> bart.name = 'Bart Simpson'
>>> bart.name
'Bart Simpson'
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：
>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson'
>>> bart.score
59
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数
类的属性：
# class OldboyStudent:
# school = 'oldboy' #类的数据属性
# def learn(self): #类的函数属性
# print('is learning')
#
# def eat(self):
# print('is eating')
# print('======>')
#类体的代码在类定义阶段就会执行,理所应当会产生类的名称空间，用__dict__属性查看
# print(OldboyStudent.__dict__)
# print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.__dict__['learn'])
#类的属性操作
# print(OldboyStudent.school)
# print(OldboyStudent.learn)
#
# def func():pass
# print(func)
# OldboyStudent.learn(123)
# OldboyStudent.x=1111111111111111111111
# OldboyStudent.school='Oldboy'
# del OldboyStudent.school
# print(OldboyStudent.__dict__)
# OldboyStudent.__dict__['x']=1111111111111111111111
#产生程序中的对象：类名加括号，调用类，产生一个该类的实际存在的对象，该调用过程称为实例化，产生的结果又可以成为实例
# class OldboyStudent:
# school = 'oldboy'
# #obj1,'李大炮',18,'女'
# def __init__(self,name,age,sex): #在实例化时,产生对象之后执行
# # if not isinstance(name,str):
# # raise TypeError('名字必须是字符串类型')
# self.name=name
# self.age=age
# self.sex=sex
# # return None #__init__方法必须返回None
# #obj1.name='李大炮'
# #obj1.age=18
# #obj1.sex='女'
#
# def learn(self):
# print('is learning')
#
# def eat(self):
# print('is eating')
# obj1=OldboyStudent('李大炮',18,'女') #
# 分两步：
# 第一步：先产生一个空对象obj1
# 第二步：OldboyStudent.__init__(obj1,'李大炮',18,'女')
# print(obj1.__dict__)
#
# obj2=OldboyStudent('张全蛋',28,'男')
# obj3=OldboyStudent('牛榴弹',18,'女')
#
# print(obj2.__dict__)
# print(obj3.__dict__)
#
#
#
# print(obj1.name)#obj1.__dict__['name']
#
# obj1.name='大炮'
# print(obj1.__dict__)
# obj1.__dict__['name']='炮'
# print(obj1.name)
#
# obj1.__dict__.pop('name')
# # print(obj1.name)
# print(obj1.__dict__)
#继承的基本形式
当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
定义
# class ParentClass1(object): #定义父类
# pass
#
# class ParentClass2: #定义父类
# pass
#
# class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
# pass
#
# class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
# pass
#
#
#
#
# print(SubClass1.__bases__)
# print(SubClass2.__bases__)
# print(ParentClass1.__bases__)
比如，我们已经编写了一个名为Animal的class，有一个run()方法可以直接打印：
class Animal(object):
def run(self):
print('Animal is running...')
当我们需要编写Dog和Cat类时，就可以直接从Animal类继承：
class Dog(Animal):
pass
class Cat(Animal):
pass
对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Dog类似。
继承有什么好处？最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法：
dog = Dog()
dog.run()
cat = Cat()
cat.run()
运行结果如下：
Animal is running...
Animal is running..
子类方法重用父类的功能
# class OldboyPeople:
# school = 'oldboy'
# def __init__(self,name,age,sex):
# self.name=name
# self.age=age
# self.sex=sex
#
# def eat(self):
# print('is eating')
# def teach(self):
# print('这是父类的teach')
#
# class OldboyTeacher(OldboyPeople):
# def __init__(self,name,age,sex,salary,title):
# # OldboyPeople.__init__(self,name,age,sex)
# #在Python2中需要写全：super(OldboyTeacher,self)
# super().__init__(name,age,sex)
# self.salary=salary
# self.title=title
#
# def teach(self):
# # OldboyPeople.teach(self)
# super().teach()
# print('%s is teaching' %self.name)
# print(OldboyTeacher.mro())
#
# egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')
# # print(egon_obj.title)
# # print(egon_obj.__dict__)
# egon_obj.teach()
总结：
1 继承的功能之一：解决类与类之间的代码重复问题
2 继承是类与类之间的关系，是一种，什么是什么的关系
3 在子类派生出的新的属性，已自己的为准
4 在子类派生出的新的方法内重用父类的功能的方式：指名道姓法OldboyPeople.__init__
这种调用方式本身与继承是没有关系
