Unit01

一、Redis

1.1 概述

Redis是一款开源的、高性能的key-value数据库，它支持数据的持久化，并可以将数据保存在内存或磁盘中。

Redis支持多种数据结构，包括字符串、列表、集合和有序集合等。它还支持数据备份和集群化操作，可以提高系统的可用性和易用性。

Redis是一个非常流行的数据存储系统，被广泛应用于缓存、消息队列、计数器、排行榜等场景。

Redis的官网地址为：https://redis.io/

1.2 安装

# 安装
$ sudo apt install redis-server

#检查 Redis 是否已经安装成功
redis-cli ping

1.3 Redis-cli

Redis-cli是Redis的命令行接口，可以让用户直接在命令行终端中与Redis数据库进行交互。

在交互模式下，Redis-cli具有基本的行编辑功能，以提供熟悉的输入体验，其语法结构为：

redis-cli [OPTIONS] [cmd [arg [arg ...]]]

常用的redis-cli选项及其含义如下：

参数	含义
-h <host>	连接的Redis实例的主机，默认为127.0.0.1
-p <port>	Redis实例的端口，默认为6379
-a <password>	Redis实例的认证密码
-n <db>	Redis实例的数据库编号，默认为0
--raw	以原始格式输出 Redis 命令的结果

如

$ redis-cli -h 127.0.0.1 -p 6379 -n 2

知识回顾：登录MySQL服务器

$ mysql -u用户名 -p密码 -P端口号 -h服务器地址 -D数据库名称

默认情况下，Redis实例有16个数据库，编号从0到15。可以使用SELECT命令在不同的数据库之间进行切换

SELECT命令的语法结构为：

SELECT dbid

Redis的配置文件为redis.conf

Redis 的默认配置文件通常位于 /etc/redis 或 /usr/local/etc 目录

# 停止Redis服务器
$ sudo systemctl stop redis-server

# 启动Redis服务器
$ sudo systemctl start redis-server

# 重新启动Redis服务器
$ sudo systemctl restart redis-server

1.4 数据类型

Redis 支持多种数据类型，常用的数据类型有：

● 字符串（string）

● 列表（list）

● 集合（set）

● 有序集合（sorted set）

● 哈希（hash）

1.5 字符处理

在redis-cli命令行中，空格会被认为是两个参数之间的分隔符，所以输入包含空格或不可打印字符的字符串值时，要使用带引号的字符串。引号可以使用单引号或者双引号。

双引号字符串支持以下转义序列：

● \"- 双引号

● \n- 换行

● \r- 回车

● \t- 水平制表符

● \b- 退格键

● \a- 警报

● \\- 反斜杠

单引号仅允许以下转义序列：

● \'- 单引号

● \\- 反斜杠

1.6 键的命名规则

● 键名应该以英文字母开头，不能以数字或特殊字符开头

● 键名中只能出现小写字母、数字、英文点号(.)和英文半角冒号(😃

● 避免特殊字符，如下划线、空格、换行、单双引号以及其他转义字符

● 键名应该具有可读性和可管理性，

● 建议使用业务模块名、业务逻辑含义和value类型来命名键，以便更好地区分不同的键

如：

user:12345:name：表示用户 ID 为 12345 的用户的名称
product:67890:price：表示产品 ID 为 67890 的产品的价格
cart:54321:items：表示购物车 ID 为 54321 的购物车中的商品列表

二、通用命令

● KEYS

KEYS命令用于查找符合指定模式的键，其语法结构是：

KEYS pattern

其中，pattern 可以包括一些通配符，如：

● 星号（*）匹配任意数量的字符

● 问号（?） 匹配任意一个字符

● 方括号（[abc]） 匹配任意一个列在方括号中的字符

● \ 用作转义字符，比如查找包含实际星号*的键名

● DEL

DEL命令用于删除指定的键，如果指定键不存在，则被忽略。其语法结构是：

DEL key [key ...]

● FLUSHDB

FLUSHDB命令用于删除当前数据库中的所有键

FLUSHDB

示例代码如下：

SET a 1
SET b 2 
SET c 3
KEYS * 
# 1) "b"
# 2) "c"
# 3) "a"
DEL a
# (integer) 1
FLUSHDB
# OK

● EXISTS

EXISTS命令用于检测指定的键是否存在，其语法结构是：

EXISTS key [key ...]

若键存在返回1，否则返回0

● EXPIRE

EXPIRE命令用于设置键的过期时间，其语法结构是：

EXPIRE key seconds 

示例代码如下：

EXPIRE username 600
#(integer) 1

EXPIRE tarena 600
# (integer) 0

● EXPIREAT

EXPIREAT命令用于设置键的过期时间，其语法结构是：

EXPIREAT key unix-time-seconds 

● MOVE

MOVE命令用于将当前数据库的键移动到指定的数据库中，其语法结构是：

MOVE key db

● RENAME

RENAME命令用于修改指定的键名，其语法结构是：

RENAME key newkey

● RENAMENX

RENAMEEX命令用于仅当newkey不存在时，才将key更名为newkey，其语法结构是：

RENAMENX key newkey

● TYPE

TYPE命令用于返回键所存储的值的数据类型，其语法结构是：

TYPE key

● TTL

TTL命令用于返回指定键的剩余的生存时间（单位为秒），其语法结构是：

TTL key

关于TTL命令的返回值

返回值	说明
-2	指定键不存在
-1	未关联生存时间
整数	剩余的生存时间

示例代码如下:

TTL a
# (integer) -1
TTL d
#(integer) 3
TTL d
#(integer) -2

● PTTL

PTTL命令用于返回指定键的剩余的生存时间（单位为毫秒），其语法结构是：

PTTL key

关于PTTL命令的返回值

返回值	说明
-2	指定键不存在
-1	未关联生存时间
整数	剩余的生存时间

● SORT

SORT命令用于为列表、集合或者有序集合进行排序，其语法结构为：

SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern
  ...]] [ASC | DESC] [ALPHA] [STORE destination]

