Redis超详细教程（1）

数据存储形式：Redis 使用键值对存储数据，每个键都是唯一的，对应一个值。
可存储的数据格式：Redis 支持多种数据结构，包括：
- 字符串（Strings）
- 列表（Lists）
- 集合（Sets）
- 有序集合（Sorted Sets）
- 哈希表（Hashes）
数据存储位置：Redis 将数据存储在内存中，这确保了高速的读写操作。此外，Redis 通过持久化机制可以将数据定期写入磁盘，保证数据的持久性。
数据库支持的操作：Redis 提供了丰富的操作命令，确保数据的原子性操作，如事务操作（Transaction）和单个命令的原子性。
数据增减操作：Redis 支持各种操作，如 push/pop 操作用于列表、add/remove 操作用于集合等，这些操作可以快速地修改数据结构。
数据逻辑操作：Redis 提供了取交集、并集和差集等集合运算操作，这些操作对于数据处理和分析非常有用。
自动排序：有序集合（Sorted Sets）是 Redis 中的一种特殊数据类型，它可以根据成员关联的分数（score）自动排序，这使得 Redis 在处理需要排序的数据时非常高效。

总体而言，Redis 是一款功能强大的非关系型数据库，适用于需要高性能、高并发读写和灵活数据操作的场景，例如缓存、会话存储、实时数据分析等。

Redis 数据库操作场景实例

Redis 数据库由于其快速的读写能力和丰富的数据结构，适用于多种实际场景。以下是一些常见的 Redis 数据库操作场景实例：

缓存：

场景：应用程序常用的缓存数据，如数据库查询结果、页面内容等，以加快数据访问速度。
操作：使用 Redis 的字符串数据类型存储缓存数据，并设置适当的过期时间，以便定期更新或重新加载数据。

会话存储：

场景：存储用户的会话信息，例如登录状态、购物车内容等。
操作：将用户会话信息存储在 Redis 的哈希表中，每个用户一个键，字段存储具体的会话数据，通过 Redis 提供的原子性操作来更新和检索会话信息。

实时数据分析：

场景：需要对实时生成的数据进行快速的分析和聚合。
操作：利用 Redis 的有序集合（Sorted Sets）或者计数器数据类型，例如 HyperLogLog 算法用于基数估计，来进行数据统计和分析。

消息队列：

场景：应用程序需要异步处理任务或者事件通知。
操作：使用 Redis 的列表数据类型作为消息队列，生产者将任务或消息推送到列表尾部，消费者从列表头部获取任务进行处理，实现简单的发布-订阅模式。

排行榜：

场景：需要展示用户得分或其他指标的排名。
操作：利用 Redis 的有序集合存储用户的得分和标识，通过集合操作（如范围获取）快速获取排名信息，并支持动态更新用户的得分信息。

分布式锁：

场景：确保在分布式环境下对关键资源或操作的互斥访问。
操作：使用 Redis 的字符串数据类型和 SETNX（SET if Not eXists）命令实现分布式锁，通过设置锁键和过期时间来避免死锁和锁过期问题。

发布订阅：

场景：需要实现消息的实时发布和订阅。
操作：Redis 提供了发布-订阅模式，可以通过 PUBLISH 发布消息，通过 SUBSCRIBE 订阅消息频道，用于实现实时消息通信或事件驱动的架构。

下载 Redis 安装包

安装教程就不多讲解了，可参考Redis 数据库安装、配置、访问这篇文章

二、Redis常见命令

Redis数据结构介绍

Redis 是一个基于内存的 key-value 数据库，其中 key 通常是字符串类型，但是其 value 的类型非常丰富，可以是以下几种主要类型：

字符串（String）：最基本的数据类型，可以存储字符串、整数或者浮点数。
哈希表（Hash）：Redis 的哈希表是一个键值对集合，适合存储对象。每个哈希表可以存储多个字段和值之间的映射。
列表（List）：双向链表实现的列表，支持在两端插入和删除元素，适合用于实现队列或者栈。
集合（Set）：无序集合，可以存储多个不重复的字符串元素，支持集合间的交集、并集和差集等操作。
有序集合（Sorted Set）：和普通集合类似，但每个成员都关联了一个分数（score），根据分数排序。适合需要排序的数据结构，如排行榜。
位图（Bitmap）：可以对字符串类型的位进行操作，支持一些特定的位运算操作。
HyperLogLog：用于基数统计的算法，可以估计集合中的不同元素的数量。
地理空间索引（GeoSpatial）：可以存储地理位置信息，并支持计算两点之间距离等操作。

Redis 的这些数据结构和类型使其不仅仅是简单的 key-value 存储，而是一个功能强大的数据处理工具，适合用于各种场景下的数据存储和操作需求。

