[轉]使用python來操做redis用法詳解

轉自：使用python來操做redis用法詳解

 

class CommRedisBase():
    def __init__(self):
        REDIS_CONF = {}
        connection_pool = redis.ConnectionPool(**REDIS_CONF)
        self._client = redis.Redis(connection_pool=connection_pool)

CommRedisBase()

 

1.字符類

 

class StringRedisClass(CommRedisBase):
    '''
    字符類
    '''

    def set(name, value, ex=None, px=None, nx=False, xx=False)
        '''
        ex: 過時時間（秒）
        px: 過時時間（毫秒）
        nx: 若是設置爲True: 則只有name不存在時: 當前set操做才執行
        xx: 若是設置爲True: 則只有name存在時: 當前set操做才執行
        '''

    def setnx(name, value)
        '''
        設置值: 只有name不存在時: 執行設置操做（添加）
        '''

    def setex(name, value, time)
        '''
        time: 過時時間（數字秒 或 timedelta對象）
        '''

    def psetex(name, time_ms, value)
        '''
        time_ms: 過時時間（數字毫秒 或 timedelta對象）
        '''

    def mset(*args, **kwargs)
        '''
        批量設置值
        '''

    def mget(keys, *args)
        '''
        批量獲取
        '''

    def getset(name, value)
        '''
        設置新值並獲取原來的值
        '''

    def getrange(key, start, end)
        '''
        獲取子序列（根據字節獲取: 非字符）
        參數：
        name: Redis 的 name
        start, 起始位置（字節）
        end, 結束位置（字節）
        '''

    def setrange(name, offset, value)
        '''
        修改字符串內容: 從指定字符串索引開始向後替換（新值太長時: 則向後添加）
        參數：
        offset: 字符串的索引: 字節（一個漢字三個字節）
        value: 要設置的值
        '''

    def setbit(name, offset, value)
        '''
        對name對應值的二進制表示的位進行操做
        參數：
        name: redis的name
        offset: 位的索引（將值變換成二進制後再進行索引）
        value: 值只能是 1 或 0        
        '''

    def getbit(name, offset)
        '''
        獲取name對應的值的二進制表示中的某位的值 （0或1）
        '''

    def bitcount(key, start=None, end=None)
        '''
        獲取name對應的值的二進制表示中 1 的個數
        參數：
        key: Redis的name
        start 字節起始位置
        end: 字節結束位置
        '''

    def bitop(operation, dest, *keys)
        '''
        獲取多個值，並將值作位運算，將最後的結果保存至新的name對應的值

        參數：
        operation,AND（並） 、 OR（或） 、 NOT（非） 、 XOR（異或）
        dest, 新的Redis的name
        *keys,要查找的Redis的name
        '''

    def strlen(name)
        '''
        返回name對應值的字節長度（一個漢字3個字節）
        '''

    def incr(self, name, amount=1)
        '''
        自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
        參數：
        name,Redis的name
        amount,自增數（必須是整數）
        注：同incrby
        應用場景 – 頁面點擊數
        假定咱們對一系列頁面須要記錄點擊次數。例如論壇的每一個帖子都要記錄點擊次數，而點擊次數比回帖的次數的多得多。若是使用關係數據庫來存儲點擊，可能存在大量的行級鎖爭用。因此，點擊數的增長使用redis的INCR命令最好不過了。
        當redis服務器啓動時，能夠從關係數據庫讀入點擊數的初始值（12306這個頁面被訪問了34634次）
        '''

    def incrbyfloat(self, name, amount=1.0)
        '''
        自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。
        參數：
        name,Redis的name
        amount,自增數（浮點型）
        '''

    def decr(self, name, amount=1)
        '''
        自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。
        參數：
        name,Redis的name
        amount,自減數（整數)
        '''

    def append(key, value)
        '''
        在redis name對應的值後面追加內容
        參數：
        key, redis的name
        value, 要追加的字符串
        '''

StringRedisClass

 

2.hash類

 

