python开发之redis

简介

　　redis是一个key-value存储系统，和Memcache类似，它支持存储的value类型相比而言较多，包括：String，list，set，zset，hash。这些数据类型都支持push/pop、add/remove及取交集、并集、差集以及更多的操作，而且这些操作都是原子性的，也就是安全的。还有redis支持各种不同方式的排序，与Memcache一样，为了保证效率，数据都是缓冲在内存中。区别在于redis会周期性的将更新的数据写入到磁盘或者把修改操作写入追加的记录文件，并且还实现了主从同步的功能。

备注：默认redis有16个数据库，即db0~db15，一般存取数据如果不指定库的话，默认都是存在db0中

安装redis模块

1、python想操作redis，需要安装第三方模块

sudo pip3 install redis
or
sudo easy_install redis
or
源码安装
详见：https://github.com/WoLpH/redis-py

注：如果ubuntu上默认有py2，安装redis会默认安装在py2下面，假如想在py3下使用redis，只要将redis mv到py3下即可，例如路径：

python@python:~$ /usr/local/lib/python3.5/dist-packages/redis/
python@python:~$ /usr/local/lib/python3.5/dist-packages/redis-2.10.6.dist-info/

　2、Ubuntu上安装redis

1）sudo apt-get install redis-server

2）Redis还有一个配置文件： /etc/redis/redis.conf

注释掉127.0.0.1，如果不注释掉只能在本地连接

3）重新启动Redis : sudo service redis restart

4）redis-cli进入redis命令行，如果改过配置文件的密码，会显示

get 'a'
(error) NOAUTH Authentication required

重新输入redis-cli -a myredisserver即可

redis模块基本使用

redis 模块使用可以分类为：

连接方式

连接池

操作

String操作
Hash操作
list操作
set操作
zset操作
管道
发布订阅

(1) 操作模式

redis提供两个类，Redis和StrictRedis，StrictRedis用于实现大部分官方的命令，Redis是StrictRedis的子类，用于向后兼用旧版本。

import redis
r = redis.Redis(host='0.0.0.0',port=6379)
# 如果要指定数据库，则r = redis.Redis(host='0.0.0.',port=6379,db=0)
r.set("name","john")
print(r.get("name"))
结果是：b'john'

从上面的结果看，redis取到的结果默认是字节byte，我们可以通过decode_responses=True来改成字符串

import redis
r = redis.Redis(host='0.0.0.0',port=6379,decode_responses=True)
# 如果要指定数据路，则r = redis.Redis(host='0.0.0.',port=6379,db=0)
r.set("name","john")
print(r.get("name"))
结果是：john

(2) 连接池

　　redis使用连接池(connection pool)来管理一个redis server 的所有连接，避免每次建立，释放连接的开销，默认每个Redis实例都会维护自己的一个连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

import redis
pool = redis.ConnectionPool(host='0.0.0.0',port=6379)
r = redis.Redis(connection_pool=pool)
r.set("age",19)
print(r.get("age"))
结果是：b'19'

(3) 数据操作

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
r = redis.Redis(host='0.0.0.0', port=6379)
r.set('age','20')
print(r.get('age'))

setnx(name,value)

设置值，只有name不存在时，执行设置操作（添加）
>>> import redis
>>> r = redis.Redis()
>>> r.setnx('sex','men') # 第一次设置时，键值不存在
True
>>> r.setnx('sex','women') # 第二次设置时，键值已经存在了
False
>>> r.get('sex')
b'men'

setex(name,value,time)

# 设置值
# 参数：time，过期时间（数字秒 或 timedelta对象）
>>> import redis
>>> r = redis.Redis()
>>> r.setex('sex','women','3') # 设置3秒过期
True
>>> print(r.get('sex')) # 过3秒后取出的值就是None
None

psetex(name,time_ms,value)

>>> import redis
>>> r = redis.Redis()
>>> r.psetex('sex','3','women')
True
>>> print(r.get('sex'))
None

mset(*args, **kwargs)

#批量设置值 
#mset(k1='v1', k2='v2')
>>> import redis
>>> r = redis.Redis()
>>> r.mset(name='egon',age=12)
True
>>> print(r.get('name'))
b'egon'
>>> print(r.get('age'))
b'12'

