Redis入门-基础键值对、list、set、hashlist基础操作

关于Redis

Redis是非关系型数据库（NoSQL）的一种，区别于关系型数据库。其内部数据间相互独立，性能表现优秀。即使是在大量数据下性能也很好，这都得益于其数据结构简单，数据间相互独立的特性。而这些特性都是关系型数据库所望尘莫及的。

主流的NoSQL产品

NoSQL数据库的四大分类

• 键值对(Key-Value)存储：Redis
  优：快速查询
  劣：存储的数据缺少结构化
• 列存储：HBase
  优：快速查询、扩展性强
  劣：功能相对局限
• 文档数据库：MongoDB
  优：数据结构要求不是很严格
  劣：查询性能不高、缺少统一的查询语法
• 图形数据库：InfoGrid
  优：利用图结构相关算法
  劣：需要对整个图做计算才能得出结果、不容易做分布式集群方案

NoSQL的特点

易扩展
灵活的数据模型
大数据量、高性能
高可用

Redis的概述

Redis是高性能键值对数据库，支持的键值数据类型有：
字符串类型
列表类型
有序集合类型
散列类型
集合类型

Redis的应用场景

缓存
任务队列
网站访问统计
数据过期处理
应用排行榜
分布式集群架构中的session分离

Redis使用方法

1. 字符串类型

"""
set --设置值，返回True 或者False
get --获取值  
mset --设置多个键值对，返回True 或者False
mget --获取多个键值对
append --添加字符串
del --删除，返回删除成功的数据数量
incr/decr -- 增加/减少 1
"""

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import redis
#python 操作str
class TestString(object):
    def __init__(self):
        self.r = redis.StrictRedis(host='localhost', port=6379, db=0)

    def test_set(self):
        rest = self.r.set('user2', 'Amy')
        print ( rest)   # 输出 True
        return rest

    def test_get(self):
        rest = self.r.get('user2')
        print (rest)  # 输出 Amy
        return rest

    def test_mset(self):
        """
        mset --设置多个键值对
        :return:
        """
        d = {
            'user1': 'XH',
            'user3': 'Bob',
            'user4': 'Bobx'
        }
        rest = self.r.mset(d)
        print (rest)  # 输出 True
        return rest

    def test_mget(self):
        """
        mget --获取多个键值对
        :return:
        """
        l = ['user1','user2','user3','user4','user6']
        rest = self.r.mget(l)
        print (rset)    # 输出[ b'XH', b'Amy', b'Bob', b'Bobx', None]
        return rest

    def test_del(self):
        """
        del 删除
        :return:
        """
        rest = self.r.delete('user1')
        print (rest)   #输出1 
        return rest


def main():
    str_obj = TestString()
    str_obj.test_set()
    str_obj.test_get()
    str_obj.test_mset()
    str_obj.test_mget()
    str_obj.test_del()



if __name__ == '__main__':
    main()

2. 列表

class TestList(object):
    """
    lpush/rpush --从左/右插入数据，返回插入成功的数据下标,列表的每个数据格式可以不一样，每push一次下标加1["1",""2,3,4",("safa"),{"name":"yangxiaoru"}]
    lrange(开始下标，结束下标) -- 获取指定长度的数据，获取完了之后列表中还有数据
    ltrim -- 截取一定长度的数据
    lpop/rpop -- 移除最左/右的元素并返回
    lpushx/rpushx -- key存在的时候才插入数据，不存在不做任何处理
    """

    def __init__(self):
        self.r = redis.StrictRedis(host='localhost', port=6379, db=0)

    def test_push(self):
        """
        lpush/rpush --从左/右插入数据
        lrange -- 获取指定长度的数据
        :return:
        """
        t = ('Amy', 'Jhon')
        reset = self.r.lpush('l_eat2', *t)
        print (reset) #输出2（2是起始下标）
        reset = self.r.lrange('l_eat2', 0, -1) #获取第一位到倒数第一位直接的数据（左右闭区间）
        print (reset) #输出 [b'Jhon', b'Amy']，左边插入，左边取出，所以倒序了

    def test_pop(self):
        """
        lpop/rpop -- 移除最左/右的元素并返回
        :return:
        """
        rest = self.r.lpop('l_eat2') #从左边弹出一个数据
        print (rest) #输出 b'Jhon'

        reset = self.r.lrange('l_eat2', 0, -1)
        print (reset) # 输出 [b'Amy']

