python3之redis

1、redis簡介

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

1. 使用Redis有哪些好處？

(1) 速度快，因為數據存在內存中，類似於HashMap，HashMap的優勢就是查找和操作的時間復雜度都是O(1)

(2) 支持豐富數據類型，支持string，list，set，sorted set，hash

(3) 支持事務，操作都是原子性，所謂的原子性就是對數據的更改要么全部執行，要么全部不執行

(4) 豐富的特性：可用於緩存，消息，按key設置過期時間，過期后將會自動刪除


2. redis相比memcached有哪些優勢？

(1) memcached所有的值均是簡單的字符串，redis作為其替代者，支持更為豐富的數據類型

(2) redis的速度比memcached快很多

(3) redis可以持久化其數據


3. redis常見性能問題和解決方案：

(1) Master最好不要做任何持久化工作，如RDB內存快照和AOF日志文件

(2) 如果數據比較重要，某個Slave開啟AOF備份數據，策略設置為每秒同步一次

(3) 為了主從復制的速度和連接的穩定性，Master和Slave最好在同一個局域網內

(4) 盡量避免在壓力很大的主庫上增加從庫

(5) 主從復制不要用圖狀結構，用單向鏈表結構更為穩定，即：Master <- Slave1 <- Slave2 <- Slave3...

這樣的結構方便解決單點故障問題，實現Slave對Master的替換。如果Master掛了，可以立刻啟用Slave1做Master，其他不變。

4. MySQL里有2000w數據，redis中只存20w的數據，如何保證redis中的數據都是熱點數據

 相關知識：redis 內存數據集大小上升到一定大小的時候，就會施行數據淘汰策略。redis 提供 6種數據淘汰策略：

voltile-lru：從已設置過期時間的數據集（server.db[i].expires）中挑選最近最少使用的數據淘汰

volatile-ttl：從已設置過期時間的數據集（server.db[i].expires）中挑選將要過期的數據淘汰

volatile-random：從已設置過期時間的數據集（server.db[i].expires）中任意選擇數據淘汰

allkeys-lru：從數據集（server.db[i].dict）中挑選最近最少使用的數據淘汰

allkeys-random：從數據集（server.db[i].dict）中任意選擇數據淘汰

no-enviction（驅逐）：禁止驅逐數據

5. Memcache與Redis的區別都有哪些？

1)、存儲方式

Memecache把數據全部存在內存之中，斷電后會掛掉，數據不能超過內存大小。

Redis有部份存在硬盤上，這樣能保證數據的持久性。

2)、數據支持類型
Memcache對數據類型支持相對簡單。
Redis有復雜的數據類型。
3），value大小
redis最大可以達到1GB，而memcache只有1MB

6. Redis 常見的性能問題都有哪些？如何解決？
1).Master寫內存快照，save命令調度rdbSave函數，會阻塞主線程的工作，當快照比較大時對性能影響是非常大的，會間斷性暫停服務，所以Master最好不要寫內存快照。
2).Master AOF持久化，如果不重寫AOF文件，這個持久化方式對性能的影響是最小的，但是AOF文件會不斷增大，AOF文件過大會影響Master重啟的恢復速度。Master最好不要做任何持久化工作，包括內存快照和AOF日志文件，特別是不要啟用內存快照做持久化,如果數據比較關鍵，某個Slave開啟AOF備份數據，策略為每秒同步一次。
3).Master調用BGREWRITEAOF重寫AOF文件，AOF在重寫的時候會占大量的CPU和內存資源，導致服務load過高，出現短暫服務暫停現象。
4). Redis主從復制的性能問題，為了主從復制的速度和連接的穩定性，Slave和Master最好在同一個局域網內

7, redis 最適合的場景
Redis最適合所有數據in-momory的場景，雖然Redis也提供持久化功能，但實際更多的是一個disk-backed的功能，跟傳統意義上的持久化有比較大的差別，那么可能大家就會有疑問，似乎Redis更像一個加強版的Memcached，那么何時使用Memcached,何時使用Redis呢?
       如果簡單地比較Redis與Memcached的區別，大多數都會得到以下觀點：
     1 、Redis不僅僅支持簡單的k/v類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
     2 、Redis支持數據的備份，即master-slave模式的數據備份。
     3 、Redis支持數據的持久化，可以將內存中的數據保持在磁盤中，重啟的時候可以再次加載進行使用。
