python笔记-redis数据库

一、redis安装

1.1 使用命令安装(Ubuntu系统)

打开终端输入下面两条命令

sudo apt update
sudo apt install redis-server

等待安装结束即可

1.2 编译安装

1. 下载源文件

sudo wget http://download.redis.io/releases/redis-5.0.5.tar.gz
sudo tar -zvxf redis-5.0.5.tar.gz

2. 编译

cd redis-5.0.5
make

3. 安装

cd src
sudo make install

4. 配置

sudo mkdir /etc/redis
cd ..
sudo cp redis.conf /etc/redis
sudo vim /etc/redis/redis.conf  # 将属性daemonize的值改为为yes
cd utils
sudo cp redis_init_script /etc/init.d/redis
sudo vim /etc/init.d/redis  # 打开启动文件按下面内容进行修改

redis初始化文件修改

#!/bin/sh
# chkconfig: 2345 10 90   // 此处修改
# description: Start and Stop redis  //此处修改
# Simple Redis init.d script conceived to work on Linux systems
# as it does use of the /proc filesystem.

### BEGIN INIT INFO
# Provides:     redis_6379
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
# Short-Description:    Redis data structure server
# Description:          Redis data structure server. See https://redis.io
### END INIT INFO

REDISPORT=6379
EXEC=/usr/local/bin/redis-server  # 自己的安装路径，默认可修改
CLIEXEC=/usr/local/bin/redis-cli  # 自己的安装路径，默认可修改

PIDFILE=/var/run/redis_6379.pid   # redis.conf 文件里面有。可复制过来
CONF="/etc/redis/redis.conf"  # 配置文件redis.conf所在目录
case "$1" in
    start)
        if [ -f $PIDFILE ]
        then
                echo "$PIDFILE exists, process is already running or crashed"
        else
                echo "Starting Redis server..."
                $EXEC $CON &  # 添加 & 表示可以后台运行
        fi
        ;;
    stop)
        if [ ! -f $PIDFILE ]
        then
                echo "$PIDFILE does not exist, process is not running"

        else
                PID=$(cat $PIDFILE)
                echo "Stopping ..."
                $CLIEXEC -p $REDISPORT shutdown
                while [ -x /proc/${PID} ]
                do
                    echo "Waiting for Redis to shutdown ..."
                    sleep 1
                done
                echo "Redis stopped"
        fi
        ;;
    *)
        echo "Please use start or stop as first argument"
        ;;
esac

5. 使文件生效

   • 可以重启电脑

   • 执行命令

   sudo chmod +x /etc/init.d/redis
   sudo update-rc.d redis defaults
   

二、Redis介绍

Redis是由意大利人Salvatore Sanfilippo（网名：antirez）开发的一款内存高速缓存数据库。Redis全称为：Remote Dictionary Server，该软件使用C语言编写，Redis是一个key-value存储系统，它支持丰富的数据类型，如：string、list、set、zset(sorted set)、hash。

Redis特点: Redis以内存作为数据存储介质，所以读写数据的效率极高，远远超过数据库。

Redis应用场景: 因为Redis交换数据快，所以在服务器中常用来存储一些需要频繁调取的数据， 将这种热点数据存到Redis（内存）中，要用的时候，直接从内存取，极大的提高了速度和节约了服务器的开销。

三、常用命令

3.1 进入和退出redis

命令	解释
redis-cli	进入Redis数据库，但是不能显示中文
redis-cli --raw	进入Redis数据库，能显示中文
exit	退出数据库

补充命令：select n

该命令用于切换到指定的数据库，数据库索引号 index 用数字值指定，以 0 作为起始索引值。 默认使用 0 号数据库 默认开16个库

3.2 数据类型

Redis数据库有五大数据类型

数据类型	含义
String	字符串
Hash	哈希
List	列表
Set	集合
Zset	有序集合

3.3 String类型数据的操作命令

• string 类型是 redis 最基本的类型,
• string 类型，一个 key 对应一个 value，一个 value 最大能存储512MB的数据。

命令	作用	其他
set key value	设置给定 key 的值	如果 key 已经存储其他值， SET 就覆写旧值，且无视类型
mset key1 value1 [key2 value2 ..]	为多组key设置值	该操作为原子操作，要么一组都设置成功，要么一组都设置失败
get key	返回key的值	若key不存在则返回nil
mget key1 [key2 ... ]	返回一个或多个key的值	若key不存在返回nil，若key存在但不是字符串返回nil
append key value	将指定的值追加到key末尾	若key不存在，则创建并赋值，返回追加后的字符串长度

