Explication détaillée de l'utilisation de Python Redis

高洛峰
Libérer: 2018-05-28 15:01:20
original
4614 Les gens l'ont consulté

Cet article explique en détail comment utiliser python redis

1, Installer

pip installer redis

2, Utilisation de base

Utilisation :
importer redis
r = redis.Redis(host='localhost', port=6379, db=0)
r['test'] = 'test' #Ou vous pouvez r.set( 'test', 'test') setkey
r.get('test') #Obtenir la valeur de test
r.delete('test') #Supprimercette clé
r.flushdb() #Effacer la base de données
r.keys() #Liste toutes les clés
r.exists('test') #Vérifier si cette clé existe
r.dbsize( ) #Combien d'entrées dans la base de données

>>> import redis

>>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)

>>> r = redis.StrictRedis(connection_pool = pool)

>>> r.set('foo', 'bar')

True

>>> r.get('foo')

'bar'
Copier après la connexion

3.APIRéférence

La documentation officielle de Redis explique chaque commande en détail (http ://www.php.cn/). redis-py fournit deux classes client qui implémentent ces commandes. La classe StrictRedis tente d'adhérer à la syntaxe de commande officielle, mais il existe quelques exceptions :

·SELECT : non implémenté. Voir l'explication dans la section "ThreadSécurité" ci-dessous.

·DEL : 'del' est un mot-clé réservé dans la syntaxe Python. Par conséquent, redis-py utilise "delete" à la place.

·CONFIG GET|SET : implémenté en utilisant respectivement config_get et config_set.

·MULTI/EXEC : implémenté dans le cadre de la classe Pipeline. Si use_transaction=True est spécifié lors de l'appel de la méthode pipeline, MULTI et EXEC seront utilisés pour encapsuler l'opération du pipeline lors de l'exécution du pipeline. Voir la section Pipeline ci-dessous.

·SUBSCRIBE/LISTEN : Semblable au pipeline, PubSub est également implémenté en tant que classe distincte en raison de la nécessité pour la connexion inférieure de maintenir l'état. L'appel de la méthode pubsub du client Redis renvoie une instance PubSub via laquelle vous pouvez vous abonner à des chaînes ou écouter des messages. Les deux classes (classes StrictRedis et PubSub) peuvent publier des messages (PUBLISH).

En plus des changements ci-dessus, Redis, une sous-classe de StrictRedis, assure la compatibilité avec l'ancienne version de redis-py :

·LREM : L'ordre des paramètres 'num' et 'value ' a été échangé, de sorte que 'num' puisse fournir une valeur par défaut de 0.

·ZADD : L'ordre du score et de la valeur a été accidentellement inversé lors de l'implémentation, et plus tard, quelqu'un l'a utilisé, et c'est tout

·SETEX : heure et valeur sont dans l'ordre inverse

Remarque : il est préférable de ne pas utiliser Redis, cette classe est uniquement destinée à la compatibilité

4. Description détaillée

4.1 Pool de connexions

En arrière-plan, redis-py utilise un pool de connexions (ConnectionPool) pour gérer les connexions au serveur Redis. Par défaut, chaque instance Redis crée son propre pool de connexions. Vous pouvez également transmettre le pool de connexions créé au paramètre connection_pool de la classe Redis. Il est ainsi possible de réaliser un sharding côté client ou de contrôler précisément la gestion des connexions :

>>> pool = redis.ConnectionPool(host='localhost', port=6379, db=0)

>>> r = redis.StrictRedis(connection_pool=pool)
Copier après la connexion

4.2 连接

ConnectionPool 管理一组 Connection 实例。redis-py 提供两种类型的 Connection。缺省情况下,Connection 是一个普通的 TCP 连接。 UnixDomainSocketConnection 允许和服务器运行在同一个设备上的客户端通过 unix 套接字进行连接。要使用 UnixDomainSocketConnection 连接, 只需要通过unix_socket_path 参数传递一个 unix 套接字文件的字符串。另外,确保redis.conf 文件配置了unixsocket 参数(缺省情况下是注释掉的):

>>> r = redis.StrictRedis(unix_socket_path='/tmp/redis.sock')
Copier après la connexion

也可以自己创建 Connection 子类。这个特性可以在使用异步框架时用于控制 socket 的行为。要使用自己的Connection 初始化客户端类,需要创建一个连接池,通 connection_class 参数把自己的类传递进去。传递的其它关键字参数会在初始化时传递给自定义的类:

>>> pool = redis.ConnectionPool(connection_class=YourConnectionClass, your_arg='...', ...)
Copier après la connexion

4.3 分析器

分析类提供了控制如何对 Redis 服务器的响应进行分析的途径。redis-py 提供了两个分析类, PythonParser和 HiredisParser。缺省情况下,如果安装了 hiredis 模块, redis-py 会尝试使用 HiredisParser,否则使用 PythonParser。

Hiredis 是由 Redis 核心团队维护的 C 库。 Pieter Noordhuis 创建了 Python 的实现。分析 Redis 服务器的响应时,Hiredis 可以提供 10 倍的速度提升。性能提升在获取大量数据时优为明显,比如 LRANGE 和SMEMBERS 操作。

和 redis-py 一样,Hiredis 在 Pypi 中就有,可以通过 pip 或 easy_install 安装:

$ pip install hiredis
Copier après la connexion

或:

$ easy_install hiredis
Copier après la connexion

4.4 响应回调函数

客户端类使用一系列回调函数来把 Redis 响应转换成合适的 Python 类型。有些回调函数在 Redis 客户端类的字典 RESPONSE_CALLBACKS 中定义。

通过 set_response_callback 方法可以把自定义的回调函数添加到单个实例。这个方法接受两个参数:一个命令名和一个回调函数。通过这种方法添加的回调函数只对添加到的对象有效。要想全局定义或重载一个回调函数,应该创建 Redis 客户端的子类并把回调函数添加到类的 RESPONSE_CALLBACKS(原文误为REDIS_CALLBACKS) 中。

响应回调函数至少有一个参数:Redis 服务器的响应。要进一步控制如何解释响应,也可以使用关键字参数。这些关键字参数在对 execute_command 的命令调用时指定。通过 “withscores” 参数,ZRANGE 演示了回调函数如何使用关键字参数。

4.5 线程安全

Redis 客户端实例可以安全地在线程间共享。从内部实现来说,只有在命令执行时才获取连接实例,完成后直接返回连接池,命令永不修改客户端实例的状态。

但是,有一点需要注意:SELECT 命令。SELECT 命令允许切换当前连接使用的数据库。新的数据库保持被选中状态,直到选中另一个数据库或连接关闭。这会导致在返回连接池时,连接可能指定了别的数据库。

因此,redis-py 没有在客户端实例中实现 SELECT 命令。如果要在同一个应用中使用多个 Redis 数据库,应该给第一个数据库创建独立的客户端实例(可能也需要独立的连接池)。

在线程间传递 PubSub 和 Pipeline 对象是不安全的。

4.6 Pipeline

Pipeline 是 StrictRedis 类的子类,支持在一个请求里发送缓冲的多个命令。通过减少客户端和服务器之间往来的数据包,可以大大提高命令组的性能。

Pipeline 的使用非常简单:

>>> r = redis.Redis(...)

>>> r.set('bing', 'baz')

>>> # Use the pipeline() method to create a pipeline instance

>>> pipe = r.pipeline()

>>> # The following SET commands are buffered

>>> pipe.set('foo', 'bar')

>>> pipe.get('bing')

>>> # the EXECUTE call sends all bufferred commands to the server, returning

>>> # a list of responses, one for each command.

>>> pipe.execute()

[True, 'baz']
Copier après la connexion

为了方便使用,所有缓冲到 pipeline 的命令返回 pipeline 对象本身。因此调用可以链起来:

>>> pipe.set('foo', 'bar').sadd('faz', 'baz').incr('auto_number').execute()

[True, True, 6]
Copier après la connexion

另外,pipeline 也可以保证缓冲的命令组做为一个原子操作。缺省就是这种模式。要使用命令缓冲,但禁止pipeline 的原子操作属性,可以关掉 transaction:

>>> pipe = r.pipeline(transaction=False)
Copier après la connexion

一个常见的问题是:在进行原子事务操作前需要从 Redis 中获取事务中要用的数据。比如,假设 INCR 命令不存在,但我们需要用 Python 创建一个原子版本的 INCR。

一个不成熟的实现是获取值(GET),在 Python 中增一, 设置(SET)新值。但是,这不是原子操作,因为多个客户端可能在同一时间做这件事,每一个都通过 GET 获取同一个值。

WATCH 命令提供了在开始事务前监视一个或多个键的能力。如果这些键中的任何一个在执行事务前发生改变,整个事务就会被取消并抛出 WatchError 异常。要实现我们的客户 INCR 命令,可以按下面的方法操作:

>>> with r.pipeline() as pipe:

...     while 1:

...         try:

...             # 对序列号的键进行 WATCH

...             pipe.watch('OUR-SEQUENCE-KEY')

...             # WATCH 执行后,pipeline 被设置成立即执行模式直到我们通知它

...             # 重新开始缓冲命令。

...             # 这就允许我们获取序列号的值

...             current_value = pipe.get('OUR-SEQUENCE-KEY')

...             next_value = unicode(int(current_value) + 1)

...             # 现在我们可以用 MULTI 命令把 pipeline 设置成缓冲模式

...             pipe.multi()

...             pipe.set('OUR-SEQUENCE-KEY', next_value)

...             # 最后,执行 pipeline (set 命令)

...             pipe.execute()

...             # 如果执行时没有抛出 WatchError,我们刚才所做的确实“原子地”

...             # 完成了

...             break

...         except WatchError:

...             # 一定是其它客户端在我们开始 WATCH 和执行 pipeline 之间修改了

...             # 'OUR-SEQUENCE-KEY',我们最好的选择是重试

...             continue
Copier après la connexion

注意,因为在整个 WATCH 过程中,Pipeline 必须绑定到一个连接,必须调用 reset() 方法确保连接返回连接池。如果 Pipeline 用作 Context Manager(如上面的例子所示), reset() 会自动调用。当然,也可以用手动的方式明确调用 reset():

>>> pipe = r.pipeline()

>>> while 1:

...     try:

...         pipe.watch('OUR-SEQUENCE-KEY')

...         current_value = pipe.get('OUR-SEQUENCE-KEY')

...         next_value = unicode(int(current_value) + 1)

...         pipe.multi()

...         pipe.set('OUR-SEQUENCE-KEY', next_value)

...         pipe.execute()

...         break

...     except WatchError:

...         continue

...     finally:

...         pipe.reset()
Copier après la connexion

重点(译者注):

·WATCH 执行后,pipeline 被设置成立即执行模式

·用 MULTI 命令把 pipeline 设置成缓冲模式

·要么使用 with,要么显式调用 reset()

有一个简便的名为“transaction”的方法来处理这种处理和在 WatchError 重试的模式。它的参数是一个可执行对象和要 WATCH 任意个数的键,其中可执行对象接受一个 pipeline 对象做为参数。上面的客户端 INCR 命令可以重写如下(更可读):

>>> def client_side_incr(pipe):

...     current_value = pipe.get('OUR-SEQUENCE-KEY')

...     next_value = unicode(int(current_value) + 1)

...     pipe.multi()

...     pipe.set('OUR-SEQUENCE-KEY', next_value)

>>> 

>>> r.transaction(client_side_incr, 'OUR-SEQUENCE-KEY')
Copier après la connexion

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal