行动力——是对平庸生活最好的回击！
Python中的random模块（属于一种假随机）
Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个函数。
1. random.random # random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0
代码如下(生成随机浮点数):
>>> import random
>>> random.random()
0.85415370477785668
2. random.uniform
random.uniform的函数原型为：random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
代码：
print random.uniform(10, 20)
print random.uniform(20, 10)
# 18.7356606526
# 12.5798298022
>>> random.uniform(1, 10)
5.4221167969800881
3. random.randint [a,b]
代码：
print random.randint(12, 20)
# 生成的随机数 n: 12 <= n <= 20
print random.randint(20, 20)
# 结果永远是20
# print random.randint(20, 10)
# 该语句是错误的，下限必须小于上限
>>> import random
>>> random.randint(0,99)
21
4. random.randrange [a , b)
random.randrange的函数原型为：
步长：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。
random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。
代码如下:
>>> import random
>>> random.randrange(0, 100, 2)
60
#randomint 与randrange的差别在于
randrange可以设置步长；
5. random.choice
random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明 一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。下面是使用choice的一些例子：
代码：
print random.choice("学习Python")
print random.choice(["JGood", "is", "a", "handsome", "boy"])
print random.choice(("Tuple", "List", "Dict"))
>>> import random
>>> random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
'orange'
6.random.shuffle
random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:
代码如下:
>>> import random
>>> p = ["Python", "is", "powerful", "simple", "and so on..."]
>>> random.shuffle(p)
>>> print (p)
['simple', 'is', 'powerful', 'Python', 'and so on...']
7. random.sample
random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列
代码如下:
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slice = random.sample(list, 5) # 从list中随机获取5个元素，作为一个片断返回
print slice
print list # 原有序列并没有改变
>>> import random
>>> random.sample('abcdefghij', 3)
['h', 'g', 'b']
元组
Tuple Docstring:
tuple() -> empty tuple;
tuple(iterable) -> tuple initialized from iterable's items
1. 元组的优点 (相比于列表)
1.通常将元组用于不同的数据类型，将列表用于相同（或相似）的数据类型。
2.由于元组不可变，所以对元组的迭代比列表要快（性能略有提升）。
3.元组可以用作字典的 key，而列表不行（因为字典的 key 必须是不可变的，而元组本身就是不可变的）。
4.如果数据不需要更改，将其作为元组来实现可以确保“写保护”。
2. 元组的定义
Python 中，元组由内置的 tuple 类型定义。
创建元组，需要将所有元素放在圆括号（()）内，以逗号（,）分隔；
构造只有一个元素的元组比较特殊，括号内只包含一个元素是不够的，还需要在元素后添加一个逗号；
t=(1) # 改变优先级 int/str/float ；
t=(1,) # 元祖类型；
元组中的元素可以有任意多个，并且可以是不同类型的（例如：数字、字符串、列表等）：
>>> t = () # 空元组
>>>
>>> t = ('P', 'y') # 字符串类型元组
>>>
>>> t = (1, 5.5, 'Python') # 混合类型元组
>>>
>>> t = (6, 'Hello', ('P', 'y')) # 嵌套元组
>>>
>>> t = 1, 5.5, 'Python' # 元组可以没有括号，称为元组包装
>>> t
(1, 5.5, 'Python')
>>>
>>> a, b, c = t # 元组解包
>>> a
1
>>> b
5.5
>>> c
'Python'
3.更改元组
元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。
但是，如果元素本身是一个可变数据类型（例如：列表、字典），那么其嵌套项可以被改变：
>>> t = (6, 'Hello', ['P', 'y'])
>>>
>>> t[0] = 10 # 不能改变元素
...
TypeError: 'tuple' object does not support item assignment
>>>
>>> t[2][1] = 's' # 可变元素内部可以被改变
>>> t
(6, 'Hello', ['P', 's'])
4.删除元组
如上所述，不能更改元组中的元素，这也意味着无法删除元组中的元素。
但如果元素本身是一个可变数据类型，那么其嵌套项是可以被删除的，而且使用关键字 del 可以删除整个元组：
>>> t = (6, 'Hello', {'name':'Waleon', 'age':18})
>>>
>>> del t[2] # 不能删除元素
...
TypeError: 'tuple' object doesn't support item deletion
>>>
>>> del t[2]['name'] # 可变元素的嵌套项可以被删除
>>> t
(6, 'Hello', {'age': 18})
>>>
>>> del t # 可以删除整个元组
>>> t
...
NameError: name 't' is not defined
2.1 元组方法
元组中的方法相对较少，可以通过 dir() 来查看方法列表：
>>> dir(tuple)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', 'count', 'index']
可以看到，有两个可用的方法：
元组：count/index方法都是O(n) ; 随着规模的增大，而效率下降；
2.2 列表和元组互转
列表和元组之间可以相互转换，分别使用 tuple() 和 list() 来实现
>>> l = ['H', 'e', 'l', 'l', 'o']
>>> tx = tuple(l) # 列表转元组
>>> tx
('H', 'e', 'l', 'l', 'o')
>>>
>>> t = ('P', 'y')
>>> lx = list(t) # 元组转列表
>>> lx
['P', 'y']
既然可以互转，那么要改变元组，可以先将其转化为列表，对列表进行更改，然后再将列表转换为元组。
例如，删除元组中的元素：
>>> t = ('P', 'y')
>>>
>>> lx = list(t) # 将元组转换为列表
>>> lx.remove('y') # 删除列表中的元素
>>> t = tuple(lx) # 再将列表转换为元组
>>> t
('P',)
注意：元组本身是不可变的，这里说的并不是传统意义的改变(增、删、改)，相当于元组的重新赋值。
元组还有些什么？
元组也支持一些基本操作，例如：连接（+）、重复（*）、成员测试（in/not in）等。此外，它还可以与一些内置函数一起使用来执行不同的任务，例如：min()、max()、len() 等。这里就不再介绍了，请参考 Python 列表 。
高级元组namedtuple
1.顾名思义，就是带有名字的元组，这是什么意思呢？就是取值时不再需要通过下标索引的方式来获取了，可以直接叫名字(字段名)，先来看怎么定义的吧。
from collections import namedtuple
# 定义namedtuple类
User = namedtuple("User", 'name gender height weight')
# 或者
# User = namedtuple("User", ['name', 'gender', 'height', 'weight'])
# 初始化namedtuple实例对象
user = User(name="jack", gender="female", height=170, weight=120)
user.name #'jack'
user.gender #'female'
模块导入的两种方式：
import collections
from collections import namedtuple
定义 namedtuple 时，第一个参数就是元组的名字，这里很像我们自定义类中的类名，第二个参数是用空格隔开的字符串（也可以是字符串组成的列表），代表元组中的4个字段，相当于类中的4个属性。初始化方式和类的实例对象是一样的，如果用普通类来定义可表示为：
class User:
def __init__(self, name, gender, height, weight):
self.name = name
self.gender = gender
self.height = height
self.weight = weight
user = User(name="jack", gender="female", height=170, weight=120)
user.name #'jack'
对比起来，其实 namedtuple 就是一个轻量级的类，代码更简洁，当我们的类非常简单，只有属性又不需要定义其他方法时，完全可以用 namedtuple 来代替类，使用 namedtuple 效率比使用普通类更高效，同样因为内部不需要维护太多的东西。
- namedtuple 其实是继承 tuple 的一个子类，它保留了 tuple 的特性，比如通过索引获取元素，切片功能，同样地，字段不能重新赋值。
>>> user[1:3]
('female', 170)
>>> user[0]
'jack'
>>> user.name = 'bob'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
namedtuple 比 tuple 的优势在于 namedtuple 具有可自我描述的特点，因为 tuple 中的值不看上下文你不知道具体代表什么，而 namedtuple 自己就可以说明各字段代表什么。
源码的阅读
帮助文档看不懂，看源码；源码中很多地方用到了namedtuple
map（str,a）生成可迭代对象；一一转换；
网友评论