先看看面向对象-----在现如今的编程语言中大部分都已经具备了完善的面向对象思想。例如C++、java这两大主流编程语言。这两个是现如今使用量最大，且将面向对象发挥到极致的语言。

　　python面向的对象最主要的类--而python类中最主要包括 字段、方法、属性

　　先来看看如何创建一个python类

　　class Pager:

　　def __init__(self, current_page):

　　# 用户当前请求的页码(第一页、第二页...)

　　self.current_page = current_page

　　# 每页默认显示10条数据

　　self.per_items = 10

　　def start(self):

　　val = (self.current_page - 1) * self.per_items

　　return val

　　def end(self):

　　val = self.current_page * self.per_items

　　return val

　　tips: python中一个类只能有一个构造函数存在。定义多个构造方法时，实例化类只实例化最后的构造方法，

　　即后面的构造方法会覆盖前面的构造方法，并且需要更具最后一个构造方法的形式进行实例化

　　接下来分片看看类中的三大将

　　字段分为------普通字段 和 静态字段

　　普通字段-----(普通字段属于类对象拥有)

　　静态字段-----(静态字段属于当前类,静态字段在内存中只保存一份;普通字段在每个对象中都要保存一份)

　　class province:

　　#静态字段

　　country = "China"

　　def __init__(self,name):

　　#普通字段

　　self.name = name

　　#访问普通字段方法

　　obj = province("shan'xi")

　　print(obj.name)

　　#访问静态字段方法

　　print(province.country)

　　方法分为------普通方法、静态方法 和 类方法

　　普通方法：由对象调用;至少一个self参数;执行普通方法时，自动将调用该方法的对象赋值给self;

　　类方法： 由类调用;至少一个cls参数;执行类方法时，自动将调用该方法的类复制给cls;

　　静态方法：由类调用;无默认参数

　　class testFun:

　　#构造函数

　　def __init__(self,name):

　　self.name = name

　　def orderFunc(self):

　　"""普通方法，至少一个self参数 """

　　print("普通方法")

　　@classmethod

　　def classFunc(cls):

　　"""类方法，至少一个cls参数 """

　　print("类方法")

　　@staticmethod

　　def staticmethod():

　　"""静态方法，没有默认参数 """

　　print("静态方法")

　　#1.调用普通方法

　　test = testFun("xi'an") #创建对象

　　test.orderFunc()

　　#2.调用类方法

　　testFun.classFunc()

　　#3.调用静态方法

　　testFun.staticmethod()

　　属性------类的普通方法的变种

　　1:在普通方法的基础上添加 @property 装饰器;

　　2:属性仅有一个self参数;

　　3:调用时，无需括号

　　属性存在意义：访问属性时可以制造出和访问字段完全相同的假象

　　class testProtertyFun:

　　#构造函数

　　def __init__(self,name):

　　self.name = name

　　#定义属性

　　@property

　　def propertyFunc(self):

　　"""属性方法，至少一个self参数 """

　　print("属性方法")

　　test = testProtertyFun("xi'an")

　　#调用属性

　　test.propertyFunc

　　再来看几个案例，看看属性和方法的区别到底在哪一块

　　#对某一个数值进行改变，计算其开始与结束后的值。

　　class Pager:

　　def __init__(self, current_):

　　# 用户当前请求的页码(第一页、第二页...)

　　self.current_ = current_

　　# 每页默认显示10条数据

　　self.per_items = 10

　　@property

　　def start(self):

　　val = (self.current_ - 1) * self.per_items

　　return val

　　@property

　　def end(self):

　　val = self.current_ * self.per_items

　　return val

　　# ############### 调用 ###############

　　p = Pager(1)

　　p.start #就是起始值，即：m

　　p.end #就是结束值，即：n

　　属性两种定义方式(装饰器模式、静态字段)

　　装饰器方式：在类的普通方法上应用@property装饰器

　　tips:Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。( 如果类继object，那么该类是新式类 )