3.3 全局key操作命令

命令	作用	其他
ttl key	返回key的剩余生存时间	-1 表示永久存在， -2表示不存在
set key value ex seconds	设置key的同时，设置过期时间(单位：秒)	key 过期后将不再可用，会被系统自动删除。
persist key	移除指定key的生存时间	成功返回1，若key不存在或不存在生存时间时返回0；
rename key newkey	改名	当key和newkey相同或者key不存在时返回一个错误，当newkey已存在时则会覆盖；
keys *	查看所有的key
del key	删除	返回成功的个数
exists key	查看key是否存在	返回存在个个数
type key	查看key类型
expire key seconds	设置过期时间

3.4 List数据类型操作命令

• 列表的元素类型为string，
• 按照插入顺序排序

命令	作用	其他
lpush key value[value...]	在头部插入数据
rpush key value [value ...]	在尾部添加数据
lindex key index	返回列表中元素的值	index从0开始，当index超出索引时返回null
lrange key start stop	查看索引范围内元素的值
llen key	返回列表的长度
lset key index newvalue	指定索引号进行修改
lpop key	头部删除数据
rpop key	尾部删除数据

3.5 Hash数据类型操作命令

• 是一个键值(key=>value)对集合。
• 是string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象, field 域, value 值

命令	作用	其他
hset key field value	将field-value设置到hash表中	若key不存在会新建hash表再赋值，已存在则会覆盖；
hmset key field1 value1[field2 value2 ...]	同时将多个field-value设置到hash表中
hget key field	获取value值
hmget key field[field...]	获取多个value
hvals key	获取全部value
hkeys key	获取所有的field
hgetall key	获取全部field 和 value
hlen key	查看有几个键值对
hexists key field	判断hash表中指定field是否存在	若存在，则返回1；若key或field不存在，则返回0
hdel key field	删除

3.6 Set数据类型操作名

• 元素为string类型
• 无序集合
• 元素具有唯一性，不重复

命令	作用	其他
sadd key member [member...]	将一个或多个member元素加入到集合key中	若member已存在那么会忽略此元素
scard key	返回集合key中元素的个数
smembers key	获取集合中所有元素
sismember key member	判断集合存在某个值	判断member在key中是否已存在, 返回0或1
srem key member [member...]	移除一个或多个元素	不存在的member会被忽略，返回被移除元素个数
spop key	随机删除	移除并返回集合中的一个随机元素，当key不存在时返回NULL

3.7 Zset数据类型的操作命令

• 类似于Set
• 不同的是Sorted中的每个成员都分配了一个分数（Score）用于对其中的成员进行排序（升序）。
• zset的成员是唯一的,但分数(score)却可以重复。

命令	作用	其他
zadd key score member [ [score member] ..]	添加数据	存在就更新
zscore key member	查看score值
zrange key start stop[withscores]	按索引返回key的成员	withscores表示显示score
zrangebyscore key min max	返回集合中 score 在给定区间的元素
zrem key member [member...]	移除有序集合中的一个或多个元素	若member不存在则忽略
zremrangebyrank min max	删除集合中索引在给定区间的元素
zremrangebyscore min max	删除集合中 score 在给定区间的元素

四、python操纵redis数据库

python与redis交互需要一个第三方接口redis来完成
安装

pip install redis

4.1 String类型操作

语法	作用	示例
r.set(key, value)	给key赋值为value	r.set(key,value)
r.get(key)	返回数据库中key的value	r.get(key)
r.getset(key, value)	给key赋值为value, 并返回上次的value; 若无值, 则不返回	r.getset(key,vakue)
r.mget(keys, *args)	返回多个key对应的value	r.mget(name,key)
r.setnx(key,value)	当key不存在才设置value, 设置成功返回True, 当key存在返回False,不更改value	r.setnx(foo,bar)
r.setex(key,time,value)	设置key的value, 指定有效期为time	r.setex('fo',1,'jane')
r.setrange(key, offset, value)	设置key的value值的子字符串	r.setrange('name',6,'world')
r.mset(**kargs)	批量赋值	r.mset({'n1':'john','n2':'kang'})
r.msetnx(**kargs)	key不存在才批量赋值	r.msetnx({'n3':'n33','n4':'n44'})
r.incr(key, amount=1)	设置key的value增值操作, 默认1, key不存在则被创建并设为 amount, amount 可以为负数,表示减值	r.incr('age',1) r.incr('age',3)
r.decr(key,amount=1)	设置key的value减值操作, 默认1, key不存在则被创建并设置为-mount, amount可以为负值, 表示增值	r.decr('score',2)
r.append(key,value)	为key的值附加value	r.append('nick','popo')
r.substr(key,start,end=-1)	返回key的value子串, end默认为-1,包含end	r.substr('nick',0)
r.getrange(key,start,end)	返回key的value值从start到end子串,包含end	r.getrange('nick',1,4)

