python3 操作redis

痛定思痛。 2021-08-25 02:42 333阅读 0赞

## 安装和使用 ##

### 安装 ###

安装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'))