python常用内置模块
类似于函数式编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来说，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个.py文件组成的代码集合就称为模块。
模块分为三种：自定义模块、内置模块、开源模块http://pypi.python.org
一、导入模块
方法：
import module from module.xx.xx import xx from module.xx.xx import xx as rename from module.xx.xx import *
导入模块其实就是告诉Python解释器去解释那个py文件，导入一个py文件，解释器解释该py文件，导入一个包，解释器解释该包下的 __init__.py 文件。
那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path
如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append(‘路径‘) 添加。可以通过os模块获得路径，例如：
import sys import os pre_path = os.path.abspath(‘../‘) sys.path.append(pre_path)
二、第三方模块的下载安装
两种方法：
使用pip工具，具体使用方法，可以参照：
http://blog.csdn.net/olanlanxiari/article/details/48086917
下载源码包，解压后进入解压目录，依次执行：
python setup.py build python setup.py install
三、内置模块
os，用于提供系统级别的操作
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: (‘.‘)
os.pardir 获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘) 可生成多层递归目录
os.removedirs(‘dirname1‘) 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘) 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘) 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat(‘path/filename‘) 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符（换行符），win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True，否则返回False
os.path.isfile(path) 如果path是一个存在的文件，返回True，否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True，否则返回False
os.path.islink(path) 如果path是一个链接目录，返回True，否则返回False
os.path.ismount(path) 如果path挂载了设备，返回True，否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，常用于拼接路径
os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间
os.path.getctime(path) 返回path所指向的文件或者目录的最后变化时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.walk(path) 目录生成器返回格式：(dirpath,[dirnames],[filenames])，例如：
>>> import os >>> for ROOT,DIR,FILE in os.walk(‘/root/test‘): ... print ROOT ... print DIR ... print FILE ... /root/test [‘lala‘] [‘test.txt‘, ‘001.txt‘, ‘002.py‘] /root/test/lala [] [‘003.txt‘] #我们可以看一下/root/test的目录结构： [[email protected] ~]# tree /root/test /root/test ├── 001.txt ├── 002.py ├── lala │ └── 003.txt └── test.txt -> test.txt 1 directory, 4 files
sys，用于提供对解释器相关的操作
sys.argv 命令行参数，结果是个列表，第一个元素是程序名，之后的元素是执行程序携带的参数。例如：
[[email protected] /]# cat /root/test.py #!/usr/bin/env python # -*- coding:utf-8 -*- import sys print sys.argv print sys.argv[0] print sys.argv[1] print sys.argv[2] [[email protected] /]# python /root/test.py a b c [‘/root/test.py‘, ‘a‘, ‘b‘, ‘c‘] /root/test.py #argv[0] a #argv[1] b #argv[2]
sys.exit() 执行到sys.exit()时，退出程序，括号中可以加上数字，sys.exit(0)表示正常退出。
sys.version 返回Python解释程序的版本信息
sys.maxint 返回最大的Int值
sys.path 返回模块的搜索路径，以列表的形式，可以追加自定义路径。
sys.platform 返回操作系统平台名称
sys.stdin.readline() 标准输入，例如：
>>> name=sys.stdin.readline() FJC #手动输入 >>> print name FJC
sys.stdout.write(‘内容’) 标准输出
sys.stdout.flush() 配合time.sleep(1)实现实时输出信息，例如：
>>> import sys >>> import time >>> for i in range(3): ... print i， ... sys.stdout.flush() ... time.sleep(1) 0 1 2 #每隔一秒输出一个数字
shutil，高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中，可以部分内容
#注意！ 在其中fsrc，fdst都是文件对象，都需要打开后才能进行复制操作，例如：
[[email protected] ~]# cat test1 test1 [[email protected] ~]# cat test2 [[email protected] ~]# python >>> n=open(‘test1‘,‘r+‘) >>> m=open(‘test2‘,‘a+‘) >>> import shutil >>> shutil.copyfileobj(n,m) >>> n.close <built-in method close of file object at 0x7fd57bd165d0> >>> m.close <built-in method close of file object at 0x7fd57bd16660> >>> quit() [[email protected] ~]# cat test2 test1
shutil.copyfile(src, dst)
仅拷贝文件到文件或目录
shutil.copymode(src, dst)
仅拷贝权限，内容、组、用户均不变
shutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copy(src, dst)
拷贝文件和权限
shutil.copy2(src, dst)
拷贝文件和状态信息
shutil.ignore_patterns(*patterns)#忽略的参数
shutil.copytree(src, dst, symlinks=True, ignore=None) #symlinks=True表示原目录中的符号链接文件会被直接复制到目标目录中；symlinks=False表示会将原目录中符号链接文件的正本文件复制到目标目录中。
递归的去拷贝文件，例如：
[[email protected] ~]# tree test test ├── 001.txt ├── 002.py └── lala └── 003.txt 1 directory, 3 files #递归拷贝，注意目标目录不能实现建立，否则会报错 >>> from shutil import * >>> copytree(‘test‘,‘test1‘,ignore=ignore_patterns(‘*.py‘)) [[email protected] ~]# tree test1 test1 ├── 001.txt └── lala └── 003.txt 1 directory, 2 files
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
shutil.move(src, dst)
递归的去移动文件
python3.0+版本
shutil.make_archive(base_name, format[, root_dir[, base_dir[, verbose[, dry_run[, owner[, group[, logger]]]]]]])
创建压缩包并返回文件路径及名称。
base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径。
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象
例如：
>>> os.chdir(‘c:\\‘) >>> ret=shutil.make_archive(‘www‘,‘zip‘,root_dir=‘c:\\test‘) >>> ret ‘c:\\www.zip‘ #表示将c:\\test目录下的文件压缩，保存到当前目录，命名为www >>> ret=shutil.make_archive(‘c:\\www\\myfile‘,‘zip‘,root_dir=‘c:\\test‘) >>> ret ‘c:\\www\\myfile.zip‘ #表示将c:\\test目录下的文件压缩，保存到c:\\www目录下，命名为myfile
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的。
>>> import zipfile #压缩 >>> z=zipfile.ZipFile(‘test.zip‘,‘w‘) >>> z.write(‘a.log‘) >>> z.write(‘b.data‘) >>> z.close() # 解压 >>> z = zipfile.ZipFile(‘test.zip‘, ‘r‘) >>> z.extractall() >>> z.close() >>> import tarfile #压缩 >>> tar=tarfile.open(‘my.tar‘,‘w‘) >>> tar.add(‘a.log‘,arcname=‘aa.log‘) #arcname可以改变文件压缩后的名称 >>> tar.add(‘b.data‘,arcname=‘bb.data‘) >>> tar.close() #解压 # 解压 >>> tar = tarfile.open(‘your.tar‘,‘r‘) >>> tar.extractall() #可设置解压地址 >>> tar.close()
random，用于生成随机数
random.random()
返回随机数，在0和1范围内
random.randint(1,3)
返回随机整数，在1和3范围内，包括1和3
random.randrange(1,10)
返回随机整数，在1和10范围内，不包括10
random.randrange(1,10,2)
末尾的2表示跳数，每隔两个取一个数，起始位置为1，所以这个结果就是1~10之间的随机奇数。
random.sample(array,n)
表示从一个数组中随机取出n个元素，例如：
>>> import random >>> random.sample([1,2,3,4],1) [3]
hashlib,提供常见的摘要算法,如：MD5、SHA1等
>>> import hashlib >>> test=hashlib.md5() >>> test.update(‘how to use md5 in python hashlib?‘) >>> print test.hexdigest() d26a53750bc40b38b65a520292f69306
如果，数据量很大，可以分块多次调用update()，最后的计算结果是一样的。
>>> test2=hashlib.md5() >>> test2.update(‘how to use md5 ‘) >>> test2.update(‘in python hashlib?‘) >>> print test2.hexdigest() d26a53750bc40b38b65a520292f69306
shelve,简单的数据存储方案
只有一个函数open()，这个函数接收一个参数就是文件名，然后返回一个shelf对象，你可以用他来存储东西，就可以简单的把他当作一个字典，key必须为字符串，而值可以是python所支持的数据。当你存储完毕的时候，就调用close函数来关闭。
>>> import shelve >>> s=shelve.open(‘test.txt‘) >>> s[‘x‘]=[1,2,3] >>> s[‘y‘]=[4,5,6] >>> s[‘x‘] [1, 2, 3] #不过有个小问题，例如： >>> s[‘x‘].append(4) >>> s[‘x‘] [1, 2, 3]
新添加的元素到哪里去了呢？其实，元素4没有写回，你把[1,2,3]存到了x，当你再次读取s[‘x‘]的时候，s[‘x‘]只是一个拷贝，而你没有将拷贝写回，所以当你再次读取s[‘x‘]的时候，它又从源中读取了一个拷贝，所以，你新修改的内容并不会出现在拷贝中，解决的办法就是，利用一个缓存的变量，例如：
>>> temp=s[‘x‘] >>> temp.append(4) >>> s[‘x‘]=temp >>> s[‘x‘] [1, 2, 3, 4]
time，时间访问和转换
time.time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
time.localtime([时间戳]) 转换时间戳为一个时间元组，没有参数是指当前时间。例如：
>>> a=time.localtime() >>> type(a) <type ‘time.struct_time‘> >>> a time.struct_time(tm_year=2017, tm_mon=5, tm_mday=23, tm_hour=18, tm_min=11, tm_sec=30, tm_wday=1, tm_yday=143, tm_isdst=0)
time.asctime([tuple]) 转换时间元组为一个可读性好的格式，没有参数是指当前时间。例如：
>>> time.asctime(time.localtime()) ‘Tue May 23 18:26:25 2017‘
time.ctime(时间戳) 转换时间戳为一个可读性好的格式，没有参数是指当前时间。例如：
>>> time.ctime(time.time()) ‘Tue May 23 18:28:46 2017‘
time.sleep(seconds) 按照给定的秒数延迟执行，参数可以是整数或浮点数。
time.strftime(format[,tuple]) 将元组时间转换成指定格式，没有tuple是定当前时间。例如：
>>> time.strftime(‘%Y-%m-%d %H:%M:%S‘) ‘2017-05-23 18:39:44‘ >>> time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.localtime(12345)) ‘1970-01-01 11:25:45‘
re,正则表达式
re.match(pattern, string) 仅从字符串头开始匹配，例如：
>>> re.match(‘abc‘,‘1abc2abc‘)#没有结果 >>> a=re.match(‘abc‘,‘abc1abc2abc‘) >>> a.group() ‘abc‘
re.search(pattern, string) 匹配整个字符串，直到找到一个匹配，例如：
>>> b=re.search(‘abc‘,‘1abc2abc‘) >>> b.group() ‘abc‘
re.findall(pattern, string) 找到所有要匹配的字符并返回列表格式，例如：
>>> re.findall(‘abc‘,‘1abc2abc‘)#注意返回结果是一个列表 [‘abc‘, ‘abc‘]
re.complie(string) 生成要匹配的正则对象,例如：
>>> c=re.compile(‘abc‘)#参数可以是各种正则表达式，提前编译。 >>> d=c.match(‘abc1abc2abc‘)#匹配时直接调用，提高了性能。 >>> d.group() ‘abc‘
re.sub(pattern, repl, string, count,flag) 替换匹配到的字符，即对字符串string按照pattern匹配，得到的替换为repl，替换个数为count，flag表示匹配模式，例如：
>>> re.sub("[0-9]","|", "aaa1bbb2ccc3ddd4eee",count=2 )
‘aaa|bbb|ccc3ddd4eee‘
>>> re.sub("[0-9]","|", "aaa1bbb2ccc3ddd4eee") #不指定count表示替换所有匹配的
‘aaa|bbb|ccc|ddd|eee‘
flag的类型：
1).re.I(re.IGNORECASE): 忽略大小写
2).re.M(MULTILINE): 多行模式，改变’^’和’$’的行为
3).re.S(DOTALL): 点任意匹配模式，改变’.’的行为
4).re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
5).re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
6).re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
注：
正则表达式实例：
字符匹配
python 匹配 "python".
字符类
[Pp]ython 匹配 "Python" 或 "python"
rub[ye] 匹配 "ruby" 或 "rube"
[aeiou] 匹配中括号内的任意一个字母
[0-9] 匹配任何数字。类似于 [0123456789]
[a-z] 匹配任何小写字母
[A-Z] 匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[^aeiou] 除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符
特殊字符类
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 ‘\n‘ 在内的任何字符，请使用象 ‘[.\n]‘ 的模式。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w 匹配包括下划线的任何单词字符。等价于‘[A-Za-z0-9_]‘。
\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]‘。
参考练习：
1.批量改名：
目录下abc_001.txt
abc_002.txt
abc_003.txt
abc_004.txt
abc_005.txt
改名为：001.txt
002.txt
003.txt
004.txt
005.txt
#!/usr/bin/env python
import os
for x,y,z in os.walk("."):
for i in z:
a="".join(list(i)[4:])
os.rename(i,a)
2.随机生成6个包含大写字母、小写字母、数字的字符串：
#!/usr/bin/env python a=range(65,91) b=range(97,123) c=range(48,58) a.extend(b) a.extend(c) import random c=[] for i in range(6): d=chr (random.sample(a,1)[0]) c.append(d) print "".join(c)