Python_Redis使用_python redis库

Redis存储(import redis)

• Redis是一个基于内存的高效的键值型非关系型数据库，存储效率极高，而且支持多种存储数据结构。
• 连接Reids，键操作，字符串操作，列表操作，集合操作，有序集合操作，散列操作

1、安装

• windows安装Redis
• Redis Desktop Manager可视化的下载及安装免费版0.9.3.817 , 介绍
• linux安装redis，Ubuntu安装redis

  # 安装
  apt-get install redis-server  或者 yum -y install redis
  # 卸载
  sudo apt-get purge --auto-remove redis-server
  # 查看启动
  ps -aux | grep redis
  # 启动
  service redis-server start  或者 	service redis start 
  # 停止
  service redis-server stop  或者 	service redis stop 
  # 连接服务
  redis-cli -h [ip] -p [端口]
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• python之redis库，pip install redis
• 修改远程访问，先修改配置

  vim /etc/redis.conf
  # 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问
  bind 0.0.0.0
  # 守护进程，修改为yes后即可后台运行
  daemonize yes
  # 密码，设置后访问Redis必须输入密码
  requirepass 123456
  #protected-mode(若有)置为no
  protected-mode no
  service redis stop 
  service redis start 
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

2、Python_Redis使用

（1）连接Redis

from redis import StrictRedis
#声明StrictRedis对象
redis = StrictRedis(host='localhost',port=6379,db=0,password=None)
redis.set('name','Bob')
print(redis.get('name'))
#运行结果
#b'Bob'
1
2
3
4
5
6
7

（2）Redis键操作

from redis import StrictRedis
redis = StrictRedis(host='localhost',port=6379,db=0,password=None)
redis.set('name','Bob')
redis.set('name1','Bob1')
redis.set('name2','Bob2')
redis.set('name3','Bob3')
'''键操作开始'''
redis.exists('name')  # 是否存在name这个键
redis.expire('name',10)  # 将name键的过期时间设置为10秒
redis.ttl('name')  # 获取name这个键的过期时间
redis.delete('name3')  # 删除name3这个键
redis.dbsize()  # 获取当前数据库中键的数目
redis.type('name')  # 判断name这个键的类型
redis.move('name1',2)  # 将name1移动到2号数据库
redis.rename('name2','nickname')  # 将name2重命名为nickname
redis.keys('n*')  # 获取所有已n开头的键
redis.randomkey()  # 获取随机的一个键
redis.flushdb()  # 删除当前选择数据库中的所有键
redis.flushall()  # 删除所有数据库中的所有键
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（3）Redis字符串操作

from redis import StrictRedis
redis = StrictRedis(host='localhost',port=6379,db=0,password=None)
'''字符串操作开始'''
redis.set('name','Bob'))  # 将name这个键的value值赋值为Bob
redis.get('name'))  # 返回name这个键的value
redis.setex('name',1,'James')  # 将name键的这个值设为James，有效期为1秒
redis.incr('count',1)  # count对应的值增1，若不存在则创建并设置为1
redis.decr('age',1)  # age对应的值减1，若不存在则创建并设置为-1
redis.mset({'name1':'Durant','name2':'James'})  # 将name1设为Durant,将name2设为James
redis.mget(['name','nickname'])  # 返回name和nickname的value
redis.getset('name','Mike')  # 赋值name值为value并得到上次的value
redis.setnx('newname','James')  # 如果newname这个键不存在，则设置值为James：", redis.setnx('newname','James')
redis.msetnx({'name3':'Smith','name4':'Curry'})  # 在name3和name4均不存在的情况下才设置二者值
redis.setrange('name',6,'World')  # 在name值为4的位置补World
redis.append('nickname','ok')  # 向键为nickname的值后面追加ok
redis.substr('name',1,4)  # 返回键为name的值的字符串没截取索引为1~4的字符
redis.getrange('name',1,4)  # 返回键为name的值的字符串没截取索引为1~4的字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（4）Redis列表操作（常用）

• 元素可重复

"""列表操作list"""
from redis import StrictRedis
r = StrictRedis(host='localhost', port=6379, db=1)
url = 'https://www.baidu.com'
url1 = 'https://www.taobao.com'
url2 = 'https://www.sina.com.cn'
r.rpush('list', url, url1, url2)  # 给键list表尾添加1，2，3
for i in range(r.llen('list')):
    t = r.lindex('list', i)
    item = t.decode('utf-8')
    print(item)
    
r.rpush('list', url)  # 给键list尾部添加字段url
r.lpush('list', url)  # 给键list头部添加字段url
r.rpop('list', url)  # 取出键list尾部字段url
r.lpop('list', url)  # 取出键list头部字段url
r.lrange('list', 0, -1)  # 查看键list里面所有的值
r.lrange('list', 0, 2) # 返回键list索引为0终止索引为2的值
r.lrem('list', 2, url)  # 删除键list里面从头开始前面2个值是url的
r.lrem('list', -2, url)  # 删除键list里面从尾部开始倒数的2个值是url的
r.lrem('list', 0, url)  # 删除键list里面所有值是url的
r.llen('list')  # 返回键为list的列表长度
r.lindex('list', 1)  # 返回键为list索引为1的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（5）Redis集合操作（常用）

• 集合中的元素是不重复的

"""集合操作set"""
from redis import StrictRedis
r = StrictRedis(host='localhost', port=6379, db=2)
r.sadd('tags', 'Book', 'Tea', 'Coffee')  # 向键为tags的集合中添加Book、Tea和Coffee这3个内容
for me in r.smembers('tags'):
    item = me.decode('utf-8')
    print(item)
    