　　经典类，具有一种@property装饰器

　　class Goods:

　　@property

　　def price(self):

　　return "wupeiqi"

　　obj = Goods()

　　# 自动执行 @property 修饰的 price 方法，并获取方法的返回值

　　result = obj.price

　　新式类，具有三种@property装饰器

　　#新式类，具有三种@property装饰器

　　class NewerPropertyClass:

　　@property

　　def Func1(self):

　　print("@property")

　　@property

　　def Func2(self):

　　pass

　　#设置属性装饰器时，被设置的setter deleter必须有一个被property修饰的函数

　　@Func2.setter

　　def Func2(self,value):

　　newvalue = value

　　print("@property.setter")

　　@Func2.deleter

　　def Func3(self):

　　print("@property.deleter")

　　obj = NewerPropertyClass()

　　obj.Func1 # 自动执行 @property 修饰的 Func1 方法，并获取方法的返回值

　　obj.Func2 = 123 # 自动执行 @price.setter 修饰的 Func2 方法，并将 123 赋值给方法的参数

　　del obj.Func3 # 自动执行 @price.deleter 修饰的 Func3 方法

　　tips:综上新式类会将属性设置为对同一个操作分为：获取、修改、删除. 而Setter必须有个参数，保证可以传入参数值。且setter、deleter的函数必须有一个被@property修饰的函数

　　静态字段模式-------当使用静态字段的方式创建属性时，经典类和新式类无区别

　　class Foo:

　　def get_bar(self):

　　return 'wupeiqi'

　　#静态字段模式

　　BAR = property(get_bar)

　　obj = Foo()

　　# 自动调用get_bar方法，并获取方法的返回值

　　reuslt = obj.BAR

　　print(reuslt)

　　property的构造方法中有个四个参数

　　第一个参数是方法名，调用 对象.属性 时自动触发执行方法

　　第二个参数是方法名，调用 对象.属性 = XXX 时自动触发执行方法

　　第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法

　　第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

　　看这个例子：

　　class TestClass:

　　def get_bar(self):

　　print("get_bar")

　　return ("wupeiqi")

　　# *必须两个参数

　　def set_bar(self, value):

　　print("set_bar:" + value)

　　return ('set value' + value)

　　def del_bar(self):

　　value = 0

　　print("del_bar:" + str(value))

　　return (value)

　　BAR = property(get_bar,set_bar,del_bar,"description...")

　　obj = TestClass()

　　obj.BAR # 自动调用第一个参数中定义的方法：get_bar

　　obj.BAR = "alex" # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入

　　print(obj.BAR.__doc__)#调用 对象.属性.__doc__ ，

　　# 此参数是该属性的描述信息(此处调用需要放在del obj.BAR这句之前)

　　del obj.BAR # 自动调用第三个参数中定义的方法：del_bar方法

　　类成员的修饰符 (公有成员---私有成员)

　　公有成员，在任何地方都能访问

　　私有成员，只有在类的内部才能方法;私有成员命名时，前两个字符是下划线 __(特殊成员除外，例如：__init__、__call__、__dict__等)

　　如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问(如：obj._C__foo)，不建议强制访问私有成员。

　　静态字段：

　　公有静态字段：类可以访问;类内部可以访问;派生类中可以访问

　　私有静态字段：仅类内部可以访问

　　访问类的公有成员字段

　　class CClass:

　　name = "公有静态字段"

　　def func(self):

　　print (CClass.name)

　　class DClass(CClass): #DClass继承CClass

　　def show(self):

　　print (CClass.name)

　　CClass.name # 类访问

　　obj = CClass()

　　obj.func() # 类内部可以访问

　　obj_son = DClass()

　　obj_son.show() # 派生类中可以访问

　　访问类的公有成员字段

　　class CClass:

　　__name = "私有静态字段"

　　def func(self):

　　print (CClass.name)

　　class DClass(CClass): #DClass继承CClass

　　def show(self):

