RabbitMQ、Memcache、Redis(隊列、緩存)

RabbitMQ

一、解釋

RabbitMQ是一個在AMQP基礎上完整的，可復用的企業消息系統。他遵循Mozilla Public License開源協議。

MQ全稱為Message Queue, 消息隊列（MQ）是一種應用程序對應用程序的通信方法。應用程序通過讀寫出入隊列的消息（針對應用程序的數據）來通信，而無需專用連接來鏈接它們。消 息傳遞指的是程序之間通過在消息中發送數據進行通信，而不是通過直接調用彼此來通信，直接調用通常是用於諸如遠程過程調用的技術。排隊指的是應用程序通過 隊列來通信。隊列的使用除去了接收和發送應用程序同時執行的要求。

二、安裝

pip install pika

三、簡單隊列

　　1、使用API操作RabbitMQ　

基於Queue實現生產者消費者模型

#!/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來說，生產和消費不再針對內存里的一個Queue對象，而是某台服務器上的RabbitMQ Server實現的消息隊列。

生產者

# ！/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創建一個隊列，再給給隊列取名字

channel.basic_publish(exchange='',  # 通過句柄給
                      routing_key='hello',  # 把body的數據放到名為hello的隊列里去
                      body='Hello World!',
                     
                      ))
print("[x] Sent 'Hello World!")
connection.close()

消費者　　

# ！/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')  # 創建隊列

def callback(ch, method, properties, body):  # 就是個回調函數
    print(" [x] Received %r" % body)
   

channel.basic_consume(callback,  # 函數名；取出數據就執行這個函數
                      queue='hello',  # 隊列名
                      no_ack=Ture)  # 無應答是（Ture）;有應答（False）

print(' [*] Waiting for messages.To exit press CTRL+C')
channel.start_consuming()

　　2、acknowledgment 消息不丟失　　

no-ack ＝ False，如果消費者遇到情況(its channel is closed, connection is closed, or TCP connection is lost)掛掉了，那么，RabbitMQ會重新將該任務添加到隊列中。

# ！/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')  # 創建隊列

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)  # 調為有應答要加上的（下面的要改no_ack=False）

channel.basic_qos(prefetch_count=1)

channel.basic_consume(callback,  # 函數名；取出數據就執行這個函數
                      queue='hello',  # 隊列名
                      no_ack=False)  # 無應答是（Ture）;有應答（False）
print(' [*] Waiting for messages.To exit press CTRL+C')
channel.start_consuming()

　　3、durable   消息不丟失

生產者

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這個參數是把數據保存到硬盤

channel.basic_publish(exchange='',
                      routing_key='hello',
                      body='Hello World!',
                      properties=pika.BasicProperties(
                          delivery_mode=2, # 傳遞模式從默認的1，改為2
                      ))
print(" [x] Sent 'Hello World!'")
connection.close()　

消費者

#!/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)  # 把無應答調整為有應答

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=False)  # 改為False,表示有應答

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

　　4、消息獲取順序　

默認消息隊列里的數據是按照順序被消費者拿走，例如：消費者1 去隊列中獲取 奇數 序列的任務，消費者1去隊列中獲取 偶數 序列的任務。

channel.basic_qos(prefetch_count=1) 表示誰來誰取，不再按照奇偶數排列

#!/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這個參數就讓取的方式改變，不在順序取數據

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

 

四、exchange

　　1、fanout模式

發布訂閱

發布訂閱和簡單的消息隊列區別在於，發布訂閱會將消息發送給所有的訂閱者，而消息隊列中的數據被消費一次便消失。

所以，RabbitMQ實現發布和訂閱時，會為每一個訂閱者創建一個隊列，而發布者發布消息時，會將消息放置在所有相關隊列中。

 exchange type = fanout

發布者

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

# 創建交換機
channel.exchange_declare(exchange='logs',  # 名字
                         type='fanout')  # 類型

message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs',  # 往名字為logs的交換機里
                      routing_key='',  # 把數據直接放到交換機里，不用放到隊列中，所以默認為空
                      body=message)
print(" [x] Sent %r" % message)
connection.close()  # 關閉

訂閱者

#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

#創建交換機
channel.exchange_declare(exchange='logs',
                         type='fanout')

