精华内容
下载资源
问答
  • 现在许多的项目都要求实时性,如果直接用Java中的Runtime调用命令行界面中的python函数,则在运行python文件前每次都得重新导入对应的包,导致函数运行的时间格外地长。在最初没经过优化的时候大概每次执行函数都...

    现在许多的项目都要求实时性,如果直接用Java中的Runtime调用命令行界面中的python函数,则在运行python文件前每次都得重新导入对应的包,导致函数运行的时间格外地长。在最初没经过优化的时候大概每次执行函数都需要10多秒的时间。这样远远不能够满足在界面调用的时候实时性要求。

    最开始的想法是对python中的运行效率进行了极致优化,例如将jieba换成jieba_fast,砍除所有用不到的功能,对数据处理的结构,循环结构,变量使用进行了优化,使对应执行的效率大大提高,然而这个过程费力不讨好,经过了一系列优化之后,最终使Java中执行python函数的时间缩短至4秒多。4秒多,虽然在运行过程中可以等待一小段时间,但这样一来的话,如果要调用的函数次数一多,经过的时间也是漫长的,同时,用户的体验也不佳。

    经过对python中的结构进行分析了之后,优化到极致之后调用对应函数时间长的原因主要在于import对应包的阶段,而这个过程并不能通过优化来使时间缩短。

    例如,导入包

    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.animation as animation
    import scipy.ndimage
    import scipy.signal
    import sys
    import os

    下面是导入包需要的时间:

    matplotlib.pyplot   [300ms]
    numpy               [110ms]
    scipy.signal        [200ms]

    通过不断地搜索,发现可以用socket套接字编程来解决这个问题,将python上对应的接口转化为Server,利用client来访问Server上的接口,这样一来就不用反复import对应的包名了。

    服务器端:

    创建文件server.py

    # -- coding:utf-8 -*-
    
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib.animation as animation
    import scipy.ndimage
    import scipy.signal
    import sys
    import os
    
    import socket
    
    End='end send' #这里是为了判断对应的客户端请求命令的结束标志,目的是为了接受不超过8192个字符的(client)客户端请求。
    def recv_end(the_socket):
        total_data=[]
        while True:
            data=the_socket.recv(8192).decode('utf-8')
            print('1: ' + data)
            if End in data:
                total_data.append(data[:data.find(End)]) # 取'end send'前面的字段
                print( total_data)
                break
            total_data.append(data)
            if len(total_data)>1:
                #check if end_of_data was split
                last_pair=total_data[-2]+total_data[-1]
                print( last_pair)
                if End in last_pair:
                    total_data[-2]=last_pair[:last_pair.find(End)]
                    total_data.pop()
                    print( total_data)
                    break
        return ''.join(total_data)
    
    HOST = ''                 # Symbolic name meaning all available interfaces
    PORT = 50007              # Arbitrary non-privileged port
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((HOST, PORT))
    s.listen(1)
    while 1:
        conn, addr = s.accept()
        print('Connected by', addr) # e.g., Connected by ('127.0.0.1', 13917)
    
        data=recv_end(conn) # 接受客服端发送过来的数据,并进行处理
        method = data[0]
        subdata = data[1:]
    
        if (method == "1"): #当客户端传递过来的第一个字符为1时,params表示传递过来的参数
            params=subdata.split("|")
            #这里写要调用的函数
    
            #将结果返回给客户端
            conn.sendall((str((params[0],params[1]))).encode()) # 发送给客户端
        #elif method=='2': #当客户端传递过来的第一个字符为2时
        #   #需要执行的命令2
    
        # update plot
        # data = conn.recv(1024)
        # if not data: break
        # conn.sendall(("PLOTTING:" + str(data)).encode())
        # update plot
        conn.close()
    

    客户端:

    创建文件client.py

    # -- coding:utf-8 -*-
    #调用服务端接口客户端,以缩短调用时间
    
    import socket
    import sys
    
    HOST = '127.0.0.1'  # The remote host
    #HOST = ''  # The remote host
    PORT = 50007  # The same port as used by the server
    
    End='end send'
    
    def cl_test(test1,test2):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((HOST, PORT))
        s.sendall((str(1)+ test1+"|"+test2 +End).encode()) #str(1)表示第一个字符,然后在server端中规定字符串用|隔开
    
        data = []
        while True:
            subdata = s.recv(20480) #接受服务端返回参数
            if not subdata: break
            data.append(str(subdata, encoding='utf-8'))
        data = ''.join(data)
    
        s.close()
        return data #data是服务端的返回参数
    
    print( 'Received', repr(cl_test('wode','nide ne ')))

    运行流程:

    (1)首先开启服务端:

    python server.py

    开启后,服务器端等待接收数据。

    (2)启动客户端:

    python client.py

    客户端接收到服务器端发送回来的数据后,自动结束。

    (3)服务器端显示的数据:

    服务器端一直在运行状态,未结束。

     

    最后Socket相关函数和连接过程,请参见https://www.cnblogs.com/wumingxiaoyao/p/7047658.html

    展开全文
  • python模块导入和包

    2017-05-03 00:13:00
    1.一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。 2.模块目的和函数,对象等一样,是为了代码的复用性而存在的。即一个py程序写了很多功能,也可以被其他py程序调用。被调用后...

    一、何为模块

    1.一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。

    2.模块目的和函数,对象等一样,是为了代码的复用性而存在的。即一个py程序写了很多功能,也可以被其他py程序调用。被调用后被作为模块,此时会产生一个pyc的文件即为这个模块的缓存文件,相当于编译了模块文件使该py模块被调用的速度变快。一个大的项目一个人肯定是不行的,所以模块也为程序员相互间的合作提供了便利。

    二、模块妙用

    1.import

    只需要在py程序开头加上import 文件名(不能有.py后缀)。例如,模块的文件名是span.py,那么只需在自己的py程序加import span。

    2. import可以在程序的任意位置调用,但一次调用后会驻留内存,下次再调用会直接调用内存中的模块(python的优化)。

    3.个模块都是一个独立的名称空间,定义在这个模块中的函数,把这个模块的名称空间当做全局名称空间,这样我们在编写自己的模块时,就不用担心我们定义在自己模块中全局变量会在被导入时,与使用者的全局变量冲突。

    print('from the spam.py')
    
    money=1000
    
    def read1():
        print('spam->read1->money',1000)
    
    def read2():
        print('spam->read2 calling read')
        read1()
    
    def change():
        global money
        money=0
    #test.py
    import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.
    import spam
    import spam
    import spam
    
    '''
    执行结果:
    from the spam.py
    '''
    test.py
    #测试一:money与spam.money不冲突
    #test.py
    import spam 
    money=10
    print(spam.money)
    
    '''
    执行结果:
    from the spam.py
    1000
    '''
    test1.py
    #测试二:read1与spam.read1不冲突
    #test.py
    import spam
    def read1():
        print('========')
    spam.read1()
    
    '''
    执行结果:
    from the spam.py
    spam->read1->money 1000
    '''
    test2.py
    #测试三:执行spam.change()操作的全局变量money仍然是spam中的
    #test.py
    import spam
    money=1
    spam.change()
    print(money)
    
    '''
    执行结果:
    from the spam.py
    1
    '''
    test3.py

    so,在首次导入模块后,解释器做了三件事:①为源文件(spam模块)创建新的名称空间,在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。②在新创建的命名空间中执行模块中包含的代码③创建名字spam来引用该命名空间

    4.模块可以起别名

    if file_format == 'xml':
        import xmlreader as reader
    elif file_format == 'csv':
        import csvreader as reader
    data=reader.read_date(filename)
    #这也体现的程序的归一化思想

    5.一行导入多个模块(不建议,为了增加可读性一般一行只加一个)

    import sys,os,re

    三、import高级使用(form ... import ...)

    1. from 语句相当于import,也会创建新的名称空间,但是将spam中的名字直接导入到当前的名称空间中,在当前名称空间中,不需要使用“模块.”的方式,直接使用名字就可以了。

    from spam import read1,read2

    2.上述方法也可以使用as起别名

    from spam import read1 as read

    3.from spam import *

    把spam中所有的不是以下划线(_)开头的名字都导入到当前位置,大部分情况下我们的python程序不应该使用这种导入方式,因为*你不知道你导入什么名字,很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差,在交互式环境中导入时没有问题。

    from spam import * #将模块spam中所有的名字都导入到当前名称空间
    print(money)
    print(read1)
    print(read2)
    print(change)
    
    '''
    执行结果:
    from the spam.py
    1000
    <function read1 at 0x1012e8158>
    <function read2 at 0x1012e81e0>
    <function change at 0x1012e8268>
    '''

    可以在模块文件使用__all__=[]来控制*导入什么,通常用来发布新版本

    __all__=['money','read1']
    #在模块文件加入这个可以选择导入什么变量

    4.考虑到性能的原因,每个模块只被导入一次,放入字典sys.module中,如果你改变了模块的内容,你必须重启程序,python不支持重新加载或卸载之前导入的模块,

    有的同学可能会想到直接从sys.module中删除一个模块不就可以卸载了吗,注意了,你删了sys.module中的模块对象仍然可能被其他程序的组件所引用,因而不会被清楚。

    特别的对于我们引用了这个模块中的一个类,用这个类产生了很多对象,因而这些对象都有关于这个模块的引用。

    5.把模块当作脚本使用

    使用"__name__"等于"__main__"

    #fib.py
    
    def fib(n):    # write Fibonacci series up to n
        a, b = 0, 1
        while b < n:
            print(b, end=' ')
            a, b = b, a+b
        print()
    
    def fib2(n):   # return Fibonacci series up to n
        result = []
        a, b = 0, 1
        while b < n:
            result.append(b)
            a, b = b, a+b
        return result
    
    if __name__ == "__main__":
        import sys
        fib(int(sys.argv[1]))
    #可以自己测试使用

    6.模块搜索路径

    python解释器在启动时会自动加载一些模块,可以使用sys.modules查看。

    模块的查找顺序是:内存中已经加载的模块->内置模块->sys.path路径中包含的模块。

    在初始化后,python程序可以修改sys.path,路径放到前面的优先于标准库被加载。

    import sys
    sys.path.append('/a/b/c/d')
    sys.path.insert(0,'/x/y/z') #排在前的目录,优先被搜索
    #首先制作归档文件:zip module.zip foo.py bar.py
    
    import sys
    sys.path.append('module.zip')
    import foo,bar
    
    #也可以使用zip中目录结构的具体位置
    sys.path.append('module.zip/lib/python')

    至于.egg文件是由setuptools创建的包,这是按照第三方python库和扩展时使用的一种常见格式,.egg文件实际上只是添加了额外元数据(如版本号,依赖项等)的.zip文件。

    需要强调的一点是:只能从.zip文件中导入.py,.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载(此时setuptools等打包系统有时能提供一种规避方法),且从.zip中加载文件不会创建.pyc或者.pyo文件,因此一定要事先创建他们,来避免加载模块是性能下降。

     7.小提示

    ①模块名字区分大小写

    ②可以使用-O或者-OO转换python命令来减少编译模块的大小

    1 -O转换会帮你去掉assert语句
    2 -OO转换会帮你去掉assert语句和__doc__文档字符串
    3 由于一些程序可能依赖于assert语句或文档字符串,你应该在在确认需要的情况下使用这些选项。

    ③在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快,只有在模块被加载时,.pyc文件才是更快的

    ④只有使用import语句是才将文件自动编译为.pyc文件,在命令行或标准输入中指定运行脚本则不会生成这类文件,因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件

    模块可以作为一个脚本(使用python -m compileall)编译Python源
     
    python -m compileall /module_directory 递归着编译
    如果使用python -O -m compileall /module_directory -l则只一层
     
    命令行里使用compile()函数时,自动使用python -O -m compileall
     
    详见:https://docs.python.org/3/library/compileall.html#module-compileall

    8.标准模块

    ython提供了一个标准模块库,一些模块被内置到解释器中,这些提供了不属于语言核心部分的操作的访问,但它们是内置的,无论是为了效率还是提供对操作系统原语的访问。这些模块集合是依赖于底层平台的配置项,如winreg模块只能用于windows系统。特别需要注意的是,sys模块内建在每一个python解释器。

    9.dir

    内建函数dir是用来查找模块中定义的名字,返回一个有序字符串列表
    import spam
    dir(spam)

    如果没有参数,dir()列举出当前定义的名字

    dir()不会列举出内建函数或者变量的名字,它们都被定义到了标准模块builtin中,可以列举出它们,
    import builtins
    dir(builtins)

    四、包

    一、概念

    无论是import形式还是from...import形式,凡是在导入语句中(而不是在使用时)遇到带点的,都要第一时间提高警觉:这是关于包才有的导入语法。

    包的本质就是一个包含__init__.py文件的目录。

    注意:

    1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。

    2.对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。

    3.对比import item 和from item import name的应用场景:
    如果我们想直接使用name那必须使用后者

    二、from ... import ...

    需要注意的是from后import导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法

    三、__init__.py文件

    不管是哪种方式,只要是第一次导入包或者是包的任何其他部分,都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下),这个文件可以为空,但是也可以存放一些初始化包的代码。

    四、from glance.api import *

    此处是想从包api中导入所有,实际上该语句只会导入包api下__init__.py文件中定义的名字,我们可以在这个文件中定义__all___:

    #在__init__.py中定义
    x=10
    
    def func():
        print('from api.__init.py')
    
    __all__=['x','func','policy']

    此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容(versions仍然不能导入)。

    五、绝对导入和相对导入

    们的最顶级包glance是写给别人用的,然后在glance包内部也会有彼此之间互相导入的需求,这时候就有绝对导入和相对导入两种方式:

    绝对导入:以glance作为起始

    相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

    在glance/api/version.py
    
    #绝对导入
    from glance.cmd import manage
    manage.main()
    
    #相对导入
    from ..cmd import manage
    manage.main()

    注意:在使用pycharm时,有的情况会为你多做一些事情,这是软件相关的东西,会影响你对模块导入的理解,因而在测试时,一定要回到命令行去执行,模拟我们生产环境,你总不能拿着pycharm去上线代码吧!!!(因为本人一直使用pycharm)

    特别需要注意的是:可以用import导入内置或者第三方模块,但是要绝对避免使用import来导入自定义包的子模块,应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式。

    六、单独导入包

    单独导入包名称时不会导入包中所有包含的所有子模块。

    #在与glance同级的test.py中
    import glance
    glance.cmd.manage.main()
    
    '''
    执行结果:
    AttributeError: module 'glance' has no attribute 'cmd'
    
    '''

    解决方法:

    #glance/__init__.py
    from . import cmd
    #glance/cmd/__init__.py
    from . import manage

    执行:

    #在于glance同级的test.py中
    import glance
    glance.cmd.manage.main()

     

    常用的模块

    #traceback模块被用来跟踪异常返回信息
    
    try:  
        raise SyntaxError, "traceback test"  
    except:  
        traceback.print_exc() 
    
    
    #用于打印完整的错误信息。
    View Code
    #subprocess 我们通过标准库中的subprocess包来fork一个子进程,并运行一个外部的程序。
    import subprocess
    retcode = subprocess.call(["ls", "-l"])
    #和shell中命令ls -a显示结果一样
    print retcode
    
    """
    shell默认为False,在Linux下,shell=False时, Popen调用os.execvp()执行args指定的程序;shell=True时,如果args是字符串,Popen直接调用系统的Shell来执行args指定的程序,如果args是一个序列,则args的第一项是定义程序命令字符串,其它项是调用系统Shell时的附加参数。
    """
    retcode = subprocess.call("ls -l",shell=True)
    subprocess

    subprocess 待续

     

    paramiko模块提供了ssh及sft进行远程登录服务器执行命令和上传下载文件的功能

    # 建立一个sshclient对象
    ssh = paramiko.SSHClient()
    # 允许将信任的主机自动加入到host_allow 列表,此方法必须放在connect方法的前面
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    # 调用connect方法连接服务器
    ssh.connect(hostname='192.168.2.129', port=22, username='super', password='super')
    # 执行命令
    stdin, stdout, stderr = ssh.exec_command('df -hl')
    # 结果放到stdout中,如果有错误将放到stderr中
    print(stdout.read().decode())
    # 关闭连接
    ssh.close()
    基于用户名和密码的 sshclient 方式登录
    '''
    
    方法1是传统的连接服务器、执行命令、关闭的一个操作,有时候需要登录上服务器执行多个操作,比如执行命令、上传/下载文件,方法1则无法实现,可以通过如下方式来操作
    '''
    # 实例化一个transport对象
    trans = paramiko.Transport(('192.168.2.129', 22))
    # 建立连接
    trans.connect(username='super', password='super')
    
    # 将sshclient的对象的transport指定为以上的trans
    ssh = paramiko.SSHClient()
    ssh._transport = trans
    # 执行命令,和传统方法一样
    stdin, stdout, stderr = ssh.exec_command('df -hl')
    print(stdout.read().decode())
    
    # 关闭连接
    trans.close()
    基于用户名和密码的 transport 方式登录
    # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
    pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
    # 建立连接
    ssh = paramiko.SSHClient()
    ssh.connect(hostname='192.168.2.129',
                port=22,
                username='super',
                pkey=pkey)
    # 执行命令
    stdin, stdout, stderr = ssh.exec_command('df -hl')
    # 结果放到stdout中,如果有错误将放到stderr中
    print(stdout.read().decode())
    # 关闭连接
    ssh.close()
    基于公钥密钥的 SSHClient 方式登录
    # 指定本地的RSA私钥文件,如果建立密钥对时设置的有密码,password为设定的密码,如无不用指定password参数
    pkey = paramiko.RSAKey.from_private_key_file('/home/super/.ssh/id_rsa', password='12345')
    # 建立连接
    trans = paramiko.Transport(('192.168.2.129', 22))
    trans.connect(username='super', pkey=pkey)
    
    # 将sshclient的对象的transport指定为以上的trans
    ssh = paramiko.SSHClient()
    ssh._transport = trans
    
    # 执行命令,和传统方法一样
    stdin, stdout, stderr = ssh.exec_command('df -hl')
    print(stdout.read().decode())
    
    # 关闭连接
    trans.close()
    基于密钥的 Transport 方式登录

    传文件 SFTP

    # 实例化一个trans对象# 实例化一个transport对象
    trans = paramiko.Transport(('192.168.2.129', 22))
    # 建立连接
    trans.connect(username='super', password='super')
    
    # 实例化一个 sftp对象,指定连接的通道
    sftp = paramiko.SFTPClient.from_transport(trans)
    # 发送文件
    sftp.put(localpath='/tmp/11.txt', remotepath='/tmp/22.txt')
    # 下载文件
    # sftp.get(remotepath, localpath)
    trans.close()
    实例
    '''
    以上操作都是基本的连接,如果我们想实现一个类似xshell工具的功能,登录以后可以输入命令回车后就返回结果:
    '''
    import paramiko
    import os
    import select
    import sys
    
    # 建立一个socket
    trans = paramiko.Transport(('192.168.2.129', 22))
    # 启动一个客户端
    trans.start_client()
    
    # 如果使用rsa密钥登录的话
    '''
    default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
    prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
    trans.auth_publickey(username='super', key=prikey)
    '''
    # 如果使用用户名和密码登录
    trans.auth_password(username='super', password='super')
    # 打开一个通道
    channel = trans.open_session()
    # 获取终端
    channel.get_pty()
    # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
    channel.invoke_shell()
    # 下面就可以执行你所有的操作,用select实现
    # 对输入终端sys.stdin和 通道进行监控,
    # 当用户在终端输入命令后,将命令交给channel通道,这个时候sys.stdin就发生变化,select就可以感知
    # channel的发送命令、获取结果过程其实就是一个socket的发送和接受信息的过程
    while True:
        readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
        # 如果是用户输入命令了,sys.stdin发生变化
        if sys.stdin in readlist:
            # 获取输入的内容
            input_cmd = sys.stdin.read(1)
            # 将命令发送给服务器
            channel.sendall(input_cmd)
    
        # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
        if channel in readlist:
            # 获取结果
            result = channel.recv(1024)
            # 断开连接后退出
            if len(result) == 0:
                print("\r\n**** EOF **** \r\n")
                break
            # 输出到屏幕
            sys.stdout.write(result.decode())
            sys.stdout.flush()
    
    # 关闭通道
    channel.close()
    # 关闭链接
    trans.close()
    实现输入命令立马返回结果的功能
    import paramiko
    import os
    import select
    import sys
    import tty
    import termios
    
    '''
    实现一个xshell登录系统的效果,登录到系统就不断输入命令同时返回结果
    支持自动补全,直接调用服务器终端
    
    '''
    # 建立一个socket
    trans = paramiko.Transport(('192.168.2.129', 22))
    # 启动一个客户端
    trans.start_client()
    
    # 如果使用rsa密钥登录的话
    '''
    default_key_file = os.path.join(os.environ['HOME'], '.ssh', 'id_rsa')
    prikey = paramiko.RSAKey.from_private_key_file(default_key_file)
    trans.auth_publickey(username='super', key=prikey)
    '''
    # 如果使用用户名和密码登录
    trans.auth_password(username='super', password='super')
    # 打开一个通道
    channel = trans.open_session()
    # 获取终端
    channel.get_pty()
    # 激活终端,这样就可以登录到终端了,就和我们用类似于xshell登录系统一样
    channel.invoke_shell()
    
    # 获取原操作终端属性
    oldtty = termios.tcgetattr(sys.stdin)
    try:
        # 将现在的操作终端属性设置为服务器上的原生终端属性,可以支持tab了
        tty.setraw(sys.stdin)
        channel.settimeout(0)
    
        while True:
            readlist, writelist, errlist = select.select([channel, sys.stdin,], [], [])
            # 如果是用户输入命令了,sys.stdin发生变化
            if sys.stdin in readlist:
                # 获取输入的内容,输入一个字符发送1个字符
                input_cmd = sys.stdin.read(1)
                # 将命令发送给服务器
                channel.sendall(input_cmd)
    
            # 服务器返回了结果,channel通道接受到结果,发生变化 select感知到
            if channel in readlist:
                # 获取结果
                result = channel.recv(1024)
                # 断开连接后退出
                if len(result) == 0:
                    print("\r\n**** EOF **** \r\n")
                    break
                # 输出到屏幕
                sys.stdout.write(result.decode())
                sys.stdout.flush()
    finally:
        # 执行完后将现在的终端属性恢复为原操作终端属性
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
    
    # 关闭通道
    channel.close()
    # 关闭链接
    trans.close()
    支持tab自动补全

     pip install -i https://pypi.tuna.tsinghua.edu.cn/simple nympy  使用清华源,5分更新一次。

    转载于:https://www.cnblogs.com/drchen/p/6799551.html

    展开全文
  • python3导入自定义模块

    2017-04-13 11:13:00
    模块是个好东西啊,大牛们开源共享许多模块也加快了大家开发的速度,许多开源模块可以在这里找到 ↓ https://pypi.python.org/pypi 因为刚入门所有有很多细节不懂,在网上搜寻资料的时候发现各位大神们的教程实在...

    模块是个好东西啊,大牛们开源共享许多模块也加快了大家开发的速度,许多开源模块可以在这里找到 ↓

    https://pypi.python.org/pypi

    因为刚入门所有有很多细节不懂,在网上搜寻资料的时候发现各位大神们的教程实在太过于精简,让我这个菜鸟很辛苦的才操作成功。

    因此在这里记录下来。


    开始

    第一种,直接 import

    这里有个大前提,就是你的py执行文件和模块同属于同个目录(父级目录),如下图:

    01

    • main.py 和 pwcong模块同在python目录
    • 执行文件为main.py
    • pwcong文件夹为一个模块

    我把pwcong模块提供的函数写在 __init__.py 里,里面只提供一个 hi 函数:

    # pwcong 模块的 __init__.py
    # -*- coding: utf-8 -*-
    
    def hi():
        print("hi")

     

    执行文件main.py直接import模块:

    # main.py
    # -*- coding: utf-8 -*-
    
    import pwcong
    
    pwcong.hi()
    

     

    接着我们运行一下main.py可以看到命令行窗口输出了一句 hi ,第一种方式完成。

    使用模块方式为:先导入-》接着输入模块.变量|函数, 如上面例子的 pwcong.hi()


    第二种,通过sys模块导入自定义模块的path

    如果执行文件和模块不在同一目录,这时候直接import是找不到自定义模块的。如下图:

    02

    • 执行文件main.py在main目录下
    • pwcong模块在python目录下

    sys模块是Python内置的,因此我们导入自定义模块的步骤如下:

    1. 先导入sys模块

    2. 然后通过sys.path.append(path) 函数来导入自定义模块所在的目录

    3. 导入自定义模块。

    这时候 main.py 这样写:

    # main.py
    # -*- coding: utf-8 -*-
    
    import sys
    sys.path.append(r"C:\Users\Pwcong\Desktop\python")
    
    import pwcong
    
    pwcong.hi()
    

    最后执行main.py文件,最终输出 hi ,第二种方式完成。


    第三种,通过pth文件找到自定义模块

    这个方法原理就是利用了系统变量,python会扫描path变量的路径来导入模块,可以在系统path里面添加。但是我还是推荐使用pth文件添加。

    模块和执行文件目录结构跟上图一样:

    02

    • 执行文件main.py在main目录下
    • pwcong模块在python目录下

    我们创建一个 module_pwcong.pth 文件,里面内容就是 pwcong模块所在的目录:

    C:\Users\Pwcong\Desktop\python

    将该 module_pwcong.pth 文件放到这里: 
    python安装目录\Python35\Lib\site-packages

    例如我的: 
    03

    然后 main.py 导入并使用自定义模块:

    # -*- coding: utf-8 -*-
    
    import pwcong
    
    pwcong.hi()
    

    最后执行 main.py 文件,可以输出 hi ,第三种方式完成。


    结束

    到这里三种导入自定义模块的方式栗子就完成了,我写的应该很详细了吧 :)

    转载于:https://www.cnblogs.com/duex/p/6703009.html

    展开全文
  • Python中动态导入模块

    2019-07-22 14:50:14
    如果导入模块不存在,Python解释器会报 ModuleNotFoundError 错误,一般通过 pip install xxx(模块名) 下载就可以了 有时两个不同的模块提供了相同的功能,比如 StringIO 和 cStringIO 都提供了StringIO这个功能...

    如果导入的模块不存在,Python解释器会报 ModuleNotFoundError 错误,一般通过 pip install xxx(模块名) 下载就可以了


    有时两个不同的模块提供了相同的功能,比如 StringIO 和 cStringIO 都提供了StringIO这个功能。


    这是因为Python是动态语言,解释执行,因此Python代码运行速度慢。
    如果要提高Python代码的运行速度,最简单的方法是把某些关键函数用 C 语言重写,这样就能大大提高执行速度。

    同样的功能,StringIO 是纯Python代码编写的,而 cStringIO 部分函数是 C 写的,因此 cStringIO 运行速度更快。


    利用ModuleNotFoundErrorr错误,经常在Python中动态导入模块:

    try:
        from cStringIO import StringIO
    except ImportError:
        from StringIO import StringIO
    

    上述代码先尝试从cStringIO导入,如果失败了(比如cStringIO没有安装),再尝试从StringIO导入。这样,如果cStringIO模块存在,则我们将获得更快的运行速度,如果cStringIO不存在,则顶多代码运行速度会变慢,但不会影响代码的正常执行。

    拓展1: try 的作用是捕获错误,并在捕获到指定错误时执行 except 语句。

    任务:
    利用import … as …,动态导入不同名称的模块。

    Python 自2.6版本及以后提供了json 模块,但Python 2.5以及更早版本没有json模块,不过可以通过安装simplejson模块,这两个模块提供的函数签名和功能都一模一样。

    写出导入json 模块的代码,能在Python 2.5及目前版本上都能正常运行。

    try:
        import simplejson as json
    except ImportError:
        import json
    
    print(json.dumps({'python': 3.6}))
    

    结果为: {“python”: 3.6}

    拓展2
    Python中的 json 模块提供了一种很简单的方式来编码解码JSON数据。 其中两个主要的函数是 json.dumps() 和 json.loads()。

    • json.dumps可以将一个Python数据结构转换为JSON:
      栗子1:
    import json
    data = {
        'name': 'guoguo',
        'age': 10,
    }
    json_str = json.dumps(data)
    print(json_str)
    

    结果为: {“name”: “guoguo”, “age”: 10}

    • json.loads将一个JSON编码的字符串转换回一个Python数据结构:
      栗子2:
    import json
    data = {
        'name': 'guoguo',
        'age': 10,
    }
    # Python--> Json
    json_str = json.dumps(data)
    print('This is json_str data structure-->', json_str)
    
    # Json-> Python
    data = json.loads(json_str)
    print('This is python data structure-->', data)
    

    结果为: This is json_str data structure–> {“name”: “guoguo”, “age”: 10}
    This is python data structure–> {‘name’: ‘guoguo’, ‘age’: 10}

    • json.dump() 和 json.load() 来编码和解码JSON数据,用于处理文件
      栗子3:
    with open('test.json', 'w') as f:
        json.dump(data, f)
     
    with open('test.json', 'r') as f:
        data = json.load(f)
    

    大家加油!
    学习链接: https://www.imooc.com/code/6071
    https://blog.csdn.net/lizhixin705/article/details/82344209

    展开全文
  • anaconda或者spyder解决python导入cv2模块失败的最快安装方法 上面是没有安装好opencv2出现导入模块失败的情况 网上已经存在一种方法,并且这种方法是肯定可以用的,但是就是太慢了,基本上是几kb/s的速度,相当...
  • 模块导入方式 1、import导入 import 模块名称 特点:导入的是模块中全部函数,程序封装打包后文件体积较大,运行速度较慢。 使用模块时需要加入函数前缀,例如: import math a = math.sqrt(16) #导入math模块使用...
  • 之后导入相同的模块时,会跳过这三个步骤,而只提取内存中已加载的模块对象,速度要快的多。 NOTE: 1. Python把已加载的模块放在内置的sys.modules字典中,在import操作开始时会确认引用的模块是否已加载。如果想看...
  • Python 模块与包

    2019-07-16 10:14:01
    一、模块 何为模块:逻辑上来说模块就是一组功能的组合;...该种调用在调用时,import首先运行一遍模块中所有的函数,如果模块较大时,代码运行速度较慢,改掉用只是导入模块,还需要用"."方法来引用这些 2、...
  • Python模块搜索及模块安装

    千次阅读 2015-01-01 05:24:32
    【import模块】 和C中的#include不同,Python中的import...之后导入相同的模块时,会跳过这三个步骤,而只提取内存中已加载的模块对象,速度要快的多。 【搜索路径】 比如说:import math,不需要加路径和后缀名,系统会
  • 这也是使用 python 标准库的方法,我们可以把写好的一些可复用的函数,封装成模块然后发布到python的本地库中。 然后在其他的程序就可以导入你这个写好的模块了。 简单来说模块就像一个常用的零件,例如组装一个高达...
  • 由于技术不够,scrapy框架导入到pycharm的步骤就卡住了几个星期,今天重新整理了思路才成功。 记录下自己的解决思路 首先是直接简单的通过在pychram-》file-》setting里的加号键进行手动搜索scrapy进行下载安装的...
  • 当我们在一个py文件中导入另外一个py文件时时候会在当前目录下生产一个pyc的文件(是python解释器将模块文件的源码转换成了字节码) 优点:进行速度的优化 [3]语法: 1. 导入模块(一)(常用的) import 模块名 (as 别名) ...
  • 1、模块的定义,模块就是一个py文件,方便我们写其它程序的时候,可以直接调用模块的函数,大大提高我们的代码编写速度 模块有自己写的模块,也有python自带的一些模块,还有第三方的一些模块。 2、我们来创建一个...
  • python模块别名和作用域

    千次阅读 2015-04-10 14:19:15
    导入模块时,还可以使用别名,这样,可以在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提供StringIO和cStringIO两个库,这两个库的接口和功能是一样的,但是cStringIO是C写的,速度更快,所以,你...
  • python import导入的可用模块很多,新增速度较快,无法一次性全部掌握。 掌握熟悉一种模块的方法是非常有价值的技能。 探究模块可以从python解释器入手,具体流程记录如下: 以os模块为例: 1. 在解释器中导入os...
  • conda下安装python模块的注意!

    千次阅读 2019-03-12 13:44:42
    建议用pip install 包名安装,否则经常会出现包导入失败或者混乱。 此外不要按照网上的教程设置清华镜像,一样很慢,只要将pypi更新为清华镜像速度立马飞起! ...
  • 一个提供懒惰和自毁工具以加快模块导入速度的软件包。 每当启动时间很关键时(例如对于命令行界面或其他面向用户的应用程序),此功能就很有用。 该模块中的工具实现了两种不同的策略来加快模块导入。 第一个是延迟...
  • python的operator模块

    2021-05-06 23:35:13
    operator模块是用c实现的,所以执行速度python代码快 02:函数的映射操作 03:简单的实例: # 导入模块 from operator import lt # 调整lt比较大小 print(lt(2,4)) mul(a, b)——支持数/列表/元组...
  • 包及跨模块导入

    2019-09-26 12:22:37
    1.pip命令默认在国外的python服务器上下载,速度会很慢。可以使用国内的豆瓣源,速度会快很多。(simple后面的斜杠/后要空一格然后输入下载的模块名,否则会像上面那样报错,下载速度惊人) 2.包 有时候一个...
  • python sys.modules模块

    2019-08-15 09:40:47
    sys.modules是一个全局字典,该字典是python启动后就加载在内存中。...当第二次再导入模块时,python会直接到字典中查找,从而加快了程序运行的速度。 字典sys.modules具有字典所拥有的一切方...
  • python中的operator模块

    2020-11-05 15:19:44
    operator模块是用c实现的,所以执行速度python代码快 2:函数的映射操作 3:简单的实例: ''' 遇到问题没人解答?小编创建了一个Python学习交流QQ群:778463939 寻找有志同道合的小伙伴,互帮互助,群里还有不错...
  • Caffe是一个深度学习框架,具有表达力强、速度快和模块化的思想,由伯克利视觉学习中心(BVLC)和社区贡献者开发。Yangqing Jia在加州大学伯克利分校攻读博士期间创建了这个项目。 为什么选择caffe? 富有表现力的...
  • Python用import或者from…import或者from…import…as…来导入相应的模块,作用和使用方法与C语言的include头文件类似。其实就是引入某些成熟的函数库和成熟的方法,避免重复造轮子,提高开发速度python的...
  • 详解Python import方法引入模块的实例在Python用import或者from…import或者from…import…as…来导入相应的模块,作用和使用方法与C语言的include头文件类似。其实就是引入某些成熟的函数库和成熟的方法,避免重复...
  • python中使用的是import,from...import和form import as 进行导入模块。其实就是导入已经写好的函数,成熟的方法,避免代码重复,提高开发速度。 作用和使用方法类似于java。就像程序结构是下面这种: |-- src  ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 209
精华内容 83
关键字:

python模块导入速度

python 订阅