python笔记--内置模块

wdx1992828

　　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的目录结构：
　　
[root@FJC ~]# tree /root/test
　　
/root/test
　　
├── 001.txt
　　
├── 002.py
　　
├── lala
　　
│   └── 003.txt
　　
└── test.txt -> test.txt
　　

　　
1 directory, 4 files
　　
　　sys，用于提供对解释器相关的操作
　　sys.argv  命令行参数，结果是个列表，第一个元素是程序名，之后的元素是执行程序携带的参数。例如：
[root@FJC /]# 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]
　　
[root@FJC /]# 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都是文件对象，都需要打开后才能进行复制操作，例如：
[root@FJC ~]# cat test1　　
test1
　　
[root@FJC ~]# cat test2
　　
[root@FJC ~]# 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()
　　
[root@FJC ~]# 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表示会将原目录中符号链接文件的正本文件复制到目标目录中。
　　递归的去拷贝文件，例如：
[root@FJC ~]# tree test　　
test
　　
├── 001.txt
　　
├── 002.py
　　
└── lala
　　
    └── 003.txt
　　

　　
1 directory, 3 files
　　

　　
#递归拷贝，注意目标目录不能实现建立，否则会报错
　　
>>> from shutil import *
　　
>>> copytree('test','test1',ignore=ignore_patterns('*.py'))
　　

　　
[root@FJC ~]# 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)