python笔记：随机数,md5,en/decoder

uuid 生成随机识别号

```import uuid

for i in range(0,10):
print "uuid is :"+ str(uuid.uuid4())```

另一种实现

```import os
import base64

def GetRndStr():
rndByte = os.urandom(6)
b64Str = base64.urlsafe_b64encode(rndByte)
return b64Str```

生成不重复随机序列

```import random

def get_rnd(max_size, counts):
basearr = [x for x in range(max_size)]
result = []

max_position = max_size - 1
while counts and max_position:
rnd_position = random.randint(0, max_position)
result.append(basearr[rnd_position])
basearr[rnd_position] = basearr[max_position]
max_position -= 1
counts -= 1
return result

for i in range(10):
print(get_rnd(1000, 50))```

生成snowflake流水号

```import datetime
import math
import time
import uuid

from random import SystemRandom

cryptogen = SystemRandom()

# 0位 时间 机器码 random 流水号
# 0 - 0 * 41 - 0 * 10 - 0 * 8 - 0 * 4

class SnowFlake(object):
def __init__(self):
self._INIT_TIME = 1420041600000  # 2015-01-01
self._last_timestamp = 0
self._WORKER_ID_LEN = 10
self._RAM_LEN = 8
self._FLOW_LEN = 22 - self._WORKER_ID_LEN - self._RAM_LEN
self._flow = 0
self._FLOW_MAX = int(math.pow(2, self._FLOW_LEN))
self._worker_id = None
self._ram = None

def _get_worker_id(self):
if not self._worker_id:
self._worker_id = uuid.getnode() % \
int(math.pow(2, self._WORKER_ID_LEN))
return self._worker_id

def _generate_ram(self):
self._ram = (self._ram + 1) % \
int(math.pow(2, self._WORKER_ID_LEN))

def _get_ram(self):
if not self._ram:
self._ram = cryptogen.randrange(0, 100000) % \
int(math.pow(2, self._RAM_LEN))
return self._ram

def generate(self):
self._lock.acquire(1)
tp = int(time.time() * 1000)
tp = tp - self._INIT_TIME

if tp < self._last_timestamp:
# 处理时间回拔，重新生成ram
self._generate_ram()

if tp == self._last_timestamp:
self._flow += 1
if self._flow > self._FLOW_MAX:
raise Exception("flow no overflowed!")
else:
self._last_timestamp = tp
self._flow = 1

ret = 0

ret += tp << (self._WORKER_ID_LEN + self._RAM_LEN + self._FLOW_LEN)
ret += self._get_worker_id() << (self._RAM_LEN + self._FLOW_LEN)
ret += self._get_ram() << self._FLOW_LEN
ret += self._flow

self._lock.release()
return ret

def get_time(self, flow_no):
flow_tp = flow_no >> (self._WORKER_ID_LEN + self._RAM_LEN + self._FLOW_LEN)
utc_tp = flow_tp + self._INIT_TIME

dt = datetime.datetime.fromtimestamp(utc_tp / 1000)
return dt

def get_worker_id(self, flow_no):
worker_id = flow_no >> self._FLOW_LEN + self._RAM_LEN
worker_id = worker_id & ((1 << self._WORKER_ID_LEN) - 1)
return worker_id

def get_ram(self, flow_no):
ram = flow_no >> self._FLOW_LEN
ram = ram & ((1 << self._RAM_LEN) - 1)
return ram

if __name__ == '__main__':
snowflake = SnowFlake()
for i in range(10):
flow_no = snowflake.generate()
bit_flow_no = '{:064b}'.format(flow_no)
dt = snowflake.get_time(flow_no)
worker_id = snowflake.get_worker_id(flow_no)
ram = snowflake.get_ram(flow_no)
# print(flow_no)
print("{} \n{} \n{} "
"\n{} \n{}".format(flow_no, bit_flow_no, dt, worker_id, ram))```

加权随机数

