Redis使用教程

最新推荐文章于 2024-07-19 16:27:24 发布

NFTSSTFN

最新推荐文章于 2024-07-19 16:27:24 发布

阅读量223

点赞数 1

分类专栏：数据库文章标签： redis 数据库缓存

本文链接：https://blog.csdn.net/qq_50693500/article/details/129585002

版权

数据库专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Redis是一个高性能的Key-Value数据库，支持多种数据结构如string、list、set、zset和hash，常用于内容缓存和高并发场景。它提供了原子性操作，能与其他数据库系统相比提供更快的速度和更灵活的数据操作。文章介绍了Redis的安装、Python接口以及NoSQL数据库的四大分类。

摘要由CSDN通过智能技术生成

Redis使用教程

$\qquad$ NoSQL(Not Only SQL)，意思是‘不仅仅是SQL’，泛指非关系型数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

NoSQL数据库的四大分类

分类	例子	应用场景	数据模型	优点	缺点
键值(key-Value)	Redis、Oracle BDB	内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志信息	Key指向Value的键值对，通常用hash table来实现	查找速度快	数据无结构化，通常被当作字符串或者二进制数据
列储存库	Cassandra、HBase、Riak	分布式的文件系统	以列簇式储存，将同一列数据存在一起	查找速度快，可扩展性强，更容易进行分布式扩展	功能相对局限
文档行数据库	CouchDB、MongoDB	web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容）	Key-Value对应的键值对，Value为结构化数据	数据库结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构	查询性能不高，而且缺乏统一的查询语法
图形数据库	InfoGrid，Infinite Graph	社交网络，推荐系统，专注于构建关系图谱	图结构	利用图结构相关算法，比如最短路径寻址，N度关系查找等	很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群方案

Redis简介

$\qquad$ redis是业界主流的Key-Value NoSQL数据库，和Memcached类似，它支持储存的value类型相对更多，包括了string、list、set、zset（sorted set有序集合）、hash。这些数据都支持push/pop、add/remove及取交集、并集、差集等丰富操作，且这些操作都是原子性的。再次基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中，区别是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave（主从）同步。

原子性操作：原子操作指不会被线程调度机制打断的操作。这种操作一但开始，中间就不会有任何 context switch（切换到另一个线程）。原子操作可以是一个步骤，也可以是多个步骤，其顺序不可以被打断，只能是切割掉一半只去执行另一半。视做整体是原子操作的核心。

Redis优点

异常快速：每秒可以执行大约110000设置操作，81000个/每秒的读取操作。
支持丰富的数据类型：五种数据类型可以在应用中容易解决各种问题。
原子性操作：所有的redis操作都是原子的，从而确保当两个客户同时访问Redis服务器得到的都是最新值。
MultiUtility工具：Redis是一个多功能实用工具，可以在很多如缓存，消息队列中使用，同时Redis原生支持发布、订阅，在应用程序中，如web应用程序会话，网站页面点击数等任何短暂的数据。

Redis安装

由于Redis在Windows下运行不稳定，所以以下操作都是基于Linux的。

sudo apt-get install redis-server

Redis启动

redis-server

连接Redis

redis-cli

Python操作Redis

教程链接：https://github.com/WoLpH/redis-py
redis-py的API主要有以下功能：

连接方式
连接池
操作
- string 操作
- list 操作
- set 操作
- sort set 操作
- hash 操作
管道
发布订阅

Ubantu安装Redis桌面管理器

$\qquad$ 下载链接：http://redisdesktop.com/download

连接方式

操作模式
$\qquad$ redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

import redis
r = redis.Redis(host='192.168.1.10', port=8000)
r.set('foo', 'Bar')
print r.get('foo')

连接池
$\qquad$ redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

Redis原生操作

1. String操作
String再内存当中按照一个name对应一个calue来储存，很像键值对。
语法：set(name, value, ex=None, px=None, nx=False, xx=Flase)

在Redis中设置值，默认，不存在则创建，存在则修改。
参数：
$\qquad$ ex，过期时间（秒）
$\qquad$ px，过期时间（毫秒）
$\qquad$ nx，如果设置为True，则只有name不存在时，当前set操作才执行
$\qquad$ xx，如果设置为True，则只有name存在时，岗前set操作才执行

setnx(name, value)

设置值，只有name不存在时，执行设置操作

setex(name, value, time)

设置值
参数：
$\qquad$ time：过期时间

psetex(name, time_ms, value)

设置值
参数：
$\qquad$ time_ms：过期时间（可以是数字毫秒或者timedelta对象）

mset(*args, **kwargs)