def main():
    # list
    list_obj = TestList()
    list_obj.test_push()
    list_obj.test_pop()

if __name__ == '__main__':
    main()

注意事项
举个栗子:当前有名字叫my_list的Redis列表如下：[0,1,2,3,4,5]
1、lrange（start，end），下标可以正向取，也可以负向取。但是参数中必须是start<=end。
lrange（2，2） #返回2
lrange（-4，-4） #返回2
lrange（1，2） #返回1,2
lrange（2，-2） #返回2,3,4
lrange（-3，-2） #返回3,4
以下方式都是取不到数据的：
lrange（2，1） #返回空
lrange（-2，-3） #返回空

2、Redis的列表下标溢出之后不会报错，她只取尽量多的数据即可
redis.lrange(6,7) #需要取下标为6和7的数据 ，结果返回空。
redis.lrange(5,7) #需要取下标为5,6,7的数据 ，结果返回[5]

3. 集合

class TestSet(Base):
    """
    sadd/srem --添加/删除元素
    sismember --判断是否为set的一个元素
    smembers --返回该集合的所有成员
    sdiff --返回一个集合与其他集合的差异
    sinter --返回几个集合的交集
    sunion --返回几个集合的并集
    """
    def __init__(self):
        self.r = redis.StrictRedis(host='172.17.20.144', port=6379, db=0)

    def test_sadd(self):
        """
        sadd/srem --添加/删除元素
        :return:
        """
        l = ['Cats', 'Dogs']
        rest = self.r.sadd('zoo3', *l) 
        print (rest) #输出2
        rest = self.r.smembers('zoo3') 
        print (rest) #输出 {b'Dogs', b'Cats'}

    def test_srem(self):
        """
        sadd/srem --添加/删除元素
        :return:
        """
        rest = self.r.srem('zoo2','Dogs') #没有名字为“zoo2”的集合
        print (rest) #输出0
        rest = self.r.smembers('zoo2')
        print (rest) #输出 set()，即空集合

    def test_sinter(self):
        """
        sinter --返回几个集合对象的交集
        sunion --返回几个集合对象的并集
        :return:
        """
        rest = self.r.sunion('zoo2', 'zoo3')
        print (rest) #输出 {b'Dogs', b'Cats'}
        rest = self.r.sinter('zoo2','zoo3')
        print (rest) #输出set()，即空集合


def main():
    test_obj = TestSet()
    test_obj.test_sadd()
    test_obj.test_srem()
    test_obj.test_sinter()

if __name__ == '__main__':
    main()

4. 散列

class TestHash(Base):
    """
    hset/hget --设置/获取散列值
    hmset/hmget --设置/获取多对散列值
    hsetnx --如果散列已经存在，则不设置
    hkeys/hvals --返回所有Keys/Values
    hlen -- 返回散列包含域
    """

    def test_set(self):
        """
        hset/hget --设置/获取散列值
        :return:
        """
        reset = self.r.hset('stu:xxx01','name','Amy')
        print (reset) #输出1，再次执行的话输出0
        reset = self.r.hexists('stu:xxx01','name')
        print (reset) #输出True
        reset = self.r.hget('stu:xxx01','name')
        print (reset)#输出 b'Amy'

    def test_mset(self):
        """
        hmset/hmget --设置/获取多对散列值
        :return:
        """
        m = {
            'name':'Bob',
            'age':21,
            'grade':98
        }
        rest = self.r.hmset('stu:xxx03',m)
        print (rest) #输出true
        rest = self.r.hkeys('stu:xxx03')
        print (rest) #输出 [b'name', b'age', b'grade']
        

def main():
    hash_obj = TestHash()
    hash_obj.test_set()
    hash_obj.test_mset()

if __name__ == '__main__':
    main()