Python操做Redis

時間 2019-11-24

標籤 python redis 欄目 Python 简体版

原文原文鏈接

一、操做模式git

redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。github

import redis

r = redis.Redis(host="192.168.0.106", port=6379)
r.set("name", "pd")
val = r.get("name")
print(val)  # b'pd'

二、鏈接池（推薦使用這種方式）

redis-py使用connection pool來管理對一個redis server的全部鏈接，避免每次創建、釋放鏈接的開銷。默認，每一個Redis實例都會維護一個本身的鏈接池。能夠直接創建一個鏈接池，而後做爲參數Redis，這樣就能夠實現多個Redis實例共享一個鏈接池。redis

import redis

pool = redis.ConnectionPool(host="192.168.0.106", port=6379, max_connections=1000)  # 這裏最多建立1000個鏈接
r = redis.Redis(connection_pool=pool)
r.set("foo", "Bar")

用一個py文件來保存建立鏈接池，其餘py文件須要使用就直接導入，至關於使用了單例模式數據庫

# redis_pool.py
import redis
pool = redis.ConnectionPool(host="192.168.0.106", port=6379, max_connections=1000)

# test.py
import redis
from redis_pool import pool

while True:
    key = input("請輸入key：")
    value = input("請輸入value：")
    # 去鏈接池中獲取鏈接
    r = redis.Redis(connection_pool=pool)
    # 設置值
    r.set(key, value)

三、操做

String（基礎）操做：redis中的String在內存中按照一個name對應一個value來存儲，以下圖：服務器

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

在Redis中設置值，默認，不存在則建立，存在則修改
參數：
     ex，過時時間（秒）
     px，過時時間（毫秒）
     nx，若是設置爲True，則只有name不存在時，當前set操做才執行
     xx，若是設置爲True，則只有name存在時，當前set操做才執行

setnx(name, value)dom

設置值，只有name不存在時，才執行設置操做
如：
    r.set("cc", "xx")
    r.setnx("cc", "ss")
    r.get("cc")  # b'xx'
對比：    
    r.set("cc", "xx")
    r.set("cc", "ss")
    r.get("cc")  # b'ss'

mset(name, mapping)socket

批量設置值
如：mset({"k1": "v1", "k2": "v2"})

msetnx(name, mapping)ide

批量設置值，只有name不存在時，才執行設置操做
示例：
    r.mset({"k1": "aa", "k2": "bb"})
    r.mset({"k1": "cc", "k2": "dd"})
    ret1 = r.mget("k1", "k2")  # [b'cc', b'dd']
    r.mset({"k1": "aa", "k2": "bb"})
    r.msetnx({"k1": "cc", "k2": "dd"})
    ret2 = r.mget("k1", "k2")  # [b'aa', b'bb']

setex(name, time, value)函數

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

psetex(name, time_ms, value)

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

get(name)

獲取某個值

mget(keys, *args)

批量獲取
如：
    mget("k1", "k2") 或 mget(["k1", "k2"])

getset(name, value)

設置新值並獲取原來的值
    r.set("vv", "xx")
    ret = r.getset("vv", "ss")
    print(ret)  # b'xx'

getrange(key, start, end)

獲取子序列（根據字節獲取，非字符）
參數：
    name，redis的name
    start，起始位置（字節）
    end，結束位置（字節）
如：
    r.set("k1", "你好嗎")
    ret = r.getrange("k1", 0, 2)
    print(ret)  # b'\xe4\xbd\xa0'
    print(ret.decode("utf8"))  # 你

strlen(name)

返回name對應值的字節長度（一個漢字3個字節）
示例：
    r.set("k1", "你好嗎")
    ret = r.strlen("k1")  # 9

setrange(name, offset, value)

r.set("k1", "12345")
r.setrange("k1", 2, "a")
b'12a45'
r.setrange("k1", 2, "ab")
b'12ab5'
r.setrange("k1", 2, "abde")
b'12abde'

incr(name, amount=1)

自增name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
參數：
    name,Redis的name
    amount,自增數（必須是整數）
示例：
    r.set("a", 20)
    r.incr("a", amount=2)
    r.get("a")  # 22

incrbyfloat(name, amount=1.0)