class HSetRedisClass(CommRedisBase):
    '''
    hash集合類
    '''
    def hset(name, key, value)
        '''
        單個增長--修改(單個取出)--沒有就新增，有的話就修改
        name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）
        參數：
        name，redis的name
        key，name對應的hash中的key
        value，name對應的hash中的value
        注：
        hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）
        '''

    def hmset(name, mapping)
        '''
        批量增長
        在name對應的hash中批量設置鍵值對
        參數：
        name，redis的name
        mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
        '''

    def hget(name,key)
        '''
        在name對應的hash中獲取根據key獲取value
        hmget(name, keys, *args)
        在name對應的hash中獲取多個key的值
        參數：
        name，reids對應的name
        keys，要獲取key集合，如：['k1', 'k2', 'k3']
        *args，要獲取的key，如：k1,k2,k3
        '''

    def hgetall(name)
        '''
        獲取name對應hash的全部鍵值
        '''

    def hlen(name)
        '''
        獲取name對應的hash中鍵值對的個數
        '''

    def hkeys(name)
        '''
        獲取name對應的hash中全部的key的值
        '''

    def hvals(name)
        '''
        獲取name對應的hash中全部的value的值
        '''

    def hexists(name, key)
        '''
        檢查name對應的hash是否存在當前傳入的key
        '''

    def hdel(name,*keys)
        '''
        將name對應的hash中指定key的鍵值對刪除
        '''

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

    def hincrbyfloat(name, key, amount=1.0)
        '''
        自增name對應的hash中的指定key的值，不存在則建立key=amount
        參數：
        name，redis中的name
        key， hash對應的key
        amount，自增數（浮點數）
        自增name對應的hash中的指定key的值，不存在則建立key=amount
        '''

    def 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時，表示數據已經經過分片獲取完畢
        '''
    def hscan_iter(name, match=None, count=None)
        '''
        利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
        參數：
        match，匹配指定key，默認None 表示全部的key
        count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
        '''

HSetRedisClass

 

3.List

 

class ListRedisClass(CommRedisBase):
    '''
    redis集合List
    '''
    def lpush(name,values)
        '''
        增長（相似於list的append，只是這裏是從左邊新增長）--沒有就新建
        在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊
        '''

    def rpush(name,values)
        '''
        增長（從右邊增長）--沒有就新建
        '''

    def lpushx(name,value)
        '''
        往已經有的name的列表的左邊添加元素，沒有的話沒法建立
        在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊
        '''

    def lpushx(name,value)
        '''
        往已經有的name的列表的右邊添加元素，沒有的話沒法建立
        '''

    def linsert(name, where, refvalue, value)
        '''
        在name對應的列表的某一個值前或後插入一個新值
        參數：
        name，redis的name
        where，BEFORE或AFTER
        refvalue，標杆值，即：在它先後插入數據
        value，要插入的數據
        '''

    def lset(name, index, value)
        '''
        對name對應的list中的某一個索引位置從新賦值
        參數：
        name，redis的name
        index，list的索引位置
        value，要設置的值
        '''

    def lrem(name, value, num)
        '''
        在name對應的list中刪除指定的值
        參數：
        name，redis的name
        value，要刪除的值
        num， num=0，刪除列表中全部的指定值；
        num=2,從前到後，刪除2個； num=1,從前到後，刪除左邊第1個
        num=-2,從後向前，刪除2個
        '''

    def lpop(name)
        '''
        在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素
        更多：
        rpop(name) 表示從右向左操做
        '''

    def ltrim(name, start, end)
        '''
        在name對應的列表中移除沒有在start-end索引之間的值
        參數：
        name，redis的name
        start，索引的起始位置
        end，索引結束位置
        '''

    def lindex(name, index)
        '''
        在name對應的列表中根據索引獲取列表元素
        '''

    def rpoplpush(src, dst)
        '''
        從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
        參數：
        src，要取數據的列表的name
        dst，要添加數據的列表的name
        '''

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

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

    def list_iter(name)
        '''
        因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
        獲取name對應的全部列表
        循環列表
        可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能
        '''
        list_count = llen(name)
        for index in range(list_count):
            yield lindex(name, index)

ListRedisClass

 

4.Set類

 

class SetRedisClass():
    '''
    Redis Set類
    '''

    def sadd(name,values)
        '''
        name對應的集合中添加元素
        '''

    def scard(name)
        '''
        獲取name對應的集合中元素個數
        '''

    def smembers(name)
        '''
        獲取name對應的集合的全部成員
        '''

    def sscan(name, cursor=0, match=None, count=None)
        '''
        獲取集合中全部的成員--元組形式
        '''

    def sscan_iter(name, match=None, count=None)
        '''
        獲取集合中全部的成員--迭代器的方式
        同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大
        '''

    def sdiff(keys, *args)
        '''
        在第一個name對應的集合中且不在其餘name對應的集合的元素集合
        '''

    def sdiffstore(dest, keys, *args)
        '''
        獲取第一個name對應的集合中且不在其餘name對應的集合，再將其新加入到dest對應的集合中
        '''

    def sinter(keys, *args)
        '''
        sinterstore(dest, keys, *args)
        獲取多一個name對應集合的並集，再將其加入到dest對應的集合中
        '''

    def sunion(keys, *args)
        '''
        獲取多個name對應的集合的並集
        '''

    def sunionstore(dest,keys, *args)
        '''
        獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中
        '''

    def sismember(name, value)
        '''
        檢查value是不是name對應的集合的成員，結果爲True和False
        '''

    def smove(src, dst, value)
        '''
        將某個成員從一個集合中移動到另一個集合
        '''

    def spop(name)
        '''
        從集合移除一個成員，並將其返回,說明一下，集合是無序的，全部是隨機刪除的
        '''

    def srem(name, values)
        '''
        在name對應的集合中刪除某些值
        '''

SetRedisClass

 

5.有序集合ZSet

 

class ZSetRedisClass(CommRedisBase):
    '''
    有序集合類
    '''

    def zadd(name, *args, **kwargs)
        '''
        在name對應的有序集合中添加元素
        '''

    def zcard(name)
        '''
        獲取name對應的有序集合元素的數量
        '''

    def zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
        '''
        按照索引範圍獲取name對應的有序集合的元素
        參數：
        name，redis的name
        start，有序集合索引發始位置（非分數）
        end，有序集合索引結束位置（非分數）
        desc，排序規則，默認按照分數從小到大排序
        withscores，是否獲取元素的分數，默認只獲取元素的值
        score_cast_func，對分數進行數據轉換的函數
        '''

    def zrevrange(name, start, end, withscores=False, score_cast_func=float)
        '''
        從大到小排序(同zrange，集合是從大到小排序的)
        '''

    def zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
        '''
        按照分數範圍獲取name對應的有序集合的元素
        '''

    def zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
        '''
        按照分數範圍獲取有序集合的元素並排序（默認從大到小排序）
        '''

    def zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
        '''
        獲取全部元素--默認按照分數順序排序
        '''

    def zscan_iter(name, match=None, count=None,score_cast_func=float)
        '''
        獲取全部元素--迭代器
        '''

    def zcount(name, min, max)
        '''
        獲取name對應的有序集合中分數 在 [min,max] 之間的個數
        '''

    def zincrby(name, value, amount)
        '''
        自增name對應的有序集合的 name 對應的分數
        '''

    def zrank(name, value)
        '''
        獲取某個值在 name對應的有序集合中的索引（從 0 開始）
        更多：
        zrevrank(name, value)，從大到小排序
        '''

    def zrem(name, values)
        '''
        刪除name對應的有序集合中值是values的成員
        '''

    def zremrangebyrank(name, min, max)
        '''
        根據排行範圍刪除
        '''

    def zremrangebyscore(name, min, max)
        '''
        根據分數範圍刪除
        '''

    def zscore(name, value)
        '''
        獲取name對應有序集合中 value 對應的分數
        '''

ZSetRedisClass

 

6.others

 

OtherRedisClass():
    '''
    其餘經常使用操做
    '''

    def delete(*names)
        '''
        根據刪除redis中的任意數據類型（string、hash、list、set、有序set）
        '''

    def exists(name)
        '''
        檢測redis的name是否存在，存在就是True，False 不存在
        '''

    def keys(pattern='')
        '''
        根據模型獲取redis的name
        更多：
        KEYS * 匹配數據庫中全部 key 。
        KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
        KEYS hllo 匹配 hllo 和 heeeeello 等。
        KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
        '''

    def expire(name ,time)
        '''
        爲某個redis的某個name設置超時時間
        '''
        lpush("list5", 11, 22)
        expire("list5", time=3)
        print(r.lrange("list5", 0, -1))
        time.sleep(3)
        print(r.lrange("list5", 0, -1))

    def rename(src, dst)
        '''
        對redis的name重命名
        '''

    def randomkey()
        '''
        隨機獲取一個redis的name（不刪除）
        '''

    def type(name)
        '''
        獲取name對應值的類型
        '''

    def scan(cursor=0, match=None, count=None)
        '''
        查看全部元素
        '''

    def scan_iter(match=None, count=None)
        '''
        查看全部元素--迭代器
        '''

    def get(name)
        '''
        查詢key爲name的值
        '''

    def dbsize()
        '''
        當前redis包含多少條數據
        '''

    def save()
        '''
        執行"檢查點"操做，將數據寫回磁盤。保存時阻塞
        '''

    def flushdb()
        '''
        清空redis中的全部數據
        '''

OtherRedisClass