1、反射之__import__

        我们知道import语句是用来导入外部模块的，当然还有from...import...也可以，但是其实import实际上是使用builtin函数__import__来工作的。

        在一些程序中，我们可以动态地去调用函数，如果我们知道模块的名称(字符串)的时候，我们可以很方便的使用动态调用。

__import__(module_name[, globals[, locals[, fromlist]]]) #可选参数默认为globals(),locals(),[]

__import__('os')    
__import__('os',globals(),locals(),['path','pip'])  #等价于from os import path, pip

例： 以字符串的形式导入模块

mod = __import__('sys')

print(mod.path)

例：以字符串的形式调用模块中的函数

func = getattr(mod,'path')

print(func)

例：从一个包中导入一个模块 ，包名为main，模块名为mod

aa = __import__('main.mod')

aa = __import__('main', globals={}, locals={}, fromlist=['mod'])

aa = __import__('main',globals(),locals(),['mod'])

m = getattr(aa, 'mod')

print(m.first('kevin'))

n = getattr(m, 'first')

print(type(n))
n('kevin')

注：web框架中根据不同的URL，来加载不同的模块，进行不同的处理。

2、装饰器

       装饰器的语法以@开头，接着是装饰器要装饰的函数的申明等。

       其实总体说起来，装饰器其实也就是一个函数，一个用来包装函数的函数，装饰器在函数申明完成的时候被调用，调用之后申明的函数被换成一个被装饰器装饰过后的函数。

       当原函数有形参时，在装饰的函数中也需要有相应的形参func(args);

       当原函数有return返回值时，在装饰的函数中也必须有returne func(args);

       装饰器分为无参装饰和有参装饰：

★无参装饰

定义方法如下：
比如先定义一个装饰方法：

def deco(func):

    """无参数调用decorator声明时必须有一个参数，这个参数将接收要装饰的方法"""
    print('第一个装饰器')          #进行额外操作
    return func                        #返回一个可调用对象(此例还是返回作为输入参数的方法),返回一个新函数时，新函数可以是一个全局方法或者decorator函数的内嵌函数，只要函数的签名和被装饰的函数相同
@deco
def MyFunc(args):                 #应用@deco修饰的方法
    print('my first decorator',args)

    return('nihao',args)

MyFunc('wangkai')                 #调用被装饰的函数
MyFunc('kevin')

info = MyFunc('gonghui')

print(info)

        注意：当使用上述方法定义一个decorator方法时，函数体内的额外操作只在被装饰的函数首次调用时执行;

       如果要保证额外操作在每次调用被装饰的函数时都执行，需要换成如下的写法：

def deco(func):
    def replaceFunc(args):     #定义一个内嵌函数，此函数包装了被装饰的函数，并提供额外操作的代码
        print('第一个装饰器')     #进行额外操作
        return func(args)          #产生对被装饰函数的调用
    return replaceFunc           #由于返回的是这个新的内嵌函数，所以确保额外操作每次调用得以运行
@deco
def MyFunc(args):                 #应用@deco修饰的方法
    print('my first decorator',args)
    return('nihao',args)
MyFunc('wangkai') #调用被装饰的函数
MyFunc('kevin')
info = MyFunc('gonghui')
print(info)

★有参装饰:

def decoWithArgs(arg):

    """由于有参数的decorator函数在调用时只会使用应用时的参数而不接收被装饰的函数做为参数，
       所以必须返回一个decorator函数， 由它对被装饰的函数进行封装处理"""
    def newDeco(func):                          #定义一个新的decorator函数
        def replaceFunc(args):                 #在decorator函数里面再定义一个内嵌函数，由它封装具体的操作
            print('第一个装饰器')                 #进行额外操作
            aa = func(args)                        #对被装饰函数进行调用

            print('再见') 

            return aa

        return replaceFunc
    return newDeco                                #返回一个新的decorator函数
@decoWithArgs("demo")
def MyFunc(args):                                 #应用@decoWithArgs修饰的方法
    print('my first decorator',args)   
    return('nihao',args)
MyFunc('wangkai')                                #调用被装饰的函数
MyFunc('kevin')
info = MyFunc('gonghui')
print(info)

       当我们对某个方法应用了装饰方法后， 其实就改变了被装饰函数名称所引用的函数代码块入口点，使其重新指向了由装饰方法所返回的函数入口点。由此我们可以用decorator改变某个原有函数的功能，添加各种操作，或者完全改变原有实现。

3、类与对象

        __init__ 的方法 完成初始化。构造函数

        __del__ 的方法 对象销毁，析构函数

       __call__ 调用方法

       所有的实例方法都拥有一个 self 参数来传递当前实例，类似于 this。

       可以使用 __class__ 来访问类型成员。

       还有些内置特殊的属性：

              __doc__   #类型帮助信息

              __name__ # 类型名称

              __module__ # 类型所在模块

              __bases__ # 类型所继承的基类

              __dict__ # 类型字典，存储所有类型成员信息。

     例：