对string类型操纵的封装

import redis


class RedisConnect(redis.Redis):
    def __init__(self, host="127.0.0.1", port="6379", db_number=1, decode_responses=True):
        super(RedisConnect, self).__init__(host=host, port=port, db=db_number, decode_responses=decode_responses)


class String:
    def __init__(self, connection=RedisConnect()):
        self.connection = connection

    def set_key(self, key, value):
        """
        添加值成功返回True, 失败返回 False
        :param key 关键字
        :param value 值
        """
        return self.connection.set(key, value)

    def set_not_exists(self, key, value):
        """
        判段指定key值是否存在, 存在不插入并返回false, 否则插入数据并返回True
        :param key 关键字
        :param value 值
        """
        if self.connection.exists(key):
            return False
        else:
            self.connection.set(key, value)
            return True

    def set_exists_time(self, key, time, value):
        """
        设置key-value值时, 设置其有效时间, 成功返回True, 失败返回False
        :param key 设置的关键字
        :param time 存在时间, 单位秒
        :param value 设置的值
        """
        return self.connection.setex(key, time, value)

    def set_range(self, key, offset, value):
        """
        设置key-value值的子字符串
        :param key 设置的关键字
        :param offset 便宜量
        :param value 值
        """
        return self.connection.setrange(key, offset, value)

    def get_key(self, key):
        """
        返回获取到的值
        :param 关键字
        """
        return self.connection.get(key)

    def get_set(self, key, value):
        """
        设置key的新值, 并返回上一次的值
        :param key 关键字
        :param value 值
        """
        return self.connection.getset(key, value)

    def many_get(self, keys: list):
        """获取多个key的值, 并且以"""
        result = []
        for key in keys:
            result.append(self.get_key(key))

        return dict(zip(keys, result))

    def many_set(self, keys: list, values: list, **kwargs):
        """
        设置多个值
        :param keys: 设置的key值
        :param values:  设置的values值
        :param kwargs: 设置的key-value键值对
        :return: 成功返回True
        """
        kwargs.update(dict(zip(keys, values)))
        for key, value in kwargs.items():
            self.connection.set(key, value)
        return True

    def many_set_not_exists(self, keys: list, values: list, **kwargs):
        """
        设置多个值， key值不存在才设置, 存在这不变
        :param keys:
        :param values:
        :param kwargs:
        :return:
        """
        kwargs.update(dict(zip(keys, values)))
        for key, value in kwargs.items():
            self.set_not_exists(key, value)

    def increment(self, key, amount=1):
        """
        设置key的value增值操作, 默认1, key不存在则被创建并设为 amount, amount 可以为负数,表示减值
        :param key: 关键字
        :param amount: 增长步长
        :return:
        """
        self.connection.incr(key, amount)

    def decrement(self, key, amount=1):
        """
        设置key的value减值操作, 默认1, key不存在则被创建并设置为-mount, amount可以为负值, 表示增值
        :param key: 关键字
        :param amount: 减少步长
        :return:
        """
        self.connection.decr(key, amount)

    def append(self, key, value):
        """
        为key的value附加值
        :param key: 关键字
        :param value: 附加值
        :return:
        """
        self.connection.append(key, value)

    def sub_str(self, key, start, end=-1):
        """
        返回key的value子串, end默认为-1,包含end
        :param key: 关键字
        :param start: 开始位置
        :param end: 结束位置
        :return:
        """
        return self.connection.substr(key, start, end)

    def get_range(self, key, start, end):
        """
        返回key的value值从start到end子串,包含end
        :param key: 关键字
        :param start: 开始位置
        :param end: 结束位置
        :return:
        """
        return self.connection.getrange(key, start, end)

4.2 全局key操作

