Redis-API

简介

Redis 是一个基于内存的高效的键值行非关系型数据库，存取效率极高。

python提供了两个类：分别为Redis和StrictRedis来实现Redis的命令操作。Redis是StrictRedis的子类

官方推荐使用StrictRedis

如果要做数据导入、导出操作的话，还需要安装RedisDump。

 

出现拒绝连接，如果不是本机连接，就需要修改远程redis的配置文件。

 cd /etc/redis/  # 有的配置文件就在/etc/目录下
 ​
 sudo vim redis.conf
 # 修改 bind 为 0.0.0.0 ::1
 bind 0.0.0.0 ::1
 ​
 # 如果想使用密码，启用下面这行，foobared就是默认的密码，也可以自行修改
 # requirepass foobared      # 去掉注释, 那么连接时也要密码，不推荐启用
 ​
 service redis-server restart    # 重启服务
 ​
 # 设置端口转发为 6379

 

连接Redis-api

 import redis
 ​
 client = redis.StrictRedis(host='127.0.0.1', port=6379, db=1, password=None, decode_responses=True)     # 密码在redis中的配置文件，如果启用就要传递
 # decode_responses 默认False 那么redis返回的是二进制，是True则返回字符串
 ​
 默认参数如下：
 # def __init__(self, host='localhost', port=6379,
 #                 db=0, password=None, decode_responses=False
 #           ... ）
 ​
 client.set('name'，'Jack', ex=10)    # ex为设置的过期时间,单位为秒，默认为None
 print(client.get('name'))

 

全局键（key）操作

方法参数说明示例
keys(pattern='*') pattern匹配规则 获取所有符合规则的键 client.keys('n*')
exists(name) name: 键名 判断该键是否存在，返回Bool类型 client.exists('username')
delete(*name) *name: 键名 删除一个或多个键 client.delete('name')
type(name) name:键名 查看这个键的类型 client.type('name')
rename(src, dst) src: 原键名 dst: 新键名 重命名键 client.rename('name', 'username')
dbsize()   获取当前数据库中键的数目 client.dbsize()
expire(name, time) name: 键名 time:秒数 设置过期时间 client.expire('username', 60)
flushdb()   删除当前选择数据库中的所有键 client.flushdb()

 

 # 全局key操作：
 results = cli.keys(pattern='*')  # 查询全部key的值。默认查找所有
 cli.exists('sex')  # 查询该键是否存在
 cli.rename('yelan', 'ze')  # 改名
 cli.expire('name', 200)  # 设置过期时间
 cli.ttl('name')  # 查看过期时间
 cli.persist('name')  # 删除过期时间
 cli.delete('name')   # 删除键值对
 ​

 

键值操作

类型增/设置查改/追加删
String set key value mset key1 value1 key2 value2 get key mget key [key] append key value del key
List rpush key value [value] lpush key value [value] lrange key start stop lindex key index lset key index value rpop key lpop key lrem key count value
Hash hset key field value hmset key field1 value1 [filed2 value2] hget key field hgetall key hvals key hkeys key hset key field new_value hdel key field
Set sadd key value smembers key / spop key srem key member [member]
Zset zadd key score member [score2 member2] zrange key start stop zrangebyscore key min max zscore key member / zremrange key member zremrangebyrank min max zremrangebyscore min max
全局key操作 expire key seconds ttl key persist key keys * exists key type key rename key new_key del key

 

键值操作： 具体使用查看接口即可（ctrl + 左键）
 # str类型
 cli.set('yelan', 'hello')  # 增
 cli.mset(name='liu', sex=18)  # 增加多条
 cli.append('yelan', '\tworld')  # 追加数据
 result = cli.get('yelan')  # 查
 print(result.title())
 result = cli.mget('name', 'sex')  # 查询多条
 print(result)
 cli.delete('yelan', 'name')  # 删(不定长)
 ​
 # list类型
 cli.rpush('name', 'wang', 'li', 'liu')  # 尾部插入
 cli.lpush('sex', 'n', 'w', 'n')  # 头部插入(倒序)
 results = cli.lrange('name', 0, 5)  # 查询(闭区间)
 print(results)
 result = cli.lindex('name', 2)  # 查询指定索引的值
 cli.lset('name', 1, 'muzi')  # 修改指定索引的值
 cli.rpop('name')  # 尾部删除key的值
 cli.lpop('name')  # 头部删除
 cli.lrem('name', 1, 'liu')  # 指定次数指定删除值
 ​
 # hash类型
 cli.hset('info', 'tel', 177)  # 添加数据
 cli.hset('info', 'tel', 150)  # 修改数据(同则修改，无则添加)
 cli.hset('info', 'sex', 'nan')
 result = cli.hget('info', 'tel')  # 查看指定域对应的值
 result = cli.hgetall('info')  # 查询所有的field和value(返回一个字典格式)
 result = cli.hvals('info')  # 查看所有的值values
 result = cli.hkeys('info')  # 查看所有的域field
 print(result)
 cli.delete('info')  # 删除
 ​
 # Set类型:
 client.sadd()
 client.smembers()
 client.spop()
 client.srem()
 ​
 # zset类型:
 client.zadd()
 client.zrange()
 client.zscore()
 client.zrangebyscore()
 client.zrem()
 client.zremrangebyrank()
 client.zremrangebyscore()
 ​

 