三、字符串(String)

3.1 概述

Redis中的字符串是最基本的数据结构之一，可以存储任何类型的数据，包括文本、序列化对象和二进制数据。每个字符串都有一个键来标识它，这个键是唯一的。Redis中的字符串是二进制安全的，这意味着Redis可以存储和处理任何类型的二进制数据。

Redis字符串的最大长度是512MB。这意味着，每个字符串对象的大小不能超过512MB。

3.2 常用命令

● SET

SET命令用于将字符串值value关联到key，如果key已经存在，则覆盖旧值，其语法结构是：

SET key value [NX | XX] [EX seconds | PX milliseconds][KEEPTTL]

选项说明

选项	说明
NX(Not Exist)	只有指定键不存在时才进行设置操作，只能添加不能更新
XX(Exist)	只有指定键存在时才进行设置操作，只能更新不能添加
EX seconds(EX，Expire)	设置生命周期时间，单位为秒
PX milliseconds(PX，Pixels)	设置生周期时间，单位为毫秒
KEEPTTL	保留与键相关的生命周期，适用于更新操作时

Pixels是图像中最小的单位，而毫秒是时间中最小的单位，因此Redis将毫秒称为时间中的"像素"

示例代码如下：

SET username Rose
SET age 23
SET password 123456

#失败，因为username的key已经存在
SET username NX Frank

#成功,因为username的key已经存在
SET username David XX
SET salary 4856.32 EX 30

#查看salary key的生命周期
TTL salary
SET salary 5000 KEEPTTL

#再次查看salary key的生命周期
TTL salary

# 在key mobile_13800138000 不存在时才为其赋值为 2369,并且设置生命周期为300秒

SET mobile_13800138000 2369 NX EX 300

关于SET命令的返回值

返回值	描述
OK	正常执行SET命令
nil	在执行NX或XX选项后，条件不符合时

● GET

GET命令用于返回 key 所关联的字符串值，如果 key 不存在将返回 nil ，其语法结构是：

GET key

示例代码如下：

GET username

# 将返加nil
GET mobile

● MSET

MSET命令用于同时设置一个或多个 key-value 对，其语法结构是：

MSET key value [key value ...]

示例代码如下：

MSET mobile 13800138000 verify 6379

● MGET

MGET命令用于返回所有指定的key的value。对于不是string类型的key或者指定key不存在时，将返回nil，其语法结构是：

MGET key [key ...]

示例代码如下：

MGET mobile verify

● MSETNX

MSETNX命令用于当且仅当所有给定 key 都不存在时才设置一个或多个 key-value 对，其语法结构是：

MSETNX key value [key value ...]

示例代码如下：

MSETEX mobile 13800138000 verify 6379 

返回值	描述
1	所有值都设置成功时
0	至少有一个值设置失败时

● INCR

INCR命令用于将指定键存储的数字值加1，返回值为累加后的结果，其语法结构是：

INCR key

示例代码如下：

INCR age

● INCRBY

INCRBY命令用于将指定的键存储的数字值加上增量值，返回值为累加后的结果，其语法结构是：

INCRBY key increment

示例代码如下：

INCRBY age 5

● INCRBYFLOAT

INCRBYFLOAT命令用于将指定键存储的值加上或者减去指定指定的浮点增量值，返回值为累加后的结果，其语法结构是：

INCRBYFLOAT key increment

示例代码如下：

INCRBYFLOAT salary 450.79

● DECR

DECR命令用于将指定键存储的数字值减1，返回值为累加后的结果，其语法结构是：

DECR key

示例代码如下：

DECR age

● DECRBY

DECRBY命令用于将指定的键存储的数字值减去增量值，返回值为累加后的结果，其语法结构是：

DECRBY key decrement

示例代码如下：

DECRBY age 3

示例代码

SET age 23
# OK

SET salary 3679.45
# OK

INCR age
#(integer) 24

INCR age
#(integer) 25

