python常用模块

什么是模块？

   常见的场景：一个模块就是一个包含了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 reret = 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 reret = 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 namedtuplepoint = 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 dequedq = 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()) # 从后面取数据 aprint(dq.popleft()) # 从前面取数 bdeque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。OrderedDict 有序字典

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

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

from collections import OrderedDictd = 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 OrderedDictod = OrderedDict()od[‘z‘] = 1od[‘y‘] = 2od[‘x‘] = 3od.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是否在字典里，要先创建K1对应的值后才能后里面追加值，如直接追加会报错defaultdict 解决办法from collections import defaultdictvalues = [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 defaultdictdd = defaultdict(lambda: ‘N/A‘) # 参数是可以调用的dd[‘key1‘] = ‘abc‘print(dd[‘key1‘]) # key1存在 # abcprint(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  Counterc = Counter(‘abcdeabcdabcaba‘)print (c) # 输出：Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})其他详细内容 http://www.cnblogs.com/Eva-J/articles/7291842.html 老师博客