# 隨機創建一個隊列
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

channel.queue_bind(exchange='logs',  # 隨機生成的隊列綁定交換機
                   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,  # 在下面阻塞后，如果得到數據后才執行這個函數
                      queue=queue_name,
                      no_ack=True)

channel.start_consuming()  # 阻塞住，等待生產者把數據放到消費者，並監聽

圖形解釋

　　

　　2、dirct模式

關鍵字發送

RabbitMQ還支持根據關鍵字發送，即：隊列綁定關鍵字，發送者將數據根據關鍵字發送到消息exchange，

exchange根據 關鍵字 判定應該將數據發送至指定隊列。

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 [info] [warning] [error]\n" % sys.argv[0])
    sys.exit(1)

for severity in severities:  # 用循環是可以綁定多個隊列
    channel.queue_bind(exchange='direct_logs',
                       queue=queue_name,
                       routing_key='severity')  # 定義的參數（關鍵字）
    
       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()

消費者

#!/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()

圖解

在交換機中用一關鍵字，只有隊列里有關鍵字交換機才會發送數據給綁定的隊列

　　3、topic

 模糊匹配

在topic類型下，可以讓隊列綁定幾個模糊的關鍵字，之后發送者將數據發送到exchange，exchange將傳入”路由值“和 ”關鍵字“進行匹配，

匹配成功，則將數據發送到指定隊列。exchange type = topic

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

發送者路由值              隊列中
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]...\n" % 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()

#!/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()

 

　圖解

 

Memcache（緩存）

一、解析

Memcached 是一個高性能的分布式內存對象緩存系統，用於動態Web應用以減輕數據庫負載。

它通過在內存中緩存數據和對象來減少讀取數據庫的次數，從而提高動態、數據庫驅動網站的速度

二、安裝

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
 
參數說明:
    -d 是啟動一個守護進程
    -m 是分配給Memcache使用的內存數量，單位是MB
    -u 是運行Memcache的用戶
    -l 是監聽的服務器IP地址
    -p 是設置Memcache監聽的端口,最好是1024以上的端口
    -c 選項是最大運行的並發連接數，默認是1024，按照你服務器的負載量來設定
    -P 是設置保存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 表示運行出現錯誤時，現實錯誤信息，上線后移除該參數。　

2、天生支持集群

python-memcached模塊原生支持集群操作，其原理是在內存維護一個主機列表，且集群中主機的權重值和主機在列表中重復出現的次數成正比

 主機    權重
    1.1.1.1   1
    1.1.1.2   2
    1.1.1.3   1
 
那么在內存中主機列表為：
    host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]

如果用戶根據如果要在內存中創建一個鍵值對（如：k1 = "v1"），那么要執行一下步驟：

• 根據算法將 k1 轉換成一個數字
• 將數字和主機列表長度求余數，得到一個值 N（ 0 <= N < 列表長度 ）
• 在主機列表中根據 第2步得到的值為索引獲取主機，例如：host_list[N]
• 連接 將第3步中獲取的主機，將 k1 = "v1" 放置在該服務器的內存中

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

添加一條鍵值對，如果已經存在的 key，重復執行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")  # （設置）存儲
mc.replace("asd", "456")  # 修改“qwe”這個key的值
# 如果memcache中存在asd，則替換成功，否則異常
ret = mc.get('asd')  # 獲取
print(ret)

5、set 和 get

set      設置一個鍵值對，如果key不存在，則創建，如果key存在，則修改

get     獲取一個鍵值對

import memcache

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

6、 set_multi和 get_multi

set_multi   設置多個鍵值對，如果key不存在，則創建，如果key存在，則修改
get_multi   獲取多一個鍵值對

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set_multi({"zxc": "888", "fgh": "999", "jkl": "777"})  # 設置（set_multi設置多個）
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的值，在該值 后面 追加內容
prepend   修改指定key的值，在該值 前面 插入內容

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
mc.set('zxl', '2222')
# mc.append('zxl', 'after')  # 在該值 后面 追加內容
# # zxl = "2222after"  # 結果
ret = mc.get('zxl')  # 獲取
print(ret)

 

# import memcache
#
# mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.prepend('zxl', 'before')  # 在該值 前面 插入內容
# # # zxl = "before2222"  # 結果
# ret = mc.get('zxl')  # 獲取
# print(ret)

 

