Python脚本之操作Redis【二】

zyooooxie

已于 2024-01-13 21:56:28 修改

阅读量434

点赞数

分类专栏：中间件学习文章标签： redis python

于 2022-02-09 20:45:55 首次发布

本文为博主原创，未经许可严禁转载。

本文链接：https://blog.csdn.net/zyooooxie/article/details/95352530

版权

中间件学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文为博主原创，未经授权，严禁转载及使用。
本文链接：https://blog.csdn.net/zyooooxie/article/details/95352530

之前分享过一篇操作Redis【一】，主要写的是 String；这一次来分享下 Hash、List、Set的；

个人博客：https://blog.csdn.net/zyooooxie

Redis命令【二】

先前说过一个学习命令的网站，再加个 https://redis.io/commands

Hash：

HGET KEY_NAME field
HGETALL KEY_NAME
HEXISTS KEY_NAME field
HLEN KEY_NAME

HSET KEY_NAME field value
HDEL KEY_NAME field

HKEYS KEY_NAME
HVALS KEY_NAME

HMSET KEY_NAME field value
HMGET KEY_NAME field

List：

LINDEX KEY_NAME index
LLEN KEY_NAME
LRANGE KEY_NAME start stop

LSET KEY_NAME index new_VALUE
LINSERT KEY_NAME BEFORE | AFTER pivot new_VALUE

LPUSH KEY_NAME VALUE1 VALUE2 【插入到列表的表头】
RPUSH KEY_NAME VALUE1 VALUE2 【插入到列表的表尾】

LPOP KEY_NAME
RPOP KEY_NAME

LREM KEY_NAME count VALUE

Set：

SCARD KEY_NAME

SMEMBERS KEY_NAME
SISMEMBER KEY_NAME member

SADD KEY_NAME member1 member2

SREM KEY_NAME member1 member2

