當(dāng)前位置：首頁(yè) > 编程资源 > 综合教程 >内容正文

综合教程

RabbitMQ、Memcache、Redis(队列、缓存)

發(fā)布時(shí)間：2023/12/13 综合教程 38 生活家

生活随笔收集整理的這篇文章主要介紹了 RabbitMQ、Memcache、Redis(队列、缓存) 小編覺(jué)得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.

RabbitMQ

一、解釋

RabbitMQ是一個(gè)在AMQP基礎(chǔ)上完整的，可復(fù)用的企業(yè)消息系統(tǒng)。他遵循Mozilla Public License開(kāi)源協(xié)議。

MQ全稱為Message Queue,消息隊(duì)列（MQ）是一種應(yīng)用程序?qū)?yīng)用程序的通信方法。應(yīng)用程序通過(guò)讀寫出入隊(duì)列的消息（針對(duì)應(yīng)用程序的數(shù)據(jù)）來(lái)通信，而無(wú)需專用連接來(lái)鏈接它們。消息傳遞指的是程序之間通過(guò)在消息中發(fā)送數(shù)據(jù)進(jìn)行通信，而不是通過(guò)直接調(diào)用彼此來(lái)通信，直接調(diào)用通常是用于諸如遠(yuǎn)程過(guò)程調(diào)用的技術(shù)。排隊(duì)指的是應(yīng)用程序通過(guò) 隊(duì)列來(lái)通信。隊(duì)列的使用除去了接收和發(fā)送應(yīng)用程序同時(shí)執(zhí)行的要求。

二、安裝

pip install pika

三、簡(jiǎn)單隊(duì)列

　　1、使用API操作RabbitMQ　

基于Queue實(shí)現(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()

對(duì)于RabbitMQ來(lái)說(shuō)，生產(chǎn)和消費(fèi)不再針對(duì)內(nèi)存里的一個(gè)Queue對(duì)象，而是某臺(tái)服務(wù)器上的RabbitMQ Server實(shí)現(xiàn)的消息隊(duì)列。

生產(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')  # 通過(guò)channel創(chuàng)建一個(gè)隊(duì)列，再給給隊(duì)列取名字

channel.basic_publish(exchange='',  # 通過(guò)句柄給
                      routing_key='hello',  # 把body的數(shù)據(jù)放到名為hello的隊(duì)列里去
                      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)建隊(duì)列

def callback(ch, method, properties, body):  # 就是個(gè)回調(diào)函數(shù)
    print(" [x] Received %r" % body)
   

channel.basic_consume(callback,  # 函數(shù)名；取出數(shù)據(jù)就執(zhí)行這個(gè)函數(shù)
                      queue='hello',  # 隊(duì)列名
                      no_ack=Ture)  # 無(wú)應(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會(huì)重新將該任務(wù)添加到隊(duì)列中。

# ！/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)建隊(duì)列

def callback(ch, method, properties, body):  # 就是個(gè)回調(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í)行這個(gè)函數(shù)
                      queue='hello',  # 隊(duì)列名
                      no_ack=False)  # 無(wú)應(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這個(gè)參數(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)  # 把無(wú)應(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)消息隊(duì)列里的數(shù)據(jù)是按照順序被消費(fèi)者拿走，例如：消費(fèi)者1 去隊(duì)列中獲取奇數(shù) 序列的任務(wù)，消費(fèi)者1去隊(duì)列中獲取偶數(shù) 序列的任務(wù)。

channel.basic_qos(prefetch_count=1) 表示誰(shuí)來(lái)誰(shuí)取，不再按照奇偶數(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這個(gè)參數(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ā)布訂閱和簡(jiǎn)單的消息隊(duì)列區(qū)別在于，發(fā)布訂閱會(huì)將消息發(fā)送給所有的訂閱者，而消息隊(duì)列中的數(shù)據(jù)被消費(fèi)一次便消失。

所以，RabbitMQ實(shí)現(xiàn)發(fā)布和訂閱時(shí)，會(huì)為每一個(gè)訂閱者創(chuàng)建一個(gè)隊(duì)列，而發(fā)布者發(fā)布消息時(shí)，會(huì)將消息放置在所有相關(guān)隊(duì)列中。

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ī)里，不用放到隊(duì)列中，所以默認(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)建一個(gè)隊(duì)列
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

channel.queue_bind(exchange='logs',  # 隨機(jī)生成的隊(duì)列綁定交換機(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í)行這個(gè)函數(shù)
                      queue=queue_name,
                      no_ack=True)

channel.start_consuming()  # 阻塞住，等待生產(chǎn)者把數(shù)據(jù)放到消費(fèi)者，并監(jiān)聽(tīng)

圖形解釋

　　2、dirct模式

關(guān)鍵字發(fā)送

RabbitMQ還支持根據(jù)關(guān)鍵字發(fā)送，即：隊(duì)列綁定關(guān)鍵字，發(fā)送者將數(shù)據(jù)根據(jù)關(guān)鍵字發(fā)送到消息exchange，

exchange根據(jù) 關(guān)鍵字判定應(yīng)該將數(shù)據(jù)發(fā)送至指定隊(duì)列。

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)是可以綁定多個(gè)隊(duì)列
    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)鍵字，只有隊(duì)列里有關(guān)鍵字交換機(jī)才會(huì)發(fā)送數(shù)據(jù)給綁定的隊(duì)列