9、decr 和 incr　

incr  自增，將Memcached中的某一個值增加 N （ N默認為1 ）
decr 自減，將Memcached中的某一個值減少 N （ N默認為1 ）

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
mc.set('sdf', '2222')
mc.incr('sdf')  # 自增，默認為1
ret = mc.get('sdf')  # 獲取
# # 2223  # 結果
print(ret)

mc.incr('sdf', 10)  # 后面的參數是自增10
ret = mc.get('sdf')  # 獲取
# # 2232  # 結果
print(ret)

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True)
# mc.set('zsd', '2222')
# mc.decr('zsd')  # 自減（默認為1）
# ret = mc.get('zsd')  # 獲取
# # # 2221  # 結果
# print(ret)

mc.decr('zsd', 10)  # 自減（參數表示自減10）
ret = mc.get('zsd')  # 獲取
# # 2212  # 結果
print(ret)

 10、gets 和 cas

 避免出現臟數據，比如京東購買商品，客戶A買一件商品；客戶B也買了件同樣的商品。

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

這樣就出現總商品只是減少一件，但事實上總商品減少兩件。

如果想避免出現此類情況，就使用gets和cas。

import memcache

mc = memcache.Client(['192.168.126.131:12000'], debug=True, cache_cas=True)
v = mc.gets('fgh')
# 如果有人在gets之后和cas之前修改了fgh，那么，下面的設置將會執行失敗，出現異常，從而避免非正常數據的產生
mc.cas('fgh', "888")
print(v)

PS:本質上每次執行gets時，會從memcache中獲取一個自增的數字，通過cas去修改gets的值時，會攜帶之前獲取的自增值

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

gets（獲取了緩沖的指定值），這樣有可能出現臟數據，則不允許修改。

 

Redis（緩存）

一、解析

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

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用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，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的所有連接，避免每次建立、釋放連接的開銷。默認，每個Redis實例都會維護一個自己的連接池。可以直接建立一個連接池，然后作為參數Redis，這樣就可以實現多個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在在內存中按照一個name對應一個value來存儲

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

在Redis中設置值，默認，不存在則創建，存在則修改

參數：

   ex，過期時間（秒）

   px，過期時間（毫秒）

   nx，如果設置為True，則只有name不存在時，當前set操作才執行

   xx，如果設置為True，則只有name存在時，崗前set操作才執行

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)

設置值，只有name不存在時，執行設置操作（添加）

import redis

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

setex(name, value, time)

設置值：參數time，過期時間（數字秒 或 timedelta對象）

import redis

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

psetex(name, time_ms, value)

設置值：參數time，過期時間（數字毫秒 或 timedelta對象）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.psetex('Bsv', '8888', 10)  # psetex在第三個參數（時間；時間的單位是毫秒）內設置操作
ret = r.get('Bsv')  # 獲取
print(ret)

mset(*args, **kwargs) /mget(keys, *args) 批量設置、獲取

批量設置值
如：
    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'})  # 批量設置值
ret = r.mget(['Bsz', 'Dzx'])  # 批量獲取值
print(ret)

getset(name, value)

設置新值並獲取原來的值

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.set('Bsn', '8888')  # 設置值
ret = r.getset('Bsn', '6666')  # 設置新值並獲取原來的值
print(ret)

getrange(key, start, end)　

# 獲取子序列（根據字節獲取，非字符）
# 參數：
    # name，Redis 的 name
    # start，起始位置（字節）
    # end，結束位置（字節）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Ban', '孔維奇')  # 設置值
ret = r.getrange('Ban', '6', '9')  # 獲取子序列（根據字節獲取，非字符）
# # b'\xe5\xa5\x87'  # 獲取的結果
print(ret)

setrange(name, offset, value)

# 修改字符串內容，從指定字符串索引開始向后替換（新值太長時，則向后添加）
# 參數：
    # offset，字符串的索引，字節（一個漢字三個字節）
    # value，要設置的值

import redis

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

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）

import redis

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

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個字節）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Bcx', '孔維奇')  # 設置值
ret = r.strlen('Bcx')  # 返回name對應值的字節長度
print(ret)
# 執行結果 9

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

