面向对象编程
面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）
OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。
面向对象的几个核心特性如下
Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法
Object 对象
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同
Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法
Inheritance 继承
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作,
他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”,
因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定
类的语法
class Foo(object): # Foo为类名，括号内的表示是这个类继承自哪个类，这里的object是所有类的基类，一个类可以继承自多个类 ''' 类的说明文档，Python会自动将这里面内容赋值给类的变量__doc__ ''' class_var1 = 'var1' # 类的变量，它属于类本身，而不是类的对象，可以通过类名.变量名的方式进行调用，也可以对象.变量名调用，前提是，没有同名的实例变量 def __init__(self, arg, arg2): ''' 初始化方法，有点类似于java语言的构造方法，在创建类的对象的时候自动调用 :param var2: 参数，初始化方法也可以 :return: ''' self.var2 = arg # 对象的变量，属于对象不属于类，只能通过对象.变量名的方式调用 self.__var3 = arg # 对象的变量，只能在内部调用，不能通过对象.变量名的方式调用，并且不能被继承 def func1(self, arg): ''' 方法 1、方法属于类（也就是在实例化的时候不会像对象的变量一样单独开辟内存空间） 2、self表示类的对象本身，当我们通过对象名.方法()来调用的时候，解释器会自动将对象作为第一个参数传给方法，方法名.方法(对象名) :return: ''' # 方法体，方法体可以通过self.关键字调用对象的变量和方法 self.__var3 = arg # 方法可以调用私有变量和方法 def __func2(self): ''' 私有方法，和私有变量一样，不能被继承和外部调用 :return: ''' pass class Foo2(Foo): def __init__(self, arg, arg2): ''' 1、这里调用了父类的初始化方法，特别注意由于“__变量名”表示的私有方法， 2、这里尽管调用了父类的构造方法，__var3变量作为父类的私有方法，子类在没有重新定义之前依然没有这个变量，这点要特别注意 :param arg: :param arg2: :return: ''' super(Foo2, self).__init__(arg, arg2) self.__var3 = arg2 # 由于__var3是父类的私有方法，尽管调用了父类的初始化方法，子类依然不会有，所以依然需要重新定义
面向对象的三大特性是指：封装、继承和多态。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承就是，一个类可以通过继承另一个类的方式，拥有另一个类的方法和变量等。和现实中的继承是一样一样的。
class Role(object): def __init__(self, name): self.name = name def get_name(self): return self.name class Teacher(Role): def __init__(self, name, course): ''' 如果父类已经有一个方法，子类也有一个同名的方法，就会覆盖掉父类的方法，专业术语叫做重写 ''' super(Teacher, self).__init__(name) # 通过super这种语法可以调用父类的方法和变量，这里调用父类的构造方法，初始化name self.course = course # 这个变量是父类所没有的 def say(self): # 定义父类的 print('My name is %s, i am a English teather' %self.name) if __name__ == '__main__': lisi = Teacher('lisi', 'English') # 定义Teacher的实例 print(lisi.name) # name这个变量是子类通过继承的方式获取的 print(lisi.get_name()) # 继承自父类的方法 lisi.say() # 子类特有的方法
多态是为了接口重用，是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数；
class Foo: def __init__(self, name): self.name = name def ord_func(self): """ 定义普通方法，至少有一个self参数 """ # print self.name print '普通方法' @classmethod def class_func(cls): """ 定义类方法，至少有一个cls参数 """ print '类方法' @staticmethod def static_func(): """ 定义静态方法 ，无默认参数""" print '静态方法' # 调用普通方法 f = Foo() f.ord_func() # 调用类方法 Foo.class_func() # 调用静态方法 Foo.static_func() 方法的定义和使用
成员修饰符__
通过两个下划线“__”，修饰的都是私有，仅仅只是内部进行调用，并且不能继承（要特别注意，有中很贴切的说法形容私有，父亲的钱、房子儿子是共有的可以继承，父亲的女人是私有的，不可以继承），包裹类变量，实例变量，方法等都可以使用__修饰变成私有的
class Foo(object): __name = 'name' # 私有类变量 def __init__(self): self.__age # 私有成员变量 def __funce(self): # 私有方法 pass
特殊成员
有一些成员不需要定义，解释器会自动加载，可以理解为这些都是继承自object
__init__：
构造方法，这里就不多说了，通过类创建对象时，自动触发执行
__doc__：
表示类的描述信息
class Foo(object): ''' 类的描述信息 ''' def __init__(self): pass if __name__ == '__main__': print(Foo.__doc__)
__module__和__class__
__module__ 表示这个或对象属于哪个模块
__class__ 表示对象属于哪个类
class Foo(object): ''' 类的描述信息 ''' def __init__(self): pass if __name__ == '__main__': print(Foo.__module__) obj = Foo() print(obj.__class__)
__del__
析构方法，当对象在内存中销毁的时候自动触发执行
class Foo(object): def __del__(self): print('del object') if __name__ == '__main__': obj = Foo()
说明：Python解释器有自己的内存回收机制，这里当程序执行完了的是否触发析构方法，也可以使用del关键字手动销毁对象触发
__call__
在Python中，对象后面加括号，就会触发这个方法，如果没有这个方法就不可以。
class Foo(object): def __call__(self): print('__call__ is exec') if __name__ == '__main__': obj = Foo() obj()
__dict__
类或者对象中的所有成员
class Province(object): country = 'China' def __init__(self, name): self.name = name def func(self): pass if __name__ == '__main__': print('Class dict:', Province.__dict__) obj = Province('zhangsan') print('Object dict:', obj.__dict__)
说明：可以看出只有name是属于对象的，其他的都是属于类的，也就是说所有的方法都是属于类而不属于对象，当执行对象名.方法名()调用方法的时候，Python解释器会自动将对象本身作为方法的第一个参数传递给方法，也就是方法里self参数。
__str__
如果类中定义了一个__str__方法，当我们打印这个类的实例的时候回调用这个方法的返回值，所以这个方法必须有return，否则就会报错（TypeError: __str__ returned non-string (type NoneType)）
class Foo(object): def __str__(self): return 'Foo object' #class Foo() if __name__ == '__main__': obj = Foo() print(obj)
反射
python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。
class Foo(object): def __init__(self): self.name = 'wupeiqi' def func(self): return 'func' obj = Foo() # #### 检查是否含有成员 #### hasattr(obj, 'name') hasattr(obj, 'func') # #### 获取成员 #### getattr(obj, 'name') getattr(obj, 'func') # #### 设置成员 #### setattr(obj, 'age', 18) setattr(obj, 'show', lambda num: num + 1) # #### 删除成员 #### delattr(obj, 'name') delattr(obj, 'func')
#!/usr/bin/env python #coding:utf-8 from wsgiref.simple_server import make_server class Handler(object): def index(self): return 'index' def news(self): return 'news' def RunServer(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) url = environ['PATH_INFO'] temp = url.split('/')[1] obj = Handler() is_exist = hasattr(obj, temp) if is_exist: func = getattr(obj, temp) ret = func() return ret else: return '404 not found' if __name__ == '__main__': httpd = make_server('', 8001, RunServer) print "Serving HTTP on port 8000..." httpd.serve_forever() Web框架实例