首页 > 数据库> 文章详细

python笔记-redis数据库

2020-06-27 13:05:44 阅读：242 来源： 互联网

标签：return python 数据库 redis value connection param key self

一、redis安装

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

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

sudo apt update
sudo apt install redis-server

等待安装结束即可

1.2 编译安装

下载源文件

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

编译

cd redis-5.0.5
make

安装

cd src
sudo make install

配置

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

使文件生效

可以重启电脑
执行命令

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')`

标签：return,python,数据库,redis,value,connection,param,key,self
来源： https://www.cnblogs.com/duyupeng/p/13193410.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9