同上，amount,自增數（浮點型）

decr(name, amount=1)

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

append(key, value)

在redis的name對應的值後面追加內容
參數：
    key, redis的name
    value, 要追加的字符串
示例：
    r.set("a", 20)
    r.append("a", "00")
    r.get("a")  # 2200

substr(name, start, end=-1)

至關於切片操做
示例：
    r.set("k1", "ABCDEFG")
    ret1 = r.substr("k1", 0, 2)   # b'ABC'
    ret2 = r.substr("k1", 0, -1)  # b'ABCDEFG'

Hash 操做：redis中Hash在內存中的存儲格式，以下圖：

hset(name, key, value)

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

hget(name, key)

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

hmset(name, mapping)

在name對應的hash中批量設置鍵值對
參數：
    name，redis的name
    mapping，字典，如：{"k2": "v2", "k3": "v3"}
如：
    r.hmset("n2", {"k2": "v2", "k3": "v3"})

hmget(name, keys, *args)

在name對應的hash中獲取多個key的值
參數：
    name，reids對應的name
    keys，要獲取key集合，如：['k1', 'k2', 'k3']
    *args，要獲取的key，如：k1,k2,k3
如：r.hmget("n2", ["k2", "k3"]) 或 conn.hmget("n2", "k2", "k3")

hgetall(name)

獲取name對應hash的全部鍵值
r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hgetall("n2")  # {b'k3': b'v3', b'k2': b'v2'}

hlen(name)

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

hkeys(name)

r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hkeys("n2")  # [b'k3', b'k2']

hvals(name)

獲取name對應的hash中全部的value的值
r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hvals("n2")  # [b'v3', b'v2']

hexists(name, key)

查name對應的hash是否存在當前傳入的key

hdel(name, *keys)

將name對應的hash中指定key的鍵值對刪除

hincrby(name, key, amount=1)

自增name對應的hash中的指定key的值，不存在則建立key=amount
參數：
    name，redis中的name
    key， hash對應的key
    amount，自增數（整數）

hincrbyfloat(name, key, amount=1.0)

同上，amount，自增數（浮點數）

hscan(name, cursor=0, match=None, count=None)

增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片
的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆。
參數：
    name，redis的name
    cursor，遊標（基於遊標分批取獲取數據）
    match，匹配指定key，默認None 表示全部的key
    count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
 
如：
    第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    ...
    直到返回值cursor的值爲0時，表示數據已經經過分片獲取完畢

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

# 利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
# 參數：
    match，匹配指定key，默認None 表示全部的key
    count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
# 如：
    r.hmset("n1", {"k1": 1, "k2": 2, "k3": 3, "k4": 4})
    ret = r.hscan_iter("n1", match=None, count=None)  # ret爲生成器
    for item in ret:
        print(item)

List 操做：redis中的List在在內存中按照一個name對應一個List來存儲，以下圖：

lpush(name, *values)

如：
    r.lpush("s", 1,2,3)
    保存順序爲: 3,2,1
擴展：
    rpush(name, *values) 表示從右向左操做

lpushx(name, value)

在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊
擴展：
    rpushx(name, value) 表示從右向左操做
示例：
    r.rpush("n1", *[1, 2])
    r.lpushx("n1", 0)
    ret = r.lrange("n1", 0, 10)  # [b'0', b'1', b'2']

linsert(name, where, refvalue, value)

在name對應的列表的某一個值前或後插入一個新值
參數：
    name，redis的name
    where，before或after
    refvalue，標杆值，即：在它先後插入數據
    value，要插入的數據
示例：
    r.rpush("n1", *[1, 2, 3, 4])
    r.linsert("n1", "after", 2, "aa")
    # [b'1', b'2', b'aa', b'3', b'4']

lset(name, index, value)

對name對應的list中的某一個索引位置從新賦值
參數：
    name，redis的name
    index，list的索引位置
    value，要設置的值
示例：
    r.rpush("n1", *[1, 2, 3, 4, 5])
    r.lset("n1", 2, "aa")
    # [b'1', b'2', b'aa', b'4', b'5']

lpop(name)

在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素
更多：
    rpop(name)  表示從右向左操做
