RabbitMQ、Memcache、Redis(队列、缓存)
RabbitMQ
一、解釋
RabbitMQ是一個在AMQP基礎(chǔ)上完整的，可復(fù)用的企業(yè)消息系統(tǒng)。他遵循Mozilla Public License開源協(xié)議。
MQ全稱為Message Queue,消息隊列（MQ）是一種應(yīng)用程序?qū)?yīng)用程序的通信方法。應(yīng)用程序通過讀寫出入隊列的消息（針對應(yīng)用程序的數(shù)據(jù)）來通信，而無需專用連接來鏈接它們。消 息傳遞指的是程序之間通過在消息中發(fā)送數(shù)據(jù)進(jìn)行通信，而不是通過直接調(diào)用彼此來通信，直接調(diào)用通常是用于諸如遠(yuǎn)程過程調(diào)用的技術(shù)。排隊指的是應(yīng)用程序通過 隊列來通信。隊列的使用除去了接收和發(fā)送應(yīng)用程序同時執(zhí)行的要求。
二、安裝
pip install pika
三、簡單隊列
1、使用API操作RabbitMQ
基于Queue實現(xiàn)生產(chǎn)者消費(fèi)者模型
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import Queue
import threading
message = Queue.Queue(10)
def producer(i):
while True:
message.put(i)
def consumer(i):
while True:
msg = message.get()
for i in range(12):
t = threading.Thread(target=producer, args=(i,))
t.start()
for i in range(10):
t = threading.Thread(target=consumer, args=(i,))
t.start()
對于RabbitMQ來說，生產(chǎn)和消費(fèi)不再針對內(nèi)存里的一個Queue對象，而是某臺服務(wù)器上的RabbitMQ Server實現(xiàn)的消息隊列。
生產(chǎn)者
# ！/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BaseConnection(pika.ConnectionParameters(host='10.211.55.4')) # 封裝socket邏輯部分
channel = connection.channel() # 拿到操作句柄
channel.queue_declare(queue='hello') # 通過channel創(chuàng)建一個隊列，再給給隊列取名字
channel.basic_publish(exchange='', # 通過句柄給
routing_key='hello', # 把body的數(shù)據(jù)放到名為hello的隊列里去
body='Hello World!',
))
print("[x] Sent 'Hello World!")
connection.close()
消費(fèi)者
# ！/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BaseConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
channel.queue_declare(queue='hello') # 創(chuàng)建隊列
def callback(ch, method, properties, body): # 就是個回調(diào)函數(shù)
print(" [x] Received %r" % body)
channel.basic_consume(callback, # 函數(shù)名；取出數(shù)據(jù)就執(zhí)行這個函數(shù)
queue='hello', # 隊列名
no_ack=Ture) # 無應(yīng)答是（Ture）;有應(yīng)答（False）
print(' [*] Waiting for messages.To exit press CTRL+C')
channel.start_consuming()
2、acknowledgment 消息不丟失
no-ack ＝ False，如果消費(fèi)者遇到情況(its channel is closed, connection is closed, or TCP connection is lost)掛掉了，那么，RabbitMQ會重新將該任務(wù)添加到隊列中。
# ！/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BaseConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
channel.queue_declare(queue='hello') # 創(chuàng)建隊列
def callback(ch, method, properties, body): # 就是個回調(diào)函數(shù)
print(" [x] Received %r" % body)
import time
time.sleep(10)
print('ok')
ch.basic_ack(delivery_tag=method.delivery_tag) # 調(diào)為有應(yīng)答要加上的（下面的要改no_ack=False）
channel.basic_qos(prefetch_count=1)
channel.basic_consume(callback, # 函數(shù)名；取出數(shù)據(jù)就執(zhí)行這個函數(shù)
queue='hello', # 隊列名
no_ack=False) # 無應(yīng)答是（Ture）;有應(yīng)答（False）
print(' [*] Waiting for messages.To exit press CTRL+C')
channel.start_consuming()
消費(fèi)者
3、durable 消息不丟失
生產(chǎn)者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
channel.queue_declare(queue='hello', durable=True) # durable=True這個參數(shù)是把數(shù)據(jù)保存到硬盤
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # 傳遞模式從默認(rèn)的1，改為2
))
print(" [x] Sent 'Hello World!'")
connection.close()
消費(fèi)者
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
channel.queue_declare(queue='hello', durable=True)
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
import time
time.sleep(10)
print 'ok'
ch.basic_ack(delivery_tag = method.delivery_tag) # 把無應(yīng)答調(diào)整為有應(yīng)答
channel.basic_consume(callback,
queue='hello',
no_ack=False) # 改為False,表示有應(yīng)答
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
4、消息獲取順序
默認(rèn)消息隊列里的數(shù)據(jù)是按照順序被消費(fèi)者拿走，例如：消費(fèi)者1 去隊列中獲取 奇數(shù) 序列的任務(wù)，消費(fèi)者1去隊列中獲取 偶數(shù) 序列的任務(wù)。
channel.basic_qos(prefetch_count=1) 表示誰來誰取，不再按照奇偶數(shù)排列
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
import time
time.sleep(10)
print 'ok'
ch.basic_ack(delivery_tag = method.delivery_tag)
channel.basic_qos(prefetch_count=1) # prefetch_count=1這個參數(shù)就讓取的方式改變，不在順序取數(shù)據(jù)
channel.basic_consume(callback,
queue='hello',
no_ack=False)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()
消費(fèi)者
四、exchange
1、fanout模式
發(fā)布訂閱
發(fā)布訂閱和簡單的消息隊列區(qū)別在于，發(fā)布訂閱會將消息發(fā)送給所有的訂閱者，而消息隊列中的數(shù)據(jù)被消費(fèi)一次便消失。
所以，RabbitMQ實現(xiàn)發(fā)布和訂閱時，會為每一個訂閱者創(chuàng)建一個隊列，而發(fā)布者發(fā)布消息時，會將消息放置在所有相關(guān)隊列中。
exchange type = fanout
發(fā)布者
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
# 創(chuàng)建交換機(jī)
channel.exchange_declare(exchange='logs', # 名字
type='fanout') # 類型
message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs', # 往名字為logs的交換機(jī)里
routing_key='', # 把數(shù)據(jù)直接放到交換機(jī)里，不用放到隊列中，所以默認(rèn)為空
body=message)
print(" [x] Sent %r" % message)
connection.close() # 關(guān)閉
訂閱者
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
#創(chuàng)建交換機(jī)
channel.exchange_declare(exchange='logs',
type='fanout')
# 隨機(jī)創(chuàng)建一個隊列
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
channel.queue_bind(exchange='logs', # 隨機(jī)生成的隊列綁定交換機(jī)
queue=queue_name)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r" % body)
channel.basic_consume(callback, # 在下面阻塞后，如果得到數(shù)據(jù)后才執(zhí)行這個函數(shù)
queue=queue_name,
no_ack=True)
channel.start_consuming() # 阻塞住，等待生產(chǎn)者把數(shù)據(jù)放到消費(fèi)者，并監(jiān)聽
圖形解釋
2、dirct模式
關(guān)鍵字發(fā)送
RabbitMQ還支持根據(jù)關(guān)鍵字發(fā)送，即：隊列綁定關(guān)鍵字，發(fā)送者將數(shù)據(jù)根據(jù)關(guān)鍵字發(fā)送到消息exchange，
exchange根據(jù) 關(guān)鍵字 判定應(yīng)該將數(shù)據(jù)發(fā)送至指定隊列。
exchange type = direct
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',
type='direct')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
severities = sys.argv[1:]
if not severities:
sys.stderr.write("Usage: %s [error]
" % sys.argv[0])
sys.exit(1)
for severity in severities: # 用循環(huán)是可以綁定多個隊列
channel.queue_bind(exchange='direct_logs',
queue=queue_name,
routing_key='severity') # 定義的參數(shù)（關(guān)鍵字）
channel.queue_bind(exchange='direct_logs',
queue=queue_name,
routing_key='alex')
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback,
queue=queue_name,
no_ack=True)
channel.start_consuming()
消費(fèi)者
消費(fèi)者
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='direct_logs',
type='direct')
severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='direct_logs',
routing_key=severity,
body=message)
print(" [x] Sent %r:%r" % (severity, message))
connection.close()
生產(chǎn)者
圖解
在交換機(jī)中用一關(guān)鍵字，只有隊列里有關(guān)鍵字交換機(jī)才會發(fā)送數(shù)據(jù)給綁定的隊列
3、topic
模糊匹配
在topic類型下，可以讓隊列綁定幾個模糊的關(guān)鍵字，之后發(fā)送者將數(shù)據(jù)發(fā)送到exchange，exchange將傳入”路由值“和 ”關(guān)鍵字“進(jìn)行匹配，
匹配成功，則將數(shù)據(jù)發(fā)送到指定隊列。exchange type = topic
# 表示可以匹配 0 個 或 多個 單詞 * 表示只能匹配 一個 單詞 發(fā)送者路由值 隊列中 old.boy.python old.* -- 不匹配 old.boy.python old.# -- 匹配
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs',
type='topic')
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
binding_keys = sys.argv[1:]
if not binding_keys:
sys.stderr.write("Usage: %s [binding_key]...
" % sys.argv[0])
sys.exit(1)
for binding_key in binding_keys:
channel.queue_bind(exchange='topic_logs',
queue=queue_name,
routing_key=binding_key)
print(' [*] Waiting for logs. To exit press CTRL+C')
def callback(ch, method, properties, body):
print(" [x] %r:%r" % (method.routing_key, body))
channel.basic_consume(callback,
queue=queue_name,
no_ack=True)
channel.start_consuming()
消費(fèi)者
#!/usr/bin/env python
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='topic_logs',
type='topic')
routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'
message = ' '.join(sys.argv[2:]) or 'Hello World!'
channel.basic_publish(exchange='topic_logs',
routing_key=routing_key,
body=message)
print(" [x] Sent %r:%r" % (routing_key, message))
connection.close()
生產(chǎn)者
圖解
Memcache（緩存）
一、解析
Memcached 是一個高性能的分布式內(nèi)存對象緩存系統(tǒng)，用于動態(tài)Web應(yīng)用以減輕數(shù)據(jù)庫負(fù)載。
它通過在內(nèi)存中緩存數(shù)據(jù)和對象來減少讀取數(shù)據(jù)庫的次數(shù)，從而提高動態(tài)、數(shù)據(jù)庫驅(qū)動網(wǎng)站的速度
二、安裝
1、Memcached安裝和基本使用
Memcached安裝：
wget http://memcached.org/latest
tar -zxvf memcached-1.x.x.tar.gz
cd memcached-1.x.x
./configure && make && make test && sudo make install
PS：依賴libevent
yum install libevent-devel
apt-get install libevent-dev
啟動Memcached
memcached -d -m 10 -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid
參數(shù)說明:
-d 是啟動一個守護(hù)進(jìn)程
-m 是分配給Memcache使用的內(nèi)存數(shù)量，單位是MB
-u 是運(yùn)行Memcache的用戶
-l 是監(jiān)聽的服務(wù)器IP地址
-p 是設(shè)置Memcache監(jiān)聽的端口,最好是1024以上的端口
-c 選項是最大運(yùn)行的并發(fā)連接數(shù)，默認(rèn)是1024，按照你服務(wù)器的負(fù)載量來設(shè)定
-P 是設(shè)置保存Memcache的pid文件
Memcached命令
存儲命令: set/add/replace/append/prepend/cas 獲取命令: get/gets 其他命令: delete/stats..
2、Python操作Memcached
安裝API
python操作Memcached使用Python-memcached模塊 下載安裝：https://pypi.python.org/pypi/python-memcached
三、操作
1、模板
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
mc.set("dee", "bar") # 存儲命令
ret = mc.get_multi('dee') # 獲取命令
print(ret)
Ps：debug = True 表示運(yùn)行出現(xiàn)錯誤時，現(xiàn)實錯誤信息，上線后移除該參數(shù)。
2、天生支持集群
python-memcached模塊原生支持集群操作，其原理是在內(nèi)存維護(hù)一個主機(jī)列表，且集群中主機(jī)的權(quán)重值和主機(jī)在列表中重復(fù)出現(xiàn)的次數(shù)成正比
主機(jī) 權(quán)重
1.1.1.1 1
1.1.1.2 2
1.1.1.3 1
那么在內(nèi)存中主機(jī)列表為：
host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]
如果用戶根據(jù)如果要在內(nèi)存中創(chuàng)建一個鍵值對（如：k1 = "v1"），那么要執(zhí)行一下步驟：
根據(jù)算法將 k1 轉(zhuǎn)換成一個數(shù)字
將數(shù)字和主機(jī)列表長度求余數(shù)，得到一個值 N（ 0 <= N < 列表長度 ）
在主機(jī)列表中根據(jù) 第2步得到的值為索引獲取主機(jī)，例如：host_list[N]
連接 將第3步中獲取的主機(jī)，將 k1 = "v1" 放置在該服務(wù)器的內(nèi)存中
mc = memcache.Client([('1.1.1.1:12000', 1),
('1.1.1.2:12000', 2),
('1.1.1.3:12000', 1)], debug=True)
mc.set('k1', 'v1')
3、add
添加一條鍵值對，如果已經(jīng)存在的 key，重復(fù)執(zhí)行add操作異常
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.add("yui", "123") # 添加
ret = mc.get('yui') # 獲取
print(ret)
4、replace
replace 修改某個key的值，如果key不存在，則異常
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("asd", "678") # （設(shè)置）存儲
mc.replace("asd", "456") # 修改“qwe”這個key的值
# 如果memcache中存在asd，則替換成功，否則異常
ret = mc.get('asd') # 獲取
print(ret)
5、set 和 get
set 設(shè)置一個鍵值對，如果key不存在，則創(chuàng)建，如果key存在，則修改
get 獲取一個鍵值對
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("zxc", "888") # 設(shè)置（set設(shè)置單個）
ret = mc.get("zxc") # 獲取（get獲取單個）
print(ret)
6、 set_multi和 get_multi
set_multi 設(shè)置多個鍵值對，如果key不存在，則創(chuàng)建，如果key存在，則修改
get_multi 獲取多一個鍵值對
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set_multi({"zxc": "888", "fgh": "999", "jkl": "777"}) # 設(shè)置（set_multi設(shè)置多個）
ret = mc.get_multi(["zxc", "fgh", "jkl"]) # 獲取（get_multi獲取多個）
print(ret)
7、delete 和 delete_multi
delete 在Memcached中刪除指定的一個鍵值對
delete_multi 在Memcached中刪除指定的多個鍵值對
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("zxc", "666")
ret = mc.delete("zxc") # （delete）刪除指定的一個鍵值對
print(ret)
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set_multi({"zxc": "666", "zxl": "888", "fgh": "999", "jkl": "777"})
ret = mc.delete_multi(["zxc", "zxl", "fgh", "jkl"]) # （delete_multi）刪除多個鍵值對
print(ret)
8、append 和 prepend
append 修改指定key的值，在該值 后面 追加內(nèi)容
prepend 修改指定key的值，在該值 前面 插入內(nèi)容
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
mc.set('zxl', '2222')
# mc.append('zxl', 'after') # 在該值 后面 追加內(nèi)容
# # zxl = "2222after" # 結(jié)果
ret = mc.get('zxl') # 獲取
print(ret)
append
# import memcache
#
# mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.prepend('zxl', 'before') # 在該值 前面 插入內(nèi)容
# # # zxl = "before2222" # 結(jié)果
# ret = mc.get('zxl') # 獲取
# print(ret)
prepend
9、decr 和 incr
incr 自增，將Memcached中的某一個值增加 N （ N默認(rèn)為1 ）
decr 自減，將Memcached中的某一個值減少 N （ N默認(rèn)為1 ）
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
mc.set('sdf', '2222')
mc.incr('sdf') # 自增，默認(rèn)為1
ret = mc.get('sdf') # 獲取
# # 2223 # 結(jié)果
print(ret)
mc.incr('sdf', 10) # 后面的參數(shù)是自增10
ret = mc.get('sdf') # 獲取
# # 2232 # 結(jié)果
print(ret)
incr
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set('zsd', '2222')
# mc.decr('zsd') # 自減（默認(rèn)為1）
# ret = mc.get('zsd') # 獲取
# # # 2221 # 結(jié)果
# print(ret)
mc.decr('zsd', 10) # 自減（參數(shù)表示自減10）
ret = mc.get('zsd') # 獲取
# # 2212 # 結(jié)果
print(ret)
decr
10、gets 和cas
避免出現(xiàn)臟數(shù)據(jù)，比如京東購買商品，客戶A買一件商品；客戶B也買了件同樣的商品。
在客戶A買了件商品，在商品的總數(shù)量中減少一件；客戶B也買了件也只是在商品的總數(shù)量基礎(chǔ)上減少一件，
這樣就出現(xiàn)總商品只是減少一件，但事實上總商品減少兩件。
如果想避免出現(xiàn)此類情況，就使用gets和cas。
import memcache
mc = memcache.Client(['192.168.126.131:12000'], debug=True, cache_cas=True)
v = mc.gets('fgh')
# 如果有人在gets之后和cas之前修改了fgh，那么，下面的設(shè)置將會執(zhí)行失敗，出現(xiàn)異常，從而避免非正常數(shù)據(jù)的產(chǎn)生
mc.cas('fgh', "888")
print(v)
PS:本質(zhì)上每次執(zhí)行g(shù)ets時，會從memcache中獲取一個自增的數(shù)字，通過cas去修改gets的值時，會攜帶之前獲取的自增值
和memcache中的自增值進(jìn)行比較，如果相同，則可以提交；如果不相同，那表示在gets和cas執(zhí)行之間又有其他人執(zhí)行了
gets（獲取了緩沖的指定值），這樣有可能出現(xiàn)臟數(shù)據(jù)，則不允許修改。
Redis（緩存）
一、解析
redis是一個key-value存儲系統(tǒng)。和Memcached類似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數(shù)據(jù)類型都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎(chǔ)上，redis支持各種不同方式的排序。與memcached一樣，為了保證效率，數(shù)據(jù)都是緩存在內(nèi)存中。區(qū)別的是redis會周期性的把更新的數(shù)據(jù)寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎(chǔ)上實現(xiàn)了master-slave(主從)同步。
二、安裝
1、Redis安裝和基本使用
wget http://download.redis.io/releases/redis-3.0.6.tar.gz tar xzf redis-3.0.6.tar.gz cd redis-3.0.6 make
2、啟動服務(wù)端
src/redis-server
3、啟動客戶端
src/redis-cli redis> set foo bar OK redis> get foo "bar"
4、Python操作Redis
sudo pip install redis or sudo easy_install redis or 源碼安裝 詳見：https://github.com/WoLpH/redis-py
三、API使用
1、操作模式
redis-py提供兩個類Redis和StrictRedis用于實現(xiàn)Redis的命令，StrictRedis用于實現(xiàn)大部分官方的命令，并使用官方的語法和命令，Redis是StrictRedis的子類，用于向后兼容舊版本的redis-py。
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
r.set('Bar', '8888') # 存儲
ret = r.get('Bar') # 獲取
print(ret)
2、連接池
redis-py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認(rèn)，每個Redis實例都會維護(hù)一個自己的連接池。可以直接建立一個連接池，然后作為參數(shù)Redis，這樣就可以實現(xiàn)多個Redis實例共享一個連接池。
import redis
pool = redis.ConnectionPool(host='192.168.126.131', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('Wer', '9999')
ret = r.get('Wer')
print(ret)
3、操作
String 操作
String操作，redis中的String在在內(nèi)存中按照一個name對應(yīng)一個value來存儲
set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中設(shè)置值，默認(rèn)，不存在則創(chuàng)建，存在則修改
參數(shù)：
ex，過期時間（秒）
px，過期時間（毫秒）
nx，如果設(shè)置為True，則只有name不存在時，當(dāng)前set操作才執(zhí)行
xx，如果設(shè)置為True，則只有name存在時，崗前set操作才執(zhí)行
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set(name, value, ex=None, px=None, nx=False, xx=False)
r.set('Bar', '8888', ex=5, px=None, nx=True, xx=False) # 存儲
ret = r.get('Bar') # 獲取
print(ret)
setnx(name, value)
設(shè)置值，只有name不存在時，執(zhí)行設(shè)置操作（添加）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
r.setnx('Bac', '999') # setnx在不存在key就是這里的'Bac'才會設(shè)置操作
ret = r.get('Bac') # 獲取
print(ret)
setex(name, value, time)
設(shè)置值：參數(shù)time，過期時間（數(shù)字秒 或 timedelta對象）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.setex('Bsc', '8888', 2) # setex在第三個參數(shù)（時間；時間的單位是秒）內(nèi)設(shè)置操作
ret = r.get('Bsc') # 獲取
print(ret)
psetex(name, time_ms, value)
設(shè)置值：參數(shù)time，過期時間（數(shù)字毫秒 或 timedelta對象）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
r.psetex('Bsv', '8888', 10) # psetex在第三個參數(shù)（時間；時間的單位是毫秒）內(nèi)設(shè)置操作
ret = r.get('Bsv') # 獲取
print(ret)
mset(*args, **kwargs) /mget(keys, *args) 批量設(shè)置、獲取
批量設(shè)置值
如：
mset(k1='v1', k2='v2')
或
mget({'k1': 'v1', 'k2': 'v2'})
批量獲取
如：
mget('ylr', 'wupeiqi')
或
r.mget(['ylr', 'wupeiqi'])
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.mset({'Bsz': '8888', 'Dzx': '7777'}) # 批量設(shè)置值
ret = r.mget(['Bsz', 'Dzx']) # 批量獲取值
print(ret)
getset(name, value)
設(shè)置新值并獲取原來的值
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
r.set('Bsn', '8888') # 設(shè)置值
ret = r.getset('Bsn', '6666') # 設(shè)置新值并獲取原來的值
print(ret)
getrange(key, start, end)
# 獲取子序列（根據(jù)字節(jié)獲取，非字符）
# 參數(shù)：
# name，Redis 的 name
# start，起始位置（字節(jié)）
# end，結(jié)束位置（字節(jié)）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Ban', '孔維奇') # 設(shè)置值
ret = r.getrange('Ban', '6', '9') # 獲取子序列（根據(jù)字節(jié)獲取，非字符）
# # b'xe5xa5x87' # 獲取的結(jié)果
print(ret)
setrange(name, offset, value)
# 修改字符串內(nèi)容，從指定字符串索引開始向后替換（新值太長時，則向后添加）
# 參數(shù)：
# offset，字符串的索引，字節(jié)（一個漢字三個字節(jié)）
# value，要設(shè)置的值
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.setrange('Bzn', '7', '孔維奇熱愛生活') # 修改字符串內(nèi)容，從指定字符串索引開始向后替換
ret = r.get('Bzn') # 獲取子序列（根據(jù)字節(jié)獲取，非字符）
print(ret)
setbit(name, offset, value)
# 對name對應(yīng)值的二進(jìn)制表示的位進(jìn)行操作
# 參數(shù)：
# name，redis的name
# offset，位的索引（將值變換成二進(jìn)制后再進(jìn)行索引）
# value，值只能是 1 或 0
# 注：如果在Redis中有一個對應(yīng)： n1 = "foo"，
那么字符串foo的二進(jìn)制表示為：01100110 01101111 01101111
所以，如果執(zhí)行 setbit('n1', 7, 1)，則就會將第7位設(shè)置為1，
那么最終二進(jìn)制則變成 01100111 01101111 01101111，即："goo"
# 擴(kuò)展，轉(zhuǎn)換二進(jìn)制表示：
# source = "武沛齊"
source = "foo"
for i in source:
num = ord(i)
print bin(num).replace('b','')
特別的，如果source是漢字 "武沛齊"怎么辦？
答：對于utf-8，每一個漢字占 3 個字節(jié)，那么 "武沛齊" 則有 9個字節(jié)
對于漢字，for循環(huán)時候會按照 字節(jié) 迭代，那么在迭代時，將每一個字節(jié)轉(zhuǎn)換 十進(jìn)制數(shù)，然后再將十進(jìn)制數(shù)轉(zhuǎn)換成二進(jìn)制
11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000
getbit(name, offset)
獲取name對應(yīng)的值的二進(jìn)制表示中的某位的值 （0或1）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.setrange('Bzn', '7', '孔維奇熱愛生活') # 修改字符串內(nèi)容，從指定字符串索引開始向后替換
ret = r.getbit('Bzn', '5') # 獲取name對應(yīng)的值的二進(jìn)制表示中的某位的值 （0或1）
print(ret)
# 執(zhí)行結(jié)果 0
bitcount(key, start=None, end=None)
# 獲取name對應(yīng)的值的二進(jìn)制表示中 1 的個數(shù)
# 參數(shù)：
# key，Redis的name
# start，位起始位置
# end，位結(jié)束位置
bitop(operation, dest, *keys)
# 獲取多個值，并將值做位運(yùn)算，將最后的結(jié)果保存至新的name對應(yīng)的值
# 參數(shù)：
# operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（異或）
# dest, 新的Redis的name
# *keys,要查找的Redis的name
# 如：
bitop("AND", 'new_name', 'n1', 'n2', 'n3')
# 獲取Redis中n1,n2,n3對應(yīng)的值，然后講所有的值做位運(yùn)算（求并集），然后將結(jié)果保存 new_name 對應(yīng)的值中
strlen(name)
返回name對應(yīng)值的字節(jié)長度（一個漢字3個字節(jié)）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Bcx', '孔維奇') # 設(shè)置值
ret = r.strlen('Bcx') # 返回name對應(yīng)值的字節(jié)長度
print(ret)
# 執(zhí)行結(jié)果 9
incr(self, name, amount=1) 自增（整數(shù)型）
# 自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。
# 參數(shù)：
# name,Redis的name
# amount,自增數(shù)（必須是整數(shù)）
# 注：同incrby
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Der', '555')
ret = r.incr('Der', 7) # incr自增（整數(shù)型）
print(ret)
# 執(zhí)行結(jié)果 562
incrbyfloat(self, name, amount=1.0) 自增數(shù)（浮點(diǎn)型）
# 自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。
# 參數(shù)：
# name,Redis的name
# amount,自增數(shù)（浮點(diǎn)型）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Dej', '555')
ret = r.incrbyfloat('Dej', 7.5) # incrbyfloat自增（浮點(diǎn)型）
print(ret)
# 執(zhí)行結(jié)果 562.5
decr(self, name, amount=1) 自減數(shù)（整數(shù)）
# 自減 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自減。
# 參數(shù)：
# name,Redis的name
# amount,自減數(shù)（整數(shù)）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Daj', '555')
ret = r.decr('Daj', 7) # decr自減
print(ret)
# 執(zhí)行結(jié)果 548
append(key, value)
# 在redis name對應(yīng)的值后面追加內(nèi)容
# 參數(shù)：
key, redis的name
value, 要追加的字符串
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Daj', '555')
r.append('Dah', '666')
res = r.get('Dah')
print(res)
# 執(zhí)行結(jié)果 b'555666'
Hash 操作
Hash操作，redis中Hash在內(nèi)存中的存儲格式如下圖
hset(name, key, value)/hget(name、key)
hset:name看做是一個鍵；'key, value'看做是name的值；'key, value'是一個鍵值對
hget:在name對應(yīng)的hash中獲取根據(jù)key獲取value
# name對應(yīng)的hash中設(shè)置一個鍵值對（不存在，則創(chuàng)建；否則，修改）
# 參數(shù)：
# name，redis的name
# key，name對應(yīng)的hash中的key
# value，name對應(yīng)的hash中的value
# 注：
# hsetnx(name, key, value),當(dāng)name對應(yīng)的hash中不存在當(dāng)前key時則創(chuàng)建（相當(dāng)于添加）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
r.hset('Dav', 'srf', '555') # 設(shè)置
# ret = r.hget('Dav', 'srf') # 獲得Dav這個鍵對應(yīng)值里的鍵'srf'的值
# print(ret)
hmset(name, mapping)/hmget(name, keys, *args)
hmset：在name對應(yīng)的hash中批量設(shè)置鍵值對
hmget：在name對應(yīng)的hash中獲取多個key的值
hmset
# 參數(shù)： # name，redis的name # mapping，字典，如：{'k1':'v1', 'k2': 'v2'} # 如： # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
hmget
# 參數(shù)： # name，reids對應(yīng)的name # keys，要獲取key集合，如：['k1', 'k2', 'k3'] # *args，要獲取的key，如：k1,k2,k3 # 如： # r.mget('xx', ['k1', 'k2']) # 或 # print r.hmget('xx', 'k1', 'k2')
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'}) # # 在name對應(yīng)的hash中批量設(shè)置鍵值對
ret = r.hmget('Fbn', ['frt', 'yui']) # 在name對應(yīng)的hash中獲取多個key的值
print(ret)
hgetall(name)
獲取name對應(yīng)hash的所有鍵值
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hgetall('Fbn') # 獲取'Fbn'對應(yīng)hash的所有鍵值
print(ret)
hlen(name)
獲取name對應(yīng)的hash中鍵值對的個數(shù)
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hlen('Fbn') # 獲取'Fbn'對應(yīng)的hash中鍵值對的個數(shù)
print(ret)
hkeys(name)
獲取name對應(yīng)的hash中所有的key的值
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hkeys('Fbn') # 獲取'Fbn'對應(yīng)的hash中所有的key的值
print(ret)
hvals(name)
獲取name對應(yīng)的hash中所有的value的值
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hvals('Fbn') # 獲取'Fbn'對應(yīng)的hash中所有的value的值
print(ret)
# 結(jié)果 [b'8888', b'6666', b'5555']
hexists(name, key)
檢查name對應(yīng)的hash是否存在當(dāng)前傳入的key
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hexists('Fbn', 'yui') # 獲取'Fbn'對應(yīng)的hash中所有的value的值
print(ret)
# True 返回的結(jié)果
hdel(name,*keys)
將name對應(yīng)的hash中指定key的鍵值對刪除
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hdel('Fbn', 'yui') # 將'Fbn'對應(yīng)的hash中指定key的鍵值對刪除
print(ret)
# 1 執(zhí)行的結(jié)果（表示刪除，如果沒有執(zhí)行結(jié)果是0）
hincrby(name, key, amount=1)
自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
# 參數(shù)：
# name，redis中的name
# key， hash對應(yīng)的key
# amount，自增數(shù)（整數(shù)）
import redis
r = redis.Redis(host='192.168.126.131', port=6379)
# r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
ret = r.hincrby('Fbn', 'yui', amount=1) # 自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
print(ret)
# 執(zhí)行結(jié)果 5556
hincrbyfloat(name, key, amount=1.0)
自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
# 參數(shù)：
# name，redis中的name
# key， hash對應(yīng)的key
# amount，自增數(shù)（浮點(diǎn)數(shù)）
# 自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
# import redis
#
# r = redis.Redis(host='192.168.126.131', port=6379)
# # r.hmset('Fbn', {'frt':'6666', 'yui':'5555', 'kiu':'8888'})
# ret = r.hincrbyfloat('Fbn', 'yui', amount=7.7) # 自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount；自增數(shù)（浮點(diǎn)數(shù)）
# print(ret)
# # 執(zhí)行結(jié)果5562.7
hscan(name, cursor=0, match=None, count=None)
# 增量式迭代獲取，對于數(shù)據(jù)大的數(shù)據(jù)非常有用，hscan可以實現(xiàn)分片的獲取數(shù)據(jù)，并非一次性將數(shù)據(jù)全部獲取完，從而放置內(nèi)存被撐爆
# 參數(shù)：
# name，redis的name
# cursor，游標(biāo)（基于游標(biāo)分批取獲取數(shù)據(jù)）
# match，匹配指定key，默認(rèn)None 表示所有的key
# count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)
# 如：
# 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值為0時，表示數(shù)據(jù)已經(jīng)通過分片獲取完畢
hscan_iter(name, match=None, count=None)
# 利用yield封裝hscan創(chuàng)建生成器，實現(xiàn)分批去redis中獲取數(shù)據(jù)
# 參數(shù)：
# match，匹配指定key，默認(rèn)None 表示所有的key
# count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)
# 如：
# for item in r.hscan_iter('xx'):
# print item
List 操作
List操作，redis中的List在在內(nèi)存中按照一個name對應(yīng)一個List來存儲
lpush(name,values)
# 在name對應(yīng)的list中添加元素，每個新的元素都添加到列表的最左邊
# 如：
# r.lpush('oo', 11,22,33)
# 保存順序為: 33,22,11
# 擴(kuò)展：
# rpush(name, values) 表示從右向左操作
lpushx(name,value)
# 在name對應(yīng)的list中添加元素，只有name已經(jīng)存在時，值添加到列表的最左邊
# 更多：
# rpushx(name, value) 表示從右向左操作
llen(name)
# name對應(yīng)的list元素的個數(shù)
linsert(name, where, refvalue, value))
# 在name對應(yīng)的列表的某一個值前或后插入一個新值
# 參數(shù)：
# name，redis的name
# where，BEFORE或AFTER
# refvalue，標(biāo)桿值，即：在它前后插入數(shù)據(jù)
# value，要插入的數(shù)據(jù)
lset(name, index, value)
# 對name對應(yīng)的list中的某一個索引位置重新賦值
# 參數(shù)：
# name，redis的name
# index，list的索引位置
# value，要設(shè)置的值
lrem(name, value, num)
# 在name對應(yīng)的list中刪除指定的值
# 參數(shù)：
# name，redis的name
# value，要刪除的值
# num， num=0，刪除列表中所有的指定值；
# num=2,從前到后，刪除2個；
# num=-2,從后向前，刪除2個
lpop(name)
# 在name對應(yīng)的列表的左側(cè)獲取第一個元素并在列表中移除，返回值則是第一個元素
# 更多：
# rpop(name) 表示從右向左操作
lindex(name, index)
在name對應(yīng)的列表中根據(jù)索引獲取列表元素
lrange(name, start, end)
# 在name對應(yīng)的列表分片獲取數(shù)據(jù)
# 參數(shù)：
# name，redis的name
# start，索引的起始位置
# end，索引結(jié)束位置
ltrim(name, start, end)
# 在name對應(yīng)的列表中移除沒有在start-end索引之間的值
# 參數(shù)：
# name，redis的name
# start，索引的起始位置
# end，索引結(jié)束位置
rpoplpush(src, dst)
# 從一個列表取出最右邊的元素，同時將其添加至另一個列表的最左邊
# 參數(shù)：
# src，要取數(shù)據(jù)的列表的name
# dst，要添加數(shù)據(jù)的列表的name
blpop(keys, timeout)
# 將多個列表排列，按照從左到右去pop對應(yīng)列表的元素
# 參數(shù)：
# keys，redis的name的集合
# timeout，超時時間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時間（秒）, 0 表示永遠(yuǎn)阻塞
# 更多：
# r.brpop(keys, timeout)，從右向左獲取數(shù)據(jù)
brpoplpush(src, dst, timeout=0)
# 從一個列表的右側(cè)移除一個元素并將其添加到另一個列表的左側(cè)
# 參數(shù)：
# src，取出并要移除元素的列表對應(yīng)的name
# dst，要插入元素的列表對應(yīng)的name
# timeout，當(dāng)src對應(yīng)的列表中沒有數(shù)據(jù)時，阻塞等待其有數(shù)據(jù)的超時時間（秒），0 表示永遠(yuǎn)阻塞
自定義增量迭代
# 由于redis類庫中沒有提供對列表元素的增量迭代，如果想要循環(huán)name對應(yīng)的列表的所有元素，那么就需要：
# 1、獲取name對應(yīng)的所有列表
# 2、循環(huán)列表
# 但是，如果列表非常大，那么就有可能在第一步時就將程序的內(nèi)容撐爆，所有有必要自定義一個增量迭代的功能：
def list_iter(name):
"""
自定義redis列表增量迭代
:param name: redis中的name，即：迭代name對應(yīng)的列表
: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操作，Set集合就是不允許重復(fù)的列表
sadd(name,values)
name對應(yīng)的集合中添加元素
scard(name)
獲取name對應(yīng)的集合中元素個數(shù)
sdiff(keys, *args)
在第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合的元素集合
sdiffstore(dest, keys, *args)
獲取第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合，再將其新加入到dest對應(yīng)的集合中
sinter(keys, *args)
獲取多一個name對應(yīng)集合的并集
sinterstore(dest, keys, *args)
獲取多一個name對應(yīng)集合的并集，再講其加入到dest對應(yīng)的集合中
sismember(name, value)
檢查value是否是name對應(yīng)的集合的成員
smembers(name)
獲取name對應(yīng)的集合的所有成員
smove(src, dst, value)
將某個成員從一個集合中移動到另外一個集合
spop(name)
從集合的右側(cè)（尾部）移除一個成員，并將其返回
srandmember(name, numbers)
從name對應(yīng)的集合中隨機(jī)獲取 numbers 個元素
srem(name, values)
在name對應(yīng)的集合中刪除某些值
sunion(keys, *args)
獲取多一個name對應(yīng)的集合的并集
sunionstore(dest,keys, *args)
獲取多一個name對應(yīng)的集合的并集，并將結(jié)果保存到dest對應(yīng)的集合中
sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)
同字符串的操作，用于增量迭代分批獲取元素，避免內(nèi)存消耗太大
Sort Set 操作
有序集合，在集合的基礎(chǔ)上，為每元素排序；元素的排序需要根據(jù)另外一個值來進(jìn)行比較，所以，對于有序集合，每一個元素有兩個值，即：值和分?jǐn)?shù)，分?jǐn)?shù)專門用來做排序。
zadd(name, *args, **kwargs)
# 在name對應(yīng)的有序集合中添加元素
# 如：
# zadd('zz', 'n1', 1, 'n2', 2)
# 或
# zadd('zz', n1=11, n2=22）
zcard(name)
獲取name對應(yīng)的有序集合元素的數(shù)量
zcount(name, min, max)
獲取name對應(yīng)的有序集合中分?jǐn)?shù) 在 [min,max] 之間的個數(shù)
zincrby(name, value, amount)
自增name對應(yīng)的有序集合的 name 對應(yīng)的分?jǐn)?shù)
zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
# 按照索引范圍獲取name對應(yīng)的有序集合的元素
# 參數(shù)：
# name，redis的name
# start，有序集合索引起始位置（非分?jǐn)?shù)）
# end，有序集合索引結(jié)束位置（非分?jǐn)?shù)）
# desc，排序規(guī)則，默認(rèn)按照分?jǐn)?shù)從小到大排序
# withscores，是否獲取元素的分?jǐn)?shù)，默認(rèn)只獲取元素的值
# score_cast_func，對分?jǐn)?shù)進(jìn)行數(shù)據(jù)轉(zhuǎn)換的函數(shù)
# 更多：
# 從大到小排序
# zrevrange(name, start, end, withscores=False, score_cast_func=float)
# 按照分?jǐn)?shù)范圍獲取name對應(yīng)的有序集合的元素
# 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對應(yīng)的有序集合中的排行（從 0 開始）
# 更多：
# zrevrank(name, value)，從大到小排序
zrangebylex(name, min, max, start=None, num=None)
# 當(dāng)有序集合的所有成員都具有相同的分值時，有序集合的元素會根據(jù)成員的 值 （lexicographical ordering）來進(jìn)行排序，
而這個命令則可以返回給定的有序集合鍵 key 中， 元素的值介于 min 和 max 之間的成員 # 對集合中的每個成員進(jìn)行逐個字節(jié)的對比（byte-by-byte compare）， 并按照從低到高的順序， 返回排序后的集合成員。
如果兩個字符串有一部分內(nèi)容是相同的話， 那么命令會認(rèn)為較長的字符串比較短的字符串要大 # 參數(shù)： # name，redis的name # min，左區(qū)間（值）。 + 表示正無限； - 表示負(fù)無限； ( 表示開區(qū)間； [ 則表示閉區(qū)間 # min，右區(qū)間（值） # start，對結(jié)果進(jìn)行分片處理，索引位置 # num，對結(jié)果進(jìn)行分片處理，索引后面的num個元素 # 如： # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga # r.zrangebylex('myzset', "-", "[ca") 結(jié)果為：['aa', 'ba', 'ca'] # 更多： # 從大到小排序 # zrevrangebylex(name, max, min, start=None, num=None)
zrem(name, values)
# 刪除name對應(yīng)的有序集合中值是values的成員
# 如：zrem('zz', ['s1', 's2'])
zremrangebyrank(name, min, max)
根據(jù)排行范圍刪除
zremrangebyscore(name, min, max)
根據(jù)分?jǐn)?shù)范圍刪除
zremrangebylex(name, min, max)
根據(jù)值返回刪除
zscore(name, value)
獲取name對應(yīng)有序集合中 value 對應(yīng)的分?jǐn)?shù)
zinterstore(dest, keys, aggregate=None)
獲取兩個有序集合的交集，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作 aggregate的值為: SUM MIN MAX
zunionstore(dest, keys, aggregate=None)
# 獲取兩個有序集合的并集，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作 # aggregate的值為: SUM MIN MAX
zscan(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，用來對分?jǐn)?shù)進(jìn)行操作
其他常用操作
delete(*names)
根據(jù)刪除redis中的任意數(shù)據(jù)類型
exists(name)
檢測redis的name是否存在
keys(pattern='*')
# 根據(jù)模型獲取redis的name
# 更多：
# KEYS * 匹配數(shù)據(jù)庫中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
expire(name ,time)
# 為某個redis的某個name設(shè)置超時時間
rename(src, dst)
對redis的name重命名為
move(name, db))
將redis的某個值移動到指定的db下
randomkey()
隨機(jī)獲取一個redis的name（不刪除）
type(name)
獲取name對應(yīng)值的類型
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
同字符串操作，用于增量迭代獲取key
4、管道
redis-py默認(rèn)在執(zhí)行每次請求都會創(chuàng)建（連接池申請連接）和斷開（歸還連接池）一次連接操作，
如果想要在一次請求中指定多個命令，則可以使用pipline實現(xiàn)一次請求指定多個命令，并且默認(rèn)情況下
一次pipline是原子性操作。
import redis
pool = redis.ConnectionPool(host='192.168.126.131', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=True)
# r.set('name', 'alex')
# r.set('svon', 'evn')
# pipe.execute()
print(r.get('name'))
print(r.get('svon'))
5、發(fā)布訂閱
發(fā)布者：服務(wù)器
訂閱者：Dashboad和數(shù)據(jù)處理
import redis
r = redis.Redis(host='192.168.126.131')
r.publish('fm9999', 'sb')
發(fā)布者
import redis
r = redis.Redis(host='192.168.126.131')
pub = r.pubsub()
pub.subscribe('fm9999')
while True:
msg = pub.parse_response()
print(msg)
訂閱者
更多參見：https://github.com/andymccurdy/redis-py/
http://doc.redisfans.com/
更多詳見：http://www.cnblogs.com/wupeiqi/articles/5132791.html
http://www.rabbitmq.com/getstarted.html
http://www.cnblogs.com/yuanchenqi/articles/5755198.html
總結(jié)
以上是生活随笔為你收集整理的RabbitMQ、Memcache、Redis(队列、缓存)的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Android Studio 突然出现很
- 下一篇： VS引用文件出现黄色感叹号丢失文件，应该