　　print (CClass.name)

　　CClass.name # 类访问==> 错误

　　obj = CClass()

　　obj.func() # 类内部可以访问 ==> 正确

　　obj_son = DClass()

　　obj_son.show() # 派生类中可以访问 ==> 错误

　　普通字段

　　公有普通字段：对象可以访问;类内部可以访问;派生类中可以访问

　　私有普通字段：仅类内部可以访问;

　　访问类的公有字段

　　class AClass:

　　def __init__(self):

　　self.foo="公有字段"

　　def func(self):

　　print (self.foo) #　类内部访问

　　class BClass(AClass):

　　def show(self):

　　print (self.foo) #派生类中访问

　　obj = AClass()

　　obj.foo # 通过对象访问

　　obj.func() # 类内部访问

　　obj_son = BClass();

　　obj_son.show() # 派生类中访问

　　class AClass:

　　def __init__(self):

　　self.__foo = "私有字段"

　　def func(self):

　　print (self.foo) #　类内部访问

　　class BClass(AClass):

　　def show(self):

　　print (self.foo) #派生类中访问

　　obj = AClass()

　　obj.__foo # 通过对象访问 ==> 错误

　　obj.func() # 类内部访问 ==> 正确

　　obj_son = BClass();

　　obj_son.show() # 派生类中访问 ==> 错误

　　方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用;---非要访问私有属性的话，可以通过 对象._类__属性名

　　还有几个类的特殊字段需要清楚的

　　1. __doc__ 表示类的描述信息

　　class Foo:

　　""" 描述类信息，这是用于看片的神奇 """

　　def func(self):

　　pass

　　print (Foo.__doc__)

　　#输出：类的描述信息

　　2. __module__ 和 __class__

　　__module__ 表示当前操作的对象在那个模块

　　__class__ 表示当前操作的对象的类是什么

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　class C:

　　def __init__(self):

　　self.name = 'wupeiqi'

　　from lib.aa import C

　　obj = C()

　　print (obj.__module__) # 输出 lib.aa，即：输出模块

　　print (obj.__class__) # 输出 lib.aa.C，即：输出类

　　3. __init__

　　# 构造方法，通过类创建对象时，自动触发执行。

　　class Foo:

　　def __init__(self, name):

　　self.name = name

　　self.age = 18

　　obj = Foo('wupeiqi') # 自动执行类中的 __init__ 方法

　　4. __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

　　#注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，

　　#所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

　　class Foo:

　　def __del__(self):

　　pass5. __call__

　　# 对象后面加括号，触发执行。

　　#注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

　　class Foo:

　　def __init__(self):

　　pass

　　def __call__(self, *args, **kwargs):

　　print ('__call__')

　　obj = Foo() # 执行 __init__

　　obj() # 执行 __call__

　　6. __dict__

　　# 类或对象中的所有成员

　　#上文中我们知道：类的普通字段属于对象;类中的静态字段和方法等属于类，即

　　class Province:

　　country = 'China'

　　def __init__(self, name, count):

　　self.name = name

　　self.count = count

　　def func(self, *args, **kwargs):

　　print ('func')

　　# 获取类的成员，即：静态字段、方法、

　　print (Province.__dict__)

　　# 输出：{'country': 'China', '__module__': '__main__', 'func': , '__init__': , '__doc__': None}

　　obj1 = Province('HeBei',10000)

　　print (obj1.__dict__)

　　# 获取 对象obj1 的成员

　　# 输出：{'count': 10000, 'name': 'HeBei'}

　　obj2 = Province('HeNan', 3888)

　　print (obj2.__dict__)

　　# 获取 对象obj1 的成员

　　# 输出：{'count': 3888, 'name': 'HeNan'}

　　7. __str__

　　# 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

　　class Foo:

　　def __str__(self):

　　return 'wupeiqi'

　　obj = Foo()

　　print (obj)

　　# 输出：wupeiqi

　　8、__getitem__、__setitem__、__delitem__