贴心小建议：命令不要死记，学会查询就好啦

Redis为了方便我们学习，将操作不同数据类型的命令也做了分组，在官网（ Commands | Docs ）可以查看到不同的命令：

当然我们也可以通过Help命令来帮助我们去查看命令

Redis 通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

KEYS pattern：用于查找符合指定模式 pattern 的所有 key。这是一个比较强大但也需要谨慎使用的命令，因为它会遍历整个数据库来寻找匹配的 key，可能会影响性能。
DEL key [key ...]：删除一个或多个指定的 key。删除成功返回删除的 key 数量，如果 key 不存在则被忽略。
EXISTS key：检查给定 key 是否存在。存在返回 1，不存在或已过期返回 0。
EXPIRE key seconds：设置 key 的过期时间，单位为秒。当 key 的过期时间到达后，key 会自动被删除。
TTL key：获取 key 的剩余过期时间（TTL，Time To Live），以秒为单位。如果 key 没有设置过期时间（永久有效），返回 -1；如果 key 已过期或不存在，返回 -2。

这些命令在日常的 Redis 数据管理中非常实用，可以帮助控制 key 的存活周期，以及进行数据的清理和管理。记住，在使用 KEYS 命令时要特别注意，避免在生产环境中频繁使用，以免影响 Redis 的性能。

通过help [command] 也可以查看一个命令的具体用法，例如：

例子

KEYS 指令

查看符合模板的所有 key：

# 设置一些测试数据
> SET user:1 "John"
OK
> SET user:2 "Alice"
OK
> SET product:100 "iPhone"
OK

# 查找所有以 "user:" 开头的 key
> KEYS user:*
1) "user:1"
1) "user:2"

# 查找所有以 "product:" 开头的 key
> KEYS product:*
1) "product:100"

小提示：在生产环境下，不推荐使用keys 命令，因为这个命令在key过多的情况下，效率不高

DEL 指令

删除一个或多个指定的 key：

# 删除单个 key
> DEL user:1
(integer) 1   # 返回 1 表示成功删除一个 key

# 删除多个 key
> DEL user:2 product:100
(integer) 2   # 返回 2 表示成功删除两个 key

EXISTS 指令

判断指定的 key 是否存在：

# 检查存在的 key
> EXISTS user:1
(integer) 1   # 返回 1 表示存在

# 检查不存在的 key
> EXISTS user:2
(integer) 0   # 返回 0 表示不存在

EXPIRE 指令

设置 key 的过期时间：

# 设置 user:1 过期时间为 60 秒
> EXPIRE user:1 60
(integer) 1   # 返回 1 表示设置成功

# 等待 60 秒后查看 key 是否存在
> EXISTS user:1
(integer) 0   # 返回 0 表示 key 已过期并被删除

TTL 指令

获取 key 的剩余过期时间：

# 设置 user:1 的过期时间为 30 秒
> EXPIRE user:1 30
(integer) 1

# 获取 user:1 的剩余过期时间
> TTL user:1
(integer) 28   # 返回剩余的秒数，直到 key 过期

Redis命令-String命令

在 Redis 中，String 类型的数据确实是非常灵活的，它可以存储不同类型的值，包括普通字符串、整数和浮点数。

普通字符串（string）：普通字符串是最常见的 Redis String 类型，可以存储任意文本数据。
整数类型（int）：Redis 可以将字符串类型的值作为整数来处理，这使得它可以支持整数的自增和自减操作。
浮点类型（float）：从 Redis 2.6 版本开始，Redis 支持浮点数类型。浮点数可以进行自增和自减操作，也可以设置和获取。

总结来说，Redis 的 String 类型非常灵活，可以根据值的不同格式（普通字符串、整数、浮点数）进行存储和操作。这种灵活性使得 Redis 在各种场景中都能有效地存储和处理不同类型的数据。

String的常见命令有：

SET：设置一个键值对，如果键已存在则覆盖其值。
GET：获取指定键的值。
MSET：同时设置多个键值对。
MGET：同时获取多个键的值。
INCR：将存储的整数值递增1。
INCRBY：将存储的整数值递增指定的步长。
INCRBYFLOAT：将存储的浮点数值递增指定的步长。
SETNX：设置键值对，仅当键不存在时才设置成功。
SETEX：设置键值对，并指定过期时间（秒）。

例子

# SET：添加或者修改已经存在的一个 String 类型的键值对
SET mykey "Hello"

# GET：根据 key 获取 String 类型的 value
GET mykey

# MSET：批量添加多个 String 类型的键值对
MSET key1 "value1" key2 "value2" key3 "value3"