代码

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: zyooooxie@gmail.com
"""


def test_hash():
    # https://redis.io/commands/?group=hash

    r = redis_connect()
    test_hash_ = 'test:zyooooxie:hash'

    # HGETALL key
    # 返回 key 中，所有的域和值

    # 返回值： 以列表形式返回哈希表的域和域的值。 若 key 不存在，返回空列表。
    # 在返回值里，紧跟每个域名(field __name)之后是域的值(init_value)，所以返回值的长度是哈希表大小的两倍。

    # hgetall() : Return a Python dict of the hash's name/value pairs

    Log.info(r.hgetall(gl_real_hash))
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hgetall(gl_no_exist))  # 不存在的key
    assert len(r.hgetall(gl_no_exist)) == 0  # 空字典

    Log.info('----')

    hash_field = 'name'
    hash_field_2 = 'blog'

    # HEXISTS key field
    # 查看 key 中，给定域 field 是否存在。

    # 返回值： 如果哈希表含有给定域，返回 1 。  如果哈希表不含有给定域，或 key 不存在，返回 0 。

    # hexists(): Returns a boolean indicating if ``key`` exists within hash ``__name``

    Log.info(r.hexists(gl_real_hash, hash_field))  # True
    Log.info(r.hexists(gl_real_hash, hash_field_2))  # False

    Log.info(r.hexists(gl_no_exist, hash_field))  # False

    Log.info('----')

    # HGET key field
    # 返回 key 中给定域 field 的值

    # 返回值： 给定域的值。 当给定域不存在或是给定 key 不存在时，返回 nil 。

    # hget(): Return the init_value of ``key`` within the hash ``__name``

    Log.info(r.hget(name=gl_real_hash, key=hash_field))
    Log.info(r.hget(name=gl_real_hash, key=hash_field_2))  # None

    Log.info(r.hget(name=gl_no_exist, key=hash_field))  # None

    Log.info('----')

    # HKEYS key
    # 返回哈希表 key 中的所有域

    # 返回值： 一个包含哈希表中所有域的表。 当 key 不存在时，返回一个空表。

    # hkeys(): Return the list of keys within hash ``__name``

    Log.info(r.hkeys(gl_real_hash))
    Log.info(r.hkeys(gl_no_exist))  # 空list

    Log.info('----')

    # HVALS key
    # 返回哈希表 key 中所有域的值。

    # 返回值： 一个包含哈希表中所有值的表。 当 key 不存在时，返回一个空表。

    # hvals(): Return the list of values within hash ``__name``

    Log.info(r.hvals(gl_real_hash))
    Log.info(r.hvals(gl_no_exist))  # 空list

    Log.info('----')

    hash_field1 = 'NAME_'
    hash_value1 = 'zy'
    hash_field2 = 'BLOG_'
    hash_value2 = 'https://blog.csdn.net/zyooooxie'

    # HSET key field value [field value ...]
    # 将 key 中的域 field 的值设为 init_value 。
    # 如果 key 不存在，一个新的哈希表被创建并进行 HSET 操作。 如果域 field 已经存在于哈希表中，旧值将被覆盖。

    # 返回值： 如果 field 是哈希表中的一个新建域，并且值设置成功，返回 1。 如果哈希表中域 field 已经存在，且旧值已被新值覆盖，返回 0。

    # hset(): Set ``key`` to ``init_value`` within hash ``__name``, ``mapping`` accepts a dict of key/init_value pairs that will be added to hash ``__name``
    # 2种用法选1种，不可多传，也必须要传参数

    r.delete(test_hash_)
    Log.info(r.hset(test_hash_, mapping={hash_field2: hash_value2}))  # 是1
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hset(test_hash_, mapping={hash_field2: hash_value2 * 2}))  # [再次设置] 是0
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hset(test_hash_, key=hash_field1, value=hash_value1))  # 是1
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hset(test_hash_, key=hash_field1, value=hash_value1 * 2))  # [再次设置] 是0
    Log.info(r.hgetall(test_hash_))

    # Log.info(r.hset(test_hash_))            # redis.exceptions.DataError: 'hset' with no key init_value pairs

    Log.info(r.unlink(test_hash_))

    Log.info('Starting with Redis version 4.0.0: Accepts multiple field and value arguments.')
    Log.info(r.hset(test_hash_, mapping={hash_field2: hash_value2,
                                         hash_field1: hash_value1}))
    Log.info(r.hgetall(test_hash_))

    Log.info(r.unlink(test_hash_))
    Log.info(r.hset(test_hash_, mapping={hash_field2: hash_value1}, key=hash_field1,
                    value=hash_value2))
    Log.info(r.hgetall(test_hash_))

    Log.info('----')

    # HDEL key field [field ...]
    # 删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。

    # 返回值: 被成功移除的域的数量，不包括被忽略的域。

    # hdel(): Delete ``keys`` from hash ``__name``

    Log.info(r.hdel(test_hash_, hash_field2))  # 1
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hdel(test_hash_, hash_field1, hash_field2))  # 成功得1，不存在的域被忽略
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hdel(test_hash_, hash_field1, hash_field2, hash_field * 2))  # 0
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hdel(gl_no_exist, hash_field1))  # 不存在的key：0

    Log.info('----')

    hash_field3 = 'f3'
    hash_value3 = 333.33
    hash_field4 = 'f4'
    hash_value4 = '(4444)(4444)'
    hash_field5 = 'f5'
    hash_value5 = 55555

    # HMSET key field value [field value ...]
    # 同时将多个 field-init_value (域-值)对设置到哈希表 key 中
    # 此命令会覆盖哈希表中已存在的域。 如果 key 不存在，一个空哈希表被创建并执行 HMSET 操作。

    # 返回值： 如果命令执行成功，返回 OK 。 当 key 不是哈希表(hash)类型时，返回一个错误。

    # hmset(): Set key to init_value within hash ``__name`` for each corresponding key and init_value from the ``mapping`` dict.

    r.delete(test_hash_)
    Log.info(r.hmset(test_hash_, mapping={hash_field3: hash_value3, hash_field4: hash_value4}))  # True
    Log.info(r.hgetall(test_hash_))

    Log.info(r.hmset(test_hash_, mapping={hash_field5: hash_value5, hash_field4: hash_value4 * 2}))
    Log.info(r.hgetall(test_hash_))

    # Redis.hmset() is deprecated. Use Redis.hset() instead.

    Log.info('----')

    # HMGET key field [field ...]
    # 返回哈希表 key 中，一个或多个给定域的值。如果给定的域不存在于哈希表，那么返回一个 nil 值。

    # 返回值：  一个包含多个给定域的关联值的表，表值的排列顺序和给定域参数的请求顺序一样。

    # hmget(): Returns a list of values ordered identically to ``keys``

    Log.info(r.hmget(test_hash_, keys=[hash_field * 3, hash_field5, hash_field4, hash_field4]))

    Log.info(r.hmget(gl_no_exist, keys=[hash_field3, hash_field5, hash_field4]))  # 不存在的 key - [None, None, None]

    Log.info('----')

    # HLEN key
    # 返回哈希表 key 中域的数量。

    # 返回值：  哈希表中域的数量。  当 key 不存在时，返回 0。

    # hlen(): Return the number of elements in hash ``__name``

    Log.info(r.hlen(test_hash_))

    Log.info(r.hlen(gl_no_exist))  # 0

    r.expire(test_hash_, 600)

    r.close()

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: zyooooxie@gmail.com
"""