INCRBY age 3
#(integer) 28

INCRBYFLOAT salary 0.01
# "3679.45999999999999996"

INCRBYFLOAT salary -0.01
# "3679.44999999999999996"

● APPEND

APPEND命令用于将value追加到指定键的未尾，并返回字符串的新长度，其语法结构是：

APPEND key value

示例代码如下：

SET username Tom
append username AID
#(integer) 6

● STRLEN

STRLEN命令用于返回指定键所存储的字符串的长度，其语法结构是：

STRLEN key

● GETRANGE

GETRANGE命令用于返回部分字符串，其语法结构是：

GETRANGE key start end

示例代码如下：

SET str "This is a string"

GETRANGE str 0 3

GETRANGE str -3 -1

GETRANGE str 0 -1

GETRANGE str 10 100

3.3 应用场景

● 缓存

● 计数器

● 分布式锁

● 会话存储

四、列表(List)

4.1 概述

列表是一个有序的字符串列表，可以存储一组字符串。Redis列表的底层实现采用了双向链表，因此可以在列表的两端进行快速的插入和删除操作。

Redis列表是一个非常灵活和强大的数据结构，可以用于实现队列、栈和发布订阅等功能。

列表最多可以存储 2^32-1（4294967295）个元素，这是由于Redis使用32位有符号整数来保存列表的长度。

SELECT 1

4.2 常用命令

● LPUSH

LPUSH命令用于将一个或多个值插入到列表的头部，并返回列表的长度，若列表不存在将自动创建之。其语法结构是：

LPUSH key element [element ...]

示例代码如下：

LPUSH databases MySQL 'SQL Server' Oracle DB2  

● RPUSH

RPUSH命令用于将一个或多个值插入到列表的尾部，并返回列表的长度，若列表不存在将自动创建之，其语法结构是：

RPUSH key element [element ...]

示例代码如下：

RPUSH databases MariaDB PostgreSQL

● LRANGE

LRANGE命令用于获取列表指定范围内的元素，其语法结构是：

LRANGE key start stop

示例代码如下：

LRANGE databases 0 -1

LRANGE databases 2 4

LRANGE databases -3 -1

LRANGE databases 10 5

如果start参数超过列表总长度，则返回empty array

● LLEN

LLEN命令用于获取列表的长度，其语法结构是：

LLEN key

示例代码如下：

LLEN databases

● LPUSHX

LPUSHX命令用于将一个或多个值插入到已存在的列表头部，并返回列表的长度，其语法结构是：

LPUSHX key element [element ...]

示例代码如下：

LPUSHX databases SQLite

● RPUSHX

RPUSHX命令用于将一个或多个值插入到已存在的列表尾部，并返回列表的长度，其语法结构是：

RPUSHX key element [element ...]

示例代码如下：

RPUSHX databases Sybase

● LINSERT

LINSERT命令用于在参考点之前或之后插入元素，其语法结构是：

LINSERT key <BEFORE | AFTER> pivot element

示例代码如下：

LINSERT databases AFTER 'SQL Server' Informix

● LSET

LSET命令用于通过索引设置列表元素的值，其语法结构是：

LSET key index element

示例代码如下：

LSET databases 2 'Oracle Database'

● LINDEX

LINDEX命令用于获取列表中指定索引的元素的值，其语法结构为：

LINDEX key index

示例代码如下：

LINDEX databases 2

● LPOP

LPOP命令用于移除并返回列表中的第一个元素，其语法结构是：

LPOP key

示例代码如下：

LPOP databases

● RPOP

RPOP命令用于移除并返回列表中的最后一个元素，其语法结构是：

RPOP key 

示例代码如下：

RPOP databases

● BRPOP

BRPOP命令用于移除并返回列表中的最后一个元素，如果列表不存在元素时会阻塞为指定时长，其语法结构为

BRPOP key [key ...] timeout

示例代码如下：

BRPOP databases 3  

● BLPOP

RRPOP命令用于移除并返回列表中的第一个元素，如果列表不存在元素时会阻塞为指定时长，其语法结构为：

BLPOP key [key ...] timeout

示例代码如下：

BLPOP databases 3  

● LREM

LREM命令用于删除列表中的元素，其语法结构为：

LREM key count element

关于count选项说明如下：

count选项	说明
count > 0	从头到尾删除指定元素
count < 0	从尾到头删除指定元素
count = 0	删除所有指定元素

● LTRIM

LTRIM命令用于对列表进行修剪–只保留指定区间内的元素，其语法结构为：

LTRIM key start stop

五、集合(SET)

5.1 概述

集合是一个无序的、唯一的字符串集合，可以存储多个字符串。Redis集合的底层实现采用了哈希表，因此可以在常数时间内执行添加、删除和查找操作。

Redis集合是一个非常灵活和强大的数据结构，可以用于实现标签、好友关系和推荐等功能。

集合的最大成员数为2^32-1（即4294967295），每个集合最多可以存储40多亿个成员。

SELECT 2

5.3 常用命令

