1.几种连接方式介绍

"""
Redis简介：
这是一个基于内存的高效的键值型非关系型数据库，存取效率极高，而且支持
多种存储数据结构，使用也比较简单。
python中提供连接redis的第三方库redis.py。
在这个库中有两个类Redis和StrictRedis来实现Redis的命令操作。
Redis是StrictRedis的子类，主要功能是向后兼容旧版本库里的几个方法。
在这里使用官方推荐的StrictRedis。
"""
from redis import StrictRedis

# 连接redis需要IP地址，运行端口，数据库，密码。如果本地redis没有密码可以直接使用默认值
conn = StrictRedis(host="localhost", port=6379, db=0, password=None)
# <class ‘redis.client.Redis‘>  调用Redis子类对象生成连接实例
from redis.client import Redis
print(type(conn))
# 连接成功之后调用实例对象的set方法设置值
conn.set("name", "Yang")
# 调用get方法获取值
print(conn.get("name"))

# 连接池操作
from redis import ConnectionPool

# 连接池设置参数，max_connections最大连接数。其他不变
pool = ConnectionPool(host="localhost", port=6379, db=0, password=None, max_connections=5)
# 生成的连接池实例传递给StrictRedis连接redis数据库
redis = StrictRedis(connection_pool=pool)
# <class ‘redis.client.Redis‘>  一样的连接类型
print(type(redis))

"""
支持三种URL方案：
redis://[:password]@localhost:6379/0    # 正常的TCP套接字连接
rediss://[:password]@localhost:6379/0   # SSL包装的TCP套接字连接
unix://[:password]@/path/to/socket.sock?db=0    # 一个Unix Domain Socket连接
"""

# For example:举例
# 构造url
url = ‘redis://:[email protected]:6379/0‘
# 调用类ConnectionPool的from_url方法传递构造的url字符串
url_pool = ConnectionPool.from_url(url=url)
# 生成的连接池实例传递给StrictRedis连接redis数据库
url_redis = StrictRedis(connection_pool=url_pool)
# <class ‘redis.client.Redis‘>  一样的连接类型
print(type(url_redis))

2.连接成功后的一些键操作

exists(name)        判断一个键是否存在               redis.exists("name")
delete(name)        删除一个键                       redis.delete("name")
type(name)          判断键的类型                     redis.type("name")
keys(pattern)       获取所有符合规则的键             redis.keys("n*")
randomkey()         获取随机的一个键                 redis.randomkey(self)
rename(src, dst)    重命名键                         redis.rename("name", "names")
dbsize()            获取当前数据库中键的数目          redis.dbsize(self)
expire(name, time)  设定键的过期时间，单位：秒        redis.expire("name", 10)
ttl(name)           获取键的过期时间，单位：秒        redis.ttl("name")      -1表示永久
move(name, db)      将键移动到其他数据库              redis.move("name", 1)
flushdb()           删除当前选择数据库中的所有键      redis.flushdb(self)
flushall()          删除所有数据库中的所有键          redis.flushall(self)

3.连接成功后的一些字符串操作

set(name, value)        将键name的值设置为`value`      redis.set(‘name‘, ‘Yang‘)
get(name)               获取键名为name的值             redis.get(‘name‘)
getset(name, value)     将键name的值设置为value并以原子方式返回键name的旧值。   redis.getset("name", "Yu")
mget(keys, *args)       返回多个键对应的value           redis.mget([‘name‘, ‘names‘])
setnx(name, value)      不存在则创建，存在则不生效       redis.setnx("newname", "Yang")
setex(name, time, value)    设置一个有效期为1秒的值      redis.setex("name", 1, "Yang")
setrange(name, offset, value)   为指定键的值拼接字符串   redis.setrange("name", num, "value")  offset为偏移量也就是指针
mset(mapping)           批量赋值                        redis.mset({"name": "value"})
msetnx(mapping)         键都不存在时批量赋值             redis.msetnx({"name": "value"})
incr(name, amount=1)    键不存在则创建并设置值为1，存在则值增长1     redis.incr("score": 1)
decr(name, amount=1)    与上一个方法相反、减值操作
append(key, value)      为key的值追加value               redis.append("name", "Yu")
substr(name, start, end=-1)   截取键name值的字符串      redis.substr("name", 1, 3)      end=-1表示截取到末尾
getrange(key, start, end)     与上一个方法相同          redis.getrange("name", 1, 3)

4.连接成功后的一些列表操作

rpush(name, *value)     在name键的列表值末尾追加多个元素      redis.rpush("name", 1,2,3)
lpush(name, *value)     在name键的列表值头部推送多个元素      redis.lpush("name", 0)
llen(name)              返回name键的列表值长度                redis.llen("name")
lrange(name, start, end)    返回name键的切片列表值            redis.lrange("name", 1, 3)
ltrim(name, start, end)     与上一个方法相同
lindex(name, index)     返回name键的列表中index位置的元素     redis.lindex("name", 2)
lset(name, index, value)    给name键的列表中index位置的元素赋值，越界则报错    redis.lset("name", 2, "Yu")
lrem(name, count, value)    删除name键的列表中count个值为value的元素     redis.lrem("name", 2, "Yang")
lpop(name)              返回并删除name键的列表中首元素        redis.lpop("name")
rpop(name)              与上一个方法相反
blpop(keys, timeout=0)  返回并删除name键的列表中首元素       如果列表为空则阻塞，timeout=0表示一直阻塞
brpop(keys, timeout=0)  与上一个方法相反                      redis.brpop("keys")
rpoplpush(src, dst)     将src键的列表中首元素取出添加到dst键列表中的头部     redis.rpoplpush("name", "name1")

