python 同时支持面向对象编程和函数式编程的语言
python面向对象的主题围绕 类 和 类实例 两个主题。
面向对象三大特性：封装、继承和多态
概念
1.对象:类的实例。对象具有两个特征：状态与行为。
2.类：用来描述具有相同的属性和方法的对象的集合，类的组成=方法+行为
3.抽象：对现实世界问题和实体的本质表现，行为和特征建模，建立一个相关的子集，可以用于描述程序结构，从而实现这种模型。
4.封装：对属性和方法的载体类,只能通过其提供的接口(方法)来访问,而把实现细节隐藏起来.python的类属性都是公开的。
5.继承：描述了子类属性从祖先类继承这样一种方式。
6.多态：同一消息可以根据发送对象的不同而采用多种不同的行为方式。
创建类
python 类是使用class关键词来创建，即关键词+类名
class ClassName():
class_suit
- class_suit(类实体由类成员、方法、数据属性组成)
- 类中的函数第一个参数必须是self，
-
类分为经典类和新式类（如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。以后慢慢推荐用新式类写）
QQ20170709-223954@2x.png
类的成员、成员修饰符、类的特殊成员
class Province:
country ＝ '中国' # 静态字段
def __init__(self, name):
self.name = name # 普通字段
obj = Province('河北省') # 直接访问普通字段
print obj.name
Province.country # 直接访问静态字段
由上图可是：
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份
应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段
方法：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
class E():
i=1
def run(self):
E.i +=1
print('{0} is run ordinary method'.format(E.i))
@staticmethod
def eat():
E.i +=1
print('{0} is eat static method'.format(E.i))
@classmethod
def fool(cls):
E.i +=1
print('{0} is fool class method '.format(E.i))
e = E()
e.run()
E.eat()
E.fool()
输出
2 is run ordinary method
3 is eat static method
4 is fool class method
属性:相当一个bean里面的方法，做比较好的封装一层,创建属性有2中方式，一种是修饰器，一种是静态字段，装饰器方式针对经典类和新式类又有所不同，下面例子针对新式类（图中-今天方式创建 改为 静态方式创建）
self
引用地址：http://m.blog.csdn.net/happyjxt/article/details/50760467
class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self):
print self.name
print self.age
obj1 = Foo('wupeiqi', 18)
obj1.detail() # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail() # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78
继承
· python是支持多继承的语言
· python主要继承的多个类时，寻找的继承的方法主要2种，分别是：深度优先和广度优先
1、当类是经典类时，多继承情况下，会按照深度优先方式查找
2、当类是新式类时，多继承情况下，会按照广度优先方式查找
eg1、
class A():
def __init__(self):
print('A start')
print('A level')
class B(A):
def __init__(self):
print('B start')
print('B level')
class C(A):
def __init__(self):
print('C start')
print('C level')
class D(B,C):
def __init__(self):
print('D start')
print('D level')
d=D();
以上程序输入
D start
D level
假设把D类改造如下，其他没有变化：
class D(B,C):
pass
程序输入
B start
B level
原因：程序首先在D类寻找init方法，程序发现没有该方法后则寻找第一个父类的init的方法。
经典类寻找
再次把B类改造如下，其他的没有变化
class B(A):
pass
程序输入
A start
A level
原因：查找顺序：D --> B --> A --> C
新式类寻找
再次把A类改造成新式类，其他没有变化
class A(object):
def __init__(self):
print('A start')
print('A level')
程序输入
C start
C level
原因：查找顺序：D --> B --> C --> A
备注：python３.０后多继承来讲，类都是新式类，所以继承顺序统一是广式优先进行
对于父类和子类重名时，又想使用父类的名字，这时可以使用关键词super-只适合用于新式类
'''
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
'''
1、super只能用于新式类
2、super不是父类，而是继承顺序的下一个类
3、 Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用，而且保证每个父类函数
只调用一次（如果每个类都使用super）
class A(object):
def __init__(self):
print('A start')
print('A level')
class B(A):
def __init__(self):
print('B start')
print('B level')
super(B, self).__init__()
class C(A):
def __init__(self):
print('C start')
print('C level')
super(C, self).__init__()
class D(C,B):
def __init__(self):
print('D start')
print('D level')
super(D, self).__init__()
d=D();
输出结果
D start
D level
C start
C level
B start
B level
A start
A level
原因：新式类的寻找顺序是D --> B --> C --> A，那么程序执行D类的init方法中触发super关键词，D的继承关系中的下一个类是B,那么把super.init转化为B.init执行。在执行过程中触发了super关键词，D的继承关系中B的下一个类是C，那么super.init转化为C.init执行
封装
封装：你钱包的有多少钱
封装主要的原因：保护隐私和隔离复杂度
在python中用双下划线的方式实现隐藏属性,还有用property方式
每一个类的成员而言都有两种形式,
1、公有成员，在任何地方都能访问，类内部可以访问；派生类中可以访问
2、私有成员，只有在类的内部才能方法
私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：init、call、dict等）
class C:
def __init__(self):
self.name = '公有字段'
self.__foo = "私有字段"
备注：本文由部分引用。此文章只是用来学习
