hmset函数可以设置每个字段的值，但我发现如果该值本身是一个复杂的结构化对象，则从hget返回的值是一个序列化的字符串，而不是原始对象。
e.g
images= [{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'}]
redis = Redis()
redis.hset('photo:1', 'images', images)
i = redis.hget('photo:1', 'images')
print type(i)
i的类型是字符串，而不是Python对象，除了手动解析每个字段之外，是否有其他解决方法？
实际上，您可以使用内置模块pickle将Python对象存储在Redis中。
这是一个例子。
import pickle
import redis
r = redis.StrictRedis(host='localhost', port=6379, db=0)
obj = ExampleObject()
pickled_object = pickle.dumps(obj)
r.set('some_key', pickled_object)
unpacked_object = pickle.loads(r.get('some_key'))
obj == unpacked_object
如果您的数据是可JSON序列化的，则与将Python pickles保存到外部数据库相比，这可能是更好的选择，因为它是Python之外更常见的标准，本身更易于人类阅读，并避免了相当大的攻击向量。
JSON示例：
import json
import redis
r = redis.StrictRedis(host='localhost', port=6379, db=0)
images= [
{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'},
]
# Convert python dict to JSON str and save to Redis
json_images = json.dumps(images)
r.set('images', json_images)
# Read saved JSON str from Redis and unpack into python dict
unpacked_images = json.loads(r.get('images'))
images == unpacked_images
Python 3：
unpacked_images = json.loads(r.get('images').decode('utf-8'))
images == unpacked_images
redis.get()得到bytes对象是正常的吗？我在Python 3中得到了b'['something']'。 - shangsunsetjson.loads()函数不能很好地处理bytes对象。您需要将redis.get()返回的bytes结果解码为Python 3的str类型。请参见最新编辑。 - CivFandecode_responses=True，这将使结果以字符串形式返回。请参考此链接获取更多信息：https://dev59.com/OWMk5IYBdhLWcg3wvARo。 - Aleksandar Jovanovic我创建了一个库，SubRedis，它让你在Redis中创建更复杂的结构/层级。如果你提供一个Redis实例和一个前缀，它会给你一个几乎完整的独立Redis实例。
redis = Redis()
photoRedis = SubRedis("photo:%s" % photoId, redis)
photoRedis.hmset('image0', images[0])
photoRedis.hmset('image1', images[1])
...
这里是一个简单的 Redis 包装器，可以对数据结构进行数据序列化和反序列化：
from redis import Redis
from collections import MutableMapping
from pickle import loads, dumps
class RedisStore(MutableMapping):
def __init__(self, engine):
self._store = Redis.from_url(engine)
def __getitem__(self, key):
return loads(self._store[dumps(key)])
def __setitem__(self, key, value):
self._store[dumps(key)] = dumps(value)
def __delitem__(self, key):
del self._store[dumps(key)]
def __iter__(self):
return iter(self.keys())
def __len__(self):
return len(self._store.keys())
def keys(self):
return [loads(x) for x in self._store.keys()]
def clear(self):
self._store.flushdb()
d = RedisStore('redis://localhost:6379/0')
d['a'] = {'b': 1, 'c': 10}
print repr(d.items())
# this will not work: (it updates a temporary copy and not the real data)
d['a']['b'] = 2
print repr(d.items())
# this is how to update sub-structures:
t = d['a']
t['b'] = 2
d['a'] = t
print repr(d.items())
del d['a']
# Here is another way to implement dict-of-dict eg d['a']['b']
d[('a', 'b')] = 1
d[('a', 'b')] = 2
print repr(d.items())
# Hopefully you do not need the equivalent of d['a']
print repr([{x[0][1]: x[1]} for x in d.items() if x[0][0] == 'a'])
del d[('a', 'b')]
del d[('a', 'c')]
如果你更喜欢在redis中使用纯文本可读数据(而不是pickle存储的二进制版本), 你可以将pickle.dumps替换为repr, 将pickle.loads替换为ast.literal_eval。对于json，使用json.dumps和json.loads。
如果你总是使用简单字符串作为键值, 你可以将pickling从键中删除。
# Set the key `obj` to some object
obj = {
'answer': 42,
'arr': [None, True, 3.14],
'truth': {
'coord': 'out there'
}
}
rj.jsonset('obj', Path.rootPath(), obj)
# Get something
print 'Is there anybody... {}?'.format(
rj.jsonget('obj', Path('.truth.coord'))
)
pip install redisworks
>>> from redisworks import Root
>>> root = Root()
>>> root.something = {1:"a", "b": {2: 2}} # saves it as Hash
>>> print(root.something) # loads it from Redis
{'b': {2: 2}, 1: 'a'}
>>> root.something['b'][2]
2
它将Python类型转换为Redis类型，反之亦然。
>>> root.sides = [10, [1, 2]] # saves it as list in Redis.
>>> print(root.sides) # loads it from Redis
[10, [1, 2]]
>>> type(root.sides[1])
<class 'list'>
for saving object in redis first convert object into stringify JSON
StringifyImages = json.dumps(images)
redis.set('images', StringifyImages)
# Read stringify object from redis and parse it
ParseImages = json.loads(redis.get('images'))
我最近遇到了类似的用例。在Redis哈希中存储复杂的数据结构。
我认为解决这个问题的最佳方法是将JSON对象序列化为字符串，并将其作为另一个对象的值进行存储。
Typescript示例
要存储在哈希映射表中的对象
const payload = {
"k1":"v1",
"k2": "v2",
"k3": {
"k4":"v4",
"k5":"v5"
}
}
将此有效载荷存储为
await redis.hmset('hashMapKey', {somePayloadKey: JSON.stringify(payload) });
这可以被检索到
const result = await redis.hgetall('hashMapKey');
const payload = JSON.parse(result.somePayloadKey);
hmset和hgetall是tedis中对应于redis中的HMSET和HGETALL的命令。
希望这可以帮到你。
您可以将结构体存储为原样，并执行“eval”将其从字符串转换为对象：
images= [{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'},
{'type':'big', 'url':'....'}]
redis = Redis()
redis.hset('photo:1', 'images', images)
i = eval(redis.hget('photo:1', 'images'))
print type(i) #type of i should be list instead of string now
eval() 函数执行任意 Python 代码。而使用 JSON 方式则不会有这个问题。 - Eric O. Lebigot