day19其他模块

collections模块

详细内容 http://www.cnblogs.com/Eva-J/articles/7291842.html

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

from collections import namedtuple

Point = namedtuple('changfx',['x','y','z'])　　# 变量 = namedtuple('名字'，[元祖元素])　　这里以一个长方形为例子
p = Point(5,6,7)
print(p)
print(p.x)
print(p.y)
print(p.z)

changfx(x=5, y=6, z=7)
5
6
7

Puke = namedtuple('puke',['color','num'])
p1 = Puke('红桃',12)
print(p1)
print(p1.color)
print(p1.num)
puke(color='红桃', num=12)
红桃
12

2.queue:队列

import queue
# 创建基本队列
# queue.Queue(maxsize=0)创建一个队列对象（队列容量），若maxsize小于或者等于0，队列大小没有限制
Q = queue.Queue(10)
print(Q)
Q.put(4)            # 插入队列元素
Q.put([5,6])        # 队列一次只可以插入一个元素，此处列表为一个元素
print(Q.queue)      # 查看队列所有元素
print(Q.qsize())    # 查看队列大小
print(Q.empty())    # 查看队列是否空
print(Q.full())     # 查看对了是否满
print(Q.get())      # 取出队列元素，先进先出原则

<queue.Queue object at 0x000001A694D402B0>
deque([4, [5, 6]])
2
False
False
4

双端队列

使用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,3,2,'a']
print(dq.pop())     # 从后面取数据
print(dq.popleft()) # 从前面取数据
print(dq)

a
b
deque([1, 3, 2])

有序字典 OrderdDict

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

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

from collections import OrderedDict
# 普通方法字典创建
od = {'a':1,'b':2,'c':3}
od1 = dict([('a',1),('b',2),('c',3)])
# 有序字典创建
od2 = OrderedDict([('a',1),('b',2),('c',3)])
print(od)
print(od1)
print(od2)
print(od2['a'])
for k in od2.items() :
    print(k)

{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3}
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
1
('a', 1)
('b', 2)
('c', 3)

默认字典 defaultdict

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

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

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]

原生字典解决方法

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)

defaultdict字典解决方法

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

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

time模块

import time
# time.sleep(10)  # 程序休息  秒
print(time.time())     # 时间戳时间，返回一个以秒为单位浮点数
print(time.strftime("%Y-%m-%d %X"))                                   # 字符串格式化时间
print(time.strftime("%Y:%m:%d  %a %H:%M:%S"))    # %a 显示星期几
print(time.localtime())                                                 # 结构化时间

print(time.mktime(time.localtime()))
# print(time.strftime('2000-12.31','%Y-%m.%d'))
print(time.asctime())                               # 显示详细时间
print(time.ctime())

###   时间戳转换成结构化时间
t = time.time()
print(time.localtime(t))
print(time.gmtime(t))
###   结构化时间转换成时间戳
t2 = time.localtime(t)
print(time.mktime(t2))
### 结构化数据转换成 字符串格式化时间
t3 = time.strptime('2000-12.30','%Y-%m.%d')  # 字符串转结构化
print(t3)
t4 = time.strftime('%Y:%m:%d %H:%M:%S',time.localtime()) # 结构化数据转字符串格式化数据
print(t4)

random模块

import random

# 随机小数
ret1 = random.random()   # 大于0小于1的小数
print(ret1)
ret2 = random.uniform(1,3) # 大于1小于3的小数
print(ret2)

# 返回整数
ret3 = random.randint(1,5)  # 大于1小于等于5之间的整数
print(ret3)
ret4 = random.randrange(1,10,2) # 大于1小于10的奇数
print(ret4)

# 随机一个返回
ret5 = random.choice(['a','b',1,2])  # 接收一个列表，随机返回
print(ret5)

# 随机多个数返回
ret6 = random.sample([1,2,3,4,5],3)   # 接收一个列表，随机返回多个数组成一个列表
print(ret6)

# 打乱列表顺序
lst = [1,2,3,4,5,6,7,8,9]
random.shuffle(lst)
print(lst)                              # 打乱顺序，洗牌功能