python在linux下运行速度_在没安装python的linux环境下运行python脚本 - CSDN
精华内容
参与话题
  • Python用的好,猪也能飞起来。 今天,带大家学习如何让...python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。 “一行代码让python运行速度提高...

    Python用的好,猪也能飞起来。

    今天,带大家学习如何让Python飞起来的方法,干货满满哦!

    https://blog.csdn.net/qq_41597912/article/details/79372982

    python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。

    “一行代码让python的运行速度提高100倍”这绝不是哗众取宠的论调。

    我们来看一下这个最简单的例子,从1一直累加到1亿。

    最原始的代码:

    进群:548377875  即可获取数十套PDF哦!

    import time
    def foo(x,y):
     tt = time.time()
     s = 0
     for i in range(x,y):
     s += i
     print('Time used: {} sec'.format(time.time()-tt))
     return s
    print(foo(1,100000000))
    

    结果:

    Time used: 6.779874801635742 sec
    4999999950000000
    

    我们来加一行代码,再看看结果:

    from numba import jit
    import time
    @jit
    def foo(x,y):
     tt = time.time()
     s = 0
     for i in range(x,y):
     s += i
     print('Time used: {} sec'.format(time.time()-tt))
     return s
    print(foo(1,100000000))
    

    结果:

    Time used: 0.04680037498474121 sec
    4999999950000000
    

    是不是快了100多倍呢?

    那么下面就分享一下“为啥numba库的jit模块那么牛掰?”

    NumPy的创始人Travis Oliphant在离开Enthought之后,创建了CONTINUUM,致力于将Python大数据处理方面的应用。最近推出的Numba项目能够将处理NumPy数组的Python函数JIT编译为机器码执行,从而上百倍的提高程序的运算速度。

    Numba项目的主页上有Linux下的详细安装步骤。编译LLVM需要花一些时间。

    Windows用户可以从Unofficial Windows Binaries for Python Extension Packages下载安装LLVMPy、meta和numba等几个扩展库。

    下面我们看一个例子:

    import numba as nb
    from numba import jit
    @jit('f8(f8[:])')
    def sum1d(array):
     s = 0.0
     n = array.shape[0]
     for i in range(n):
     s += array[i]
     return s
    import numpy as np
    array = np.random.random(10000)
    %timeit sum1d(array)
    %timeit np.sum(array)
    %timeit sum(array)
    10000 loops, best of 3: 38.9 us per loop
    10000 loops, best of 3: 32.3 us per loop
    100 loops, best of 3: 12.4 ms per loop
    

    numba中提供了一些修饰器,它们可以将其修饰的函数JIT编译成机器码函数,并返回一个可在Python中调用机器码的包装对象。为了能将Python函数编译成能高速执行的机器码,我们需要告诉JIT编译器函数的各个参数和返回值的类型。我们可以通过多种方式指定类型信息,在上面的例子中,类型信息由一个字符串’f8(f8[:])’指定。其中’f8’表示8个字节双精度浮点数,括号前面的’f8’表示返回值类型,括号里的表示参数类型,’[:]’表示一维数组。因此整个类型字符串表示sum1d()是一个参数为双精度浮点数的一维数组,返回值是一个双精度浮点数。

    需要注意的是,JIT所产生的函数只能对指定的类型的参数进行运算:

    print sum1d(np.ones(10, dtype=np.int32))
    print sum1d(np.ones(10, dtype=np.float32))
    print sum1d(np.ones(10, dtype=np.float64))
    1.2095376009e-312
    1.46201599944e+185
    10.0
    

    如果希望JIT能针对所有类型的参数进行运算,可以使用autojit

    from numba import autojit
    @autojit
    def sum1d2(array):
     s = 0.0
     n = array.shape[0]
     for i in range(n):
     s += array[i]
     return s
    %timeit sum1d2(array)
    print sum1d2(np.ones(10, dtype=np.int32))
    print sum1d2(np.ones(10, dtype=np.float32))
    print sum1d2(np.ones(10, dtype=np.float64))
    10000 loops, best of 3: 143 us per loop
    10.0
    10.0
    10.0
    

    autoit虽然可以根据参数类型动态地产生机器码函数,但是由于它需要每次检查参数类型,因此计算速度也有所降低。numba的用法很简单,基本上就是用jit和autojit这两个修饰器,和一些类型对象。下面的程序列出numba所支持的所有类型:

    print [obj for obj in nb.__dict__.values() if isinstance(obj, nb.minivect.minitypes.Type)]
    [size_t, Py_uintptr_t, uint16, complex128, float, complex256, void, int , long double,
    unsigned PY_LONG_LONG, uint32, complex256, complex64, object_, npy_intp, const char *,
    double, unsigned short, float, object_, float, uint64, uint32, uint8, complex128, uint16,
    int, int , uint8, complex64, int8, uint64, double, long double, int32, double, long double,
    char, long, unsigned char, PY_LONG_LONG, int64, int16, unsigned long, int8, int16, int32,
    unsigned int, short, int64, Py_ssize_t]
    

    工作原理

    numba的通过meta模块解析Python函数的ast语法树,对各个变量添加相应的类型信息。然后调用llvmpy生成机器码,最后再生成机器码的Python调用接口。

    meta模块

    通过研究numba的工作原理,我们可以找到许多有用的工具。例如meta模块可在程序源码、ast语法树以及Python二进制码之间进行相互转换。下面看一个例子:

    def add2(a, b):
     return a + b
    

    decompile_func能将函数的代码对象反编译成ast语法树,而str_ast能直观地显示ast语法树,使用这两个工具学习Python的ast语法树是很有帮助的。

    from meta.decompiler import decompile_func
    from meta.asttools import str_ast
    print str_ast(decompile_func(add2))
    FunctionDef(args=arguments(args=[Name(ctx=Param(),
     id='a'),
     Name(ctx=Param(),
     id='b')],
     defaults=[],
     kwarg=None,
     vararg=None),
     body=[Return(value=BinOp(left=Name(ctx=Load(),
     id='a'),
     op=Add(),
     right=Name(ctx=Load(),
     id='b')))],
     decorator_list=[],
     name='add2')
    

    而python_source可以将ast语法树转换为Python源代码:

    from meta.asttools import python_source
    python_source(decompile_func(add2))
    def add2(a, b):
     return (a + b)
    

    decompile_pyc将上述二者结合起来,它能将Python编译之后的pyc或者pyo文件反编译成源代码。下面我们先写一个tmp.py文件,然后通过py_compile将其编译成tmp.pyc。

    with open("tmp.py", "w") as f:
     f.write("""
    def square_sum(n):
     s = 0
     for i in range(n):
     s += i**2
     return s
    """)
    import py_compile
    py_compile.compile("tmp.py")
    

    下面调用decompile_pyc将tmp.pyc显示为源代码:

    with open("tmp.pyc", "rb") as f:
     decompile_pyc(f)
    def square_sum(n):
     s = 0
     for i in range(n):
     s += (i ** 2)
     return s
    

    llvmpy模块

    LLVM是一个动态编译器,llvmpy则可以通过Python调用LLVM动态地创建机器码。直接通过llvmpy创建机器码是比较繁琐的,例如下面的程序创建一个计算两个整数之和的函数,并调用它计算结果。

    from llvm.core import Module, Type, Builder
    from llvm.ee import ExecutionEngine, GenericValue
    # Create a new module with a function implementing this:
    #
    # int add(int a, int b) {
    # return a + b;
    # }
    #
    my_module = Module.new('my_module')
    ty_int = Type.int()
    ty_func = Type.function(ty_int, [ty_int, ty_int])
    f_add = my_module.add_function(ty_func, "add")
    f_add.args[0].name = "a"
    f_add.args[1].name = "b"
    bb = f_add.append_basic_block("entry")
    # IRBuilder for our basic block
    builder = Builder.new(bb)
    tmp = builder.add(f_add.args[0], f_add.args[1], "tmp")
    builder.ret(tmp)
    # Create an execution engine object. This will create a JIT compiler
    # on platforms that support it, or an interpreter otherwise
    ee = ExecutionEngine.new(my_module)
    # Each argument needs to be passed as a GenericValue object, which is a kind
    # of variant
    arg1 = GenericValue.int(ty_int, 100)
    arg2 = GenericValue.int(ty_int, 42)
    # Now let's compile and run!
    retval = ee.run_function(f_add, [arg1, arg2])
    # The return value is also GenericValue. Let's print it.
    print "returned", retval.as_int()
    returned 142
    

    f_add就是一个动态生成的机器码函数,我们可以把它想象成C语言编译之后的函数。在上面的程序中,我们通过ee.run_function调用此函数,而实际上我们还可以获得它的地址,然后通过Python的ctypes模块调用它。

    首先通过ee.get_pointer_to_function获得f_add函数的地址:

    addr = ee.get_pointer_to_function(f_add)
    addr
    2975997968L
    

    然后通过ctypes.PYFUNCTYPE创建一个函数类型:

    import ctypes
    f_type = ctypes.PYFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
    

    最后通过f_type将函数的地址转换为可调用的Python函数,并调用它:

    f = f_type(addr)
    f(100, 42)
    142
    

    numba所完成的工作就是:

    解析Python函数的ast语法树并加以改造,添加类型信息;

    将带类型信息的ast语法树通过llvmpy动态地转换为机器码函数,然后再通过和ctypes类似的技术为机器码函数创建包装函数供Python调用。

    一行代码让你的python运行速度提高100倍!Python真强!

    展开全文
  • Python用的好,猪也能飞起来。python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。“一...
        

    Python用的好,猪也能飞起来。

    python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。

    “一行代码让python的运行速度提高100倍”这绝不是哗众取宠的论调。

    我们来看一下这个最简单的例子,从1一直累加到1亿。

    最原始的代码:

    import time
    def foo(x,y):
            tt = time.time()
            s = 0
            for i in range(x,y):
                    s += i
            print('Time used: {} sec'.format(time.time()-tt))
            return s
    
    print(foo(1,100000000))
    

    结果:

    Time used: 6.779874801635742 sec
    4999999950000000
    

    我们来加一行代码,再看看结果:

    from numba import jit
    import time
    @jit
    def foo(x,y):
            tt = time.time()
            s = 0
            for i in range(x,y):
                    s += i
            print('Time used: {} sec'.format(time.time()-tt))
            return s
    print(foo(1,100000000))
    

    结果:

    Time used: 0.04680037498474121 sec
    4999999950000000
    

    是不是快了100多倍呢?

    那么下面就分享一下“为啥numba库的jit模块那么牛掰?”

    NumPy的创始人Travis Oliphant在离开Enthought之后,创建了CONTINUUM,致力于将Python大数据处理方面的应用。最近推出的Numba项目能够将处理NumPy数组的Python函数JIT编译为机器码执行,从而上百倍的提高程序的运算速度。

    Numba项目的主页上有Linux下的详细安装步骤。编译LLVM需要花一些时间。

    下面我们看一个例子:

    import numba as nb
    from numba import jit
    
    @jit('f8(f8[:])')
    def sum1d(array):
        s = 0.0
        n = array.shape[0]
        for i in range(n):
            s += array[i]
        return s
    
    import numpy as np
    array = np.random.random(10000)
    %timeit sum1d(array)
    %timeit np.sum(array)
    %timeit sum(array)
    10000 loops, best of 3: 38.9 us per loop
    10000 loops, best of 3: 32.3 us per loop
    100 loops, best of 3: 12.4 ms per loop
    

    numba中提供了一些修饰器,它们可以将其修饰的函数JIT编译成机器码函数,并返回一个可在Python中调用机器码的包装对象。为了能将Python函数编译成能高速执行的机器码,我们需要告诉JIT编译器函数的各个参数和返回值的类型。我们可以通过多种方式指定类型信息,在上面的例子中,类型信息由一个字符串’f8(f8[:])’指定。其中’f8’表示8个字节双精度浮点数,括号前面的’f8’表示返回值类型,括号里的表示参数类型,’[:]’表示一维数组。因此整个类型字符串表示sum1d()是一个参数为双精度浮点数的一维数组,返回值是一个双精度浮点数。

    print sum1d(np.ones(10, dtype=np.int32))
    print sum1d(np.ones(10, dtype=np.float32))
    print sum1d(np.ones(10, dtype=np.float64))
    1.2095376009e-312
    1.46201599944e+185
    10.0
    

    如果希望JIT能针对所有类型的参数进行运算,可以使用autojit

    from numba import autojit
    @autojit
    def sum1d2(array):
        s = 0.0
        n = array.shape[0]
        for i in range(n):
            s += array[i]
        return s
    
    %timeit sum1d2(array)
    print sum1d2(np.ones(10, dtype=np.int32))
    print sum1d2(np.ones(10, dtype=np.float32))
    print sum1d2(np.ones(10, dtype=np.float64))
    10000 loops, best of 3: 143 us per loop
    10.0
    10.0
    10.0
    

    autoit虽然可以根据参数类型动态地产生机器码函数,但是由于它需要每次检查参数类型,因此计算速度也有所降低。numba的用法很简单,基本上就是用jit和autojit这两个修饰器,和一些类型对象。下面的程序列出numba所支持的所有类型:

    print [obj for obj in nb.__dict__.values() if isinstance(obj, nb.minivect.minitypes.Type)]
    [size_t, Py_uintptr_t, uint16, complex128, float, complex256, void, int , long double,
    unsigned PY_LONG_LONG, uint32, complex256, complex64, object_, npy_intp, const char *,
    double, unsigned short, float, object_, float, uint64, uint32, uint8, complex128, uint16,
    int, int , uint8, complex64, int8, uint64, double, long double, int32, double, long double,
    char, long, unsigned char, PY_LONG_LONG, int64, int16, unsigned long, int8, int16, int32,
    unsigned int, short, int64, Py_ssize_t]
    

    工作原理numba的通过meta模块解析Python函数的ast语法树,对各个变量添加相应的类型信息。然后调用llvmpy生成机器码,最后再生成机器码的Python调用接口。

    meta模块

    通过研究numba的工作原理,我们可以找到许多有用的工具。例如meta模块可在程序源码、ast语法树以及Python二进制码之间进行相互转换。下面看一个例子:

    def add2(a, b):
        return a + b
    

    decompile_func能将函数的代码对象反编译成ast语法树,而str_ast能直观地显示ast语法树,使用这两个工具学习Python的ast语法树是很有帮助的。

    from meta.decompiler import decompile_func
    from meta.asttools import str_ast
    print str_ast(decompile_func(add2))
    FunctionDef(args=arguments(args=[Name(ctx=Param(),
                                          id='a'),
                                     Name(ctx=Param(),
                                          id='b')],
                               defaults=[],
                               kwarg=None,
                               vararg=None),
                body=[Return(value=BinOp(left=Name(ctx=Load(),
                                                   id='a'),
                                         op=Add(),
                                         right=Name(ctx=Load(),
                                                    id='b')))],
                decorator_list=[],
                name='add2')
    

    而python_source可以将ast语法树转换为Python源代码:

    from meta.asttools import python_source
    python_source(decompile_func(add2))
    def add2(a, b):
        return (a + b)
    

    decompile_pyc将上述二者结合起来,它能将Python编译之后的pyc或者pyo文件反编译成源代码。下面我们先写一个tmp.py文件,然后通过py_compile将其编译成tmp.pyc。

    with open("tmp.py", "w") as f:
        f.write("""
    def square_sum(n):
        s = 0
        for i in range(n):
            s += i**2
        return s
    """)
    import py_compile
    py_compile.compile("tmp.py")
    

    下面调用decompile_pyc将tmp.pyc显示为源代码:

    with open("tmp.pyc", "rb") as f:
        decompile_pyc(f)
    def square_sum(n):
        s = 0
        for i in range(n):
            s += (i ** 2)
        return s
    

    llvmpy模块

    LLVM是一个动态编译器,llvmpy则可以通过Python调用LLVM动态地创建机器码。直接通过llvmpy创建机器码是比较繁琐的,例如下面的程序创建一个计算两个整数之和的函数,并调用它计算结果。

    from llvm.core import Module, Type, Builder
    from llvm.ee import ExecutionEngine, GenericValue
    
    # Create a new module with a function implementing this:
    #
    # int add(int a, int b) {
    #   return a + b;
    # }
    #
    my_module = Module.new('my_module')
    ty_int = Type.int()
    ty_func = Type.function(ty_int, [ty_int, ty_int])
    f_add = my_module.add_function(ty_func, "add")
    f_add.args[0].name = "a"
    f_add.args[1].name = "b"
    bb = f_add.append_basic_block("entry")
    
    # IRBuilder for our basic block
    builder = Builder.new(bb)
    tmp = builder.add(f_add.args[0], f_add.args[1], "tmp")
    builder.ret(tmp)
    
    # Create an execution engine object. This will create a JIT compiler
    # on platforms that support it, or an interpreter otherwise
    ee = ExecutionEngine.new(my_module)
    
    # Each argument needs to be passed as a GenericValue object, which is a kind
    # of variant
    arg1 = GenericValue.int(ty_int, 100)
    arg2 = GenericValue.int(ty_int, 42)
    
    # Now let's compile and run!
    retval = ee.run_function(f_add, [arg1, arg2])
    
    # The return value is also GenericValue. Let's print it.
    print "returned", retval.as_int()
    returned 142
    

    f_add就是一个动态生成的机器码函数,我们可以把它想象成C语言编译之后的函数。在上面的程序中,我们通过ee.run_function调用此函数,而实际上我们还可以获得它的地址,然后通过Python的ctypes模块调用它。

    addr = ee.get_pointer_to_function(f_add)
    addr
    2975997968L
    

    然后通过ctypes.PYFUNCTYPE创建一个函数类型:

    import ctypes
    f_type = ctypes.PYFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
    

    最后通过f_type将函数的地址转换为可调用的Python函数,并调用它:

    f = f_type(addr)
    f(100, 42)
    142
    

    numba所完成的工作就是:

    本文转载自公众号:python宝典,id:zhangqiye1993

    640?wx_fmt=gif
    END

    进学习交流群

    扫码加X先生微信进学习交流群

    640?wx_fmt=jpeg

    640?wx_fmt=png

    温馨提示

    欢迎大家转载、转发、留言、点赞支持X先生。

    文末广告点一下也是对X先生莫大的支持。

    更多精彩推荐,请关注我们

    640?wx_fmt=gif

    640?wx_fmt=jpeg

    640?wx_fmt=gif
    展开全文
  • python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。 “一行代码让python运行速度提高100倍”这绝不是哗众取宠的论调。 我们来看一下这个最简单的...

    本文转自:Python宝典 https://mp.weixin.qq.com/s/Vm0BKSljCzMMgRmIBbpxdQ

    python一直被病垢运行速度太慢,但是实际上python的执行效率并不慢,慢的是python用的解释器Cpython运行效率太差。

    “一行代码让python的运行速度提高100倍”这绝不是哗众取宠的论调。

    我们来看一下这个最简单的例子,从1一直累加到1亿。

    最原始的代码:

    import time
    def foo(x,y):
            tt = time.time()
            s = 0
            for i in range(x,y):
                    s += i
            print('Time used: {} sec'.format(time.time()-tt))
            return s
    
    print(foo(1,100000000))
    

    结果:

    Time used: 6.779874801635742 sec
    4999999950000000
    

    我们来加一行代码,再看看结果:

    from numba import jit
    import time
    @jit
    def foo(x,y):
            tt = time.time()
            s = 0
            for i in range(x,y):
                    s += i
            print('Time used: {} sec'.format(time.time()-tt))
            return s
    print(foo(1,100000000))
    

    结果:

    Time used: 0.04680037498474121 sec
    4999999950000000
    

    是不是快了100多倍呢?

    那么下面就分享一下“为啥numba库的jit模块那么牛掰?”

    NumPy的创始人Travis Oliphant在离开Enthought之后,创建了CONTINUUM,致力于将Python大数据处理方面的应用。最近推出的Numba项目能够将处理NumPy数组的Python函数JIT编译为机器码执行,从而上百倍的提高程序的运算速度。

    Numba项目的主页上有Linux下的详细安装步骤。编译LLVM需要花一些时间。
    Windows用户可以从Unofficial Windows Binaries for Python Extension Packages下载安装LLVMPy、meta和numba等几个扩展库。

    下面我们看一个例子:

    import numba as nb
    from numba import jit
    
    @jit('f8(f8[:])')
    def sum1d(array):
        s = 0.0
        n = array.shape[0]
        for i in range(n):
            s += array[i]
        return s
    
    import numpy as np
    array = np.random.random(10000)
    %timeit sum1d(array)
    %timeit np.sum(array)
    %timeit sum(array)
    10000 loops, best of 3: 38.9 us per loop
    10000 loops, best of 3: 32.3 us per loop
    100 loops, best of 3: 12.4 ms per loop
    

    numba中提供了一些修饰器,它们可以将其修饰的函数JIT编译成机器码函数,并返回一个可在Python中调用机器码的包装对象。为了能将Python函数编译成能高速执行的机器码,我们需要告诉JIT编译器函数的各个参数和返回值的类型。我们可以通过多种方式指定类型信息,在上面的例子中,类型信息由一个字符串’f8(f8[:])’指定。其中’f8’表示8个字节双精度浮点数,括号前面的’f8’表示返回值类型,括号里的表示参数类型,’[:]’表示一维数组。因此整个类型字符串表示sum1d()是一个参数为双精度浮点数的一维数组,返回值是一个双精度浮点数。
    需要注意的是,JIT所产生的函数只能对指定的类型的参数进行运算:

    print sum1d(np.ones(10, dtype=np.int32))
    print sum1d(np.ones(10, dtype=np.float32))
    print sum1d(np.ones(10, dtype=np.float64))
    1.2095376009e-312
    1.46201599944e+185
    10.0
    

    如果希望JIT能针对所有类型的参数进行运算,可以使用autojit

    from numba import autojit
    @autojit
    def sum1d2(array):
        s = 0.0
        n = array.shape[0]
        for i in range(n):
            s += array[i]
        return s
    
    %timeit sum1d2(array)
    print sum1d2(np.ones(10, dtype=np.int32))
    print sum1d2(np.ones(10, dtype=np.float32))
    print sum1d2(np.ones(10, dtype=np.float64))
    10000 loops, best of 3: 143 us per loop
    10.0
    10.0
    10.0
    

    autoit虽然可以根据参数类型动态地产生机器码函数,但是由于它需要每次检查参数类型,因此计算速度也有所降低。numba的用法很简单,基本上就是用jit和autojit这两个修饰器,和一些类型对象。下面的程序列出numba所支持的所有类型:

    print [obj for obj in nb.__dict__.values() if isinstance(obj, nb.minivect.minitypes.Type)]
    [size_t, Py_uintptr_t, uint16, complex128, float, complex256, void, int , long double,
    unsigned PY_LONG_LONG, uint32, complex256, complex64, object_, npy_intp, const char *,
    double, unsigned short, float, object_, float, uint64, uint32, uint8, complex128, uint16,
    int, int , uint8, complex64, int8, uint64, double, long double, int32, double, long double,
    char, long, unsigned char, PY_LONG_LONG, int64, int16, unsigned long, int8, int16, int32,
    unsigned int, short, int64, Py_ssize_t]
    

    工作原理
    numba的通过meta模块解析Python函数的ast语法树,对各个变量添加相应的类型信息。然后调用llvmpy生成机器码,最后再生成机器码的Python调用接口。

    meta模块

    通过研究numba的工作原理,我们可以找到许多有用的工具。例如meta模块可在程序源码、ast语法树以及Python二进制码之间进行相互转换。下面看一个例子:

    def add2(a, b):
        return a + b
    

    decompile_func能将函数的代码对象反编译成ast语法树,而str_ast能直观地显示ast语法树,使用这两个工具学习Python的ast语法树是很有帮助的。

    from meta.decompiler import decompile_func
    from meta.asttools import str_ast
    print str_ast(decompile_func(add2))
    FunctionDef(args=arguments(args=[Name(ctx=Param(),
                                          id='a'),
                                     Name(ctx=Param(),
                                          id='b')],
                               defaults=[],
                               kwarg=None,
                               vararg=None),
                body=[Return(value=BinOp(left=Name(ctx=Load(),
                                                   id='a'),
                                         op=Add(),
                                         right=Name(ctx=Load(),
                                                    id='b')))],
                decorator_list=[],
                name='add2')
    

    而python_source可以将ast语法树转换为Python源代码:

    from meta.asttools import python_source
    python_source(decompile_func(add2))
    def add2(a, b):
        return (a + b)
    

    decompile_pyc将上述二者结合起来,它能将Python编译之后的pyc或者pyo文件反编译成源代码。下面我们先写一个tmp.py文件,然后通过py_compile将其编译成tmp.pyc。

    with open("tmp.py", "w") as f:
        f.write("""
    def square_sum(n):
        s = 0
        for i in range(n):
            s += i**2
        return s
    """)
    import py_compile
    py_compile.compile("tmp.py")
    

    下面调用decompile_pyc将tmp.pyc显示为源代码:

    with open("tmp.pyc", "rb") as f:
        decompile_pyc(f)
    def square_sum(n):
        s = 0
        for i in range(n):
            s += (i ** 2)
        return s
    

    llvmpy模块

    LLVM是一个动态编译器,llvmpy则可以通过Python调用LLVM动态地创建机器码。直接通过llvmpy创建机器码是比较繁琐的,例如下面的程序创建一个计算两个整数之和的函数,并调用它计算结果。

    from llvm.core import Module, Type, Builder
    from llvm.ee import ExecutionEngine, GenericValue
    
    # Create a new module with a function implementing this:
    #
    # int add(int a, int b) {
    #   return a + b;
    # }
    #
    my_module = Module.new('my_module')
    ty_int = Type.int()
    ty_func = Type.function(ty_int, [ty_int, ty_int])
    f_add = my_module.add_function(ty_func, "add")
    f_add.args[0].name = "a"
    f_add.args[1].name = "b"
    bb = f_add.append_basic_block("entry")
    
    # IRBuilder for our basic block
    builder = Builder.new(bb)
    tmp = builder.add(f_add.args[0], f_add.args[1], "tmp")
    builder.ret(tmp)
    
    # Create an execution engine object. This will create a JIT compiler
    # on platforms that support it, or an interpreter otherwise
    ee = ExecutionEngine.new(my_module)
    
    # Each argument needs to be passed as a GenericValue object, which is a kind
    # of variant
    arg1 = GenericValue.int(ty_int, 100)
    arg2 = GenericValue.int(ty_int, 42)
    
    # Now let's compile and run!
    retval = ee.run_function(f_add, [arg1, arg2])
    
    # The return value is also GenericValue. Let's print it.
    print "returned", retval.as_int()
    returned 142
    

    f_add就是一个动态生成的机器码函数,我们可以把它想象成C语言编译之后的函数。在上面的程序中,我们通过ee.run_function调用此函数,而实际上我们还可以获得它的地址,然后通过Python的ctypes模块调用它。
    首先通过ee.get_pointer_to_function获得f_add函数的地址:

    addr = ee.get_pointer_to_function(f_add)
    addr
    2975997968L
    

    然后通过ctypes.PYFUNCTYPE创建一个函数类型:

    import ctypes
    f_type = ctypes.PYFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
    

    最后通过f_type将函数的地址转换为可调用的Python函数,并调用它:

    f = f_type(addr)
    f(100, 42)
    142
    

    numba所完成的工作就是:
    解析Python函数的ast语法树并加以改造,添加类型信息;
    将带类型信息的ast语法树通过llvmpy动态地转换为机器码函数,然后再通过和ctypes类似的技术为机器码函数创建包装函数供Python调用。

    展开全文
  • Linux下如何测试网速

    千次阅读 2018-05-29 15:33:38
    这里用到一个Python工具speedtest,speedtest是一个用Python编写的轻量级Linux命令行工具,在Python2.4至3.4版本均可运行。它基于Speedtest.net的基础架构来测量网络的上/下行速率。安装speedtest很简单——只需要...

    在Linux下如何测量下载和上传的速度?

    这里用到一个Python工具speedtest,speedtest是一个用Python编写的轻量级Linux命令行工具,在Python2.4至3.4版本下均可运行。它基于Speedtest.net的基础架构来测量网络的上/下行速率。安装speedtest很简单——只需要下载其Python脚本文件。

    1、安装speedtest

    $ wget https://raw.githubusercontent.com/sivel/speedtest-cli/master/speedtest.py
    $ chmod a+rx speedtest.py
    $ mv speedtest.py /usr/local/bin/speedtest
    $ chown root:root /usr/local/bin/speedtest

    2、调用speedtest命令

    $ speedtest

    输入这个命令后,它会自动发现离你最近的Speedtest.net服务器(地理距离),然后打印出测试的网络上/下行速率


    展开全文
  • Linux环境的Anaconda安装及使用

    万次阅读 2017-09-24 00:45:47
    Anaconda对于python就相当于Ubuntu对于Linux,即Anaconda是python的一个发行版,将python和许多常用的package打包,方便pythoners直接使用。像virtualenv、pyenv等工具管理虚拟环境,起到的作用也是类似的。Anaconda...
  • Python-Python及PyCharm的下载与安装

    万次阅读 2017-11-01 16:57:50
    1.Python的下载安装 2.pyCharm的下载安装
  • 最新Python学习路线+千锋Python课程大纲+Python视频教程+Python学习资料下载地址大合集 目前Python已经成为最受欢迎的程序设计语言之一。Python的设计哲学是“优雅”、“明确”、“简单”。 Python的优点(来自...
  • 百度云 python 客户端使用详解!

    万次阅读 2015-01-26 17:25:12
    Linux百度网盘Python客户端 2014-06-03 作者:佚名 来源:本站整理 浏览:474 评论:0 百度网盘是一款云存储服务器,用户可以轻松把自己的文件上传到网盘上,并可以跨终端随时随地查看和分享。小编本文提供...
  • 更多Python视频、源码、资料加群683380553免费获取 C / C ++编程语言主要是嵌入式系统编程,尽管它们有许多缺点。 另一方面,Python具有许多优点,使其成为嵌入式系统的优秀语言。 我们来看看每个的利弊,为什么你...
  • 1. 安装python3 1.拿到源码安装包(python3.6)—>去官网下载 2.解压安装包到/opt目录 3.安装编译过程中需要的依赖包:gcc,zlib,zlib-devel,openssl-devel 4.进入解压的安装包进行编译 ...
  • linux测试上下行最大网速和实时网速

    千次阅读 2018-03-02 14:12:39
     speedtest-cli是一个用Python编写的轻量级Linux命令行工具,在Python2.4至3.4版本均可运行。它基于 Speedtest.net的基础架构来测量网络的上/下行速率。安装speedtest-cli很简单——只需要下载其Python脚本文件。...
  • Phython是什么?

    万次阅读 2017-12-14 17:09:37
    也许最初设计Python这种语言的人并没有想到今天Python工业和科研上获得如此广泛的使用。著名的自由软件作者Eric Raymond他的文章《如何成为一名黑客》中,将Python列为黑客应当学习的四种编程语言之一,并建议...
  • tespeed - 测试网速的Python工具

    千次阅读 2016-06-06 23:17:09
    Linux用户喜欢终端中输入命令来完成任务,至少我就是这样的。 tespeed是一款有很多特性的python工具,可以终端测试网速。根据文档说明,它利用了speedtest.net的服务器,但是用户可以手动指定。 最初...
  • 一直以来我都使用 sublime text 作为主流开发的 ide ,但其实我开始我的 linux mint 系统使用 sublime text 配置 python3 的开发环境踩过的坑又何止一两个,所以有了这篇文章, 本片文章是针对linux系统配置 ...
  • 浅谈Python垃圾回收机制 使用C语言开发时代,我们的开发效率(生产力的问题)受牵制于内存释放、泄露等问题,于是普遍的口号---“指针好难学”。时过境迁,当今的流行的语言都配套了内存自动回收机制,从而使...
  • 对比java和python对比

    万次阅读 2017-11-09 14:23:57
    运行速度。java远优于标准python,pypy和cython可以追赶java,但是两者都没有成熟到可以做项目的程度。  4.可用资源。java一抓一大把,python很少很少,尤其是中文资源。  5.稳定程度。python3和2不兼容,造成了...
  • 比较环境,win7 64位,比较各种语言的整数型运算,下面的比较只作为单项比较。 具体方式,40000*40000遍历相加。为了防止编译器优化,生成一个随机数。 1:c#,NET2.0框架作为比较,不清楚这些年微软把...
  • 为啥 Python 运行速度这么慢 ?

    万次阅读 2018-08-04 08:49:33
    作者:Anthony Shaw 是 Python 软件基金会成员和 Apache 基金会成员。...Java在速度方面与C、C++、C#或Python相比如何?答案很大程度上取决于你运行的应用程序的类型。没有哪个基准测试程序尽善尽美,不过The Co...
  • Python解释器简介  解释器是一种让其他程序运行起来的程序,它是代码与机器的计算机硬件之间的软件逻辑层,Python解释器就是能够让Python程序机器上执行的一套程序。 当我们执行写好的Python代码时,Python解释...
  • 02-python你应该知道这这些

    万次阅读 多人点赞 2020-08-11 08:46:07
    python小白入门系列教程》专栏 • 第02篇 文| 曾庆林 深度好文:3588字 | 7分钟阅读 ​ 1. Python的出生 1989年 Guido van Rossum开始编写Python语言编辑器(龟叔为了打发无聊的圣诞节) 1991年 第一个...
1 2 3 4 5 ... 20
收藏数 65,600
精华内容 26,240
关键字:

python在linux下运行速度