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）操作

 # 全局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‘)   # 删除键值对
 ?

键值操作

键值操作： 具体使用查看接口即可（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‘)
 ?

Redis-API