# 自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。
 
# 參數：
    # name,Redis的name
    # amount,自增數（必須是整數）
 
# 注：同incrby

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Der', '555')
ret = r.incr('Der', 7)  # incr自增（整數型）
print(ret)
# 執行結果 562

incrbyfloat(self, name, amount=1.0)  自增數（浮點型）

# 自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。
 
# 參數：
    # name,Redis的name
    # amount,自增數（浮點型）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Dej', '555')
ret = r.incrbyfloat('Dej', 7.5)  # incrbyfloat自增（浮點型）
print(ret)
# 執行結果 562.5

decr(self, name, amount=1)  自減數（整數）

# 自減 name對應的值，當name不存在時，則創建name＝amount，否則，則自減。
 
# 參數：
    # name,Redis的name
    # amount,自減數（整數）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
# r.set('Daj', '555')
ret = r.decr('Daj', 7)  # decr自減
print(ret)
# 執行結果 548

append(key, value)　　

# 在redis name對應的值后面追加內容
 
# 參數：
    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)
# 執行結果 b'555666'

　　

　　Hash 操作

Hash操作，redis中Hash在內存中的存儲格式如下圖

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

hset:name看做是一個鍵；'key, value'看做是name的值；'key, value'是一個鍵值對

hget:在name對應的hash中獲取根據key獲取value

# name對應的hash中設置一個鍵值對（不存在，則創建；否則，修改）
 
# 參數：
    # name，redis的name
    # key，name對應的hash中的key
    # value，name對應的hash中的value
 
# 注：
    # hsetnx(name, key, value),當name對應的hash中不存在當前key時則創建（相當於添加）

import redis

r = redis.Redis(host='192.168.126.131', port=6379)
r.hset('Dav', 'srf', '555')  # 設置
# ret = r.hget('Dav', 'srf')  # 獲得Dav這個鍵對應值里的鍵'srf'的值
# print(ret)

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

hmset：在name對應的hash中批量設置鍵值對

hmget：在name對應的hash中獲取多個key的值

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

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

hgetall(name)

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

hlen(name)

獲取name對應的hash中鍵值對的個數

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'對應的hash中鍵值對的個數
print(ret)

hkeys(name)

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

hvals(name)

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

hexists(name, key)

檢查name對應的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.hexists('Fbn', 'yui')  # 獲取'Fbn'對應的hash中所有的value的值
print(ret)
# True 返回的結果

hdel(name,*keys)

將name對應的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'對應的hash中指定key的鍵值對刪除
print(ret)
# 1 執行的結果（表示刪除，如果沒有執行結果是0）

hincrby(name, key, amount=1)

自增name對應的hash中的指定key的值，不存在則創建key=amount

# 參數：
    # name，redis中的name
    # key， hash對應的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.hincrby('Fbn', 'yui', amount=1)  # 自增name對應的hash中的指定key的值，不存在則創建key=amount
print(ret)
# 執行結果 5556

hincrbyfloat(name, key, amount=1.0)

自增name對應的hash中的指定key的值，不存在則創建key=amount

# 參數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（浮點數）
 
# 自增name對應的hash中的指定key的值，不存在則創建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對應的hash中的指定key的值，不存在則創建key=amount；自增數（浮點數）
# print(ret)
# # 執行結果5562.7

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 操作

List操作，redis中的List在在內存中按照一個name對應一個List來存儲

 

lpush(name,values)

# 在name對應的list中添加元素，每個新的元素都添加到列表的最左邊
 
# 如：
    # r.lpush('oo', 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操作，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)

同字符串的操作，用於增量迭代分批獲取元素，避免內存消耗太大

 

　　Sort Set 操作

有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較，所以，對於有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。

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

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，用來對分數進行操作

其他常用操作

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

　　

 

　　4、管道

redis-py默認在執行每次請求都會創建（連接池申請連接）和斷開（歸還連接池）一次連接操作，

如果想要在一次請求中指定多個命令，則可以使用pipline實現一次請求指定多個命令，並且默認情況下

一次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、發布訂閱

 

 發布者：服務器

訂閱者：Dashboad和數據處理

import redis

r = redis.Redis(host='192.168.126.131')
r.publish('fm9999', 'sb')

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