redis之列表，redis之hash，redis其他操作，redis 管道，django中使用redis

1|0redis之列表，redis之hash，redis其他操作，redis 管道，django中使用redis

1|1redis之列表

1 lpush(name, values)
2 rpush(name, values) 表示从右向左操作
3 lpushx(name, value)
4 rpushx(name, value) 表示从右向左操作
5 llen(name)
6 linsert(name, where, refvalue, value))
7 r.lset(name, index, value)
8 r.lrem(name, value, num)
9 lpop(name)
10 rpop(name) 表示从右向左操作
11 lindex(name, index)
12 lrange(name, start, end)
13 ltrim(name, start, end)
14 rpoplpush(src, dst)
15 blpop(keys, timeout)
16 r.brpop(keys, timeout)，从右向左获取数据
17 brpoplpush(src, dst, timeout=0)

List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：

1|0lpush(name,values)

# 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
import redis

conn = redis.Redis(decode_responses=True)
conn.lpush('girls','杨颖','白鹿','鞠婧祎')

1|0lpushx(name,value)

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
conn = redis.Redis(decode_responses=True)
conn.lpushx('girls','谭松韵','IU')

1|0rpushx(name, value) 表示从右向左操作

conn.rpushx('girls','古力娜扎')

1|0llen(name)

# name对应的list元素的个数
print(conn.llen('girls'))

1|0linsert(name, where, refvalue, value))

在name对应的列表的某一个值前或后插入一个新值
 
# 参数：
    # name，redis的name
    # where，BEFORE或AFTER(小写也可以)
    # refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
    # value，要插入的数据
    
conn.linsert('girls','after','鞠婧祎','王源')

1|0lset(name, index, value)

 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置
    # value，要设置的值
    
conn.lset('girls','1','xxxx')

1|0lrem(name, value, num)

 在name对应的list中删除指定的值
 
# 参数：
    # name，redis的name
    # value，要删除的值
    # num，  num=0，删除列表中所有的指定值；
           # num=2,从前到后，删除2个；
           # num=-2,从后向前，删除2个
            
conn.lrem('girls','1','xxxx')

1|0lpop(name)

 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
 
# 更多：
    # rpop(name) 表示从右向左操作
    
res = conn.lpop('girls')
print(res)

1|0lindex(name, index)

在name对应的列表中根据索引获取列表元素
# res = str(conn.lindex('girls', 1), encoding='utf-8')
# print(res)

1|0lrange(name, start, end)

 在name对应的列表分片获取数据
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置  print(re.lrange('aa',0,re.llen('aa')))
 res=conn.lrange('girls',0,0)   # 前闭后闭区间
 print(res) 

1|0ltrim(name, start, end)

在name对应的列表中移除没有在start-end索引之间的值
# 参数：
    # name，redis的name
    # start，索引的起始位置
    # end，索引结束位置（大于列表长度，则代表不移除任何）

1|0rpoplpush(src, dst)

# 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
# 参数：
    src，要取数据的列表的name
    dst，要添加数据的列表的name

1|0blpop(keys, timeout)

# 将多个列表排列，按照从左到右去pop对应列表的元素
 
# 参数：
    keys，redis的name的集合
    timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
 
# 更多：
    r.brpop(keys, timeout)，从右向左获取数据爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式

res=conn.blpop('boys')
print(res)

1|0brpoplpush(src, dst, timeout=0)

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
 
# 参数：
    src，取出并要移除元素的列表对应的name
    dst，要插入元素的列表对应的name
    timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
# conn.flushall()
def scan_list(name,count=2):
    index=0
    while True:
        data_list=conn.lrange(name,index,count+index-1)
        if not data_list:
            return
        index+=count
        for item in data_list:
            yield item
print(conn.lrange('test',0,100))
for item in scan_list('test',5):
    print('---')
    print(item)

1|2redis之hash

1 hset(name, key, value)
2 hmset(name, mapping)
3 hget(name,key)
4 hmget(name, keys, *args)
5 hgetall(name)
6 hlen(name)
7 hkeys(name)
8 hvals(name)
9 hexists(name, key)
10 hdel(name,*keys)
11 hincrby(name, key, amount=1)
12 hincrbyfloat(name, key, amount=1.0)
13 hscan(name, cursor=0, match=None, count=None)
14 hscan_iter(name, match=None, count=None)

1|0hset(name, key, value)

conn.hset('userinfo', 'name', '王源')
conn.hset('userinfo', 'age', '19')
conn.hset('xx', mapping={'name': 'xxx', 'hobby': '篮球'})

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）

# 参数：
    name，redis的name
    key，name对应的hash中的key
    value，name对应的hash中的value

# 注：
    hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

1|0hmset(name, mapping) 弃用了

conn.hmset('yy', {'a': 'a', 'b': 'b'})

1|0hget(name,key)

res = conn.hget('userinfo', 'age')
print(res)

1|0hmget(name, keys, *args)

res=conn.hmget('userinfo',['name','age'])
print(res)

1|0hgetall(name) 慎用，可能会造成 阻塞 尽量不要在生产代码中执行它

res=conn.hgetall('userinfo')
print(res)

1|0hlen(name)

