Python操作Redis

import redis

r = redis.Redis(host="192.168.0.106", port=6379)
r.set("name", "pd")
val = r.get("name")
print(val)  # b'pd'

import redis

pool = redis.ConnectionPool(host="192.168.0.106", port=6379, max_connections=1000)  # 这里最多创建1000个连接
r = redis.Redis(connection_pool=pool)
r.set("foo", "Bar")

# redis_pool.py
import redis
pool = redis.ConnectionPool(host="192.168.0.106", port=6379, max_connections=1000)

# test.py
import redis
from redis_pool import pool

while True:
    key = input("请输入key：")
    value = input("请输入value：")
    # 去连接池中获取连接
    r = redis.Redis(connection_pool=pool)
    # 设置值
    r.set(key, value)

在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行
     xx，如果设置为True，则只有name存在时，当前set操作才执行

设置值，只有name不存在时，才执行设置操作
如：
    r.set("cc", "xx")
    r.setnx("cc", "ss")
    r.get("cc")  # b'xx'
对比：    
    r.set("cc", "xx")
    r.set("cc", "ss")
    r.get("cc")  # b'ss'

批量设置值
如：mset({"k1": "v1", "k2": "v2"})

批量设置值，只有name不存在时，才执行设置操作
示例：
    r.mset({"k1": "aa", "k2": "bb"})
    r.mset({"k1": "cc", "k2": "dd"})
    ret1 = r.mget("k1", "k2")  # [b'cc', b'dd']
    r.mset({"k1": "aa", "k2": "bb"})
    r.msetnx({"k1": "cc", "k2": "dd"})
    ret2 = r.mget("k1", "k2")  # [b'aa', b'bb']

设置值
参数：time，过期时间（数字秒 或 timedelta对象）

设置值
参数：time_ms，过期时间（数字毫秒 或 timedelta对象）

获取某个值

批量获取
如：
    mget("k1", "k2") 或 mget(["k1", "k2"])

设置新值并获取原来的值
    r.set("vv", "xx")
    ret = r.getset("vv", "ss")
    print(ret)  # b'xx'

获取子序列（根据字节获取，非字符）
参数：
    name，redis的name
    start，起始位置（字节）
    end，结束位置（字节）
如：
    r.set("k1", "你好吗")
    ret = r.getrange("k1", 0, 2)
    print(ret)  # b'xe4xbdxa0'
    print(ret.decode("utf8"))  # 你 

返回name对应值的字节长度（一个汉字3个字节）
示例：
    r.set("k1", "你好吗")
    ret = r.strlen("k1")  # 9

r.set("k1", "12345")
r.setrange("k1", 2, "a")
b'12a45'
r.setrange("k1", 2, "ab")
b'12ab5'
r.setrange("k1", 2, "abde")
b'12abde'

自增name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
参数：
    name,Redis的name
    amount,自增数（必须是整数）
示例：
    r.set("a", 20)
    r.incr("a", amount=2)
    r.get("a")  # 22

同上，amount,自增数（浮点型）

自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
参数：
    name,Redis的name
    amount,自减数（整数）

在redis的name对应的值后面追加内容
参数：
    key, redis的name
    value, 要追加的字符串
示例：
    r.set("a", 20)
    r.append("a", "00")
    r.get("a")  # 2200

相当于切片操作
示例：
    r.set("k1", "ABCDEFG")
    ret1 = r.substr("k1", 0, 2)   # b'ABC'
    ret2 = r.substr("k1", 0, -1)  # b'ABCDEFG'

name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
参数：
    name，redis的name
    key，name对应的hash中的key
    value，name对应的hash中的value
注：
    hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

在name对应的hash中获取根据key获取value

在name对应的hash中批量设置键值对
参数：
    name，redis的name
    mapping，字典，如：{"k2": "v2", "k3": "v3"}
如：
    r.hmset("n2", {"k2": "v2", "k3": "v3"})

在name对应的hash中获取多个key的值
参数：
    name，reids对应的name
    keys，要获取key集合，如：['k1', 'k2', 'k3']
    *args，要获取的key，如：k1,k2,k3
如：r.hmget("n2", ["k2", "k3"]) 或 conn.hmget("n2", "k2", "k3")

获取name对应hash的所有键值
r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hgetall("n2")  # {b'k3': b'v3', b'k2': b'v2'}

