python笔记--内置模块

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

>>> m.close

>>> 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)

>>> 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)