先是,不要把您的模块名写成socket.py ,因为python自动把当前目录的py文件作为模块来import了

1.1Python中的模块介绍和平运动用

模块就是完毕某项作用的程序集,举例 sys 模块,random 模块等。在
Python 语言中,每个 .py 文件就是二个模块。

# -*- coding: utf-8 -*-
import socket,sys
from fileinput import filename


host = ""
port = 51423

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
s.bind((host,port))
s.listen(1)

print ("service is running on port %d; press ctrl+c to terminate")
while True:
    '''
            进入服务器的无限循环中,等待连接到来
            有连接时,进入对话循环,等待客户发送数据。
            如果数据为空,表示客户端已经退出。等待下一个客户端连接。
            得到客户端消息后在消息前加一个时间戳后返回
    '''        
    clientsock,clientaddr =s.accept()
    clientfile = clientsock.makefile("rw",0)
    clientfile.write("welcom,"+str(clientaddr) + "n")
    clientfile.write("please enter a string: ")
    line = clientfile.readline().strip()
    clientfile.write("you entered %d characters. n" % len(line))
    clientfile.close()
    clientsock.close()

#用telnet可以连接本地接口    

模块就好比是工具包,要想行使那么些工具包中的工具(就好比函数卡塔尔(قطر‎,就必要导入那么些模块

成立二个模块

任何以 .py 结尾的文件都以三个模块。
创建 tool.py 文件:

def greeting(name):
    print("Hello, I'm %s"%name)

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

在 py.py 中选用该模块:

import tool
tool.greeting("Mike")

运转结果:

Hello, I'm Mike

1.1.1import

引进模块的两种情势

以地方创制的 tool 模块为例,有须臾间二种引进形式(1 为引进格局,2
为调用方式):

1.import tool
2.tool.greeting("Mike")

1.from tool import greeting,add
2.greeting("Mike")

1.from tool import *
2.greeting("Mike")

在Python中用关键字import来引进有个别模块,比方要引用模块math,就足以在文书最最早的地点用import
math来引入。

__all__ 变量

暗许景况下,使用 from xxx import *
导入模块时会导入模块中具有的函数和数据,要是我们想限制哪些内容能被导入,哪些内容不可能被导入,就须求利用
__all__
变量,该变量是系统内置的,默以为一个空驶列车表。大家能够在该列表中加多想要被导出的剧情。更改tool.py:

__all__ = ["greeting"]

def greeting(name):
    print("Hello, I'm %s"%name)

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

在 py.py 中调用 add 方法尝试:

from tool import *

greeting("Mike")
print(add(1,2))

运营结果如下:

Hello, I'm Mike
Traceback (most recent call last):
  File "C:UsersCharleyDesktoppypy.py", line 4, in <module>
    print(add(1,2))
NameError: name 'add' is not defined

greeting 函数被成功实施了,而 add 函数没有找到。
对此模块内部的私有变量也许函数,还是能在称呼前拉长叁个下划线
_,那样就不会被导出了。
注:这种办法只对 from xxx import * 有效:
tool.py:

_num = 1

def count():
    global _num
    _num += 1
    return _num

py.py:

from tool import *
print(count())
print(_num)

运营结果如下:

2
Traceback (most recent call last):
  File "C:UsersCharleyDesktoppypy.py", line 3, in <module>
    print(_num)
NameError: name '_num' is not defined
[Finished in 0.1s with exit code 1]
[shell_cmd: python -u "C:UsersCharleyDesktoppypy.py"]

这里不也许利用 _num 变量。以上的情势只对 from xxx import *
有效,借使大家不使用星号 * 引进,则无此限定:

from tool import count,_num
print(count())
print(_num)

运营结果为:

2
1

形如:

__pycache__ 文件夹

在导入 tool 模块后运营代码,开掘多出了叁个 __pycache__ 文件夹:

│  py.py
│  tool.py
│
└─__pycache__
        tool.cpython-35.pyc

个中有个 .pyc
文件,那是编写翻译器为了巩固运营速度创设的缓存字节码文件,这里有多少个简约介绍:

设若 Python
进度在机械上具备写入权限,那么它将把程序的字节码保存为八个以 .pyc
为扩充名的文书( “.pyc” 就是编写翻译过的 “.py”
源代码)。当程序运转之后,你会在这里些源代码的邻座(也正是说同多少个目录下)看见那些文件。
Python那样保存字节码是当作生机勃勃种运维速度的优化。下一回运路程序时,假设您在上次保存字节码之后并未有改变过源代码的话,Python将会加载.pyc文件并跳过编写翻译那一个手续。当Python必须重编写翻译时,它会活动物检疫查源文件和字节码文件的小运戳:假使你又保留了源代码,后一次程序运维时,字节码将电动重新创造。

上边的解释来自于《python学习手册》。
总是,__pycache__ 和其下的 .pyc
文件是解释器为了优化代码试行创立的,并且只会成立被导入的模块缓存,主模块不创制缓存。

importmodule1,mudule2…

有的时候四个模块无法到位具体的作用,要求八个模块合作完毕,大家得以把这么些模块放在三个文书夹中开展统生机勃勃保管,这正是Python 中包的概念。
Python3 和 Python2 对此包的定义有一些细微的分别:Python3
以为三个文本夹便是一个包,Python2 认为富含 __init__.py
文件的公文夹是多少个包。但随就是 Python3 照旧 Python3,如若包中有
__init__ 文件,在导入包的时候都会先进行 __init.py__ 文件。
Python3 下能够直接导入包中的模块:

from mypkg import tool
tool.greeting("NAME")

运营结果:

Hello, I'm NAME

Python2 下须要新建 __init__.py 文件:

__all__ = ["tool"]

除开使用格局和 Python3 相像:

from mypkg import tool
tool.greeting("Python2 中使用")

为了宽容性,提出总是在包中加上 __init__.py 文件。

当解释器遭逢import语句,如若模块在脚下的搜寻路线就能够被导入。

模块寻觅的不二诀要

sys 模块中的 path 变量能够接济大家查阅 Python 搜索模块的门道:

import sys
print(sys.path)

运维结果:

[
'C:\Users\Charley\Desktop\py', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\python35.zip', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\DLLs', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\lib', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\lib\site-packages'
]

在探究模块时,会相继依照列表中的路线搜索,直到找到地方。
设若大家想自定义寻觅路线,能够修正 path 变量:

from sys import path
path.append("./mypkg/");

from tool import greeting
greeting("Mike")

运维结果为:

Hello, I'm Mike
[
'C:\Users\Charley\Desktop\py', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\python35.zip', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\DLLs', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\lib', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32', 
'C:\Users\Charley\AppData\Local\Programs\Python\Python35-32\lib\site-packages',
'./mypkg/'
]

我们在 path
变量中追加了一条门路,定义到前边创立的包中,那样就能够直接导入包中的模块,无需导入包名了。那只是风流倜傥种展现性的做法,不推荐使用。

在调用math模块中的函数时,必需这样引用:

模块热导入

那是小编本人编的多个名词,意思是导入模块后,程序在不脱离的前提下,假若退换了被导入的模块,能够一同使用改进后的模块中的功用。
创造三个 tesereload.py 模块:

def show():
    print("Hello World")
    # print("Hello China")

张开命令行,导入 testreload 模块,并推行 show 函数:

>>> import testreload
>>> testreload.show()
Hello World

改善 testreload 模块,废除注释,再一次在命令行中实施 show 函数:

>>> testreload.show()
Hello World

在命令行中使用 import 再度导入 testreload 模块,再执行 show 函数:

>>> import testreload
>>> testreload.show()
Hello World

试行结果并未有发生变化,那是因为前面讲到的缓存机制,在程序运维起来之后,更改了村生泊长模块并不会协同创新导入,而是从缓存的
pyc 文件中读取。要是须要重新使用改革后的模块,能够:

  • 再度起动程序
  • 使用 imp 模块中的 reload 方法

世襲在指令行中程导弹入 imp 模块,并通过 reload 方法重复载入模块:

>>> from imp import reload
>>> reload(testreload)
<module 'testreload' from 'C:\Users\Charley\Desktop\py\testreload.py'>

重复实行 show 方法:

>>> testreload.show()
Hello World
Hello China

可见 show 方法的推行结果已经一齐立异了。那正是 reload 的作用。

模块名.函数名

防止模块循环导入

模块循环导入便是五个模块之间互相正视导入,会发生死循环,校正 py.py
文件:

from testreload import show

def show2():
    pass
show()

修改 testreload.py 文件:

from py import show2

def show():
    print("Hello World")

show2()

运行 py.py 文件:

Traceback (most recent call last):
  File "C:UsersCharleyDesktoppypy.py", line 1, in <module>
    from testreload import show
  File "C:UsersCharleyDesktoppytestreload.py", line 1, in <module>
    from py import show2
  File "C:UsersCharleyDesktoppypy.py", line 1, in <module>
    from testreload import show
ImportError: cannot import name 'show'
[Finished in 0.2s with exit code 1]
[shell_cmd: python -u "C:UsersCharleyDesktoppypy.py"]
[dir: C:UsersCharleyDesktoppy]
[path: C:Python27;C:Python27Scripts;C:WINDOWSsystem32;C:WINDOWS;C:WINDOWSSystem32Wbem;C:WINDOWSSystem32WindowsPowerShellv1.0;D:nvm;D:nodejs;C:Program Files (x86)Windows Kits8.1Windows Performance Toolkit;C:Program FilesMicrosoft SQL Server110ToolsBinn;C:ProgramDatachocolateybin;C:Program Files (x86)GtkSharp2.12bin;C:Program FilesMySQLMySQL Utilities 1.6;C:UsersCharleyAppDataLocalProgramsPythonPython35-32Scripts;C:UsersCharleyAppDataLocalProgramsPythonPython35-32;D:Gitbin;D:Sublime Text 3;D:MinGWbin;D:MinGWbin;D:Microsoft VS Codebin;D:Javajdk 8.0bin;D:Androidsdk;C:Program FilesMySQLMySQL Server 5.7bin;]

前后相继直接挂掉了。因而大家须要制止模块的大循环导入,若四个模块相互有依附,应该经过第八个的肤浅举行化解。

只需求使用模块中有些函数的时候,能够用上边方法完毕:

__name__ 变量

__name__
变量是系统提供的二个全局变量,用来对现阶段的模块进行描述。大家在 py.py
文件和 testreload.py 文件中分别查看 __name__ 变量:
py.py:

import testreload
print("--> py %s"%__name__)

testreload.py:

print("--> testreload %s"%__name__)

运行 py.py 文件:

--> testreload testreload
--> py __main__

__name__ 变量用来对脚下的模块进行描述,若是是主模块,其值为
__main__,要是是被导入的模块,其值就是模块名。
实际上运用中,我们得以依赖 __name__ 变量来调节是不是实行模块中的内容。校订testreload.py:

print("--> testreload %s"%__name__)

if __name__ == "__main__":
    print("__MAIN__")

运行 py.py 文件:

--> testreload testreload
--> py __main__

运行 testreload.py 文件:

--> testreload __main__
__MAIN__

在 testreload 模块中,唯有该模块是组模块中才奉行 print 函数输出。
品种中大家平日常有多少个入口文件,建议在输入文件中对 __name__
进行决断,完毕早先化职业:

# 如果当前模块是主模块
if __name__ == "__main__":
    # 执行初始化函数
    main()

完。

from模块名import函数名1,函数名2….

不只有能够引进函数,仍是可以引进一些全局变量、类等

注意:

o通过这种格局引进的时候,调用函数时只可以给出函数名,不可能交到模块名,不过当四个模块中包涵相似名称函数的时候,前边叁次引进会覆盖前贰回引进。也正是说假诺模块A中有函数function(
卡塔尔,在模块B中也许有函数function(

State of Qatar,假使引入A中的function在先、B中的function在后,那么当调用function函数的时候,是去推行模块B中的function函数。

o固然想叁次性引入math中具备的事物,还足以经过from math import *来实现

1.1.2from…import

Python的from语句能够从模块中程导弹入二个钦赐的有些到眼下命名空间中

语法如下:

frommodnameimportname1[, name2[, … nameN]]

举例,要导入模块fib的fibonacci函数,使用如下语句:

fromfibimportfibonacci

注意

·不会把方方面面fib模块导入到当前的命名空间中,它只会将fib里的fibonacci单个引进

1.1.3from … import *

把一个模块的拥有剧情全都导入到当前的命名空间:

frommodnameimport*

注意

·这提供了贰个简约的点子来导入三个模块中的全部类型。然而这种申明不应当被过多地行使。

1.1.4as

In [1]: import time as tt

In [2]: time.sleep(1)


NameErrorTraceback (most recent call last)

in ()

—-> 1 time.sleep(1)

NameError: name ‘time’ is not defined

In [3]:

In [3]:

In [3]: tt.sleep(1)

In [4]:

In [4]:

In [4]: from time import sleep as sp

In [5]: sleep(1)


NameErrorTraceback (most recent call last)

in ()

—-> 1 sleep(1)

NameError: name ‘sleep’ is not defined

In [6]:

In [6]:

In [6]: sp(1)

In [7]:

1.1.5一定模块

当导入三个模块时,Python深入深入分析器对模块地方的查找顺序是:

1.当前目录

2.只要不在当前目录,Python则找寻在shell变量PYTHONPATH下的种种目录。

3.假如都找不到,Python会察看暗许路线。UNIX下,暗中同意路线平常为/usr/local/lib/python/

4.模块寻觅路线存款和储蓄在system模块的sys.path变量中。变量里包括当前目录,PYTHONPATH和由设置进程决定的默许目录。

1.2模块制作

1.2.1定义本人的模块

每一个Python文件都得以充任二个模块,模块的名字正是文件的名字。

开创文件test.py,在test.py中定义函数add

test.py

defadd(a,b):

returna+b

1.2.2调用本人定义的模块

在其余文件中就足以先import
test,然后通过test.add(a,b卡塔尔(قطر‎来调用,当然也得以经过from test import
add来引进

main.py

importtest

result = test.add(11,22)

print(result)

1.2.3测量检验模块

python在实行三个文件时有个变量__name__

能够依照__name__变量的结果可以知道看清出,是向来实施的python脚本依旧被引进实施的,进而能够有采用性的举办测量试验代码

__name__若果写在被直接运转的主文件中,是”__main__”

要是写在被导入的文件中,运维主文件的时候,导入文本中的__name__是”模块的名字”

1.3模块中的__all__

·要是贰个文件中有__all__变量,那么也就代表这几个变量中的成分,不会被from
xxx import *时导入

1.4python中的包

·包将有关联的模块组织在同步,即放手同叁个文本夹下,何况在此个文件夹成立八个名为__init__.py文件,那么这一个文件夹就称之为包

·有效防止模块名称冲突难点,让动用组织构造更为清晰

1.4.1__init__.py文件有哪些用

__init__.py调整着包的导入行为

1.4.1.1__init__.py为空

只是是把这么些包导入,不会导入包中的模块

1.4.1.2__all__

在__init__.py文件中,定义贰个__all__变量,它决定着from包名import
*时导入的模块

1.4.1.3(了解)可以在__init__.py文件中编辑内容

可以在__init__.py文件中编辑语句,当导入时,那些讲话就能被实践

1.4.2恢弘:嵌套的包

只要包的目录构造:

Phone/

__init__.py

common_util.py

Voicedta/

__init__.py

Pots.py

Isdn.py

Fax/

__init__.py

G3.py

Mobile/

__init__.py

Analog.py

igital.py

Pager/

__init__.py

Numeric.py

Phone是最顶层的包,Voicedta等是它的子包。能够那样导入子包:

import Phone.Mobile.Analog

Phone.Mobile.Analog.dial()

也可利用from-import达成分化须求的导入

第风流倜傥种艺术是只导入顶层的子包,然后利用质量/点操作符向下引用子包树:

from Phone import Mobile

Mobile.Analog.dial(‘555-1212’)

其余,还足以引用越来越多的子包:

from Phone.Mobile import Analog

Analog.dial(‘555-1212’)

实则,能够直接沿子包的树状布局导入:

from Phone.Mobile.Analog import dial

dial(‘555-1212’)

在上面的目录布局中,能够窥见好多的__init__.py文件。那几个是开首化模块,from-import语句导入子包时供给动用它。如果未有利用,他们得以是空文件。

包相像协理from-import all语句:

from package.module import *

诸有此类的语句会导入哪些文件决意于操作系统的文件系统。所以能够在__init__.py中加入__all__变量。该变量包罗实践那样的言辞时应该导入的模块的名字。它由三个模块名字符串列表组成.。

1.5模块公布

1.mymodule目录构造体如下:

.

├── setup.py

├── suba

│├── aa.py

│├── bb.py

│└── __init__.py

└── subb

├── cc.py

├── dd.py

└── __init__.py

2.编辑setup.py文件

py_modules需指明所需包涵的py文件

fromdistutils.coreimportsetup

setup(name=”yongGe”, version=”1.0″, description=”yongGe’s module”,
author=”yongGe”,
py_modules=[‘suba.aa’,’suba.bb’,’subb.cc’,’subb.dd’])

3.创设立模型块

python setup.py build

塑造后目录布局

.

├── build

│└── lib.linux-i686-2.7

│├── suba

││├── aa.py

││├── bb.py

││└── __init__.py

│└── subb

│├── cc.py

│├── dd.py

│└── __init__.py

├── setup.py

├── suba

│├── aa.py

│├── bb.py

│└── __init__.py

└── subb

├── cc.py

├── dd.py

└── __init__.py

4.生成宣布压缩包

python setup.py sdist

卷入后,生成最后公布压缩包yongGe-1.0.tar.gz

,目录布局

.

├── build

│└── lib.linux-i686-2.7

│├── suba

││├── aa.py

││├── bb.py

││└── __init__.py

│└── subb

│├── cc.py

│├── dd.py

│└── __init__.py

├── dist

│└── yongGe-1.0.tar.gz

├── MANIFEST

├── setup.py

├── suba

│├── aa.py

│├── bb.py

│└── __init__.py

└── subb

├── cc.py

├── dd.py

└── __init__.py

1.6模块安装、使用

1.6.1.1装置的议程

1.找到模块的压缩包

2.解压

3.跻身文件夹

4.施行命令python

setup.py install

注意:

·假若在install的时候,实行目录安装,能够运用python

setup.py install –prefix=安装路线

1.6.1.2模块的引进

在程序中,使用from import就能够产生对设置的模块使用

from模块名import模块名或然*