Python使用Redis数据库
Redis 简介
Redis是开源的高性能Key-Value数据库,可以用于缓存等用途.
Redis可以提供事务和持久化支持保证并发安全性,并提供TTL(time to life)服务.
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提供的所有特性中，我感觉这个是喜欢的人最少的一个，虽然它为用户提供如果此多功能。
使用Redis
Ubuntu系统可以用包管理器安装Redis服务:
sudo apt-get install redis-server
并安装客户端:
sudo apt-get install redis-tools
进入Redis客户端
redis-cli
登录远程Redis服务
redis-cli -h host -p port -a password
Redis基本操作指令
redis.conf 配置项说明如下：
1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程
daemonize no
2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定
pidfile /var/run/redis.pid
3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字
port 6379
4. 绑定的主机地址
bind 127.0.0.1
5.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
timeout 300
6. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
loglevel verbose
7. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null
logfile stdout
8. 设置数据库的数量，默认数据库为0，可以使用SELECT
databases 16
9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
save
Redis默认配置文件中提供了三个条件：
save 900 1
save 300 10
save 60 10000
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。
10. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
rdbcompression yes
11. 指定本地数据库文件名，默认值为dump.rdb
dbfilename dump.rdb
12. 指定本地数据库存放目录
dir ./
13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
slaveof
14. 当master服务设置了密码保护时，slav服务连接master的密码
masterauth
15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH
requirepass foobared
16. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
maxclients 128
17. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
maxmemory
18. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
19. 指定更新日志文件名，默认为appendonly.aof
appendfilename appendonly.aof
20. 指定更新日志条件，共有3个可选值：
no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折中，默认值）
appendfsync everysec
21. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）
vm-enabled no
22. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
vm-max-memory 0
24. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值
vm-page-size 32
25. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。
vm-pages 134217728
26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4
vm-max-threads 4
27. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启
glueoutputbuf yes
28. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512
29. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）
activerehashing yes
30. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件
include /path/to/local.conf
Redis的Key-Value均为大小写敏感的,但是Redis指令对大小写不敏感.
Redis使用字符串作为Key,常用操作命令有:
SET key val
设置键值对,无则新建有则更新
127.0.0.1:6379> set user name
OKDEL key
删除键值对, 返回删除的条数
127.0.0.1:6379> del user
(integer) 1GET key
返回Value
127.0.0.1:6379> get user
"name"EXISTS key
检查指定键值对是否存在
127.0.0.1:6379> exists user
(integer) 1KEYS pattern
使用通配符筛选显示所有符合条件的键
127.0.0.1:6379> keys *
1) "playing_yichya"
2) "playing_yy"
3) "online_yichya"
4) "user"
5) "online_yy"
127.0.0.1:6379> keys *_*
1) "playing_yichya"
2) "playing_yy"
3) "online_yichya"
4) "online_yy"RANDOMKEY
随机返回一个键
127.0.0.1:6379> randomkey
"hm1"RENAME key newname
重命名键
127.0.0.1:6379> set user2 234
OK
127.0.0.1:6379> set user 233
OK
127.0.0.1:6379> rename user user2
OK
127.0.0.1:6379> get user
(nil)RENAMEX key newname
重命名键, 不允许新名与已有的键名重复
QUIT
退出redis客户端
Redis TTL服务命令
EXPIRE key seconds
以秒为单位,指定键值对的生存周期
127.0.0.1:6379> expire user 10000
(integer) 1PEXIRE key mseconds
以毫秒为单位,指定键值对的生存周期
TTL key
以秒为单位,返回键值对的剩余生存周期
127.0.0.1:6379> ttl user
(integer) 9996PTTL key
以毫秒为单位,返回键值对的剩余生存周期
127.0.0.1:6379> pttl user
(integer) 9991684PERSIST key
将键值对的生存周期设为永久
127.0.0.1:6379> persist user
(integer) 1EXPIREAT key timestamp
使用Unix时间戳指定过期时间
Redis哈希命令
Redis哈希命令以Hash表作为数据结构, Hash表中所有键值对共享同样的TTL,并有着比通常键值对更快的操作速度.
HSET table key val
示例:
127.0.0.1:6379> hset hml yichya 233
(integer) 1执行keys和hkeys命令,可以看出hash表的数据结构
127.0.0.1:6379> keys *
1) "hml"
2) "user"
127.0.0.1:6379> hkeys hml
1) "yichya"HDEL table key
删除键
HGET table key
得到键值对
HKEYS tabel
得到哈希表上所有键
HGETALL table
返回所有key和value
127.0.0.1:6379> hgetall hml
1) "yichya"
2) "233"Redis事务支持
MULTI
开启事务块
127.0.0.1:6379> multi
OKEXEC
提交事务执行
DISCARD
放弃事务
WATCH key [key ...]
WATCH命令在事务执行之前监控Keys.
若在WATCH之后有任何Key的值发生了变化，EXEC命令执行的事务都将被放弃，同时返回Null multi-bulk
UNWATCH
放弃所有WATCH
Python使用Redis数据库
redis-py是常用的python-redis连接器,使用python包管理器安装此模块:
pip install redis
在Python环境下导入redis模块
>>> from redis import Redis>>> r = Redis()
Redis是封装了Redis数据库操作的类,并提供了类似的API.
使用JSON存储
除Redis-Hash表之外,redis-py将键值都作为字符串处理
>>> r.set('user', 233)
True
>>> r.get('user')
'233'对于复杂数据类型,处理返回的字符串非常不便:
>>> r.set('user', [1,[{'name':'yichya'}]])
True
>>> r.get('user')
"[1, [{'name': 'yichya'}]]"
>>> result = r.get('user')
>>> list(result)
['[', '1', ',', ' ', '[', '{', "'", 'n', 'a', 'm', 'e', "'", ':', ' ', "'", 'y', 'i', 'c', 'h', 'y', 'a', "'", '}', ']', ']']可以选择使用JSON作为存储类型,并以python内置json模块进行编码和解码.
另外,一个redis实例只维护一个数据表而应用中经常出现需要维护多个字典的情况.
草民建议使用prefix+key作为redis的键来模拟多个数据表.
草民写了一个简单的Redis-dict适配器,允许以类似字典的方式操作Redis数据库:
from redis import Redis
import json
class RedisDict:
def __init__(self, prefix=''):
self.data = Redis()
self.prefix = prefix
def get(self, key):
redis_key = self.prefix + '_' + key
redis_val = self.data.get(redis_key)
if redis_val is None:
return None
else:
return json.loads(redis_val)
def set(self, key, val):
redis_key = self.prefix + '_' + key
redis_val = json.dumps(val)
self.data.set(redis_key, redis_val)
def pop(self, key):
redis_key = self.prefix + '_' + key
self.data.delete(redis_key)
def __iter__(self):
for item in self.data.keys(self.prefix + '*'):
prefix, key = decode(item)
yield key
def decode(redis_key):
sep = redis_key.find('_')
prefix = redis_key[:sep]
key = redis_key[sep+1:]
return prefix, key
if __name__ == '__main__':
r = RedisCache('online')
r.set('user', [1,[{'name':'yichya'}]])
for item in r:
print(item)
print(r.get(item))hash表操作
redis-py的hash操作与redis命令类似:
from redis import Redis
import json
class RedisDict:
def __init__(self, table):
self.session = Redis()
self.table = table
self.session.delete(table)
def get(self, key):
redis_val = self.session.hget(self.table, key)
if redis_val is None:
return None
else:
return json.loads(redis_val)
def set(self, key, val):
redis_val = json.dumps(val)
self.session.hset(self.table, key, redis_val)
def pop(self, key):
self.session.hdel(self.table, key)
def __iter__(self):
for key in self.session.hkeys(self.table):
yield key用hash表模拟dict,这个实现比用前缀区分高效得多.
pipeline操作
Redis-Server是一个TCP服务器,使用pipline维护消息队列可以提高批量处理的效率.
>>> p = r.pipeline()
>>> p.set('yichya', 2333)
Pipeline>>
>>> p.get('yichya')
Pipeline>>
>>> p.execute()
[True, '2333'] redis提供五种数据类型：string，hash，list，set及zset(sorted set)。
1. 安装redis模块
| 1 |
|
2. redis模块介绍
redis-py 的API的使用可以分类为：
- 连接方式
- 连接池
- 操作
- String 操作
- Hash 操作
- List 操作
- Set 操作
- Sort Set 操作
- 管道
- 发布订阅
3. 操作模式
redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
| 1 2 3 4 5 6 7 8 9 10 11 12 |
|
4. 连接池
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
5. String操作
String操作，redis中的String在在内存中按照一个name对应一个value来存储
5.1 set(name, value, ex=None, px=None, nx=False, xx=False)
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，当前set操作才执行
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
|
基于这个命令的变种：
setnx(name, value) 设置值，只有name不存在时，执行设置操作（添加）
setex(name, value, time) 设置值， time，过期时间（数字秒 或 timedelta对象）
psetex(name, time_ms, value) 设置值，time_ms，过期时间（数字毫秒 或 timedelta对象）
mset(*args, **kwargs) 批量设置值，mset(k1='v1', k2='v2') 或 mset({'k1': 'v1', 'k2': 'v2'})
getset(name, value)
| 1 |
|
getrange(key, start, end)
| 1 2 3 4 5 6 |
|
setrange(name, offset, value)
| 1 2 3 4 |
|
setbit(name, offset, value)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
|
getbit(name, offset)
| 1 |
|
bitcount(key, start=None, end=None)
| 1 2 3 4 5 |
|
bitop(operation, dest, *keys)
| 1 2 3 4 5 6 7 8 9 10 |
|
strlen(name)
| 1 |
|
incr(self, name, amount=1)
| 1 2 3 4 5 6 7 |
|
incrbyfloat(self, name, amount=1.0)
| 1 2 3 4 5 |
|
decr(self, name, amount=1)
| 1 2 3 4 5 |
|
append(key, value)
| 1 2 3 4 5 |
|
6. Hash操作
Hash操作，redis中Hash在内存中的存储格式如下图：
hset(name, key, value)
| 1 2 3 4 5 6 7 8 9 |
|
hmset(name, mapping)
| 1 2 3 4 5 6 7 8 |
|
hget(name,key)
| 1 |
|
hmget(name, keys, *args)
| 1 2 3 4 5 6 7 8 9 10 11 |
|
hgetall(name)
| 1 |
|
hlen(name)
| 1 |
|
hkeys(name)
| 1 |
|
hvals(name)
| 1 |
|
hexists(name, key)
| 1 |
|
hdel(name,*keys)
| 1 |
|
hincrby(name, key, amount=1)
| 1 2 3 4 5 |
|
hincrbyfloat(name, key, amount=1.0)
| 1 2 3 4 5 6 7 8 |
|
hscan(name, cursor=0, match=None, count=None)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
|
hscan_iter(name, match=None, count=None)
| 1 2 3 4 5 6 7 8 9 |
|
7. List操作
List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：
lpush(name,values)
| 1 2 3 4 5 6 7 8 |
|
lpushx(name,value)
| 1 2 3 4 |
|
llen(name)
| 1 |
|
linsert(name, where, refvalue, value))
| 1 2 3 4 5 6 7 |
|
r.lset(name, index, value)
| 1 2 3 4 5 6 |
|
r.lrem(name, value, num)
| 1 2 3 4 5 6 7 8 |
|
lpop(name)
| 1 2 3 4 |
|
lindex(name, index)
| 1 |
|
lrange(name, start, end)
| 1 2 3 4 5 |
|
ltrim(name, start, end)
| 1 2 3 4 5 |
|
rpoplpush(src, dst)
| 1 2 3 4 |
|
blpop(keys, timeout)
| 1 2 3 4 5 6 7 8 |
|
brpoplpush(src, dst, timeout=0)
| 1 2 3 4 5 6 |
|
自定义增量迭代
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
8. Set操作
sadd(name,values)
| 1 |
|
scard(name)
| 1 |
|
sdiff(keys, *args)
| 1 |
|
sdiffstore(dest, keys, *args)
| 1 |
|
sinter(keys, *args)
| 1 |
|
sinterstore(dest, keys, *args)
| 1 |
|
sismember(name, value)
| 1 |
|
smembers(name)
| 1 |
|
smove(src, dst, value)
| 1 |
|
spop(name)
| 1 |
|
srandmember(name, numbers)
| 1 |
|
srem(name, values)
| 1 |
|
sunion(keys, *args)
| 1 |
|
sunionstore(dest,keys, *args)
| 1 |
|
sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)
| 1 |
|
9. Zset操作
有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
zadd(name, *args, **kwargs)
| 1 2 3 4 5 |
|
zcard(name)
| 1 |
|
zcount(name, min, max)
| 1 |
|
zincrby(name, value, amount)
| 1 |
|
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
zrank(name, value)
| 1 2 3 4 |
|
zrangebylex(name, min, max, start=None, num=None)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
|
zrem(name, values)
| 1 2 3 |
|
zremrangebyrank(name, min, max)
| 1 |
|
zremrangebyscore(name, min, max)
| 1 |
|
zremrangebylex(name, min, max)
| 1 |
|
zscore(name, value)
| 1 |
|
zinterstore(dest, keys, aggregate=None)
| 1 2 |
|
zunionstore(dest, keys, aggregate=None)
| 1 2 |
|
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
| 1 |
|
10. 其他常用操作
delete(*names)
| 1 |
|
exists(name)
| 1 |
|
keys(pattern='*')
| 1 2 3 4 5 6 7 |
|
expire(name ,time)
| 1 |
|
rename(src, dst)
| 1 |
|
move(name, db))
| 1 |
|
randomkey()
| 1 |
|
type(name)
| 1 |
|
scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)
| 1 |
|
四、Redis之管道
管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能，避免每次建立、释放连接的开销。并且默认情况下,一次pipline 是原子性操作
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
|
当然，也支持管道的命令放在一起
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
|
五、Redis之发布订阅
订阅者可以订阅一个或多个频道，发布者向一个频道发送消息后，所有订阅这个频道的订阅者都将收到消息，而发布者也将收到一个数值，这个数值是收到消息的订阅者的数量。订阅者只能收到自它开始订阅后发布者所发布的消息，之前发布的消息呢，就不可能收到了。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
|
参考链接:
Redis官网
redis-py
Redis 教程
使用Python操作Redis