　　3、topic

模糊匹配

在topic類型下，可以讓隊(duì)列綁定幾個(gè)模糊的關(guān)鍵字，之后發(fā)送者將數(shù)據(jù)發(fā)送到exchange，exchange將傳入”路由值“和 ”關(guān)鍵字“進(jìn)行匹配，

匹配成功，則將數(shù)據(jù)發(fā)送到指定隊(duì)列。exchange type = topic

# 表示可以匹配 0 個(gè) 或 多個(gè) 單詞
*  表示只能匹配 一個(gè) 單詞

發(fā)送者路由值              隊(duì)列中
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 是一個(gè)高性能的分布式內(nèi)存對(duì)象緩存系統(tǒng)，用于動(dòng)態(tài)Web應(yīng)用以減輕數(shù)據(jù)庫(kù)負(fù)載。

它通過(guò)在內(nèi)存中緩存數(shù)據(jù)和對(duì)象來(lái)減少讀取數(shù)據(jù)庫(kù)的次數(shù)，從而提高動(dòng)態(tài)、數(shù)據(jù)庫(kù)驅(qū)動(dòng)網(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

　　啟動(dòng)Memcached

memcached -d -m 10    -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid
 
參數(shù)說(shuō)明:
    -d 是啟動(dòng)一個(gè)守護(hù)進(jìn)程
    -m 是分配給Memcache使用的內(nèi)存數(shù)量，單位是MB
    -u 是運(yùn)行Memcache的用戶
    -l 是監(jiān)聽(tīng)的服務(wù)器IP地址
    -p 是設(shè)置Memcache監(jiān)聽(tīng)的端口,最好是1024以上的端口
    -c 選項(xiàng)是最大運(yùn)行的并發(fā)連接數(shù)，默認(rèn)是1024，按照你服務(wù)器的負(fù)載量來(lái)設(shè)定
    -P 是設(shè)置保存Memcache的pid文件

　　Memcached命令

存儲(chǔ)命令: 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")  # 存儲(chǔ)命令
ret = mc.get_multi('dee')  # 獲取命令
print(ret)

Ps：debug = True 表示運(yùn)行出現(xiàn)錯(cuò)誤時(shí)，現(xiàn)實(shí)錯(cuò)誤信息，上線后移除該參數(shù)。　

2、天生支持集群

python-memcached模塊原生支持集群操作，其原理是在內(nèi)存維護(hù)一個(gè)主機(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)建一個(gè)鍵值對(duì)（如：k1 = "v1"），那么要執(zhí)行一下步驟：

根據(jù)算法將 k1 轉(zhuǎn)換成一個(gè)數(shù)字
將數(shù)字和主機(jī)列表長(zhǎng)度求余數(shù)，得到一個(gè)值 N（ 0 <= N < 列表長(zhǎng)度）
在主機(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

添加一條鍵值對(duì)，如果已經(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 修改某個(gè)key的值，如果key不存在，則異常

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("asd", "678")  # （設(shè)置）存儲(chǔ)
mc.replace("asd", "456")  # 修改“qwe”這個(gè)key的值
# 如果memcache中存在asd，則替換成功，否則異常
ret = mc.get('asd')  # 獲取
print(ret)

5、set 和 get

set 設(shè)置一個(gè)鍵值對(duì)，如果key不存在，則創(chuàng)建，如果key存在，則修改

get 獲取一個(gè)鍵值對(duì)

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("zxc", "888")  # 設(shè)置（set設(shè)置單個(gè)）
ret = mc.get("zxc")  # 獲取（get獲取單個(gè)）
print(ret)

6、 set_multi和 get_multi

set_multi 設(shè)置多個(gè)鍵值對(duì)，如果key不存在，則創(chuàng)建，如果key存在，則修改
get_multi 獲取多一個(gè)鍵值對(duì)

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è)置多個(gè)）
ret = mc.get_multi(["zxc", "fgh", "jkl"])  # 獲取（get_multi獲取多個(gè)）
print(ret)

7、delete 和 delete_multi　　

delete 在Memcached中刪除指定的一個(gè)鍵值對(duì)
delete_multi 在Memcached中刪除指定的多個(gè)鍵值對(duì)

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set("zxc", "666")
ret = mc.delete("zxc")  # （delete）刪除指定的一個(gè)鍵值對(duì)
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）刪除多個(gè)鍵值對(duì)
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中的某一個(gè)值增加 N （ N默認(rèn)為1 ）
decr 自減，將Memcached中的某一個(gè)值減少 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ù)，比如京東購(gòu)買商品，客戶A買一件商品；客戶B也買了件同樣的商品。

在客戶A買了件商品，在商品的總數(shù)量中減少一件；客戶B也買了件也只是在商品的總數(shù)量基礎(chǔ)上減少一件，

這樣就出現(xiàn)總商品只是減少一件，但事實(shí)上總商品減少兩件。

如果想避免出現(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è)置將會(huì)執(zhí)行失敗，出現(xiàn)異常，從而避免非正常數(shù)據(jù)的產(chǎn)生
mc.cas('fgh', "888")
print(v)

PS:本質(zhì)上每次執(zhí)行g(shù)ets時(shí)，會(huì)從memcache中獲取一個(gè)自增的數(shù)字，通過(guò)cas去修改gets的值時(shí)，會(huì)攜帶之前獲取的自增值

和memcache中的自增值進(jìn)行比較，如果相同，則可以提交；如果不相同，那表示在gets和cas執(zhí)行之間又有其他人執(zhí)行了

gets（獲取了緩沖的指定值），這樣有可能出現(xiàn)臟數(shù)據(jù)，則不允許修改。

Redis（緩存）

一、解析

redis是一個(gè)key-value存儲(chǔ)系統(tǒng)。和Memcached類似，它支持存儲(chǔ)的value類型相對(duì)更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數(shù)據(jù)類型都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎(chǔ)上，redis支持各種不同方式的排序。與memcached一樣，為了保證效率，數(shù)據(jù)都是緩存在內(nèi)存中。區(qū)別的是redis會(huì)周期性的把更新的數(shù)據(jù)寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎(chǔ)上實(shí)現(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、啟動(dòng)服務(wù)端

src/redis-server

　　3、啟動(dòng)客戶端

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
源碼安裝
 
詳見(jiàn)：https://github.com/WoLpH/redis-py

三、API使用

　　1、操作模式

redis-py提供兩個(gè)類Redis和StrictRedis用于實(shí)現(xiàn)Redis的命令，StrictRedis用于實(shí)現(xiàn)大部分官方的命令，并使用官方的語(yǔ)法和命令，Redis是StrictRedis的子類，用于向后兼容舊版本的redis-py。

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.set('Bar', '8888')  # 存儲(chǔ)
ret = r.get('Bar')  # 獲取
print(ret)

　　2、連接池

redis-py使用connection pool來(lái)管理對(duì)一個(gè)redis server的所有連接，避免每次建立、釋放連接的開(kāi)銷。默認(rèn)，每個(gè)Redis實(shí)例都會(huì)維護(hù)一個(gè)自己的連接池。可以直接建立一個(gè)連接池，然后作為參數(shù)Redis，這樣就可以實(shí)現(xiàn)多個(gè)Redis實(shí)例共享一個(gè)連接池。

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)存中按照一個(gè)name對(duì)應(yīng)一個(gè)value來(lái)存儲(chǔ)

set(name, value, ex=None, px=None, nx=False, xx=False)

在Redis中設(shè)置值，默認(rèn)，不存在則創(chuàng)建，存在則修改

參數(shù)：
ex，過(guò)期時(shí)間（秒）
px，過(guò)期時(shí)間（毫秒）
nx，如果設(shè)置為True，則只有name不存在時(shí)，當(dāng)前set操作才執(zhí)行
xx，如果設(shè)置為True，則只有name存在時(shí)，崗前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)  # 存儲(chǔ)