　　#用于索引操作，如字典。以上分别表示获取、设置、删除数据

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　class Foo(object):

　　def __getitem__(self, key):

　　print ('__getitem__',key)

　　def __setitem__(self, key, value):

　　print ('__setitem__',key,value)

　　def __delitem__(self, key):

　　print ('__delitem__',key)

　　obj = Foo()

　　result = obj['k1'] # 自动触发执行 __getitem__

　　obj['k2'] = 'wupeiqi' # 自动触发执行 __setitem__

　　del obj['k1'] # 自动触发执行 __delitem__

　　9、__getslice__、__setslice__、__delslice__

　　# 该三个方法用于分片操作，如：列表

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　class Foo(object):

　　def __getslice__(self, i, j):

　　print ('__getslice__',i,j)

　　def __setslice__(self, i, j, sequence):

　　print ('__setslice__',i,j)

　　def __delslice__(self, i, j):

　　print ('__delslice__',i,j)

　　obj = Foo()

　　obj[-1:1] # 自动触发执行 __getslice__

　　obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__

　　del obj[0:2] # 自动触发执行 __delslice__

　　10. __iter__

　　#用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

　　#第一步

　　class Foo(object):

　　pass

　　obj = Foo()

　　for i in obj:

　　print (i)

　　# 报错：TypeError: 'Foo' object is not iterable

　　#第二步

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　class Foo(object):

　　def __iter__(self):

　　pass

　　obj = Foo()

　　for i in obj:

　　print (i)

　　# 报错：TypeError: iter() returned non-iterator of type 'NoneType'

　　#第三步 郑州做人流多少钱 http://mobile.120zzzzyy.com/

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　class Foo(object):

　　def __init__(self, sq):

　　self.sq = sq

　　def __iter__(self):

　　return iter(self.sq)

　　obj = Foo([11,22,33,44])

　　for i in obj:

　　print (i)

　　#以上步骤可以看出，for循环迭代的其实是 iter([11,22,33,44]) ，所以执行流程可以变更为：

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　obj = iter([11,22,33,44])

　　for i in obj:

　　print (i)

　　#For循环语法内部

　　#!/usr/bin/env python

　　# -*- coding:utf-8 -*-

　　obj = iter([11,22,33,44])

　　while True:

　　val = obj.next()

　　print (val)

　　#11. __new__ 和 __metaclass__

　　#阅读以下代码：

　　class Foo(object):

　　def __init__(self):

　　passobj = Foo() # obj是通过Foo类实例化的对象

　　#上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。

　　#如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。

　　print (type(obj)) # 输出： 表示，obj 对象由Foo类创建

　　print (type(Foo)) # 输出： 表示，Foo类对象由 type 类创建

　　#所以，obj对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。

　　#那么，创建类就可以有两种方式：

　　#a). 普通方式

　　class Foo(object):

　　def func(self):

　　print ('hello wupeiqi')

　　#b).特殊方式(type类的构造函数)

　　def func(self):

　　print ('hello wupeiqi')

　　Foo = type('Foo',(object,), {'func': func})

　　#type第一个参数：类名

　　#type第二个参数：当前类的基类

　　#type第三个参数：类的成员

　　# 类 是由 type 类实例化产生

　　#那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类?类又是如何创建对象?

　　#答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。

　　class MyType(type):

　　def __init__(self, what, bases=None, dict=None):

　　super(MyType, self).__init__(what, bases, dict)

　　def __call__(self, *args, **kwargs):

　　obj = self.__new__(self, *args, **kwargs)

　　self.__init__(obj)

　　class Foo(object):

　　__metaclass__ = MyType

　　def __init__(self, name):

　　self.name = name

　　def __new__(cls, *args, **kwargs):

　　return object.__new__(cls, *args, **kwargs)

　　# 第一阶段：解释器从上到下执行代码创建Foo类

　　# 第二阶段：通过Foo类创建obj对象

　　obj = Foo()