安装

https://www.runoob.com/redis/redis-install.html

在 Ubuntu 系统安装 Redis 可以使用以下命令:

$sudo apt-get update
$sudo apt-get install redis-server
启动 Redis
$ redis-server
查看 redis 是否启动？
$ redis-cli
以上命令将打开以下终端：
redis 127.0.0.1:6379>
127.0.0.1 是本机 IP ，6379 是 redis 服务端口。现在我们输入 PING 命令。
redis 127.0.0.1:6379> ping
PONG
以上说明我们已经成功安装了redis。

Mac 安装

brew install redis

使用

https://www.cnblogs.com/zhangxinqi/p/8418545.html
https://www.cnblogs.com/wang-yc/p/5693288.html

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