get(name)

>>> import redis
>>> r = redis.Redis()
>>> r.mset(name='egon',age=12)
True
>>> print(r.get('name'))
b'egon'
>>> print(r.get('age'))
b'12'

getrange(key, start, end)

>>> import redis
>>> r = redis.Redis()
>>> r.set("name",'alexegon')
True
>>> print(r.getrange('name',4,9))
b'egon'   # 取出egon

setrange(name,offset,value)

# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
# offset，字符串的索引，字节（一个汉字三个字节）
# value，要设置的值
>>> import redis
>>> r = redis.Redis()
>>> r.set("name",'alexegon')  # name的长度是8
True
>>> r.setrange('name',0,'wusir') # setrange后会占用之前name的位置
8
>>> print(r.get('name'))
b'wusirgon'

setbit(name,offset,value)

# 对name对应值的二进制表示的位进行操作
# 参数：
# name，redis的name
# offset，位的索引（将值变换成二进制后再进行索引）
# value，值只能是 1 或 0
# 注：如果在Redis中有一个对应： n1 = "foo"，
#那么字符串foo的二进制表示为：01100110 01101111 01101111
#所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
#那么最终二进制则变成 01100111 01101111 01101111，即："goo"
>>> import redis
>>> r = redis.Redis()
>>> r.set("name",'foo')
True
>>> r.get('name')
b'foo'
>>> r.setbit('name',7,1)
0
>>> r.get('name')
b'goo'
#######################################
>>> ord('f')
102
>>> bin(102)
'0b1100110'
>>> ord('o')
111
>>> bin(111)
'0b1101111'

getbit(name,offset)

# 获取name对应的值的二进制表示中的某位的值 （0或1）
>>> import redis
>>> r = redis.Redis()
>>> r.set('name','wusir')
True
>>> r.getbit('name',3)
1

bitcount(key,start=None,end=None)

# 获取name对应的值的二进制表示中 1 的个数
# 参数：
# key，Redis的name
# start，位起始位置
# end，位结束位置
>>> import redis
>>> r = redis.Redis()
>>> r.set('name','wusir')
True
>>> r.bitcount('name',0,5)
24

bitop(operation,dest,*keys)

# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
# 参数：
# operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
# dest, 新的Redis的name
# *keys,要查找的Redis的name
# 如：
bitop("AND", 'new_name', 'n1', 'n2', 'n3')
# 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
>>> import redis
>>> r = redis.Redis()
>>> r.set('n1','11')
True
>>> r.set('n2','22')
True
>>> r.set('n3','33')
True
>>> r.bitop('AND','new_name','n1','n2','n3')
2
>>> r.get('new_name')
b'00'

incr(self, name, amount = 1)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
# 参数：
# name,Redis的name
# amount,自增数（必须是整数）
# 注：同incrby
>>> import redis
>>> r = redis.Redis()
>>> r.set('name','2')
True
>>> r.incr('name','3')
5
>>> r.incr('name1','3')
3

incrbyfloat(self,name,amount=1.0)

# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
# 参数：
# name,Redis的name
# amount,自增数（浮点型）
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.set('byfloat','1')
print(r.incrbyfloat('byfloat','2.0'))
结果：
3.0

decr(self, name, amount=1)

# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
# 参数：
# name,Redis的name
# amount,自减数（整数）
>>> import redis
>>> r = redis.Redis()
>>> r.set('name','2')
True
>>> r.decr('name','3')
-1

append(key,value)

# 在redis name对应的值后面追加内容
# 参数：
key, redis的name
value, 要追加的字符串
>>> import redis
>>> r = redis.Redis()
>>> r.set('name','2')
True
>>> r.get('name')
b'2'
>>> r.append('name','3333')
5
>>> r.get('name')
b'23333'

Hash

hset(name,key,value)

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
# 参数：
# name，redis的name
# key，name对应的hash中的key
# value，name对应的hash中的value
# 注：
# hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'

hmset(name,mapping)

# 在name对应的hash中批量设置键值对
# 参数：
# name，redis的name
# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
# 如：
# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']

hgetall(name)