● SADD

SADD命令用于向集合添加一个或多个成员，其语法结构是：

SADD key member [member ...]

示例代码如下：

SADD friends:user1 沧海 沙粒 圣女果 刘召 芬达 刀锋 秋天

SADD friends:user2 战士 秋天 小烟一叼 沧海 田儿 斯威 顺期自然

● SMEMBERS

SMEMBERS命令用于返回集合中的所有成员，其语法结构是：

SMEMBERS key

示例代码如下：

SMEMBERS friends:user1
SMEMBERS friends:user2

● SREM

SREM命令用于从集合中删除一个或多个成员，其语法结构是：

SREM key member [member ...]

● SPOP

SPOP命令用于移除并返回集合中的一个或多个随机元素，其语法结构是：

SPOP key [count]

● SISMEMBER

SISMEMBER命令用于返回指定元素是否为集合中的成员，其语法结构是：

SISMEMBER key member

示例代码如下：

SISMEMBER friends:user1 田儿 
SISMEMBER friends:user2 田儿 

● SRANDMEMBER

SRANDMEMBER命令用于返回集合中一个或多个随机成员，其语法结构是：

SRANDMEMBER key [count]

示例代码如下：

SRANDMEMBER friends:user1 2

● SMOVE

SMOVE命令用于将指定成员从源集合移动到目标集合，其语法结构是：

SMOVE source destination member

示例代码如下：

SMOVE friends:user1 friends:user2 刘召

● SDIFF

SDIFF命令用于返回指定集合的差集，其语法结构是：

SDIFF key [key ...]

● SINTER

SINTER命令用于返回指定集合的交集，其语法结构是：

SINTER key [key ...]

示例代码如下：

SINTER friends:user1 friends:user2

● SUNION

SUNION命令用于返回指定集合的并集，其语法结构是：

SUNION key [key ...]

● SUNIONSTORE

SUNION命令用于返回指定集合的并集并存储到目标集合，其语法结构是：

SUNIONSTORE destination key [key ...]

● SINTERSTORE

SINTERSTORE命令用于返回指定集合的交集并存储到目标集合，其语法结构是：

SINTERSTORE destination key [key ...]

● SDIFFSTORE

SDIFFSTORE命令用于返回指定集合的差集并存储到目标集合，其语法结构是：

SDIFFSTORE destination key [key ...]

---

标签案例

每个商品可以有多个标签，而每个标签可以对应多个商品。使用 Redis 的无序集合来实现这个功能：

SADD tag:电脑	  1001 1002 1003 1004 1005 1006 1007 1008 1009 10010
SADD tag:游戏本  1003 1005 1007 1009 10010
SADD tag:超级本  1001 1002 1005 1008

# 超级本 与 游戏本的交集

SINTER tag:游戏本 tag:超级本

# 其他类型的电脑
SDIFF tag:电脑 tag:游戏本 tag:超级本

六、有序集合

6.1 概述

有序集合是一个有序的、唯一的字符串集合，可以存储多个字符串，并为每个字符串关联一个分数。Redis有序集合的底层实现采用了跳跃表和哈希表，因此可以在对数时间内执行添加、删除和查找操作。

Redis有序集合是一个非常灵活和强大的数据结构，可以用于实现排行榜、计数器和时间序列等功能。

Redis有序集合的最大成员数为2^32-1（即4294967295），每个有序集合最多可以存储40多亿个成员。

SELECT 3

6.2 常用命令

● ZADD

ZADD命令用于向有序集合添加一个或多个成员或者更新已存在成员的分数，其语法结构是：

ZADD key [NX | XX] [GT | LT] [CH] [INCR] score member [score member ...]

选项	说明
NX	仅在元素存在时进行创建操作
XX	仅在元素不存在时进行创建操作
CH	更新成员的分数值
INCR	添加新成员时是否自动将其分数与现有分数相加

示例代码如下：

ZADD audience:1  8.2 singer1 8.5 singer2 9.0 singer3
ZADD audience:2  8.5 singer1 8.3 singer2 8.8 singer3
ZADD judger:1 7.8 singer1 8.3 singer2 8.8 singer3
ZADD judger:2 8.1 singer1 7.6 singer2 8.9 singer3

● ZRANGE

ZRANGE命令用于返回有序集合内指定区域内的成员，其语法结构是：

ZRANGE key start stop [WITHSCORES]

示例代码如下：

ZRANGE audience:1 0 -1 WITHSCORES

● ZCOUNT

ZCOUNT命令用于计算有序集合中指定区间分数的成员数量，其语法结构是：

ZCOUNT key min max

示例代码如下：

ZCOUNT audience:1 7 8.5

● ZSCORE

ZSCORE命令用于返回有序集合中成员的分数值，其语法结构是：

ZSCORE key member

示例代码如下：

ZSCORE audience:1 singer3

● ZREM

ZREM命令用于移除有序集合中的一个或多个成员，其语法结构是：

ZREM key member [member ...]