示例：
r.rpush("n1", *[1, 2, 3, 4])
ret1 = r.lpop("n1")  # b'1'
ret2 = r.rpop("n1")  # b'4'

blpop(keys, timeout)

將多個列表排列，按照從左到右去pop對應列表的元素
參數：
    keys，redis的name的集合
    timeout，超時時間，當元素全部列表的元素獲取完以後，
    阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞。
更多：
    r.brpop(keys, timeout)，從右向左獲取數據

rpoplpush(src, dst)

從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
參數：
    src，要取數據的列表的name
    dst，要添加數據的列表的name
示例：
    r.rpush("n1", 1, 2)
    r.rpush("n2", *["a", "b"])
    r.rpoplpush("n1", "n2")
    ret = r.lrange("n2", 0, 10)  # [b'2', b'a', b'b']

brpoplpush(src, dst, timeout=0)

從一個列表的右側移除一個元素並將其添加到另外一個列表的左側
參數：
    src，取出並要移除元素的列表對應的name
    dst，要插入元素的列表對應的name
    timeout，當src對應的列表中沒有數據時，阻塞等
    待其有數據的超時時間（秒），0 表示永遠阻塞。

lindex(name, index)

在name對應的列表中根據索引獲取列表元素
示例：
    r.rpush("n1", "a", "b", "c")
    ret = r.lindex("n1", 0)  # b'a'

llen(name)

name對應的list元素的個數
示例：
    r.rpush("n1", "a", "b", "c")
    ret = r.llen("n1")  # 3

lrange(name, start, end)

在name對應的列表分片獲取數據
參數：
    name，redis的name
    start，索引的起始位置
    end，索引結束位置

lrem(name, count, value)

在name對應的list中刪除指定的值
參數：
    name，redis的name
    count，count=0，刪除列表中全部的指定值；
           count=2, 從前到後，刪除2個；
           count=-2, 從後向前，刪除2個。
    value，要刪除的值
示例：
    r.rpush("n1", *[1,2,3,1,2,3])
    r.lrem("n1", 0, 3)  # [b'1', b'2', b'1', b'2']
    r.lrem("n1", 1, 3)  # [b'1', b'2', b'1', b'2', b'3']
    r.lrem("n1", 2, 3)  # [b'1', b'2', b'1', b'2']

ltrim(name, start, end)

在name對應的列表中移除沒有在 start~end 索引之間的值
參數：
    name，redis的name
    start，索引的起始位置
    end，索引結束位置
示例：
    r.rpush("n1", *[1,2,3,4,5,6,7,8])
    r.ltrim("n1", 2, 5)
    xx = r.lrange("n1",0, 7)  # [b'3', b'4', b'5', b'6']

自定義增量迭代

# 因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
    # 一、獲取name對應的全部列表
    # 二、循環列表
# 可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能：
import redis

