python redis详解(一)安装及连接使用

野性酷女 2021-12-10 11:31 206阅读 0赞

redis提供了多种语言的客户端， python连接使用redis 官方推荐使用叫redis的第三方库

python redis 对于redis的使用以及一些管理都很方便：

#### 安装： ####

pip install redis

这里安装使用的是目前最新版本 3.2.1

--------------------

#### redis连接 ####

##### 单连接 #####

# coding:utf-8
    import redis
    
    r = redis.Redis(host='100.69.169.13', port=4410, db=13)
    r.set('m1', 'test')
    print r.get('m1')

python3只允许 bytes, strings or numbers (ints, longs and floats)  
而python2会尝试将用户的输入转换为string， 这有时候会引起DataError异常

获取锁

try:
        with r.lock('my-lock-key', blocking_timeout=5) as lock:
            # code you want executed only after the lock has been acquired
    except LockError:
        # the lock wasn't acquired

##### 连接池 #####

pool = redis.ConnectionPool(host=‘localhost’, port=6379, db=0)  
r = redis.Redis(connection\_pool=pool)

线程安全， 可以在线程之间安全地共享Redis客户端实例

这里详解一下redis及redispool

##### REDIS定义： #####

class Redis(object):
        def __init__(self, host='localhost', port=6379,
                     db=0, password=None, socket_timeout=None,
                     socket_connect_timeout=None,
                     socket_keepalive=None, socket_keepalive_options=None,
                     connection_pool=None, unix_socket_path=None,
                     encoding='utf-8', encoding_errors='strict',
                     charset=None, errors=None,
                     decode_responses=False, retry_on_timeout=False,
                     ssl=False, ssl_keyfile=None, ssl_certfile=None,
                     ssl_cert_reqs='required', ssl_ca_certs=None,
                     max_connections=None):

host 连接地址

port端口号

db redis默认提供0-15 一共16个db区分， 默认为0， 在集群中只能是0

password 安全认证设置， redis的认证密码， 密码串无加密

socket\_timeout socket超时时间

connection\_pool 连接池参数， 如果要使用redis连接池，则指定该参数 传入ConnectionPool 对象

ssl 是否为ssl认证

ssl\_certfile 证书文件

ssl\_keyfile ca证书的key

ssl\_\* 与ssl认证相关的参数

max\_connections 最大连接数

##### ConnectionPool 定义 #####

class ConnectionPool(object):
        def __init__(self, connection_class=Connection, max_connections=None,
                     **connection_kwargs):
                    pass
                    
         def __repr__(self):
            return "%s<%s>" % (
                type(self).__name__,
                repr(self.connection_class(**self.connection_kwargs)),
            )

使用的是Connection 进行参数初始化：

定义如下：

class Connection(object):
        "Manages TCP communication to and from a Redis server"
        description_format = "Connection<host=%(host)s,port=%(port)s,db=%(db)s>"
    
        def __init__(self, host='localhost', port=6379, db=0, password=None,
                     socket_timeout=None, socket_connect_timeout=None,
                     socket_keepalive=False, socket_keepalive_options=None,
                     socket_type=0, retry_on_timeout=False, encoding='utf-8',
                     encoding_errors='strict', decode_responses=False,
                     parser_class=DefaultParser, socket_read_size=65536):

与Redis 的参数基本一致

--------------------

#### pipline ####

可以进行批量操作，以节省带宽

pipe = r.pipeline()
     # The following SET commands are buffered
     pipe.set('foo', 'bar')
     pipe.get('bing')
     # the EXECUTE call sends all buffered commands to the server, returning
     # a list of responses, one for each command.
     pipe.execute()
     [True, 'baz']

pipeline 返回的是pipline对象本身，因此可以进行连续操作

pe.set(‘foo’, ‘bar’).sadd(‘faz’, ‘baz’).incr(‘auto\_number’).execute()  
rue, True, 6\]

在默认情况下，pipline能够自动将命令缓冲为组进行操作，如果想禁用pipline的原子性操作，但仍然使用pipline的buffer进行命令  
缓冲， 可以关闭事务：

pe = r.pipeline(transaction=False)

WATCH命令。WATCH提供在开始交易之前监视一个或多个密钥的能力。如果在执行该事务之前这些键中的任何键发生了更改，则将取消整个事务并引发WatchError  
例如： incr