def test_list():
    # https://redis.io/commands/?group=list

    r = redis_connect()
    test_list_ = 'test:zyooooxie:list'

    # RPUSH key element [element ...]
    # 将一个或多个值 init_value 插入到列表 key 的表尾(最右边)。
    # 如果有多个 init_value 值，那么各个 init_value 值按从左到右的顺序依次插入到表尾。
    # 如果 key 不存在，一个空列表会被创建并执行 RPUSH 操作。
    # 当 key 存在但不是列表类型时，返回一个错误。

    # 返回值： 执行 RPUSH 操作后，表的长度。

    # rpush(): Push ``values`` onto the tail of the list ``__name``

    r.delete(test_list_)
    Log.info(r.rpush(test_list_, '1f', '2s', '3d', '4e'))  # 新插入元素在右侧，如果list不存在则新建
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.rpush(test_list_, '1f1111', '2s2222'))  # 元素一个接一个地插入到列表的尾部，从最左边的元素到最右边的元素
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.rpush(test_list_, '3d3333', '1f1111', '1f1111'))  # 重复添加
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info('----')

    # LINDEX key index
    # 返回列表 key 中，下标为 index 的元素

    # 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    # 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
    # 如果 key 不是列表类型，返回一个错误。

    # 返回值: 列表中下标为 index 的元素。 如果 index 参数的值不在列表的区间范围内(out of range)，返回 nil 。

    # lindex(): Return the item from list ``__name`` at position ``index``

    Log.info(r.lindex(test_list_, 0))
    Log.info(r.lindex(test_list_, 300))  # index超了，返回的None

    # Negative indexes are supported and will return an item at the end of the list
    Log.info(r.lindex(test_list_, -1))
    Log.info(r.lindex(test_list_, -500))  # index超了，返回的None

    Log.info(r.lindex(gl_no_exist, 0))  # key不存在，返回的None

    Log.info('----')

    # LLEN key
    # 返回列表 key 的长度。
    # 如果 key 不存在，则 key 被解释为一个空列表，返回 0 。 如果 key 不是列表类型，返回一个错误。

    # 返回值： 列表 key 的长度。

    # llen(): Return the length of the list ``__name``

    Log.info(r.llen(test_list_))
    Log.info(r.llen(gl_real_list))

    Log.info(r.llen(gl_no_exist))  # key不存在，返回的0

    # Log.info(r.llen(gl_real_string))  # WRONGTYPE Operation against a key holding the wrong kind of value

    Log.info('----')

    # LINSERT key <BEFORE | AFTER> pivot element
    # 将值 element 插入到列表 key 当中，位于值 pivot 之前或之后。

    # 当 pivot 不存在于列表 key 时，不执行任何操作。 当 key 不存在时， key 被视为空列表，不执行任何操作。
    # 如果 key 不是列表类型，返回一个错误。

    # 返回值: 如果命令执行成功，返回插入操作完成之后，列表的长度。如果没有找到 pivot ，返回 -1 。如果 key 不存在或为空列表，返回 0 。

    # linsert(): Insert ``init_value`` in list ``__name`` either immediately before or after  [``where``] ``refvalue``
    # Returns the new length of the list on success or -1 if ``refvalue`` is not in the list.

    Log.info(r.linsert(gl_no_exist, 'before', 'zyooooxie', 'https://blog.csdn.net/zyooooxie'))

    Log.info(r.linsert(test_list_, 'BEFORE', 'zyooooxie', 'https://blog.csdn.net/zyooooxie'))

    r.rpush(test_list_, 'new0')
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.linsert(test_list_, 'BEFORE', 'new0', 'BEFORE-前面'))  # BEFORE（前）或AFTER（后）
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.linsert(test_list_, 'AFTER', 'new0', 'AFTER-后面'))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info('----')

    # LRANGE key start stop
    # 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。

    # 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。
    # 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

    # LRANGE 命令 是 (闭区间)；

    # 超出范围的下标值不会引起错误。
    # 如果 start 下标比 列表的结束 还要大，那么 LRANGE 返回一个空列表。
    # 如果 stop 下标比 列表的结束 还要大，Redis will treat it like the last element of the list.

    # 返回值: 一个列表，包含指定区间内的元素。 an empty array if the key doesn't exist.

    # lrange(): Return a slice of the list ``__name`` between position ``start`` and ``end``
    # ``start`` and ``end`` can be negative numbers

    Log.info(r.lrange(gl_no_exist, 0, -1))  # key不存在，返回[]

    Log.info(r.lrange(test_list_, 0, -1))  # 所有元素
    Log.info(r.lrange(test_list_, 0, 2))
    Log.info(r.lrange(test_list_, -16, -5))
    Log.info(r.lrange(test_list_, -8, 7))

    Log.info(r.lrange(test_list_, 16, 5))  # stop小于start，返回[]
    Log.info(r.lrange(test_list_, -16, -25))  # stop小于start，返回[]

    Log.info(r.lrange(test_list_, 5, 200))  # stop超了 最大index
    Log.info(r.lrange(test_list_, 200, 300))  # start超了 最大index

    Log.info('----')

    # LPUSH key element [element ...]
    # 将一个或多个值 init_value 插入到列表 key 的表头。

    # 如果有多个 value 值，那么各个 value 值按从左到右的顺序依次插入到表头。
    # 如果 key 不存在，一个空列表会被创建并执行 LPUSH 操作。
    # 当 key 存在但不是列表类型时，返回一个错误。

    # 返回值： 执行 LPUSH 命令后，列表的长度。

    r.delete(test_list_)

    Log.info(r.lpush(test_list_, 'zyooooxie'))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.lpush(test_list_, 'zyoooo', 'zy', 'zyooooxie', '123', 'zyooooxie', 456, 'zyooooxie', 789.001))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.lpush(test_list_, 'zyooooxie'))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info('----')

    # LPOP key [count]
    # 移除并返回列表 key 的头元素。

    # 返回值： 列表的头元素。 当 key 不存在时，返回 nil 。

    # lpop(): Remove and return the first item of the list ``__name``

    Log.info(r.lpop(gl_no_exist))

    Log.info(r.lrange(test_list_, 0, -1))
    Log.info(r.lpop(test_list_))

    Log.info(r.lrange(test_list_, 0, -1))
    Log.info(r.lpop(test_list_))

    Log.info('https://redis.io/commands/lpop')
    # Redis version >= 6.2.0: Added the `count` argument.

    Log.info('----')

    # RPOP key [count]
    # 移除并返回列表 key 的尾元素。

    # 返回值：列表的尾元素。 当 key 不存在时，返回 nil 。

    Log.info(r.rpop(gl_no_exist))

    Log.info(r.lrange(test_list_, 0, -1))
    Log.info(r.rpop(test_list_))

    Log.info(r.lrange(test_list_, 0, -1))

    # Redis version >= 6.2.0: Added the `count` argument.

    Log.info('----')

    # LREM key count element
    # 根据参数 count 的值，移除列表中与参数 init_value 相等的元素。

    # count 的值可以是以下几种：
    # count > 0 : 从表头开始向表尾搜索，移除与 init_value 相等的元素，数量为 count 。
    # count < 0 : 从表尾开始向表头搜索，移除与 init_value 相等的元素，数量为 count 的绝对值。
    # count = 0 : 移除表中所有与 init_value 相等的值。

    # 返回值： 被移除元素的数量。 因为不存在的 key 被视作空表(empty list)，所以当 key 不存在时， LREM 命令总是返回 0 。

    Log.info(r.lrem(gl_no_exist, count=0, value='zyooooxie'))  # key 不存在

    Log.info(r.lrem(gl_real_list, count=0, value='zyooooxie'))  # 没有这个value

    # 移除从表头到表尾
    Log.info(r.lrem(test_list_, count=2, value='zyooooxie'))  # 两个元素被移除，还剩一个
    Log.info(r.lrange(test_list_, 0, -1))

    # 移除从表尾到表头
    Log.info(r.lrem(test_list_, count=-10, value='zyooooxie'))  # 实际只移除1个
    Log.info(r.lrange(test_list_, 0, -1))

    # 移除表中所有的

    Log.info(r.lpush(test_list_, 'zyooooxie', 'zyooooxie'))
    Log.info(r.rpush(test_list_, 'zyooooxie', '123', 'zyooooxie', 'zyooooxie'))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.lrem(test_list_, count=0, value='zyooooxie'))
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info('----')

    # LSET key index element
    # 将列表 key 下标为 index 的元素的值设置为 value 。
    # 当 index 参数超出范围，或对一个空列表( key 不存在)进行 LSET 时，返回一个错误。

    # 返回值： 操作成功返回 ok ，否则返回错误信息。

    # lset(): Set ``position`` of list ``__name`` to ``init_value``

    Log.info(r.lset(test_list_, 1, 'new-1新值'))  # True
    Log.info(r.lrange(test_list_, 0, -1))

    Log.info(r.lset(test_list_, -1, '新值'))
    Log.info(r.lrange(test_list_, 0, -1))

    # r.lset(test_list_, 2222, 'new-4')  # 超出范围 redis.exceptions.ResponseError: index out of range
    # Log.info(r.lset(gl_no_exist, 0, 'zyooooxie'))  # redis.exceptions.ResponseError: no such key

    r.expire(test_list_, 600)

    r.close()

