re模块、collections模块、random模块

re模块

re.findall

import  re
ret = re.findall("q","qwe,qdf,dsq") # 返回所有满足匹配条件的结果,放在列表里
print(ret)#结果 : ['a', 'a']

re.findall优先级问题：

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

re.search

ret=re.search("q","qwe,qdf,dsq")
print(ret)  #结果：<_sre.SRE_Match object; span=(0, 1), match='q'>
print(ret.group())  #结果"q"  找到第一个就结束
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

re.match

ret=re.match("qw","qweqdfdsq") # 同search,不过必须是字符串的开头处进行匹配，类似^
print(ret.group())#结果："a"

re.split

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

re.split优先级问题：

ret=re.split("d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。

re.sub

ret=re.sub('d',"H","a1b2c3d4e5f",2) #将数字替换成'H'，参数2表示只替换2个
print(ret)#aHbHc3d4e5f

re.subn

subn('d', 'H', 'a1b2c3d4e5f"')#将数字替换成'H'，返回元组
print(ret) #返回替换后的结果，和替换次数，在一个元组里 结果：('aHbHcHdHeHf"', 5)

re.compile

obj = re.compile('d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123

re.finditer

ret = re.finditer('d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

 collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典

namedtuple

用namedtuple表示一个坐标：

from collections import namedtuple
point=namedtuple("point",["x","y"])#类似于写一个point方法，只要point后加一个元组，就会对应把值给x和y
p=point(1,2)
print(p)       #point(x=1, y=2)
print(p.x)#1          point.x  就会调出x对应的值
print(p.y)#2
#这就很方便的调用元组中的值

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections import deque
l=[1,2,3,4,5]
l1=deque(l)
print(l1)    #deque([1, 2, 3, 4, 5])
l1.append(6)
print(l1)#deque([1, 2, 3, 4, 5, 6])
l1.appendleft(7)
print(l1)#deque([7, 1, 2, 3, 4, 5, 6])
l1.pop()
print(l1)#deque([7, 1, 2, 3, 4, 5] 默认从右侧删除
l1.popleft()
print(l1)#deque([1, 2, 3, 4, 5]) 从左侧删
#操作该列表，只可以从两侧操作

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

from collections import OrderedDict
d=dict([("a",1),("b",2),("c",3)])#创建一个字典
print(d)#{'a': 1, 'b': 2, 'c': 3}
dic = OrderedDict()
dic['z'] = 1
dic['y'] = 2
dic['x'] = 3
print(dic)    #OrderedDict([('z', 1), ('y', 2), ('x', 3)])
print(dic.keys()) # 按照插入的Key的顺序返回
print(dic.values()) # 按照顺序返回values

defaultdict

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

用原生字典写：

l=[11,22,33,44,55,66,77,88,99,90]
dic={"key1":[],"key2":[]}   #必须先创建一个带有key的字典，不然会报错
for i in l:
    if i <66:
        dic["key2"].append(i)
    elif i>66:
        dic["key1"].append(i)
print(dic)

defaultdict字典解决方法：

from collections import defaultdict
l = [11, 22, 33,44,55,66,77,88,99,90]
dic = defaultdict(list)  #创建一个defaultdict字典，不需要先写key，因为他有默认参数list
for i in  l:
    if i>66:
        dic['k1'].append(i)
    else:
        dic['k2'].append(i)
print(dic)

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda:None)
dd['key1'] = 'abc'
dd['key1'] # key1存在
dd['key2'] # key2不存在，返回默认值
print(dd)#defaultdict(<function <lambda> at 0x0000023411182E18>, {'key1': 'abc', 'key2': None})

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

from collections import Counter
s="asdfkjdskfjhasa"
print(Counter(s))#Counter({'a': 3, 's': 3, 'd': 2, 'f': 2, 'k': 2, 'j': 2, 'h': 1})

random模块

import random
#随机小数
random.random()      # 大于0且小于1之间的小数
0.7664338663654585
random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

#随机整数
random.randint(1,5)  # 大于等于1且小于等于5之间的整数
random.randrange(1,10,2) # 大于等于1且小于10之间的奇数


#随机选择一个返回
random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回，返回的个数为函数的第二个参数
random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
item=[1,3,5,7,9]
random.shuffle(item) # 打乱次序
item
[5, 1, 3, 7, 9]
random.shuffle(item)
item
[5, 9, 7, 1, 3]

随机验证码练习：