● ZPOPMIN

ZPOPMIN命令用于删除最小分数的成员，其语法结构是：

ZPOPMIN key [count]

● ZPOPMAX

ZPOPMAX命令用于删除最大分数的成员，其语法结构是：

ZPOPMIN key [count]

● ZINCRBY

ZINCRBY命令用于有序集合中对指定成员的分数加上增量值，其语法结构是：

ZINCRBY key increment member

● ZINTERSTORE

ZINTERSTORE命令用于计算指定的一个或多个有序集合中的交集并存储到目标集合，其语法结构是：

ZINTERSTORE destination numkeys key [key ...] 
[WEIGHTS weight [weight ...]] 
[AGGREGATE <SUM | MIN | MAX>]

示例代码如下：

ZINTERSTORE ranks 4 audience:1 audience:2 judger:1 judger:2 WEIGHTS 1 1 2 2 AGGREGATE SUM

● ZUNIONSTORE

ZUNIONSTORE从用于指定指定的一个或多个有序集合的并集并存储到目标有序集合中，其语法结构是：

ZUNIONSTORE destination numkeys key [key ...] 
[WEIGHTS weight [weight ...]] 
[AGGREGATE <SUM | MIN | MAX>]

七、哈希(Hash)

7.1 概述

哈希是一个键值对集合，可以存储多个键值对。Redis哈希的底层实现采用了哈希表，因此可以在常数时间内执行添加、删除和查找操作。

Redis哈希是一个非常灵活和强大的数据结构，可以用于实现对象存储、缓存和计数器等功能。

SELECT 3

7.2 常用命令

● HSET

HSET命令用于为哈希中的一个或多个字段设置值，其语法结构是：

HSET key field value [field value ...]

示例代码如下：

HSET user:1 id 5 username Rose age 25

HSET  buyer_tom 6 "1,14,1"  3 "3,8199,1"

● HSETNX

HSETNX 命令用于为哈希中的一个字段设置值，仅当该字段不存在时才设置成功。其语法结构是：

HSETNX key field value

示例代码如下：

HSETNX user:1 salary 4578.31

● HGET

HGET命令用于获取指定字段的值，其语法结构是：

HGET key field

示例代码如下：

HGET user:1 username

● HMGET

HMGET命令用于获取哈希中指定字段的值，其语法结构为：

HMGET key field [field ...]

示例代码如下：

HMGET user:1 id username

● HGETALL

HGETALL命令用于获取哈希中指定键的所有字段和值，其语法结构是：

HGETALL key

示例代码如下：

HGETALL user:1

● HKEYS

HKEYS命令用于获取哈希中所有的字段，其语法结构为：

HKEYS key

示例代码如下：

HKEYS user:1

● HVALS

HVALS命令用于获取哈希中所有字段的值，其语法结构是：

HVALS key

示例代码如下：

HVALS user:1

● HSTRLEN

HSTRLEN命令用于返回哈希中指定字段值的长度，其语法结构是：

HSTRLEN key field

HSTRLEN user:1 username

● HINCRBY

HINCRBY命令用于为指定字段加上增量值，其语法结构是：

HINCRBY key field increment

示例代码如下：

HINCRBY user:1 age 1

● HINCREBYFLOAT

HINCRBYFLOAT命令用于为指定字段的浮点数值加上增量值，其语法结构是：

HINCRBYFLOAT key field increment

示例代码如下：

HINCRBYFLOAT user:1 salary 500

● HDEL

HDEL命令用于删除一个或多个哈希字段，其语法结构是：

HDEL key field [field ...]

示例代码如下：

HDEL user:1 sex

● HEXISTS

HEXISTS命令用于返回是否存在指定字段，其语法结构是：

HEXISTS key field

示例代码如下：

HEXISTS user:1 id

● HLEN

HLEN命令用于获取哈希中字段的数量，其语法结构为：

HLEN key

示例代码如下：

HLEN user:1

八、数据类型的应用场景

数据类型	应用场景
String	缓存、计数器、分布式锁等
List	消息队列、任务队列、最新消息列表等
Set	标签、好友关系、推荐等
Sorted Set	排行榜、计数器、时间序列等
Hash	对象存储、缓存、计数器等

Unit02

一、Redis模块

1.1 概述

Redis模块 是 Redis 的官方 Python 客户端，用于与 Redis 服务器进行交互。它提供了一组简单而强大的 API，可以方便地进行连接、数据读写、事务、管道等操作。

1.2 安装

Redis模块版本	Redis版本
3.5.3	<= 6.2
>= 4.5.0	5.0 ~ 7.0
>= 5.0.0	5.0 ~ 现在

$ sudo pip3 install redis

1.2 构造函数

import redis
redis.Redis(host='localhost',port=6379,db=0,password=None,decode_responses=False)

Redis获取取出的结果默认是字节，可以设定 decode_responses=True 改成字符串

示例代码如下：

import redis

r = redis.Redis(host='localhost',db=0,port=6379,password=None,decode_responses=True)

