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

标签：hash name res redis django print 列表 conn

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

redis之列表

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来存储。如图：

lpush(name,values)

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

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

lpushx(name,value)

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

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

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

llen(name)

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

linsert(name, where, refvalue, value))


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

lset(name, index, value)


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

lrem(name, value, num)

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

lpop(name)

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

lindex(name, index)

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

lrange(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)

ltrim(name, start, end)

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

rpoplpush(src, dst)

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

blpop(keys, timeout)

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

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

brpoplpush(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)

redis之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)

hset(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时则创建（相当于添加）

hmset(name, mapping) 弃用了

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

hget(name,key)

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

hmget(name, keys, *args)

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

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

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

hlen(name)

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

hkeys(name)

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

hvals(name)

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

hexists(name, key)

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

hdel(name,*keys)

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

hincrby(name, key, amount=1)

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

hincrbyfloat(name, key, amount=1.0)

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

hscan(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类型所有数据

hscan_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()

redis其他操作

集合，有序集合 --- 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()

redis 管道

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

django中集成redis

方式一：直接使用

##  方式一：自定义包方案（通用的，不针对与框架，所有框架都可以用）
	-第一步：写一个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})

方式二：使用第三方模块：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})

方式三：借助于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})

标签：hash,name,res,redis,django,print,列表,conn
From： https://www.cnblogs.com/zx0524/p/17195836.html

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

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

redis之列表

lpush(name,values)

lpushx(name,value)

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

llen(name)

linsert(name, where, refvalue, value))

lset(name, index, value)

lrem(name, value, num)

lpop(name)

lindex(name, index)

lrange(name, start, end)

ltrim(name, start, end)

rpoplpush(src, dst)

blpop(keys, timeout)

brpoplpush(src, dst, timeout=0)

redis之hash

hset(name, key, value)

hmset(name, mapping) 弃用了

hget(name,key)

hmget(name, keys, *args)

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

hlen(name)

hkeys(name)

hvals(name)

hexists(name, key)

hdel(name,*keys)

hincrby(name, key, amount=1)

hincrbyfloat(name, key, amount=1.0)

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

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

redis其他操作

redis 管道

django中集成redis

方式一：直接使用

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

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

相关文章

赞助商

阅读排行

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