标签：功能 div cms git 号码 次数 不能 开头 现在
什么是模块？
常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。
但其实import加载的模块分为四个通用类别：
1 使用python编写的代码（.py文件）
2 已被编译为共享库或DLL的C或C++扩展
3 包好一组模块的包
4 使用C编写并链接到python解释器的内置模块
为何要使用模块？
如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。
随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用，
Re模块
讲正题之前我们先来看一个例子：https://reg.jd.com/reg/person?ReturnUrl=https%3A//www.jd.com/
这是京东的注册页面，打开页面我们就看到这些要求输入个人信息的提示。
假如我们随意的在手机号码这一栏输入一个11111111111，它会提示我们格式有误。
这个功能是怎么实现的呢？
假如现在你用python写一段代码，类似：
phone_number = input(‘please input your phone number ： ‘)
你怎么判断这个phone_number是合法的呢？
根据手机号码一共11位并且是只以13、14、15、18开头的数字这些特点，我们用python写了如下代码：
判断手机号码是否合法1
while True:
phone_number = input(‘please input your phone number ： ‘)
if len(phone_number) == 11 \
and phone_number.isdigit()\
and (phone_number.startswith(‘13‘) \
or phone_number.startswith(‘14‘) \
or phone_number.startswith(‘15‘) \
or phone_number.startswith(‘18‘)):
print(‘是合法的手机号码‘)
else:
print(‘不是合法的手机号码‘)
现在需要用正则表达式判断手机号是否合法
phone_number= input(‘please input your phone number:‘)
if re.match(‘^(13|14|15|18|17)[0-9]{9}$‘,phone_number):
print(‘是合法的手机号码‘)
else:
print(‘这是不合法的手机号码‘)
re模块下的常用方法
import re
ret = re.findall(‘a‘, ‘eva egon yuan‘) # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : [‘a‘, ‘a‘]
ret = re.search(‘j‘, ‘eva egon yuan‘)
if ret:
print(ret.group()) #结果 : ‘a‘
函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None,此时调用group会报错
所以要加IF进行判断下
ret = re.match(‘a‘, ‘bbc‘) # 同search,不过是从在字符串开始处进行匹配
if ret:
print(ret).group()
结果 : ‘a‘
match是从头开始匹配，如果正则规则从头开始可以匹配上，就返回一个变量。
匹配的内容需要用group才能显示，如果没匹配上，就返回None，调用group会报错。
# ret = re.split(‘[ab]‘, ‘abcd‘) # 先按‘a‘分割得到‘‘和‘bcd‘,在对‘‘和‘bcd‘分别按‘b‘分割
# print(ret) # [‘‘, ‘‘, ‘cd‘]
ret = re.sub(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘, 1) #将数字替换成‘H‘，参数1表示只替换1个.不写就全部替换
print(ret) #evaHegon4yuan4
obj = re.compile(‘\d{3}‘) #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search(‘abc123eeee‘) #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group()) #结果 ： 123
import re
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]) #查看剩余的左右结果
注意：
1 findall的优先级查询
ret = re.findall(‘www.(baidu|oldboy).com‘, ‘www.oldboy.com‘)
print(ret) # [‘oldboy‘] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
ret = re.findall(‘www.(?:baidu|oldboy).com‘, ‘www.baidu.com‘) ? 取消优先级的作业
print(ret) # [‘www.baidu.com‘]
2 split的优先级查询
ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： [‘eva‘, ‘egon‘, ‘yuan‘]
ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： [‘eva‘, ‘3‘, ‘egon‘, ‘4‘, ‘yuan‘]
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。
collections模块
在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。
1.namedtuple: 生成可以使用名字来访问元素内容的tuple
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
namedtuple 可命名元组
我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：
p = (1, 2)
但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。
这时，namedtuple就派上了用场：
from collections import namedtuple
point = namedtuple(‘card‘,[‘x‘,‘y‘,‘z‘])
p = point(1,2,3)
print(p) # card(x=1, y=2, z=3)
# 花色和数字
Card = namedtuple(‘card‘,[‘suits‘,‘number‘])
c1 = Card(‘红桃‘,2)
print(c1)
print(c1.number)
print(c1.suits)
类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：
#namedtuple(‘名称‘, [属性list]):
Circle = namedtuple(‘Circle‘, [‘x‘, ‘y‘, ‘r‘])
queue 队列
# 堆栈：先进后出
# 队列：先进先出
不能循环取值，不是可迭代，不能插队
import queue 队列
q = queue.Queue()
q.put(10)
q.put(5)
q.put(6)
print(q)
print(q.qsize())
print(q.get())
print(q.get())
print(q.get())
print(q.get()) # 取不到值会堵塞，一直卡在这里,可以判断长度为0时不取值了
deque 双端队列
可以插队，可以查看里面的值
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
from collections import deque
dq = deque([1,2])
dq.append(‘a‘) # 从后面放数据 [1,2,‘a‘]
dq.appendleft(‘b‘) # 从前面放数据 [‘b‘,1,2,‘a‘]
dq.insert(2,3) # 在索引2的前面插入一个3 [‘b‘,1,2,‘a‘]
print(dq)
print(dq.pop()) # 从后面取数据 a
print(dq.popleft()) # 从前面取数 b
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
OrderedDict 有序字典
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：
from collections import OrderedDict
d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]) #普通字典
# print(d) # dict的Key是无序的 # {‘a‘: 1, ‘c‘: 3, ‘b‘: 2}
od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
# od # OrderedDict的Key是有序的
print(od) # OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：
from collections import OrderedDict
od = OrderedDict()
od[‘z‘] = 1
od[‘y‘] = 2
od[‘x‘] = 3
od.keys() # 按照插入的Key的顺序返回
print(od.keys()) # odict_keys([‘z‘, ‘y‘, ‘x‘])
defaultdict 默认字典
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1‘: 大于66 , ‘k2‘: 小于66}首先第一次要判断K1是否在字典里，要先创建K1对应的值后才能后里面追加值，如直接追加会报错
defaultdict 解决办法
from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)
for value in values:
if value>66:
my_dict[‘k1‘].append(value)
else:
my_dict[‘k2‘].append(value)
使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
from collections import defaultdict
dd = defaultdict(lambda: ‘N/A‘) # 参数是可以调用的
dd[‘key1‘] = ‘abc‘
print(dd[‘key1‘]) # key1存在 # abc
print(dd[‘key2‘]) # key2不存在，返回默认值 # ‘N/A‘
Counter 字符串计算
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。
Counter类和其他语言的bags或multisets很相似。
c = Counter(‘abcdeabcdabcaba‘)
print c
输出：Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})
from collections import Counter
c = Counter(‘abcdeabcdabcaba‘)
print (c) # 输出：Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})
其他详细内容 http://www.cnblogs.com/Eva-J/articles/7291842.html 老师博客
标签：功能 div cms git 号码 次数 不能 开头 现在
原文地址：https://www.cnblogs.com/tinaLi/p/13378721.html
