Day11 线程，进程，协程，缓存（memcached+redis）
线程 进程 协程 缓存
线程
1. 基本使用
import threading
import time
def func(args):
print(args)
time.sleep(1)
for i in range(10):
t = threading.Thread(target=func, args=(i,))
t.start()
2. 线程锁
线程锁：由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。
五种方法，lock(), Rlock(), BoundedSemaphore(), Event()， Condition()
lock() 单层锁 只能被一个线程acquire()一次
Rlock() 多层锁 可以被一个线程acquire()多次
两种基本锁：
import threading
import time
NUM = 10
tl = threading.Lock()
tr = threading.RLock()
tb = threading.BoundedSemaphore(1)
def func(i, arg,):
global NUM
arg.acquire()
NUM -= 1
time.sleep(1)
print(i, NUM)
arg.release()
for i in range(10):
t = threading.Thread(target=func, args=(i, tr, ))
t.start()
信号量(互斥锁)：
同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据。
BoundedSemaphore(n) 同时只有n个线程获得Semaphore
import threading
import time
l = threading.BoundedSemaphore(5)
def func(i, l):
l.acquire()
print(i)
time.sleep(1)
l.release()
for i in range(10):
t = threading.Thread(target=func, args=(i, l))
t.start()
事件锁：
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。
import threading
import time
NUM = 10
e = threading.Event()
def func(i, e):
print(i)
e.wait()
print(i+100)
for i in range(10):
t = threading.Thread(target=func, args=(i, e))
t.start()
e.clear()
while True:
inp = input('>>> ')
if inp == 'go':
e.set()
time.sleep(1)
break
else:
print('Incorrect')
条件锁：
import threading
c = threading.Condition()
def condition():
inp = input('>>> ')
if inp == 'true':
return True
else:
return False
def func(i, c):
print(i)
c.acquire()
c.wait_for(condition)
print(i+100)
c.release()
for i in range(10):
t = threading.Thread(target=func, args=(i, c))
t.start()
补充：（定时器）
import threading
import time
def func():
print('Python')
time.sleep(1)
t = threading.Timer(1, func) # 1s后，打印'Python'
t.start()
3.生产者消费者模型
先引入一个东西，队列
四种队列:
- queue.Queue 先进先出队列
- queue.LifoQueue 后进先出队列
- queue.PriorityQueue 优先级队列
- queue.deque 双向队列
常用方法:
- q.qsize() 返回队列的大小
- q.empty() 如果队列为空，返回True，反之False
- q.full() 如果队列满了，返回True，反之False
- q.full 与 maxsize 大小对应
- q.get([block[, timeout]]) 获取队列，timeout等待时间，默认阻塞
- q.get_nowait() 相当q.get(False)
- q.put(item) 是否阻塞，写入队列，timeout等待时间
- q.put_nowait(item) 相当q.put(item, False)
- q.task_done() 在完成一项工作之后，向任务已经完成的队列发送一个信号,当任务执行完，不再阻塞
- q.join() 实际上意味着等到队列为空，再执行别的操作
队列和多线程的生产者消费者模型：
import threading
import queue
import time
q = queue.Queue(5)
def f1(args):
q.put('%s - 包子' % str(args))
for i in range(30):
c = threading.Thread(target=f1, args=(i, ))
c.start()
def f2(args):
while True:
print(args, q.get())
time.sleep(2)
if q.qsize() == 0:
break
for i in range(3):
s = threading.Thread(target=f2, args=(i, ))
s.start()
线程池
import queue
import threading
import contextlib
import time
StopEvent = object()
class ThreadPool(object):
def __init__(self, max_num, max_task_num = None):
if max_task_num:
self.q = queue.Queue(max_task_num)
else:
self.q = queue.Queue()
self.max_num = max_num
self.cancel = False
self.terminal = False
self.generate_list = []
self.free_list = []
def run(self, func, args, callback=None):
"""
线程池执行一个任务
:param func: 任务函数
:param args: 任务函数所需参数
:param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
:return: 如果线程池已经终止，则返回True否则None
"""
if self.cancel:
return
if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
self.generate_thread()
w = (func, args, callback,)
self.q.put(w)
def generate_thread(self):
"""
创建一个线程
"""
t = threading.Thread(target=self.call)
t.start()
def call(self):
"""
循环去获取任务函数并执行任务函数
"""
current_thread = threading.currentThread
self.generate_list.append(current_thread)
event = self.q.get()
while event != StopEvent:
func, arguments, callback = event
try:
result = func(*arguments)
success = True
except Exception as e:
success = False
result = None
if callback is not None:
try:
callback(success, result)
except Exception as e:
pass
with self.worker_state(self.free_list, current_thread):
if self.terminal:
event = StopEvent
else:
event = self.q.get()
else:
self.generate_list.remove(current_thread)
def close(self):
"""
执行完所有的任务后，所有线程停止
"""
self.cancel = True
full_size = len(self.generate_list)
while full_size:
self.q.put(StopEvent)
full_size -= 1
def terminate(self):
"""
无论是否还有任务，终止线程
"""
self.terminal = True
while self.generate_list:
self.q.put(StopEvent)
self.q.empty()
@contextlib.contextmanager
def worker_state(self, state_list, worker_thread):
"""
用于记录线程中正在等待的线程数
"""
state_list.append(worker_thread)
try:
yield
finally:
state_list.remove(worker_thread)
pool = ThreadPool(5)
def callback(status, result):
# status, execute action status
# result, execute action return value
pass
def action(i):
print(i)
for i in range(300):
ret = pool.run(action, (i,), callback)
# time.sleep(5)
# print(len(pool.generate_list), len(pool.free_list))
# print(len(pool.generate_list), len(pool.free_list))
进程
from multiprocessing import Process
def func(i):
print('Say Hi ------ %d' % i)
for i in range(10):
Process(target=func, args=(i,)).start()
进程间默认数据不共享，由于数据各自持有，所以创建进程开销大。
数据共享
1. 使用Array
不加锁：
from multiprocessing import Process, RLock, Array
def f(l, n):
n[0] -= 1
print(n[0])
if __name__ == '__main__':
li = Array('i', 1) # 'i' 对应int类型， 1表示数组长度为1
lock = RLock()
li[0] = 10
for num in range(20):
Process(target=f, args=(lock, li)).start()
由于数据共享，不加锁，print出来的结果会有脏数据情况产生。
加锁：
from multiprocessing import Process, RLock, Array
def f(l, n):
with l:
n[0] -= 1
print(n[0])
if __name__ == '__main__':
li = Array('i', 1)
lock = RLock()
li[0] = 10
for num in range(20):
Process(target=f, args=(lock, li)).start()
补充（类型对应）：
'c': ctypes.c_char, 'u': ctypes.c_wchar,
'b': ctypes.c_byte, 'B': ctypes.c_ubyte,
'h': ctypes.c_short, 'H': ctypes.c_ushort,
'i': ctypes.c_int, 'I': ctypes.c_uint,
'l': ctypes.c_long, 'L': ctypes.c_ulong,
'f': ctypes.c_float, 'd': ctypes.c_double
2. 使用Manager
from multiprocessing import Process, Manager
def f(i, n):
n[i] = 100 + i
print(n)
if __name__ == '__main__':
with Manager() as manager:
data = manager.dict()
for num in range(10):
t = Process(target=f, args=(num, data))
t.start()
t.join()
进程池
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。
进程池中有两个方法：apply_async()，apply()
from multiprocessing import Process, Pool
import time
def f(i):
time.sleep(1)
print(i)
if __name__ == '__main__':
with Pool(5) as pool:
for i in range(10):
pool.apply_async(func=f, args=(i, ))
pool.close() # 所有的任务执行完毕
# pool.terminate() # 立即终止
pool.join() # 进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭
注意使用apply_async()方法，如果使用apply()就是阻塞版本的多进程并发
协程
线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。
存在意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程
greenlet模块：
from greenlet import greenlet
def f1():
print('A+')
g2.switch()
print('B+')
g2.switch()
def f2():
print('A-')
g1.switch()
print('B-')
g1.switch()
g1= greenlet(f1)
g2= greenlet(f2)
g1.switch()
gevent模块：
from gevent import monkey;monkey.patch_all()
import gevent
import requests
def f(url):
print('GET: %s' % url)
resp = requests.get(url)
data = resp.text
print('%d bytes recive from %s.' % (len(data), url))
gevent.joinall([
gevent.spawn(f, 'https://www.python.org'),
gevent.spawn(f, 'https://www.centos.org'),
gevent.spawn(f, 'https://github.com'),
])
缓存操作-Memcached
下载地址：Memcached
1. add
添加一条键值对，如果已经存在的 key，重复执行add操作异常
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
mc.add('k1', 'v1')
mc.add('k1', 'v2') # 报错：MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
2. replace
replace 修改某个key的值，如果key不存在，则异常
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
mc.add('k1', 'v1')
print(mc.get('k1'))
mc.replace('k1', 'v2')
print(mc.get('k1'))
3. set 和 set_multi
set 设置一个键值对，如果key不存在，则创建，如果key存在，则修改
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
mc.set('k1', 'v3')
print(mc.get('k1'))
print(mc.get('k4'))
mc.set('k4', 'v4')
print(mc.get('k4'))
set_multi 设置多个键值对，如果key不存在，则创建，如果key存在，则修改
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
print(mc.get_multi(['k7', 'k8']))
mc.set_multi({'k7':'v5', 'k8':'v6'}) # 字典形式存储
print(mc.get_multi(['k7', 'k8'])) # 列表形式读取
4. delete 和 delete_multi
delete 在Memcached中删除指定的一个键值对
delete_multi 在Memcached中删除指定的多个键值对
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
print(mc.get('k8'))
mc.delete('k8')
print(mc.get('k8'))
print(mc.get_multi(['k6', 'k7']))
mc.delete_multi(['k6', 'k7']) #列表形式删除
print(mc.get_multi(['k6', 'k7']))
5. get 和 get_multi
get 获取一个键值对
get_multi 获取多一个键值对
参考上面用法
6. append 和 prepend
append 修改指定key的值，在该值后面追加内容
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
print(mc.get('k5'))
mc.append('k5', '-after')
print(mc.get('k5')
prepend 修改指定key的值，在该值前面插入内容
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
print(mc.get('k4'))
mc.prepend('k4', '-before')
print(mc.get('k4'))
7、decr 和 incr
incr 自增，将Memcached中的某一个值增加N（N默认为1）
decr 自减，将Memcached中的某一个值减少N（N默认为1）
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
mc.set_multi({'k2':18, 'k3':18})
print(mc.get_multi(['k2', 'k3']))
mc.incr('k2')
print(mc.get('k2'))
mc.decr('k3')
print(mc.get('k3'))
8. gets 和 cas
线程数据共享时处理不好会产生脏数据，为了避免脏数据，我们使用线程锁来避免该类问题。在memcached中也一样会存在这种情况，而gets和cas方式就相当于加了锁机制，保证数据的准确。
A:
import memcache
import time
mc = memcache.Client(['127.0.0.1:11211'], debug=True, cache_cas=True)
mc.gets('num')
time.sleep(10)
mc.cas('num', 999)
print(mc.get('num'))
B:
import memcache
mc = memcache.Client(['12.12.11.137:11211'], debug=True, )
mc.set('num', 500)
print(mc.get('num'))
缓存之redis
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
数据模型：
Redis的外围由一个键、值映射的字典构成。与其他非关系型数据库主要不同在于：Redis中值的类型
不仅限于字符串，还支持如下抽象数据类型：
- 字符串列表
- 无序不重复的字符串集合
- 有序不重复的字符串集合
- 键、值都为字符串的哈希表
值的类型决定了值本身支持的操作。Redis支持不同无序、有序的列表，无序、有序的集合间的交集、并集等高级服务器端原子操作。
数据结构：
redis提供五种数据类型：string，hash，list，set及zset(sorted set)。
存储：
redis使用了两种文件格式：全量数据和增量请求。
全量数据格式是把内存中的数据写入磁盘，便于下次读取文件进行加载；
增量请求文件则是把内存中的数据序列化为操作请求，用于读取文件进行replay得到数据，序列化的操作包括SET、RPUSH、SADD、ZADD。
redis的存储分为内存存储、磁盘存储和log文件三部分，配置文件中有三个参数对其进行配置。
save seconds updates，save配置，指出在多长时间内，有多少次更新操作，就将数据同步到数据文件。这个可以多个条件配合，比如默认配置文件中的设置，就设置了三个条件。
appendonly yes/no ，appendonly配置，指出是否在每次更新操作后进行日志记录，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面的save条件来同步的，所以有的数据会在一段时间内只存在于内存中。
appendfsync no/always/everysec ，appendfsync配置，no表示等操作系统进行数据缓存同步到磁盘，always表示每次更新操作后手动调用fsync()将数据写到磁盘，everysec表示每秒同步一次。
redis模块(API)使用
Python redis的API的使用可以分类为：
- 连接方式
- 连接池
- 操作
- String 操作
- Hash 操作
- List 操作
- Set 操作
- Sort Set 操作
- 管道
- 发布订阅
redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
import redis
r = redis.Redis(host='192.168.224.136', port=6379)
r.set('foo', 'Bar')
print r.get('foo')
连接池：
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
import redis
pool = redis.ConnectionPool(host='192.168.224.136', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('name', 'tom')
print(r.get('name'))
String操作
redis中的String在在内存中按照一个name对应一个value来存储。
set(name, value, ex=None, px=None, nx=False, xx=False) 作用：在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，岗前set操作才执行
setnx(name, value) 作用：设置值，只有name不存在时，执行设置操作（添加）
setex(name, value, time) 作用：设置值
参数：
time，过期时间（数字秒 或 timedelta对象）
psetex(name, time_ms, value) 作用：设置值
参数：
time_ms，过期时间（数字毫秒 或 timedelta对象）
mset(*args, **kwargs) 作用：批量设置值
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
get(name) 作用：获取值
mget(keys, *args)
作用：批量获取
如：
r.mget('name', 'age')
或
r.mget(['name', 'age'])
getset(name, value)
作用：设置新值并获取原来的值
getrange(key, start, end) 作用：获取子序列（根据字节获取，非字符）
name，Redis 的 name
start，起始位置（字节）
end，结束位置（字节）
如： "alex" ，0-3表示 "ale"
setrange(name, offset, value) 作用：修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
offset，字符串的索引，字节（一个汉字三个字节）
value，要设置的值
setbit(name, offset, value) 作用：对name对应值的二进制表示的位进行操作
name，redis的name
offset，位的索引（将值变换成二进制后再进行索引）
value，值只能是 1 或 0
注：如果在Redis中有一个对应： n1 = "foo"，那么字符串foo的二进制表示为：01100110 01101111 01101111 所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，那么最终二进制则变成 01100111 01101111 01101111，即："goo"
扩展，转换二进制表示：
# source = "我的天"
source = "foo"
for i in source:
num = ord(i)
print（bin(num).replace('b','')）
特别的，如果source是汉字 "我的天"怎么办？
答：对于utf-8，每一个汉字占 3 个字节，那么 "武沛齐" 则有 9个字节
对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制
11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000
-------------------------- ----------------------------- -----------------------------
我 的 天
getbit(name, offset) 作用： 获取name对应的值的二进制表示中的某位的值 （0或1）
bitcount(key, start=None, end=None) 作用：获取name对应的值的二进制表示中 1 的个数
key，Redis的name
start，位起始位置
end，位结束位置
bitop(operation, dest, *keys) 作用：获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
dest, 新的Redis的name
*keys,要查找的Redis的name
如：
bitop("AND", 'new_name', 'n1', 'n2', 'n3')
获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
strlen(name) 作用：返回name对应值的字节长度（一个汉字3个字节）
incr(self, name, amount=1) 作用：自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
name,Redis的name
amount,自增数（必须是整数）
注：同incrby
incrbyfloat(self, name, amount=1.0) 作用：自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
name,Redis的name
amount,自增数（浮点型）
decr(self, name, amount=1) 作用：自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
name,Redis的name
amount,自减数（整数）
append(key, value) 作用：在redis name对应的值后面追加内容
key, redis的name
value, 要追加的字符串
Hash操作
hset(name, key, value) 作用：name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
name，redis的name
key，name对应的hash中的key
value，name对应的hash中的value
注：hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
hmset(name, mapping)
在name对应的hash中批量设置键值对
name，redis的name
mapping，字典，
如：{'k1':'v1', 'k2': 'v2'}
如：r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
hget(name,key) 作用：在name对应的hash中获取根据key获取value
hmget(name, keys, *args) 作用：在name对应的hash中获取多个key的值
name，reids对应的name
keys，要获取key集合，如：['k1', 'k2', 'k3']
*args，要获取的key，如：k1,k2,k3
如：
r.mget('xx', ['k1', 'k2'])
或
print r.hmget('xx', 'k1', 'k2')
hgetall(name) 获取name对应hash的所有键值
hlen(name) 作用：获取name对应的hash中键值对的个数
hkeys(name) 作用：获取name对应的hash中所有的key的值
hvals(name) 作用：获取name对应的hash中所有的value的值
hexists(name, key) 作用：检查name对应的hash是否存在当前传入的key
hdel(name,*keys) 作用：将name对应的hash中指定key的键值对删除
hincrby(name, key, amount=1) 作用：自增name对应的hash中的指定key的值，不存在则创建key=amount
name，redis中的name
key， hash对应的key
amount，自增数（整数）
hincrbyfloat(name, key, amount=1.0) 作用：自增name对应的hash中的指定key的值，不存在则创建key=amount
name，redis中的name
key， hash对应的key
amount，自增数（浮点数）
自增name对应的hash中的指定key的值，不存在则创建key=amount
hscan(name, cursor=0, match=None, count=None) 作用：增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
name，redis的name
cursor，游标（基于游标分批取获取数据）
match，匹配指定key，默认None 表示所有的key
count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
如：
第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
...
直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
hscan_iter(name, match=None, count=None)
利用yield封装hscan创建生成器，实现分批去redis中获取数据
match，匹配指定key，默认None 表示所有的key
count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
如：
for item in r.hscan_iter('xx'):
print item
List操作
redis中的List在在内存中按照一个name对应一个List来存储
lpush(name,values) 作用：在name对应的list中添加元素，每个新的元素都添加到列表的最左边
如：
r.lpush('nums', 11,22,33)
保存顺序为: 33,22,11
扩展：
rpush(name, values) 表示从右向左操作
lpushx(name,value)
在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
更多：rpushx(name, value) 表示从右向左操作
llen(name)
name对应的list元素的个数
linsert(name, where, refvalue, value))
在name对应的列表的某一个值前或后插入一个新值
参数：
name，redis的name
where，BEFORE或AFTER
refvalue，标杆值，即：在它前后插入数据
value，要插入的数据
lset(name, index, value)
对name对应的list中的某一个索引位置重新赋值
参数：
name，redis的name
index，list的索引位置
value，要设置的值
lrem(name, value, num)
在name对应的list中删除指定的值
参数：
name，redis的name
value，要删除的值
num， num=0，删除列表中所有的指定值；
num=2,从前到后，删除2个；
num=-2,从后向前，删除2个
lpop(name)
在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
更多：
rpop(name) 表示从右向左操作
lindex(name, index)
在name对应的列表中根据索引获取列表元素
lrange(name, start, end)
在name对应的列表分片获取数据
参数：
name，redis的name
start，索引的起始位置
end，索引结束位置
ltrim(name, start, end)
在name对应的列表中移除没有在start-end索引之间的值
参数：
name，redis的name
start，索引的起始位置
end，索引结束位置
rpoplpush(src, dst)
从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
参数：
src，要取数据的列表的name
dst，要添加数据的列表的name
blpop(keys, timeout)
将多个列表排列，按照从左到右去pop对应列表的元素
参数：
keys，redis的name的集合
timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
更多：
r.brpop(keys, timeout)，从右向左获取数据
brpoplpush(src, dst, timeout=0)
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
参数：
src，取出并要移除元素的列表对应的name
dst，要插入元素的列表对应的name
timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
1、获取name对应的所有列表
2、循环列表
但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
def list_iter(name):
"""
自定义redis列表增量迭代
:param name: redis中的name，即：迭代name对应的列表
:return: yield 返回 列表元素
"""
list_count = r.llen(name)
for index in xrange(list_count):
yield r.lindex(name, index)
使用
for item in list_iter('pp'):
print item
Set操作
Set集合就是不允许重复的列表
sadd(name,values)
name对应的集合中添加元素
scard(name)
获取name对应的集合中元素个数
sdiff(keys, *args)
在第一个name对应的集合中且不在其他name对应的集合的元素集合
sdiffstore(dest, keys, *args)
获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
sinter(keys, *args)
获取多一个name对应集合的并集
sinterstore(dest, keys, *args)
获取多一个name对应集合的并集，再讲其加入到dest对应的集合中
sismember(name, value)
检查value是否是name对应的集合的成员
smembers(name)
获取name对应的集合的所有成员
smove(src, dst, value)
将某个成员从一个集合中移动到另外一个集合
spop(name)
从集合的右侧（尾部）移除一个成员，并将其返回
srandmember(name, numbers)
从name对应的集合中随机获取 numbers 个元素
srem(name, values)
在name对应的集合中删除某些值
sunion(keys, *args)
获取多一个name对应的集合的并集
sunionstore(dest,keys, *args)
获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)
同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
有序集合
在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
zadd(name, *args, **kwargs)
在name对应的有序集合中添加元素
如：
zadd('zz', 'n1', 1, 'n2', 2)
或
zadd('zz', n1=11, n2=22)
zcard(name)
获取name对应的有序集合元素的数量
zcount(name, min, max)
获取name对应的有序集合中分数 在 [min,max] 之间的个数
zincrby(name, value, amount)
自增name对应的有序集合的 name 对应的分数
zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
按照索引范围获取name对应的有序集合的元素
参数：
name，redis的name
start，有序集合索引起始位置（非分数）
end，有序集合索引结束位置（非分数）
desc，排序规则，默认按照分数从小到大排序
withscores，是否获取元素的分数，默认只获取元素的值
score_cast_func，对分数进行数据转换的函数
更多：
从大到小排序
zrevrange(name, start, end, withscores=False, score_cast_func=float)
按照分数范围获取name对应的有序集合的元素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
从大到小排序
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
zrank(name, value)
获取某个值在 name对应的有序集合中的排行（从 0 开始）
更多：
zrevrank(name, value)，从大到小排序`
zrangebylex(name, min, max, start=None, num=None)
当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
参数：
name，redis的name
min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
min，右区间（值）
start，对结果进行分片处理，索引位置
num，对结果进行分片处理，索引后面的num个元素
如：
ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
更多：
从大到小排序
zrevrangebylex(name, max, min, start=None, num=None)
zrem(name, values)
删除name对应的有序集合中值是values的成员
如：
zrem('zz', ['s1', 's2'])
zremrangebyrank(name, min, max)
根据排行范围删除
zremrangebyscore(name, min, max)
根据分数范围删除
zremrangebylex(name, min, max)
根据值返回删除
zscore(name, value)
获取name对应有序集合中 value 对应的分数
zinterstore(dest, keys, aggregate=None)
获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为: SUM MIN MAX
zunionstore(dest, keys, aggregate=None)
获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为: SUM MIN MAX
scan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作
其他常用操作
delete(*names)
根据删除redis中的任意数据类型
exists(name)
检测redis的name是否存在
keys(pattern='*')
根据模型获取redis的name
更多：
KEYS * 匹配数据库中所有 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
expire(name ,time)
为某个redis的某个name设置超时时间
rename(src, dst)
对redis的name重命名为
move(name, db))
将redis的某个值移动到指定的db下
randomkey()
随机获取一个redis的name（不删除）
type(name)
获取name对应值的类型
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
同字符串操作，用于增量迭代获取key