with r.pipeline() as pipe:
        while True:
            try:
                # put a WATCH on the key that holds our sequence value
                pipe.watch('OUR-SEQUENCE-KEY')
                # after WATCHing, the pipeline is put into immediate execution
                # mode until we tell it to start buffering commands again.
                # this allows us to get the current value of our sequence
                current_value = pipe.get('OUR-SEQUENCE-KEY')
                next_value = int(current_value) + 1
                # now we can put the pipeline back into buffered mode with MULTI
                pipe.multi()
                pipe.set('OUR-SEQUENCE-KEY', next_value)
                # and finally, execute the pipeline (the set command)
                pipe.execute()
                # if a WatchError wasn't raised during execution, everything
                # we just did happened atomically.
                break
           except WatchError:
                # another client must have changed 'OUR-SEQUENCE-KEY' between
                # the time we started WATCHing it and the pipeline's execution.
                # our best bet is to just retry.
                continue

由于Pipeline必须在WATCH期间绑定到单个连接，因此必须注意确保通过调用reset（）方法将连接返回到连接池

如果不使用上下文管理 with， 则可以手动关闭

pipe = r.pipeline()
    while True:
        try:
            pipe.watch('OUR-SEQUENCE-KEY')
            ...
            pipe.execute()
            break
        except WatchError:
            continue
        finally:
            pipe.reset()

transaction可以更简便地实现：

f  client_side_incr （pipe ）：
    ...     current_value  =  pipe 。get （'OUR-SEQUENCE-KEY' ）
    ...     next_value  =  int （current_value ） +  1 
    ...     pipe 。multi （）
    ...     pipe 。set （'OUR-SEQUENCE-KEY' ， next_value ）
    >>transaction （client_side_incr ， 'OUR-SEQUENCE-KEY' ）
    [True]

##### Pipeline类 #####

除了使用REDIS类的pipline之外， redis还提供了一个专门的Pipeline类对于pipline的支持

定义如下：

class Pipeline(Redis):

继承REDIS

提供一些方法， 比如

`def execute_command(self, *args, **kwargs)`

`def immediate_execute_command(self, *args, **options)`

--------------------

#### 发布订阅： ####

创建发布对象  
r = redis.Redis(…)  
p = r.pubsub()

发布订阅消息：

subscribe(‘my-first-channel’, ‘my-second-channel’, …)  
psubscribe(‘my-\*’, …)

订阅获取消息：

get_message()
    {'pattern': None, 'type': 'subscribe', 'channel': 'my-second-channel', 'data': 1L}
    get_message()
    {'pattern': None, 'type': 'subscribe', 'channel': 'my-first-channel', 'data': 2L}
    get_message()
    {'pattern': None, 'type': 'psubscribe', 'channel': 'my-*', 'data': 3L}

类型：以下之一：‘subscribe’，‘unsubscribe’，‘psubscribe’，‘punsubscribe’，‘message’，‘pmessage’  
channel：订阅的频道\[un\]或发布消息的频道  
pattern：匹配已发布消息的通道的模式。将 没有在所有情况下，除了“pmessage”类型。  
data：消息数据。使用\[un\]订阅消息，此值将是连接当前订阅的通道和模式的数量。使用\[p\]消息消息，此值将是实际发布的消息。

unsubscribe()
    punsubscribe('my-*')
    get_message()
    channel': 'my-second-channel', 'data': 2L, 'pattern': None, 'type': 'unsubscribe'}
    get_message()
    channel': 'my-first-channel', 'data': 1L, 'pattern': None, 'type': 'unsubscribe'}
    get_message()
    channel': 'my-*', 'data': 0L, 'pattern': None, 'type': 'punsubscribe'}

--------------------

#### 哨兵Sentinel 支持： ####

示例：

from redis.sentinel import Sentinel
    ntinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
    ntinel.discover_master('mymaster')
    ('127.0.0.1', 6379)
    ntinel.discover_slaves('mymaster')
    [('127.0.0.1', 6380)]

可以从Sentinel 建立连接 可以连接到master 也可以连接到slave (用于只读，提高读性能)

ster = sentinel.master_for('mymaster', socket_timeout=0.1)
    ave = sentinel.slave_for('mymaster', socket_timeout=0.1)
    ster.set('foo', 'bar')
    ave.get('foo')
    'bar'