获取name对应的hash中键值对的个数

r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hkeys("n2")  # [b'k3', b'k2']

获取name对应的hash中所有的value的值
r.hmset("n2", {"k2": "v2", "k3": "v3"})
r.hvals("n2")  # [b'v3', b'v2']

查name对应的hash是否存在当前传入的key

将name对应的hash中指定key的键值对删除

自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
    name，redis中的name
    key， hash对应的key
    amount，自增数（整数）

同上，amount，自增数（浮点数）

增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片
的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆。
参数：
    name，redis的name
    cursor，游标（基于游标分批取获取数据）
    match，匹配指定key，默认None 表示所有的key
    count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
如：
    第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    ...
    直到返回值cursor的值为0时，表示数据已经通过分片获取完毕

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
# 参数：
    match，匹配指定key，默认None 表示所有的key
    count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# 如：
    r.hmset("n1", {"k1": 1, "k2": 2, "k3": 3, "k4": 4})
    ret = r.hscan_iter("n1", match=None, count=None)  # ret为生成器
    for item in ret:
        print(item)

如：
    r.lpush("s", 1,2,3)
    保存顺序为: 3,2,1
扩展：
    rpush(name, *values) 表示从右向左操作

在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
扩展：
    rpushx(name, value) 表示从右向左操作
示例：
    r.rpush("n1", *[1, 2])
    r.lpushx("n1", 0)
    ret = r.lrange("n1", 0, 10)  # [b'0', b'1', b'2']

在name对应的列表的某一个值前或后插入一个新值
参数：
    name，redis的name
    where，before或after
    refvalue，标杆值，即：在它前后插入数据
    value，要插入的数据
示例：
    r.rpush("n1", *[1, 2, 3, 4])
    r.linsert("n1", "after", 2, "aa")
    # [b'1', b'2', b'aa', b'3', b'4']

对name对应的list中的某一个索引位置重新赋值
参数：
    name，redis的name
    index，list的索引位置
    value，要设置的值
示例：
    r.rpush("n1", *[1, 2, 3, 4, 5])
    r.lset("n1", 2, "aa")
    # [b'1', b'2', b'aa', b'4', b'5']

在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
更多：
    rpop(name)  表示从右向左操作
示例：
r.rpush("n1", *[1, 2, 3, 4])
ret1 = r.lpop("n1")  # b'1'
ret2 = r.rpop("n1")  # b'4'

将多个列表排列，按照从左到右去pop对应列表的元素
参数：
    keys，redis的name的集合
    timeout，超时时间，当元素所有列表的元素获取完之后，
    阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞。
更多：
    r.brpop(keys, timeout)，从右向左获取数据

从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
参数：
    src，要取数据的列表的name
    dst，要添加数据的列表的name
示例：
    r.rpush("n1", 1, 2)
    r.rpush("n2", *["a", "b"])
    r.rpoplpush("n1", "n2")
    ret = r.lrange("n2", 0, 10)  # [b'2', b'a', b'b']

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
参数：
    src，取出并要移除元素的列表对应的name
    dst，要插入元素的列表对应的name
    timeout，当src对应的列表中没有数据时，阻塞等
    待其有数据的超时时间（秒），0 表示永远阻塞。

在name对应的列表中根据索引获取列表元素
示例：
    r.rpush("n1", "a", "b", "c")
    ret = r.lindex("n1", 0)  # b'a'

name对应的list元素的个数
示例：
    r.rpush("n1", "a", "b", "c")
    ret = r.llen("n1")  # 3    

在name对应的列表分片获取数据
参数：
    name，redis的name
    start，索引的起始位置
    end，索引结束位置

在name对应的list中删除指定的值
参数：
    name，redis的name
    count，count=0，删除列表中所有的指定值；
           count=2, 从前到后，删除2个；
           count=-2, 从后向前，删除2个。
    value，要删除的值
示例：
    r.rpush("n1", *[1,2,3,1,2,3])
    r.lrem("n1", 0, 3)  # [b'1', b'2', b'1', b'2']
    r.lrem("n1", 1, 3)  # [b'1', b'2', b'1', b'2', b'3']
    r.lrem("n1", 2, 3)  # [b'1', b'2', b'1', b'2']

在name对应的列表中移除没有在 start~end 索引之间的值
参数：
    name，redis的name
    start，索引的起始位置
    end，索引结束位置
