您现在的位置是：首页 > 数据库

当前栏目

python3 操作redis

Redis Python3

2023-03-02 11:24:06 时间

## 安装和使用 ##

### 安装 ###

安装redis模块

pip3 install redis

**普通连接**

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

import redis
    conn = redis.Redis(host='127.0.0.1', port=6379)
    # 可以使用url方式连接到数据库
    # conn = Redis.from_url('redis://@localhost:6379/1')
    conn.set('name', 'LinWOW')
    print(conn.get('name'))

**连接池**

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

连接池：redis\_pool.py

from redis import ConnectionPool
    POOL=ConnectionPool(host='127.0.0.1',port=6379,max_connections=100)

使用连接池：test\_redis.py

import redis
    from redis_pool import POOl
    conn = redis.Redis(connection_pool=POOl)
    conn.set('name', 'LinWOW')
    print(conn.get('name'))

构造url方式连接到数据库，有以下三种模式：

redis://[:password]@host:port/db    # TCP连接
    rediss://[:password]@host:port/db   # Redis TCP+SSL 连接
    unix://[:password]@/path/to/socket.sock?db=db    # Redis Unix Socket 连接

**Python操作Redis**

### String操作 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>set(name, value, ex=None, px=None, nx=False, xx=False)</td> 
   <td>ex，过期时间(s)；px，过期时间(ms)；nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果；xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值</td> 
   <td>效果和setex，setnx一致</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>set(name, value)</td> 
   <td>给name赋值为value</td> 
   <td>redis.set(‘name’, ‘Bob’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>get(name)</td> 
   <td>返回数据库中key为name的string的value</td> 
   <td>redis.get(‘name’)</td> 
   <td>b’Bob’</td> 
  </tr> 
  <tr> 
   <td>getset(name, value)</td> 
   <td>给数据库中key为name的string赋予值value并返回上次的value</td> 
   <td>redis.getset(‘name’, ‘Mike’)</td> 
   <td>b’Bob’</td> 
  </tr> 
  <tr> 
   <td>mget(keys, *args)</td> 
   <td>返回多个key对应的value</td> 
   <td>redis.mget([‘name’, ‘nickname’])</td> 
   <td>[b’Mike’, b’Miker’]</td> 
  </tr> 
  <tr> 
   <td>setnx(name, value)</td> 
   <td>如果key不存在才设置value</td> 
   <td>redis.setnx(‘newname’, ‘James’)</td> 
   <td>第一次运行True，第二次False</td> 
  </tr> 
  <tr> 
   <td>setex(name, time, value)</td> 
   <td>设置可以对应的值为string类型的value，并指定此键值对应的有效期</td> 
   <td>redis.setex(‘name’, 1, ‘James’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>setrange(name, offset, value)</td> 
   <td>设置指定key的value值的子字符串</td> 
   <td>redis.set(‘name’, ‘Hello’) redis.setrange(‘name’, 6, ‘World’)</td> 
   <td>11，修改后的字符串长度</td> 
  </tr> 
  <tr> 
   <td>mset(mapping)</td> 
   <td>批量赋值</td> 
   <td>redis.mset({‘name1’: ‘Durant’, ‘name2’: ‘James’})</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>msetnx(mapping)</td> 
   <td>key均不存在时才批量赋值</td> 
   <td>redis.msetnx({‘name3’: ‘Smith’, ‘name4’: ‘Curry’})</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>incr(name, amount=1)</td> 
   <td>key为name的value增值操作，默认1，key不存在则被创建并设为amount</td> 
   <td>redis.incr(‘age’, 1)</td> 
   <td>1，即修改后的值</td> 
  </tr> 
  <tr> 
   <td>decr(name, amount=1)</td> 
   <td>key为name的value减值操作，默认1，key不存在则被创建并设置为-amount</td> 
   <td>redis.decr(‘age’, 1)</td> 
   <td>-1，即修改后的值</td> 
  </tr> 
  <tr> 
   <td>append(key, value)</td> 
   <td>key为name的string的值附加value</td> 
   <td>redis.append(‘nickname’, ‘OK’)</td> 
   <td>13，即修改后的字符串长度</td> 
  </tr> 
  <tr> 
   <td>substr(name, start, end=-1)</td> 
   <td>返回key为name的string的value的子串</td> 
   <td>redis.substr(‘name’, 1, 4)</td> 
   <td>b’ello’</td> 
  </tr> 
  <tr> 
   <td>getrange(key, start, end)</td> 
   <td>获取key的value值从start到end的子字符串</td> 
   <td>redis.getrange(‘name’, 1, 4)</td> 
   <td>b’ello’</td> 
  </tr> 
 </tbody> 
</table>

### Key操作 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>exists(name)</td> 
   <td>判断一个key是否存在</td> 
   <td>redis.exists(‘name’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>delete(name)</td> 
   <td>删除一个key</td> 
   <td>redis.delete(‘name’)</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>type(name)</td> 
   <td>判断key类型</td> 
   <td>redis.type(‘name’)</td> 
   <td>b’string’</td> 
  </tr> 
  <tr> 
   <td>keys(pattern)</td> 
   <td>获取所有符合规则的key</td> 
   <td>redis.keys(‘n*’)</td> 
   <td>[b’name’]</td> 
  </tr> 
  <tr> 
   <td>randomkey()</td> 
   <td>获取随机的一个key</td> 
   <td>randomkey()</td> 
   <td>b’name’</td> 
  </tr> 
  <tr> 
   <td>rename(src, dst)</td> 
   <td>将key重命名</td> 
   <td>redis.rename(‘name’, ‘nickname’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>dbsize()</td> 
   <td>获取当前数据库中key的数目</td> 
   <td>dbsize()</td> 
   <td>100</td> 
  </tr> 
  <tr> 
   <td>expire(name, time)</td> 
   <td>设定key的过期时间，单位秒</td> 
   <td>redis.expire(‘name’, 2)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>ttl(name)</td> 
   <td>获取key的过期时间，单位秒，-1为永久不过期</td> 
   <td>redis.ttl(‘name’)</td> 
   <td>-1</td> 
  </tr> 
  <tr> 
   <td>move(name, db)</td> 
   <td>将key移动到其他数据库</td> 
   <td>move(‘name’, 2)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>flushdb()</td> 
   <td>删除当前选择数据库中的所有key</td> 
   <td>flushdb()</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>flushall()</td> 
   <td>删除所有数据库中的所有key</td> 
   <td>flushall()</td> 
   <td>True</td> 
  </tr> 
 </tbody> 
</table>

### List操作 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rpush(name, *values)</td> 
   <td>在key为name的list尾添加值为value的元素，可以传多个</td> 
   <td>redis.rpush(‘list’, 1, 2, 3)</td> 
   <td>3，list大小</td> 
  </tr> 
  <tr> 
   <td>lpush(name, *values)</td> 
   <td>在key为name的list头添加值为value的元素，可以传多个</td> 
   <td>redis.lpush(‘list’, 0)</td> 
   <td>4，list大小</td> 
  </tr> 
  <tr> 
   <td>llen(name)</td> 
   <td>返回key为name的list的长度</td> 
   <td>redis.llen(‘list’)</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>lrange(name, start, end)</td> 
   <td>返回key为name的list中start至end之间的元素</td> 
   <td>redis.lrange(‘list’, 1, 3)</td> 
   <td>[b’3’, b’2’, b’1’]</td> 
  </tr> 
  <tr> 
   <td>ltrim(name, start, end)</td> 
   <td>截取key为name的list，保留索引为start到end的内容</td> 
   <td>ltrim(‘list’, 1, 3)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>lindex(name, index)</td> 
   <td>返回key为name的list中index位置的元素</td> 
   <td>redis.lindex(‘list’, 1)</td> 
   <td>b’2’</td> 
  </tr> 
  <tr> 
   <td>lset(name, index, value)</td> 
   <td>给key为name的list中index位置的元素赋值，越界则报错</td> 
   <td>redis.lset(‘list’, 1, 5)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>lrem(name, count, value)</td> 
   <td>删除count个key的list中值为value的元素</td> 
   <td>redis.lrem(‘list’, 2, 3)</td> 
   <td>1，即删除的个数</td> 
  </tr> 
  <tr> 
   <td>lpop(name)</td> 
   <td>返回并删除key为name的list中的首元素</td> 
   <td>redis.lpop(‘list’)</td> 
   <td>b’5’</td> 
  </tr> 
  <tr> 
   <td>rpop(name)</td> 
   <td>返回并删除key为name的list中的尾元素</td> 
   <td>redis.rpop(‘list’)</td> 
   <td>b’2’</td> 
  </tr> 
  <tr> 
   <td>blpop(keys, timeout=0)</td> 
   <td>返回并删除名称为在keys中的list中的首元素，如果list为空，则会一直阻塞等待</td> 
   <td>redis.blpop(‘list’)</td> 
   <td>[b’5’]</td> 
  </tr> 
  <tr> 
   <td>brpop(keys, timeout=0)</td> 
   <td>返回并删除key为name的list中的尾元素，如果list为空，则会一直阻塞等待</td> 
   <td>redis.brpop(‘list’)</td> 
   <td>[b’2’]</td> 
  </tr> 
  <tr> 
   <td>rpoplpush(src, dst)</td> 
   <td>返回并删除名称为src的list的尾元素，并将该元素添加到名称为dst的list的头部</td> 
   <td>redis.rpoplpush(‘list’, ‘list2’)</td> 
   <td>b’2’</td> 
  </tr> 
 </tbody> 
</table>

**应用场景：**

blpop实现简单分布式爬虫：

多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式

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

自定义增量迭代：

> 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：  
>     1、获取name对应的所有列表  
>     2、循环列表  
> 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：

import redis
    conn=redis.Redis(host='127.0.0.1',port=6379)
    # conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
    # conn.flushall()
    def scan_list(name,count=2):
        index=0
        while True:
            data_list=conn.lrange(name,index,count+index-1)
            if not data_list:
                return
            index+=count
            for item in data_list:
                yield item
    print(conn.lrange('test',0,100))
    for item in scan_list('test',5):
        print('---')
        print(item)

**Set操作**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sadd(name, *values)</td> 
   <td>向key为name的set中添加元素</td> 
   <td>redis.sadd(‘tags’, ‘Book’, ‘Tea’, ‘Coffee’)</td> 
   <td>3，即插入的数据个数</td> 
  </tr> 
  <tr> 
   <td>srem(name, *values)</td> 
   <td>从key为name的set中删除元素</td> 
   <td>redis.srem(‘tags’, ‘Book’)</td> 
   <td>1，即删除的数据个数</td> 
  </tr> 
  <tr> 
   <td>spop(name)</td> 
   <td>随机返回并删除key为name的set中一个元素</td> 
   <td>redis.spop(‘tags’)</td> 
   <td>b’Tea’</td> 
  </tr> 
  <tr> 
   <td>smove(src, dst, value)</td> 
   <td>从src对应的set中移除元素并添加到dst对应的set中</td> 
   <td>redis.smove(‘tags’, ‘tags2’, ‘Coffee’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>scard(name)</td> 
   <td>返回key为name的set的元素个数</td> 
   <td>redis.scard(‘tags’)</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>sismember(name, value)</td> 
   <td>测试member是否是key为name的set的元素</td> 
   <td>redis.sismember(‘tags’, ‘Book’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>sinter(keys, *args)</td> 
   <td>返回所有给定key的set的交集</td> 
   <td>redis.sinter([‘tags’, ‘tags2’])</td> 
   <td>{b’Coffee’}</td> 
  </tr> 
  <tr> 
   <td>sinterstore(dest, keys, *args)</td> 
   <td>求交集并将交集保存到dest的集合</td> 
   <td>redis.sinterstore(‘inttag’, [‘tags’, ‘tags2’])</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>sunion(keys, *args)</td> 
   <td>返回所有给定key的set的并集</td> 
   <td>redis.sunion([‘tags’, ‘tags2’])</td> 
   <td>{b’Coffee’, b’Book’, b’Pen’}</td> 
  </tr> 
  <tr> 
   <td>sunionstore(dest, keys, *args)</td> 
   <td>求并集并将并集保存到dest的集合</td> 
   <td>redis.sunionstore(‘inttag’, [‘tags’, ‘tags2’])</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>sdiff(keys, *args)</td> 
   <td>返回所有给定key的set的差集</td> 
   <td>redis.sdiff([‘tags’, ‘tags2’])</td> 
   <td>{b’Book’, b’Pen’}</td> 
  </tr> 
  <tr> 
   <td>sdiffstore(dest, keys, *args)</td> 
   <td>求差集并将差集保存到dest的集合</td> 
   <td>redis.sdiffstore(‘inttag’, [‘tags’, ‘tags2’])</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>smembers(name)</td> 
   <td>返回key为name的set的所有元素</td> 
   <td>redis.smembers(‘tags’)</td> 
   <td>{b’Pen’, b’Book’, b’Coffee’}</td> 
  </tr> 
  <tr> 
   <td>srandmember(name)</td> 
   <td>随机返回key为name的set的一个元素，但不删除元素</td> 
   <td>redis.srandmember(‘tags’)</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

### Sorted Set操作 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>zadd(name, args, *kwargs)</td> 
   <td>向key为name的zset中添加元素member，score用于排序。如果该元素存在，则更新其顺序</td> 
   <td>redis.zadd(‘grade’, 100, ‘Bob’, 98, ‘Mike’)</td> 
   <td>2，即添加的元素个数</td> 
  </tr> 
  <tr> 
   <td>zrem(name, *values)</td> 
   <td>删除key为name的zset中的元素</td> 
   <td>redis.zrem(‘grade’, ‘Mike’)</td> 
   <td>1，即删除的元素个数</td> 
  </tr> 
  <tr> 
   <td>zincrby(name, value, amount=1)</td> 
   <td>如果在key为name的zset中已经存在元素value，则该元素的score增加amount，否则向该集合中添加该元素，其score的值为amount</td> 
   <td>redis.zincrby(‘grade’, ‘Bob’, -2)</td> 
   <td>98.0，即修改后的值</td> 
  </tr> 
  <tr> 
   <td>zrank(name, value)</td> 
   <td>返回key为name的zset中元素的排名（按score从小到大排序）即下标</td> 
   <td>redis.zrank(‘grade’, ‘Amy’)</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>zrevrank(name, value)</td> 
   <td>返回key为name的zset中元素的倒数排名（按score从大到小排序）即下标</td> 
   <td>redis.zrevrank(‘grade’, ‘Amy’)</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>zrevrange(name, start, end, withscores=False)</td> 
   <td>返回key为name的zset（按score从大到小排序）中的index从start到end的所有元素</td> 
   <td>redis.zrevrange(‘grade’, 0, 3)</td> 
   <td>[b’Bob’, b’Mike’, b’Amy’, b’James’]</td> 
  </tr> 
  <tr> 
   <td>zrangebyscore(name, min, max, start=None, num=None, withscores=False)</td> 
   <td>返回key为name的zset中score在给定区间的元素</td> 
   <td>redis.zrangebyscore(‘grade’, 80, 95)</td> 
   <td>[b’Amy’, b’James’]</td> 
  </tr> 
  <tr> 
   <td>zcount(name, min, max)</td> 
   <td>返回key为name的zset中score在给定区间的数量</td> 
   <td>redis.zcount(‘grade’, 80, 95)</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>zcard(name)</td> 
   <td>返回key为name的zset的元素个数</td> 
   <td>redis.zcard(‘grade’)</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>zremrangebyrank(name, min, max)</td> 
   <td>删除key为name的zset中排名在给定区间的元素</td> 
   <td>redis.zremrangebyrank(‘grade’, 0, 0)</td> 
   <td>1，即删除的元素个数</td> 
  </tr> 
  <tr> 
   <td>zremrangebyscore(name, min, max)</td> 
   <td>删除key为name的zset中score在给定区间的元素</td> 
   <td>redis.zremrangebyscore(‘grade’, 80, 90)</td> 
   <td>1，即删除的元素个数</td> 
  </tr> 
 </tbody> 
</table>

### Hash操作 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
   <th>示例</th> 
   <th>示例结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hset(name, key, value)</td> 
   <td>向key为name的hash中添加映射</td> 
   <td>hset(‘price’, ‘cake’, 5)</td> 
   <td>1，即添加的映射个数</td> 
  </tr> 
  <tr> 
   <td>hsetnx(name, key, value)</td> 
   <td>向key为name的hash中添加映射，如果映射键名不存在</td> 
   <td>hsetnx(‘price’, ‘book’, 6)</td> 
   <td>1，即添加的映射个数</td> 
  </tr> 
  <tr> 
   <td>hget(name, key)</td> 
   <td>返回key为name的hash中field对应的value</td> 
   <td>redis.hget(‘price’, ‘cake’)</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>hmget(name, keys, *args)</td> 
   <td>返回key为name的hash中各个键对应的value</td> 
   <td>redis.hmget(‘price’, [‘apple’, ‘orange’])</td> 
   <td>[b’3’, b’7’]</td> 
  </tr> 
  <tr> 
   <td>hmset(name, mapping)</td> 
   <td>向key为name的hash中批量添加映射</td> 
   <td>redis.hmset(‘price’, {‘banana’: 2, ‘pear’: 6})</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>hincrby(name, key, amount=1)</td> 
   <td>将key为name的hash中映射的value增加amount</td> 
   <td>redis.hincrby(‘price’, ‘apple’, 3)</td> 
   <td>6，修改后的值</td> 
  </tr> 
  <tr> 
   <td>hexists(name, key)</td> 
   <td>key为namehash中是否存在键名为key的映射</td> 
   <td>redis.hexists(‘price’, ‘banana’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>hdel(name, *keys)</td> 
   <td>key为namehash中删除键名为key的映射</td> 
   <td>redis.hdel(‘price’, ‘banana’)</td> 
   <td>True</td> 
  </tr> 
  <tr> 
   <td>hlen(name)</td> 
   <td>从key为name的hash中获取映射个数</td> 
   <td>redis.hlen(‘price’)</td> 
   <td>6</td> 
  </tr> 
  <tr> 
   <td>hkeys(name)</td> 
   <td>从key为name的hash中获取所有映射键名</td> 
   <td>redis.hkeys(‘price’)</td> 
   <td>[b’cake’, b’book’, b’banana’, b’pear’]</td> 
  </tr> 
  <tr> 
   <td>hvals(name)</td> 
   <td>从key为name的hash中获取所有映射键值</td> 
   <td>redis.hvals(‘price’)</td> 
   <td>[b’5’, b’6’, b’2’, b’6’]</td> 
  </tr> 
  <tr> 
   <td>hgetall(name)</td> 
   <td>从key为name的hash中获取所有映射键值对</td> 
   <td>redis.hgetall(‘price’)</td> 
   <td>{b’cake’: b’5’, b’book’: b’6’, b’orange’: b’7’, b’pear’: b’6’}</td> 
  </tr> 
 </tbody> 
</table>

注意点：

hscan(name, cursor=0, match=None, count=None)：增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆

> 参数：  
>     name，redis的name  
>     cursor，游标（基于游标分批取获取数据）  
>     match，匹配指定key，默认None 表示所有的key  
>     count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数  
> 如：  
>     第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)  
>     第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)  
>     ...  
>     直到返回值cursor的值为0时，表示数据已经通过分片获取完毕  
>

hscan\_iter(name, match=None, count=None)： 利用yield封装hscan创建生成器，实现分批去redis中获取数据

> 参数：  
>     match，匹配指定key，默认None 表示所有的key  
>     count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数  
> 如：  
>     for item in r.hscan\_iter('xx'):  
>         print item  
>

**管道**

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.multi()
    pipe.set('name', 'linwow')
    pipe.set('age', '18')
    pipe.execute()

**Django中使用redis**

**方式一：**

utils文件夹下，建立redis\_pool.py

import redis
    POOL = redis.ConnectionPool(host='127.0.0.1', port=6379,password='1234',max_connections=1000)

视图函数中使用：

import redis
    from django.shortcuts import render,HttpResponse
    from redis_pool import POOL
    
    def index(request):
        conn = redis.Redis(connection_pool=POOL)
        conn.hset('liwow','age',18)
        return HttpResponse('设置成功')
        
    def order(request):
        conn = redis.Redis(connection_pool=POOL)
        conn.hget('kkk','age')
        return HttpResponse('获取成功')

**方式二：**

安装django-redis模块

pip3 install django-redis

setting里配置：

# redis配置
    CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://127.0.0.1:6379",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
                "CONNECTION_POOL_KWARGS": {"max_connections": 100}
                # "PASSWORD": "123",
            }
        }
    }

视图函数：

from django_redis import get_redis_connection
    conn = get_redis_connection('default')
    print(conn.hgetall('xxx'))

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

python3 操作redis

相关文章