# MGET：根据多个 key 获取多个 String 类型的 value
MGET key1 key2 key3

# INCR：让一个整型的 key 自增1
SET mycounter "10"
INCR mycounter

# INCRBY：让一个整型的 key 自增并指定步长
SET mycounter "10"
INCRBY mycounter 2

# INCRBYFLOAT：让一个浮点类型的数字自增并指定步长
SET myfloat "10.5"
INCRBYFLOAT myfloat 1.2

# SETNX：添加一个 String 类型的键值对，前提是这个 key 不存在，否则不执行
SETNX mykey "value"

# SETEX：添加一个 String 类型的键值对，并且指定有效期（秒）
SETEX mykey 60 "value"

Redis命令-Key的层级结构

在 Redis 中，虽然没有像 MySQL 中的表（Table）的概念，但可以通过命名规范来区分不同类型的 key，避免冲突和混淆。

如何区分不同类型的 Key

1、使用前缀区分类型：可以通过给 key 添加前缀来区分不同类型的数据。例如：

用户相关的 key 可以使用 heima:user:1
商品相关的 key 可以使用 heima:product:1

这种方式利用了 Redis 的命名空间来确保不同类型的数据不会发生冲突。

2、命名约定和规范：建议使用清晰、一致的命名约定，确保所有开发者都理解和遵循这些规范。例如，前缀后可以跟随一个简短的描述性词汇，以更好地表示数据的用途或类型。

示例和数据存储

假设有一个名为 heima 的项目，存储了用户和商品信息：

用户信息存储为 JSON 格式：

 SET heima:user:1 '{"id":1, "name": "Jack", "age": 21}'

商品信息存储为 JSON 格式：

SET heima:product:1 '{"id":1, "name": "小米11", "price": 4999}'

结果与可视化

存储完成后，在 Redis 可视化界面或者通过命令行查看，可以看到数据被按照以下结构存储：

这种命名约定和结构使得在 Redis 中管理和查询用户和商品信息变得简单和清晰。

总结

通过在 Redis 中使用命名空间前缀来区分不同类型的数据，我们可以有效地模拟类似于数据库表的结构，避免数据冲突，并且方便管理和查询各种类型的数据。这种做法非常适合需要高效且清晰地组织数据的应用场景。

Redis命令-Hash命令

Redis 的 Hash 类型类似于其他编程语言中的字典或映射类型，如Java中的 HashMap。它适合于存储和操作对象的各个字段，使得针对对象的单个字段进行 CRUD 操作变得非常方便和高效。

Hash 结构优势

字段级别的操作:Redis Hash 允许你单独操作对象的每个字段。这意味着你可以针对对象的某个特定字段进行读取、更新或删除操作，而不需要加载和处理整个对象。
存储结构:每个 Redis 的 Hash 类型实际上是一个键值对集合，其中的每个键对应一个对象，每个对象存储了一系列字段和对应的值。
效率和性能:当需要频繁地修改对象的某个字段时，使用 Hash 类型比将整个对象序列化为 JSON 字符串存储更为高效。这是因为 Hash 类型支持直接对单个字段进行操作，而不需要反序列化整个对象。
适用场景:Hash 类型适合存储和管理需要频繁更新的对象，尤其是具有多个字段的对象。例如，在电子商务应用中存储商品信息，每个商品可以作为一个 Hash 类型存储，其中包含名称、价格、描述等字段。

使用场景示例

对于对象的每个字段，可以使用 Redis 的 Hash 类型分别存储，如商品对象中的名称、价格、描述等字段，每个字段可以通过其对应的 Hash 命令进行操作，非常方便和高效。

总结来说，Redis 的 Hash 类型是一种非常适合存储和操作对象字段的数据结构，能够在需要对对象的特定字段进行频繁操作时提供高效的解决方案。

Hash类型的常见命令

在 Redis 中，Hash 类型的数据结构支持一系列的命令来对字段进行操作。以下是一些常见的 Hash 类型命令及其功能：

HSET key field value：设置哈希表 key 中字段 field 的值为 value。如果字段 field 已经存在于哈希表中，将会被更新；如果 key 不存在，一个新的哈希表将被创建并执行操作。
HGET key field：获取哈希表 key 中字段 field 的值。
HMSET key field1 value1 [field2 value2 ...]：批量设置哈希表 key 中多个字段的值。每个 field 可以关联一个 value。
HMGET key field1 [field2 ...]：批量获取哈希表 key 中多个字段的值。
HGETALL key：获取哈希表 key 中所有字段和值。返回的是一个列表，包含所有的字段和关联的值。
HKEYS key：获取哈希表 key 中所有的字段名（不包含值）。
HINCRBY key field increment：将哈希表 key 中的字段 field 的值增加 increment。 increment 必须是一个整数值。
HSETNX key field value：只有在字段 field 不存在时，设置哈希表 key 中字段 field 的值为 value。如果 field 已经存在，操作无效。