示例：
    r.rpush("n1", *[1,2,3,4,5,6,7,8])
    r.ltrim("n1", 2, 5)
    xx = r.lrange("n1",0, 7)  # [b'3', b'4', b'5', b'6']

# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
import redis

r = redis.Redis(host="127.0.0.1", port=6379)
# 测试数据
r.rpush("xx", *[1,2,3,4,5,6,7,8,9,10])
# ====================================================
# 方式一：
def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name，即：迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)
# 使用
for item in list_iter("xx"):
    print(item)
# ====================================================
# 方式二：
def list_iter(key, count=100):
    index = 0
    while True:
        data_list = r.lrange(key, index, index+count-1)
        if not data_list:
            return None
        index += count
        for item in data_list:
            yield item

# print(r.lrange("xx",0,1))
# print(r.lrange("xx",2,3))
# print(r.lrange("xx",4,5))

for item in list_iter("xx", count=5):
    print(item)

name对应的集合中添加元素
r.sadd("jj", "v1", "v2", "v3")

获取name对应的集合中元素个数
r.scard("jj")  # 3

在第一个name对应的集合中且不在其他name对应的集合的元素集合

获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

获取多一个name对应集合的并集

获取多一个name对应集合的并集，再讲其加入到dest对应的集合中

检查value是否是name对应的集合的成员

获取name对应的集合的所有成员

将某个成员从一个集合中移动到另外一个集合

从集合的右侧（尾部）移除一个成员，并将其返回

从name对应的集合中随机获取 numbers 个元素

在name对应的集合中删除某些值

获取多一个name对应的集合的并集

获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

在name对应的有序集合中添加元素
如：
     zadd('zz', 'n1', 1, 'n2', 2)
     或
     zadd('zz', n1=11, n2=22)

获取name对应的有序集合元素的数量

获取name对应的有序集合中分数 在 [min,max] 之间的个数

自增name对应的有序集合的 name 对应的分数

# 按照索引范围获取name对应的有序集合的元素
 
# 参数：
    # name，redis的name
    # start，有序集合索引起始位置（非分数）
    # end，有序集合索引结束位置（非分数）
    # desc，排序规则，默认按照分数从小到大排序
    # withscores，是否获取元素的分数，默认只获取元素的值
    # score_cast_func，对分数进行数据转换的函数
 
# 更多：
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)
 
    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

获取某个值在 name对应的有序集合中的排行（从 0 开始）
更多：
    zrevrank(name, value)，从大到小排序

# 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）
  来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员。
# 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后
  的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大。
 
# 参数：
    # name，redis的name
    # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
    # min，右区间（值）
    # start，对结果进行分片处理，索引位置
    # num，对结果进行分片处理，索引后面的num个元素
 
# 如：
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
 
# 更多：
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

删除name对应的有序集合中值是values的成员
如：zrem('zz', ['s1', 's2'])

根据排行范围删除

根据分数范围删除

根据值返回删除

获取name对应有序集合中 value 对应的分数

获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为:  SUM  MIN  MAX

获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为:  SUM  MIN  MAX

同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

根据删除redis中的任意数据类型

检测redis的name是否存在

根据模型获取redis的name
更多：
    KEYS * 匹配数据库中所有 key 。
    KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    KEYS h*llo 匹配 hllo 和 heeeeello 等。
    KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

为redis的某个name设置超时时间，单位为秒，可以用整数或timedelta对象表示。

对redis的name重命名，将src改为dst

对redis的name重命名，如果dst不存在，则将src改为dst

将redis的某个值移动到指定的db下

随机获取一个redis的name（不删除）

获取name对应值的类型

同字符串操作，用于增量迭代获取key

import redis

r = redis.Redis(host="127.0.0.1", port=6379)
p = r.pipeline(transaction=True)
p.multi()
p.set("k1","v1")
p.hset("k2", "k2", "v2")
p.rpush("k3", "v3")

p.execute()

import redis

r = redis.Redis(host="127.0.0.1", port=6379)
r.set("count",1000)

with r.pipeline() as pipe:
    # 先监视，自己的值没有被修改过
    r.watch("count")
    # 事务开始
    pipe.multi()
    old_count = r.get("count")
    count = int(old_count)
    if count > 0:  # 有库存
        pipe.set("count", count-1)
    # 执行，把所有命令一次性推送过去
    pipe.execute()