class peason(object):

    '''this is peason class'''
    #静态字段
    aa = 'nihao'
    bb = ['a',1,'b',2,'c',3]
    cc = {'a':'wangkai','b':'gonghui'}
    
    def __init__(self,name,flag):
        self.name = name                           #动态字段
        self.__flag = flag                              #私有字段

    def __del__(self):
        print('i will go')
    
    def __call__(self,caa):                            #call方法
        print('this is call method',caa)    

 

    def __priv(self):                                    #私有方法
        print('hello,this is privacy method',self.__flag)
    
    
    def first(self):                                       #动态方法
        print('hello,this is dymamic method',self.name)
        self.__priv()                                     #调用私有方法
        return self.__flag                            #调用私有字段
    
    @staticmethod                                  #静态方法
    def foo():
        print('this is static method')
    
    @property                                         #属性               
    def bar(self):
        print(self.name)
        self.__priv()
        return "this is property"
    
    @property                                         #属性(只读）

    def flag(self):

        return self.__flag
    
    @flag.setter                                       #修改私有字段值
    def flag(self,value):
        self.__flag = value
        
print('#################')    
print(peason.__doc__,peason.__name__,peason.__module__,peason.__bases__,peason.__dict__)
print('#################')        
print(peason.aa,peason.bb,peason.cc)      #获取静态字段
print('#################')    
print(peason.foo())                                    #获取静态方法
print('#################')    
pp = peason('wang','true')                       #类实例化
print(pp.name)                                         #通过对象获取动态字段
print('#################')                
print(pp.first())                                          #通过对象获取动态方法
print('#################')          
print(pp.bar)                                             #通过对象获取属性
print('#################')          
print(pp._peason__priv())                          #特殊调用方式
print('#################')          
print(pp.flag)
pp.flag = 'false'                                         #通过属性修改私有字段值
print(pp.flag)

pp('aa')                                                      #call方法调用

注：静态的可以直接通过类来访问，而动态的只能通过调用对象的方式来访问；

       私有字段和方法能通过方法和属性调用；

       只读或只写的字段，修改需要@flag.setter 和 class peason(object):来实现

继承

Python编程中类可以承继父类属性，形式为class 类名（父类），子类可以继承父类的所有方法和属性，也可以重载父类的成员函数及属性，须注意的是子类成员函数若重载父类（即名字相同），则会使用子类成员函数

例：

class CAnimal(object):

    def __init__(self,voice='hello'):                     # voice初始化默认为hello
        self.voice = voice
    def Say(self):
        print(self.voice)
    def Run(self):
        print('this is parent run')
class CDog(CAnimal):                                      # 继承类CAnimal 

    def __init__(self):

        self.dog = 'ssss'
        CAnimal.__init__(self, voice='aaa')           #调用父类的__init__
        super(CDog,self).__init__()                       #通过使用super调用父类的__init__

    def SetVoice(self,voice):                              # 子类增加函数

        self.voice = voice
    def Run(self,voice):                                      # 子类重载函数Run            
        print('this is child run')
bobo = CDog()
bobo.SetVoice('My Name is BoBo!')               # 设置child.data为hello
bobo.Say()
bobo.Run('aa')

       新式类以object为基类，在python3之后版本原来有经典类将不在使用，而且新式类的多类继承是以广度代替了经典类的深度搜索方式。

        例，A、B、C、D四个类，其中B和C继承A，D又继承B和C，即class D(B,C)

        继承的方法：

              经典类的搜索顺序是B，A，C     搜索到第一个方法结束

              新式类的搜索顺序是B,C。

例：经典类写法

class A(object):

    def __init__(self):
        print('this is class A')
    def test(self):
        print('this is parent test')
        
class B(A):
    def __init__(self):
        print('this is class B')
       
class C(A):
    def __init__(self):
        print('this is class C')
    def test(self):
        print('this is son C test')
        
class D(B,C):
    def __init__(self):
        print('this is class D')
    
R = D()
R.test()

经典类写法结果为：

this is class D

this is parent test

新式类写法结果为：

this is class D

this is son C test

抽象类+抽象方法 = 接口 （用于规范）

由于python 没有抽象类、接口的概念，所以要实现这种功能得abc.py 这个类库,

抽象基类（或者ABCs）是Python里一个相同的特性。抽象基类由abc模块构成，包含了一个叫做ABCMeta的metaclass。这个metaclass由内置的isinstance()和issubclass()特别处理

具体方式如下：

from abc import ABCMeta,abstractmethod

from _pyio import __metaclass__
class headers(object):
    __metaclass__ = ABCMeta
    
    def __init__(self):
        print('this is abc class')
        
    @abstractmethod
    def fun(self):
        pass
    
class foo(headers):
    def __init__(self):
        print('__init__')
        
    def fun(self):
        print('foo.fun')
        
f = foo()
f.fun()