redis一览

redis一览

Redis 简介

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

• Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

---

Redis 优势

• 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
• 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
• 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
• 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

---

1、安装redis

Redis与其他key-value存储有什么不同？

• Redis有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。

• Redis运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，因为数据量不能大于硬件内存。在内存数据库方面的另一个优点是，相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，这样Redis可以做很多内部复杂性很强的事情。同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。

来源： http://www.runoob.com/redis/redis-intro.html

Window 下安装

下载地址：https://github.com/MSOpenTech/redis/releases。

下载的为.msc后缀的，只需一顿下一步即可！

目前只是将redis安装在win环境下的，因为现在的对linux不是很熟悉！

2、Python操作redis

pip3 install redis

a、创建连接

1、普通连接

import redis


conn = redis.Redis(host='127.0.0.1', port=6379)
conn.set('animal', 'cat')
val = conn.get('animal')
print(val)

2、基于连接池

import redis

POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)    # 创建连接池
conn = redis.Redis(connection_pool=POOL)

conn.set("key", "cat")
val = conn.get("key")
print(val)

b、redis常用操作

在涉及到操作之前可以先来了解下redis支持的数据结构

1. String：字符串
2. Hash：散列（字典）
3. List：列表
4. Set：集合（去重）
5. Sorted Set：有序集合

# redis 就相当与内存中的一个字典。（session？？）
redis = {
    k1: 'hello',                                            # String
    k2: [1, 2, 3, 5, 4, 5, 2],                              # List
    k3: {1, 2, 3, 4},                                       # Set
    k4: {name: 'pontoon', age: 19},                         # Dict/Hash
    k5: {('pontoon': 65), ('god_v': 75), ('dandy': 85)}     # SortedSet
}

1、字典的操作

 

import redis

POOL = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)
conn = redis.Redis(connection_pool=POOL)

# conn.set("key", "cat")
# val = conn.get("key")
# print(val)

# 1、hset(name, key, value)    # 设置单个值
conn.hset("k1", "animal", "dog")

# 2、hget(name,key)            # 取单个值
val = conn.hget("k1", "animal")
print(val)    # b'dog'  

# 3、hmset(name, mapping)      # 设置多个值
conn.hmset("k2", {"animal1": "cat", "animal2": "dog"})

# 4、hmger(name, keys, *args)  # 取多个值
val = conn.hmget("k2", "animal1", "animal2")
print(val)    # [b'cat', b'dog']

# 5、hgetall(name)             # 获取name对应的所有值
val = conn.hgetall("k2")
print(val)    # {b'animal1': b'cat', b'animal2': b'dog'}

# 6、hlen(name)                # 获取个数
val = conn.hlen("k2")
print(val)    # 2

# 7、hkeys(name)               # 获取key

# 8、hvals(name)               # 获取value

# 9、hexists(name, key)        # 判断是否存在
val = conn.hexists("k2", "animal1")
print(val)    # True

# 10、hdel(name,*keys)         # 删除指定key中的键值对

# 11、hincrby(name, key, amount=1)  # 自增name对应的hash中的指定key的值，不存在则创建key=amount

# 12、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时，表示数据已经通过分片获取完毕
"""

# 13、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
"""

关于第13条的一个补充：

# 对于13的补充：
假设redis中有name=k4的一个字典，这个字典中有10个G的数据，我们该如何取值？
ret = conn.hscan_iter("k4", count=10000)  # 创建一个生成器对象，每次取1W条数据
for i in range(1000):    1000x10000 ≈ 10G
    for item in ret:
        print(item)

hscan_iter的源码

  def hscan_iter(self, name, match=None, count=None):
        """
        Make an iterator using the HSCAN command so that the client doesn't
        need to remember the cursor position.

        ``match`` allows for filtering the keys by pattern

        ``count`` allows for hint the minimum number of returns
        """
        # cursor表示游标 指明了count就相当于指明了cursor的数量
        cursor = '0'
        # 假如count=10000， 那么下一次迭代cursor='10000'
        while cursor != 0:
            cursor, data = self.hscan(name, cursor=cursor, match=match, count=count)
            for item in data.items():
                yield item

2、列表的操作

import redis


pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 设置最大连接数量为1000
conn = redis.Redis(connection_pool=pool)  # 连接连接池

# 1、lpush(name,values)     # 列表的左侧添加数据

# 2、rpush(name, values)    # 列表的右侧添加数据
conn.lpush("l1", "v1")
conn.lpush("l1", "v2")
conn.rpush("l1", "v3")

ret = conn.lrange("l1", 0, 100)  # 范围取值，取前100条数据
print(ret)  # [b'v2', b'v1', b'v3']

# 3、lpushx(name, value)    # 当name存在时，向列表左侧添加数据

# 4、rpushx(name, value)    # 当name存在时，向列表右侧添加数据  

# 5、lpop(name)             # 列表的左侧弹出数据

# 6、rpop(name)             # 列表的右侧弹出数据
val = conn.lpop("l1")
print(val)  # b'v1'

val = conn.rpop("l1")
print(val)  # b'v3'


# 7、llen(name)             # name对应的list元素的个数

# 8、linsert(name, before/after, refvalue, value))    # 在name对应的列表的某一个值前或后插入一个新值
conn.linsert("l1", "before", "v2", "v3")  # 在列表内找到第一个元素v2，在它前面插入v3

ret = conn.lrange("l1", 0, 100)
print(ret)

# 9、lset(name, index, value)  # 对list中的某一个索引位置重新赋值
conn.lset("l1", 0, "v4")  # 将索引为0的值重新赋值v4

ret = conn.lrange("l1", 0, 100)
print(ret)