例子（python版）

import redis

# 连接到 Redis 服务器
r = redis.Redis(host='localhost', port=6379, db=0, password='填写自己的Redis密码')

# 用户 ID
user_id = 'user:123'

# 使用 HSET 批量设置用户信息
user_info = {
    'username': 'john_doe',
    'email': 'john.doe@example.com',
    'age': '30',
    'city': 'New York',
    'status': 'active'
}
# 因为在最新版本的 Redis Python 客户端中，Redis.hmset() 方法已经被标记为废弃，所以使用 Redis.hset() 方法来代替。
# r.hmset(user_id, user_info)
for key, value in user_info.items():
    r.hset(user_id, key, value)

# 使用 HGETALL 获取用户的所有信息
user_data = r.hgetall(user_id)
print("用户信息:", {key.decode('utf-8'): value.decode('utf-8') for key, value in user_data.items()})

# 使用 HGET 获取用户的特定字段值（比如邮箱）
email = r.hget(user_id, 'email')
print("用户邮箱:", email.decode('utf-8'))  # 因为返回的是 bytes 类型，需要解码为字符串

# 使用 HSET 更新用户的状态为 'inactive'
r.hset(user_id, 'status', 'inactive')
print("用户状态更新为 inactive")

# 使用 HINCRBY 增加用户的年龄
r.hincrby(user_id, 'age', 1)
new_age = r.hget(user_id, 'age')
print("用户年龄增加到", new_age.decode('utf-8'))  # 解码为字符串

# 使用 HKEYS 获取用户所有字段名
fields = r.hkeys(user_id)
print("用户字段名:", [field.decode('utf-8') for field in fields])  # 解码为字符串列表

# 使用 HSETNX 设置用户的加入日期（如果不存在）
r.hsetnx(user_id, 'join_date', '2024-07-26')
print("设置加入日期为 2024-07-26（如果不存在）")

# 使用 HMGET 批量获取用户的城市和状态
city_status = r.hmget(user_id, ['city', 'status'])
print("用户城市和状态:", [item.decode('utf-8') for item in city_status])  # 解码为字符串列表

Redis命令-List命令

Redis 中的 List 类型的确可以被看作是一个双向链表结构，与 Java 中的 LinkedList 类似，具有许多相似的特性和用途。

特点

有序性： List 中的元素按照插入顺序排列，可以通过索引进行访问和操作。
元素可以重复： List 中允许存储相同的元素多次。
插入和删除快速：在 List 的两端进行插入和删除操作的时间复杂度为 O(1)，这使得它们在处理大量数据时效率很高。
查询速度一般：尽管可以通过索引访问元素，但由于 Redis 是单线程的，因此在大型列表中进行范围查询时可能会影响性能。

常见用途

朋友圈点赞列表：可以使用 List 存储每篇朋友圈的点赞用户，方便快速插入新的点赞用户和检索点赞情况。
评论列表：存储文章或帖子的评论，可以按照时间顺序存储，方便获取最新评论或者分页展示评论。
消息队列： Redis 的 List 可以作为简单的消息队列，支持生产者向列表尾部插入消息，消费者从列表头部取出消息，实现轻量级的队列功能。
任务列表：类似消息队列，可以用 List 存储待处理的任务，工作进程可以通过阻塞式弹出命令 BLPOP 或 BRPOP 获取新的任务，实现任务分发和处理。
实时数据更新：可以用 List 存储最近更新的数据记录，比如实时监控数据、用户行为记录等，便于快速获取最新的数据状态。

Redis 的 List 类型在实际应用中非常灵活，结合其快速的插入和删除操作，适合于需要高效处理有序数据集合的场景。

List的常见命令

LPUSH key element [element ...]：将一个或多个元素插入到列表 key 的左侧。
LPOP key：移除并返回列表 key 左侧的第一个元素，如果列表为空则返回 nil。
RPUSH key element [element ...]：将一个或多个元素插入到列表 key 的右侧。
RPOP key：移除并返回列表 key 右侧的最后一个元素。
LRANGE key start stop：返回列表 key 中指定范围内的所有元素，从 start 到 stop。
BLPOP key [key ...] timeout 和 BRPOP key [key ...] timeout：类似于 LPOP 和 RPOP，但如果列表为空，则阻塞 timeout 秒等待元素出现，超时后返回 nil 或空数组。
LINDEX key index：返回列表 key 中指定位置 index 的元素。
LLEN key：返回列表 key 的长度。
LINSERT key BEFORE|AFTER pivot element：将元素 element 插入到列表 key 中 pivot 元素的前或后。
LREM key count element：从列表 key 中移除 count 个与 element 相等的元素。
LTRIM key start stop：对列表 key 进行修剪，保留从 start 到 stop 之间的元素，其他元素删除。
RPOPLPUSH source destination：移除列表 source 的最后一个元素，并将该元素添加到列表 destination 的头部。
LSET key index element：将列表 key 中位置 index 的元素设置为 element。
RPOPLPUSH：移除 source 列表的最后一个元素，并将该元素添加到 destination 列表的头部。