r.sadd('tags', 'Book')  # 向键为tags的集合中添值
r.smembers("tags", "Book")  # 判断Book是否是tags的元素
r.srem('tags', 'Book')  # 从键为tags的集合中删除Book
r.scard('tags')  # 获取键为tags的集合中的元素的个数
r.smembers('tags')  # 返回键为tags的集合中所有元素
1
2
3
4
5
6
7
8
9
10
11
12
13

（6）Redis有序集合操作（常用）

• 有序集合比集合多了一个分数字段，利用该字段可以对集合中的数据进行排序

"""有序集合操作zset"""
from redis import StrictRedis
r = StrictRedis(host='localhost', port=6379, db=3)
# r.zadd('grade', 100, 'Bob')
1
2
3
4

（7）Redis散列（哈希）操作（常用）

• 用name指定散列表的名称，表内存储多个键值对，可进行键定位，值的更新

  """散列操作"""
  from redis import StrictRedis
  r = StrictRedis(host='localhost', port=6379, db=4)
  r.hset('price', 'cake', 5)  # 向键为price的散列表中添加映射关系，cake的值为5
  r.hget('price', 'cake')  # 获取键为price的散列表中键名为cake的值
  r.hgetall('price')  # 键为price的散列表中获取所有映射键值对
  r.hmset('price', {'banana': 2, 'pear': 8})  # 向键为price的散列表中批量添加映射
  r.hkeys('price')  # 从键为price的散列表中获取所有映射键名
  r.hvals('price')  # 从键为price的散列表中获取所有映射键值
  r.hdel("price", "cake")  # 删除键为price的散列表中键名为cake的
  r.hexists("price", "cake")  # 判断键为price的散列表中键名为cake是否存在
  r.hlen('price')  # 从键为price的散列表中获取映射个数
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

• 其中如果name名称命名中间以冒号的形式，则会归类到一个文件夹里面
  

  

• 如下代码，是hash的一个应用案例

  import random
  import redis
  
  
  class RedisClient(object):
      """
      redis client
      """
      
      def __init__(self, _type, website, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
          """
          init redis client
          :param host: redis host
          :param port: redis port
          :param password: redis password
          """
          self.db = redis.StrictRedis(host=host, port=port, password=password, decode_responses=True)
          self.type = _type
          self.website = website
      
      def name(self):
          """
          get hash name
          :return: name of hash
          """
          return f'{self.type}:{self.website}'
      
      def set(self, username, value):
          """
          set key-value
          :param username: username
          :param value: password or cookies
          :return:
          """
          return self.db.hset(self.name(), username, value)
      
      def get(self, username):
          """
          get value
          :param username: username
          :return:
          """
          return self.db.hget(self.name(), username)
      
      def delete(self, username):
          """
          delete key-value
          :param username: username
          :return: result
          """
          return self.db.hdel(self.name(), username)
      
      def count(self):
          """
          get count
          :return: count
          """
          return self.db.hlen(self.name())
      
      def random(self):
          """
          get random cookies or password
          :return: random cookies or password
          """
          return random.choice(self.db.hvals(self.name()))
      
      def usernames(self):
          """
          get all usernames
          :return: all usernames
          """
          return self.db.hkeys(self.name())
      
      def all(self):
          """
          get all key-values
          :return: map of key-values
          """
          return self.db.hgetall(self.name())
  
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81

3、RedisDump

• RedisDump提供了强大的Redis数据的导入和导出功能
• redis-dump用于导出数据，redis-dump是将redis和json互转的工具
• redis-load用于导入数据

4、实例函数

（1）连接redis数据库

from redis import StrictRedis


def connect_redis(config: dict, db_index: int):
    """
    连接redis数据库
    :param config:
    :param db_index: 
    :return:
    """
    _db = StrictRedis(
        host=config['host'],
        port=config['port'],
        password=config['auth'], db=db_index)
    return _db


local_config = {
    "host": "localhost",
    "port": 6379,
    "auth": None
}
redis_db = connect_redis(local_config, 0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（2）存储数据

• lpush添表头
• rpush添表尾

from redis import StrictRedis
import json
def save_redis_record(redis_db, key_name, record):
    """
    存储1条数据
    :param redis_db:
    :param key_name: "键名"
    :param record: 数据
    :return:
    """
    # 存储1条数据
    redis_db.lpush(key_name, json.dumps(record, ensure_ascii=False))  # 添表头
    redis_db.rpush(key_name, json.dumps(record, ensure_ascii=False))  # 添表尾
1
2
3
4
5
6
7
8
9
10
11
12
13

（3）取1条数据

• lpop添表头
• rpop添表尾

from redis import StrictRedis
import json
def fetch_redis_record(redis_db, key_name):
    """
    redis取数据
    :param redis_db:
    :param key_name:
    :return:
    """
    data1 = json.loads(redis_db.lpop(key_name))  # 取表首
    data2 = json.loads(redis_db.rpop(key_name))  # 取表尾
1
2
3
4
5
6
7
8
9
10
11

（4）取一系列数据

from redis import StrictRedis
import json
def read_range_redis_record(redis_db, key_name, s_index: int, e_index: int):
    """
    读取索引为0终止索引为10的数据
    :param redis_db: 
    :param key_name: 
    :param s_index: 起始索引
    :param e_index: 终止索引
    :return: 
    """
    records = redis_db.lrange(key_name, s_index, e_index)
    for record in records:
        print(json.loads(record))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5、其他机器访问本地redis服务器

• 首先，修改本地redis.windows.conf文件，第56行的bind 127.0.0.1改为bind 192.168.1.8（查看本机ipv4地址）

  bind 本机ipv4地址
  1

• 接着重启redis服务

  redis-server.exe
  1

• 最后，在另一个尝试连接，比如ubuntu尝试连接windows的redis

  redis-cli -h 192.168.1.8 -p 6379
  1