"""
@blog: https://blog.csdn.net/zyooooxie
@qq: 153132336
@email: zyooooxie@gmail.com
"""


def test_set():
    # https://redis.io/commands/?group=set

    r = redis_connect()
    test_set_ = 'test:zyooooxie:set'

    # SADD key member [member ...]
    # 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
    # 假如 key 不存在，则创建一个只包含 member 元素作成员的集合。 当 key 不是集合类型时，返回一个错误。

    # 返回值: 被添加到集合中的 新元素的数量，不包括被忽略的元素。

    # sadd(): Add ``init_value(write_pkl)`` to set ``__name``

    r.delete(test_set_)
    Log.info(r.sadd(test_set_, 'zyooooxie', '123', 'abc', 'zyooooxie'))
    # Log.info(r.sadd(test_set_, 'zyooooxie'))
    Log.info(r.smembers(test_set_))

    # 重复元素 会被忽略
    Log.info(r.sadd(test_set_, 'zyooooxie', '123', 'zyooooxie123', 'https://blog.csdn.net/zyooooxie', '123', 456))
    Log.info(r.smembers(test_set_))

    Log.info(r.sadd(test_set_, '456', 'https://blog.csdn.net/zyooooxie', 'zyooooxie', 789.789, 132, '132'))
    Log.info(r.smembers(test_set_))

    Log.info('----')

    # SMEMBERS key
    # 返回集合 key 中的所有成员。
    # 不存在的 key 被视为空集合。

    # 返回值: 集合中的所有成员。

    # smembers(): Return all members of the set ``__name``

    Log.info(r.smembers(gl_no_exist))  # 不存在的key

    Log.info(r.smembers(test_set_))

    Log.info(r.sadd(test_set_, *['new2222', 2222]))
    Log.info(r.smembers(test_set_))

    Log.info('----')

    # SCARD key
    # 返回 集合中元素的数量

    # 返回值： 集合的基数。 当 key 不存在时，返回 0 。

    # scard(): Return the number of elements in set ``__name``

    Log.info(r.scard(gl_no_exist))

    Log.info(r.scard(test_set_))

    r.sadd(test_set_, 'new', 'new2', 'new22', 'new222')
    Log.info(r.scard(test_set_))

    Log.info('----')

    # SISMEMBER key member
    # 判断 member 元素是否集合 key 的成员。

    # 返回值:如果 member 元素是集合的成员，返回 1 。 如果 member 元素不是集合的成员，或 key 不存在，返回 0 。

    # sismember(): Return a boolean indicating if ``init_value`` is a member of set ``__name``

    Log.info(r.sismember(test_set_, 'zyooooxie'))
    Log.info(r.sismember(test_set_, 'xie'))

    Log.info(r.sismember(gl_no_exist, 'zyooooxie'))  # False

    Log.info('----')

    # SREM key member [member ...]
    # 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。 当 key 不是集合类型，返回一个错误。

    # 返回值:   被成功移除的元素的数量，不包括被忽略的元素。

    # srem(): Remove ``values`` from set ``__name``

    Log.info(r.srem(test_set_, 'zyooooxie'))
    Log.info(r.smembers(test_set_))

    Log.info(r.srem(test_set_, 'zyooooxie', 'new2222', 'zyooooxie', '不存在的', 'new'))
    Log.info(r.smembers(test_set_))

    Log.info(r.srem(test_set_, '不存在的123'))
    Log.info(r.smembers(test_set_))

    # If key does not exist, it is treated as an empty set and this command returns 0.
    Log.info(r.srem(gl_no_exist, 'zyooooxie'))

    r.expire(test_set_, 600)

    r.close()