语法	作用	示例
r.exists(key)	判断一个key是否存在, 存在返回True, 解码为1,不存在返回False, 解码为0	r.exists('score')
r.delete(key)	删除一个key,	r.delete('nick')
r.type(key)	判断一个key的类型	r.type('age')
r.keys(pattern)	获取所有符合规则的key	r.keys('a*')
r.randomkey()	获取随机的一个key	r.randomkey()
r.rename(key,newkey)	将key重命名	r.rename('age','height')
r.dbsize()	获取当前数据库中key的数目	r.dbsize()
r.expire(key,time)	设定key的过期时间, 单位秒	r.expire('scor',2)
r.ttl(key)	获取key的过期时间, 单位秒, -1为永久不过期	r.ttl('score')
r.move(key,db)	将key移动其他数据库	r.move('score',2)
r.flushdb()	删除当前选择数据库中的所有key	r.flushdb()
r.flushall()	删除所有数据库中的所有key	r.flushall()

全局key的封装

class GlobalKey:
    def __init__(self, connection=RedisConnect()):
        self.connection = connection

    def exists(self, key):
        """
        查看key是否存在
        :param key: 查看的key
        :return: True if exists else False
        """
        return self.connection.exists(key)

    def delete(self, key):
        """
        删除key
        :param key: 删除的key值
        :return:
        """
        return self.connection.delete(key)

    def type(self, key):
        """
        查看key的数据类型
        :param key: 查询的key
        :return:
        """
        return self.connection.type(key)

    def keys(self, pattern):
        """
        查询符合patter规则的key
        :param pattern: 规则
        :return:
        """
        return self.connection.keys(pattern)

    def random_key(self):
        """
        随机获取一个key
        :return:
        """
        return self.connection.randomkey()

    def rename(self, key, new_key):
        """
        对key进行重命名
        :param key: 旧的key
        :param new_key:  新的key
        :return:
        """
        self.connection.rename(key, new_key)

    def db_size(self):
        """
        获取数据库中的数据条数
        :return:
        """
        self.connection.dbsize()

    def expire(self, key, time):
        """
        设置过期时间
        :param key: 设置的key
        :param time: 时间, 单位秒
        :return:
        """
        self.connection.expire(key, time)

    def ttl(self, key):
        """
        查询key的生存时间
        :param key: 查询的值
        :return:
        """
        return self.connection.ttl(key)

    def move(self, key, db):
        """
        移动key到db号数据库
        :param key:
        :param db:
        :return:
        """
        self.connection.move(key, db)

    def flush_db(self):
        """清楚当前数据库的所有内容"""
        self.connection.flushdb()

    def flush_all(self):
        """清楚所用数据库中的内容"""
        self.connection.flushall()

4.3 List操作