ret = r.get('Bar')  # 獲取
print(ret)

setnx(name, value)

設(shè)置值，只有name不存在時(shí)，執(zhí)行設(shè)置操作（添加）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.setnx('Bac', '999')  # setnx在不存在key就是這里的'Bac'才會(huì)設(shè)置操作
ret = r.get('Bac')  # 獲取
print(ret)

setex(name, value, time)

設(shè)置值：參數(shù)time，過(guò)期時(shí)間（數(shù)字秒或 timedelta對(duì)象）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.setex('Bsc', '8888', 2)  # setex在第三個(gè)參數(shù)（時(shí)間；時(shí)間的單位是秒）內(nèi)設(shè)置操作
ret = r.get('Bsc')  # 獲取
print(ret)

psetex(name, time_ms, value)

設(shè)置值：參數(shù)time，過(guò)期時(shí)間（數(shù)字毫秒或 timedelta對(duì)象）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.psetex('Bsv', '8888', 10)  # psetex在第三個(gè)參數(shù)（時(shí)間；時(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è)置新值并獲取原來(lái)的值

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.set('Bsn', '8888')  # 設(shè)置值
ret = r.getset('Bsn', '6666')  # 設(shè)置新值并獲取原來(lái)的值
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)容，從指定字符串索引開(kāi)始向后替換（新值太長(zhǎng)時(shí)，則向后添加）
# 參數(shù)：
    # offset，字符串的索引，字節(jié)（一個(gè)漢字三個(gè)字節(jié)）
    # value，要設(shè)置的值

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.setrange('Bzn', '7', '孔維奇熱愛(ài)生活')  # 修改字符串內(nèi)容，從指定字符串索引開(kāi)始向后替換
ret = r.get('Bzn')  # 獲取子序列（根據(jù)字節(jié)獲取，非字符）
print(ret)