# 10、lrem(name, num, value)  
''' 参数：
    name:  redis的name   
    num:   num=0 删除列表中所有的指定值；
           num=2 从前到后，删除2个；
           num=-2 从后向前，删除2个
    value: 要删除的值       
'''
# 这里要注意lrem在最新版本的redis中用法改了，将num与value调换位置了。（难怪我对着网上的博客写一致会报错~）

# 11、ltrim(name, start, end)  # 在name对应的列表中移除没有在start-end索引之间的值
conn.ltrim("l1", 0, 0)  # 移除第一个之后的所有值

ret = conn.lrange("l1", 0, 100)
print(ret)

# 12、rpoplpush(src, dst)  # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
"""
参数：
    src，要取数据的列表的name
    st，要添加数据的列表的name
"""
conn.lpush("l2", '11', '22', '33')
conn.lpush("l3", '44', '55', '66')
conn.rpoplpush("l2", "l3")

ret = conn.lrange("l3", 0, 100)
print(ret)

# redis都是玩的一些什么操作啊？花里胡哨~还有一部分反向操作的就不列出来了。要吐血了

 3、集合的操作 

 

# 1、sadd(name,values)      # ame对应的集合中添加元素

# 2、smembers(name)         # 获取name对应的集合的所有成员
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 设置最大连接数量为1000
conn = redis.Redis(connection_pool=pool)  # 连接连接池

conn.sadd("s1", "v1")
conn.sadd("s1", "v1", "v2", "v3", "v4", "v5")

print(conn.smembers("s1"))
>>>{b'v4', b'v5', b'v2', b'v1', b'v3'}    # 得到一个无序集合

3、scard(name)              # 获取name对应的集合中的元素个数

4、sdiff(keys, *args)       # 在第一个name对应的集合中且不在其他name对应的集合的元素集合(差集)
conn.sadd("s2", "aa", "bb")
conn.sadd("s3", "bb", "cc")
conn.sadd("s4", "bb", "cc", "dd")

print(conn.sdiff("s2", "s3", "s4"))  
>>>{b'aa'}

5、sinter(keys, *args)      # 获取多个name对应集合的交集
conn.sadd("s2", "aa", "bb")
conn.sadd("s3", "bb", "cc")
conn.sadd("s4", "bb", "cc", "dd")

print(conn.sinter("s2", "s3", "s4"))
>>>{b'bb'}

6、sinterstore(dest, keys, *args)  # 获取两个name对应集合的交集，并将结果存入第三个集合中
conn.sadd("s3", "bb", "cc")
conn.sadd("s4", "bb", "cc", "dd")

print(conn.sinterstore("s2", "s3", "s4")）  # s2为一个空的store存储s3,s4的交集，返回数字
print(conn.smembers("s2"))  # 返回集合中的值

7、sunion(keys, *args)      # 并集，获取多个name对应的集合的并集

8、smove(src, dst, value)
conn.smove("s2", "s3", 'aa')
print(conn.smembers("s3"))
>>>{b'cc', b'aa', b'bb'}

9、sismember(name, value)   # 判断是否是集合的成员 类似in

10、spop(name)              # 删除--随机删除并且返回被删除值

11、srem(name, values)      # 删除--指定值删除  

# 集合的操作相对最简单。      

3.1、有序集合的操作

# 注意我的redis版本为3.2.1，python在操作有序集合中的部分源码已经改了，网上的一些博客抄来抄去，自己也不动手实践下，错的地方都一样。

1、zadd(name, mapping, nx=False, xx=False, ch=False, incr=False)  # zadd的源码改了，网上大部分的博客都是旧的。所以输出的时候会报错
pool = redis.ConnectionPool(host='127.0.0.1', port=6379, max_connections=1000)  # 设置最大连接数量为1000
conn = redis.Redis(connection_pool=pool)  # 连接连接池

conn.zadd("z1", {"v11": 1, "v2": 2})
print(conn.zrange("z1", 0, -1))   # 获取有序集合中所有元素
>>>[b'v11', b'v2']  # 返回一个列表

2、zcard(name)                  # 获取name对应的有序集合元素的数量
print(conn.zcard("z1"))
>>>2

3、zcount(name, min, max)       # 获取name对应的有序集合中分数 在 [min,max] 之间的个数 

4、zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)  # 按照索引范围获取name对应的有序集合的元素
"""
参数:
    name，redis的name
    start，有序集合索引起始位置（非分数）    # 注意是索引
    end，有序集合索引结束位置（非分数）
    desc，排序规则，默认按照分数从小到大排序
    withscores，是否获取元素的分数，默认只获取元素的值
    score_cast_func，对分数进行数据转换的函数
"""

4.1、zrevrange(name, start, end, withscores=False, score_cast_func=float)  # 从大到小排序(同zrange，集合是从大到小排序的)
4.2、zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)  # 按照分数范围获取name对应的有序集合的元素
4.3、zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)  # 按照分数范围获取有序集合的元素并排序（默认从大到小排序）

5、zscan(name, cursor=0, match=None, count=None, score_cast_func=float)  # 获取所有元素--默认按照分数顺序排序
print(conn.zscan("z1"))
>>>(0, [(b'n1', 1.0), (b'v11', 1.0), (b'v2', 2.0)])

5.1、zscan_iter(name, match=None, count=None,score_cast_func=float)  # 获取所有元素--迭代器（这个非常有用）
print(conn.zscan_iter("z1"))
for i in conn.zscan_iter("z1"):
    print(i)

>>><generator object Redis.zscan_iter at 0x00000010F26047D8>
(b'n1', 1.0)
(b'v11', 1.0)
(b'v2', 2.0)

6、zrem(name, values)  # 删除--指定值删除

7、zremrangebyrank(name, min, max)  # 删除--根据排行范围删除，按照索引号来删除

8、zscore(name, value)  # 获取值对应的分数

4、一些相关的补充