1.4 通用方法

● delete()

delete()方法用于删除一个或多个指定名称的键，其语法结构为：

Redis.delete(*names)

示例代码如下：

r.delete('usesrname')

● select()

select()方法用于打开数据库，其语法结构为：

Redis.select(index)

示例代码如下：

r.select(4)

● keys()

keys()方法用于以列表形式返回匹配指定模式的键，其语法结构为：

Redis.keys(pattern="*")

示例代码如下：

r.keys()
r.keys(pattern = '?a*')

● exists()

exists()方法用于返回指定键存在的数量，其语法结构为：

Redis.exsits(*names)

示例代码如下：

r.exists('id','username','members')

● expire()

expire()方法用于设置键的生命周期，其语法结构为：

Redis.expire(name=name,time=expire)

示例代码如下：

r.expire(name='username',time=86400)

● expireat()

expireat()方法用于设置键的生命周期，其语法结构为：

Redis.expireat(name=name,when=when)

示例代码如下：

import time
timestamp = int(time.time()) + 86400
r.expireat(name='id',when=timestamp)

● move()

move()方法用于将当前数据库的键移动到指定的数据库中，其语法结构为：

Redis.move(name=name,db)

示例代码如下：

r.move(name='id',db=2)

● rename()

rename()方法用于用于修改指定的键名，其语法结构为：

Redis.rename(src,dst)

示例代码如下：

r.rename('databases','database')

● renamenx()

renamenx()方法用于仅当dst不存在时，才将src更名为dst，其语法结构为：

Redis.renamenx(src,dst)

示例代码如下：

r.renamenx('databases','database')

● type()

type()方法用于返回键所存储的值的数据类型，其语法结构为：

Redis.type(name)

示例代码如下：

r.type(name='username')

● ttl()

ttl()方法用于用于返回指定键的剩余的生存时间（单位为秒），其语法结构为：

Redis.ttl(name)

示例代码如下：

r.ttl(name='username')

● pttl()

pttl()方法用于返回指定键的剩余的生存时间（单位为毫秒），其语法结构为：

Redis.pttl(name)

示例代码如下：

r.pttl(name='username')

1.5 字符串

● set()

set()方法用于将字符串值value关联到key，如果key已经存在，则覆盖旧值，其语法结构为：

Redis.set(name=KeyT,value=EncodableT,ex=None,px=None,nx=False,XX=False,keepttl=False)

示例代码如下：

r.set(name='username',value='Rose')
r.set(name='password',value='123456',ex=86400)

● get()

get()方法用于返回 key 所关联的字符串值，其语法结构为：

Redis.get(name=Key)

示例代码如下：

r.get(name='username')

● mset()

mset()方法用于同时设置一个或多个 key-value 对，其语法结构为：

Redis.mset(mapping={})

示例代码如下：

r.mset(mapping={'id':1,'age':25})

● mget()

mget()方法用于返回所有指定的key的value，其语法结构为：

Redis.mget(keys=str|list)

示例代码如下：

r.mget('id','username')

r.mget(keys=['id','username','password'])

● msetnx()

msetnx()方法用于当且仅当所有给定 key 都不存在时才设置一个或多个 key-value 对，其语法结构为：

Redis.msetnx(mapping={})

示例代码如下：

r.mset(mapping={'salary':5600,'mobile':'13800138000'})

● incr()

incr()方法用于将指定键存储的数字值累加指定量值，其语法结构为：

Redis.incr(name=key,amount=1)

示例代码如下：

r.incr(name='age')

● incrby()

incrby()方法用于将指定键存储的数字值累加指定量值，其语法结构为：

Redis.incrby(name=key,amount=1)

示例代码如下：

r.incrby(name='age',amount=2)

● incrbyfloat()

incrbyfloat()方法用于将指定键存储的值加上或者减去指定指定的浮点增量值，其语法结构为：

Redis.incrbyfloat(name=key,amount=1.0)

示例代码如下：

r.incrbyfloat(name='salary',amount=566.30)

● decr()

decr()方法用于将指定键存储的数字值累减指定量值，其语法结构为：

Redis.decr(name=key,amount=1)

示例代码如下：

r.decr(name='age')

● decrby()

decrby()方法用于将指定键存储的数字值累减指定量值，其语法结构为：

Redis.decrby(name=key,amount=1)

示例代码如下：

r.decrby(name='age',amount=2)

● append()

append()方法用于将value追加到指定键的未尾，并返回字符串的新长度，其语法结构为：

Redis.append(key=key,value=value)

示例代码如下：

r.append(key='password',value='78')

● strlen()

strlen()方法用于返回指定键所存储的字符串的长度，其语法结构为：

Redis.strlen(key=key)

示例代码如下：

r.strlen(key='username')

● getrange()

1.6 列表

● lpush()

lpush()方法用于将一个或多个值插入到列表的头部，并返回列表的长度，其语法结构为：

Redis.lpush(name, *values)

示例代码如下：

