Python 供应了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的阐明器实例利用，这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以利用该模块中的函数等功能。这也是利用 python 标准库的方法。
下面是一个利用 python 标准库中模块的例子。
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为：', sys.path, '\n')
实行结果如下所示：
$ python using_sys.py
参数1
参数2
命令行参数如下:
using_sys.py
参数1
参数2
Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2、sys.argv 是一个包含命令行参数的列表。
3、sys.path 包含了一个 Python 阐明器自动查找所需模块的路径的列表。
import 语句
想利用 Python 源文件，只需在另一个源文件里实行 import 语句，语法如下：
import module1[, module2[,... moduleN]
当阐明器碰着 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个阐明器会前辈行搜索的所有目录的列表。如想要导入模块 support，须要把命令放在脚本的顶端：
support.py 文件代码
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
test.py 引入 support 模块：
test.py 文件代码
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
以上实例输出结果：
$ python3 test.py
Hello : Runoob
一个模块只会被导入一次，不管你实行了多少次import。这样可以防止导入模块被一遍又一各处实行。
当我们利用import语句的时候，Python阐明器是若何找到对应的文件的呢？
这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python阐明器就依次从这些目录中去探求所引入的模块。
这看起来很像环境变量，事实上，也可以通过定义环境变量的办法来确定搜索路径。
搜索路径是在Python编译或安装的时候确定的，安装新的库该当也会修正。搜索路径被存储在sys模块中的path变量，做一个大略的实验，在交互式阐明器中，输入以下代码：
>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']>>>
sys.path 输出是一个列表，个中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们实行python阐明器的目录（对付脚本的话便是运行的脚本所在的目录）。
因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。
理解了搜索路径的观点，就可以在脚本中修正sys.path来引入一些不在搜索路径中的模块。
现在，在阐明器确当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下：
实例
# 斐波那契(fibonacci)数列模块
def fib(n):
# 定义到 n 的斐波那契数列
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n): # 返回到 n 的斐波那契数列
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
然后进入Python阐明器，利用下面的命令导入这个模块：
>>> import fibo
这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。
可以利用模块名称来访问函数：
实例
>>>fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__ '
fibo'
如果你打算常常利用一个函数，你可以把它赋给一个本地的名称：
>>> fib = fibo.fib>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377
个中，语法格式还有另一种：import modulename [as alias]
[as alias]是为了给模块起的别名，通过该别名也可以利用模块。
例：import bmi as m
as关键字为模块名重新设置一个别名，然后就可以通过这个别名来调用模块中的变量，函数和类。
利用import语句也可以一次导入多个模块，再导入多个模块时，模块之间利用"，"进行分隔。
from … import 语句
from … import …语句可以让你从模块中导入一个指定的部分到当前模块，语法如下：
from modname import member
# member：用于指定要导入的变量，函数或者类等。
例如，要导入模块 fibo 的 fib 函数，利用如下语句：
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这个声明不会把全体fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。
当我们须要从模块中同时导入多个指定内容，可以用逗号隔开，写成from xx模块 import a,b,c的形式
对付from … import …语句要把稳的是，没有被写在import后面的内容，将不会被导入。
from … import 语句
当我们须要从模块中指定所有内容直策应用时，可以写成【from xx模块 import 】的形式，代表"模块中所有的变量、函数、类"
把一个模块的所有内容全都导入到当前的命名空间，只需利用如下声明：
from modname import
这供应了一个大略的方法来导入一个模块中的所有项目。然而这种声明不该被过多地利用。
深入模块
模块除了方法定义，还可以包括可实行的代码。这些代码一样平常用来初始化这个模块。这些代码只有在第一次被导入时才会被实行。
每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来利用。
以是，模块的作者可以放心大胆的在模块内部利用这些全局变量，而不用担心把其他用户的全局变量搞混。
从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面利用 import 来导入一个模块，当然这只是一个老例，而不是逼迫的。被导入的模块的名称将被放入当前操作的模块的符号表中。
还有一种导入的方法，可以利用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这种导入的方法不会把被导入的模块的名称放在当前的字符表中（以是在这个例子里面，fibo 这个名称是没有定义的）。
这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:
>>> from fibo import
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情形， Python程序员不该用这种方法，由于引入的其它来源的命名，很可能覆盖了已有的定义。
__name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不实行，我们可以用__name__属性来使该程序块仅在该模块自身运行时实行。
为理解释什么是【if __name__ == '__main__'】，我先给大家讲解一个观点"程序的入口"。
对付Python和其他许多编程措辞来说，程序都要有一个运行入口。
在Python中，当我们在运行某一个py文件，就能启动程序 ——— 这个py文件便是程序的运行入口。
当我们有了一大堆py文件组成一个程序的时候，为了【指明】某个py文件是程序的运行入口，我们可以在该py文件中写出这样的代码：
# 【文件：xx.py】
代码块 ①……
if __name__ == '__main__':
代码块 ②……
if __name__ == '__main__':
print('程序自身在运行')else:
print('我来自另一模块')
运行输出如下：
$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>
解释： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
解释：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。
在每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以检讨该变量，以确定它们在哪个模块中实行。如果一个模块不是被导入到其他程序中实行，那么它就可能在阐明器的顶级模块在实行。顶级模块的__name__变量的值为__main__。
标准模块
引用模块
Python中自带的模块，称为标准模块（标准库），对付这些标准模块，我们可以直策应用
import语句导入来利用。
例如：import random
在导入模块时，也可以利用as关键字为其指定别名。
导入标准模块后，就可以通过模块名调用其供应的函数。
标准模块直接被构建在解析器里，这些虽然不是一些措辞内置的功能，但是他却能很高效的利用，乃至是系统级调用也没问题。
这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会供应给 Windows 系统。
该当把稳到这有一个特殊的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
print('Runoob!')
Runoob!
C>
Python供应了大约200多个内置标准模块，涵盖了python运行时做事，笔墨模式匹配，操作系统接口，数学运算，工具永久保存，网络和Internet脚本和GUI构建等方面。
os模块:
os.remove() 删除文件
os.unlink() 删除文件
os.rename() 重命名文件
os.listdir() 列出指定目录下所有文件
os.chdir() 改变当前事情目录
os.getcwd() 获取当前文件路径
os.mkdir() 新建目录
os.rmdir() 删除空目录(删除非空目录, 利用shutil.rmtree())
os.makedirs() 创建多级目录
os.removedirs() 删除多级目录
os.stat(file) 获取文件属性
os.chmod(file) 修正文件权限
os.utime(file) 修正文件韶光戳
os.name(file) 获取操作系统标识
os.system() 实行操作系统命令
os.execvp() 启动一个新进程
os.fork() 获取父进程ID，在子进程返回中返回0
os.execvp() 实行外部程序脚本（Uinx）
os.spawn() 实行外部程序脚本（Windows）
os.access(path, mode) 判断文件权限(详细参考cnblogs)
os.wait() 暂时未知
os.path模块：
os.path.split(filename) 将文件路径和文件名分割(会将末了一个目录作为文件名而分离)
os.path.splitext(filename) 将文件路径和文件扩展名分割成一个元组
os.path.dirname(filename) 返回文件路径的目录部分
os.path.basename(filename) 返回文件路径的文件名部分
os.path.join(dirname,basename) 将文件路径和文件名凑成完全文件路径
os.path.abspath(name) 得到绝对路径
os.path.splitunc(path) 把路径分割为挂载点和文件名
os.path.normpath(path) 规范path字符串形式
os.path.exists() 判断文件或目录是否存在
os.path.isabs() 如果path是绝对路径，返回True
os.path.realpath(path) #返回path的真实路径
os.path.relpath(path[, start]) #从start开始打算相对路径
os.path.normcase(path) #转换path的大小写和斜杠
os.path.isdir() 判断name是不是一个目录，name不是目录就返回false
os.path.isfile() 判断name是不是一个文件，不存在返回false
os.path.islink() 判断文件是否连接文件,返回boolean
os.path.ismount() 指定路径是否存在且为一个挂载点，返回boolean
os.path.samefile() 是否相同路径的文件，返回boolean
os.path.getatime() 返回最近访问韶光 浮点型
os.path.getmtime() 返回上一次修正韶光 浮点型
os.path.getctime() 返回文件创建韶光 浮点型
os.path.getsize() 返回文件大小 字节单位
os.path.commonprefix(list) #返回list(多个路径)中，所有path共有的最长的路径
os.path.lexists #路径存在则返回True,路径破坏也返回True
os.path.expanduser(path) #把path中包含的"~"和"~user"转换成用户目录
os.path.expandvars(path) #根据环境变量的值更换path中包含的"$name"和"${name}"
os.path.sameopenfile(fp1, fp2) #判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2) #判断stat tuple stat1和stat2是否指向同一个文件
os.path.splitdrive(path) #一样平常用在windows下，返回驱动器名和路径组成的元组
os.path.walk(path, visit, arg) #遍历path，给每个path实行一个函数
os.path.supports_unicode_filenames() 设置是否支持unicode路径名
stat模块：
描述os.stat()返回的文件属性列表中各值的意义
fileStats = os.stat(path) 获取到的文件属性列表
fileStats[stat.ST_MODE] 获取文件的模式
fileStats[stat.ST_SIZE] 文件大小
fileStats[stat.ST_MTIME] 文件末了修正韶光
fileStats[stat.ST_ATIME] 文件末了访问韶光
fileStats[stat.ST_CTIME] 文件创建韶光
stat.S_ISDIR(fileStats[stat.ST_MODE]) 是否目录
stat.S_ISREG(fileStats[stat.ST_MODE]) 是否一样平常文件
stat.S_ISLNK(fileStats[stat.ST_MODE]) 是否连接文件
stat.S_ISSOCK(fileStats[stat.ST_MODE]) 是否COCK文件
stat.S_ISFIFO(fileStats[stat.ST_MODE]) 是否认名管道
stat.S_ISBLK(fileStats[stat.ST_MODE]) 是否块设备
stat.S_ISCHR(fileStats[stat.ST_MODE]) 是否字符设置
sys模块：
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.path 返回模块的搜索路径，初始化时利用PYTHONPATH环境变量的值
sys.modules.keys() 返回所有已经导入的模块列表
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.exc_info() 获取当前正在处理的非常类,exc_type、exc_value、exc_traceback当前处理的非常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python阐明程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python阐明程序的版本信息
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdout.write('aaa') 标准输出内容
sys.stdout.writelines() 无换行输出
sys.stdin 标准输入
sys.stdin.read() 输入一行
sys.stderr 缺点输出
sys.exc_clear() 用来打消当前哨程所涌现确当前的或最近的缺点信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权干系的东西
sys.api_version 阐明器的C的API版本
sys.version_info 'final'表示终极,也有'candidate'表示候选，表示版本级别，是否有后继的发行
sys.getdefaultencoding() 返回当前你所用的默认的字符编码格式
sys.getfilesystemencoding() 返回将Unicode文件名转换成系统文件名的编码的名字
sys.builtin_module_names Python阐明器导入的内建模块列表
sys.executable Python阐明程序路径
sys.getwindowsversion() 获取Windows的版本
sys.stdin.readline() 从标准输入读一行，sys.stdout.write("a") 屏幕输出a
sys.setdefaultencoding(name) 用来设置当前默认的字符编码
sys.displayhook(value) 如果value非空，这个函数会把他输出到sys.stdout
datetime,date,time模块：
datetime.date.today() 本地日期工具,(用str函数可得到它的字面表示(2014-03-24))
datetime.date.isoformat(obj) 当前[年-月-日]字符串表示(2014-03-24)
datetime.date.fromtimestamp() 返回一个日期工具，参数是韶光戳,返回 [年-月-日]
datetime.date.weekday(obj) 返回一个日期工具的星期数,周一是0
datetime.date.isoweekday(obj) 返回一个日期工具的星期数,周一是1
datetime.date.isocalendar(obj) 把日期工具返回一个带熟年月日的元组
datetime工具：
datetime.datetime.today() 返回一个包含本地韶光(含微秒数)的datetime工具 2014-03-24 23:31:50.419000
datetime.datetime.now([tz]) 返回指定时区的datetime工具 2014-03-24 23:31:50.419000
datetime.datetime.utcnow() 返回一个零时区的datetime工具
datetime.fromtimestamp(timestamp[,tz]) 按韶光戳返回一个datetime工具，可指定时区,可用于strftime转换为日期表示
datetime.utcfromtimestamp(timestamp) 按韶光戳返回一个UTC-datetime工具
datetime.datetime.strptime('2014-03-16 12:21:21',"%Y-%m-%d %H:%M:%S") 将字符串转为datetime工具
datetime.datetime.strftime(datetime.datetime.now(), '%Y%m%d %H%M%S') 将datetime工具转换为str表示形式
datetime.date.today().timetuple() 转换为韶光戳datetime元组工具，可用于转换韶光戳
datetime.datetime.now().timetuple()
time.mktime(timetupleobj) 将datetime元组工具转为韶光戳
time.time() 当前韶光戳
time.localtime
time.gmtime
hashlib,md5模块：
hashlib.md5('md5_str').hexdigest() 对指定字符串md5加密
md5.md5('md5_str').hexdigest() 对指定字符串md5加密
random模块：
random.random() 产生0-1的随机浮点数
random.uniform(a, b) 产生指定例模内的随机浮点数
random.randint(a, b) 产生指定例模内的随机整数
random.randrange([start], stop[, step]) 从一个指定步长的凑集中产生随机数
random.choice(sequence) 从序列中产生一个随机数
random.shuffle(x[, random]) 将一个列表中的元素打乱
random.sample(sequence, k) 从序列中随机获取指定长度的片断
types模块：
保存了所有数据类型名称。
if type('1111') == types.StringType:
MySQLdb模块：
MySQLdb.get_client_info() 获取API版本
MySQLdb.Binary('string') 转为二进制数据形式
MySQLdb.escape_string('str') 针对mysql的字符转义函数
MySQLdb.DateFromTicks(1395842548) 把韶光戳转为datetime.date工具实例
MySQLdb.TimestampFromTicks(1395842548) 把韶光戳转为datetime.datetime工具实例
MySQLdb.string_literal('str') 字符转义
MySQLdb.cursor()游标工具上的方法：《python核心编程》P624
atexit模块：
atexit.register(fun,args,args2..) 注册函数func，在解析器退出前调用该函数
string模块
str.capitalize() 把字符串的第一个字符大写
str.center(width) 返回一个原字符串居中，并利用空格添补到width长度的新字符串
str.ljust(width) 返回一个原字符串左对齐，用空格添补到指定长度的新字符串
str.rjust(width) 返回一个原字符串右对齐，用空格添补到指定长度的新字符串
str.zfill(width) 返回字符串右对齐，前面用0添补到指定长度的新字符串
str.count(str,[beg,len]) 返回子字符串在原字符串涌现次数，beg,len是范围
str.decode(encodeing[,replace]) 解码string,出错引发ValueError非常
str.encode(encodeing[,replace]) 解码string
str.endswith(substr[,beg,end]) 字符串是否以substr结束，beg,end是范围
str.startswith(substr[,beg,end]) 字符串是否以substr开头，beg,end是范围
str.expandtabs(tabsize = 8) 把字符串的tab转为空格，默认为8个
str.find(str,[stat,end]) 查找子字符串在字符串第一次涌现的位置，否则返回-1
str.index(str,[beg,end]) 查找子字符串在指定字符中的位置，不存在报非常
str.isalnum() 检讨字符串是否以字母和数字组成，是返回true否则False
str.isalpha() 检讨字符串是否以纯字母组成，是返回true,否则false
str.isdecimal() 检讨字符串是否以纯十进制数字组成，返回布尔值
str.isdigit() 检讨字符串是否以纯数字组成，返回布尔值
str.islower() 检讨字符串是否全是小写，返回布尔值
str.isupper() 检讨字符串是否全是大写，返回布尔值
str.isnumeric() 检讨字符串是否只包含数字字符，返回布尔值
str.isspace() 如果str中只包含空格，则返回true,否则FALSE
str.title() 返回标题化的字符串（所有单词首字母大写，别的小写）
str.istitle() 如果字符串是标题化的(拜会title())则返回true,否则false
str.join(seq) 以str作为连接符，将一个序列中的元素连接成字符串
str.split(str='',num) 以str作为分隔符，将一个字符串分隔成一个序列，num是被分隔的字符串
str.splitlines(num) 以行分隔，返回各行内容作为元素的列表
str.lower() 将大写转为小写
str.upper() 转换字符串的小写为大写
str.swapcase() 翻换字符串的大小写
str.lstrip() 去掉字符左边的空格和回车换行符
str.rstrip() 去掉字符右边的空格和回车换行符
str.strip() 去掉字符两边的空格和回车换行符
str.partition(substr) 从substr涌现的第一个位置起，将str分割成一个3元组。
str.replace(str1,str2,num) 查找str1更换成str2，num是更换次数
str.rfind(str[,beg,end]) 从右边开始查询子字符串
str.rindex(str,[beg,end]) 从右边开始查找子字符串位置
str.rpartition(str) 类似partition函数，不过从右边开始查找
str.translate(str,del='') 按str给出的表转换string的字符，del是要过虑的字符
urllib模块：
urllib.quote(string[,safe]) 对字符串进行编码。参数safe指定了不须要编码的字符
urllib.unquote(string) 对字符串进行解码
urllib.quote_plus(string[,safe]) 与urllib.quote类似，但这个方法用'+'来更换' '，而quote用'%20'来代替' '
urllib.unquote_plus(string ) 对字符串进行解码
urllib.urlencode(query[,doseq]) 将dict或者包含两个元素的元组列表转换成url参数。
例如 字典{'name':'wklken','pwd':'123'}将被转换为"name=wklken&pwd=123″
urllib.pathname2url(path) 将本地路径转换成url路径
urllib.url2pathname(path) 将url路径转换成本地路径
urllib.urlretrieve(url[,filename[,reporthook[,data]]]) 下载远程数据到本地
filename：指定保存到本地的路径（若未指定该，urllib天生一个临时文件保存数据）
reporthook：回调函数，当连接上做事器、以及相应的数据块传输完毕的时候会触发该回调
data：指post到做事器的数据
rulrs = urllib.urlopen(url[,data[,proxies]]) 抓取网页信息，[data]post数据到Url,proxies设置的代理
urlrs.readline() 跟文件工具利用一样
urlrs.readlines() 跟文件工具利用一样
urlrs.fileno() 跟文件工具利用一样
urlrs.close() 跟文件工具利用一样
urlrs.info() 返回一个httplib.HTTPMessage工具，表示远程做事器返回的头信息
urlrs.getcode() 获取要求返回状态HTTP状态码
urlrs.geturl() 返回要求的URL
re模块：
一.常用正则表达式符号和语法：
'.' ：匹配所有字符串，除\n以外
'-' ：表示范围[0-9]
'' ：匹配前面的子表达式零次或多次。要匹配 字符，请利用 \。
'+' ：匹配前面的子表达式一次或多次。要匹配 + 字符，请利用 \+
'^' ：匹配字符串开头
'$' ：匹配字符串结尾 re
'\' ：转义字符， 使后一个字符改变原来的意思，如果字符串中有字符须要匹配，可以\或者字符集[] re.findall(r'3\','3ds')结['3']
'' ：匹配前面的字符0次或多次 re.findall("ab","cabc3abcbbac")结果：['ab', 'ab', 'a']
'?' ：匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
'{m}' ：匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
'{n,m}' ：匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
'\d' ：匹配数字，即是[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
'\D' ：匹配非数字，即是[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
'\w' ：匹配字母和数字，即是[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
'\W' ：匹配非英笔墨母和数字,即是[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
'\s' ：匹配空缺字符 re.findall('\s','3ds \t\n')结果[' ', '\t', '\n']
'\S' :匹配非空缺字符 re.findall('\s','3ds \t\n')结果['3', '', 'd', 's']
'\A' :匹配字符串开头
'\Z' :匹配字符串结尾
'\b' :匹配单词的词首和词尾，单词被定义为一个字母数字序列，因此词尾是用空缺符或非字母数字符来表示的
'\B' 与\b相反，只在当前位置不在单词边界时匹配
'(?P<name>...)' ：分组，除了原有编号外在指定一个额外的别名 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '19930614'}
[] 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英笔墨符和数字。[\s]表示空格或者号。
二.常用的re函数：
方法/属性 浸染
re.match(pattern, string, flags=0) ：从字符串的起始位置匹配，如果起始位置匹配不堪利的话，match()就返回none
re.search(pattern, string, flags=0) ：扫描全体字符串并返回第一个成功的匹配
re.findall(pattern, string, flags=0) ：找到RE匹配的所有字符串，并把他们作为一个列表返回
re.finditer(pattern, string, flags=0) ：找到RE匹配的所有字符串，并把他们作为一个迭代器返回
re.sub(pattern, repl, string, count=0, flags=0) ：更换匹配到的字符串
math模块
ceil:取大于即是x的最小的整数值，如果x是一个整数，则返回x
copysign:把y的正负号加到x前面，可以利用0
cos:求x的余弦，x必须是弧度
degrees:把x从弧度转换成角度
e:表示一个常量
exp:返回math.e,也便是2.71828的x次方
expm1:返回math.e的x(其值为2.71828)次方的值减１
fabs:返回x的绝对值
factorial:取x的阶乘的值
floor:取小于即是x的最大的整数值，如果x是一个整数，则返回自身
fmod:得到x/y的余数，其值是一个浮点数
frexp:返回一个元组(m,e),其打算办法为：x分别除0.5和1,得到一个值的范围
fsum:对迭代器里的每个元素进行求和操作
gcd:返回x和y的最大公约数
hypot:如果x是不是无穷大的数字,则返回True,否则返回False
isfinite:如果x是正无穷大或负无穷大，则返回True,否则返回False
isinf:如果x是正无穷大或负无穷大，则返回True,否则返回False
isnan:如果x不是数字True,否则返回False
ldexp:返回x(2i)的值
log:返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,打算式为：log(x)/log(base)
log10:返回x的以10为底的对数
log1p:返回x+1的自然对数(基数为e)的值
log2:返回x的基2对数
modf:返回由x的小数部分和整数部分组成的元组
pi:数字常量，圆周率
pow:返回x的y次方，即xy
radians:把角度x转换成弧度
sin:求x(x为弧度)的正弦值
sqrt:求x的平方根
tan:返回x(x为弧度)的正切值
trunc:返回x的整数部分
dir() 函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
'__package__', '__stderr__', '__stdin__', '__stdout__',
'_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
'_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
'call_tracing', 'callstats', 'copyright', 'displayhook',
'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
'thread_info', 'version', 'version_info', 'warnoptions']
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:
>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一个当前模块中定义的属性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一个新的变量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 删除变量名a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>
包
包是一种管理 Python 模块命名空间的形式，采取"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
就彷佛利用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采取点模块名称这种形式也不用担心不同库之间的模块重名的情形。
这样不同的作者都可以供应 NumPy 模块，或者是 Python 图形库。
不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。
现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），以是你须要有一组不断增加的模块，用来在不同的格式之间转换。
并且针对这些音频数据，还有很多不同的操作（比如混音，添加反应，增加均衡器功能，创建人造立体声效果），以是你还须要一组怎么也写不完的模块来处理这些操作。
这里给出了一种可能的包构造（在分层的文件系统中）:
sound/ 顶层包
__init__.py 初始化 sound 包
formats/ 文件格式转换子包
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ 声音效果子包
__init__.py
echo.py
surround.py
reverse.py
...
filters/ filters 子包
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
在导入一个包的时候，Python 会根据 sys.path 中的目录来探求这个包中包含的子目录。
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，紧张是为了避免一些滥俗的名字（比如叫做 string）欠妥心的影响搜索路径中的有效模块。
最大略的情形，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面先容的） __all__变量赋值。
用户可以每次只导入一个包里面的特定模块，比如:
import sound.effects.echo
这将会导入子模块:sound.effects.echo。 他必须利用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
还有一种导入子模块的方法是:
from sound.effects import echo
这同样会导入子模块: echo，并且他不须要那些冗长的前缀，以是他可以这样利用:
echo.echofilter(input, output, delay=0.7, atten=4)
还有一种变革便是直接导入一个函数或者变量:
from sound.effects.echo import echofilter
同样的，这种方法会导入子模块: echo，并且可以直策应用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)
把稳当利用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。
import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，抛出一个 :exc:ImportError 非常。
反之，如果利用形如 import item.subitem.subsubitem 这种导入形式，除了末了一项，都必须是包，而末了一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。
从一个包中导入
设想一下，如果我们利用 from sound.effects import 会发生什么？
Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。
但是很不幸，这个方法在 Windows平台上事情的就不是非常好，由于Windows是一个大小写不区分的系统。
在这类平台上，没有人敢包管一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 乃至 ECHO。
（例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。
为理解决这个问题，只能烦劳包作者供应一个精确的包的索引了。
导入语句遵照如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在利用 from package import 的时候就把这个列表中的所有名字作为包内容导入。
作为包的作者，可别忘了在更新包之后担保 __all__ 也更新了啊。你说我就不这么做，我就不该用导入这种用法，好吧，没问题，谁让你是老板呢。这里有一个例子，在:file:sounds/effects/__init__.py中包含如下代码:
__all__ = ["echo", "surround", "reverse"]
这表示当你利用from sound.effects import 这种用法时，你只会导入包里面这三个子模块。
如果 __all__ 真的没有定义，那么利用from sound.effects import 这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）。
这会把 __init__.py 里面定义的所有名字导入进来。并且他不会毁坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:
import sound.effects.echoimport sound.effects.surroundfrom sound.effects import
这个例子中，在实行 from...import 前，包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。（当然如果定义了 __all__ 就更没问题了）
常日我们并不主见利用 这种方法来导入模块，由于这种方法常常会导致代码的可读性降落。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。
记住，利用 from Package import specific_submodule 这种方法永久不会有错。事实上，这也是推举的方法。除非是你要导入的子模块有可能和其他包的子模块重名。
如果在构造中包是一个子包（比如这个例子中对付包sound来说），而你又想导入兄弟包（同级别的包）你就得利用导入绝对的路径来导入。比如，如果模块sound.filters.vocoder 要利用包 sound.effects 中的模块 echo，你就要写成 from sound.effects import echo。
from . import echofrom .. import formatsfrom ..filters import equalizer
无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永久是"__main__"，一个Python运用程序的主模块，应该总是利用绝对路径引用。
包还供应一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个经办事的__init__.py，你得在其他__init__.py被实行前定义哦。可以修正这个变量，用来影响包含在包里面的模块和子包。
这个功能并不常用，一样平常用来扩展包里面的模块。