#获取name对应hash的所有键值
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']
>>> r.hgetall('name4')
{b'go': b'22222', b'python': b'1111'}

hlen(name)

# 获取name对应的hash中键值对的个数
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']
>>> r.hgetall('name4')
{b'go': b'22222', b'python': b'1111'}
>>> r.hlen('name4')
2

hkeys(name)

>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']
>>> r.hgetall('name4')
{b'go': b'22222', b'python': b'1111'}
>>> r.hlen('name4')
2
>>> r.hkeys('name4')
[b'go', b'python']

hvals(name)

# 获取name对应的hash中所有的value的值
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']
>>> r.hgetall('name4')
{b'go': b'22222', b'python': b'1111'}
>>> r.hlen('name4')
2
>>> r.hkeys('name4')
[b'go', b'python']
>>> r.hvals('name4')
[b'22222', b'1111']

hexists(name,key)

# 检查name对应的hash是否存在当前传入的key
>>> import redis
>>> r = redis.Redis()
>>> r.hset("name3",'python','1111')
1
>>> r.hget('name3','python')
b'1111'
>>> import redis
>>> r = redis.Redis()
>>> r.hmset("name4",{'python':'1111','go':'22222'})
True
>>> r.hmget('name4','python','go')
[b'1111', b'22222']
>>> r.hgetall('name4')
{b'go': b'22222', b'python': b'1111'}
>>> r.hlen('name4')
2
>>> r.hkeys('name4')
[b'go', b'python']
>>> r.hvals('name4')
[b'22222', b'1111']
>>> r.hexists('name4','python')
True

hdel(name,*key)

# 将name对应的hash中指定key的键值对删除
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.hmset('someset',{'k1':'v1','k2':'v2'})
print(r.hdel('someset','k1'))
print(r.hget('someset','k1'))

hincrby(name,key,amount=1)

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
#amount，自增数（整数)
r = redis.Redis(host='0.0.0.0', port=6379)
r.hmset('someset',{'k1':'1','k2':'v2'})
r.hincrby('someset','k1','2')
print(r.hget('someset','k1'))
结果：
b'3'

hincrbyfloat(name,key,amount=1.0)

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（浮点数）
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.hmset('someset',{'k1':'1.0','k2':'v2'})
print(r.hincrbyfloat('someset','k1','2.0'))
结果：
3.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时，表示数据已经通过分片获取完毕
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.hmset('someset',{'k1':'1.0','k2':'v2'})
print(r.hscan('someset',cursor=2, match=0, count=5))

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
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.hmset('someset',{'k1':'1.0','k2':'v2'})
for i in  r.hscan_iter('someset',match=None, count=None):
    print(i)
结果：
(b'k2', b'v2')
(b'k1', b'1.0')

List

lpush(name,values)

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
 
# 如：
# r.lpush('oo', 11,22,33)
# 保存顺序为: 33,22,11
# 扩展：
# rpush(name, values) 表示从右向左操作
>>> r.lpush('name','wusir','alex','egon')
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('name5','wusir','alex','egon')
3
>>> r.lrange('name5','0','2')
[b'egon', b'alex', b'wusir']

lpushx(name,value)

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
# 更多：
# rpushx(name, value) 表示从右向左操作
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('name11','11')
3
>>> r.lindex('name11','1')
b'11'

llen(name)

# name对应的list元素的个数
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('name11','11')
3
>>> r.lindex('name11','1')
b'11'
>>> r.llen('name11')
3

linsert(name,where,refvalue,value)

# 在name对应的列表的某一个值前或后插入一个新值
# 参数：
# name，redis的name
# where，BEFORE或AFTER
# refvalue，标杆值，即：在它前后插入数据
# value，要插入的数据
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('num1','11')
1
>>> r.lpush('num1','12')
2
>>> r.lpush('num1','13')
3
>>> r.linsert('num1','AFTER','13','14')
4
>>> r.lrange('num1','0','3')
[b'13', b'14', b'12', b'11']

r.lset(name,index,value)

