Python标准库02

发表于 | 分类于
字数统计: 1,759 | 阅读时长 ≈ 8

本文主要介绍Python标准库。

1.re模块

re模块中常用功能函数
①compile()
编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）
格式：
re.compile(pattern,flags=0)
pattern: 编译时用的表达式字符串。
flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：
|标志|含义|
|:-|:-|
|re.S(DOTALL)|使.匹配包括换行在内的所有字符
|re.I(IGNORECASE)|使匹配对大小写不敏感
|re.L(LOCALE)|做本地化识别（locale-aware)匹配，法语等
|re.M(MULTILINE)|多行匹配，影响^和$
|re.X(VERBOSE)|该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
|re.U|根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B

1
2
3
4
5
6
import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print(rr.findall(tt))   #查找所有包含'oo'的单词
执行结果如下：
['good', 'cool']

②　match()
决定RE是否在字符串刚开始的位置匹配。//注：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’
格式：
re.match(pattern, string, flags=0)
print(re.match(‘com’,’comwww.runcomoob').group())
print(re.match(‘com’,’Comwww.runcomoob',re.I).group())
执行结果如下：
com
com

③　search()
格式：
re.search(pattern, string, flags=0)
re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None。
print(re.search(‘\dcom’,’www.4comrunoob.5com').group())
执行结果如下：
4com
注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：
group() 返回被 RE 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
group()返回re整体匹配的字符串，
b. group (n,m) 返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常
c.groups() groups()方法返回一个包含正则表达式中所有小组字符串的元组，从 1 到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。
import re
a = “123abc456”
print(re.search(“([0-9])([a-z])([0-9])”,a).group(0)) #123abc456,返回整体
print(re.search(“([0-9])([a-z])([0-9])”,a).group(1)) #123
print(re.search(“([0-9])([a-z])([0-9])”,a).group(2)) #abc
print(re.search(“([0-9])([a-z])([0-9]*)”,a).group(3)) #456

###group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。###
④　findall()
re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。
格式：
re.findall(pattern, string, flags=0)
p = re.compile(r’\d+’)
print(p.findall(‘o1n2m3k4’))
执行结果如下：
[‘1’, ‘2’, ‘3’, ‘4’]
import re
tt = “Tina is a good girl, she is cool, clever, and so on…”
rr = re.compile(r’\woo\w‘)
print(rr.findall(tt))
print(re.findall(r’(\w)*oo(\w)’,tt))#()表示子表达式
执行结果如下：
[‘good’, ‘cool’]
[(‘g’, ‘d’), (‘c’, ‘l’)]
⑤　finditer()
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。
格式：
re.finditer(pattern, string, flags=0)
iter = re.finditer(r’\d+’,’12 drumm44ers drumming, 11 … 10 …’)
for i in iter:
print(i)
print(i.group())
print(i.span())
执行结果如下：

<_sre.SRE_Match object; span=(0, 2), match=’12’>
(0, 2)

<_sre.SRE_Match object; span=(8, 10), match=’44’>
(8, 10)

<_sre.SRE_Match object; span=(24, 26), match=’11’>
(24, 26)

<_sre.SRE_Match object; span=(31, 33), match=’10’>
(31, 33)
⑥　split()
按照能够匹配的子串将string分割后返回列表。
可以使用re.split来分割字符串，如：re.split(r’\s+’, text)；将字符串按空格分割成一个单词列表。
格式：
re.split(pattern, string[, maxsplit])
maxsplit用于指定最大分割次数，不指定将全部分割。

print(re.split(‘\d+’,’one1two2three3four4five5’))
执行结果如下：
[‘one’, ‘two’, ‘three’, ‘four’, ‘five’, ‘’]
⑦　sub()
使用re替换string中每一个匹配的子串后返回替换后的字符串。
格式：
re.sub(pattern, repl, string, count)
import re
text = “JGood is a handsome boy, he is cool, clever, and so on…”
print(re.sub(r’\s+’, ‘-‘, text))
执行结果如下：
JGood-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on…
其中第二个函数是替换后的字符串；本例中为’-‘
第四个参数指替换个数。默认为0，表示每个匹配项都替换。
re.sub还允许使用函数对匹配项的替换进行复杂的处理。
如：re.sub(r’\s’, lambda m: ‘[‘ + m.group(0) + ‘]’, text, 0)；将字符串中的空格’ ‘替换为’[ ]’。
import re
text = “JGood is a handsome boy, he is cool, clever, and so on…”
print(re.sub(r’\s+’, lambda m:’[‘+m.group(0)+’]’, text,0))
执行结果如下：
JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on…
⑧　subn()
返回替换次数
格式：
subn(pattern, repl, string, count=0, flags=0)
print(re.subn(‘[1-2]’,’A’,’123456abcdef’))
print(re.sub(“g.t”,”have”,’I get A, I got B ,I gut C’))
print(re.subn(“g.t”,”have”,’I get A, I got B ,I gut C’))
执行结果如下：
(‘AA3456abcdef’, 2)
I have A, I have B ,I have C
(‘I have A, I have B ,I have C’, 3)

2.time模块

在Python中，通常有这几种方式来表示时间：1）时间戳 2）格式化的时间字符串 3）元组（struct_time）共九个元素。

1
2
3
4
5
>>> time.time()					//返回unix时间戳
>>> time.localtime()				//用一个元组装起来的9组数字处理时间
>>> time.sleep(5)					//延时函数
>>> time.asctime( time.localtime() ) 	//获取可读的时间模式
>>> print time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())

3.random模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> import random					//生成一个0到1的随机符点数: 0 <= n < 1.0
>>> random.random()
>>> random.uniform(10,20)			//生成的随机数n: a <= n <= b
>>> random.randint(1,20)			//生成的随机数n: a <= n <= b
>>> random.randrange(1,10,2)
>>> random.choice(["JGood","is", "a","handsome", "boy"])
>>> p = ["Python","is", "powerful","simple", "and so on..."]
>>> random.shuffle(p)				//打乱
>>> print p
['simple', 'and so on...', 'is', 'powerful', 'Python']

>>> list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> slice = random.sample(list, 5) 
>>> print slice
[1, 6, 7, 4, 3]
>>> print list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4.csv模块

读csv文件：
语法：reader(csvfile, dialect=’excel’, **fmtparams)

import csv
reader=csv.reader(open(‘foo.csv’,’rb’))
for item in reader:
… print item
写csv文件：
import csv
writer=csv.writer(open(‘foo.csv’,’wb+’))
writer.writerow([‘tianqi’,’26’,’79’])
字典方式读写：

读

import csv
with open(‘names.csv’) as csvfile:
… reader = csv.DictReader(csvfile)
… for row in reader:
… print(row[‘first_name’], row[‘last_name’])
…
Baked Beans
Lovely Spam
Wonderful Spam

写

import csv
with open(‘names.csv’, ‘w’) as csvfile:
fieldnames = [‘first_name’, ‘last_name’]
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

writer.writeheader()
writer.writerow({'first_name': 'Baked', 'last_name': 'Beans'})
writer.writerow({'first_name': 'Lovely', 'last_name': 'Spam'})
writer.writerow({'first_name': 'Wonderful', 'last_name': 'Spam'})
---------------- The End ----------------