r.lpush('databases','MySQL','Oracle')

● rpush()

rpush()方法用于将一个或多个值插入到列表的尾部，并返回列表的长度，其语法结构为：

Redis.rpush(name, *values)

示例代码如下：

r.rpush('databases','MariaDB','SQL Server')

● lrange()

lrange()方法用于获取列表指定范围内的元素，其语法结构为：

Redis.lrange(name, start, end)

示例代码如下：

databases = r.lrange('databases', 0, -1)
print(databases)

● llen()

llen()方法用于获取列表的长度，其语法结构为：

Redis.llen(name)

示例代码如下：

len = r.llen('databases')
print(f'共有{len}个元素')

● lpushx()

lpushx()方法用于将一个或多个值插入到已存在的列表头部（如果name存在），并返回列表的长度，其语法结构为：

Redis.lpushx(name, *values)

示例代码如下：

r.lpushx('students', 'Tom', 'John')

● rpushx()

rpushx()方法用于将一个值插入到已存在的列表尾部（如果name存在），并返回列表的长度，其语法结构为：

Redis.rpushx(name, value)

示例代码如下：

r.rpushx('students', 'Rose')

● linsert()

linsert()方法用于在参考点之前或之后插入元素，其语法结构为：

Redis.linsert(name, where, refvalue, value)

示例代码如下：

r.linsert('students','AFTER','Tom','Ben')

● lset()

lset()方法用于通过索引设置列表元素的值，其语法结构为：

Redis.lset(name, index, value)

示例代码如下：

r.lset('students',2,'Brandi')

● lindex()

lindex()方法用于获取列表中指定索引的元素的值，其语法结构为：

Redis.lindex(name, index)

示例代码如下：

print(r.lindex('students',-1))

● lpop()

lpop()方法用于移除并返回列表中的第一个元素，其语法结构为：

Redis.lpop(name)

示例代码如下：

first = r.lpop('students')
print(first)

● rpop()

rpop()方法用于移除并返回列表中的最后一个元素，其语法结构为：

Redis.rpop(name)

示例代码如下：

last = r.rpop('students')
print(last)

● blpop()

blpop()方法用于移除并返回列表中的第一个元素，如果列表不存在元素时会阻塞为指定时长，其语法结构为：

Redis.blpop(keys, timeout=0)

示例代码如下：

import time
print(time.time())
r.blpop(['countries','students'],3)
print(time.time())

● brpop()

brpop()方法用于移除并返回列表中的最后一个元素，如果列表不存在元素时会阻塞为指定时长，其语法结构为：

Redis.brpop(keys, timeout=0)

示例代码如下：

import time
print(time.time())
r.brpop('countries',3)
print(time.time())

● lrem()

lrem()方法用于删除列表中的元素，其语法结构为：

Redis.lrem(name, count, value)

● ltrim()

ltrim()方法用于对列表进行修剪–只保留指定区间内的元素，其语法结构为：

Redis.ltrim(name, start, end)

二、缓存

2.1 概述

缓存是一种牺牲存储空间来换取访问时间的技术。

缓存可以将计算结果或数据存储在高速存储器中，以便提高访问速度，它可以提高应用程序的性能和响应速度。

在 Web 应用程序中，缓存通常用于存储动态页面和静态资源（例如图像、样式表和 JavaScript 文件）的副本，以便在下一次请求时快速提供这些内容。

Django所提倡缓存思想：

given a URL, try finding that page in the cache
if the page is in the cache:
    return the cached page
else:
    generate the page
    save the generated page in the cache (for next time)
    return the generated page

2.2 缓存方式

Django提供了多种缓存方式，包括：

• 本地内存缓存：将缓存数据存储在本地内存中，适用于小规模应用程序和开发环境

• 数据库缓存：将缓存数据存储在关系数据库中，适用于需要持久化缓存数据的应用程序

• 文件缓存：将缓存数据存储在本地文件系统中，适用于需要在多个服务器之间共享缓存数据的应用程序

• Memcached 缓存：将缓存数据存储在 Memcached 缓存服务器中，适用于需要高性能缓存的大型应用程序

• Redis 缓存：将缓存数据存储在 Redis 缓存服务器中，适用于需要高性能缓存和高级缓存功能的应用程序

2.2.1 本地内存缓存

settings.py中关于本地内存缓存的配置如下：

CACHES = {
    'memory': {
        # 缓存类型为本地内存缓存
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        # 缓存提供了一个唯一的名称
        'LOCATION': 'unique-snowflake',
        # 存数据的过期时间（单位为秒），默认为 None，即永久存储
        'TIMEOUT': 300,
        # 缓存选项
        'OPTIONS': {
            # 限制缓存中的最大条目数
            'MAX_ENTRIES': 1000,
            # 当达到 MAX_ENTRIES 时，被删除的条目的比例。实际比例是 1 / CULL_FREQUENCY
            'CULL_FREQUENCY':3            
        },
    }
}

2.2.2 数据库缓存