（1）、會話緩存（Session Cache）
最常用的一種使用Redis的情景是會話緩存（session cache）。用Redis緩存會話比其他存儲（如Memcached）的優勢在於：Redis提供持久化。當維護一個不是嚴格要求一致性的緩存時，如果用戶的購物車信息全部丟失，大部分人都會不高興的，現在，他們還會這樣嗎？
幸運的是，隨着 Redis 這些年的改進，很容易找到怎么恰當的使用Redis來緩存會話的文檔。甚至廣為人知的商業平台Magento也提供Redis的插件。
（2）、全頁緩存（FPC）
除基本的會話token之外，Redis還提供很簡便的FPC平台。回到一致性問題，即使重啟了Redis實例，因為有磁盤的持久化，用戶也不會看到頁面加載速度的下降，這是一個極大改進，類似PHP本地FPC。
再次以Magento為例，Magento提供一個插件來使用Redis作為全頁緩存后端。
此外，對WordPress的用戶來說，Pantheon有一個非常好的插件  wp-redis，這個插件能幫助你以最快速度加載你曾瀏覽過的頁面。
（3）、隊列
Reids在內存存儲引擎領域的一大優點是提供 list 和 set 操作，這使得Redis能作為一個很好的消息隊列平台來使用。Redis作為隊列使用的操作，就類似於本地程序語言（如Python）對 list 的 push/pop 操作。
如果你快速的在Google中搜索“Redis queues”，你馬上就能找到大量的開源項目，這些項目的目的就是利用Redis創建非常好的后端工具，以滿足各種隊列需求。例如，Celery有一個后台就是使用Redis作為broker，你可以從這里去查看。
（4），排行榜/計數器
Redis在內存中對數字進行遞增或遞減的操作實現的非常好。集合（Set）和有序集合（Sorted Set）也使得我們在執行這些操作的時候變的非常簡單，Redis只是正好提供了這兩種數據結構。所以，我們要從排序集合中獲取到排名最靠前的10個用戶–我們稱之為“user_scores”，我們只需要像下面一樣執行即可：
當然，這是假定你是根據你用戶的分數做遞增的排序。如果你想返回用戶及用戶的分數，你需要這樣執行：
ZRANGE user_scores 0 10 WITHSCORES
Agora Games就是一個很好的例子，用Ruby實現的，它的排行榜就是使用Redis來存儲數據的，你可以在這里看到。
（5）、發布/訂閱
最后（但肯定不是最不重要的）是Redis的發布/訂閱功能。發布/訂閱的使用場景確實非常多。我已看見人們在社交網絡連接中使用，還可作為基於發布/訂閱的腳本觸發器，甚至用Redis的發布/訂閱功能來建立聊天系統！（不，這是真的，你可以去核實）。
Redis提供的所有特性中，我感覺這個是喜歡的人最少的一個，雖然它為用戶提供如果此多功能。

2、python鏈接redis操作

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

import redis
#創建redis鏈接對象
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
#存儲鍵值對
r.set('site','www.qi.cn')
#獲取值
print(r.get('site'))
#指定decode_responses為True，表示輸出為字符串
red = redis.StrictRedis(host='127.0.0.1',port=6379,decode_responses=True)

#默認redis入庫編碼是utf-8，如果要修改的話，需要指明 charset 和 decode_responsers 為True
#test = redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None)
red.lpush('list1','mongdb','redis','mysql')
print(r.lrange('list1',0,-1))
print(r.llen('list1'))

#output:
www.qi.cn
['mysql', 'redis', 'mongdb']
3

連接池：

redis-py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認，每個Redis實例都會維護一個自己的連接池。可以直接建立一個連接池，然后作為參數Redis，這樣就可以實現多個Redis實例共享一個連接池。

import redis
#創建連接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)
#創建鏈接對象
r=redis.Redis(connection_pool=pool)
#設置集合
r.sadd('set1','v1','v2','v3')
r.sadd('set1','v2')
#顯示集合的值
print(r.smembers('set1'))

