Python（Redis 中 String/List/Hash 类型数据操作）

1、下载 redis 模块

• pip install redis

2、redis 数据库两种连接方式

• 简单连接
  • decode_responses=True，写入和读取的键值对中的 value 为 str 类型，不加这个参数写入的则为字节类型

import redis

re = redis.Redis(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)    # host 是 redis 主机，需要 redis 服务端和客户端都启动  redis 默认端口是 6379，password 是 redis 数据库访问密码，db 是库
value = re.get("Student1")    # 取出键 Student 对应的值
print(value)

#结果如下
zhangsan

• 使用连接池

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
print(re.get("Student1"))

# 结果如下
zhangsan

3、redis 基本操作命令

• String 操作
  • redis 中的 String 在在内存中按照一个 name 对应一个 value 来存储

• • get(name)　　获取 name 的 value 值

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
print(re.get("Student1"))

# 结果如下
zhangsan

• • mget(keys， *args) 　　批量获取多个 value 值　　

import redis

re = redis.Redis(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
value = re.mget("Student1","Student2")    # 同时获取键 Student1 和 Student2 的 value 值
print(value)

# 结果如下
['zhangsan', 'lisi']

• • getrange(key，start，end)　　取出索引 [start,end] 所对应的序列

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
name1 = re.get("Student1")
print(name1)
name2 = re.getrange("Student1",0,3)     # 取出索引 [0,3] 所对应的序列
print(name2)

# 结果如下
zhaoliu
zhao

• • set(name，value，ex=None，px=None，nx=False，xx=False)　　在 redis 中设置值
    • 默认不存在则创建，存在则修改
    • ex，过期时间（秒）
    • px，过期时间（毫秒）
    • nx，如果设置为 True，则只有 name 不存在时，当前 set 操作才执行，同 setnx(name, value）
    • xx，如果设置为 True，则只有 name 存在时，当前 set 操作才执行

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.set("Student","Alex")    # 设置 Student 值为 Alex
name = re.get("Student")
print(name)

# 结果如下
Alex

• • mset(dict)　　批量设置值

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.mset({"Student1":"zhangsan","Student2":"lisi"})

• • getset(name，value)　　设置新值，打印原值

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
print(re.getset("Student1","zhaoliu"))  # 将 Student1 对应的值更新为 zhaoliu，并且返回原来的值

# 结果如下
wangwu    # 返回的原来的值

• • append(name，value)　　在 name 对应的值后面追加内容 value

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
name1 = re.get("Student1")
print(name1)
re.append("Student1","liu")     # 在 Student1 对应的值上追加字符串 liu
name2 = re.get("Student1")
print(name2)

# 结果如下
zhaoliu
zhaoliuliu

• • strlen(name)　　返回name对应值的字节长度
    • 一个汉字 3 个字节

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
name = re.get("Student1")
w = re.strlen("Student1")        # 获取 Student1 所对应的字符串长度
print(name)
print(w)

# 结果如下
zhaoliu
7

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
name = re.get("Student1")
w = re.strlen("Student1")        # 获取 Student1 所对应的字符串长度
print(name)
print(w)

# 结果如下
赵六
6

• List 操作
  • redis 中的 List 在内存中按照一个 name 对应一个 List 来存储

• • lindex(name，index)　　根据索引获取列表内元素

import redis

re = redis.Redis(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
value = re.lindex("Fruits",2)    # 通过索引值 2 取出对应的值 Apple
print(value)

# 结果如下
Apple

• • lrange(name，start，end)　　获取列表内的多个值
    • 返回的是 value 值列表
    • 取值范围 [start，end]

import redis

re = redis.Redis(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
value = re.lrange("Fruits",0,1)    # 取出列表中索引值为 0 和 1 的 value 值
print(value)

# 结果如下
['Orange', 'Banana']

• • llen(name)　　name 对应的 list 元素的个数　　

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
num = re.llen("Fruits")
print(num)

# 结果如下
4

• • lpush(name，values)　　在 name 对应的 list 中添加元素
    • 列表是有序集合　　
    • 每个新的元素都添加到列表的最左边　　　　

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.lpush("Fruits","Apple","Banana","Orange")    # 在 Fruits 对应的 list 中添加 Apple,Banana,Orange 三个元素
li = re.lrange("Fruits",0,2)
print(li)

# 结果如下
['Orange', 'Banana', 'Apple']    # 保存在列表中的顺序与添加的顺序相反

• • rpush(name，values)　　在 name 对应的 list 中添加元素　　
    • 同 lpush()  但每个新的元素都添加到列表的最右边

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.rpush("Fruits","Apple","Banana","Orange")    # 在 Fruits 对应的 list 中添加 Apple,Banana,Orange 三个元素
li = re.lrange("Fruits",0,2)
print(li)

# 结果如下
['Apple', 'Banana', 'Orange']

• • lpushx(name，value)　　在 name 对应的 list 中添加元素
    • 只有name已经存在时，值添加到列表的最左边

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.lpushx("Fruits","Pear")    # 在 Fruits 对应的 list 中添加 Pear 单个元素
li = re.lrange("Fruits",0,3)
print(li)

# 结果如下
['Pear', 'Apple', 'Banana', 'Orange']

• • rpushx(name，value)　　在 name 对应的 list 中添加元素　　
    • 只有 name 已经存在时，值添加到列表的最右边

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.rpushx("Fruits","Pear")    # 在 Fruits 对应的 list 中添加 Pear 单个元素
li = re.lrange("Fruits",0,3)
print(li)

# 结果如下
['Apple', 'Banana', 'Orange', 'Pear']

• • linsert(name，where，refvalue，value)　　在 name 对应的列表的某一个值前或后插入一个新值　　
    • name：redis 的 name
    • where：BEFORE（前）或 AFTER（后）
    • refvalue：列表内的值
    • value：要插入的数据

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
li1 = re.lrange("Fruits",0,10)
print(li1)
re.linsert("Fruits","BEFORE","Banana","Grape")  # 在列表 Fruits 中找到元素 Banana，在 Banana 前插入 Grape
li2 = re.lrange("Fruits",0,10)
print(li2)

# 结果如下
['Apple', 'Banana', 'Orange', 'Pear']
['Apple', 'Grape', 'Banana', 'Orange', 'Pear']

• • lset(name，index，value)　　对 name 中的某一个索引位置重新赋值　　

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
li1 = re.lrange("Fruits",0,10)
print(li1)
re.lset("Fruits",1,"Pear")      # 对 Fruits 中的索引位置为 1 的值进行修改成 Pear
li2 = re.lrange("Fruits",0,10)
print(li2)

# 结果如下
['Apple', 'Grape', 'Banana', 'Orange']
['Apple', 'Pear', 'Banana', 'Orange']    # Grape 更新为 Pear

• • lpop(name)　　移除列表的左侧第一个元素，返回值则是第一个元素　　

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
li1 = re.lrange("Fruits",0,10)
print(li1)
fruit = re.lpop("Fruits")    # 移除 Fruits 所对应列表中的第一个值，且将移除的值返回出来
print(fruit)
li2 = re.lrange("Fruits",0,10)
print(li2)

# 结果如下
['Apple', 'Orange', 'Pear', 'Banana']
Apple
['Orange', 'Pear', 'Banana']

• • ltrim(name, start, end)　　移除列表内没有在该索引之内的值

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
li1 = re.lrange("Fruits",0,10)
print(li1)
re.ltrim("Fruits",0,1)      # 移除 [0，1] 索引值之外的所有值
li2 = re.lrange("Fruits",0,10)
print(li2)

# 结果如下
['Apple', 'Orange', 'Pear', 'Banana']
['Apple', 'Orange']

• Hash 操作
  • redis 中的 hash 在内存中类似于一个 name 对应一个 dic 来存储

• • hset(name，key，value)　　对应的 hash 中设置一个键值对（不存在，则创建，否则，修改）

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.hset("Teacher","Teacher01","Mr.ZHENG")
re.hset("Teacher","Teacher02","Mr.XIAO")
re.hset("Teacher","Teacher03","Mr.FU")

• • hmset(name，dic)　　在 name 对应的 hash 中批量设置键值对

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
dic = {"Teacher01":"Mr.ZHENG","Teacher02":"Mr.XIAO","Teacher03":"Mr.FU",}
re.hmset("Teacher",dic)    # 批量设置多个键值对

• • hget(name，key)　　在 name 对应的 hash 中根据 key 获取 value

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
value = re.hget("Teacher","Teacher02")    # 获取 Teacher 对应的 hash 中键 Teacher02 的 value 值
print(value)

# 结果如下
Mr.XIAO

• • hgetall(name)　　获取 name 对应 hash 的所有键值对
    • 返回的是一个所有键值对的字典　　

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
dic = re.hgetall("Teacher")     # 获取 Teacher 对应 hash 的所有键值对
print(dic)
print(type(dic))

# 结果如下
{'Teacher01': 'Mr.ZHENG', 'Teacher02': 'Mr.XIAO', 'Teacher03': 'Mr.FU'}
<class 'dict'>

• • hkeys(name)　　获取 hash 中所有的 key
    • 返回的是所有键的列表

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
keys = re.hkeys("Teacher")    # 获取 Teacher 所对应 hash 中的所有的 key
print(keys)

# 结果如下
['Teacher01', 'Teacher02', 'Teacher03']

• • hvals(name)　　获取 hash 中所有的 value
    • 返回的是所有值的列表

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
values = re.hvals("Teacher")    # 获取 Teacher 所对应 hash 中的所有的 value
print(values)

# 结果如下
['Mr.ZHENG', 'Mr.XIAO', 'Mr.FU']

• • hmget(name，keys，*args)　　在 name 对应的 hash 中获取多个 key 的值　　
    • 返回的是多个 value 值的列表

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
keys = re.hmget("Teacher","Teacher01","Teacher02")  #在 Teacher 对应的 hash 中获取 Teacher01 和 Teacher02 的值　　
print(keys)
print(type(keys))

"""
import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="123456",decode_responses=True)
re = redis.Redis(connection_pool=pool)
li = ["Teacher01","Teacher02"]
keys = re.hmget("Teacher",li)  #在 Teacher 对应的 hash 中获取 Teacher01 和 Teacher02 的值　　
print(keys)
print(type(keys))
"""

# 结果如下
['Mr.ZHENG', 'Mr.XIAO']
<class 'list'>

• • hlen(name)　　获取 hash 中键值对的个数

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
num = re.hlen("Teacher")    # 获取 Teacher 所对应 hash 中的键值对个数
print(num)

# 结果如下
3

• • hdel(name，*keys)　　删除指定 name 对应的 key 所在的键值对

import redis

pool = redis.ConnectionPool(host="192.168.0.221",port=6379,db=0,password="",decode_responses=True)
re = redis.Redis(connection_pool=pool)
re.hdel("Teacher","Teacher01","Teacher03")    # 同时删除 Teacher01 和 Teacher02 键值对
dic = re.hgetall("Teacher")    # 获取未被删除的键值对
print(dic)

# 结果如下
{'Teacher02': 'Mr.XIAO'}