python操作Redis緩存

一、Redis的安裝

　　xshell連上服務器，依次輸入以下代碼：

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

 

　　如果不巧發生以下截圖中的錯誤：

　　說明未安裝gcc，如果是centos系統，輸入：yum install gcc安裝gcc即可，然后再次輸入make執行。

　　輸入make后，很不幸，再次發生如下截圖錯誤：

　　推測是因為編譯庫的問題。

　　將make改為make MALLOC=libc 再次運行！好事多磨。

　    終於安裝成功了！

　　還有配置文件的修改什么的先不折騰了，此時已然可以啟動Redis服務

src/redis-server # 啟動服務端

# 啟動客戶端的代碼如下
src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar"

　    看到上面的圖像，說明服務端已經起來了！

　　但是看到很多WARNING，沒錯，此時你用pycharm寫了連接redis服務端的代碼，但是你發現服務端竟然沒有響應

　　OK，在服務端Ctrl + C ,先把服務斷開

　　分別執行下面的語句：

echo 511 > /proc/sys/net/core/somaxconn
echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
sysctl vm.overcommit_memory=1
echo never > /sys/kernel/mm/transparent_hugepage/enabled

　　在/etc下的rc.local的最后添加：

echo never > /sys/kernel/mm/transparent_hugepage/enabled

　　最后的重點來了，折騰半天還是服務器不鳥我，無奈之下試了試臨時關閉防火牆：

service iptables stop 

　　唉呀呀，終於成功了！

　　我在另一台服務器用了另一種搭建方法：傳送門也成功了，但是也不要忘記要臨時關掉防火牆。

 

二、Redis的兩種連接方式

1.簡單連接

import redis
conn = redis.Redis(host='207.148.120.229', port=6379)
conn.set('foo', 'Bar')
print(conn.get('foo'))
a = input('按任意鍵結束')

2.使用連接池　　

　　為了減少每次建立、釋放連接的開銷，推薦使用連接池

　　redis使用connection pool來管理對一個redis服務的所有連接。

　　多個redis實例可共享一個連接池。

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('key', 'Hello World')
print(conn.get('key'))
a = input('按任意鍵結束')

三、五大數據類型

1.String操作　　

　　redis中的String在在內存中按照一個key對應一個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
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('key', 'Hello World')
print(conn.get('key'))

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

# 批量設置值
import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.mset(k1='v1', k2='v2')
# conn.mset({'k1': 'v1', 'k2': 'v2'})

print(conn.get('k1'))

　　get(name)  獲取值

print(conn.get('k1'))

　　mget(keys, *args) 批量獲取值

# 批量獲取值
import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.mset(k1='v1', k2='v2')

print(conn.mget('k1','k2'))    # [b'v1', b'v2']
print(conn.mget(['k1','k2']))  # [b'v1', b'v2']

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

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.mset(k1='v1', k2='v2')

ret = conn.getset('k1','value_1')
print(ret)             # b'v1'
print(conn.get('k1')) # b'value_1'

　　getrange(key, start, end)  獲取name對應value的指定字節

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('k1','hello')

print(conn.getrange('k1',0,3)) # b'hell''
# 獲取子序列（根據字節獲取，非字符）
# 參數：
    # name，Redis 的 name
    # start，起始位置（字節）
    # end，結束位置（字節）
# 如： "hello" ，0-3表示 "hell"

　　setrange(name, offset, value) 從指定字節開始替換新值

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

print(conn.get('k1'))  # b'hello'
conn.setrange('k1',2,'long_time')
print(conn.get('k1'))  # b'helong_time'

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

　　strlen(name) 獲取name對應的value的長度

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('k1','hello')
conn.set('k2','天寶')

print(conn.strlen('k1'))  # 5
print(conn.strlen('k2'))  # 6  一個漢字占3個字節

　　incr(self, name, amount=1) name存在，則自增amount，否則設置name的value值為amount