#使用strictRedis連接池
rs = redis.StrictRedis(connection_pool=pool)
r.lpush('l1','python','memcache','redis','mongodb')
print(r.lrange('l1',0,-1))


#output:
{'v3', 'v1', 'v2'}
['mongodb', 'redis', 'memcache', 'python']

（1）數據string操作

redis中的String在在內存中按照一個name對應一個value來存儲的。

 set key value [EX seconds] [PX milliseconds] [NX|XX]

參數：

ex，過期時間（秒）

px，過期時間（毫秒）

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

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

import redis
#創建連接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)
#創建鏈接對象
r=redis.Redis(connection_pool=pool)
r.set('test','dddddddddddd',ex=3,nx=True)
print(r.get('test'))

setnx(name,value)：設置值，只有在name不存在是才執行操作

setex(name,value,time)：設置值過期時間，單位為秒

psetex(name,time_ms,value)：設置值，過期時間為毫秒

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

get(name)：獲取值

getrange(key,start,end)：獲取子序列,根據字節獲取

setrange(name,oofset,value)：修改字符串內容，從指定字符串索引開始向后替換

import redis
#創建連接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)
#創建鏈接對象
r=redis.Redis(connection_pool=pool)
r.set('test','12345',nx=True)
r.setrange('test',0,'8888')
print(r.get('test'))

setbit(name,offset,value)：對name對應值的二進制表示的位進行操作

getbit(name,offset)：獲取name對應的二進制位表示的值，只能是0或1

import redis
r=redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.set('name','p')
print(r.get('name'))
#打印p,q對應的ascii碼
print(ord('p'),ord('q'))
#打印ascii碼對應的二進制
print(bin(ord('p')),bin(ord('q')))
print('修改前7位的值：',r.getbit('name','7'))
#設置二進制位的第7位為1，相當於移動ascii碼位112為113對應的字符為q
r.setbit('name','7','1')
print('修改后7位的值：',r.getbit('name','7'))
print(r.get('name'))

#output：
p
112 113
0b1110000 0b1110001
修改前7位的值： 0
修改后7位的值： 1
q

strlen(name)：返回name對應值的字節長度，一個漢字3個字節

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.set('name','python')
print(r.strlen('name'))  #輸出6個字節

incr(self,name,amount=1)：自增name對應的值，當name不存在時，則創建name=amount，否則自增

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
#r.set('name','python')
r.set('age','1')
print(r.incr('age','3')) #結果為4

decr(self,name,amount=1)：自減 name對應的值，當name不存在時，則創建name＝amount，否則，則自減

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)

r.set('age','10')
print(r.decr('age','3'))  #輸出為7

append(key,value)：在name對應的值后面追加內容

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.set('age','10')
print(r.get('age'))
print(r.append('age','11'))
print(r.get('age'))

#output：
10
4
1011

（2）hash操作

hset(name,key,value)：在name對應的hash中設置一個鍵值對，不存在則創建否則修改

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hset('haset','python','3.5')
print(r.hget('haset','python'))
r.hset('haset','redis','1.8')
print(r.hgetall('haset'))

#output：
3.5
{'python': '3.5', 'redis': '1.8'}

hmset(name,mapping)：在name對應的hash中批量設置鍵值對

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hmget('hashmore','k1','k2','k3'))
print(r.hgetall('hashmore'))

hget(name,key)：獲取hash中的value

hmget(name,keys,*args)：獲取過個hash的key的值

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

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

hkeys(name)：獲取hash中所有keys的值

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

hexists(name,key)：檢查hash中是否存在key

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hmget('hashmore','k1','k2','k3'))
print(r.hgetall('hashmore'))
print(r.hexists('hashmore','k2'))
print(r.hexists('hashmore','k4'))

#output：
['v1', 'v2', 'v3']
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
True
False

hdel(name,*key)：刪除hash中的key

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hgetall('hashmore'))
print(r.hdel('hashmore','k3'))
print(r.hgetall('hashmore'))

#output：
{'k3': 'v3', 'k2': 'v2', 'k1': 'v1'}
1
{'k2': 'v2', 'k1': 'v1'}

hincrby(name,key,amount=1)：自增hash中指定的key的值，不存在則創建key=amount

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3'})
print(r.hgetall('hashmore'))
r.hincrby('hashmore','k1','2')
print(r.hgetall('hashmore'))