Redis命令-Set命令

Redis 中的 Set 类型具有与 Java 中的 HashSet 类似的特性，它们都是基于哈希表实现的集合结构，具备以下特征：

无序性：集合中的元素没有特定的顺序，即不像列表（List）类型那样按照插入顺序存储元素。
唯一性：集合中不允许重复的元素，每个元素在集合中是唯一的。
快速查找：集合内部使用哈希表来存储元素，因此查找、插入、删除操作的时间复杂度都是 O(1)。
支持集合操作：Redis 的 Set 类型支持多种集合操作，如交集、并集、差集等，这使得可以方便地对多个集合进行组合和计算。

Set的常见命令

下面是 Redis 中常用的一些集合操作命令，这些命令使得 Redis 的 Set 类型在实际应用中非常有用：

SADD key member [member ...]：向集合中添加一个或多个成员。
SCARD key：获取集合中成员的数量。
SMEMBERS key：获取集合中的所有成员。
SISMEMBER key member：检查成员是否存在于集合中。
SREM key member [member ...]：从集合中移除一个或多个成员。
SPOP key [count]：随机移除并返回集合中的一个或多个成员。
SRANDMEMBER key [count]：随机返回集合中的一个或多个成员，但不移除成员。
SINTER key [key ...]：计算多个集合的交集。
SUNION key [key ...]：计算多个集合的并集。
SDIFF key [key ...]：计算多个集合的差集。

通过这些命令，可以高效地管理和操作集合数据，适用于需要存储唯一值且需要进行快速查找和集合运算的场景，比如社交网络的关注列表、标签系统等。

例子（python版）

import redis

# 连接到 Redis 服务器
r = redis.Redis(host='localhost', port=6379, db=0, password='填写自己的Redis密码')

# 清空可能存在的旧数据
r.flushdb()

# 添加成员到集合 'set1'
r.sadd('set1', 'a', 'b', 'c')

# 添加成员到集合 'set2'
r.sadd('set2', 'b', 'c', 'd')

# 获取集合 'set1' 的所有成员
print("Set 1 Members:", r.smembers('set1'))

# 获取集合 'set2' 的所有成员
print("Set 2 Members:", r.smembers('set2'))

# 计算并输出 'set1' 和 'set2' 的交集
print("Intersection of set1 and set2:", r.sinter('set1', 'set2'))

# 计算并输出 'set1' 和 'set2' 的并集
print("Union of set1 and set2:", r.sunion('set1', 'set2'))

# 计算并输出 'set1' 和 'set2' 的差集
print("Difference of set1 and set2:", r.sdiff('set1', 'set2'))

# 演示移动成员从 'set1' 到 'set2'
r.smove('set1', 'set2', 'a')

# 获取修改后的集合 'set1' 和 'set2' 的所有成员
print("Updated Set 1 Members:", r.smembers('set1'))
print("Updated Set 2 Members:", r.smembers('set2'))

# 断开与 Redis 的连接
r.close()

Redis命令-SortedSet类型

Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。

特性

可排序性：Sorted Set 中的每个元素都关联一个分数（score），Redis 根据这个分数对集合中的元素进行排序。分数可以是浮点数，允许元素按照从低到高或从高到低的顺序排列。
元素唯一性：与普通 Set 类型一样，Sorted Set 中的元素是唯一的，不允许重复。
快速查询：Redis 使用跳表（SkipList）和哈希表来实现 Sorted Set，这使得对元素的插入、删除和获取操作的时间复杂度为 O(log(N))，其中 N 是集合中的元素数量。这比传统的平衡二叉树要快，并且在元素数量较大时仍能保持高效。

应用场景

排行榜：最常见的应用是实现排行榜功能。例如，可以将每个用户的分数作为 Sorted Set 中的 score，用户 ID 或用户名作为成员，这样就可以轻松地按照分数高低获取排名信息。
优先级队列：由于 Sorted Set 可以按照分数排序，因此可以用来实现优先级队列，优先处理分数高的任务或消息。
范围查询：可以根据分数的范围快速获取一批元素，例如获取分数在某个区间内的前几名用户或者前几条数据。
带权重的数据集合：适合存储带有权重的数据，例如文章的热度排行，商品的评分排行等。