自定义封装

全局key操作封装
 import redis
 ​
 class GlobalKey:
     def __init__(self, db=0, decode_response=False):
         self.conn = redis.StrictRedis(db=db, decode_responses=decode_response)
 ​
     def check_all(self, key="*"):
         result = self.conn.keys(key)    # 查询全部key
         print(result)
 ​
     def set_expire(self, key, seconds):     # 设置过期时间
         self.conn.expire(key, seconds)
 ​
     def check_type(self, key):              # 查看key类型
         res = self.conn.type(key)
         print(res)
 ​
     def check_exists(self, key):            # 查看key是否存在
         res = self.conn.exists(key)
         print(res)
 ​
     def check_ttl(self, key):               # 查看剩余的过期时间
         res = self.conn.ttl(key)
         print(res)
 ​
     def change_name(self, key, new_key):    # 重命名
         self.conn.rename(key, new_key)
 ​
     def globl_del(self, *key):              # 全局删除操作
         self.conn.delete(*key)
 ​
 gk = GlobalKey(1, decode_response=True)
 gk.check_all()

 

字符串操作封装
 class RedisString:
     def __init__(self, db=0, decode_response=False):
         self.conn = redis.StrictRedis(db=db, decode_responses=decode_response)
 ​
     def str_set(self, key, value):
         self.conn.set(key, value)
 ​
     def str_mset(self, dict_):
         self.conn.mset(dict_)
 ​
     def str_append(self, key, value):
         self.conn.append(key, value)
 ​
     def str_get(self, key):
         res = self.conn.get(key)
         print(res)
 ​
     def str_del(self, key):
         self.conn.delete(key)
 ​
 ​
 # my_str = RedisString(1, decode_response=True)
 # my_str.str_mset({'name': 'liu', 'age': 18})
 # my_str.str_del("age")

 

列表类型操作封装
 class RedisList:
     def __init__(self, n=0, decode_responses=False):  # 初始化时连接redis n号数据库
         self.client = redis.StrictRedis(db=n, decode_responses=decode_responses)
 ​
     def push(self, key, *values, l=True):  # 增加数据
         if l:
             self.client.lpush(key, *values)  # 头部插入
         else:
             self.client.rpush(key, *values)  # 尾部插入
 ​
     def lrange(self, key, start, stop):  # 查询数据
         result = self.client.lrange(key, start, stop)
         print(result)  # 查询的结果需要打印
 ​
     def lset(self, key, index, value):  # 修改数据
         self.client.lset(key, index, value)
 ​
     def pop(self, key, R=True):  # 删除数据
         if R:
             self.client.rpop(key)
         else:
             self.client.lpop(key)
 ​
     def remove(self, key, count, value):  # 指定删除数据
         self.client.lrem(key, count, value)
 ​
 if __name__ == "__main__":
 ​
 my_list = RedisList(n=2, decode_responses=True)  # 实例化时传入2号数据库
 my_list.push('sex', 'man', 'nv', l=False)
 my_list.lrange('sex', 0, 10)
 my_list.lset('sex', 2, 'wo')
 my_list.pop('sex', R=False)
 my_list.remove('sex', 0, '男')

 

散列类型操作封装
 class Redis_Hash:
     def __init__(self, db, is_str=False):
         self.conn = redis.StrictRedis(db=db, decode_responses=is_str)
 ​
     def hash_set(self, hash_key, field, value):
         self.conn.hset(hash_key, field, value)
 ​
     def hash_mset(self,key, dict_):
         self.conn.hmset(key, dict_)
 ​
     def hash_get(self, key, field):
         res = self.conn.hget(key, field)
         print(res)
 ​
     def hash_getall(self, key):
         res = self.conn.hgetall(key)
         print(res)
 ​
     def hash_hvals(self, key):
         res = self.conn.hvals(key)
         print(res)
 ​
     def hash_hkey(self, key):
         res = self.conn.hkeys(key)
         print(res)
 ​
     def hash_del(self, *key):
         self.conn.delete(*key)
 ​
 my_hash = Redis_Hash(1, True)
 my_hash.hash_mset('info', {"name": 18})
 my_hash.hash_del('info')
 ​