import redis
pool = redis.ConnectionPool(host='207.148.120.229',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('k1','5')
conn.incr('k1',amount=3)

print(conn.get('k1'))  # b'8'

# 自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。

# 參數：
# name,Redis的name
# amount,自增數（必須是整數）

# 注：同incrby

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

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('k1','5')
conn.decr('k1',amount=3)

print(conn.get('k1'))  # b'2'

# 自減 name對應的值，當name不存在時，則創建name＝amount，否則，則自減。

# 參數：
# name,Redis的name
# amount,自減數（整數）

　    append(key, value)

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.set('k1','hello_')
conn.append('k1','world')

print(conn.get('k1'))  # b'hello_world'

# 在redis name對應的值后面追加內容

# 參數：
# key, redis的name
# value, 要追加的字符串

2.Hash操作

 

　　hset(name, key, value)  設置值

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.hset('n1','key_1','hello')
conn.hset('n1','key_2','world')

print(conn.hget('n1','key_1'))  # b'hello'
print(conn.hget('n1','key_2'))  # b'world'

# name對應的hash中設置一個鍵值對（不存在，則創建；否則，修改）

# 參數：
# name，redis的name
# key，name對應的hash中的key
# value，name對應的hash中的value

# 注：
# hsetnx(name, key, value),當name對應的hash中不存在當前key時則創建（相當於添加）

 

　　hmset(name, mapping) 批量設置值

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.hmset('n1',{'k1':'v1', 'k2': 'v2'})

print(conn.hget('n1','k1'))  # b'v1'
print(conn.hget('n1','k2'))  # b'v2'

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

# 參數：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}

# 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

　　hmget(name, keys, *args) 獲取多個值

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.hmset('n1',{'k1':'v1', 'k2': 'v2'})

print(conn.hmget('n1',['k1','k2']))  # [b'v1', b'v2']

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

# 參數：
# name，reids對應的name
# keys，要獲取key集合，如：['k1', 'k2', 'k3']
# *args，要獲取的key，如：k1,k2,k3

# 如：
# r.mget('xx', ['k1', 'k2'])
# 或
# print(r.hmget('xx', 'k1', 'k2'))

　　hgetall(name)  獲取name對應hash的所有鍵值

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.hmset('n1',{'k1':'v1', 'k2': 'v2'})

print(conn.hgetall('n1'))  # {b'k1': b'v1', b'k2': b'v2'}

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

　　hkeys(name)  獲取name對應的hash中所有的key的值 

　　hvals(name)  獲取name對應的hash中所有的value的值

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

　　hincrby(name, key, amount=1)  自增（整數）

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.hmset('n1',{'k1':'10', 'k2': '20'})
conn.hincrby('n1','k1',amount=5)

print(conn.hget('n1','k1'))  # b'15'

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

　　hincrbyfloat(name, key, amount=1.0) 自增（浮點數）

　　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

3.List操作

　　lpush(name,values)  

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.lpush('ww',11)

print(conn.lindex('ww',0))  # b'11'  # 根據所有獲取值

# 在name對應的list中添加元素，每個新的元素都添加到列表的最左邊

# 如：
# r.lpush('oo', 11,22,33)
# 保存順序為: 33,22,11

# 擴展：
# rpush(name, values) 表示從右向左操作

　　lpushx(name,value)

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.lpushx('ww',22)

print(conn.lrange('ww',0,1))  # [b'22', b'22']

# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊

# 更多：
# rpushx(name, value) 表示從右向左操作

 

　　llen(name)  name對應的list元素的個數

　　linsert(name, where, refvalue, value))

# 在name對應的列表的某一個值前或后插入一個新值

# 參數：
#     name，redis的name
#     where，BEFORE或AFTER
#     refvalue，標桿值，即：在它前后插入數據
#     value，要插入的數據

 

　　r.lset(name, index, value)

# 對name對應的list中的某一個索引位置重新賦值

# 參數：
#     name，redis的name
#     index，list的索引位置
#     value，要設置的值

 

　　r.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

4.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_iter(name, match=None, count=None)  同字符串的操作，用於增量迭代分批獲取元素，避免內存消耗太大

5.有序集合

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

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

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.zadd("zset_name", "a1", 6, "a2", 2,"a3",5)
#conn.zadd('zset_name1', b1=10, b2=5)

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

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

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

import redis
pool = redis.ConnectionPool(host='207.148.121.149',port=6379)
conn = redis.Redis(connection_pool=pool)

conn.zadd("zset_name", "a1", 6, "a2", 2,"a3",5)
#conn.zadd('zset_name1', b1=10, b2=5)
conn.zincrby("zset_name","a1",amount=2)#自增zset_name對應的有序集合里a1對應的分數

　　r.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('zset_name', ['a1', 'a2'])

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

6.其他常用操作

　　delete(*names)  根據name刪除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

四、管道

　　redis-py默認在執行每次請求都會創建（連接池申請連接）和斷開（歸還連接池）一次連接操作，如果想要在一次請求中指定多個命令，則可以使用pipline實現一次請求指定多個命令，並且默認情況下一次pipline 是原子性操作。

import redis

pool = redis.ConnectionPool(host='207.148.121.149', port=6379)

conn = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = conn.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'bigboss')

pipe.execute()

五、發布和訂閱

　　發布者：服務器

　　訂閱者：Dashboad和數據處理

　　Demo如下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis


class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='10.211.55.4')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

 

　　訂閱者：

from monitor.RedisHelper import RedisHelper

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

while True:
    msg = redis_sub.parse_response()
    print(msg)

 

　　發布者：

from monitor.RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello world')