批量设置值
示例：
$\qquad$ mset(k1=‘v1’, k2='v2)
$\qquad$ mset({‘k1’ : ‘v1’, ‘k1’ : ‘v2’})

get(name)

获取值

mget(keys, *args)

批量获取值
示例：
$\qquad$ mget(‘name’, ‘age’)
$\qquad$ r.mget([‘name’, ‘age’])

getset(name, value)

设置新值并获取原来的值

getrange(key, start, end)

获取子序列（根据字节获取，非字符）
参数：
$\qquad$ key：sting中的key
$\qquad$ start：起始位置（字节）
$\qquad$ end：结束未知（字节）
示例：
$\qquad$ “张三丰”，0-3表示“张”

setrange(name, offset, value)

修改字符串中的内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
参数：
$\qquad$ offset：字符串索引，字节（一个汉字三个字节）
$\qquad$ value：要设置的值

setbit(name, offset, value)

对name对应值的二进制表示的位进行操作
参数：
$\qquad$ name：redis的name
$\qquad$ offset：位的索引（将值变换成二进制后再进行索引）
$\qquad$ value：值只能是1或0
注：如果在Redis中有一个对应：
$\qquad$ n1 = “foo”，那么字符串foo的二进制表示为：
$\qquad$ 01100110 01101111 01101111
$\qquad$ 所以，如果执行 setbit(‘n1’, 7, 1)，则就会将第7位设置为1，
$\qquad$ 那么最终二进制则变成 01100111 01101111 01101111，即：“goo”

getbit(name, offset)

获取name对应的值的二进制表示中的某位的值（0或1）

bitcount(key, start-None, end-None)

获取name对应的值的二进制表示中1的个数
参数
$\qquad$ key：Redis的name
$\qquad$ start：位的起始位置
$\qquad$ end：位结束位置

strlen(name)

返回name对应值的字节长度

incr(name, amount=1)

自增name对应的值，当name不存在时，则创建name=amount，否则，则自增
参数：
$\qquad$ name：Redis的name
$\qquad$ amount：自增数（必须是整数

incrbyfloat(name, amount=1.0)

自增name对应的值，当name不存在时，则创建name=amount，否则，则自增
参数：
$\qquad$ name：Redis的name
$\qquad$ amount：自增数（浮点型）

decr(name, amount=1)

自减name对应的值，当name不存在时，则创建name=amount，否则，则自减。
参数：
$\qquad$ name：Redis的name
$\qquad$ amount：自减数

append(key, value)

在Redis name对应的值后面追加内容
参数：
$\qquad$ key：Redis的name
$\qquad$ value：要追加的字符串

2. Hash操作
hash变现形式上有点像python中的dict，可以储存一组关联性较强的数据。
hset(name,key, value)

name对应的hash中设置的一个键值对（不存在，则创建）
参数：
$\qquad$ name：Redis中的name
$\qquad$ key：name对应的hash中的key
$\qquad$ value：name对应的hash中的value
注：hsetnx(name, key, value)，当name对应的hash中不能存在当前key时，就会创建（相当于添加）

hmset(name, mapping)

在name对应的hash中批量设置键值对
参数：
$\qquad$ nameRedis中的name
$\qquad$ mapping：字典，如{‘name’:‘Ethan’,‘age’:‘18’}
如：r.hmset(‘xx’,{‘k1’ : ‘k2’, ‘k3’ : ‘k4’})

hget(name, key)

在name对应的hash中根据key获取value

hmget

在name对应的hash中获取多个key的值
$\qquad$ 参数：
$\qquad$ name：Redis对应的name
$\qquad$ keys：要获取key集合，如：[‘k1’ ,‘k2’ ,‘k3’]
$\qquad$ *args：要获取的key，如：k1,k2,k3
如：
$\qquad$ r.mget(‘xx’, [‘k1’, ‘k2’])
$\qquad$ 或
$\qquad$ print r.hmget(‘xx’, ‘k1’, ‘k2’)

hgetall(name)

获取name对应hash的所有键值

hlen(name)

获取name对应的hash中键值对的个数

hkeys(name)

获取name对应的hash中所有的key的值

hvals(name)

获取name对应的hash中所有的value的值

hexists(name, key)

检查name对应的hash是否存在当前传入的key

hdel(name, *keys)

将name对应的hash中指定key的键值对删除

hincrby(name, key, amount=1)

自增name对应的hash中的指定key的值，不存在则创建key=amount
$\qquad$ name：Redis中的name
$\qquad$ key：hash对应的key
$\qquad$ amount：自增数（整数）

hincrbyfloat(name, key, amount=1.0)

自增name对应的hash中的指定key的值，不存在则创建key=amount
参数：
$\qquad$ name：Redis中的name
$\qquad$ key：hash对应的key
$\qquad$ amount：自增数（浮点数）
自增name对应的hash中的指定key的值，不存在则创建key=amount

hscan(name, cursor=0, match=None, count=None)

增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完。
参数：
$\qquad$ name：Redis中的name
$\qquad$ cursor：游标（基于游标分批获取数据）
$\qquad$ match：匹配指定key，默认None表示所有的key
$\qquad$ count：每次分片最少获取个数，默认表示采用Redis的默认分片个数
示例：
$\qquad$ 第一次：cursor1，data1 = r.hscan(‘xx’,cursor=0,match=None, count=None)
$\qquad$ 第二次cursor2, data1 = r.hacan(‘xx’,cursor=cursor1, match=None, count=None)
指导返回cursor的值位0时，表示数据已经通过分片获取完毕

hscan_iter(name, match=None,count=None)

利用yield封装hscan创建生成器，实现分批去redis中获取数据
参数：
$\qquad$ match：匹配指定key，默认None，表示所有的key
$\qquad$ count：每次分片最少获取个数，默认None表示采用Redis的默认分片个数
示例：
for itemin r.hscan_iter(‘xx’):
$\qquad$ print item

3. list
List操作，redis中的List在内存中按照一个name对应一个List来存储。
lpush(name, values)

在name对应的list中添加元素，每一个新的元素都添加到列表的最左边
示例：
$\qquad$ r.lpush(‘oo’,11,22,33)
$\qquad$ 保存顺序位：33，22，11
扩展：
$\qquad$ rpush(name,values)，表示从右向左操作

lpsuhx(name, value)

在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
扩展：
$\qquad$ rpushx(name, value)，表示从右向左操作

llen(name)

name对应的list元素的个数

linsert(name, where, refvalue, value)

在name对应的列表的某一个值前或后插入一个新值
参数：
$\qquad$ name：Redis的name
$\qquad$ where：before或after
$\qquad$ refvalue：标杆值
$\qquad$ value：要插入的数据

r.lset(name, index, value)

对name对应的list中的某一个索引的位置重新赋值
参数：
$\qquad$ name：Redis的name
$\qquad$ index：list的索引位置
$\qquad$ value：要设置的值

r.lrem(name, value, num)

在name对应的list中删除指定的值
参数：
$\qquad$ name：Redis的name
$\qquad$ value：要删除的值
$\qquad$ num：num=0，删除列表中所有的指定值
$\qquad$ $\qquad$ num=2，从前到后，删除两个
$\qquad$ $\qquad$ num=-2，从后到前，删除两个

lpop(name)

在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
扩展：
$\qquad$ rpop(name)，表示从右向左操作

lindex(name, index)

在name对应的列表中根据索引获取列表元素

lrange(name, start, end)

在name对应的列表分片获取数据
参数：
$\qquad$ name：Redis的name
$\qquad$ start：索引的起始位置
$\qquad$ end：索引结束位置

ltrim(name, start, end)

在name对应的列表中移除没有在start-end索引之间的值
参数：
$\qquad$ name：redis的name
$\qquad$ start：索引的起始位置
$\qquad$ end：索引结束位置

rpoplpush(src, dst)

从一个列表中去除最右边的元素，同时将其添加至另一个列表的最左边
参数：
$\qquad$ src：要去数据的列表的name
$\qquad$ dst：要添加数据的列表的name

blpop(key, timeout)

将多个列表排列，按照从左到右去pop对应列表的元素
参数：
$\qquad$ keys：redis的name的集合
$\qquad$ timeout：超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒），0表示永远阻塞
扩展：
$\qquad$ r.brpop(keys, timeout)，从右向左获取数据

brpoplpush(src, dst, timeout=0)

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
参数：
$\qquad$ src，取出并要移除元素的列表对应的name
$\qquad$ dst，要插入元素的列表对应的name
$\qquad$ timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

4.set集合操作
sadd(name, values)

name对应的集合中添加元素

scard(name)

获取name对应的集合中元素个数

sdiff(keys, *args)

在第一个name对应的集合中且不在其他name对应的集合的元素集合

sdiffstore(dest, keys, *args)

获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

sinter(keys, *args)

获取多一个name对应集合的并集

sinterstore(dest, keys, *args)

获取多一个name对应集合的并集，再讲其加入到dest对应的集合中

sismember(name, value)

检查value是否是name对应的集合的成员

smembers(name)

获取name对应的集合的所有成员

smove(src, dst, value)

将某个成员从一个集合中移动到另外一个集合

spop(name)

从集合的右侧（尾部）移除一个成员，并将其返回

srandmember(name, numbers)

从name对应的集合中随机获取 numbers 个元素

srem(name, values)

在name对应的集合中删除某些值

sunion(keys, *args)

获取多一个name对应的集合的并集

sunionstore(dest,keys, *args)

获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

5. 有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。
zadd(name, *args, **kwargs)

在name对应的有序集合中添加元素
如：
$\qquad$ zadd(‘zz’, ‘n1’, 1, ‘n2’, 2)
$\qquad$ 或
$\qquad$ zadd(‘zz’, n1=11, n2=22)

zcard(name)

获取name对应的有序集合元素的数量

zcount(name, min, max)

获取name对应的有序集合中分数在 [min,max] 之间的个数

zincrby(name, value, amount)

自增name对应的有序集合的 name 对应的分数

r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

按照索引范围获取name对应的有序集合的元素
参数：
$\qquad$ name，redis的name
$\qquad$ start，有序集合索引起始位置（非分数）
$\qquad$ end，有序集合索引结束位置（非分数）
$\qquad$ desc，排序规则，默认按照分数从小到大排序
$\qquad$ withscores，是否获取元素的分数，默认只获取元素的值
$\qquad$ score_cast_func，对分数进行数据转换的函数
扩展：
$\qquad$ 从大到小排序
$\qquad$ $\qquad$ zrevrange(name, start, end, withscores=False, score_cast_func=float)
$\qquad$ 按照分数范围获取name对应的有序集合的元素
$\qquad$ $\qquad$ zrangebyscore(name, min, max, start=None, num=None, withscores=False,score_cast_func=float)
$\qquad$ 从大到小排序
$\qquad$ $\qquad$ zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

zrank(name, value)

获取某个值在 name对应的有序集合中的排行（从 0 开始）
更多：
$\qquad$ zrevrank(name, value)，从大到小排序

zrem(name, values)

删除name对应的有序集合中值是values的成员
如：zrem(‘zz’, [‘s1’, ‘s2’])

zremrangebyrank(name, min, max)

根据排行范围删除

zremrangebyscore(name, min, max)

根据分数范围删除

zscore(name, value)

获取name对应有序集合中 value 对应的分数

zinterstore(dest, keys, aggregate=None)

获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为: SUM MIN MAX

zunionstore(dest, keys, aggregate=None)

获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
aggregate的值为: SUM MIN MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作

6. 其他操作
delete(*names)

根据删除redis中的任意数据类型

exists(name)

检测redis的name是否存在

keys(pattern=‘*’)

根据模型获取redis的name
更多：
$\qquad$ KEYS * ：匹配数据库中所有 key 。
$\qquad$ KEYS h?llo ：匹配 hello ， hallo 和 hxllo 等。
$\qquad$ KEYS h*llo ：匹配 hllo 和 heeeeello 等。
$\qquad$ KEYS h[ae]llo ：匹配 hello 和 hallo ，但不匹配 hillo

expire(name ,time)

为某个redis的某个name设置超时时间

rename(src, dst)

对redis的name重命名为

move(name, db))