res = conn.hlen('userinfo')
print(res)

1|0hkeys(name)

res = conn.hkeys('userinfo')
print(res)

1|0hvals(name)

res = conn.hvals('userinfo')
print(res)

1|0hexists(name, key)

res = conn.hexists('userinfo','name')
print(res)

1|0hdel(name,*keys)

conn.hdel('userinfo','age')

1|0hincrby(name, key, amount=1)

conn.hincrby('userinfo','age')

1|0hincrbyfloat(name, key, amount=1.0)

conn.hincrbyfloat('userinfo','age',5.44)

1|0hscan(name, cursor=0, match=None, count=None)

 hash类型没有顺序---》python字典 之前没有顺序，3.6后有序了    python字段的底层实现
 for i in range(1000):
     conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)

# count 是要取的条数，但是不准确，有点上下浮动
# 它一般步单独用
 res=conn.hscan('test_hash',cursor=0,count=19)
 print(res)
 print(res[0])
 print(res[1])
 print(len(res[1]))
 res=conn.hscan('test_hash',cursor=res[0],count=19)
 print(res)
 print(res[0])
 print(res[1])
 print(len(res[1]))

# 咱么用它比较多，它内部封装了hscan，做成了生成器，分批取hash类型所有数据

1|0hscan_iter(name, match=None, count=None) 获取所有hash的数据

res = conn.hscan_iter('test_hash',count=100)
print(res)  # 生成器
for item in res:
    print(item)

conn.close()

1|3redis其他操作

集合，有序集合 --- redis模块提供的方法API
通用操作：无论是5大类型的那种，都支持

import redis

conn = redis.Redis()
# 1 delete(*names)
# conn.delete('age', 'name')

# 2 exists(name)
# res=conn.exists('xx')
# print(res)  # 0

# 3 keys(pattern='*')
# res=conn.keys('*o*')
# res=conn.keys('?o*')
# print(res)

# 4 expire(name ,time)
# conn.expire('test_hash',3)

# 5  rename(src, dst) # 对redis的name重命名为
# conn.rename('xx','xxx')

# 6 move(name, db) # 将redis的某个值移动到指定的db下
# 默认操作都是0 库，总共默认有16个库
# conn.move('xxx',2)

# 7  randomkey()  随机获取一个redis的name（不删除）
# res=conn.randomkey()
# print(res)

# 8 type(name)  查看类型
# res = conn.type('aa')  # list  hash set
# print(res)

conn.close()

1|4redis 管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

import redis

conn = redis.Redis()
p=conn.pipeline(transaction=True)
p.multi()
p.decr('zhangsan_je',100)
p.incr('lisi_je',100)
p.execute()
conn.close()

 redis事务机制可以保证一致性和隔离性，无法保证持久性，但是对于redis而言，本身是内存数据库，所以持久化不是必须属性。原子性需要自己进行检查，尽可能保证


 redis 不像mysql一样，支持强事务，事务的四大特性不能全部满足，但是能满足一部分，通过redis的管道实现的

 redis本身不支持事务，但是可以通过管道，实现部分事务

 redis 通过管道，来保证命令要么都成功，要么都失败，完成事务的一致性，但是管道只能用在单实例，集群环境中，不支持pipline

1|5django中集成redis

1|0方式一：直接使用

##  方式一：自定义包方案（通用的，不针对与框架，所有框架都可以用）
	-第一步：写一个pool.py
    import redis
	POOL = redis.ConnectionPool(max_connections=100)
    -第二步：写视图函数
    # 在django中使用redis
    from utils.pool import POOL
    import redis

    def test_redis(request):
        conn = redis.Redis(connection_pool=POOL)
        conn.incr('count')
        res = conn.get('count')
        return JsonResponse({'count':'接口被访问的次数为： %s' % res},json_dumps_params={'ensure_ascii':False})

1|6方式二：使用第三方模块：django-redis

settings.py 中配置
        CACHES = {
            "default": {
                "BACKEND": "django_redis.cache.RedisCache",
                "LOCATION": "redis://127.0.0.1:6379",
                "OPTIONS": {
                    "CLIENT_CLASS": "django_redis.client.DefaultClient",
                    "CONNECTION_POOL_KWARGS": {"max_connections": 100}
                    # "PASSWORD": "123",
                }
            }
        }

from django.core.cache import cache
def test_redis(request):
    res = cache.get('count')
    cache.set('count',res+1)
    return JsonResponse({'count':'接口被访问的次数为： %s' % res},json_dumps_params={'ensure_ascii':False})

1|7方式三：借助于django的缓存使用redis

如果配置文件中配置了 CACHES  ，以后django的缓存，数据直接放在redis中
以后直接使用cache.set 设置值，可以传过期时间
使用cache.get 获取值
强大之处在于，可以直接缓存任意的python对象，底层使用pickle实现的

from django_redis import get_redis_connection
        def test_redis(request):
            conn=get_redis_connection()
            print(conn.get('count'))
            return JsonResponse({'count': '今天这个接口被访问的次数为：%s'}, json_dumps_params={'ensure_ascii': False})

__EOF__

本文作者：泡芙有点甜
本文链接：https://www.cnblogs.com/zx0524/p/17195836.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！