SortedSet的常见命令

ZADD key score member：将一个或多个成员元素及其分数添加到有序集合中，如果成员已经存在，则更新其分数。
ZREM key member：从有序集合中移除指定的成员。
ZSCORE key member：获取指定成员的分数。
ZRANK key member：获取指定成员在有序集合中的排名（从 0 开始，按分数升序排列）。
ZREVRANK key member：获取指定成员在有序集合中的排名（按分数降序排列）。
ZCARD key：获取有序集合中的成员数量。
ZCOUNT key min max：计算有序集合中分数在给定范围内的成员数量。
ZINCRBY key increment member：增加指定成员在有序集合中的分数。
ZRANGE key min max [WITHSCORES]：按照分数从小到大的顺序，获取指定排名范围内的成员。可选参数 [WITHSCORES] 可以返回成员及其分数。
ZREVRANGE key min max [WITHSCORES]：按照分数从大到小的顺序，获取指定排名范围内的成员。
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]：按照分数范围获取成员列表，可选参数 [WITHSCORES] 返回成员及其分数，[LIMIT offset count] 控制返回结果的数量。
ZDIFFSTORE destination numkeys key [key ...]：计算并存储多个有序集合的差集。
ZINTERSTORE destination numkeys key [key ...]：计算并存储多个有序集合的交集。
ZUNIONSTORE destination numkeys key [key ...]：计算并存储多个有序集合的并集。

注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，

例子（python版）

import redis

# 连接到 Redis 服务器
redis_client = redis.Redis(host='localhost', port=6379, db=0, password='填写自己的Redis密码')

# 添加元素到有序集合
redis_client.zadd('myset', {'member1': 10, 'member2': 15, 'member3': 5, 'member4': 20})

# 获取指定成员的分数
score = redis_client.zscore('myset', 'member2')
print(f'member2 的分数为：{score}')

# 获取指定成员的排名（升序）
rank = redis_client.zrank('myset', 'member2')
print(f'member2 的排名为（升序）：{rank}')

# 获取指定成员的排名（降序）
rev_rank = redis_client.zrevrank('myset', 'member2')
print(f'member2 的排名为（降序）：{rev_rank}')

# 获取有序集合的元素数量
cardinality = redis_client.zcard('myset')
print(f'myset 的基数为：{cardinality}')

# 获取指定排名范围内的成员（升序）及其分数
members_with_scores = redis_client.zrange('myset', 0, -1, withscores=True)
print('按升序排列的成员及其分数:')
for member, score in members_with_scores:
    print(f'{member}: {score}')

# 按分数范围获取成员列表（升序）及其分数
members_in_range = redis_client.zrangebyscore('myset', min=10, max=20, withscores=True)
print('分数范围在 [10, 20] 内的成员及其分数:')
for member, score in members_in_range:
    print(f'{member}: {score}')

# 增加指定成员的分数
redis_client.zincrby('myset', 5, 'member2')

# 计算并存储多个有序集合的交集，并将结果存储到新的有序集合中
redis_client.zinterstore('destination', ['myset'], aggregate='SUM')

# 计算并存储多个有序集合的并集，并将结果存储到新的有序集合中
redis_client.zunionstore('destination', ['myset'], aggregate='SUM')

# 获取新有序集合的成员（升序）及其分数
new_set_members = redis_client.zrange('destination', 0, -1, withscores=True)
print('新有序集合中的成员及其分数:')
for member, score in new_set_members:
    print(f'{member}: {score}')

Redis命令-Geospatial类型

Geospatial（地理空间）数据处理指的是处理和分析与地理位置相关的数据。在计算机科学和信息技术领域，处理地理空间数据通常涉及存储、查询、分析和可视化地理位置信息。

Redis 提供了强大的 Geospatial 功能，可以有效地处理和查询地理空间数据，主要依赖于其 Sorted Set 数据结构和相关的 Geospatial 操作命令。允许用户存储一组地理位置点（通常是经度和纬度坐标）以及与之关联的一个或多个成员（如城市名称）。

Geospatial的常见命令