将redis的某个值移动到指定的db下

randomkey()

随机获取一个redis的name（不删除）

type(name)

获取name对应值的类型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

同字符串操作，用于增量迭代获取key

管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

import redis
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)

r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
 
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()

发布订阅

发布者：服务器
订阅者：Dashboad和数据处理
一个Demo

import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='10.211.55.4')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

订阅者

from monitor.RedisHelper import RedisHelper
 
obj = RedisHelper()
redis_sub = obj.subscribe()
 
while True:
    msg= redis_sub.parse_response()
    print msg

发布者

from monitor.RedisHelper import RedisHelper
 
obj = RedisHelper()
obj.public('hello')

更多操作可以参考：
https://github.com/andymccurdy/redis-py/
http://doc.redisfans.com/

什么时候用关系型数据库，什么时候用NosQL

传统关系型数据库

数据结构良好，并且很适合表格排列。例如：银行账户信息，客户信息，客户订单信息，员工信息，部门信息。
需要考虑数据本质上是不是事务性的。
数据没有向外扩展架构的需求，集群到多个节点数据库
不用于高速摄取数据
如果客户端应用程序希望快速地将大量数据输入/输出数据库，那么关系数据库可能不是一个好的选择，因为它们实际上并不是为扩展繁重的写工作负载而设计的。
In order to achieve ACID properties, lots of additional background work is done especially in writer (INSERT, UPDATE, DELETE) code paths. This definitely affects performance.
不是用来储存海量数据

NoSQL

数据没有合适的、固定的储存模式
可伸缩性、性能(高吞吐量和低操作延迟)、持续可用性是数据库底层架构必须满足的重要要求。
“高速数据摄取”的好选择。这类应用程序(例如物联网风格)在一秒钟内生成数百万个数据点，需要一个能够提供极端写入可伸缩性的数据库。
横向扩展的固有能力允许在集群中的普通服务器之间存储大量数据。它们通常使用低成本资源，并且能够随着需求的增长线性地增加计算和存储能力。
来源：https://www.quora.com/When-should-you-use-NoSQL-vs-regular-RDBMS