1.简介
Redis 是一个基于内存的高效的键值行非关系型数据库，存取效率极高。
python提供了两个类：分别为Redis和StrictRedis来实现Redis的命令操作。StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。如果需要另一个Redis实例（or Redis数据库）时，就需要重新创建redis连接实例来获取一个新的连接。同理，python的redis没有实现select命令。
官方推荐使用StrictRedis
如果要做数据导入、导出操作的话，还需要安装RedisDump。
2.连接Redis-api
安装redis模块
pip install redis
python操作
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'))
连接redis，加上decode_responses=True，写入的键值对中的value为str类型，不加这个参数写入的则为字节类型。
连接池
redis使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。
可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池
import redis
pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
# host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('gender', 'male') # key是"gender" value是"male" 将键值对存入redis缓存
print(r.get('gender')) # gender 取出键male对应的值
连接问题及解决
出现拒绝连接，如果不是本机连接，就需要修改远程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
3.全局键（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') # 删除键值对
4.键值操作
str类型
cli.set('yelan', 'hello') # 增
cli.mset(name='liu', sex=18) # 增加多条
cli.append('yelan', ' world') # 追加数据
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()
5.自定义封装
全局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')