r = redis.Redis(host="127.0.0.1", port=6379)
# 測試數據
r.rpush("xx", *[1,2,3,4,5,6,7,8,9,10])
# ====================================================
# 方式一：
def list_iter(name):
    """
    自定義redis列表增量迭代
    :param name: redis中的name，即：迭代name對應的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)
# 使用
for item in list_iter("xx"):
    print(item)
# ====================================================
# 方式二：
def list_iter(key, count=100):
    index = 0
    while True:
        data_list = r.lrange(key, index, index+count-1)
        if not data_list:
            return None
        index += count
        for item in data_list:
            yield item

# print(r.lrange("xx",0,1))
# print(r.lrange("xx",2,3))
# print(r.lrange("xx",4,5))

for item in list_iter("xx", count=5):
    print(item)

Set 操做：Set集合就是不容許重複的列表

sadd(name, *values)

name對應的集合中添加元素
r.sadd("jj", "v1", "v2", "v3")

scard(name)

獲取name對應的集合中元素個數
r.scard("jj")  # 3

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, count=None)

從集合的右側（尾部）移除一個成員，並將其返回

srandmember(name, number=None)

從name對應的集合中隨機獲取 numbers 個元素

srem(name, *values)

在name對應的集合中刪除某些值

sunion(keys, *args)

獲取多一個name對應的集合的並集

sunionstore(dest, keys, *args)

獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中

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

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

Sort Set 操做：有序集合，在集合的基礎上，爲每元素排序；元素的排序須要根據另一個值來進行比較，因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。

用來保存須要排序的數據，例如排行榜，成績，工資等。

zadd(name, mapping, nx=False, xx=False, ch=False, incr=False)

在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, amount, value)

自增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_iter(name, match=None, count=None,score_cast_func=float)

同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做

其餘經常使用操做

delete(*names)

根據刪除redis中的任意數據類型

exists(*names)

檢測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設置超時時間，單位爲秒，能夠用整數或timedelta對象表示。

rename(src, dst)

對redis的name重命名，將src改成dst

renamenx(src, dst)

對redis的name重命名，若是dst不存在，則將src改成dst

move(name, db)

將redis的某個值移動到指定的db下

randomkey()

隨機獲取一個redis的name（不刪除）

type(name)

獲取name對應值的類型

scan_iter(match=None, count=None)

同字符串操做，用於增量迭代獲取key

四、管道

redis-py默認在執行每次請求都會建立（鏈接池申請鏈接）和斷開（歸還鏈接池）一次鏈接操做，若是想要在一次請求中指定多個命令，則可使用 pipline 實現一次請求指定多個命令，而且默認狀況下一次 pipline 是原子性操做。

import redis

r = redis.Redis(host="127.0.0.1", port=6379)
p = r.pipeline(transaction=True)
p.multi()
p.set("k1","v1")
p.hset("k2", "k2", "v2")
p.rpush("k3", "v3")

p.execute()

import redis

r = redis.Redis(host="127.0.0.1", port=6379)
r.set("count",1000)

with r.pipeline() as pipe:
    # 先監視，本身的值沒有被修改過
    r.watch("count")
    # 事務開始
    pipe.multi()
    old_count = r.get("count")
    count = int(old_count)
    if count > 0:  # 有庫存
        pipe.set("count", count-1)
    # 執行，把全部命令一次性推送過去
    pipe.execute()

實現計數器

五、發佈訂閱

發佈者：服務器

訂閱者：Dashboad和數據處理

代碼示例：

import redis

class RedisHelper(object):

    def __init__(self):
        pool = redis.ConnectionPool(host="127.0.0.1", port=6379)
        self.__conn = redis.Redis(connection_pool=pool)
        # 頻道至關於隊列名
        self.channel_pub = "FM107.5"  # 定義發佈頻道
        self.channel_sub = "FM107.5"  # 定義訂閱頻道

    def publish(self, msg):
        """
        將信息msg發送到指定的頻道
        :param msg:
        :return:
        """
        self.__conn.publish(self.channel_pub, msg)
        return True

    def subscribe(self):
        """
        定義給定的一個或多個頻道的信息
        :return:
        """
        pub = self.__conn.pubsub()       # 打開收音機
        pub.subscribe(self.channel_sub)  # 訂閱頻道
        pub.parse_response()             # 監聽信息
        return pub

redis_helper.py

訂閱者：

from redis_helper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()  # 阻塞，沒有數據就卡住
    print(msg)

發佈者：

from redis_helper import RedisHelper

obj = RedisHelper()
obj.publish("what's up? dude.")

操做：啓動訂閱者，開始監聽消息，發佈者發佈信息；又啓動一個訂閱者，發佈者再次發佈信息。

效果：

六、sentinel

redis中的sentinel主要用於在redis主從複製中，若是master宕機，則自動將slave替換成master。

from redis.sentinel import Sentinel

# 鏈接哨兵服務器(主機名也能夠用域名)
sentinel = Sentinel([("10.211.55.20", 26379),
                     ("10.211.55.20", 26380),
                     ],
                    socket_timeout=0.5)
# 獲取主服務器地址
master = sentinel.discover_master("master")
print(master)

# 獲取從服務器地址
slave = sentinel.discover_slaves("master")
print(slave)

# 獲取主服務器進行寫入
master = sentinel.master_for("master")
master.set("foo", "bar")

# 獲取從服務器進行讀取（默認是round-roubin）
slave = sentinel.slave_for("master", password="redis_auth_pass")
ret = slave.get("foo")
print(ret)