5.连接成功后的一些集合操作

sadd(name, *values)     向键为name的集合中添加多个元素     redis.sadd("tags", "Yang", "Yu")
srem(name, *values)     从键为name的集合中删除多个元素     redis,srem("tags", "Yu")
spop(name)              在集合name中随机删除并返回删除的元素     redis.spop("tags")
smove(src, dst, value)  从src集合中移除元素添加到dst集合中       redis.smove("tags", "tags2", "Yang")
scard(name)             返回集合name中的元素个数           redis.scard("tags")
sismember(name, value)  判断value是否在集合name中          redis.sismember("tags", "Yang")
sinter(keys, *args)     返回给定键keys中多个集合的交集     redis.sinter(["tags", "tags2"])
sinterstore(dest, keys, *args)   求交集并保存到dest集合中  redis.sinterstore("intag", ["tags", "tags2"])
sunion(keys, *args)     返回所有给定键keys的并集           redis.sunion(["tags", "tags2"])
sunionstore(dest, keys, args)    求并集并保存到dest集合中  redis.sunionstore("intags", ["tags", "tags2"])
sdiff(keys, *args)      返回所有给定键集合的差集           redis.sdiff(["tags", "tags2"])
sdiffstore(dest, keys, *args)    求差集并保存到dest集合中  redis.sdiffstore("intags", ["tags", "tags2"])
smembers(name)          返回键为name的集合中所有元素       redis.smembers("tags")
srandmember(name)       随机返回键为name集合中的一个元素并不删除  redis.srandmember("tags")

6.连接成功后的一些有序集合操作

zadd(name, *args, **kwargs) 向键为name的zset中添加多个元素     redis.zadd("tags", 91, "Jim", 80, "Bob")
zrem(name, *values)         删除键为name的zset中的元素         redis.zrem("tags", "Bob")
如果在键为name的zset中已经存在元素value，则将该元素的score增加amount，
否则向该集合中添加该元素，其score的值为amount
zincrby(name, value, amount=1)                                 redis.zincrby("tags", "Jim". -9)
zrank(name, value)          返回键为name中score从小到大的zset排名   redis.zrank("tags", "Jim")
zrevrank(name, value)       与上一个方法相反
返回键为name的zset中index从start到end的所有元素
zrevrange(name, start, end, withscores=False)       redis.zrevrange("tags", 0, 2)
返回键为name的zset中score在给定区间的元素, num：个数，withscores：是否带score
zrangebyscore(name, min, max, start=None, num=None, withscores=False)   redis.zrangebyscore("tags", 80, 90)
zcount(name, min, max)      返回键为name的zset中score在给定区间的元素个数   redis.zcount("tags", 80, 90)
zcard(name)                 返回键为name的zset中元素个数        redis.zcard("tags")
删除键为name的zset中排名在给定区间的元素
zremrangebyrank(name, min, max)     redis.zremrangebyrank("tags", 0, 59)
删除键为name的zset中score在给定区间的元素
zremrangebyscore(name, min, max)    redis.zremrangebyscore("tags", 80, 90)

7.连接成功后的一些散列操作

hset(name, key, value)      向键为name的散列表中添加映射            redis.hset("price", "apple", 2)
hsetnx(name, key, value)    不存在则向键为name的散列表中添加映射    redis.hsetnx("price", "orange", 1)
hget(name, key)             返回键为name的散列表中key对应的值       redis.hget("price", "apple")
hmget(name, keys, *args)    返回键为name的散列表中各个key对应的值   redis.hmget("price", ["apple", "orange"])
hmset(name, mapping)        向键为name的散列表中批量添加映射        redis.hmset("price", {"banana": 2, "tomato": 1})
hincrby(name, key, amount=1) 向键为name的散列表中对应key的值增加    redis.hincrby("price", "apple", 1)
hexists(name, key)          判断键为name的散列表中是否存在键为key的映射   redis.hexists("price", "tomato")
hdel(name, *keys)           删除键为name的散列中对应key             redis.hdel("price", "banana")
hlen(name)                  从键为name的散列表中获取映射个数        redis.hlen("price")
hkeys(name)                 从键为name的散列表中获取所有映射键名    redis.hkeys("price")
hvals(name)                 从键为name的散列表中获取所有映射键值    redis.hvals("price")
hgetall(name)               从键为name的散列表中获取所有映射键值对  redis.hgetall("price")

原文地址：https://www.cnblogs.com/Guishuzhe/p/10343071.html