# 对name对应的list中的某一个索引位置重新赋值
# 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('num1','11')
1
>>> r.lpush('num1','12')
2
>>> r.lpush('num1','13')
3
>>> r.linsert('num1','AFTER','13','14')
4
>>> r.lrange('num1','0','3')
[b'13', b'14', b'12', b'11']
>>> r.lset('num1','0','22')
True
>>> r.lrange('num1','0','3')
[b'22', b'14', b'12', b'11']

r.lrem(name,value,num)

在name对应的list中删除指定的值
 
# 参数：
# name，redis的name
# value，要删除的值
# num，  num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个;
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('num1','11')
1
>>> r.lpush('num1','12')
2
>>> r.lpush('num1','13')
3
>>> r.linsert('num1','AFTER','13','14')
4
>>> r.lrange('num1','0','3')
[b'13', b'14', b'12', b'11']
>>> r.lset('num1','0','22')
True
>>> r.lrange('num1','0','3')
[b'22', b'14', b'12', b'11']
>>> r.lrem('num1','14',num=1)  ###
1
>>> r.lrange('num1','0','3')
[b'22', b'12', b'11']

lpop(name)

# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
# 更多：
# rpop(name) 表示从右向左操作
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.lpush('num','33','44','55')
print(r.lpop('num'))
b'55'

lindex(name,index)

#在name对应的列表中根据索引获取列表元素
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.lpushx('num','33')   
print(r.lindex('num','0'))
结果：
b'33'

ltrim(name,start,end)

#在name对应的列表中移除没有在start-end索引之间的值
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('num1','11')
1
>>> r.lpush('num1','12')
2
>>> r.lpush('num1','13')
3
>>> r.linsert('num1','AFTER','13','14')
4
>>> r.lrange('num1','0','3')
[b'13', b'14', b'12', b'11']
>>> r.lset('num1','0','22')
True
>>> r.lrange('num1','0','3')
[b'22', b'14', b'12', b'11']
>>> r.lrem('num1','14',num=1)
1
>>> r.lrange('num1','0','3')
[b'22', b'12', b'11']
>>> r.ltrim('num1','0','1')
True
>>> r.lrange('num1','0','3')
[b'22', b'12']

lrange(name,start,end)

# 在name对应的列表分片获取数据
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.lpush('num','33','44','55')
print(r.lrange('num','0','2'))
结果：
[b'55', b'44', b'33']

rpoplpush(src,dst)

# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
# src，要取数据的列表的name
# dst，要添加数据的列表的name
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.lpush('num1','11','22','33')
r.lpush('num2','44','55','66')
r.rpoplpush('num1','num2')
print(r.lrange('num1','0','2'))
print(r.lrange('num2','0','3'))
结果：
[b'33', b'22', b'11']
[b'33', b'66', b'55', b'44']

blpop(keys,timeout)

# 将多个列表排列，按照从左到右去pop对应列表的元素
# 参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，
阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
# 更多：
# r.brpop(keys, timeout)，从右向左获取数据
>>> import redis
>>> r = redis.Redis()
>>> r.lpush('num3','11','22','33')
6
>>> r.lrange('num3','0','6')
[b'33', b'22', b'11', b'33', b'22', b'11']
>>> r.blpop('num3',timeout=5)
(b'num3', b'33')
>>> r.blpop('num3',timeout=5)
(b'num3', b'22')
>>> r.blpop('num3',timeout=5)
(b'num3', b'11')
>>> r.blpop('num3',timeout=5)
(b'num3', b'33')
>>> r.lrange('num3','0','6')
[b'22', b'11']

set

set集合不允许重复的列表

sadd(name,values)

# name对应的集合中添加元素
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex','11')
print(r.smembers('sex'))
结果：
{b'11'}

scard(name)

#获取name对应的集合中元素个数
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex','11')
print(r.scard('sex'))
结果：
1

sdiff(keys,*args)

#在第一个name对应的集合中且不在其他name对应的集合的元素集合
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','22','33')
r.sadd('sex2','22','33','55')
print(r.sdiff('sex1','sex2'))
结果:
{b'11'}

sdiffstore(dest,keys,*args)

# 获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
r.sadd('sex2','22','33','55')
r.sadd('sex3','66','77','88')
r.sdiffstore('sex4','sex1','sex2','sex3')
print(r.smembers('sex4'))
结果：
{b'44', b'11'}

