python-Web-数据库-Redis

概述：

>>>安装：

>>>数据类型：

　　string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)

>>>数据备份：redis 127.0.0.1:6379> SAVE

>>>设置密码：127.0.0.1:6379> CONFIG set requirepass "123456"

>>>性能测试：redis-benchmark -n 100000

>>>最大链接数：redis-server --maxclients 100000

>>>Redis是基于客户端-服务端模型  请求/响应的TCP服务

　　所以客户端通常是阻塞模式，等待服务端响应

　　Redis管道技术可以让客户端继续向服务端发送请求，最终一次性返回所有响应

>>>Redis分区，利用多台计算机内存，构建大型数据库

　　范围分区：ID从0到10000的用户会保存到实例R0，ID从10001到 20000的用户会保存到R1，以此类推

　　哈希分区：crc32 hash函数-->key转换为一个数字-->93024922 % 4 = 2,存R2

面试题：

1 远程-非关系型数据库-内存-缓存

2 它可以用作数据库、缓存和消息中间件

3 速度快,丰富数据类型

4 redis常见性能问题和解决方案

　　Redis 是单进程单线程 利用队列技术将并发访问变为串行访问

命令：

String:

key - value(string/int/float)

-----set string1 ‘haha’

-----get string1

list:

key - [12,13,14,15]    左->右

-----lpush list1 12

-----lpop list1

-----llen  list1

set:

key - [1,2,3,4]   无序

-----sadd set1 12

-----scard set1  查看

-----sismember set1 12  是否存在

------srem  set1  删

hash:

key - key1 value(string/int/float)

key2 value(string/int/float)

　　　key3 vlaue(string/int/float)

-----hset hash1 key1 12

-----hget hash1 key1

-----hlen hash1

sort set:

key - score(10.1)  value(string/int/float)  rank:1

　　  score(9.9)  value(string/int/float)  rank:0

score(10.2)  value(string/int/float)  rank:2

----zadd  zset1  12.2  val1

----zcart  zset1  查

-----zrange  zset1  0  2  withscores    排序

python-django应用：

'''缓冲redis'''
import redis
import pickle

class PersonMetaclass(type):
    '''单例模式'''
    __instance = None
    def __call__(self, *args, **kwargs):
        if not self.__instance:
            self.__instance = super().__call__(*args, **kwargs)
        return self.__instance

class Redis(object,metaclass=PersonMetaclass):
    '''共享缓存'''
    def __init__(self,host='127.0.0.1', port=6379, password=''):
        '''初始'''
        # 链接redis
        self._redis=redis.Redis(host=host, port=port, password=password)
        self.redis = self._redis

    def setString(self,*args):
        '''' aaa',1 '''
        key,value = args
        self._redis.set(key,pickle.dumps(value))

    def setList(self,*args):
        '''' names_list', *['fi', 'li'] '''
        key, *v = args
        self._redis.lpush(key,pickle.dumps(*v))
        map(lambda value: self._redis.lpush(key,pickle.dumps(value)),list(v))

    def setSet(self):
        ''' key, *['fi', 1] '''
        pass

    def setHash(self,name,**kwargs):
        ''' hash1,{k1:1,k2:2,} '''
        keys,values = kwargs.items()
        map(lambda key,value:self._redis.hset(name, key, pickle.dumps(value)),list(keys),list(values))

    def setSortSet(self,name,nx=False, xx=False, ch=False, incr=False,**kwargs):
        '''
        key,[score:value:rank,]
        设置任意数量的元素名称，将对的值设置为键
        ' ' name ' ' '双指定为元素名称键的dict以获得值。
        ' ' nx ' ' '强制ZADD只创建新元素，不更新
        已经存在的元素的得分。
        ' ' xx ' ' '强制ZADD只更新已经更新的元素的分数
        存在。不会添加新元素。
        ' ' ch ' '将返回值修改为已更改的元素数量。
        更改的元素包括添加的新元素和元素
        分数的改变。
        '''
        sorts, values = kwargs.items()
        map(lambda sort, value: self._redis.zadd(name, pickle.dumps(sort), nx=nx, xx=xx, ch=False, incr=incr), list(sorts), list(values))

    def length(self,*args):
        ''' 长度 list '''
        try:
            name,*name1 = args
            if args.__len__() == 1:
                return len(self.get(name))
            return [ self._redis.llen(lens) for lens in args ]
        except:
            return None

    def int_or_str(value):
        ''''''

    def set(self,*args,TYPE=None, **kwargs):
        '''
        存入,String,list
        String:key->value(int,str,float)
        list:  key->list--[]
        '''
        try:
            a,*b = args
            if TYPE is not None:
                if TYPE == 'hash':
                    self.setHash(a,**kwargs)
                elif TYPE == 'sort':
                    self.setSortSet(a,**kwargs)
            elif len(b) == 1:
                self.setString(*args)
            elif len(b) > 1 :
                self.setList(*args)
            assert 'key error'
        except ValueError:
            return ValueError

    def get(self,name):
        ''' 取出 '''
        try:
            return pickle.loads(self._redis.get(name))
        except:
            return None

    def getList(self,name):
        try:
            return pickle.loads(self._redis.rpop(name))
        except:
            return None

    def getHash(self,*args):
        try:
            name,key,*value = args
            return pickle.loads(self._redis.hmget(name,key,*value))
        except:
            return None