python操做Redis緩存

時間 2019-12-20

原文原文鏈接

1、Redis的安裝

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

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

　　若是不巧發生如下截圖中的錯誤：python

　　說明未安裝gcc，若是是centos系統，輸入：yum install gcc安裝gcc便可，而後再次輸入make執行。redis

　　輸入make後，很不幸，再次發生以下截圖錯誤：shell

　　推測是由於編譯庫的問題。數據庫

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

　終於安裝成功了！服務器

　　還有配置文件的修改什麼的先不折騰了，此時已然能夠啓動Redis服務app

src/redis-server # 啓動服務端

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

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

　　可是看到不少WARNING，沒錯，此時你用pycharm寫了鏈接redis服務端的代碼，可是你發現服務端居然沒有響應ide

　　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

　　唉呀呀，終於成功了！

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

2、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('按任意鍵結束')

3、五大數據類型

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'))

View Code

　　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']

View Code

　　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'

View Code

　　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"

View Code

　　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，要設置的值

View Code

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

View Code

　　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

View Code

　　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,自減數（整數）

View Code

　 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, 要追加的字符串

View Code

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時則建立（至關於添加）

View Code

　　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'})

View Code

　　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'))

View Code

　　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'}

View Code

　　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，自增數（整數）

View Code

　　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時，表示數據已經經過分片獲取完畢

View Code

　　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

View Code

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) 表示從右向左操做

View Code

　　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) 表示從右向左操做

View Code

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

　　linsert(name, where, refvalue, value))

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

# 參數：
#     name，redis的name
#     where，BEFORE或AFTER
#     refvalue，標杆值，即：在它先後插入數據
#     value，要插入的數據

View Code

　　r.lset(name, index, value)

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

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

View Code

　　r.lrem(name, value, num)

# 在name對應的list中刪除指定的值

# 參數：
#     name，redis的name
#     value，要刪除的值
#     num，  num=0，刪除列表中全部的指定值；
#       num=2,從前到後，刪除2個；
#       num=-2,從後向前，刪除2個

View Code

　　lpop(name)

# 在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素

# 更多：
#   rpop(name) 表示從右向左操做

View Code

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

　　lrange(name, start, end)

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

View Code

　　ltrim(name, start, end)

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

View Code

　　rpoplpush(src, dst)

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

View Code

　　blpop(keys, timeout)

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

View Code

　　brpoplpush(src, dst, timeout=0)

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

View Code

　　自定義增量迭代

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

View Code

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)

View Code

　　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對應的分數

View Code

　　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)

View Code

　　zrank(name, value)　　

# 獲取某個值在 name對應的有序集合中的排行（從 0 開始）

# 更多：
#    zrevrank(name, value)，從大到小排序

View Code

　　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)

View Code

　　zrem(name, values)

# 刪除name對應的有序集合中值是values的成員

# 如：zrem('zset_name', ['a1', 'a2'])

View Code

　　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

View Code

　　zunionstore(dest, keys, aggregate=None)

# 獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做
# aggregate的值爲:  SUM  MIN  MAX

View Code

　　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

View Code

　　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='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()

View Code

5、發佈和訂閱

　　發佈者：服務器

　　訂閱者：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

RedisHelper

　　訂閱者：

from monitor.RedisHelper import RedisHelper

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

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

View Code

　　發佈者：

from monitor.RedisHelper import RedisHelper

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

View Code

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。