GEOADD：将一个或多个地理位置成员添加到指定的键中。每个成员由经度、纬度和成员名组成。
```
GEOADD cities 13.361389 38.115556 Palermo
GEOADD cities 15.087269 37.502669 Catania
```
GEOPOS：获取指定成员的经纬度坐标。
```
GEOPOS cities Palermo Catania
```
GEODIST：计算两个成员之间的距离。
```
GEODIST cities Palermo Catania [unit]
```
其中 [unit] 可以是 m（米）、km（千米）、mi（英里）、ft（英尺）等单位。
GEORADIUS 和 GEORADIUSBYMEMBER：根据指定的地理位置坐标或成员，查询在指定范围内的成员。
```
GEORADIUS cities 15 37 200 km
GEORADIUSBYMEMBER cities Palermo 100 km
```
GEOHASH：获取指定成员的 Geohash 值，用于进行基于地理位置的快速索引。
```
GEOHASH cities Palermo
```

注意事项和最佳实践

坐标范围：在使用 GEOADD 添加地理位置时，确保经度范围在 -180 到 180 度之间，纬度范围在 -85.05112878 到 85.05112878 度之间（这是 WGS-84 坐标系的标准范围）。
单位选择：根据实际需求选择合适的距离单位进行距离计算，例如米、千米、英里或英尺。
性能考虑：Redis 的 Geospatial 操作通常具有高效的性能，但需要根据数据量和访问模式进行适当的规模和优化。
数据导入和更新：通过批量导入或定期更新地理位置数据，确保数据的实时性和准确性。

应用场景

Redis 的 Geospatial 功能适用于许多应用场景，包括：

位置服务和地理信息系统：如基于位置的搜索、附近位置查找等。
实时物流和配送管理：跟踪和优化配送路径、服务覆盖区域等。
社交网络和位置基础服务：查找附近的朋友、活动或服务。

总之，Redis 的 Geospatial 功能为处理和查询地理空间数据提供了高效、简单和可扩展的解决方案，使得开发者能够轻松地集成地理位置功能到各种应用中。

Redis命令-HyperLogLog类型

HyperLogLog 是一种用于估计集合中唯一元素数量（基数）的算法，它通过使用固定的内存空间来实现对大数据集合的基数估计，而不需要准确存储每个元素。

HyperLogLog 的原理

HyperLogLog 使用了一种称为基数估计器（cardinality estimator）的数据结构，其核心思想是：

哈希函数：首先，将每个元素通过哈希函数映射到一个固定位数的二进制串中。
前导零计数：接着，统计这些哈希值的前导零的数量。前导零是指从左边开始数，连续的零的数量。
估计基数：根据前导零的最大数量，估算集合中不同元素的数量。

主要特点和优势

空间效率：HyperLogLog 只需要固定大小的空间来存储估计器的状态，通常是 12 KB 左右，不受集合大小的影响。
时间效率：计算基数的时间复杂度是 O(1)，即使对于大数据集合，计算也非常迅速。
精度控制：HyperLogLog 提供了可以控制估计精度和内存占用之间的权衡（通过调整位数），通常可以达到较高的准确度。官方给出的误差率是0.81%。

应用场景

HyperLogLog 主要用于需要快速统计大数据集合中唯一元素数量的场景，例如：

用户统计：在分析网站访问者、活跃用户或注册用户时，快速估计唯一用户的数量。
广告点击计数：估算不同广告点击的唯一用户数量，用于广告效果分析和计费。
数据流处理：在数据流中估计不同 IP 地址的数量，用于流量分析和异常检测。

HyperLogLog 的常见命令

HyperLogLog 是一种用于估算集合基数（唯一元素数量）的算法，在 Redis 中，可以使用以下命令来操作 HyperLogLog：

PFADD key element [element ...]：将一个或多个元素添加到 HyperLogLog 结构中。
```
PFADD hll_key element1 element2 element3
```
PFCOUNT key [key ...]：返回给定 HyperLogLog 的基数估计值，或者多个 HyperLogLog 的并集的基数估计值。
```
PFCOUNT hll_key1 hll_key2
```
PFMERGE destkey sourcekey [sourcekey ...]：将多个 HyperLogLog 合并为一个 HyperLogLog。
```
PFMERGE hll_dest hll_source1 hll_source2
```

总结

HyperLogLog 是一种高效的基数估计算法，通过使用固定的内存空间和哈希函数，可以在不需要存储所有元素的情况下快速估算大数据集合中的唯一元素数量。它在大数据处理和实时分析中广泛应用，为处理大规模数据集合提供了重要的工具和性能优化。

Redis命令-Bitmap类型

Bitmap（位图）是一种数据结构，用于高效地存储和操作大量布尔类型的数据，其中每个位(bit)只能存储0或1。在计算机科学中，位图常用于需要紧凑存储大量布尔信息的场景，例如标记某些元素的出现或者状态的记录。

数据结构