hincrbyfloat(name,key,amount=1.0)：自增hash中指定的key的值，同上針對浮點數

hscan(name,cursor=0,match=None,count=None)：增量迭代獲取hash中數據，cursor游標，match匹配key默認所有，count獲取的個數。

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4'})
print(r.hgetall('hashmore'))
print(r.hscan('hashmore',cursor=2,match='k2',count=1))
print(r.hscan('hashmore',count=4))

#output：

{'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'}
(0, {'k2': '2'})
(0, {'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'})

hscan_iter(name,match=None,count=None)：利用yield封裝hscan創建生成器，實現分批獲取數據

import redis
r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4','k5':'5','k6':'6','k7':'7','k8':'8'})
oo = r.hscan_iter('hashmore')
print(next(oo))
print(next(oo))
print(next(oo))
print(next(oo))

#output:
('k2', '2')
('k7', '7')
('k8', '8')
('k5', '5')

（3）list操作

lpush(name,values)：在列表中添加元素，每個新元素都從左邊開始添加

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.lpush('l3',1,2)
print(r.lrange('l3',0,-1))
r.lpush('l3','88')
print(r.lrange('l3',0,-1))

#output：
['2', '1']
['88', '2', '1']

lpushx(name,value)：在列表中添加元素，只有在name存在時才添加

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.lpushx('l4',1)
print(r.lrange('l4',0,-1))
r.lpush('l4',2)
r.lpushx('l4',1)
print(r.lrange('l4',0,-1))

#output:
[]
['1', '2']

llen(name)：name對應的list元素的長度

linsert(name,where,refvalue,value)：在name對應的列表的某個值前或后插入一個新值，where指定前或后(befor/after)，refvalue參考值即指定的元素，value要插入的值

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.lpush('num','1','2')
r.linsert('num','after','2','python')#在2后面添加python元素值
r.linsert('num','before','1','redis') #在1之前插入redis
print(r.lrange('num',0,-1))

#output:
['2', 'python', 'redis', '1']

lset(name,index,value)：對列表中的某個索引位的值修改

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
print(r.lrange('num',0,-1))
r.lset('num','0','hello')
print(r.lrange('num',0,-1))

#output：
['2', 'python', 'redis', '1']
['hello', 'python', 'redis', '1']

lrem(name,value,num)：在name對應的list中刪除指定的值

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
print(r.lrange('num',0,-1))
r.lrem('num','1','2')   #2為num指定的值的個數,可以指定-2從后往前刪除
print(r.lrange('num',0,-1))

#output:
['1', 'hello', 'python', 'redis', '1']
['hello', 'python', 'redis']

lpop(name)：在name對應的列表的左側獲取第一個元素並刪除，並返回參數的元素

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

ltrim(name,start,end)：在name對應的列表中移除start到end之間的值

lrange(name,start,end)：列表分片獲取數據

rpoplush(src,dst):獲取源列表最后一個元素的值，並將它添加到目標列表中的最左邊

blpop(keys,timeout)：將多個列表排列，按照從左到右去pop對應列表的元素

brpoplpush(src,dst,timeout=0)：從一個列表的右側移除一個元素並將其添加到另一個列表的左側

（4）set操作

sadd(name,values)：添加元素到集合

scard(name)：獲取集合中元素的個數

sdiff(keys,*args)：在第一個集合中的元素且不在其他集合的元素的集合

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.sadd('s1',1,2,3)
r.sadd('s2',4,5,2)
r.sadd('s3',7,8,1)
print(r.sdiff('s1','s2','s3'))

#output:
{'3'}

sdiffstore(dest,keys,*args)：在第一個keys中的集合元素且不在其他集合中的元素添加到dest新集合中

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
# r.sadd('s1',1,2,3)
# r.sadd('s2',4,5,2)
# r.sadd('s3',7,8,1)
print(r.sdiffstore('s4','s1','s2','s3'))
print(r.smembers('s4'))

sinter(keys,*args)：獲取多個集合的並集

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
 r.sadd('s1',1,2,3)
 r.sadd('s2',4,5,2)
print(r.sinter('s1','s2'))

#output：
{'2'}

