redis 的基本操作

redis 的基本操作

redis有五大基本类型，分别是：字符串，hash，列表，集合，有序集合

字符串(String)操作

redis中的String在在内存中按照一个name对应一个value来存储

img

字符串操作及其作用

  • set(name, value, ex=None, px=None, nx=False, xx=False)

    在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
     xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
import redis
conn = redis.Redis()
conn.set('name','lqz') # value 只能是字符串或byte格式
conn.set('name','lqz',ex=3) # ex 是过期时间，到3s过期，数据就没了
conn.set('name','lqz',px=3000) # px 是过期时间，到3s过期，数据就没了
conn.set('age',25,nx=True) # redis 实现分布式锁：https://zhuanlan.zhihu.com/p/489305763
conn.set('hobby', '足球', xx=False)

  • setnx(name, value)

    import redis
conn = redis.Redis()
conn.setnx('hobby1','橄榄球')

    设置值，只有name不存在时，执行设置操作（添加）,如果存在，不会修改

  • psetex(name, time_ms, value)

    import redis
conn = redis.Redis()
conn.psetex('name',3000,'lqz')

    ​ time_ms是过期时间（数字毫秒 或 timedelta对象),本质就是 set px设置时间

  • mset(*args, **kwargs)

    import redis
conn = redis.Redis()
conn.mset({'name':'xxx','age':19})

    ​ 传字典批量设置

  • get(name)

    import redis
conn = redis.Redis()
print(conn.get('name'))
print(str(conn.get('name')[:3],encoding='utf-8'))

    获取值，取到是bytes格式 ,指定：decode_responses=True，就完成字符的转换

  • mget(keys, *args)

    import redis
conn = redis.Redis()
res=conn.mget('name','age')
res=conn.mget(['name','age'])
print(res)

    ​ 批量获取

  • getset(name, value)

    import redis
conn = redis.Redis()
res=conn.getset('name','lqz')
print(res)

    ​ 先获取，再设置

  • getrange(key, start, end)

    import redis
conn = redis.Redis()
res=conn.getrange('name',0,1)
print(res)

    取的是字节，前闭后闭区间

  • setrange(name, offset, value)

    import redis
conn = redis.Redis()
conn.setrange('name', 1, 'xxx')

    从某个起始位置开始替换字符串

  • setbit(name, offset, value)

    import redis
conn = redis.Redis()
conn.setbit('name',1,0)   #lqz  00000000   00000000   00000000
res=conn.get('name')
print(res)
"""
参数：
    name，redis的name
    offset，位的索引（将值变换成二进制后再进行索引）
    value，值只能是 1 或 0

"""

    ​ 对name对应值的二进制表示的位进行操作

  • getbit(name, offset)

    import redis
conn = redis.Redis()
res=conn.getbit('name',1)
print(res)

    获取name对应的值的二进制表示中的某位的值 （0或1）

  • bitcount(key, start=None, end=None)

    import redis
conn = redis.Redis()
print(conn.bitcount('name',0,3))
"""
参数：
    key，Redis的name
    start，位起始位置
    end，位结束位置
"""

    获取name对应的值的二进制表示中 1 的个数

  • strlen(name)

    import redis
conn = redis.Redis()
print(conn.strlen('name'))
print(len('lqz政'))  # len 统计字符长度

    返回name对应值的字节长度（一个汉字3个字节）

  • incr(self, name, amount=1)

    import redis
conn = redis.Redis()
conn.incr('age',amount=3)
"""
参数：
    name,Redis的name
    amount,自增数（必须是整数
"""

    自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。

  • incrbyfloat(self, name, amount=1.0)

    import redis
conn = redis.Redis()
conn.incrbyfloat('age')
"""
参数：
    name,Redis的name
    amount,自增数（浮点型）
"""

    自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。

  • decr(self, name, amount=1)

    import redis
conn = redis.Redis()
conn.decr('age')
"""
参数：
    name,Redis的name
    amount,自减数（整数）
"""

    自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。

  • append(key, value)

    import redis
conn = redis.Redis()
conn.append('name','nb')
conn.close()

"""
参数：
    key, redis的name
    value, 要追加的字符串
"""

    在redis name对应的值后面追加内容

redis hash操作

  • hset(name, key, value)

    import redis
conn = redis.Redis(decode_responses=True)
conn.hset('userinfo', 'name', '彭于晏')
conn.hset('userinfo', 'age', '32')
conn.hset('xx',mapping={'name':'xxx','hobby':'篮球'})

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

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

  • hmset(name, mapping)

    import redis
