redis 5种数据类型
string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。
redis 数据迁移
方式一：
使用python脚本迁移数据到另外一台服务器。缺点是需要检查数据的正确性。
rdm 访问 redis
centos 开启6379端口
bind 127.0.0.1 修改为：bind 0.0.0.0
protected-mode yes 改为 protected-mode no
## redis 设置密码访问
requirepass demo
redis 服务管理
# 服务操作命令
systemctl start redis.service #启动redis服务
systemctl stop redis.service #停止redis服务
systemctl restart redis.service #重新启动服务
systemctl status redis.service #查看服务当前状态
systemctl enable redis.service #设置开机自启动
systemctl disable redis.service #停止开机自启动
mac redis环境搭建
# 查找redis
➜ ~ brew search redis
==> Formulae
hiredis redis ✔ redis-leveldb [email protected] [email protected]
==> Casks
another-redis-desktop-manager redis redisinsight
# 安装redis
brew install redis
# 删除redis
brew uninstall redis
# 查看brew services列表
brew services list
Name Status User Plist
nginx started xxxx /Users/xxxx/Library/LaunchAgents/homebrew.mxcl.nginx.plist
php started xxxx /Users/xxxx/Library/LaunchAgents/homebrew.mxcl.php.plist
postgresql stopped
redis stopped
tomcat stopped
unbound stopped
# 启动redis
brew services start redis
# 停止redis
brew services stop redis
# 重启redis
brew services restart redis
➜ ~ which redis-server
/usr/local/bin/redis-server
➜ ~ redis-server
60641:C 08 Apr 2021 21:08:47.659 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
60641:C 08 Apr 2021 21:08:47.659 # Redis version=5.0.2, bits=64, commit=00000000, modified=0, pid=60641, just started
60641:C 08 Apr 2021 21:08:47.659 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
60641:M 08 Apr 2021 21:08:47.661 * Increased maximum number of open files to 10032 (it was originally set to 256).
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 5.0.2 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in standalone mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 6379
| `-._ `._ / _.-' | PID: 60641
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
60641:M 08 Apr 2021 21:08:47.665 # Server initialized
60641:M 08 Apr 2021 21:08:47.672 * DB loaded from disk: 0.007 seconds
60641:M 08 Apr 2021 21:08:47.672 * Ready to accept connections
# 开机启动redis
ln -sfv /usr/local/opt/redis/*.plist ~/Library/LaunchAgents
string
string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。value其实不仅是String，也可以是数字。string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。
常用命令：
常用命令：get、set、incr、decr、mget等。
127.0.0.1:6379> set name runoob #批量增加：mset
OK
127.0.0.1:6379> get name # 查：
"runoob"
127.0.0.1:6379> set name tom #直接覆盖
OK
127.0.0.1:6379> del name #删：
(integer) 1
hash
hash 是一个键值(key => value)对集合。Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。
id
id+label
value field
#增： 设置多个属性：hmset 001 name zsq age 18
127.0.0.1:6379> hmset 001 name zsq age 18
(integer) 1
# hgetall key #不需要具体字段，直接获取整个hash值
127.0.0.1:6379> hgetall 001
1) "name"
2) "zsq"
3) "age"
4) "18"
# 查：
127.0.0.1:6379> hget 001 name
"zsq"
#改：
127.0.0.1:6379> hset 001 name zcf #直接覆盖
(integer) 0
删：
127.0.0.1:6379> del 001
(integer) 1
#删掉hash的一个属性：
127.0.0.1:6379> hdel 001 age
(integer) 1
list
list 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
常用命令：lpush（添加左边元素）,rpush,lpop（移除左边第一个元素）,rpop,lrange（获取列表片段，LRANGE key start stop）等。
应用场景：Redis list的应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表等都可以用Redis的list结构来实现。
List 就是链表，相信略有数据结构知识的人都应该能理解其结构。使用List结构，我们可以轻松地实现最新消息排行等功能。List的另一个应用就是消息队列，
可以利用List的PUSH操作，将任务存在List中，然后工作线程再用POP操作将任务取出进行执行。Redis还提供了操作List中某一段的api，你可以直接查询，删除List中某一段的元素。
实现方式：Redis list的实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。
Redis的list是每个子元素都是String类型的双向链表，可以通过push和pop操作从列表的头部或者尾部添加或者删除元素，这样List即可以作为栈，也可以作为队列。 获取越接近两端的元素速度越快，但通过索引访问时会比较慢。
使用场景：消息队列系统：使用list可以构建队列系统，使用sorted set甚至可以构建有优先级的队列系统。比如：将Redis用作日志收集器，实际上还是一个队列，多个端点将日志信息写入Redis，然后一个worker统一将所有日志写到磁盘。
# 增：
127.0.0.1:6379> lpush list aa bb cc dd #lpush/rpush list XXX
(integer) 4
#查：
127.0.0.1:6379> LRANGE list 0 -1 #查询整个列表
1) "dd"
2) "cc"
3) "bb"
4) "aa"
#改：
127.0.0.1:6379> lset list 0 00 #修改需要指定到对应下标
OK
#删：
127.0.0.1:6379> del list #删除整个列表
(integer) 1
127.0.0.1:6379> lrem list 1 aa #从列表list左边开始删除1个aa的值
(integer) 1
LREM解释
LREM key count value
根据参数 count 的值，移除列表中与参数 value 相等的元素。
count 的值可以是以下几种：
- count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。
- count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。
- count = 0 : 移除表中所有与 value 相等的值。
set
set是string类型的无序集合。集合是通过hashtable实现的，概念和数学中个的集合基本类似，可以交集，并集，差集等等，set中的元素是没有顺序的。所以添加，删除，查找的复杂度都是O(1)。
sadd 命令：添加一个 string 元素到 key 对应的 set 集合中，成功返回1，如果元素已经在集合中返回 0，如果 key 对应的 set 不存在则返回错误。
常用命令：sadd,spop,smembers,sunion 等。
应用场景：Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
Set 就是一个集合，集合的概念就是一堆不重复值的组合。利用Redis提供的Set数据结构，可以存储一些集合性的数据。
案例：在微博中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis还为集合提供了求交集、并集、差集等操作，可以非常方便的实现如共同关注、共同喜好、二度好友等功能，对上面的所有集合操作，你还可以使用不同的命令选择将结果返回给客户端还是存集到一个新的集合中。
实现方式： set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。
# 增：
127.0.0.1:6379> sadd ss aa bb cc
(integer) 3
# 删：
127.0.0.1:6379> SREM ss bb
(integer) 1
# 查：
127.0.0.1:6379> SMEMBERS ss
1) "bb"
2) "cc"
3) "aa"
zset
zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
zadd 命令：添加元素到集合，元素在集合中存在则更新对应score。
常用命令：zadd,zrange,zrem,zcard等
使用场景：Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构，比如twitter 的public timeline可以以发表时间作为score来存储，这样获取时就是自动按时间排好序的。和Set相比，Sorted Set关联了一个double类型权重参数score，使得集合中的元素能够按score进行有序排列，redis正是通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的,但分数(score)却可以重复。比如一个存储全班同学成绩的Sorted Set，其集合value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然的排序。另外还可以用Sorted Set来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒序来获取工作任务。让重要的任务优先执行。
实现方式：Redis sorted set的内部使用HashMap和跳跃表(SkipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。
zset score
# 增：
127.0.0.1:6379> zadd zz 1 zz1
(integer) 1
127.0.0.1:6379> zadd zz 2 zz2
(integer) 1
127.0.0.1:6379> zadd zz 3 zz3
(integer) 1
# 查：
127.0.0.1:6379> ZRANGE zz 0 -1
1) "zz1"
2) "zz2"
3) "zz3"
# 删：
127.0.0.1:6379> ZREM zz zz2
(integer) 1
# 集合中元素数量：
127.0.0.1:6379> ZCARD zz
(integer) 2
Redis 指定decode_responses=True
连接redis:
decode_responses=True:这样写存的数据是字符串格式
import redis
try:
self._redis = redis.Redis(host=ip, port=port, db=db, password=passwd, decode_responses=decode_responses) # redis默认端口是6379
self._redis.ping()
except Exception as e:
input('''
******************************************
未链接到redis数据库，
您当前的链接信息为：
ip = {}
port = {}
db = {}
passwd = {}
请参考教程正确安装配置redis，然后重启本程序
Exception: {}'''.format(ip, port, db, passwd, str(e))
)
import sys
sys.exit()
python redis
文件参考来源 redisdb.py
striver-ing/wechat-spider
# -*- coding: utf-8 -*-
'''
Created on 2016-11-16 16:25
---------
@summary: 操作redis数据库
---------
@author: Boris
'''
from utils.log import log
import redis
# setting.REDISDB_DB = 0
# setting.REDISDB_IP_PORTS = 'localhost:6379'
# setting.REDISDB_USER_PASS = None
class RedisDB():
def __init__(self, ip=None, port=None, db=None, passwd=None, decode_responses=True):
self._is_redis_cluster = False
try:
self._redis = redis.Redis(host=ip, port=port, db=db, password=passwd, decode_responses=decode_responses) # redis默认端口是6379
self._redis.ping()
except Exception as e:
input('''
******************************************
未链接到redis数据库，
您当前的链接信息为：
ip = {}
port = {}
db = {}
passwd = {}
请参考教程正确安装配置redis，然后重启本程序
Exception: {}'''.format(ip, port, db, passwd, str(e))
)
import sys
sys.exit()
def sadd(self, table, values):
'''
@summary: 使用无序set集合存储数据， 去重
---------
@param table:
@param values: 值； 支持list 或 单个值
---------
@result: 若库中存在 返回0，否则入库，返回1。 批量添加返回None
'''
if isinstance(values, list):
# redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
pipe = self._redis.pipeline(transaction=True)
if not self._is_redis_cluster:
pipe.multi()
for value in values:
pipe.sadd(table, value)
pipe.execute()
else:
return self._redis.sadd(table, values)
def sget(self, table, count=1, is_pop=True):
'''
返回 list 如 ['1'] 或 []
@param table:
@param count:
@param is_pop:
@return:
'''
datas = []
if is_pop:
count = count if count <= self.sget_count(table) else self.sget_count(table)
if count:
if count > 1:
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi()
while count:
pipe.spop(table)
count -= 1
datas = pipe.execute()
else:
datas.append(self._redis.spop(table))
else:
datas = self._redis.srandmember(table, count)
return datas
def srem(self, table, values):
'''
@summary: 移除集合中的指定元素
---------
@param table:
@param values: 一个或者列表
---------
@result:
'''
if isinstance(values, list):
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi()
for value in values:
pipe.srem(table, value)
pipe.execute()
else:
self._redis.srem(table, values)
def sget_count(self, table):
return self._redis.scard(table)
def sdelete(self, table):
'''
@summary: 删除set集合的大键（数据量大的表）
删除大set键，使用sscan命令，每次扫描集合中500个元素，再用srem命令每次删除一个键
若直接用delete命令，会导致Redis阻塞，出现故障切换和应用程序崩溃的故障。
---------
@param table:
---------
@result:
'''
# 当 SCAN 命令的游标参数被设置为 0 时， 服务器将开始一次新的迭代， 而当服务器向用户返回值为 0 的游标时， 表示迭代已结束
cursor = '0'
while cursor != 0:
cursor, data = self._redis.sscan(table, cursor=cursor, count=500)
for item in data:
# pipe.srem(table, item)
self._redis.srem(table, item)
# pipe.execute()
def zadd(self, table, values, prioritys=0):
'''
@summary: 使用有序set集合存储数据， 去重(值存在更新)
---------
@param table:
@param values: 值； 支持list 或 单个值
@param prioritys: 优先级； double类型，支持list 或 单个值。 根据此字段的值来排序, 值越小越优先。 可不传值，默认value的优先级为0
---------
@result:若库中存在 返回0，否则入库，返回1。 批量添加返回 [0, 1 ...]
'''
if isinstance(values, list):
if not isinstance(prioritys, list):
prioritys = [prioritys] * len(values)
else:
assert len(values) == len(prioritys), 'values值要与prioritys值一一对应'
pipe = self._redis.pipeline(transaction=True)
if not self._is_redis_cluster:
pipe.multi()
for value, priority in zip(values, prioritys):
if self._is_redis_cluster:
pipe.zadd(table, priority, value)
else:
pipe.zadd(table, value, priority)
return pipe.execute()
else:
if self._is_redis_cluster:
return self._redis.zadd(table, prioritys, values)
else:
return self._redis.zadd(table, values, prioritys)
def zget(self, table, count=1, is_pop=True):
'''
@summary: 从有序set集合中获取数据 优先返回分数小的（优先级高的）
---------
@param table:
@param count: 数量 -1 返回全部数据
@param is_pop:获取数据后，是否在原set集合中删除，默认是
---------
@result: 列表
'''
start_pos = 0 # 包含
end_pos = count - 1 if count > 0 else count
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi() # 标记事务的开始 参考 http://www.runoob.com/redis/redis-transactions.html
pipe.zrange(table, start_pos, end_pos) # 取值
if is_pop:
pipe.zremrangebyrank(table, start_pos, end_pos) # 删除
results, *count = pipe.execute()
return results
def zremrangebyscore(self, table, priority_min, priority_max):
'''
根据分数移除成员 闭区间
@param table:
@param priority_min:
@param priority_max:
@return: 被移除的成员个数
'''
return self._redis.zremrangebyscore(table, priority_min, priority_max)
def zrangebyscore(self, table, priority_min, priority_max, count=None, is_pop=True):
'''
@summary: 返回指定分数区间的数据 闭区间
---------
@param table:
@param priority_min: 优先级越小越优先
@param priority_max:
@param count: 获取的数量，为空则表示分数区间内的全部数据
@param is_pop: 是否删除
---------
@result:
'''
# 使用lua脚本， 保证操作的原子性
lua = '''
local key = KEYS[1]
local min_score = ARGV[2]
local max_score = ARGV[3]
local is_pop = ARGV[4]
local count = ARGV[5]
-- 取值
local datas = nil
if count then
datas = redis.call('zrangebyscore', key, min_score, max_score, 'limit', 0, count)
else
datas = redis.call('zrangebyscore', key, min_score, max_score)
end
-- 删除redis中刚取到的值
if (is_pop) then
for i=1, #datas do
redis.call('zrem', key, datas[i])
end
end
return datas
'''
cmd = self._redis.register_script(lua)
if count:
res = cmd(keys=[table], args=[table, priority_min, priority_max, is_pop, count])
else:
res = cmd(keys=[table], args=[table, priority_min, priority_max, is_pop])
return res
def zrangebyscore_increase_score(self, table, priority_min, priority_max, increase_score, count=None):
'''
@summary: 返回指定分数区间的数据 闭区间， 同时修改分数
---------
@param table:
@param priority_min: 最小分数
@param priority_max: 最大分数
@param increase_score: 分数值增量 正数则在原有的分数上叠加，负数则相减
@param count: 获取的数量，为空则表示分数区间内的全部数据
---------
@result:
'''
# 使用lua脚本， 保证操作的原子性
lua = '''
local key = KEYS[1]
local min_score = ARGV[1]
local max_score = ARGV[2]
local increase_score = ARGV[3]
local count = ARGV[4]
-- 取值
local datas = nil
if count then
datas = redis.call('zrangebyscore', key, min_score, max_score, 'limit', 0, count)
else
datas = redis.call('zrangebyscore', key, min_score, max_score)
end
--修改优先级
for i=1, #datas do
redis.call('zincrby', key, increase_score, datas[i])
end
return datas
'''
cmd = self._redis.register_script(lua)
if count:
res = cmd(keys=[table], args=[priority_min, priority_max, increase_score, count])
else:
res = cmd(keys=[table], args=[priority_min, priority_max, increase_score])
return res
def zrangebyscore_set_score(self, table, priority_min, priority_max, score, count=None):
'''
@summary: 返回指定分数区间的数据 闭区间， 同时修改分数
---------
@param table:
@param priority_min: 最小分数
@param priority_max: 最大分数
@param score: 分数值
@param count: 获取的数量，为空则表示分数区间内的全部数据
---------
@result:
'''
# 使用lua脚本， 保证操作的原子性
lua = '''
local key = KEYS[1]
local min_score = ARGV[1]
local max_score = ARGV[2]
local set_score = ARGV[3]
local count = ARGV[4]
-- 取值
local datas = nil
if count then
datas = redis.call('zrangebyscore', key, min_score, max_score, 'withscores','limit', 0, count)
else
datas = redis.call('zrangebyscore', key, min_score, max_score, 'withscores')
end
local real_datas = {} -- 数据
--修改优先级
for i=1, #datas, 2 do
local data = datas[i]
local score = datas[i+1]
table.insert(real_datas, data) -- 添加数据
redis.call('zincrby', key, set_score - score, datas[i])
end
return real_datas
'''
cmd = self._redis.register_script(lua)
if count:
res = cmd(keys=[table], args=[priority_min, priority_max, score, count])
else:
res = cmd(keys=[table], args=[priority_min, priority_max, score])
return res
def zget_count(self, table, priority_min=None, priority_max=None):
'''
@summary: 获取表数据的数量
---------
@param table:
@param priority_min:优先级范围 最小值（包含）
@param priority_max:优先级范围 最大值（包含）
---------
@result:
'''
if priority_min != None and priority_max != None:
return self._redis.zcount(table, priority_min, priority_max)
else:
return self._redis.zcard(table)
def zrem(self, table, values):
'''
@summary: 移除集合中的指定元素
---------
@param table:
@param values: 一个或者列表
---------
@result:
'''
if isinstance(values, list):
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi()
for value in values:
pipe.zrem(table, value)
pipe.execute()
else:
self._redis.zrem(table, values)
def zexists(self, table, values):
'''
利用zscore判断某元素是否存在
@param values:
@return:
'''
is_exists = []
if isinstance(values, list):
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
pipe.multi()
for value in values:
pipe.zscore(table, value)
is_exists_temp = pipe.execute()
for is_exist in is_exists_temp:
if is_exist != None:
is_exists.append(1)
else:
is_exists.append(0)
else:
is_exists = self._redis.zscore(table, values)
is_exists = 1 if is_exists != None else 0
return is_exists
def lpush(self, table, values):
if isinstance(values, list):
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi()
for value in values:
pipe.rpush(table, value)
pipe.execute()
else:
return self._redis.rpush(table, values)
def lpop(self, table, count=1):
'''
@summary:
---------
@param table:
@param count:
---------
@result: count>1时返回列表
'''
datas = None
count = count if count <= self.lget_count(table) else self.lget_count(table)
if count:
if count > 1:
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
if not self._is_redis_cluster:
pipe.multi()
while count:
pipe.lpop(table)
count -= 1
datas = pipe.execute()
else:
datas = self._redis.lpop(table)
return datas
def rpoplpush(self, from_table, to_table=None):
'''
将列表 from_table 中的最后一个元素(尾元素)弹出，并返回给客户端。
将 from_table 弹出的元素插入到列表 to_table ，作为 to_table 列表的的头元素。
如果 from_table 和 to_table 相同，则列表中的表尾元素被移动到表头，并返回该元素，可以把这种特殊情况视作列表的旋转(rotation)操作
@param from_table:
@param to_table:
@return:
'''
if not to_table:
to_table = from_table
return self._redis.rpoplpush(from_table, to_table)
def lget_count(self, table):
return self._redis.llen(table)
def lrem(self, table, value, num=0):
return self._redis.lrem(table, value, num)
def hset(self, table, key, value):
'''
@summary:
如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。
如果域 field 已经存在于哈希表中，旧值将被覆盖
---------
@param table:
@param key:
@param value:
---------
@result: 1 新插入； 0 覆盖
'''
return self._redis.hset(table, key, value)
def hincrby(self, table, key, increment):
return self._redis.hincrby(table, key, increment)
def hget(self, table, key, is_pop=False):
if not is_pop:
return self._redis.hget(table, key)
else:
lua = '''
local key = KEYS[1]
local field = ARGV[1]
-- 取值
local datas = redis.call('hget', key, field)
-- 删除值
redis.call('hdel', key, field)
return datas
'''
cmd = self._redis.register_script(lua)
res = cmd(keys=[table], args=[key])
return res
def hgetall(self, table):
return self._redis.hgetall(table)
def hexists(self, table, key):
return self._redis.hexists(table, key)
def hdel(self, table, *keys):
'''
@summary: 删除对应的key 可传多个
---------
@param table:
@param *keys:
---------
@result:
'''
self._redis.hdel(table, *keys)
def hget_count(self, table):
return self._redis.hlen(table)
def setbit(self, table, offsets, values):
'''
设置字符串数组某一位的值， 返回之前的值
@param table:
@param offsets: 支持列表或单个值
@param values: 支持列表或单个值
@return: list / 单个值
'''
if isinstance(offsets, list):
if not isinstance(values, list):
values = [values] * len(offsets)
else:
assert len(offsets) == len(values), 'offsets值要与values值一一对应'
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
pipe.multi()
for offset, value in zip(offsets, values):
pipe.setbit(table, offset, value)
return pipe.execute()
else:
return self._redis.setbit(table, offsets, values)
def getbit(self, table, offsets):
'''
取字符串数组某一位的值
@param table:
@param offsets: 支持列表
@return: list / 单个值
'''
if isinstance(offsets, list):
pipe = self._redis.pipeline(transaction=True) # redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
pipe.multi()
for offset in offsets:
pipe.getbit(table, offset)
return pipe.execute()
else:
return self._redis.getbit(table, offsets)
def bitcount(self, table):
return self._redis.bitcount(table)
def strset(self, table, value, **kwargs):
return self._redis.set(table, value, **kwargs)
def strget(self, table):
return self._redis.get(table)
def strlen(self, table):
return self._redis.strlen(table)
def getkeys(self, regex):
return self._redis.keys(regex)
def exists_key(self, key):
return self._redis.exists(key)
def set_expire(self, key, seconds):
'''
@summary: 设置过期时间
---------
@param key:
@param seconds: 秒
---------
@result:
'''
self._redis.expire(key, seconds)
def clear(self, table):
try:
self._redis.delete(table)
except Exception as e:
log.error(e)
def get_redis_obj(self):
return self._redis
if __name__ == '__main__':
db = RedisDB(ip='127.0.0.1', port=6379, db=0, passwd=None)
data = db.hgetall('myhash')
print(data)
参考
Centos7安装Redis
https://www.cnblogs.com/jasonZh/p/9513948.html