语法	作用	示例
r.rpush(key,*values)	在key尾部(右边)添加值为value的元素, key传多个, 返回list元素个数	r.rpush('list',1,2,3)
r.lpush(key,*values)	在key头部添加值为value的元素, 可以传多个,返回list元素个数	r.lpush('list',0)
r.llen(key)	返回key的长度	r.llen('list')
r.lrange(key,start,end)	返回key中start~end之间的元素, 包含end	r.lrange('list',0,-1)
r.ltrim(key,start,end	截取key, 保留索引为start至end的内容	r.ltrim('list',1,3)
r.lindex(key,index)	返回key的index位置的元素, 越界则没有返回值	r.lindex('list',2)
r.lset(key,index,value)	给key的index位置赋值, 越界则报错	r.lset('list',2,6)
r.lrem(key,count,value)	删除key中 count 个值为 value 的元素, 返回删除个数	r.lrem('list',2,6)
r.lpop(key)	删除并返回key的首元素(左边)	r.lpop('list')
r.rpop(key)	删除并返回key的尾元素(右边)	r.rpop('list')
r.blpop(key,timeout=0)	删除并返回key的首元素, 如果key为空, 则会一直阻塞等待, 返回元组,(key,value)	r.blpop('list')
r.brpop(key,timeout=0)	删除并返回key的尾元素, 如果key为空, 则会一直阻塞等待, 返回元组,(key,value)	r.brpop('list')
r.rpoplpush(key,newkey)	删除并返回key的尾元素, 并将元素添加到, newkey的头部	r.rpoplpush('list','list1')

List操作封装

class List:
    def __init__(self, connection=RedisConnect()):
        self.connection = connection

    def right_push(self, key, *values) -> int:
        """
        在key尾部(右边)添加值为value的元素, key传多个, 返回list元素个数
        :param key: 关键字
        :param values: 值
        :return: len(values)
        """
        self.connection.rpush(key, *values)
        return len(values)

    def left_push(self, key, *values) -> int:
        """
        在key头部(左边)添加值为value的元素, 可以传多个,返回list元素个数
        :param key: 关键字
        :param values: 值
        :return: len(values)
        """
        self.connection.lpush(key, *values)
        return len(values)

    def len_list(self, key):
        """
        返回key中元素的个数
        :param key: 关键字
        :return: len(key)
        """
        return self.connection.llen(key)

    def list_range(self, key, start, end):
        """
        返回key中start~end之间的元素, 包含end
        :param key: 关键字
        :param start: 开始位置
        :param end: 结束位置
        :return: start - end 之间的元素, 包含end位置
        """
        return self.connection.lrange(key, start, end)

    def list_trim(self, key, start, end):
        """
        截取key, 保留start--end之间的数据
        :param key: 关键字
        :param start: 开始位置
        :param end: 结束位置
        :return:
        """
        self.connection.ltrim(key, start, end)

    def list_index(self, key, pos):
        """
        获取key在pos处的值
        :param key: 关键字
        :param pos: 位置
        :return: key[pos]
        """
        return self.connection.lindex(key, pos)

    def list_set(self, key, pos, value):
        """
        在key的pos处赋值value, 如果越界则报错
        :param key: 关键字
        :param pos: 位置
        :param value: 值
        :return:
        """
        self.connection.lset(key, pos, value)

    def list_remove(self, key, count, value):
        """
        删除key中值为value的值, count指定删除个数
        :param key: 关键字
        :param count: 删除个数
        :param value: 删除值
        :return:
        """
        self.connection.lrem(key, count, value)

    def left_pop(self, key):
        """
        删除并返回key的首元素(左边)
        :param key: 关键字
        :return:
        """
        return self.connection.lpop(key)

    def right_pop(self, key):
        """
        删除并返回key的首元素(右边)
        :param key: 关键字
        :return:
        """
        return self.connection.rpop(key)

    def blpop(self, keys: list, timeout=10):
        """
        删除并返回key的首元素, 如果key为空, 则会一直阻塞等待, 返回元组,(key,value)
        :param keys: 关键字
        :param timeout: 阻塞时间
        :return:
        """
        return self.connection.blpop(keys, timeout)

    def brpop(self, keys: list, timeout=10):
        """
        删除并返回key的尾元素, 如果key为空, 则会一直阻塞等待, 返回元组,(key,value)
        :param keys: 关键字
        :param timeout: 阻塞时间
        :return:
        """
        return self.connection.brpop(keys, timeout)

    def right_pop_left_plush(self, key, newkey):
        """
        删除并返回key的尾元素, 并将元素添加到, newkey的头部
        :param key: 删除的键
        :param newkey: 新键
        :return:
        """
        self.connection.rpoplpush(key, newkey)

4.4 Set操作

语法	作用	示例
r.sadd(key,*values)	向key中添加元素, 可以添加多个, 返回插入元素个数	r.sadd('tags','Book','Tea')
r.srem(key,*values)	从key中删除元素, 可以删除多个, 返回成功删除的个数	r.srem('tags','Book','Tea')
r.spop(key)	随机删除并返回key中的一个元素	r.spop('tags')
r.smove(key,newkey,value)	从key中移除元素并添加到newkey中	r.smove('tags','news','Book')
r.scard(key)	返回key中的元素个数	r.scard('tags')
r.sismember(key,value)	测试value是否在key中, 在返回True, 不在返回False	r.sismember('tags','Tea')
r.sinter(keys, *args)	返回交集, 没有交集返回空集	r.sinter('tags','news')
r.sinterstore(dset,keys,*args)	求交集, 并将交集保存到dset集合中, 返回dset元素个数	r.sinterstore('dset','tags','news')
r.sunion(keys.*args)	返回并集	r.sunion('tags','tag2','tag3')
r.sunionstore(dset,keys,*args)	求并集, 并将并集保存到dset中, 返回并集的元素个数	r.sunionstore('log','tags','news')
r.sdiff(key,*args)	求差集, 并返回在key中, 但不在*args中的元素集合	r.sdiff('tags','news')
r.sdiffstore(dset,key,*args)	求差集, 并将差集保存在dset中, 返回差集个数	r.sdiffstore('dset','tags','news')
r.smembers(key)	返回key中所有元素	r.smembers('tags')
r.srandmember(key)	随机返回key中的一个元素, 但不删除元素	r.srandmember('tags')

Set操作封装

class Set:
    def __init__(self, connection=RedisConnect()):
        self.connection = connection

    def set_add(self, key, *values):
        """
        设置key的多个值
        :param key: 关键字
        :param values: 值
        :return:
        """
        self.connection.sadd(key, *values)

    def set_remove(self, key, *values):
        """
        删除key的值
        :param key: 关键字
        :param values: 删除的值
        :return:
        """
        self.connection.srem(key, *values)

    def set_pop(self, key):
        """
        随机删除并返回key中的一个元素
        :param key: 关键字
        :return:
        """
        return self.connection.spop(key)

    def set_move(self, key, newkey, value):
        """
        从key中移除元素value并添加到newkey中
        :param key: 要被移除值的key
        :param newkey: 添加值的key
        :param value: 被移除的值
        :return:
        """
        self.connection.smove(key, newkey, value)

    def scard(self, key):
        """
        返回key中的元素个数
        :param key: 关键字
        :return:
        """
        return self.connection.scard(key)

    def set_is_member(self, key, value):
        """
        测试value是否在key中, 在返回True, 不在返回False
        :param key: 关键字
        :param value: 判断的值
        :return:
        """
        return self.connection.sismember(key, value)

    def set_inter(self, key: list, *values):
        """
        返回key与values交集, 没有交集返回空集
        :param key: 关键字
        :param values: 值
        :return:
        """
        return self.connection.sinter(*key, *values)

4.5 ZSet操作

语法	作用	示例
r.zadd(key,**kargs)	向key中添加元素, 如果元素已存在, 则更新其score	r.zadd('grade',{'Bob':80,'Mike':61})
r.zrem(key,*values)	删除key中的元素	r.zrem('grade','Mike','Bob')
r.zincrby(key, amount=1,value,)	如果在key中已经存在元素value，则该元素的score增加amount，否则向该集合中添加该元素，其score的值为amount	r.zincrby('grade',-2, 'Bob')
r.zrank(key,value)	返回key中元素的排名下标 (按score从小到大)	r.zrank('grade','Bob')
r.zrevrank(key,value)	返回key中元素的倒数排名下标 (按score从大到小)	r.zrevrank('grade','Bob')
r.zrevrange(key,start,end, withscores=False)	返回key中的index从start到end的所有元素 (按score从大到小排序)	r.zrevrange('grade',0,-1)
r.zrangebyscore( key,min,max, start=None, num=None, withscores=False)	返回key中score在min到max之间的元素	r.zrangebyscore('grade',60,90)
r.zcount(key,min,max)	返回key中score在min到max之间的数量	r.zcount('grade',60,90)
r.zcard(key)	返回key中元素个数	r.zcard('grade')
r.zremrangebyrank( key,min,max)	删除并返回key中排名在min到max之间的元素个数	r.zremrangebyrank('grade',0,1)
r.zremrangebyscore( key,min,max)	删除并返回key中score在给定区间的元素个数	r.zremrangebyscore('grade',60,90)

4.7 Hash操作

语法	作用	示例
r.hset(key,field,value)	向key中添加映射, 如果已存在, 则更新,	r.hset('price','cake',5)
r.hsetnx(key,field,value)	向key中添加映射, 如果field不存在, 如果存在不更新	r.hsetnx('price','apple',5)
r.hget(key, field)	返回key中映射对象的value	r.hget('price','cake')
r.hmget(key,fields,*args)	返回key中各个映射对应的value	r.hmget('price','cake','apple')
r.hmset(key,mapping)	向key中批量添加映射	r.hmset('price',{'orange':3,'banana':2})
r.hincrby(key,field, amount=1)	向key中映射的value增加amount	r.hincrby('price','orange',2)
r.hexists(key,field)	判断key中是否存在键名为field的映射	r.hexists('price','orange')
r.hdel(key,*fields)	删除key中field的映射	r.hdel('price','orange')
r.hlen(key)	从key中获取映射个数	r.hlen('price')
r.hkeys(key)	从key中获取所有映射键名	r.hkeys('price')
r.hvals(key)	从key中获取所有映射键值	r.hvals('price')
r.hgetall(key)	从key中获取所有映射键值对	r.hgetall('price')