sinterstore(dest,keys,*args)：獲取多個集合的並集並將結果加入到dest集合中

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.sadd('sex1',1,2,3,4)
r.sadd('sex2',4,5,2,7)
r.sadd('sex3',7,8,1,4,2)
r.sinterstore('sex4','sex1','sex2','sex3')
print(r.smembers('sex4'))

#output：
{'4', '2'}

sismember(name,value)：檢查value是否在集合中

import redis
r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)
r.sadd('sex3',7,8,1,4,2)
print(r.sismember('sex3','8'))

#output：
True

smembers(name)：獲取集合的所有成員

smove(src,dst,value)：將源集合中的某個成員移動到目標集合中

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

srandmember(name,numbers)：從name對應的集合中隨機獲取 numbers 個元素

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

sunion(keys,*args)：並集顯示多個集合元素

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

sscan(name,cursor=0,match=None,count=None)：同字符串的操作，用於增量迭代分批獲取元素，避免內存消耗太大

sscan_iter(name,match=None,count=None)：同字符串的操作，用於增量迭代分批獲取元素，避免內存消耗太大

（5）有序集合操作

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

• zadd(name,*args,**kwargs)：在name對應的有序集合中添加元素
• zcard(name)：獲取name對應的有序集合元素的數量
• zcount(name,min,max)：獲取name對應的有序集合中分數 在 [min,max] 之間的個數
• zincrby(name,value,amount)：自增name對應的有序集合的 name 對應的分數
• r.zrange(name, start, end, desc=False, withscores=Flase, score_cast_func=float)：按照索引范圍獲取name對應的有序集合的元素
• zrank(name, value)：獲取某個值在 name對應的有序集合中的排行（從 0 開始）
• zrangebylex(name, min, max, start=None, num=None)：當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值
• zrem(name, values)：刪除name對應的有序集合中值是values的成員
• zremrangebyrank(name, min, max)： 根據排行范圍刪除
• zremrangebyscore(name, min, max)：根據分數范圍刪除
• zremrangebylex(name, min, max)：根據值返回刪除
• zscore(name, values)：獲取name對應有序集合中 value 對應的分數
• zinterstore(dest, keys, aggregate=None)：獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作
• zunionstore(dest, keys, aggregate=None)：獲取兩個有序集合的並集，如果遇到相同值不同分數，則按照aggregate進行操作
• zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：同字符串相似，相較於字符串新增score_cast_func，用來對分數進行操作
• zscan_iter(name, match=None, count=None,score_cast_func=float)：同字符串相似，相較於字符串新增score_cast_func，用來對分數進行操作

（6）其他操作

• delete(*name)：根據刪除redis中的任意數據類型
• exists(name)：檢測redis的name是否存在
• keys(pattern='*')：根據模型獲取redis的name
• 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)：同字符串操作，用於增量迭代獲取key
• scan_iter(match=None,count=None)：同字符串操作，用於增量迭代獲取key

 3、python對redis管道操作

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

import redis
 
pool = redis.ConnectionPool(host='0.0.0.0', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
 
r.set('name', 'python')
r.set('age', '18')
 
pipe.execute()

4、python對redis發布與訂閱

demo:

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import redis
class RedisHelper:
    '''類'''
    def __init__(self):
        #鏈接
        self.__conn = redis.Redis(host='0.0.0.0')
        self.chan_sub = 'fm104.5'
        #創建頻道
        self.chan_pub = 'fm104.5'
 
    def public(self,info):
        '''公共的'''
        self.__conn.publish(self.chan_pub,info)
        '''將內容發布到頻道'''
        return True
 
    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

發布者：

#!/usr/bin/env python
# -*- coding:utf-8 -*- 
#導入模塊
from redis_demo.demo import RedisHelper
#實例化
obj = RedisHelper()
#把內容發布到頻道
obj.public('python')

訂閱者：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from redis_demo.demo import RedisHelper
 
obj = RedisHelper()
redis_sub = obj.subscribe()
 
while True:
    msg= redis_sub.parse_response()
    print (msg)
    print(type(msg))

運行方式：

　　　　先啟動demo, 啟動訂閱者，啟動發布者，訂閱者接受消息。

---------------------------------------------------------------------------------------------