sinter(keys,*args)

# 获取多一个name对应集合的并集
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
r.sadd('sex2','22','33','55')
r.sadd('sex3','66','77','88')
r.sinter('sex1','sex2',)
print(r.smembers('sex1'))
结果：
{b'44', b'11', b'22', b'33'}

sinterstore(dest,keys.*args)

# 获取多一个name对应集合的交集，再讲其加入到dest对应的集合中
>>> import redis
>>> r = redis.Redis()
>>> r.sadd("sex1",'11','44','55')
3
>>> r.sadd("sex2",'22','33','55')
3
>>> r.sinterstore("sex3","sex1","sex2")
1
>>> r.smembers("sex3")
{b'55'}

sismember(name,value)

# 检查value是否是name对应的集合的成员
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
print(r.sismember('sex1','11'))
结果：
True

smembers(name)

# 获取name对应的集合的所有成员
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
print(r.smembers('sex1'))
结果：
{b'11', b'44', b'33', b'22'}

smove(src,dst,value)

>>> import redis
>>> r = redis.Redis()
>>> r.sadd("age1","11","22",'33')
3
>>> r.sadd("age2","44","55",'66')
3
>>> r.smove("age1","ag2","11")
True
>>> r.smembers("ag2")
{b'11'}
>>> r.smove("age1","age2","11")
False
>>> r.smove("age2","age1","11")
False
>>> r.smove("age2","age1","44")
True
>>> r.smembers("age1")
{b'22', b'33', b'44'}
>>> r.smembers("age2")
{b'55', b'66'}

spop(name)

# 从集合的右侧（尾部）移除一个成员，并将其返回
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
print(r.smembers('sex1'))
print(r.spop('sex1'))

srandmember(name,numbers)

# 从name对应的集合中随机获取 numbers 个元素
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
print(r.srandmember('sex1','2'))
结果：
[b'44', b'11']

srem(name,values)

# 在name对应的集合中删除某些值
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.sadd('sex1','11','44','33')
r.srem('sex1','11')
print(r.smembers('sex1'))
结果：
{b'44', b'33'}

sunion(keys,*args)

>>> import redis
>>> r = redis.Redis()
>>> r.sadd("age1","11","22",'33')
3
>>> r.sadd("age3","44","55",'66')
3
>>> r.sunion("age1","age3")
{b'22', b'55', b'33', b'44', b'11', b'66'}

sunionstore(dest,keys,*args)

# 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
>>> import redis
>>> r.sadd("age4","44","55",'66')
3
>>> r.sadd("age5","77","55",'66')
3
>>> r.sunionstore("age6",'age4','age5')
4
>>> r.smembers('age6')
{b'55', b'66', b'77', b'44'}

其它常用操作

delete(*name)

# 根据删除redis中的任意数据类型
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.set('num','11')
print(r.get('num'))
r.delete('num')
print(r.get('num'))
结果：
b'11'
None

keys(pattern='*')

# 根据模型获取redis的name
 # 更多：
# KEYS * 匹配数据库中所有 key 。
# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
# KEYS h*llo 匹配 hllo 和 heeeeello 等。
# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
print(r.keys(pattern='*'))
结果：
[b'foo', b'num2', b'sex1', b'someset', b'noset', b'sex2', b'num',
b'role', b'name', b'num1', b'n3', b'newname', b'byfloat', b'n2',
b'ageno', b'name1', b'sex4', b'sex3', b'age', b'sex']

rename(src, dst)

# 对redis的name重命名为
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
r.set('xin','11')
print(r.get('xin'))
r.rename('xin','xin1')
print(r.get('xin1'))
结果：
b'11'
b'11'

randomkey()

# 随机获取一个redis的name（不删除）
import redis
r = redis.Redis(host='0.0.0.0', port=6379)
print(r.randomkey())
结果：
b'n2'

type(name)

# 获取name对应值的类型
>>> r = redis.Redis()
>>> r.set("name","wusir")
True
>>> r.type('name')
b'string'

管道

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

posted on 2018-07-27 00:38 Mr.Hui 阅读(112) 评论(0) 收藏举报

刷新页面返回顶部

Mr.Hui