存储方式：位图通过一个二进制数组来表示，其中每个位(bit)对应于某个元素或者某个特定的标记。如果位的值为1，表示相应元素存在或者标记为真；如果为0，表示不存在或者标记为假。
内存占用：位图在存储大量布尔信息时非常高效，因为它们通常使用的是紧凑的位存储，而不是传统的字节或更大的数据结构。

应用场景

集合操作：位图可以用来表示和操作大型集合，例如在数据库中记录用户的行为或者特征，以快速进行成员检查和集合操作（并集、交集、差集等）。
索引：在搜索引擎中，位图可以用来快速过滤或者聚合文档的属性，例如哪些文档包含某个关键词或者特定的属性。
压缩存储：位图通常比传统的数组或哈希表占用更少的内存，因此在大数据集上能够显著减少存储开销。

总之，位图是一种在需要高效存储和操作大量布尔信息时非常有用的数据结构，特别适用于需要快速成员检查或集合操作的场景。

注意事项

空间与时间复杂度：位图的主要优势在于其空间效率和部分集合操作的快速执行速度，但在某些情况下可能需要权衡空间与查询速度。
限制：位图的主要限制在于它们只能存储布尔类型的信息，且位操作可能需要额外的计算步骤来实现更复杂的逻辑。

Bitmap的常见命令

Bitmaps（位图）在计算机科学中有许多常见的操作命令，主要用于设置、清除、检查位以及执行位运算。这些操作命令通常作为位图数据结构的基本操作，用于管理和操作位级别的信息。以下是常见的位图命令和操作：

SETBIT key offset value：设置指定位图 key 中偏移量为 offset 的位的值为 value（0或1）。
GETBIT key offset：获取指定位图 key 中偏移量为 offset 的位的值（返回0或1）。
BITCOUNT key [start end]：计算指定位图 key 中设置为1的位的数量。可选地，可以指定起始和结束偏移量范围。
BITOP operation destkey key [key ...]：对多个位图执行位操作，并将结果存储在目标位图 destkey 中。操作可以是 AND（求交集）、OR（求并集）、XOR（求异或）、NOT（取反）。
BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment]：对位图 key 中的位域执行多种操作。例如，GET 获取指定偏移量处的位域值，SET 设置指定偏移量处的位域值，INCRBY 增加指定偏移量处的有符号整数。
BITPOS key bit [start] [end]：查找位图 key 中第一个设置为给定位 bit 值的偏移量。可选地，可以指定起始和结束偏移量范围。

例子（python版）

import redis

class RedisBitmap:
    def __init__(self, key, size):
        self.redis = redis.StrictRedis(host='localhost', port=6379, db=0, password='填写自己的Redis密码')  # 连接到 Redis
        self.key = key  # Redis 中存储位图的键名
        self.size = size  # 位图的大小（位数）

    def set_bit(self, offset):
        # 设置位图中偏移量为 offset 的位为1
        self.redis.setbit(self.key, offset, 1)

    def clear_bit(self, offset):
        # 清除位图中偏移量为 offset 的位为0
        self.redis.setbit(self.key, offset, 0)

    def get_bit(self, offset):
        # 获取位图中偏移量为 offset 的位的值（0或1）
        return self.redis.getbit(self.key, offset)

    def __str__(self):
        # 返回位图的二进制表示形式
        bitmap_str = ""
        for offset in range(self.size):
            bitmap_str += str(self.get_bit(offset))
        return bitmap_str

if __name__ == "__main__":
    bitmap = RedisBitmap("my_bitmap", 8)  # 创建一个8位的位图，存储在 Redis 中的 "my_bitmap" 键下

    bitmap.set_bit(1)   # 设置第2位为1
    bitmap.set_bit(3)   # 设置第4位为1
    bitmap.set_bit(5)   # 设置第6位为1

    print("当前位图：", bitmap)  # 打印当前位图

    print("偏移量为3的位：", bitmap.get_bit(3))  # 获取第4位的值

    bitmap.clear_bit(3)  # 清除第4位
    print("清除偏移量3处的位后的位图：", bitmap)  # 打印清除后的位图

正在奋斗的程序猿

关注

21
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
Redis超详细教程（1）

字符串（String）：最基本的数据类型，可以存储字符串、整数或者浮点数。哈希表（Hash）：Redis 的哈希表是一个键值对集合，适合存储对象。每个哈希表可以存储多个字段和值之间的映射。列表（List）：双向链表实现的列表，支持在两端插入和删除元素，适合用于实现队列或者栈。集合（Set）：无序集合，可以存储多个不重复的字符串元素，支持集合间的交集、并集和差集等操作。有序集合（Sorted Set）：和普通集合类似，但每个成员都关联了一个分数（score），根据分数排序。
复制链接

扫一扫