python中的random和collection包

random包

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(0,101,2) )   # 生成从0到100的间隔为2的随机整数  生成奇偶数
print( random.randrange(10))   # 0-9的整数
a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

输出：

2
0.9102862018860547
2.6921488352834926
r
36
7
[6, 3, 1, 5, 7]

collection包

collections模块自Python 2.4版本开始被引入，包含了dict、set、list、tuple以外的一些特殊的容器类型，分别是：

• OrderedDict类：排序字典，是字典的子类。引入自2.7。
• namedtuple()函数：命名元组，是一个工厂函数。引入自2.6。
• Counter类：为hashable对象计数，是字典的子类。引入自2.7。
• deque：双向队列。引入自2.4。
• defaultdict：使用工厂函数创建字典，使不用考虑缺失的字典键。引入自2.5。

1.计数器（counter）

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

（1）创建

创建一个空的Counter类

import collections
c = collections.Counter()# 创建一个空的Counter类
print(c)
c = collections.Counter('asdfghjjhgfdqwer')
print(c)
c = collections.Counter({'a': 4, 'b': 2})#从一个字典对象创建
print(c)
c = collections.Counter(a=4, b=2) # 从一组键值对创建
print(c)

结果：

Counter()
Counter({'d': 2, 'f': 2, 'h': 2, 'g': 2, 'j': 2, 's': 1, 'a': 1, 'r': 1, 'q': 1, 'e': 1, 'w': 1})
Counter({'a': 4, 'b': 2})
Counter({'a': 4, 'b': 2})

(2).计数值的访问
当所访问的键不存在时，返回0，而不是KeyError；否则返回它的计数。

>>> import collections
>>> c = collections.Counter('asdfgdsasdf')
>>> c['a']
2
>>> c['h']
0
>>> c['s']
3
>>> 

(3).计数器的更新与减少

1.update()更新

>>> c
Counter({'s': 3, 'd': 3, 'a': 2, 'f': 2, 'g': 1})
>>> c = collections.Counter('update')
>>> c.update('update')
>>> c
Counter({'a': 2, 'e': 2, 'd': 2, 'p': 2, 'u': 2, 't': 2})

2.subtract()减少

(4）键的删除

当计数值为0时，并不意味着元素被删除，删除元素应当使用del
(5) 迭代器

返回一个迭代器。元素被重复了多少次，在该迭代器中就包含多少个该元素。所有元素按照字母序排序，个数小于1的元素不被包含。
(6）浅拷贝
(7）算术与集合操作

+、-、&、|操作也可以用于Counter。其中&和|操作分别返回两个Counter对象各元素的最小值和最大值。需要注意的是，得到的Counter对象将删除小于1的元素。

2.有序字典(orderedDict )

有序字典继承字典的一切属性，只是在顺序上是有序的。

>>> import collections
>>> info = collections.OrderedDict({'name':'liuyao','age':21})
>>> info
OrderedDict([('age', 21), ('name', 'liuyao')])
>>> type(info)
<class 'collections.OrderedDict'>

import collections
info = collections.OrderedDict(name='liuyao',age='21',job='IT')
print (info)
print (info.keys())
print (info.values())
OrderedDict([('age', '21'), ('name', 'liuyao'), ('job', 'IT')])
odict_keys(['age', 'name', 'job'])
odict_values(['21', 'liuyao', 'IT'])

3.默认字典(defaultdict)

这里的defaultdict(function_factory)构建的是一个类似dictionary的对象，其中keys的值，自行确定赋值，但是values的类型，是function_factory的类实例，而且具有默认值。比如default(int)则创建一个类似dictionary对象，里面任何的values都是int的实例，而且就算是一个不存在的key, d[key] 也有一个默认值，这个默认值是int()的默认值0.

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。创建一个默认字典，value值类型为列表.dic = collections.defaultdict(list)

import collections
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
 
d = collections.defaultdict(list)
for k, v in s:
    d[k].append(v)
 
list(d.items())

defaultdict可以接受一个内建函数list作为参数。其实呢，list()本身是内建函数，但是再经过更新后，python里面所有东西都是对象，所以list改编成了类，引入list的时候产生一个类的实例。

import collections
dic = collections.defaultdict(list)
dic['k1']
print (dic)
print (dic.keys())
print (dic.values())
dic['k1'].append('v1')
print (dic.values())

4.可命名元组(namedtuple)

没有现成的类，用户需要自行创建相应的类

import collections
tu = collections.namedtuple('tu',['x','y','z'])  #创建一个类,类名为Point
yao_tu = tu(11,22,33)
print(yao_tu)
print(yao_tu.x)  #直接通过命名元素去访问元组对应的元素,
print(yao_tu[1])  #等同于上面这种方式,但是没有上面这种方式可读性强
print(yao_tu.y)
print(yao_tu.z)

5.双向队列(deque)

（1）创建一个队列

import collections
que = collections.deque(['sb','liu','yao'])
print (que)

(2)追加元素到队列

>>> que.append('wo')
>>> que
deque(['sb', 'liu', 'yao', 'wo'])
>>> que.append(['ni','ta'])
>>> que
deque(['sb', 'liu', 'yao', 'wo', ['ni', 'ta']])

（3）追加元素到队列左侧

>>> que.appendleft('zuo')
>>> que
deque(['zuo', 'sb', 'liu', 'yao', 'wo', ['ni', 'ta']])`

未完待续···