## 引言：编程范式 　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 ， 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式， 对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。 不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程，当然还有人们常说的函数式编程。 **面向过程编程(Procedural Programming)** 　　面向过程编程依赖 ， 面向过程又被称为top-down languages， 就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。 #### 面向对象编程(**Object-Oriented Programming ）** 　　OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。 ## 面向对象编程几大核心 **Class 类** 一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法 **Object 对象 ** 一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同 **Encapsulation 封装** 在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法 **Inheritance 继承** 一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承 **Polymorphism 多态** 多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。 ##  面向对象基础介绍 　　好了，话不多说，我们先来看一下最简单的定义一个类和使用的方法。 ~~~ class Person(object): #定义一个类， class是定义类的语法，Person是类名，(object)是新式类的写法。 def __init__(self,name,age,cn='中国'): #构造函数，为你实例化类的对象传参数，类名加括号就会自动执行该方法。 self.name = name self.age = age def talk(self):　　　　　　　　#定义类的方法，为什么它们都要自动传入一个self？下面我再解释。。。 print('%s is talking'%self.name) def __del__(self): #析构函数，在实例释放、销毁的时候自动执行，通常用于做一些收尾工作，如关闭一些数据库连接，关闭打开的临时文件等等,一般可以不写。 print('结束了') p1 = Person('wusir',22) p1.talk() ~~~ 　　那至于为什么会自动传入一个self呢，我们看下面这个图：  　　 根据上图我们得知，**其实self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去。** ## 面向对象的三大特性 ### 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 ### 继承 　　面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行继承和扩展。 通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。 继承的过程，就是从一般到特殊的过程。 Python2 经典类是按深度优先来继承的，新式类是按广度优先来继承的， Python3 经典类和新式类都是统一按广度优先来继承的。 OK，那什么是经典类、新式类，什么又是深度优先和广度优先。以后我会慢慢介绍。 ### 多态 　　多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。好吧，我知道你没看懂，简单来说，多态就是：一种接口，多种实现。 ``` Person(object): def __init__(self, name, job): self.name = name self.job = job def whoAmI(self): print('I am a %s, my name is %s' % (self.job,self.name)) class Student(Person): def __init__(self,name,job, gender): super(Student, self).__init__(name,job) self.gender = gender class Teacher(Person): def __init__(self,name,job,gender): super(Teacher, self).__init__(name,job) self.gender = gender def who_am_i(x): x.whoAmI() s = Student('Bob', 'student', '男') t = Teacher('Alice', 'teacher', '女') who_am_i(s) who_am_i(t) 点开瞅一眼 ``` 　　这个代码很好的说明了这三大特性，代码的封装，继承和多态。将功能封装到类里面，同时Student类和Teacher类又继承了Person类的属性与方法，最后调用同样的接口who\_am\_i，来输出不同的结果。 ``` ~~~ I am a student, my name is Bob I am a teacher, my name is Alice ~~~ ``` ## 经典类vs新式类 先试着用python2和python3分别把下面代码执行一边 ``` class A: def __init__(self): self.n = 'A' class B(A): def __init__(self): self.n = 'B' class C(A): def __init__(self): self.n = 'C' class D(B,C): def __init__(self): self.n = 'D' obj = D() print(obj.n) ``` 　　然后分别用python2和python3按照顺序，分别把D、B、C的构造函数注释掉换成pass执行，你会发现，在python2中，几次输出分别是D、B、A、C，在python3中几次输出分别是D、B、C、A。但如果我们在A后面加上一个(object)，那么它就从经典类变成了一个新式类，然后你再次在python2中像刚才那样运行。你会发现这次的输出结果由上次的D、B、A、C变成了D、B、C、A。python3再次运行无变化。 由此我们可以得出结果： 　　python2： * 经典类：深度优先 * 新式类：广度优先 　　python3 * 经典类：广度优先 * 新式类：广度优先 ## 静态方法　　 　　@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法。 ~~~ class Person(object): def __init__(self,name): self.name = name @staticmethod #把eat方法变为静态方法 def eat(self): print("%s is eating" % self.name) p = Person("jack") p.eat() ~~~ 　　上面的调用会出错误，说是eat需要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再通过实例调用时就不会自动把实例本身当作一个参数传给self了。 　　解决方法有两种： *  调用时主动传递实例本身给eat方法，即d.eat(d)  *  在eat方法中去掉self参数，但这也意味着，在eat中不能通过self.调用实例中的其它变量了 ## 类方法 　　类方法通过@classmethod装饰器实现，类方法和普通方法的区别是，类方法只能访问类变量，不能访问实例变量。并且类方法传入的第一个参数为cls，是类本身。类方法可以通过类直接调用，或通过实例直接调用。但无论哪种调用方式，最左侧传入的参数一定是类本身。 ~~~ class Dog(object): name = 'jack' def __init__(self, name): self.name = name @classmethod def eat(cls): print("%s is eating" % cls.name) Dog.eat() d = Dog("tom") d.eat() ~~~ 但无论上哪一种的调用方式，结果打印的都是一样的： ~~~ jack is eating jack is eating ~~~ ## 属性方法 　　属性方法的作用就是通过@property把一个方法变成一个静态属性 ~~~ class Dog(object): def __init__(self,name): self.name = name @property def eat(self): print(" %s is eating" %self.name) d = Dog("Jack") d.eat() ~~~ 　　上面这种代码的运行会报错这种错误，TypeError: 'NoneType' object is not callable，因为此时的eat已经是一个静态属性了，不能再通过加()来调用。 正常调用如下： ~~~ d = Dog("jack") d.eat 输出 jack is eating ~~~ PS：如果属性方法还传入了固定参数，想对这个固定参数进行修改怎么办呢？因为我们知道，属性方法的调用是不能加括号的，既然不能加括号，那就不能传参数，擦，这样的话，参数不就写死了。。。当然是可以改的，可以在属性方法的下方再写一个同名的函数，用下面这种装饰器  @函数名.setter  来进行装饰，可以在这个函数中进行参数的修改，当然还有装饰器  @函数名.deleter   来装饰函数，对属性进行删除操作。 ## 面向对象中类成员的特殊方法 **1、\_\_doc\_\_　　表示类的描述信息** ~~~ class Foo: """ 这是一个神奇的类 """ def func(self): pass print(Foo.__doc__) f = Foo() print(f.__doc__) 输出结果: 这是一个神奇的类 这是一个神奇的类 ~~~ PS:用类或者实例都可以进行调用该方法。 **2、\_\_module\_\_、\_\_class\_\_** * 　\_\_module\_\_ 表示当前操作的对象在那个模块 * 　\_\_class\_\_     表示当前操作的对象的类是什么 ``` ~~~ class C: def __init__(self): self.name = 'wusir' ~~~ ``` ``` ~~~ from lib.aa import C obj = C() print (obj.__module__ ) # 输出 lib.aa，即：输出模块 print (obj.__class__) # 输出 lib.aa.C，即：输出类 ~~~ ``` **3、\_\_init\_\_   构造函数**，通过类创建对象时自动执行，用于完成对类的初始化操作 **4、\_\_del\_\_   析构函数**，当对象在内存中被释放时，自动触发执行。此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。 **5、\_\_call\_\_ **对象后面加括号，触发执行。即：对象()或者类()()会触发执行。 ``` class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('我是call') obj = Foo() # 执行 __init__ obj() # 执行 __call__ 输出结果： 我是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__) # 获取对象obj1的成员 obj1 = Province('HeBei', 10000) print(obj1.__dict__) # 获取对象obj2的成员 obj2 = Province('HeNan', 3888) print(obj2.__dict__) ``` 输出结果： ``` ~~~ {'__module__': '__main__', 'country': 'China', '__init__': <function Province.__init__ at 0x000001875B266598>, 'func': <function Province.func at 0x000001875B266620>, '__dict__': <attribute '__dict__' of 'Province' objects>, '__weakref__': <attribute '__weakref__' of 'Province' objects>, '__doc__': None} {'name': 'HeBei', 'count': 10000} {'name': 'HeNan', 'count': 3888} ~~~ ``` **7、 \_\_str\_\_ **如果一个类中定义了该方法，那么在打印对象时，默认输出该方法的返回值 ``` class Foo: def __str__(self): return 'wusir' obj = Foo() print(obj) # 输出结果 wusir ``` **8、 \_\_getitem\_\_,\_\_setitem\_\_,\_\_delitem\_\_** ``` 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'] = 'wusir' # 自动触发执行 __setitem__ del obj['k1'] #自动触发执行 __delitem__，按上述写法并未真正删除，如需删除，需在 #__delitem__ 方法中写删除操作 输出： __getitem__ k1 __setitem__ k2 wusir __delitem__ k1 ``` **9、\_\_new\_\_  \\  \_\_metaclass\_\_** ~~~ class Foo(object): def __init__(self,name): self.name = name f = Foo("wusir") ~~~ 　　上述代码中，f是通过 Foo 类实例化的对象，其实，不仅 f 是一个对象，Foo类本身也是一个对象，因为在python中，一切皆对象，那么如果按照一切皆对象的理论：f对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的构造方法创建。 ~~~ print type(f) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建 print type(Foo) # 输出：<type 'type'> 表示，Foo类对象由 type 类创建 ~~~ 　　由上述打印结果我们可以发现：f是Foo的一个实例，Foo是type的一个实例，即：Foo类对象 是通过type类的构造方法创建。 那么，创建类就可以有两种方式： 一般方式： ~~~ class Foo(): def func(self): pass ~~~ 特殊方式： ~~~ def func(self): pass Foo = type('Foo',(object,),{"func":func}) #type第一个参数：类名 #type第二个参数：当前类的基类 #type第三个参数：类的成员 ~~~ ``` def func(self): print("hello %s"%self.name) def __init__(self,name,age): self.name = name self.age = age Foo = type('Foo',(object,),{'func':func,'__init__':__init__}) f = Foo("wusir",22) f.func() 特殊方式加上构造方法 ``` 所以，要牢记：**类是由type类实例化产生的！** 　　那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？ 　　答：类中有一个属性 \_\_metaclass\_\_，其用来表示该类由谁来实例化创建，所以，我们可以为 \_\_metaclass\_\_ 设置一个type类的派生类，从而查看类创建的过程。  ``` class MyType(type): def __init__(self, what, bases=None, dict=None): print("--MyType init---") super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): print("--MyType call---") obj = self.__new__(self, *args, **kwargs) self.__init__(obj, *args, **kwargs) class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name print("Foo ---init__") def __new__(cls, *args, **kwargs): print("Foo --new--") return object.__new__(cls) # 第一阶段：解释器从上到下执行代码创建Foo类 # 第二阶段：通过Foo类创建obj对象 obj = Foo("Alex") 自定义元类 ``` **类的生成 调用 顺序依次是 \_\_new\_\_ --> \_\_init\_\_ --> \_\_call\_\_** ##  反射 　　通过字符串映射或修改程序运行时的状态、属性、方法, 内置函数分别为:getattr、hasattr、setattr、delattr  获取成员、检查成员、设置成员、删除成员。 ``` class Foo(object): def __init__(self): self.name = 'wusir' def func(self): return 'jack' obj = Foo() #### 检查是否含有成员 #### print(hasattr(obj, 'name')) print(hasattr(obj, 'func')) #### 获取成员 #### print(getattr(obj, 'name')) print(getattr(obj, 'func')()) #### 设置成员 #### print(hasattr(obj,'age')) setattr(obj, 'age', 18) print(getattr(obj,'age')) #### 删除成员 #### delattr(obj, 'name') print(hasattr(obj,'name')) ``` 　　输出结果： ``` True True wusir jack False 18 False ```