conn = redis.Redis(decode_responses=True)
conn.hmset('yy',{'a':'a','b':'b'})

    ​ 作用是 在name对应的hash中批量设置键值对

    ​ 但此方法已经被弃用了，可使用hset（）方法

  • hget(name,key)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hget('userinfo','age')
print(res)

    ​ 在name对应的hash中获取根据key获取value

  • hmget(name, keys, *args)

import redis
conn = redis.Redis(decode_responses=True)
res=conn.hmget('userinfo',['name','age'])
print(res)

在name对应的hash中获取多个key的值

  • hgetall(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hgetall('userinfo')
print(res)

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

    获取name对应hash的所有键值

  • hlen(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hlen('userinfo')
print(res)

    获取name对应的hash中键值对的个数

  • hkeys(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hkeys('userinfo')
print(res)

    获取name对应的hash中所有的key的值

  • hvals(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hvals('userinfo')
print(res)

    获取name对应的hash中所有的value的值

  • hexists(name, key)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.hexists('userinfo','name')
print(res)

    检查name对应的hash是否存在当前传入的key

  • hdel(name,*keys)

    import redis
conn = redis.Redis(decode_responses=True)
conn.hdel('userinfo','age')

    将name对应的hash中指定key的键值对删除

  • hincrby(name, key, amount=1)

    import redis
conn = redis.Redis(decode_responses=True)
conn.hincrby('userinfo','age')

    自增name对应的hash中的指定key的值，不存在则创建key=amount

  • hincrbyfloat(name, key, amount=1.0)

    import redis
conn = redis.Redis(decode_responses=True)
conn.hincrbyfloat('userinfo','age',5.44)

    自增name对应的hash中的指定key的值，不存在则创建key=amount

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

    import redis
conn = redis.Redis(decode_responses=True)

for i in range(1000):
    conn.hset('test_hash','key_%s'%i,'鸡蛋%s号'%i)
res=conn.hscan('test_hash',cursor=[0],count=19)
print(res)
print(res[0])
print(res[1])
print(len(res[1]))

它内部封装了hscan，做成了生成器，分批取hash类型所有数据
"""
参数：
    name，redis的name
    cursor，游标（基于游标分批取获取数据）
    match，匹配指定key，默认None 表示所有的key
    count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
"""

    增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆

  • hscan_iter(name, match=None, count=None)

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

    利用yield封装hscan创建生成器，实现分批去redis中获取数据

redis列表操作

  • lpush(name,values)

    import redis
conn = redis.Redis(decode_responses=True)

conn.lpush('girls','刘亦菲')
conn.lpush('girls','迪丽热巴')
conn.lpush('girls','刘诗诗')
conn.rpush('girls','鞠婧祎')  # 从右侧插入

    ​ lpush()从左侧插入 [刘诗诗 迪丽热巴 刘亦菲]

    ​ rpush()从右侧插入 [鞠婧祎 刘诗诗 迪丽热巴 刘亦菲]

  • lpushx(name,value)

    import redis
conn = redis.Redis(decode_responses=True)
conn.lpushx('girls','小丽')
conn.lpushx('boys','小刚')

    在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边

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

  • llen(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.llen('girls')
print(res)

    name对应的list元素的个数

  • linsert(name, where, refvalue, value))

    import redis
conn = redis.Redis(decode_responses=True)
conn.linsert('girls', where='after', refvalue='刘诗诗', value='吴倩')
conn.linsert('girls', where='before', refvalue='刘诗诗', value='吴倩')

"""
参数：
   name，redis的name
   where，BEFORE或AFTER(小写也可以)
   refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
   value，要插入的数据
"""

    在name对应的列表的某一个值前或后插入一个新值

  • lset(name, index, value)

    import redis
conn = redis.Redis(decode_responses=True)
conn.lset('girls',0,'xx')
"""
参数：
    name，redis的name
    index，list的索引位置
    value，要设置的值
"""

    对name对应的list中的某一个索引位置重新赋值

  • lrem(name, value, num)

    import redis
conn = redis.Redis(decode_responses=True)
conn.lrem('girls',0,'吴倩')

"""
参数：
    name，redis的name
    value，要删除的值
    num，  num=0，删除列表中所有的指定值；
           num=2,从前到后，删除2个；
           num=-2,从后向前，删除2个
"""

    在name对应的list中删除指定的值

  • lpop(name)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.lpop('girls')
res=conn.rpop('girls')
print(res)

""" rpop(name) 表示从右向左操作"""

    在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素

  • lindex(name, index)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.lindex('girls',2)
print(res)

    在name对应的列表中根据索引获取列表元素

  • lrange(name, start, end) 前闭后闭

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.lrange('girls',0,2)
print(res)

    在name对应的列表分片获取数据

  • ltrim(name, start, end)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.ltrim('girls',1,2)

    在name对应的列表中移除没有在start-end索引之间的值

  • rpoplpush(src, dst)

    import redis
conn = redis.Redis(decode_responses=True)
conn.rpoplpush('girls','boys')

"""
参数：
    src，要取数据的列表的name
    dst，要添加数据的列表的name
"""

    从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边

  • blpop(keys, timeout)

    import redis
conn = redis.Redis(decode_responses=True)
res=conn.blpop('boys',timeout=3)
print(res)
阻塞式弹出，如果列表中没有值，会阻塞在这，直到有值，再弹出，它可以做消息队列，做分布式的系统
"""
参数：
   keys，redis的name的集合
   timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
"""

    将多个列表排列，按照从左到右去pop对应列表的元素

  • brpoplpush(src, dst, timeout=0)

    import redis
conn = redis.Redis(decode_responses=True)

    从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

  • 自定义增量迭代

    
# 由于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其他操作

  • delete(*names)

    import redis
conn = redis.Redis()
conn.delete('age', 'name')

    根据删除redis中的任意数据类型

  • exists(name)

    import redis
conn = redis.Redis()
res=conn.exists('xx')
print(res)  # 0

    检测redis的name是否存在

  • keys(pattern='*')

    import redis
conn = redis.Redis()
res=conn.keys('*o*')
res=conn.keys('?o*')
print(res)

    根据模型获取redis的name

  • expire(name ,time)

    import redis
conn = redis.Redis()
conn.expire('test_hash',3)

    为某个redis的某个name设置超时时间

  • rename(src, dst) # 对redis的name重命名为

    import redis
conn = redis.Redis()
conn.rename('xx','xxx')

    对redis的name重命名为

  • move(name, db) # 将redis的某个值移动到指定的db下

import redis
conn = redis.Redis()
# 默认操作都是0 库，总共默认有16个库
conn.move('xxx',2)

将redis的某个值移动到指定的db下

  • randomkey() 随机获取一个redis的name（不删除）

    import redis
conn = redis.Redis()
res=conn.randomkey()
print(res)

    随机获取一个redis的name（不删除）

  • type(name) 查看类型

    import redis
conn = redis.Redis()
res = conn.type('aa')  # list  hash set
print(res)

    获取name对应值的类型

redis管道

redis数据库，是否支持事务？

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

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

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

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

import redis

conn = redis.Redis()
pipline = conn.pipeline(transaction=True)
pipline.decr('a', 2)  # a减2
raise Exception('我崩了')
pipline.incr('b', 2)  # b加2
pipline.execute()
conn.close()

django中集成redis

django中集成redis有三种方式

方式一：直接使用

from user.POOL import pool
import redis
def index(request):
    conn = redis.Redis(connection_pool=pool)
    conn.incr('page_view')
    res = conn.get('page_view')
    return HttpResponse('被你看了%s次' % res)

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

1.下载第三方模块
2.配置文件配置
CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://127.0.0.1:6379/0",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
                "CONNECTION_POOL_KWARGS": {"max_connections": 100}
                # "PASSWORD": "123",
            }
        }
    }

3. 使用
from django_redis import get_redis_connection
    def index(request):
        conn = get_redis_connection(alias="default") # 每次从池中取一个链接
        conn.incr('page_view')
        res = conn.get('page_view')
        return HttpResponse('被你看了%s次' % res)

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

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

celery介绍

celery：翻译过来叫芹菜，它是一个 分布式的异步任务 框架

celery有什么用？

1.完成异步任务：可以提高项目的并发量，之前开启线程做，现在使用celery做

2.完成延迟任务

3.完成定时任务

架构

1.消息中间件：broker 提交的任务（函数）都放在这里，celery本身不提供消息中间件，需要借助于第三方：redis，rabbitmq

2.任务执行单元：worker，真正执行任务的地方，一个个进程，执行函数

3.结果存储：backend，函数return的结果存储在这里，celery本身不提供结果存储，借助于第三方：redis，数据库，rabbitmq

img
posted @ 2022-11-15 20:55  Nirvana*  阅读(28)  评论(0)    收藏  举报