```import random

# 加权随机数
def rnd_power(power_ranks: [int]) -> int:
"""
传入权重，随机返回该权重的index
:param power_ranks: [10,20,30,40]
:return: index of power_rank
"""
sum_ranks = sum(power_ranks)
rnd = random.randint(0, sum_ranks - 1)
all_rank = 0
for i, rank in enumerate(power_ranks):
all_rank += rank
if rnd < all_rank:
return i

if __name__ == '__main__':
result = [0, 0, 0, 0]
for i in range(10000):
index = rnd_power([10, 20, 30, 40])
result[index] += 1
print(result) # [1000, 2025, 2973, 4002]```

2 md5加密

```import hashlib

md5obj = hashlib.md5()
md5obj.update("hello")
md5obj.update("world")

print md5obj.hexdigest()

#md5文件
def CalcMD5(filepath):
with open(filepath,'rb') as f:
md5obj = hashlib.md5()
hash = md5obj.hexdigest()
return hash```

3 url的编码和解码

```import urllib
import urlparse

data = {
'name':'尹子豪',
'id':'346093'
}
#返回的是string类型的url
data = urllib.urlencode(data) #比较坑，有urlencode没有urldecode。。
print data

data = urlparse.urlparse("www.yinzihao.com.cn/index?"+data) #凑个网址，使用parse拆分
print data

params=urlparse.parse_qs(data.query,True) #拆分url参数，自动urldecode了，大家不用担心。
print params
myname = params['name'][0] #此时可以打印名称了
print myname.decode('utf-8').encode('gbk') #输出的时候使用系统的gbk编码，否则乱码。```

py3可以这样

```from urllib import parse

test = "大猪"
test = parse.quote(test)
print(test)
test = parse.unquote(test)
print(test)```

4 htmlencoder和decoder

```import HTMLParser
import cgi

def decodeHtml(input):
h = HTMLParser.HTMLParser()
s = h.unescape(input)
return s

def encodeHtml(input):
s = cgi.escape(input)
return s```

py3

```from html import escape, unescape

strs = "<span>&#62;</span>"
strs = escape(strs)
print(strs)
strs = unescape(strs)
print(strs)```

0 条评论

• python笔记：迭代器

1 原理 指实现系统的迭代接口，这样，我们自己的对象也能使用系统的 for in 来进行迭代循环，是不是很酷！ 在每次迭代之时，类的内部状态都发生了变化，所以我...

• python:组合模式

组合模式是一种抽象。将整体和部分统一对待。 比如一个网页。它可以显示一条新闻，N条新闻，它的操作“显示”对于一条新闻和N条新闻的动作是一致的。“N条新闻”是“一...

• python笔记：面向对象

1 封装与断言 在Python中，用类封装概念十分简单，下面是一个类的使用。所有的类都继承自object。在类的成员函数中，第一个参数必须是self，否则，这个...

• PyQt QMainWindow 简单使用

QMainWindow继承自QWidget QMainWindow相当于程序的主界面，内置了menu和toolBar。 使用 Qt Designer 可以很方便...

• 使用 Pyqt5 制作猜数游戏 GUI

首先，选择 Pycharm ->File->Settings-> Tools->External Tools,点击 + ，添加新项目。name 可以设为 'qt...

• 自定义求解器之Cholesky分解法

，这种分解被称为Cholesky分解，是LU分解的一个重要特例，可以显著降低计算量。在计算机程序中常常用到这种方法解线性代数方程组。它的优点是节省存储量，得到的...

• [源码解析] 并行分布式任务队列 Celery 之 多进程架构和模型

Celery是一个简单、灵活且可靠的，处理大量消息的分布式系统，专注于实时处理的异步任务队列，同时也支持任务调度。因为 Celery 通过多进程来提高执行效率，...

• python——类

通过上面的代码，我们知道创建一个对象使用man = Human("Zhao Si", "man", 18, 172, 67) 也知道了，如何使用对象的方法ma...

• PyQt5 从零开始制作 PDF 阅读器(一)

此前，我已经写了三篇关于 Ui 界面的文章，分别是：猜数游戏、计时器程序和天气查询软件。这次，我们使用 Python 实现 PDF 阅读器。