redis和mongodb基础引入（兼补充集合的定义）

基础补全

1.集合（可变set与不可变frozenset）

s = {}                                          #为字典dict
s = set()                                       #为空集合
s = {1}                                         #为集合set，因为无key_value
s = {1, 32, 1, 2, 21, 2, 23, 14}                #{32, 1, 2, 14, 21, 23}剔除重复

常见命令

set（list/……）#使list、string等集合化
s.add(1)#添加一个元素
s.update({1, 2, 3})#导入多个元素
s.pop()#删除第一个元素
s.remove(2)#删除指定元素
s.clear()#删除所有元素
sorted(s) #从小到大排序

s1 = {1, 2, 4, 3}
s2 = {2, 56, 79, 1}
s1.union(s2) #并集
s1 | s2 #并集

s1.intersection(s2)#交集
s1 & s2 #交集

数据库

1.关系与非关系型数据库

各自优势：
关系型：1)使用二维表结构，易于维护
非关系型：1)数据间无关联，可分散存储
2)存储介质不止于硬盘，读取速度可能更快
3)高并发

非关系型数据库的分类：
1)键值型，redis、flare，适合处理大量数据的高并发访问
2)文档类型，MongoDB 、couchDB，满足海量存储，且对字段格式要求不高
3)列表存储，cassandra、hbase，查询速度快，可拓展性强
4)图数据库，infogrid、neo4j，适合搭建社交网络和推荐系统的关系图谱

mongodb 与redis

MongoDB适合存储大量关联性不强的数据

redis适合更广泛
1)缓存：字符串和哈希两种数据结构适合存储大量键值对信息，实现高速缓存
2)队列：“列表”结构实现普通和优先级队列
“有序集合”实现优先级队列
“哈希表”实现延时队列
3)去重：“集合”数据结构小批量去重
“字符串”的位操作，实现布隆过滤器，超大规模去重
“hyperloglog”数据结构，超大规模去重合计数
4)积分板：“有序集合”实现积分板功能，还可自动排序、排名
5)发布/订阅：实现多对多的“发布/订阅”

推演出数据库的重要性

数据库的演变：少量数据可记事本存放在硬盘，数据越来越多出现了数据库；而一些数据作为中间数据需要频繁被读写，放在内存中不便观察，放在硬盘中影响速度，内存数据库诞生。

针对队列
利用python中自带的队列（可以看做是生产者与消耗者的关系，最好的状态当然供需平衡）

import time
import random
from queue import Queue
from threading import Thread  #调用了多线程

class Producer(Thread):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue

    def run(self):
        while True:
            a = random.randint(0, 10)
            b = random.randint(90, 100)
            print(f'生产者生产了两个数字：{a}, {b}')
            self.queue.put((a, b))
            time.sleep(2)


class Consumer(Thread):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue

    def run(self):
        while True:
            num_tuple = self.queue.get(block=True) #block=True代表 若队列为空则停在这里等待队列上有东西
            sum_a_b = sum(num_tuple)
            print(f'消费者消费了一组数, {num_tuple[0]} + {num_tuple[1]} = {sum_a_b}')
            time.sleep(random.randint(0, 10))

queue = Queue()
producer = Producer(queue)
consumer = Consumer(queue)

producer.start()
consumer.start()
while True:
    time.sleep(1)
"""
由于消费者的sleep随机，所以大概率出现了生产与消耗不均等的状况
生产者生产了两个数字：8, 91
生产者生产了两个数字：7, 92
生产者生产了两个数字：3, 97
生产者生产了两个数字：5, 93
消费者消费了一组数, 3 + 99 = 102 ，此时消费者还在消耗很久之前的数据，大量数据堆积在队列中
"""

"""
问题：
无法看到队列的长度
无法看到队列中的数
存放在内存中，断电即丢失
"""

针对以上问题，使用redis改进

#模块1，生产者
import time
import random
import redis
import json
from threading import Thread

class Producer(Thread):
    def __init__(self):
        super().__init__()
        self.queue = redis.Redis()

    def run(self):
        while True:
            a = random.randint(0, 10)
            b = random.randint(90, 100)
            print(f'生产者生产了两个数字：{a}, {b}')
            self.queue.rpush('producer', json.dumps((a, b)))#在键为producer的列表尾添加
            time.sleep(2)
producer = Producer()
producer.start()
while True:
    time.sleep(1)

#模块2，消费者
import time
import random
import redis
import json
from threading import Thread

class Consumer(Thread):
    def __init__(self):
        super().__init__()
        self.queue = redis.Redis()

    def run(self):
        while True:
            num_tuple = self.queue.blpop('producer')#返回并删除键producer的首个元素，为空则等待
            a, b = json.loads(num_tuple[1].decode())
            print(f'消费者消费了一组数, {a} + {b} = {a + b}')
            time.sleep(random.randint(0, 10))
consumer = Consumer()
consumer.start()
while True:
    time.sleep(1)

"""
利用redis做存储，生产者和消费者各自为模块
redis模块会做持久性处理，断电也没事
可查询数据量也可删减数据
"""