settings.py中关于数据库缓存的配置如下：

CACHES = {
    'database': {
        # 缓存类型为数据库缓存
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        # 缓存数据表的名称
        'LOCATION': 'my_cache_table',
        # 存数据的过期时间（单位为秒），默认为 None，即永久存储
        'TIMEOUT': 300,
        # 缓存选项
        'OPTIONS': {
            # 限制缓存中的最大条目数
            'MAX_ENTRIES': 1000,
            # 当达到 MAX_ENTRIES 时，被删除的条目的比例。实际比例是 1 / CULL_FREQUENCY
            'CULL_FREQUENCY':20            
        },
    }
}

创建缓存数据表：

python3 manage.py createcachetable

2.2.3 文件缓存

settings.py中关于文件缓存的配置如下：

CACHES = {
    'file': {
        # 缓存类型为数据库缓存
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        # 缓存数据文件夹的名称
        'LOCATION': BASE_DIR / 'caches',
        # 存数据的过期时间（单位为秒），默认为 None，即永久存储
        'TIMEOUT': 300,
        # 缓存选项
        'OPTIONS': {
             # 限制缓存中的最大条目数
            'MAX_ENTRIES': 1000,
            # 当达到 MAX_ENTRIES 时，被删除的条目的比例。实际比例是 1 / CULL_FREQUENCY
            'CULL_FREQUENCY':3
        },
    }
}

2.3 缓存实现

Django中实现缓存的方法有：视图缓存、模板片断缓存、底层缓存API

2.3.1 视图缓存

django.views.decorators.cache 定义了一个 cache_page 装饰器，它将自动缓存视图的响应：

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def view_func(request):
    ...

如果许多 URL 指向相同的视图，每个 URL 将被单独缓存

也可以在 URLconf 中指定视图缓存：

from django.views.decorators.cache import cache_page

urlpatterns = [
    path('foo/<int:code>/', cache_page(60 * 15)(view_func)),
]

2.3.2 模板片断缓存

实现模板片断缓存需要以下两个步骤：

第一步：通过{% load cache %} 标签用于加载缓存模板标签库，其语法结构为：

{% load cache %}
<html>
    <head>
        ...
    </head>
    <body>
        ...
    </body>
</html>

第二步：通过{% cache %}标签设置缓存片断及时效时间，其语法结构为：

{% cache [expire_time] [cache_key] %}
    Cached content goes heres
{% endcache %}

其中：

• expire_time 参数指定了缓存数据的过期时间（单位为秒），默认为 None，即永久缓存

• cache_key 参数指定缓存数据的键，用于将缓存数据与特定的视图或模板片段关联起来

通过传递一个或多个附加参数，参数可能是带有或不带过滤器的变量：

{% load cache %}
{% cache 500 sidebar request.user.username %}
    .. sidebar for logged in user ..
{% endcache %}

2.3.3 底层缓存API

可以通过django.core.cache.caches 对象访问在 CACHES 配置的缓存：

from django.core.cache import caches
cache1 = caches['myalias']
cache2 = caches['myalias']

django.core.cache.cache作为快捷方式，默认缓存可以通过 django.core.cache.cache 引用：

from django.core.cache import cache

这个对象等价于 caches['default']

set()

set()方法用于存储指定键的缓存数据。可以指定缓存数据的过期时间，其语法结构是：

cache.set(key, value, timeout=None, version=None)

get()

get()方法用于获取指定键的缓存数据。如果缓存不存在，则返回默认值，其语法结构是：

cache.get(key, default=None, version=None)

add()

add()方法用于存储指定的缓存数据。如果缓存已经存在，则不进行任何操作，其语法结构是：

cache.add(key, value, timeout=None, version=None)

get_many()

get_many()方法用于获取多个键的缓存数据。返回一个字典，包含所有存在的缓存数据，其语法结构是：

cache.get_many(keys, version=None)

set_many()

set_many()方法用于存储多个键的缓存数据，其语法结构是：

cache.set_many(data, timeout=None, version=None)

delete()

delete()方法用于删除指定键的缓存数据，其语法结构是：

cache.delete(key, version=None)

delete_many()

delete_many()方法用于删除多个键的缓存数据，其语法结构是：

cache.delete_many(keys, version=None)

clear()

clear()方法用于删除所有缓存数据，其语法结构是：

cache.clear()

三、Django-Redis

3.1 概述

django-redis 基于 BSD 许可, 是一个使 Django 支持 Redis cachen 后端的全功能组件。

3.2 安装

$ pip3 install django-redis

3.3 作为 cache backend 使用配置

CACHES = {
    # 别名
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    },
}

3.4 原生客户端使用

在某些情况下你的应用需要进入原生 Redis 客户端使用一些 django cache 接口没有暴露出来的进阶特性. 为了避免储存新的原生连接所产生的另一份设置, django-redis 提供了方法 get_redis_connection(alias) 使你获得可重用的连接字符串.

from django_redis import get_redis_connection
conn = get_redis_connection("default")