精华内容
下载资源
问答
  • python高级特性

    2018-03-06 11:39:01
    讲述了python面型对象,对类属性的操作,垃圾回收,类的继承,方法重写以及python json等
  • Python 高级特性

    2021-01-20 02:44:31
    Python 高级特性 文章目录Python 高级特性切片迭代列表生成式生成器 generator迭代器 切片 可以对list, tuple, string进行切片 [起始位置:终止位置 + 1: 步长] 可以使用负数,-1为倒数第一个数 步长为负数时,从后...
  • python高级特性简介

    2020-09-16 09:43:29
    主要介绍了python高级特性的相关内容,其中包括切片,迭代,列表生成式,生成器,迭代器,感兴趣的朋友可以了解下
  • Python高级特性

    2016-12-17 15:43:06
    从本文开始,所有示例代码以Spyder环境为例。...类似其它编程语言中的subString函数,针对获取list或tuple的指定索引范围的操作,Python提供了切片操作符,示例如下L=['Alice','Bob','Ten','Jack'] T=(0,1,2

    最近开始学习Python,利用空闲时间记录部分笔记,方便日后回顾,同时,希望能帮助到正在学习中的同胞,如果文章内容有出入,欢迎随时指正。从本文开始,所有示例代码以Spyder环境为例。

    1. 切片
      类似其它编程语言中的subString函数,针对获取list或tuple的指定索引范围的操作,Python提供了切片操作符,示例如下

      L=['Alice','Bob','Ten','Jack']
      T=(0,1,2,3)
      print (L[0:3])
      print(L[-3:-1])
      print(T[:2])

      运行结果:

      ['Alice', 'Bob', 'Ten']
      ['Bob', 'Ten']
      (0, 1)

      L[0:3]表示,从索引0开始取,直到索引3为止,但不包含索引3。如果第一个索引是0,可以省略不写,如L[:3]。切片也支持倒数,倒数时,第一个元素的索引是-1。

    2. 迭代
      在Python中,通过for…in循环来遍历list或其他对象,这种遍历称为迭代。

      D={'a':1,'b':2,'c':3}
      for key in D:
          print (key)

      运行结果:

      a
      c
      b

      Python可对list、dict等进行迭代,也可以对字符串进行迭代,但依然有部分对象不可以进行迭代,如果不确定时,可以先判断是否支持迭代。

      from collections import Iterable
      print(isinstance('abc',Iterable))
      print(isinstance([1,2,3],Iterable))
      print(isinstance(123,Iterable))

      运行结果:

      True
      True
      False
    3. 列表生成式
      Python内置了强大而又简单的方法,即可以创建list生成式。示例如下:

      L = list(range(1,11))
      print(L)
      P = [x*x for x in range(1,11)]
      print(P)
      Q = [x*x for x in range(1,11) if x%2== 0]
      print(Q)
      运行结果:
      
      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
      [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
      [4, 16, 36, 64, 100]
    4. 生成器
      为解决list生成过大所造成的内存浪费,Python提供了一种边循环边计算的机制,称为生成器:Generator。这样就不必创建完整的list,从而节省了大量的空间。

      G = (x*x for x in range(10))
      print (G)

      运行结果:

      <generator object <genexpr> at 0x0000023783AE9B48>

      将列表生成式的[]改成(),就可以创建一个Generator。更复杂的Generator将在后期做进一步补充。

    5. 迭代器
      可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。前面已经写了如何判断是否是可迭代对象,同样,可以使用isinstance()判断一个对象是否是Iterator对象。

      from collections import Iterator
      print(isinstance((x for x in range(10)),Iterator))
      print(isinstance([],Iterator))
      print(isinstance({},Iterator))

      运行结果:

      True
      False
      False

      生成器都是Iterator对象,但list、dict、字符串等虽然是Iterable,却不是Iterator。

    展开全文
  • 主要介绍了Python高级特性 切片 迭代解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python很棒,它有很多高级用法值得细细思索,学习使用。这篇文章主要介绍了python高级特性和高阶函数及使用详解,需要的朋友可以参考下
  • 本文实例讲述了Python高级特性之闭包与装饰器。分享给大家供大家参考,具体如下: 闭包 1.函数参数: (1)函数名存放的是函数的地址 (2)函数名()存放的是函数内的代码 (3)函数名只是函数代码空间的引用,当函数名...
  • Python中对于具有序列结构的数据来说都可以使用切片操作,需注意的是序列对象某个索引位置返回的是一个元素,而切片操作返回是和被切片对象相同类型对象的副本。
  • 今天小编就为大家分享一篇Python高级特性——详解多维数组切片(Slice),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇关于Python高级特性与几种函数的讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • scrapy是一个基于Twisted的异步处理框架,是一个纯Python实现的爬虫框架,其架构清晰,模块之间的耦合程度低,可扩展性很强,我们可以通过定制开发几个模块就可以实现一个功能强大的爬虫。一个Scrapy框架如下图所示...
  • python进阶 Python高级特性

    千次阅读 多人点赞 2018-03-09 17:05:58
    1 内建函数(__xxx__) 背景:为什么要有这种带下划线的内建函数,个人认为这种内建函数开放了很多Python的特殊用法,只要详尽掌握,就会理解平时用到的数据结构是复写了什么方法,自己也可以写出类似set,dqueue,dict,...

    目录

     1 内建函数(__xxx__)

        1.1 类似字典的操作方式,__getitem__,__setitem__,__delitem__

        1.2 __new__和__init__

        1.3 __iter__,next(python2),__next__(python3)

        1.4 __call__

        1.5 __repr__,__str__

        1.6 __all__

        1.7 __setattr__,__getattr__,__delattr__

        1.8 __le__,__lt__,__ge__,__gt__,__ne__,__eq__

        1.9 __slots__

    1.10 __metaclass__

    1.10.2 动态地创建类

    1.10.3 到底什么是元类

    1.10.4 metaclass__属性

    1.10.5 自定义元类

     2 私有变量(__xx)

     3 type

     4 推导式

     5 装饰器(@decorate)

     5.1函数是可以返回函数

    5.2 装饰器的使用场景:

      5.3 在函数中嵌入装饰器

      5.4 装饰器类

     6 容器

           6.1 defaultdict:

           6.2 Counter

            6.3 deque

            6.4 namedtuple(命名元组)

     7 上下文

     8 继承

     9 生成器,迭代器,可迭代对象

    10 自省

    11 闭包

    12 反射

    13 推导式

    14 C扩展

    15 函数缓存

    16 Flask上下文

    18 多线程,多进程,协程

    20 socket和socketserver

    21 yield

    22 进程间通讯

    23 进程内存共享

    24 Python实现冒泡法排序

    25 对象

    26 IO多路复用

    27 动态加载


     1 内建函数(__xxx__)

        背景:为什么要有这种带下划线的内建函数,个人认为这种内建函数开放了很多Python的特殊用法,只要详尽掌握,就会理解平时用到的数据结构是复写了什么方法,自己也可以写出类似set,dqueue,dict,list的数据类型方法。

        1.1 类似字典的操作方式,__getitem__,__setitem__,__delitem__

            我们熟悉的字典是可以像如下方式操作赋值取值:

    d = dict()
    d["a"] = 1
    d["b"] = 2
    print d
    del d["a"]
    print d

           其实像这种赋值方式就是复写了__setitem__,__getitem__,__delitem__请见如下类

    class TestDict(object):
    
       def __getitem__(self,key):
           return self.__dict__.get(key)
    
       def __setitem__(self,key,value):
           self.__dict__[key] = value
    
       def __delitem__(self,key):
           self.__dict__.pop(key)
    
    td = TestDict()
    td["a"] = 1
    td["b"] = 2
    print td["a"]
    print td.__dict__
    del td["a"]
    print td.__dict__
     
    

    为了更加灵活,如上代码也可以在对象执行赋值方法(__init__)的时候声明个变量d = dict(),然后对这个变量进行赋值和取值操作也可以模拟上面的操作。

        1.2 __new__和__init__

            __new__: 在类实例化的时候调用,用来创建实例如果不返回实例那么__init__将不会执行,第一个参数是class对象,在创建实例的时候需要有返回值

            __init__: 在初始化实例的时候调用,比如说实例属性赋值,第一个参数是实例对象,一般都重写__init__方法,在执行的时候不需要返回值

    class TestNew(object):
        def __new__(cls, *args, **kwargs):
            print '__new__ called.'
            return super(TestNew,cls).__new__(cls,*args,**kwargs)
        def __init__(self):
            print '__init__ called.'
            self.a = 1
    
    tn = TestNew()
    print tn.a

           可以用__new__来实现单例模式

    class Singleton(object):
            def __new__(cls):
                # 关键在于这,每一次实例化的时候,我们都只会返回这同一个instance对象
                if not hasattr(cls, 'instance'):
                    cls.instance = super(Singleton, cls).__new__(cls)
                return cls.instance
    
    obj1 = Singleton()
    obj2 = Singleton()
    
    obj1.attr1 = 'value1'
    print obj1.attr1, obj2.attr1
    print obj1 is obj2
     
    

        Tips: 单例模式有很多种实现方式,也可以通过类变量+静态方法的方式实现。

        可以通过重载__new__来实现很多创建实例时的功能。

        1.3 __iter__,next(python2),__next__(python3)

                __iter__: 复写这个函数的对象是可迭代对象

                next/__next__: 复写这个函数的对象都是一个迭代器

    class TestIterNext(object):
        def __init__(self,data=1):
            self.data = data
    
        def next(self):
            if self.data > 5:
                raise StopIteration
            else:
                self.data+=1
                return self.data
    
        def __iter__(self):
            print "iter"
            return self
     
    

    当for循环去迭代tin = TestIterNext()对象的时候第一步会去看__iter__是否返回一个生成器(generator),如果返回的是对象本身才会去执行next函数。

        1.4 __call__

                把一个类实例的对象当做函数一样调用就是复写了__call__方法,如下:

    class TestCall(object):
        def __call__(self):
            print "call it"
    tc = TestCall()
    tc()
     
    

                复写__call__方法大多数用在装饰器类中(第5章)和继承Type类(第3章)的时候。

        1.5 __repr__,__str__

            __repr__和__str__没有太大区别,在Python交互模式下才能发现。复写改方法后输出对象就是按照该方法里的内容进行输出。在类里可以这样用__repr__ = __str__

        1.6 __all__

            可用于模块导入时限制,,当我们from module import *的时候这个__all__就起作用了,__all__=["bar","sar"] ,[]里定义函数或者变量类等,有些模块内部一些函数不对外开放,此时把一些对外开放的函数变量放入到__all__里就可以了,这样避免了一些多余的导入。如果在__init__.py里定义则在导入模块的时候只导入__all__里定义的各个文件,此时无法定义到文件里具体哪个类或方法,如果需要细化则需要在具体的类里写入__all__。如果是from module import Test这种使用不受__all__限制

        1.7 __setattr__,__getattr__,__delattr__

                __setattr__: 对变量赋值时调用。

                __getattr__:默认查找对象属性是在一个字典里(__dict__),这里没有要查找的对象则去__getattr__方法里查找,如果我们复写__getattr__则可以根据实际需求来返回值。

                __delattr__:删除属性时调用。

    class TestAttr(object):
        def __init__(self):
            self.name = "abc"
    
        def __getattr__(self, item):
            print "item:" + str(item)
            print "getattr"
            return 10
        def __setattr__(self, *args, **kwargs):
            print "set attr"
            object.__setattr__(self,*args,**kwargs)
    
        def __delattr__(self, *args, **kwargs):
            print "delete attr"
            object.__delattr__(self,*args, **kwargs)
    
    ta = TestAttr()
    print ta.__dict__
    print ta.names
    del ta.name
    print ta.__dict__
     
    

        1.8 __le__,__lt__,__ge__,__gt__,__ne__,__eq__

               一个对象和另一个对象比较大小,返回的并不一定是True和False,返回值有可能是我们定义的任何值,这里就是复写上面这些方法。如下:

    class TestCompare(object):
        def __lt__(self, other):
            return "aaa"
    
    t = TestCompare()
    print(t<1)
     
    

    这里打印出的就不是True和False,打印的是我们再复写的方法里定义的"aaa",其实有一些常用的orm,比如说sqlalchemy里查询条件可以这样写

    g.pg_db.query(Company.id).filter(Company.level_id == level)

    这里的Company.level_id == level返回的就是筛选条件,因为对Company的level_id对象复写了__eq__

        1.9 __slots__

            优点:

                1,更快的属性访问速度

                2,减少内存消耗

            每个类里都维护一个字典__dict__,这个字典维护了对象的所有属性,但如果成千上万个对象则就会创建很多个__dict__来存放对象属性,为了性能我们可以不用Python帮我们维护这个字典。此时我们在类里定义__slots__ = ["name","age"]的时候就表示禁用了__dict__,并限定name和age为类的属性(类里只能有name和age属性),这样做的好处能大大节省内存开支,对象越多节省的就越多,大概能节省40%以上。

    class TestSlots(object):
        __slots__ = ["name","age"]
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
    ts = TestSlots("a",1)
    ts.name = 1
    print ts.name
     
    

    1.10 __metaclass__

            在理解元类之前,你需要先掌握Python中的类。Python中类的概念借鉴于Smalltalk,这显得有些奇特。在大多数编程语言中,类就是一组用来描述如何生成一个对象的代码段。在Python中这一点仍然成立

            1.10.1 元类是什么?

                但就元类本身而言,它们其实是很简单的:

                1)   拦截类的创建

                2)   修改类

                3)   返回修改之后的类

            但是,Python中的类还远不止如此。类同样也是一种对象。是的,没错,就是对象。只要你使用关键字class,Python解释器在执行的时候就会创建一个对象。下面的代码段:

    class ObjectCreator(object):
        pass

    将在内存中创建一个对象,名字就是ObjectCreator。这个对象(类)自身拥有创建对象(类实例)的能力,而这就是为什么它是一个类的原因。但是,它的本质仍然是一个对象,于是乎你可以对它做如下的操作:

    1)   你可以将它赋值给一个变量

    2)   你可以拷贝它

    3)   你可以为它增加属性

    4)   你可以将它作为函数参数进行传递

    下面是示例:

    print ObjectCreator
    # 你可以打印一个类,因为它其实也是一个对象
    def echo(o):
        print o
    
    echo(ObjectCreator)
    
    # 你可以将类做为参数传给函数
    print hasattr(ObjectCreator, 'new_attribute')
    ObjectCreator.new_attribute = 'foo'
    #  你可以为类增加属性
    print hasattr(ObjectCreator, 'new_attribute')
    print ObjectCreator.new_attribute
    ObjectCreatorMirror = ObjectCreator
    # 你可以将类赋值给一个变量
    print ObjectCreatorMirror()

    1.10.2 动态地创建类

    因为类也是对象,你可以在运行时动态的创建它们,就像其他任何对象一样。首先,你可以在函数中创建类,使用class关键字即可。

    def choose_class(name):
        if name == 'foo':
            class Foo(object):
                pass
            return Foo     
    # 返回的是类,不是类的实例
        else:
            class Bar(object):
                pass
            return Bar
    MyClass = choose_class('foo')
    print MyClass              
    # 函数返回的是类,不是类的实例>>> print MyClass()            
    # 你可以通过这个类创建类实例,也就是对象
    # <__main__.foo object="" at="" 0x89c6d4c="">

    但这还不够动态,因为你仍然需要自己编写整个类的代码。由于类也是对象,所以它们必须是通过什么东西来生成的才对。当你使用class关键字时,Python解释器自动创建这个对象。但就和Python中的大多数事情一样,Python仍然提供给你手动处理的方法。还记得内建函数type吗?这个古老但强大的函数能够让你知道一个对象的类型是什么,就像这样:

    print type(1)
    print type("1")
    print type(ObjectCreator)
    print type(ObjectCreator())
    

    这里,type有一种完全不同的能力,它也能动态的创建类。type可以接受一个类的描述作为参数,然后返回一个类。(我知道,根据传入参数的不同,同一个函数拥有两种完全不同的用法是一件很傻的事情,但这在Python中是为了保持向后兼容性)

    type可以像这样工作:

    type(类名, 父类的元组(针对继承的情况,可以为空),包含属性的字典(名称和值))

    比如下面的代码:

    class MyShinyClass(object):
        pass
    
    MyShinyClass = type('MyShinyClass', (), {})  
    # 返回一个类对象
    print MyShinyClass
    print MyShinyClass()  
    #  创建一个该类的实例
    # <__main__.myshinyclass object="" at="" 0x8997cec="">

    你会发现我们使用“MyShinyClass”作为类名,并且也可以把它当做一个变量来作为类的引用。类和变量是不同的,这里没有任何理由把事情弄的复杂。

    type 接受一个字典来为类定义属性,因此

    class Foo(object):
        bar = True
    # 可以翻译为:
    
    Foo = type('Foo', (), {'bar':True})

    为类增加方法。只需要定义一个有着恰当签名的函数并将其作为属性赋值就可以了。

    def echo_bar(self):
        print self.bar
    
    FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
    hasattr(Foo, 'echo_bar')
    False
    hasattr(FooChild, 'echo_bar')
    True
    my_foo = FooChild()
    my_foo.echo_bar()
    True

     你可以看到,在Python中,类也是对象,你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情,而这就是通过元类来实现的。

    1.10.3 到底什么是元类

    元类就是用来创建类的“东西”。你创建类就是为了创建类的实例对象,不是吗?但是我们已经学习到了Python中的类也是对象。好吧,元类就是用来创建这些类(对象)的,元类就是类的类,你可以这样理解为:

    MyClass = MetaClass()
    MyObject = MyClass()

    你已经看到了type可以让你像这样做:

    MyClass = type('MyClass', (), {})

    这是因为函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。现在你想知道那为什么type会全部采用小写形式而不是Type呢?好吧,我猜这是为了和str保持一致性,str是用来创建字符串对象的类,而int是用来创建整数对象的类。type就是创建类对象的类。你可以通过检查__class__属性来看到这一点。Python中所有的东西,注意,我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象,而且它们都是从一个类创建而来。

    >>> age = 35
    >>> age.__class__
    >>> name = 'bob'
    >>> name.__class__
    >>> def foo(): pass
    >>>foo.__class__
    >>> class Bar(object): pass
    >>> b = Bar()
    >>> b.__class__

    现在,对于任何一个__class__的__class__属性又是什么呢?

    >>> a.__class__.__class__
    >>> age.__class__.__class__
    >>> foo.__class__.__class__
    >>> b.__class__.__class__

    因此,元类就是创建类这种对象的东西。如果你喜欢的话,可以把元类称为“类工厂”(不要和工厂类搞混了:D) type就是Python的内建元类,当然了,你也可以创建自己的元类。

    1.10.4 metaclass__属性

    你可以在写一个类的时候为其添加__metaclass__属性。

    class Foo(object):
        __metaclass__ = something…
    […]

    如果你这么做了,Python就会用元类来创建类Foo。小心点,这里面有些技巧。你首先写下class Foo(object),但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性,如果找到了,Python就会用它来创建类Foo,如果没有找到,就会用内建的type来创建这个类。把下面这段话反复读几次。当你写如下代码时 :

    class Foo(Bar):
    
        pass

    Python做了如下的操作:

    Foo中有__metaclass__这个属性吗?如果是,Python会在内存中通过__metaclass__创建一个名字为Foo的类对象(我说的是类对象,请紧跟我的思路)。如果Python没有找到__metaclass__,它会继续在Bar(父类)中寻找__metaclass__属性,并尝试做和前面同样的操作。如果Python在任何父类中都找不到__metaclass__,它就会在模块层次中去寻找__metaclass__,并尝试做同样的操作。如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。

    现在的问题就是,你可以在__metaclass__中放置些什么代码呢?答案就是:可以创建一个类的东西。那么什么可以用来创建一个类呢?type,或者任何使用到type或者子类化type的东东都可以。

    1.10.5 自定义元类

    元类的主要目的就是为了当创建类时能够自动地改变类。通常,你会为API做这样的事情,你希望可以创建符合当前上下文的类。假想一个很傻的例子,你决定在你的模块里所有的类的属性都应该是大写形式。有好几种方法可以办到,但其中一种就是通过在模块级别设定__metaclass__。采用这种方法,这个模块中的所有类都会通过这个元类来创建,我们只需要告诉元类把所有的属性都改成大写形式就万事大吉了。

    幸运的是,__metaclass__实际上可以被任意调用,它并不需要是一个正式的类(我知道,某些名字里带有‘class’的东西并不需要是一个class,画画图理解下,这很有帮助)。所以,我们这里就先以一个简单的函数作为例子开始。

    # 元类会自动将你通常传给‘type’的参数作为自己的参数传入

    def upper_attr(future_class_name, future_class_parents, future_class_attr):
         
    '''返回一个类对象,将属性都转为大写形式'''
         
    #  选择所有不以'__'开头的属性
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
         
    # 将它们转为大写形式
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
      
         
    # 通过'type'来做类对象的创建
        return type(future_class_name, future_class_parents, uppercase_attr)
      
    __metaclass__ = upper_attr  
    #  这会作用到这个模块中的所有类
      
    class Foo(object):
         
    # 我们也可以只在这里定义__metaclass__,这样就只会作用于这个类中
        bar = 'bip'
    print hasattr(Foo, 'bar')
    # 输出: False
    print hasattr(Foo, 'BAR')
    # 输出:True
      
    f = Foo()
    print f.BAR
    # 输出:'bip'

    现在让我们再做一次,这一次用一个真正的class来当做元类。

    # 请记住,'type'实际上是一个类,就像'str'和'int'一样
    # 所以,你可以从type继承
    class UpperAttrMetaClass(type):
         
    # __new__   是在__init__之前被调用的特殊方法
         
    # __new__是用来创建对象并返回之的方法
         
    # 而__init__只是用来将传入的参数初始化给对象
         
    # 你很少用到__new__,除非你希望能够控制对象的创建
         
    # 这里,创建的对象是类,我们希望能够自定义它,所以我们这里改写__new__
         
    # 如果你希望的话,你也可以在__init__中做些事情
         
    # 还有一些高级的用法会涉及到改写__call__特殊方法,但是我们这里不用
        def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
            attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
            uppercase_attr = dict((name.upper(), value) for name, value in attrs)
            return type(future_class_name, future_class_parents, uppercase_attr)
    但是,这种方式其实不是OOP。我们直接调用了type,而且我们没有改写父类的__new__方法。现在让我们这样去处理:
    class UpperAttrMetaclass(type):
        def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
            attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
            uppercase_attr = dict((name.upper(), value) for name, value in attrs)
      
             
    # 复用type.__new__方法
             
    # 这就是基本的OOP编程,没什么魔法
            return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)

    你可能已经注意到了有个额外的参数upperattr_metaclass,这并没有什么特别的。类方法的第一个参数总是表示当前的实例,就像在普通的类方法中的self参数一样。当然了,为了清晰起见,这里的名字我起的比较长。但是就像self一样,所有的参数都有它们的传统名称。因此,在真实的产品代码中一个元类应该是像这样的:

    class UpperAttrMetaclass(type):
        def __new__(cls, name, bases, dct):
            attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')
            uppercase_attr  = dict((name.upper(), value) for name, value in attrs)
            return type.__new__(cls, name, bases, uppercase_attr)
    如果使用super方法的话,我们还可以使它变得更清晰一些,这会缓解继承(是的,你可以拥有元类,从元类继承,从type继承)
    class UpperAttrMetaclass(type):
        def __new__(cls, name, bases, dct):
            attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
            uppercase_attr = dict((name.upper(), value) for name, value in attrs)
            return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)

    用元类实现单例模式

    class Singleone(type):
    
        def __init__(cls, name,bases,dct):
            super(Singleone, cls).__init__(name,bases,dct)
    
            cls._instance = None
    
    
    
        def __call__(cls, *args, **kwargs):
            if cls._instance is None:
                cls._instance = super(Singleone,cls).__call__(*args,**kwargs)
            return cls._instance
    
    class One(object):
        __metaclass__ = Singleone
        def __init__(self,*args, **kwargs):
            self.name = args[0]
    
    o = One("a")
    print (o.name)
    b = One("b")
    
    print(b.name)

    执行步骤从上到下当执行用Singleone创建One类,One = Singleone(...),当实例化Singleone的时候执行其内部的__init__()方法,代码
    继续解析到o = One("a")的时候示例化了One类,相当于Singleone()(),此时执行Singleone里面的__call__方法,在call方法里需要有
    返回值。也可以在__call__里主动实例化(__new__)One并调用里面的__init__方法。

    就是这样,除此之外,关于元类真的没有别的可说的了。使用到元类的代码比较复杂,这背后的原因倒并不是因为元类本身,而是因为你通常会使用元类去做一些晦涩的事情,依赖于自省,控制继承等等。确实,用元类来搞些“黑暗魔法”是特别有用的,因而会搞出些复杂的东西来。

    为什么要用metaclass类而不是函数?

    由于__metaclass__可以接受任何可调用的对象,那为何还要使用类呢,因为很显然使用类会更加复杂啊?这里有好几个原因:

    1)  意图会更加清晰。当你读到UpperAttrMetaclass(type)时,你知道接下来要发生什么。

    2) 你可以使用OOP编程。元类可以从元类中继承而来,改写父类的方法。元类甚至还可以使用元类。

    3)  你可以把代码组织的更好。当你使用元类的时候肯定不会是像我上面举的这种简单场景,通常都是针对比较复杂的问题。将多个方法归总到一个类中会很有帮助,也会使得代码更容易阅读。

    4) 你可以使用__new__, __init__以及__call__这样的特殊方法。它们能帮你处理不同的任务。就算通常你可以把所有的东西都在__new__里处理掉,有些人还是觉得用__init__更舒服些。

    5) 哇哦,这东西的名字是metaclass,肯定非善类,我要小心!

    “元类就是深度的魔法,99%的用户应该根本不必为此操心。如果你想搞清楚究竟是否需要用到元类,那么你就不需要它。那些实际用到元类的人都非常清楚地知道他们需要做什么,而且根本不需要解释为什么要用元类。”  —— Python界的领袖 Tim Peters

    元类的主要用途是创建API。一个典型的例子是Django ORM。它允许你像这样定义:

    class Person(models.Model):
        name = models.CharField(max_length=30)
        age = models.IntegerField()

    这并不会返回一个IntegerField对象,而是会返回一个int,甚至可以直接从数据库中取出数据。这是有可能的,因为models.Model定义了__metaclass__, 并且使用了一些魔法能够将你刚刚定义的简单的Person类转变成对数据库的一个复杂hook。Django框架将这些看起来很复杂的东西通过暴露出一个简单的使用元类的API将其化简,通过这个API重新创建代码,在背后完成真正的工作。

    结语

    首先,你知道了类其实是能够创建出类实例的对象。好吧,事实上,类本身也是实例,当然,它们是元类的实例。

    Python中的一切都是对象,它们要么是类的实例,要么是元类的实例,除了type。type实际上是它自己的元类,在纯Python环境中这可不是你能够做到的,这是通过在实现层面耍一些小手段做到的。其次,元类是很复杂的。对于非常简单的类,你可能不希望通过使用元类来对类做修改。你可以通过其他两种技术来修改类:

    1) Monkey patching(详情请查看28)

    2)   class decorators

    当你需要动态修改类时,99%的时间里你最好使用上面这两种技术。当然了,其实在99%的时间里你根本就不需要动态修改类 

     2 私有变量(__xx)

            python类里的私有变量就是前面加两个下划线这样用,但是这只是在使用上的私有变量,不像Java那种只能通过内部函数修改,python的私有变量可以通过 对象._类名__参数来从外部引用。

     3 type

            请查看 1.20

     4 推导式

            推导式又称解析式,有三种

            1,列表推导式

                    multiples = [ i for i in range(30) if i % 3 is 0 ]

            2,字典推导式

                    mcase = {"a":10,"b":2,"c":3}

                    {k:v for k,v in mcase.items()}

            3,集合推导式

                    其实大括号里扩着的就是集合(set),例:

                        {"a","b",1}

                    squared = {x*2 for x in [1,2,3]}

     5 装饰器(@decorate)

     装饰器是python特色代表之一,非常好用,先介绍一下如何用装饰器。

     5.1函数是可以返回函数

            在if/else里面我们返回greet和welcome,而不是greet()和welcome(),为什么? 是因为当把小括号放到后面的时候这个函数就会执行,如果不放小括号这个函数就可以到处传递,并且可以赋给变量而不去执行。

            将函数作为参数传递给另一个函数

    def hi():
        return "hi yasoob"
    
    def doSomethingBefore(func):
        print "I am doing something before"
        print (func())
    
    doSomethingBefore(hi)
     
    

    输出:

            I am doing something before

            hi yasoob

        装饰器就是在一个函数前后执行代码

        上个例子里我们相当于创建了装饰器,现在我们稍加修改并编写一个更有用的程序。

        

    def a_new_decorator(a_func):
        def wrapTheFunction():
            print "I am doing some before"
            a_func()
            print "I am doing some after"
        return wrapTheFunction
    
    def a_function_requiring_decoration():
        print "I am in the function"
    
    a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)
    a_function_requiring_decoration()
     
    

    明白了吗? 这正是python装饰器做的事情,它们封装一个函数,并且用这样或者那样的方式修改它的行为,现在你可能疑惑,我们的代码里并没有使用@符号?那只是一个简短的方式来生成一个被装饰的函数。请见如下例子

    @a_new_decorator
    def a_function_requiring_decoration():
        print "I am in the function"
    
    a_function_requiring_decoration()
     
    

    现在对装饰器的理解差不多了吧!但如果我们运行如下代码会存在一个问题:

    print(a_function_requiring_decoration.__name__)

    输出:wrapTheFunction

    这并不是我们想要看到的,我们想看到的是a_function_requiring_decoration,这里的函数被wrapTheFunction替代了,它重写了我们函数的名字和注释文档(docstring)。幸运的是python提供给我们一个简单的函数来解决这个问题

    from functools import wraps
    def a_new_decorator(a_func):
        @wraps(a_func)
        def wrapTheFunction():
            print "I am doing some before"
            a_func()
            print "I am doing some after"
        return wrapTheFunction
     
    

    下面我们看一下蓝本规范:

    from functools import wraps
    def decorator_name(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            if not can_run:
                return "Function will not run"
            return f(*args, **kwargs)
        return decorated
    
    @decorator_name
    def func():
        return "Function is running"
    can_run = True
    print(func())
    can_run = False
    print(func())
     
    

     注意:@wraps接受一个函数来进行装饰,并加入了复制函数名称,注释文档,参数列表等等的功能。这可以让我们在装饰器里面访问在装饰器之前的函数的属性。

    5.2 装饰器的使用场景:

            5.2.1 授权(Authorization)

                装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django框架中。这里是一个例子来使用基于装饰器的授权:

    from functools import wraps
    def requires_auth(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            auth = request.authorization
            if not auth or not check_auth(auth.username,auth.password):
                authenticate()
            return f(*args,**kwargs)
        return decorated

            5.2.2 日志(Logging)

    from functools import wraps
    def logit(func):
        @wraps(func)
        def with_logging(*args, **kwargs):
            print(func.__name__ + " was called")
            return func(*args, **kwargs)
        return with_logging
    @logit
    def addition_func(x):
        return x+x
    addition_func(2)
     
    

      5.3 在函数中嵌入装饰器

      我们回到日志的例子,并创建一个包裹函数,能让我们指定一个用于输出的日志文件。

    from functools import wraps
    def logit(logfile='out.log'):
        def logging_decorator(func):
            @wraps(func)
            def wrapped_function(*args, **kwargs):
                log_string = func.__name__ + " was called"
                print(log_string)
                with open(logfile, 'wb') as f:
                    f.write(log_string + '\n')
                return func(*args, **kwargs)
            return wrapped_function
        return logging_decorator
    
    @logit
    def myfunc():
        pass
     
    

      5.4 装饰器类

           现在我们有了能用于正式环境的logit装饰器,但当我们的应用的某些部分还比较脆弱时,异常也许是需要更紧急关注的事情。比方说有时候你只想打日志到一个文件,而有时你想把引起你注意的问题发送到一个email,同事也保留日志,留个记录。这是一个使用继承的场景,但目前为止我们只看到过用来构建装饰器的函数。

                The lucky is! 类也可以构建装饰器,现在我们用类重新构建logit

    class logit(object):
        def __init__(self, logfile='out.log'):
            self.logfile = logfile
        
        def __call__(self, func):
            @wraps(func)
            def wrapped_function(*args, **kwargs):
                log_string = func.__name__ + " was called"
                print(log_string)
                with open(self.logfile, 'wb') as f:
                    f.write(log_string + '\n')
                self.notify()
                return func(*args,**kwargs)
            return wrapped_function
            
        def notify(self):
            # 可以做一些其它行为
            pass
        
    @logit()
    def my_func():
        pass

            现在我们给logit创建子类,来添加email等功能

    class email_logit(logit):
    
        def __init__(self, email='admin@123.com', *args, **kwargs):
            self.email = email
            super(email_logit, self).__init__(*args, **kwargs)
    
        def notify(self):
            # 发送一封email
            pass
     
    

    从现在起,@email_logit会在logit基础上多发送一封邮件。

    注意:从以上方法中我们就可以发现__call__这种用法的好处,它在装饰器类和新写元类的时候起到了很大作用。

     6 容器

            python附带一个模块,它包含许多容器数据类型,名字叫做collections。我们将讨论它的作用和用法。

           6.1 defaultdict:

                defaultdict不需要检查key是否存在,我们一般这样用

    from collections import defaultdict
    ddl = defaultdict(list)
    ddl["x"].append(1)
    print ddl
    ddd = defaultdict(dict)
    ddd["x"]["a"] = 1
    print ddd
    
    defaultdict(<type 'list'>, {'x': [1]})
    defaultdict(<type 'dict'>, {'x': {'a': 1}})
     
    

           6.2 Counter

                counter是一个计数器,帮助我们对某项数据做统计。

    from collections import Counter
    c = Counter("aaaabbbc")
    print c
    
    d = {"a":1,"b":2,"c":3}
    c = Counter( k for k,v in d.items())
    print c
     
    

    还可以用counter来统计一个文件

                        此处没有弄明白,需要后期补上

            6.3 deque

                 deque提供了一个双向队列,可以从头尾两端添加或删除元素,类似于list

    from collections import deque
    dl = deque(range(5))
    print dl
    dl.popleft()
    print dl
    dl.pop()
    print dl
    dl.extendleft([-10])
    print dl
    dl.extend([10])
    print dl
     
    

    输出:

    deque([0, 1, 2, 3, 4])
    deque([1, 2, 3, 4])
    deque([1, 2, 3])
    deque([-10, 1, 2, 3])
    deque([-10, 1, 2, 3, 10])
     
    

            deque也可以限制列表的大小,先进先出

    dl = deque(maxlen=2)
    dl.append(1)
    dl.append(2)
    print dl
    dl.append(3)
    print dl

            输出

    deque([1, 2], maxlen=2)
    deque([2, 3], maxlen=2)
     
    

            6.4 namedtuple(命名元组)

    正常访问一个元组和访问list一样,都是通过下标来访问,命名元组可以提供类似于字典的访问方式,和tuple一样不可变。

    from collections import namedtuple
    Animal = namedtuple('Animal','name age type')
    perry = Animal(name='perry',age=10,type='cat')
    print perry
    print perry.name
     
    

    一个命名元组需要两个参数,他们是元组名称和字段名称。在上面的例子中,我们的元组名称是Animal,字段名称是'name,age,type'。

    namedtuple让你的元组变得自文档了。不必使用证书索引来访问一个命名元组,这让代码更易于维护。

    而且,namedtuple的每个实例没有对象字典(__dict__),所以它们更轻量,与普通的元组相比,并不需要更多的内存,这使他们比字典更快。

    然而,要记住它仍然是一个元组,属性在namedtuple中是不可变的,所以下面的代码不行:

    perry.age = 10

    命名元组(namedtuple)向后兼容元组,所以用下标访问也是可以的

    print perry[0]

    命名元组支持多态,可以转换为字典

    print (perry._asdict())

     7 上下文

            上下文管理器允许你在需要的时候,精确的分配和释放资源。

            使用上下文管理器最广泛的案例就是with语句。想象一下你有个需要结对执行的操作,然后还要在中间放置一段代码。

            上下文管理器就是专门让你做这种事情的,举个例子:

    with open('some_file', 'wb') as f:
        f.write("fuck u!")

            上面这段代码打开了一个文件,往里面写入了一些数据,然后关闭该文件。如果在往文件里写数据的时候发生异常,它也会尝试去关闭文件。上面的代码与下面的是等价的。

    file = open('some_file', 'wb')
    try:
        file.write("funck u !")
    finally:
        file.close()
     
    

    当与第一个例子比较的时候,有很多样板代码(boilerplate code)被消掉了。这就是with语句的主要优势,它确保我们的文件会被关闭,而不用关注嵌套代码如何退出。

    上下文的又一用例就是资源的加锁与解锁,以及关闭已经打开的文件(就像上面的例子)

        下面让我们自己实现一下上下文管理器

         一个上下文管理器的类,最起码要定义__enter__,__exit__方法。

    class File(object):
        def __init__(self,file_name, method):
            self.file_obj = open(file_name, method)
        def __enter__(self):
            return self.file_obj
        def __exit__(self, exc_type, exc_val, exc_tb):
            self.file_obj.close()
    
    with File('demo.txt', 'wb') as f:
        f.write('Hello')
     
    

            我们的__exit__函数接受三个参数。这些参数对于每个上下文管理器类中的__exit__方法都是必须得,我们来谈谈在底层都发生了什么。

    1,with语句先暂存了File类的__exit__方法

    2,然后它调用File类的__enter__方法

    3,__enter__方法返回打开文件对象

    4,打开的文件对象被传递给 f

    5,使用write来写文件

    6,调用之前暂存的__exit__

    7,__exit__关闭了文件

    8,处理异常

             我们目前还没有谈到__exit__方法的这三个参数,exc_type,exc_val,exc_tb,在with以下部分如果发生异常,python会将异常的type,value和traceback传递给__exit__方法。

      它让__exit__方法来决定如何关闭文件以及是否需要其他步骤,如果没有异常这三个参数的值为None

    class File(object):
        def __init__(self,file_name, method):
            self.file_obj = open(file_name, method)
        def __enter__(self):
            return self.file_obj
        def __exit__(self, exc_type, exc_val, exc_tb):
            print exc_val
            self.file_obj.close()
            return True
    
    with File('demo.txt', 'wb') as f:
        f.write_function('Hello')
     
    

            当发生异常的时候with语句会采取如下步骤:

       1,它把异常的type,value,traceback传递给__exit__方法

       2,它让__exit__方法来处理异常

       3,如果__exit__返回的是True,那么这个异常就优雅的处理了

       4,如果__exit__返回的是除了True以外的其它值,那么这个异常会被抛出

    基于装饰器和生成器来实现上下文管理

            python有个contextlib专门用于这个,我们可以使用一个生成器函数来实现一个上下文管理器,而不是使用一个类。

    from contextlib import contextmanager
    @contextmanager
    def open_file(name):
        f = open(name,'w')
        yield f
        f.close()
    
    with open_file('aaa.log') as of:
        of.write("fuck u!")

    这块我个人用得比较少,因为内部也是通过__enter__和__exit__来实现的。

     8 继承、多态、封装

             对于很多新入门的朋友来说面向对象的概念只停留在使用上,但深入理解面向对象并能用其特性使代码变得简洁,可复用,可扩展才算是真正的入门。python web开发中函数式编程较多,因为@staticmethod确实看起来很简洁,但是python语言有着和Java一样的特性,大家在使用上不应该只停留在函数式编程,利用面向对象才能让自己的工程更加“完美”。

            8.1什么是继承

                   它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。在python中子类可以继承一个或多个父类(纵向),一个父类也可以被多个子类继承,多对多的关系。

            8.2 什么时候使用继承

                   python中所有的类都使用了继承,比如class Test(object),例如sqlalchemy这种orm框架会用到Base类,新建的ORM类继承该类。很多框架提供的接口类都是需要继承的时候使用,或者当你需要拓展使用其它类时可以用继承。

            8.3 为什么使用继承

                    1、代码的冗余会大大减少,提升代码的复用

                    2、继承是多态的基础,没有继承就没有多态

                    3、提高代码的扩展性

             8.4 继承有哪些缺点

                    1、侵入性,只要继承了,父类的所有东西即刻拥有且必须有

                    2、降低类的灵活性,稍微有点约束,但这个作者在使用中没感觉多大约束

                    3、增加了耦合性,继承就相当于增加了耦合,但是这是必须要做的,要不就不叫继承了

             8.5 什么是多态

                    什么是多态呢? 网上查的说法是这样,让具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同的功能的函数。如下:

                    

    >>> a = "a"
    >>> b = 1
    >>> l = [1,2,3]
    >>> d = {"a":1}
    >>> str(a)
    'a'
    >>> str(b)
    '1'
    >>> str(l)
    '[1, 2, 3]'
    >>> str(d)
    "{'a': 1}"
    

                          其实我们在写代码的时候经常用到多态,只是有时候我们不知道,a,b,l,d这里是不同的数据类型,但为什么我都能用str()来对其转换成字符串格式,这就是多态的用法。

    >>> a.__str__()
    'a'
    >>> b.__str__()
    '1'
    >>> l.__str__()
    '[1, 2, 3]'
    >>> d.__str__()
    "{'a': 1}"

           上面的代码里的数据类型都有__str__()方法,函数的定义是这样的class Test(object):pass,这里的object就是所有类的爸爸,这就是为什么我说python里的类都使用继承,我们看下object类。

            

            object类里有该函数,所以我们只要对类执行str()都可以。这就是一个函数名实现了不同功能。

            Tips:这里作者提醒一下大家,像list,dict,tuple这些都是python内置的数据结构,python的灵活性非常高,我们也可以自己定义特定的数据结构,只要复写指定的函数就行。

            8.6 为什么使用多态

                    其实我们平时在开发的时候不会刻意的使用多态,个人认为多态有如下好处:

                    子类的功能可以被父类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护性。继承相当于从下面往上用,多态可以从上面往下用。

             8.7 封装

                    类的封装可有数据封装,方法封装,属性封装,封装的目的是为了保护隐私,隔离复杂性,我在python开发过程中很少刻意的去使用封装,个人认为在编写类的时候把变量,

               函数做好定义,提升复用性即可。python的私有变量也不完全是私有变量,也可以被引用,封装这块和Java有点不同。

     9 生成器,迭代器,可迭代对象

            9.1 生成器的定义

                    在Python中,一边循环一边计算的机制,称为生成器:generator

            生成器仅仅保存了一套生成数值的算法,并且没有让这个算法现在就开始执行,而是我什么时候调它,它什么时候开始计算一个新的值,并给你返回。

             9.2 为什么使用生成器

                   列表所有数据都在内存中,如果有海量数据的话将会非常耗内存。

                   如:仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。

                   如果列表元素按照某种算法推算出来,那我们就可以在循环的过程中不断推算出后续的元素,这样就不必创建完整的list,从而节省大量的空间。

                   简单一句话:我又想要得到庞大的数据,又想让它占用空间少,那就用生成器!

            9.3 怎么创建生成器

                   第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:

    >>> L = [x * x for x in range(10)]
    >>> L
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    >>> g = (x * x for x in range(10))
    >>> g
    <generator object <genexpr> at 0x7f6804d43c80>
    

            创建Lg的区别仅在于最外层的[]()L是一个list,而g是一个generator。

                  方法二, 如果一个函数中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator。调用函数就是创建了一个生成器(generator)对象,如下图:

                    

    def test():
        temp = 1
        while temp < 5:
            a = yield temp
            temp+=1
            
            
    t = test()
    print(t.__next__())
    print(t.__next__())
    print(t.__next__())
    print(t.__next__())
    print(t.__next__())
    
    1
    2
    3
    4
    Traceback (most recent call last):
      File "D:/pyprojects/DocAnd/test", line 11, in <module>
        print(a.__next__())
    StopIteration

            9.4  生成器的工作原理

                    (1)生成器(generator)能够迭代的关键是它有一个next()方法,

               工作原理就是通过重复调用next()方法,直到捕获一个异常。

                    (2)带有 yield 的函数不再是一个普通函数,而是一个生成器generator。

                可用next()调用生成器对象来取值。next 两种方式 t.__next__()  |  next(t),可用for 循环获取返回值,每执行一次,

                     取生成器里面一个值,实际使用中基本上不会用next()来获取下一个返回值,而是直接使用for循环来迭代。

                    (3)yield相当于 return 返回一个值,并且记住这个返回的位置,下次迭代时,代码从yield的下一条语句开始执行。

                    (4).send() 和next()一样,都能让生成器继续往下走一步(下次遇到yield停),但send()能传一个值,这个值作为yield表达式整体的结果

      ——换句话说,就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值,a = yield 5,第一次迭代到这里会返回5,a还没有赋值。第二次迭代时,使用.send(10),那么,就是强行修改yield 5表达式的值为10,本来是5的,那么a=10

    感受下yield返回值的过程(关注点:每次停在哪,下次又开始在哪)及send()传参的通讯过程,

    思考None是如何产生的(第一次取值:yield 返回了 i 值 0,停在yield i,temp没赋到值。第二次取值,开始在print,temp没被赋值,故打印None,i加1,继续while判断,yield  返回了 i 值 1,停在yield i):

    def test():
        temp = 1
        while temp < 5:
            a = yield temp
            print(a)
            temp+=1
    
    
    t = test()
    print(t.__next__())
    print(t.__next__())
    print(t.__next__())
    print(t.__next__())
    
    
    1
    None
    2
    None
    3
    None
    4

       再看如下代码,帮助理解代码的执行顺序。理解的关键在于:下次迭代时,代码从yield的下一条语句开始执行。

    #encoding:UTF-8
    def yield_test(n):
        for i in range(n):
            yield call(i)
            print("i=",i)
        print("Done.")
    
    def call(i):
        return i*2
    
    for i in yield_test(5):
        print(i,",")
    
    
    
    0 ,
    i= 0
    2 ,
    i= 1
    4 ,
    i= 2
    6 ,
    i= 3
    8 ,
    i= 4
    Done.


    10 自省/反射

            10.1 什么是自省

                    检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力。

                    说的更简单直白一点:自省就是面向对象的语言所写的程序在运行时,能够知道对象的类型。简单一句就是,运行时能够获知对象的类型。

                    例如python, buby, object-C, c++都有自省的能力,这里面的c++的自省的能力最弱,只能够知道是什么类型,而像python可以知道是什么类型,还有什么属性。

            最好的理解自省就是通过例子: Type introspection 这里是各种编程语言中自省(introspection)的例子(这个链接里的例子很重要,也许你很难通过叙述理解什么

            是introspection,但是通过这些例子,一下子你就可以理解了)

                    Python中比较常见的自省(introspection)机制(函数用法)有: dir(),type(), hasattr(), setattr(), getattr(), isinstance(),通过这些函数,我们能够在程序运行时得知对象的类型,

            判断对象是否存在某个属性,访问对象的属性。

            10.2 为什么需要自省机制

                    代码里的对象引用有时候不是固定的,比如说你想去根据变量或者字符串来引用对象的属性,这时候就需要灵活的自省机制,或者有时候我们需要动态判断变量类型,

             也需要自省。下面的代码是一个自动发邮件的程序,用到了自省,大家可以学习(以下代码无法直接执行)。

            

    class SendThread(object):
    
        def __init__(self):
            self.db = DbClass(PG_DB_URI)
            self.Session = self.db.make_session()
            self.pg_conn = self.Session()
    
        def start(self):
            while True:
                now = arrow.now().timestamp
                job_obj_list, job_total = DMLHandle.query_obj(Job, [Job.send_status == 1, Job.start_time < now], context=1)
                for job_obj in job_obj_list:
                    exec(
                        'self.{} = Process(name="{}"+str(uuid.uuid1()),target=getattr(self, "send_mail"), args=("{}",))'.format(
                            job_obj.job_name, job_obj.job_name, job_obj.id))
                    logging.warn("{} Job is starting ...".format(job_obj.job_name))
                    getattr(self, job_obj.job_name).start()
    
                for job_obj in job_obj_list:
                    if hasattr(self, job_obj.job_name):
                        status = getattr(self, job_obj.job_name).is_alive()
                        logging.warn("Heart Beat: {} [{}]".format(status, job_obj.job_name))
                time.sleep(3)
    
    
        def send_mail(self, job_id):
            pattern = re.compile(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')
            job_obj = DMLHandle.query_obj_scalar(Job, [Job.id == job_id ], context=1)
            if not job_obj or job_obj.send_status !=1:
                return
            update_flag = DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 2}, context=1)
            if not update_flag:
                DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 5, "failed_reason": "更新任务状态失败"}, context=1)
                return
            ms_obj = DMLHandle.query_obj_scalar(MailServer, [MailServer.mail_server == job_obj.mail_server], context=1)
            if not ms_obj:
                DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 5, "failed_reason": "邮件服务器未配置"}, context=1)
                return
            template_obj = DMLHandle.query_obj_scalar(Template, [ Template.id == job_obj.template_id ],context=1)
            if not template_obj:
                DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 5, "failed_reason": "邮件模板未配置"}, context=1)
                return
            content = template_obj.content
            url_list = re.findall(pattern, content)
            try:
                app = Flask(__name__)
                app.config.update(
                    MAIL_DEBUG=False,
                    MAIL_SERVER=ms_obj.server_domain,
                    MAIL_USERNAME=ms_obj.mail_server,
                    MAIL_PASSWORD=ms_obj.mail_password,
                    MAIL_DEFAULT_SENDER=(ms_obj.send_username, ms_obj.mail_server)
                )
                email = Mail(app)
                email.init_app(app)
            except Exception as e:
                logging.error("执行任务 {} 失败:{}".format(job_obj.job_name, str(e)))
                DMLHandle.update_obj(Job, [Job.id == job_id], {"failed_reason": "连接邮件服务器失败,初始化失败"}, context=1)
                return
    
            try:
                while True:
                    time.sleep(job_obj.send_speed)
                    receive_obj_list, receive_total = DMLHandle.query_obj(MailAll, [ MailAll.job_id == job_obj.id, MailAll.send_status == 0 ], limit=5, context=1)
                    if receive_total == 0:
                        break
                    #password = 'SHBLMMYARTDUDDLS'  # 邮箱密码:需要使用授权码
                    job_obj_inside = DMLHandle.query_obj_scalar(Job, [Job.id == job_id], context=1)
                    if job_obj_inside.send_status == 4:
                        return
    
                    with app.app_context():
                        for recv_obj in receive_obj_list:
                            s_code = pc.encrypt(str(recv_obj.id)).decode("utf-8")
                            send_content = content
                            now = arrow.now().timestamp
                            try:
                                for url in url_list:
                                    send_content = send_content.replace(url, url+'?user={}'.format(s_code))
                                msg = Message(subject=template_obj.mail_title,
                                              recipients=[recv_obj.mail])
                                msg.html = send_content
                                email.send(msg)
                            except Exception as e:
                                DMLHandle.update_obj(MailAll, [ MailAll.id == recv_obj.id ], {"send_status": 2, "send_time": now}, context=1)
                                logging.error(str(e))
                                continue
                            try:
                                DMLHandle.update_obj(MailAll, [ MailAll.id == recv_obj.id ], {"send_status": 1, "send_time": now}, context=1)
                            except:
                                logging.error("{} Job running failed".format(job_obj.job_name))
                                return
            except Exception as e:
                DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 5, "failed_reason": str(e)}, context=1)
                logging.error(str(e))
            logging.warning("{} Job is complete".format(job_obj.job_name))
            DMLHandle.update_obj(Job, [Job.id == job_id], {"send_status": 3}, context=1)
    
    
    if __name__ == "__main__":
        st = SendThread()
        logging.warning("Main Process Start")
        st.start()

                    
    11 闭包

            其实我们经常用到闭包,装饰器就是闭包的最好应用。

           11.1 什么是闭包

                    在一个外函数中定义了一个内函数,内函数里运用了外函数的临时变量,并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

    一般情况下,在我们认知当中,如果一个函数结束,函数的内部所有东西都会释放掉,还给内存,局部变量都会消失。但是闭包是一种特殊情况,如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到,就把这个临时变量绑定给了内部函数,然后自己再结束。

    #闭包函数的实例
    # outer是外部函数 a和b都是外函数的临时变量
    def outer( a ):
        b = 10
        # inner是内函数
        def inner():
            #在内函数中 用到了外函数的临时变量
            print(a+b)
        # 外函数的返回值是内函数的引用
        return inner
    
    if __name__ == '__main__':
        # 在这里我们调用外函数传入参数5
        #此时外函数两个临时变量 a是5 b是10 ,并创建了内函数,然后把内函数的引用返回存给了demo
        # 外函数结束的时候发现内部函数将会用到自己的临时变量,这两个临时变量就不会释放,会绑定给这个内部函数
        demo = outer(5)
        # 我们调用内部函数,看一看内部函数是不是能使用外部函数的临时变量
        # demo存了外函数的返回值,也就是inner函数的引用,这里相当于执行inner函数
        demo() # 15
    
        demo2 = outer(7)
        demo2()#17

    从上面例子是我写的一个最简单的很典型的闭包。我估计如果是初学的小伙伴,可能很多名词都不明白是什么意思,没关系,我把这些名词按照自己的理解去解释一下~

    1 外函数返回了内函数的引用:

      引用是什么?在python中一切都是对象,包括整型数据1,函数,其实是对象。

      当我们进行a=1的时候,实际上在内存当中有一个地方存了值1,然后用a这个变量名存了1所在内存位置的引用。引用就好像c语言里的指针,大家可以把引用理解成地址。a只不过是一个变量名字,a里面存的是1这个数值所在的地址,就是a里面存了数值1的引用。

      相同的道理,当我们在python中定义一个函数def demo():  的时候,内存当中会开辟一些空间,存下这个函数的代码、内部的局部变量等等。这个demo只不过是一个变量名字,它里面存了这个函数所在位置的引用而已。我们还可以进行x = demo, y = demo, 这样的操作就相当于,把demo里存的东西赋值给x和y,这样x 和y 都指向了demo函数所在的引用,在这之后我们可以用x() 或者 y() 来调用我们自己创建的demo() ,调用的实际上根本就是一个函数,x、y和demo三个变量名存了同一个函数的引用。

      不知道大家有没有理解,很晦涩,希望我说明白了我想表达的。

      有了上面的解释,我们可以继续说,返回内函数的引用是怎么回事了。对于闭包,在外函数outer中 最后return inner,我们在调用外函数 demo = outer() 的时候,outer返回了inner,inner是一个函数的引用,这个引用被存入了demo中。所以接下来我们再进行demo() 的时候,相当于运行了inner函数。

      同时我们发现,一个函数,如果函数名后紧跟一对括号,相当于现在我就要调用这个函数,如果不跟括号,相当于只是一个函数的名字,里面存了函数所在位置的引用。

    2 外函数把临时变量绑定给内函数:

      按照我们正常的认知,一个函数结束的时候,会把自己的临时变量都释放还给内存,之后变量都不存在了。一般情况下,确实是这样的。但是闭包是一个特别的情况。外部函数发现,自己的临时变量会在将来的内部函数中用到,自己在结束的时候,返回内函数的同时,会把外函数的临时变量送给内函数绑定在一起。所以外函数已经结束了,调用内函数的时候仍然能够使用外函数的临时变量。

      在我编写的实例中,我两次调用外部函数outer,分别传入的值是5和7。内部函数只定义了一次,我们发现调用的时候,内部函数是能识别外函数的临时变量是不一样的。python中一切都是对象,虽然函数我们只定义了一次,但是外函数在运行的时候,实际上是按照里面代码执行的,外函数里创建了一个函数,我们每次调用外函数,它都创建一个内函数,虽然代码一样,但是却创建了不同的对象,并且把每次传入的临时变量数值绑定给内函数,再把内函数引用返回。虽然内函数代码是一样的,但其实,我们每次调用外函数,都返回不同的实例对象的引用,他们的功能是一样的,但是它们实际上不是同一个函数对象。

    闭包中内函数修改外函数局部变量:

      在闭包内函数中,我们可以随意使用外函数绑定来的临时变量,但是如果我们想修改外函数临时变量数值的时候发现出问题了!咋回事捏??!!(哇哇大哭)

      在基本的python语法当中,一个函数可以随意读取全局数据,但是要修改全局数据的时候有两种方法:1 global 声明全局变量 2 全局变量是可变类型数据的时候可以修改

      在闭包内函数也是类似的情况。在内函数中想修改闭包变量(外函数绑定给内函数的局部变量)的时候:

        1 在python3中,可以用nonlocal 关键字声明 一个变量, 表示这个变量不是局部变量空间的变量,需要向上一层变量空间找这个变量。

        2 在python2中,没有nonlocal这个关键字,我们可以把闭包变量改成可变类型数据进行修改,比如列表。

    上代码!!!

    #修改闭包变量的实例
    # outer是外部函数 a和b都是外函数的临时变量
    def outer( a ):
        b = 10  # a和b都是闭包变量
        c = [a] #这里对应修改闭包变量的方法2
        # inner是内函数
        def inner():
            #内函数中想修改闭包变量
            # 方法1 nonlocal关键字声明
            nonlocal  b
            b+=1
            # 方法二,把闭包变量修改成可变数据类型 比如列表
            c[0] += 1
            print(c[0])
            print(b)
        # 外函数的返回值是内函数的引用
        return inner
    
    if __name__ == '__main__':
    
        demo = outer(5)
        demo() # 6  11

    从上面代码中我们能看出来,在内函数中,分别对闭包变量进行了修改,打印出来的结果也确实是修改之后的结果。以上两种方法就是内函数修改闭包变量的方法。

    还有一点需要注意:使用闭包的过程中,一旦外函数被调用一次返回了内函数的引用,虽然每次调用内函数,是开启一个函数执行过后消亡,但是闭包变量实际上只有一份,每次开启内函数都在使用同一份闭包变量

    上代码!

    #coding:utf8
    def outer(x):
        def inner(y):
            nonlocal x
            x+=y
            return x
        return inner
    
    
    a = outer(10)
    print(a(1)) //11
    print(a(3)) //14

    两次分别打印出11和14,由此可见,每次调用inner的时候,使用的闭包变量x实际上是同一个。


    12 C扩展


    15 函数缓存

    函数缓存允许我们将一个函数对于给定参数的返回值缓存起来。
    当一个I/O密集的函数被频繁使用相同的参数调用的时候,函数缓存可以节约时间。
    在Python 3.2版本以前我们只有写一个自定义的实现。在Python 3.2以后版本,有个lru_cache的装饰器,允许我们将一个函数的返回值快速地缓存或取消缓存。

    我们来看看,Python 3.2前后的版本分别如何使用它。

    我们来实现一个斐波那契计算器,并使用lru_cache

    from functools import lru_cache
    
    @lru_cache(maxsize=32)
    def fib(n):
        if n < 2:
            return n
        return fib(n-1) + fib(n-2)
    
    >>> print([fib(n) for n in range(10)])
    # Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

    那个maxsize参数是告诉lru_cache,最多缓存最近多少个返回值。

    我们也可以轻松地对返回值清空缓存,通过这样:


    16 Flask上下文
    18 多线程,多进程,协程
    20 socket和socketserver
    21 python加密

        整体思路

       1、修改python源码opcode为随机值

       修改下载后的Python源码包中opcode值(opcode可以理解为python读取代码的坐标,比如一个变量的opcode是5,则cpython读取这个变量时是从第5个字符串开始读的),修改后会导致关键变量的opcode混乱,除了自己的环境外,其他人都执行和解密不了了

       2、在修改好opcode的python环境,把所有py文件编译成pyc,然后删除原始py文件  

    #!/usr/bin/env python2.7
    # encoding:utf-8
    #FileName scramble-opcodes.py
    __author__ = 'mafei'
    import argparse
    import re
    import random
    import os
    python_version = 'Python-3.5.3'
    regex_for_opcode_h = r'^#define\s+(?P<name>[A-Z_]+)\s+(?P<code>\d+)(?P<extra>.*)'
    regex_for_opcode_py = r'^(?P<key>[a-z_]+)+\(\'+(?P<name>[A-Z_]+)+\'+\,\s+(?P<code>\d+)(?P<extra>.*)'
    
    
    try:
        from importlib.machinery import SourceFileLoader
    except ImportError:
        import imp
        
        
    class replace_opcode(object):
        
        def __init__(self):
            self.replace_dict = {}
            self.not_have_argument_code_list = []
            self.have_argument_code_list = []
        
        def set_list(self, reg, file):
            f1 = open(file, 'r+')
            infos = f1.readlines()
            f1.seek(0, 0)
            for line in infos:
                rex = re.compile(reg).match(line)
                if rex:
                    if rex.group('name') in ['CALL_FUNCTION', 'CALL_FUNCTION_KW', 'CALL_FUNCTION_EX', 'CALL_FUNCTION_VAR',
                                             'CALL_FUNCTION_VAR_KW']:
                        continue
                    elif int(rex.group('code')) < 90:
                        self.not_have_argument_code_list.append(int(rex.group('code')))
                    else:
                        self.have_argument_code_list.append(int(rex.group('code')))
        
        def replace_file(self, reg, file, is_update=False):
            if not is_update:
                self.set_list(reg, file)
            f1 = open(file, 'r+')
            infos = f1.readlines()
            f1.seek(0, 0)
            for line in infos:
                rex = re.compile(reg).match(line)
                if rex:
                    n = self.replace_code(rex, is_update)
                    line = line.replace(rex.group('code'), str(n))
                f1.write(line)
            f1.close()
            
        def replace_code(self, rex, is_update):
            if is_update:
                try:
                    n = self.replace_dict[rex.group('name')]
                except:
                    n = rex.group('code')
                return n
            if rex.group('name') == "CALL_FUNCTION":
                n = int(rex.group('code'))
            elif rex.group('name') in ['CALL_FUNCTION_KW', 'CALL_FUNCTION_EX', 'CALL_FUNCTION_VAR',
                                       'CALL_FUNCTION_VAR_KW']:
                n = int(rex.group('code'))
            else:
                if int(rex.group('code')) < 90:
                    n = random.choice(self.not_have_argument_code_list)
                    self.not_have_argument_code_list.remove(n)
                else:
                    n = random.choice(self.have_argument_code_list)
                    self.have_argument_code_list.remove(n)
            self.replace_dict[rex.group('name')] = n
            return n
            
        def run(self, source_directory):
            OPCODE_PY = 'Lib/opcode.py'
            OPTARGETS_H = "Include/opcode.h"
            print source_directory
            print('start run......', os.path.join(source_directory, OPCODE_PY))
            self.replace_file(reg=regex_for_opcode_py, file=os.path.join(source_directory, OPCODE_PY))
            print('run {} end'.format(os.path.join(source_directory, OPCODE_PY)))
            print('start run......', os.path.join(source_directory, OPCODE_PY))
            self.replace_file(reg=regex_for_opcode_h, file=os.path.join(source_directory, OPTARGETS_H), is_update=True)
            print('run {} end'.format(os.path.join(source_directory, OPTARGETS_H)))
            self.write_opcode_targets_contents()
            print('run {} end'.format(os.path.join(source_directory, OPTARGETS_H)))
        
        def write_opcode_targets_contents(self, file='Python/opcode_targets.h'):
            """Write C code contents to the target file object.
            """
            targets = ['_unknown_opcode'] * 256
            for opname, op in sorted(self.replace_dict.items(), key=lambda nc: nc[1]):
                targets[op] = "TARGET_%s" % opname
            with open(os.path.join(source_directory, file), 'w') as f:
                f.write("static void *opcode_targets[256] = {\n")
                sep = ',%s' % os.linesep
                f.write(sep.join(["    &&%s" % s for s in targets]))
                f.write("\n};\n")
                
                
    if __name__ == '__main__':
        parser = argparse.ArgumentParser(description='Scramble python opcodes table')
        parser.add_argument('--python-source', dest='src', type=str,
                            help='Python source code', required=True)
        args = parser.parse_args()
        source_directory = os.path.abspath(args.src)
        # main(source_directory)
        replace_opcode_class = replace_opcode()
        replace_opcode_class.run(source_directory)

          

    cd /opt/
    下载源码包 wget 
    解压   tar xJf Python-3.5.3.tar.xz

    执行修改opcode操作

    python scramble-opcodes.py --python-source=/opt/Python-3.5.3

    #后面几步就是标准的python安装步骤啦

    cd /opt/Python-3.5.3 

    ./configure --prefix=/opt/python-3.5.3 && make && make install

    加入系统路径

    export PATH=/opt/python-3.5.3/bin/:$PATH
    
    这时候执行python3就可以进入python3.5.3的修改opcode后的环境了

    加密Python代码(一定要在修改过opcode的Python环境执行,否则不生效的)

    #!/usr/bin/env python2.7
    # encoding:utf-8
    __author__ = 'mafei'
    import os
    import subprocess
    import argparse
    import sys
    def compile_py3(source_dir):
        g = os.walk(source_dir)
        # compileall.compile_dir(source_dir, maxlevels=100)
        subprocess.check_output('{} -m compileall -b {}'.format(sys.executable,source_dir),shell=True)
        for path,d,filelist in g:
            for filename in filelist:
                #对所有py文件进行加密并删除原始文件
                if os.path.splitext(filename)[-1] =='.py':
                    os.remove(os.path.join(path, filename))
                    print('compile {}'.format(os.path.join(path, filename)))
    if __name__ == '__main__':
        parser = argparse.ArgumentParser(description='Scramble python opcodes table')
        parser.add_argument('--python-source', dest='src', type=str,
                            help='Python source code', required=True)
        args = parser.parse_args()
        source_directory = os.path.abspath(args.src)
        compile_py3(source_directory)


    22 进程间通讯
    23 进程内存共享
    24 Python排序算法

     

    25 对象

    26 IO多路复用

    27 动态加载

    27.1 Python 模块动态加载技术

    C 语言中可以使用 dlopen,dlsym 和 dlclose 让程序在运行过程中按需加载和卸载动态库。Python 也支持这种方式,使用模块动态加载技术,我们可以把程序的配置文件写成可运行的 python 程序,在程序运行过程中可以动态去更新配置。当然也可以将 python 脚本作为业务逻辑加载到正在运行的主程序中,而不用重启服务

    作者在个人项目 pyed 中使用了这种技术,本文对个人研究和使用这种技术的一个总结。如有问题,欢迎大家讨论。

    python 提供了 exec 用于在程序中执行一段 python 代码,官方说明:

    exec_stmt ::=  "exec" or_expr ["in" expression ["," expression]]

    该语句可以使用 exec() 函数进行替代。来看一个简单的例子:

    >>> exec "print('Hello World')"
    Hello World
    >>>

    这种使用方式,在程序中其实作用不大,我们使用动态加载,一般是希望将一个模块中的某个变量或函数按需引入到正在执行的程序中,而不仅仅是去执行一下,打印一句 “Hello World”,exec 中的 in 解决了这个问题。

    in 的作用是将执行代码中的变量,函数或者类放入到一个字典中,这里再来看一个例子:

    >>> exec "a=100" in tmp
    >>> print tmp
    {'__builtins__': ..., 'a': 100}
    >>>

    上面的语句等效于:

    exec("a=100", tmp)

    执行结果中,tmp 除了我们给定的一个 a 变量,赋值为 100 外,还有一个 __builtins__ 成员,内容很多,这里使用 … 替代了实际的内容。如果要访问 a 的值,只需要像操作字典一样就行了:

    >>> print tmp["a"]
    100
    >>>

    27.2 简单的模块加载

    简单模块加载库

    按照上面的思路,我们构造了一个模块

    import traceback
    
    
    class loader(object):
        def __init__(self):
            pass
    
        def load(self, path):
            try:
                tmp = {}
                exec open(path).read() in tmp
                return tmp
            except:
                print("Load module [path %s] error: %s"
                      % (path, traceback.format_exc()))
                return None

    27.2.1 加载配置文件

    有一个配置文件 test.conf:

    $ cat test.conf
    addr="127.0.0.1"
    port=2539
    
    $

    使用以下代码加载它:

    load = loader()
    m = load.load("test.conf")
    addr = m["addr"]
    port = m["port"]
    print addr + ":" + str(port)

    执行结果:

    $ python loader.py
    127.0.0.1:2539
    $

    27.2.2 加载和执行函数

    如果要执行加载模块(test.py)中的函数:

    def greeting(name):
         print "Hello", name

    使用以下代码加载它:

    load = loader()
    m = load.load("test.py")
    func = m["greeting"]
    func("World")

    执行结果:

    $ python loader.py
    Hello World
    $

    27.2.3 加载和使用模块中的类

    按照上面的思路,如果加载的模块是一个类,其实调用方式也是大同小异的。

    修改 test.py

    class test(object):
        def __init__(self):
            pass
    
        def greeting(self, name):
            print "Hello", name

    使用以下代码加载它:

    load = loader()
    m = load.load("test.py")
    c = m["test"]
    print c
    print dir(c)
    t = c()
    t.greeting("World")

    执行结果:

    $ python loader.py
    <class 'test'>
    ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'greeting']
    Hello World
    $

    从上面可以看到 m[“test”] 是一个 class 类型,我们可以使用它创建类的实例,并调用实例方法

    27.2.4 加载的模块引入了其它模块

    如果在加载的模块中导入了其它模块,调用方法也是不变的。我们引入一个 test1,继承上例中的 test:

    from test import test
    
    
    class test1(test):
        def __init__(self):
            test.__init__(self)

    使用以下代码加载它:

    load = loader()
    m = load.load("subtest.py")
    c = m["test1"]
    print c
    print dir(c)
    t = c()
    t.greeting("World")

    执行结果:

    $ python loader.py
    <class 'test1'>
    ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'greeting']
    Hello World
    $

    27.3 改进模块加载

    上一节介绍了使用 exec … in … 的方式动态去加载模块。完成后可以直接使用返回的字典,访问模块中的变量,函数和类。但是从习惯上,我们更习惯使用模块去调用模块中的变量,函数和类,按此思路,我们对前面的模块加载器进行修改。

    新的模块加载器

    import traceback, types
    
    
    class loader(object):
        def __init__(self):
            pass
    
        def load(self, name, path):
            try:
                m = types.ModuleType(name)
                exec open(path).read() in m.__dict__
                return m
            except:
                print("Load module [path %s] error: %s"
                      % (path, traceback.format_exc()))
                return None

    这里使用 types.ModuleType 来构造一个模块 m,将 exec 生成的字典放入到 m.__dict__。这样就生成了一个简单的模块

    使用新的模块加载器

    待加载的模块:

    def test():
        s = 0
        for i in range(1000000):
            s += i
        print s

    执行逻辑:

    load = loader()
    m = load.load("test", "test.py")
    print m
    print m.__dict__
    m.test()

    执行结果:

    $ python loader.py
    <module 'test' (built-in)>
    {'__builtins__': ..., '__name__': 'test', 'test': <function test at 0x1007f7398>, '__doc__': None}
    499999500000
    $

    从执行结果,我们可以看到使用新的模块加载器,我们得到的是一个 module 类型的实例,其 __dict__ 中包含了 test 函数,我们可以直接使用 m.test() 调用该函数

    28 Monkey Patch

    展开全文
  • Python高级特性-列表解析

    千次阅读 2015-05-25 21:37:49
    列表解析是Python是迭代的一种,可以方便的实现for或while循环的功能,且运行速度相比要快的多,本文简要介绍Python列表解析的概念和应用。

    简介

    列表解析是Python是迭代的一种,可以方便的实现for或while循环的功能,且运行速度相比要快的多,本文简要介绍Python列表解析的概念和应用。

    列表解析

    先来看一个列表解析的简单例子:
    Python 2.7.9 (default, Dec 10 2014, 12:28:03) [MSC v.1500 64 bit (AMD64)] on win32
    Type "copyright", "credits" or "license()" for more information.
    >>> L = [1, 2, 3, 4, 5, 6]
    >>> L = [x + 10 for x in L]
    >>> print L
    [11, 12, 13, 14, 15, 16]
    >>> 

    列表解析写在一个方括号中,因为它们最终是构建一个新的列表的一种方式。它们以所组成的一个任意表达式开始,该表达式组成一个循环变量(x + 10),这之后跟着一个看做是一个for循环头部的部分,它声明了循环变量以及一个可迭代对象(for x in L)。

    要运行该表达式,Python解释器执行一个遍历L的迭代,按照顺序把x赋值给每个元素,并且收集对各元素运行左边的表达式的结果。得到的结果列表就是列表解析所表达的内容。

    优点:列表解析比手动的for循环语句运行快,因为它们的迭代在解释器内部是以C语言的速度执行的,而不是以手动Python代码执行的,特别是对于较大的数据集合,这是列表推导的一个主要的性能优点。

    高级应用

    实际上,列表解析可以有更高级的应用,作为一个特别有用的扩展,表达式嵌套的for循环可以有一个相关的if子句,来过滤那些测试不为真的结果项。我们这这里将上面例子中的计算结果中列表元素为偶数挑选处理,并将其其平方值组成列表:

    >>> L = [x ** 2 for x in L if x % 2 == 0]
    >>> print L
    [144, 196, 256]
    也可以对列表元素直接调用函数处理:
    >>> res = [ord(x) for x in ‘spam’]
    >>> res
    [115, 112, 97, 109]

    通用的列表解析结构如下所示:
    [ expression for target1 in iterable1 [if condition1]
              for target1 in iterable2 [ifcondition2] ...... ]

    总结

    列表解析是执行常见for循环任务的简明并且高效的方法:对可迭代对象内所有元素应用一个表达式,并收集结果。可以把列表解析转换为for循环,而列表解析表达式的一部分的语法看起来就像for循环的首行。但列表解析的运行速度要比for循环快的多。
    本质上列表解析应用了Python中的迭代协议,具体深层的概念,请参考迭代协议相关的高级特性说明。

    展开全文
  • 前言:本章的内容本来很简单,但是涉及到的理论部分相对较多,想要彻底弄懂前因后果需要具备以下几个知识点, (1)python的高阶函数 ...博客专栏分类,关于Python的各种高级特性都有说明 关于functoo...

    前言:本章的内容本来很简单,但是涉及到的理论部分相对较多,想要彻底弄懂前因后果需要具备以下几个知识点,

    (1)python的高阶函数

    (2)python的装饰器本质

    (3)Python的functools模块里面的偏函数的本质

    这三块类容我在之前的文章中已经有详细说明了,不再赘述,可以参考下面的连接中的文章:

    博客专栏分类,关于Python的各种高级特性都有说明

    关于functools模块以及偏函数的详细理解

    一、什么是函数柯里化(Currying)

    函数柯里化是解释型语言常见的一种特性,常见的语言比如python、javascript都支持函数柯里化

    有两种理解,当然这两种理解的本质实际上是表达同一层含义,如下:

    定义一:

    柯里化:一个函数中有个多个参数,想固定其中某个或者几个参数的值,而只接受另外几个还未固定的参数,这样函数演变成新的函数。

    定义二:

    函数柯里化(currying)又称部分求值。一个 currying 的函数首先会接受一些参数,接受了这些参数之后,该函数并不会立即求值,而是继续返回另外一个函数,刚才传入的参数在函数形成的闭包中被保存起来。待到函数被真正需要求值的时候,之前传入的所有参数都会被一次性用于求值。

    定义三:

    一些函数式语言的工作原理是将多参数函数语法转化为单参数函数集合,这一过程称为柯里化,它是以逻辑学家Haskell Curry的名字命名的。Haskell Curry从早期概念中发展出了该理论。其形式相当于将z = f(x, y)转换成z = f(x)(y)的形式,原函数由两个参数,现在变为两个接受单参数的函数,在函数式编程语言中,这种特性很常见。

    柯里化是一种将多参数函数转化为单参数高阶函数的技术。例如函数 f(x,y) -> z,对于给定的两个参数 x 和 y ,该函数会返回 z 值作为结果。可以将 f(x,y) 柯里化为两个函数:f(x)(y) -> z。

    即 

    f(x1,x2,x3,x4) ——> f(x1)(x2)(x3)(x4)

     

    1.1 从一个例子来说起——按照定义二来实现

    现在有一个函数add1,作用是实现三个数字相加,现在我们想要固定其中的第二个参数不变,调用的时候只指定第一个、第三个参数,艰难单的实现如下:

    def add1(a, b, c):
        return a + b + c
    
    def add2(a, b):
        return add1(a, 666, b)
    
    result = add2(12,13)
    print(result)
    

    不错,这就是函数柯里化的简单实现,因为在python中一切皆对象,函数也是一种对象,所以实现起来很简单灵活,

    1.2 python函数柯里化的不同实现方法——基于定义一、定义二

    (1)通过functools提供的偏函数来实现

    from functools import partial
    
    def add1(a, b, c):
        return a + b + c
    
    add2 = partial(add1, b=666)
    # 使用 partial 来实现偏函数时,要指定参数名
    result = add2(a = 12, c = 13)
    print(result)
    

    (2)定义两个函数,用函数2来包装函数1

    如上面所示,用add2来包装add1,这里不再赘述

    (3)使用lambda表达式来完成

    既然可以用一个函数包装另一个函数,自然可以使用lambda表达式来实现,如下所示:

    def add1(a, b, c):
        return a + b + c
    
    # 使用lambda表达式柯里化,固定第二个参数b=666
    add2 = lambda x,y:add_number(x,666,y)
    result = add2(12, 13)
    print(result)
    
    

    (4)使用python的装饰器来实现

    这就是最开始为什么强调深入理解python高级特性“装饰器”是非常有帮助的,关于python装饰器的系列文章,可以参考我前面的博客。代码如下:

    def add(a, b, c):
        return a + b + c
    
    def currying_add(func):
        def wrapper(a, c, b=666):
            return func(a, b, c)
        return wrapper
    
    
    result = currying_add(add)(1,2)
    print(result)  # 669

    如果是使用装饰器符号@该怎么实现呢?如下:

    def currying_add(func):
        def wrapper(a, c, b=666):
            return func(a, b, c)
        return wrapper
    
    # 使用装饰器符号来定义函数add,add = currying_add(add)
    @currying_add
    def add(a, b, c):
        return a + b + c
    
    result = add(1,2)
    print(result)  # 669

    (5)通过pymond模块;来实现currying

    from pymonad import curry

     

    1.2 python函数柯里化的不同实现方法——基于定义三

    这里是实现以下功能,一个函数有多个参数,将其拆分成几个函数,每一个函数只具有其中的部分参数,实现函数参数的拆分。

    如下代码:

    def add(x, y):
        return x + y
    
    # 柯里化
    def currying_add(x):
        def inc(y):
            return x + y
        return inc  # 返回函数
    
    result = currying_add(2)(3)
    print(result)   # 5

    柯里化的通俗总结:

    不管是基于第一种、第二种定义,他更加侧重于将一个函数的多个参数中的其中几个先固定,这样减少参数的数量

    还是基于第三中定义,它更加侧重于将函数的多个参数拆分成少量几个参数的组成,其实它们的本质都是一样,它们的实现核心思想也是一样的,真正核心的地方就在于“高阶函数”

    注意:柯里化的第一种定义、第二种定义看似是和函数定义默认值相似,但是默认值只能定义单个固定值,而柯里化能泛化出多个不同固定值但是相同计算规则的函数。

     

    二、什么是函数反柯里化?

    前面说的函数柯里化是实现这样的功能,即:

    f(x1,x2,x3,x4) ——> f(x1)(x2)(x3)(x4)

    那么实际上,函数的反柯里化就是恰好反过来的过程,即实现

    f(x1)(x2)(x3)(x4)——>f(x1,x2,x3,x4)

    含义的确是比较好理解,但是Python中比较少的用到,因为我们更多的使用函数柯里化操作,我们很少见到python中调用函数通过下面这样的方式调用吧,即:

    f(x1)(x2)(x3)(x4)

    所以函数反柯里化实际上一般都是和函数柯里化来结合使用,我们参见下面的例子:

    # 定义加法函数
    def add(x, y):
        return x + y
    
    # 柯里化
    def currying_add(x):
        def inc(y):
            return x + y
        return inc  # 返回函数
    
    # 因为currying_add()是一个柯里化函数,现在我针对他定义一个反柯里化函数,如下:
    def anti_currying_add(x,y):
        return currying_add(x)(y)
    
    result = anti_currying_add(2,3)  # 调用反柯里化函数
    
    print(result)   # 5

    就是这么简单,其实这一个特性最重要的理解就在于“高阶函数”。

    注意:

    我搜查了很多资料,下面几篇博客中所说的反柯里化是f(x,y)到f(x)(y),实际上应该是柯里化,有点错误的地方,如下:

    https://blog.csdn.net/qq_37160773/article/details/90301926

    https://blog.csdn.net/bq_cui/article/details/90054416

    https://zhuanlan.zhihu.com/p/69184694

     

    参考文献:

    https://www.cnblogs.com/yifeng555/p/8878474.html(推荐)

    https://www.cnblogs.com/yifeng555/p/8901751.html(推荐)

    http://blog.sina.com.cn/s/blog_7e04e0d00102yb0a.html

    https://www.cnblogs.com/readygood/p/10482475.html

    https://blog.csdn.net/qq_41635167/article/details/83151875

    https://www.cnblogs.com/soulgou123/p/9608749.html

     

    展开全文
  • 前言 文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,版权归原作者所有,如有问题请...将多个值赋值给一个变量时,python会自动将这些值封装成元组,这个特性称之为封包 当函数返回多个数值时...
  • Python代码的执行由Python 虚拟机(也叫解释器主循环,CPython版本)来控制,Python 在设计之初就考虑到要在解释器的主循环中,同时只有一个线程在执行,即在任意时刻,只有一个线程在解释器中运行。对Python 虚拟机的...
  • Python高级特性:类属性

    千次阅读 2015-03-20 21:46:20
    Python语言除了支持类实例的数据属性之外,还支持类属性,其为类本身所有。本文结合类属性的实例,介绍类属性的应用。
  • Python高级特性——多维数组切片(Slice)

    万次阅读 多人点赞 2018-01-04 15:25:40
    (1)我们先用arange函数创建一个数组并改变其维度,使之变成一个三维数组: >>> a = np.arange(24).reshape(2,3,4) >>> a array([[[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]], [[12, 13, 14, 15], ...
  • def make_gen(): for x in range(100): yield x ** 2
  • Python高级特性:私有属性

    千次阅读 2015-04-12 22:02:16
    在其它高级编程语言,如Java、C++等,均支持对属性和函数的访问控制,如public, private等关键字;也许你会好奇在Python语言是否支持数据隐藏功能呢。本文结合实际案例,来介绍Python编程语言中如何实现私有属性和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,432
精华内容 27,372
关键字:

python高级特性

python 订阅