setbit(name, offset, value)

# 對(duì)name對(duì)應(yīng)值的二進(jìn)制表示的位進(jìn)行操作
 
# 參數(shù)：
    # name，redis的name
    # offset，位的索引（將值變換成二進(jìn)制后再進(jìn)行索引）
    # value，值只能是 1 或 0
 
# 注：如果在Redis中有一個(gè)對(duì)應(yīng)： n1 = "foo"，
        那么字符串foo的二進(jìn)制表示為：01100110 01101111 01101111
    所以，如果執(zhí)行 setbit('n1', 7, 1)，則就會(huì)將第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是漢字 "武沛齊"怎么辦？
    答：對(duì)于utf-8，每一個(gè)漢字占 3 個(gè)字節(jié)，那么 "武沛齊" 則有 9個(gè)字節(jié)
       對(duì)于漢字，for循環(huán)時(shí)候會(huì)按照 字節(jié) 迭代，那么在迭代時(shí)，將每一個(gè)字節(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對(duì)應(yīng)的值的二進(jìn)制表示中的某位的值（0或1）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.setrange('Bzn', '7', '孔維奇熱愛(ài)生活')  # 修改字符串內(nèi)容，從指定字符串索引開(kāi)始向后替換
ret = r.getbit('Bzn', '5')  # 獲取name對(duì)應(yīng)的值的二進(jìn)制表示中的某位的值 （0或1）
print(ret)
# 執(zhí)行結(jié)果 0

bitcount(key, start=None, end=None)　　

# 獲取name對(duì)應(yīng)的值的二進(jìn)制表示中 1 的個(gè)數(shù)
# 參數(shù)：
    # key，Redis的name
    # start，位起始位置
    # end，位結(jié)束位置

bitop(operation, dest, *keys)

# 獲取多個(gè)值，并將值做位運(yùn)算，將最后的結(jié)果保存至新的name對(duì)應(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對(duì)應(yīng)的值，然后講所有的值做位運(yùn)算（求并集），然后將結(jié)果保存 new_name 對(duì)應(yīng)的值中

strlen(name)　　

返回name對(duì)應(yīng)值的字節(jié)長(zhǎng)度（一個(gè)漢字3個(gè)字節(jié)）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Bcx', '孔維奇')  # 設(shè)置值
ret = r.strlen('Bcx')  # 返回name對(duì)應(yīng)值的字節(jié)長(zhǎng)度
print(ret)
# 執(zhí)行結(jié)果 9

incr(self, name, amount=1)　自增（整數(shù)型）

# 自增 name對(duì)應(yīng)的值，當(dāng)name不存在時(shí)，則創(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對(duì)應(yīng)的值，當(dāng)name不存在時(shí)，則創(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對(duì)應(yīng)的值，當(dāng)name不存在時(shí)，則創(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對(duì)應(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)存中的存儲(chǔ)格式如下圖

hset(name, key, value)/hget(name、key)

hset:name看做是一個(gè)鍵；'key, value'看做是name的值；'key, value'是一個(gè)鍵值對(duì)

hget:在name對(duì)應(yīng)的hash中獲取根據(jù)key獲取value

# name對(duì)應(yīng)的hash中設(shè)置一個(gè)鍵值對(duì)（不存在，則創(chuàng)建；否則，修改）
 
# 參數(shù)：
    # name，redis的name
    # key，name對(duì)應(yīng)的hash中的key
    # value，name對(duì)應(yīng)的hash中的value
 
# 注：
    # hsetnx(name, key, value),當(dāng)name對(duì)應(yīng)的hash中不存在當(dāng)前key時(shí)則創(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這個(gè)鍵對(duì)應(yīng)值里的鍵'srf'的值
# print(ret)

hmset(name, mapping)/hmget(name, keys, *args)

hmset：在name對(duì)應(yīng)的hash中批量設(shè)置鍵值對(duì)

hmget：在name對(duì)應(yīng)的hash中獲取多個(gè)key的值

hmset
# 參數(shù)：
    # name，redis的name
    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hmget
# 參數(shù)：
    # name，reids對(duì)應(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對(duì)應(yīng)的hash中批量設(shè)置鍵值對(duì)
ret = r.hmget('Fbn', ['frt', 'yui'])  # 在name對(duì)應(yīng)的hash中獲取多個(gè)key的值
print(ret)

hgetall(name)

獲取name對(duì)應(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'對(duì)應(yīng)hash的所有鍵值
print(ret)

hlen(name)

獲取name對(duì)應(yīng)的hash中鍵值對(duì)的個(gè)數(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'對(duì)應(yīng)的hash中鍵值對(duì)的個(gè)數(shù)
print(ret)

hkeys(name)

獲取name對(duì)應(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'對(duì)應(yīng)的hash中所有的key的值
print(ret)

hvals(name)

獲取name對(duì)應(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'對(duì)應(yīng)的hash中所有的value的值
print(ret)
# 結(jié)果 [b'8888', b'6666', b'5555']

hexists(name, key)

檢查name對(duì)應(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'對(duì)應(yīng)的hash中所有的value的值
print(ret)
# True 返回的結(jié)果

hdel(name,*keys)

將name對(duì)應(yīng)的hash中指定key的鍵值對(duì)刪除

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'對(duì)應(yīng)的hash中指定key的鍵值對(duì)刪除
print(ret)
# 1 執(zhí)行的結(jié)果（表示刪除，如果沒(méi)有執(zhí)行結(jié)果是0）

hincrby(name, key, amount=1)

自增name對(duì)應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount

# 參數(shù)：
    # name，redis中的name
    # key， hash對(duì)應(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對(duì)應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
print(ret)
# 執(zhí)行結(jié)果 5556

hincrbyfloat(name, key, amount=1.0)

自增name對(duì)應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount

# 參數(shù)：
    # name，redis中的name
    # key， hash對(duì)應(yīng)的key
    # amount，自增數(shù)（浮點(diǎn)數(shù)）
 
# 自增name對(duì)應(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對(duì)應(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)

# 增量式迭代獲取，對(duì)于數(shù)據(jù)大的數(shù)據(jù)非常有用，hscan可以實(shí)現(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，每次分片最少獲取個(gè)數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個(gè)數(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í)，表示數(shù)據(jù)已經(jīng)通過(guò)分片獲取完畢

hscan_iter(name, match=None, count=None)

# 利用yield封裝hscan創(chuàng)建生成器，實(shí)現(xiàn)分批去redis中獲取數(shù)據(jù)
 
# 參數(shù)：
    # match，匹配指定key，默認(rèn)None 表示所有的key
    # count，每次分片最少獲取個(gè)數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個(gè)數(shù)
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print item

　List 操作

List操作，redis中的List在在內(nèi)存中按照一個(gè)name對(duì)應(yīng)一個(gè)List來(lái)存儲(chǔ)

lpush(name,values)

# 在name對(duì)應(yīng)的list中添加元素，每個(gè)新的元素都添加到列表的最左邊
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存順序?yàn)? 33,22,11
 
# 擴(kuò)展：
    # rpush(name, values) 表示從右向左操作

lpushx(name,value)

# 在name對(duì)應(yīng)的list中添加元素，只有name已經(jīng)存在時(shí)，值添加到列表的最左邊
 
# 更多：
    # rpushx(name, value) 表示從右向左操作

llen(name)

# name對(duì)應(yīng)的list元素的個(gè)數(shù)

linsert(name, where, refvalue, value))

# 在name對(duì)應(yīng)的列表的某一個(gè)值前或后插入一個(gè)新值
 
# 參數(shù)：
    # name，redis的name
    # where，BEFORE或AFTER
    # refvalue，標(biāo)桿值，即：在它前后插入數(shù)據(jù)
    # value，要插入的數(shù)據(jù)

lset(name, index, value)

# 對(duì)name對(duì)應(yīng)的list中的某一個(gè)索引位置重新賦值
 
# 參數(shù)：
    # name，redis的name
    # index，list的索引位置
    # value，要設(shè)置的值

lrem(name, value, num)

# 在name對(duì)應(yīng)的list中刪除指定的值
 
# 參數(shù)：
    # name，redis的name
    # value，要?jiǎng)h除的值
    # num，  num=0，刪除列表中所有的指定值；
           # num=2,從前到后，刪除2個(gè)；
           # num=-2,從后向前，刪除2個(gè)

lpop(name)

# 在name對(duì)應(yīng)的列表的左側(cè)獲取第一個(gè)元素并在列表中移除，返回值則是第一個(gè)元素
 
# 更多：
    # rpop(name) 表示從右向左操作

lindex(name, index)

在name對(duì)應(yīng)的列表中根據(jù)索引獲取列表元素

lrange(name, start, end)

# 在name對(duì)應(yīng)的列表分片獲取數(shù)據(jù)
# 參數(shù)：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結(jié)束位置

ltrim(name, start, end)

# 在name對(duì)應(yīng)的列表中移除沒(méi)有在start-end索引之間的值
# 參數(shù)：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結(jié)束位置

rpoplpush(src, dst)

# 從一個(gè)列表取出最右邊的元素，同時(shí)將其添加至另一個(gè)列表的最左邊
# 參數(shù)：
    # src，要取數(shù)據(jù)的列表的name
    # dst，要添加數(shù)據(jù)的列表的name

blpop(keys, timeout)

# 將多個(gè)列表排列，按照從左到右去pop對(duì)應(yīng)列表的元素
 
# 參數(shù)：
    # keys，redis的name的集合
    # timeout，超時(shí)時(shí)間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時(shí)間（秒）, 0 表示永遠(yuǎn)阻塞
 
# 更多：
    # r.brpop(keys, timeout)，從右向左獲取數(shù)據(jù)

brpoplpush(src, dst, timeout=0)

# 從一個(gè)列表的右側(cè)移除一個(gè)元素并將其添加到另一個(gè)列表的左側(cè)
 
# 參數(shù)：
    # src，取出并要移除元素的列表對(duì)應(yīng)的name
    # dst，要插入元素的列表對(duì)應(yīng)的name
    # timeout，當(dāng)src對(duì)應(yīng)的列表中沒(méi)有數(shù)據(jù)時(shí)，阻塞等待其有數(shù)據(jù)的超時(shí)時(shí)間（秒），0 表示永遠(yuǎn)阻塞

自定義增量迭代

# 由于redis類庫(kù)中沒(méi)有提供對(duì)列表元素的增量迭代，如果想要循環(huán)name對(duì)應(yīng)的列表的所有元素，那么就需要：
    # 1、獲取name對(duì)應(yīng)的所有列表
    # 2、循環(huán)列表
# 但是，如果列表非常大，那么就有可能在第一步時(shí)就將程序的內(nèi)容撐爆，所有有必要自定義一個(gè)增量迭代的功能：
 
def list_iter(name):
    """
    自定義redis列表增量迭代
    :param name: redis中的name，即：迭代name對(duì)應(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對(duì)應(yīng)的集合中添加元素

scard(name)

獲取name對(duì)應(yīng)的集合中元素個(gè)數(shù)

sdiff(keys, *args)

在第一個(gè)name對(duì)應(yīng)的集合中且不在其他name對(duì)應(yīng)的集合的元素集合

sdiffstore(dest, keys, *args)

獲取第一個(gè)name對(duì)應(yīng)的集合中且不在其他name對(duì)應(yīng)的集合，再將其新加入到dest對(duì)應(yīng)的集合中

sinter(keys, *args)

獲取多一個(gè)name對(duì)應(yīng)集合的并集

sinterstore(dest, keys, *args)

獲取多一個(gè)name對(duì)應(yīng)集合的并集，再講其加入到dest對(duì)應(yīng)的集合中

sismember(name, value)

檢查value是否是name對(duì)應(yīng)的集合的成員

smembers(name)

獲取name對(duì)應(yīng)的集合的所有成員

smove(src, dst, value)

將某個(gè)成員從一個(gè)集合中移動(dòng)到另外一個(gè)集合

spop(name)

從集合的右側(cè)（尾部）移除一個(gè)成員，并將其返回

srandmember(name, numbers)

從name對(duì)應(yīng)的集合中隨機(jī)獲取 numbers 個(gè)元素

srem(name, values)　

在name對(duì)應(yīng)的集合中刪除某些值

sunion(keys, *args)

獲取多一個(gè)name對(duì)應(yīng)的集合的并集

sunionstore(dest,keys, *args)

獲取多一個(gè)name對(duì)應(yīng)的集合的并集，并將結(jié)果保存到dest對(duì)應(yīng)的集合中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

同字符串的操作，用于增量迭代分批獲取元素，避免內(nèi)存消耗太大

　　Sort Set 操作

有序集合，在集合的基礎(chǔ)上，為每元素排序；元素的排序需要根據(jù)另外一個(gè)值來(lái)進(jìn)行比較，所以，對(duì)于有序集合，每一個(gè)元素有兩個(gè)值，即：值和分?jǐn)?shù)，分?jǐn)?shù)專門用來(lái)做排序。

zadd(name, *args, **kwargs)

# 在name對(duì)應(yīng)的有序集合中添加元素
# 如：
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22）

zcard(name)

獲取name對(duì)應(yīng)的有序集合元素的數(shù)量

zcount(name, min, max)

獲取name對(duì)應(yīng)的有序集合中分?jǐn)?shù) 在 [min,max] 之間的個(gè)數(shù)

zincrby(name, value, amount)

自增name對(duì)應(yīng)的有序集合的 name 對(duì)應(yīng)的分?jǐn)?shù)

zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

# 按照索引范圍獲取name對(duì)應(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，對(duì)分?jǐn)?shù)進(jìn)行數(shù)據(jù)轉(zhuǎn)換的函數(shù)
 
# 更多：
    # 從大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分?jǐn)?shù)范圍獲取name對(duì)應(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)

# 獲取某個(gè)值在 name對(duì)應(yīng)的有序集合中的排行（從 0 開(kāi)始）
 
# 更多：
    # zrevrank(name, value)，從大到小排序

zrangebylex(name, min, max, start=None, num=None)

# 當(dāng)有序集合的所有成員都具有相同的分值時(shí)，有序集合的元素會(huì)根據(jù)成員的 值 （lexicographical ordering）來(lái)進(jìn)行排序，
而這個(gè)命令則可以返回給定的有序集合鍵 key 中， 元素的值介于 min 和 max 之間的成員
# 對(duì)集合中的每個(gè)成員進(jìn)行逐個(gè)字節(jié)的對(duì)比（byte-by-byte compare）， 并按照從低到高的順序， 返回排序后的集合成員。 
如果兩個(gè)字符串有一部分內(nèi)容是相同的話， 那么命令會(huì)認(rèn)為較長(zhǎng)的字符串比較短的字符串要大
 
# 參數(shù)：
    # name，redis的name
    # min，左區(qū)間（值）。 + 表示正無(wú)限； - 表示負(fù)無(wú)限； ( 表示開(kāi)區(qū)間； [ 則表示閉區(qū)間
    # min，右區(qū)間（值）
    # start，對(duì)結(jié)果進(jìn)行分片處理，索引位置
    # num，對(duì)結(jié)果進(jìn)行分片處理，索引后面的num個(gè)元素
 
# 如：
    # 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對(duì)應(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對(duì)應(yīng)有序集合中 value 對(duì)應(yīng)的分?jǐn)?shù)

zinterstore(dest, keys, aggregate=None)

獲取兩個(gè)有序集合的交集，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作
aggregate的值為:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None)

# 獲取兩個(gè)有序集合的并集，如果遇到相同值不同分?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，用來(lái)對(duì)分?jǐn)?shù)進(jìn)行操作

其他常用操作

delete(*names)

根據(jù)刪除redis中的任意數(shù)據(jù)類型

exists(name)

檢測(cè)redis的name是否存在

keys(pattern='*')

# 根據(jù)模型獲取redis的name
 
# 更多：
    # KEYS * 匹配數(shù)據(jù)庫(kù)中所有 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

expire(name ,time)

# 為某個(gè)redis的某個(gè)name設(shè)置超時(shí)時(shí)間

rename(src, dst)

對(duì)redis的name重命名為

move(name, db))

將redis的某個(gè)值移動(dòng)到指定的db下

randomkey()

隨機(jī)獲取一個(gè)redis的name（不刪除）

type(name)

獲取name對(duì)應(yīng)值的類型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

同字符串操作，用于增量迭代獲取key

　　4、管道

redis-py默認(rèn)在執(zhí)行每次請(qǐng)求都會(huì)創(chuàng)建（連接池申請(qǐng)連接）和斷開(kāi)（歸還連接池）一次連接操作，

如果想要在一次請(qǐng)求中指定多個(gè)命令，則可以使用pipline實(shí)現(xiàn)一次請(qǐng)求指定多個(gè)命令，并且默認(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)

訂閱者

更多參見(jiàn)：https://github.com/andymccurdy/redis-py/

http://doc.redisfans.com/

更多詳見(jiàn)：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(队列、缓存)的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。

上一篇： Android Studio 突然出现很
下一篇： VS引用文件出现黄色感叹号丢失文件，应该

日韩av黄I国产麻豆传媒I国产91av视频在线观看I日韩一区二区三区在线看I美女国产在线I麻豆视频国产在线观看I成人黄色短片

综合教程

RabbitMQ、Memcache、Redis(队列、缓存)

RabbitMQ

一、解釋

二、安裝

三、簡(jiǎn)單隊(duì)列

1、使用API操作RabbitMQ

生產(chǎn)者

消費(fèi)者

2、acknowledgment 消息不丟失

3、durable 消息不丟失

4、消息獲取順序

四、exchange

1、fanout模式

發(fā)布訂閱

2、dirct模式

關(guān)鍵字發(fā)送

圖解

3、topic

Memcache（緩存）

一、解析

二、安裝

三、操作

Redis（緩存）

一、解析

二、安裝

三、API使用

1、操作模式

2、連接池

3、操作

String 操作

Hash 操作

Set 操作

Sort Set 操作

4、管道

5、發(fā)布訂閱

總結(jié)

　　1、使用API操作RabbitMQ　

消費(fèi)者　　

　　2、acknowledgment 消息不丟失　　

　　3、durable 消息不丟失

　　4、消息獲取順序　

　　1、fanout模式

　　2、dirct模式

　　3、topic

　　1、操作模式

　　2、連接池

　　3、操作

　　String 操作

　　Hash 操作

　　Set 操作

　　Sort Set 操作

　　4、管道

　　5、發(fā)布訂閱