首页 > 数据库 >redis类型操作与管道

redis类型操作与管道

时间：2022-11-15 22:44:30浏览次数：34  
标签：name redis Redis 管道 res 类型 close conn

redis字符串操作

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

'''
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
'''
conn = redis.Redis()
conn.set('name', 'barry')  # value只能是字符串或byte格式
conn.set('name', 'barry1', ex=3)  # ex是限时销毁，3秒后数据就没了
conn.set('name', 'barry2', px=3)  # ex是限时销毁，3秒后数据就没了
conn.set('name', 'barry3', nx=True)  # 实现分布式锁
conn.set('name', 'barry4', xx=True)
conn.close()
  • setnx(name, value)

本质就是set nx=True

conn = redis.Redis()
conn.setnx('hobby', '乒乓球')
conn.close()

  • psetex(name, time_ms, value)

    本质就是set px 设置时间

conn = redis.Redis()
conn.psetex('name', 3000, 'barry')
conn.close()

  • mset(*args, **kwargs)

    以字典格式批量设置

conn = redis.Redis()
conn.mset({'name': 'barry', 'age': 18})
conn.close()

  • get(name)

    以bytes格式获取值

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
print(conn.get('name'))  # b'barry'
conn.close()

  • mget(keys, *args)

    以bytes格式批量获取获取值

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
res = conn.mget('name', 'age')
res1 = conn.mget(['name', 'age'])
print(res, res1)  # [b'barry', b'18'] [b'barry', b'18']
conn.close()

  • getset(name, value)

    先获取，在设置新的值

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
res = conn.getset('name', 'kevin')
print(res)  # b'barry'
conn.close()

  • getrange(key, start, end)

    以字节的格式按区间位置获取值

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
res = conn.getrange('name', 0, 1)  # 前闭后闭区间
print(res)  # b'ba'
conn.close()

  • setrange(name, offset, value)

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

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
conn.setrange('name', 1, 'xxx')  # 从第1个位置开始替换字符串
print(conn.get('name'))  # b'bxxxy'
conn.close()

  • setbit(name, offset, value)

    以二进制，将某个位置的编码修改

conn = redis.Redis()
conn.setbit('name', 1, 0)
conn.close()

  • getbit(name, offset)

    获取某个位置的比特位

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
res = conn.getbit('name', 1)  # 获取第1个位置的比特位
print(res)  # 1
conn.close()

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

    获取从某个位置开始到某个位置结束有多少个比特位

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
res = conn.bitcount('name', 0, 3)  # 3指的是3字符
print(res)  # 14
conn.close()

  • strlen(name)

    统计字节

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
print(conn.strlen('name'))  # 5
conn.close()

  • incr(self, name, amount=1)

    每执行一次就加1

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
print(conn.incr('age'))  # 19
conn.close()

  • incrbyfloat(self, name, amount=1.0)

    浮点型incr

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
print(conn.incrbyfloat('age'))  # 20.0
conn.close()

  • decr(self, name, amount=1)

    每执行一次就减1

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
print(conn.decr('age'))  # 19
conn.close()

  • append(key, value)

    在后面追加

conn = redis.Redis(encoding='utf8')  # 将bytes转换为真正的值
conn.append('name', 'nb')
print(conn.get('name'))  # b'barrynb'
conn.close()
  • 常用:get set strlen

redis hash操作

  • hset(name, key, value)
import redis

conn = redis.Redis()
conn.hset('info', 'name', 'barry')  # 在info中以字典格式设置值
conn.hset('info', mapping={'age': 18, 'hobby': '篮球'})  # 在info中以字典格式设置多条值
conn.close()

  • hmset(name, mapping)

    已经弃用的批量设置

conn = redis.Redis(decode_responses=True)
conn.hmset('aa', {'a': 'a', 'b': 'b'})  # 批量设置值
conn.close()

  • hget(name,key)

    以bytes格式获取值

conn = redis.Redis()
res = conn.hget('info', 'name')
print(res)  # b'barry'
conn.close()

  • hmget(name, keys, *args)

    以bytes格式批量获取获取值

conn = redis.Redis()
res = conn.hmget('info', ['name', 'age'])
print(res)  # [b'barry', b'18']
conn.close()

  • hgetall(name)、

    获取所有(谨慎使用，可能会造成阻塞，尽量不要在生产代码中执行它)

conn = redis.Redis()
res = conn.hgetall('info')
print(res)  # {b'name': b'barry', b'age': b'18'}
conn.close()

  • hlen(name)

    获取其中有多少kv对

conn = redis.Redis()
res = conn.hlen('info')
print(res)  # 2
conn.close()

  • hkeys(name)

    获取所有的k中

conn = redis.Redis()
res = conn.hkeys('info')
print(res)  # [b'name', b'age']
conn.close()

  • hvals(name)

    获取所有的v值

conn = redis.Redis()
res = conn.hvals('info')
print(res)  # [b'barry', b'18']
conn.close()

  • hexists(name, key)

    判断是否存在

conn = redis.Redis()
res = conn.hexists('info', 'name')
print(res)  # True
conn.close()

  • hdel(name,*keys)

    删除指定键值对

conn = redis.Redis()
conn.hdel('info', 'age')
conn.close()

  • hincrby(name, key, amount=1)

    每执行一次就加1

conn = redis.Redis()
conn.hincrby('info', 'age')
res = conn.hmget('info', ['age'])
print(res)  # [b'19']
conn.close()

  • hincrbyfloat(name, key, amount=1.0)

    浮点型hincrby

conn = redis.Redis()
conn.hincrbyfloat('info', 'age')
res = conn.hmget('info', ['age'])
print(res)  # [b'19']
conn.close()
  • hscan(name, cursor=0, match=None, count=None)
# 无序得设置值
conn = redis.Redis()
for i in range(100):
    conn.hset('test_hash', 'key_%s' % i, '鸡蛋%s号' % i)
    conn.close()

# 从第0条取10条值
res = conn.hscan('userinfo', cursor=0, count=10)
  • hscan_iter(name, match=None, count=None)
# 获取10条数据，做成生成器
conn = redis.Redis()
res = conn.hscan_iter('test_hash', count=10)
print(res)  # 生成器
for item in res:
    print(item)
conn.close()

redis列表操作

  • lpush(name,values)

    在列表左侧插入值

import redis

conn = redis.Redis(decode_responses=True)
conn.lpush('user', 'barry')
conn.close()

  • lpushx(name,value)

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

conn = redis.Redis(decode_responses=True)
conn.lpushx('user', 'kevin')
conn.close()

  • rpushx(name, value)

    在列表右侧插入值

conn = redis.Redis(decode_responses=True)
conn.rpushx('user', 'barry1')
conn.close()

  • llen(name)

    name对应的list元素的个数

conn = redis.Redis(decode_responses=True)
res = conn.llen('user')
print(res)  # 5
conn.close()

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

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

conn = redis.Redis(decode_responses=True)
# 在barry后面插入tom
conn.linsert('user', where='after', refvalue='barry', value='tom')
# 在barry前面插入tom
conn.linsert('user', where='before', refvalue='barry', value='tom')
conn.close()

  • lset(name, index, value)

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

conn = redis.Redis(decode_responses=True)
conn.lset('user', 0, 'xxx')
conn.close()

  • lrem(name, value, num)

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

conn = redis.Redis(decode_responses=True)
conn.lrem('user', 1, 'tom')  # 删除从左往右的第一个tom
conn.close()

  • lpop(name)

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

conn = redis.Redis(decode_responses=True)
res = conn.lpop('user')
print(res)  # barry
conn.close()

  • lindex(name, index)

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

conn = redis.Redis(decode_responses=True)
res = conn.lindex('user', 0)
print(res)  # kevin
conn.close()

  • lrange(name, start, end)

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

conn = redis.Redis(decode_responses=True)
conn.lpushx('user', 'kevin')
res = conn.lrange('user', 0, 1)
print(res)  # ['kevin', 'barry1']
conn.close()

  • ltrim(name, start, end)

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

conn = redis.Redis(decode_responses=True)
conn.ltrim('user', 0, 1)
conn.close()

  • rpoplpush(src, dst)

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

conn = redis.Redis(decode_responses=True)
conn.rpoplpush('user', 'userinfo')
conn.close()

  • blpop(keys, timeout)

    如果列表中没有值，会进入阻塞态，直到有值，在按照从左到右去pop对应列表的元素

conn = redis.Redis(decode_responses=True)
res = conn.blpop('user')
print(res)  # ('user', 'kevin')
conn.close()

  • brpoplpush(src, dst, timeout=0)

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

'''
src:取出并要移除元素的列表对应的name
dst:要插入元素的列表对应的name
timeout:当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
'''
conn = redis.Redis(decode_responses=True)
conn.rpoplpush('user', 'userinfo')
conn.close()

通用操作(5大类型都支持)

  • delete(*names)

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

conn = redis.Redis()
conn.delete('age', 'name')  # 删除age、name
conn.close()

  • exists(name)

    检测redis的name是否存在(0就是不存在，1就是存在)

conn = redis.Redis()
res = conn.exists('name')
print(res)  # 0
conn.close()

  • keys(pattern='*')

    根据模型获取redis的name

conn = redis.Redis()
res = conn.keys()  # 返回所有的k
conn.close()

  • expire(name ,time)

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

conn = redis.Redis()
conn.expire('name', 3)  # 3秒针过期
conn.close()

  • rename(src, dst)

    对redis的name重命名为

conn = redis.Redis()
conn.delete('name'， 'namexxx')  # 将name修改为namexxx
conn.close()

  • move(name, db))

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

conn = redis.Redis()
conn.move('age', 2)  # 将age移动到第2个库中
conn.close()

  • randomkey()

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

conn = redis.Redis()
res = conn.randomkey()
conn.close()

  • type(name)

    获取name对应值的类型

conn = redis.Redis()
res = conn.type('age')  # 获取age中值的数据类型
conn.close()

redis管道

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

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

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

2.实例
import redis

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

django中集成redis

1.方式1(直接使用)
1.1POOL.py
import redis

pool = redis.ConnectionPool(max_connections=10, host='127.0.0.1', port=6379)
1.2使用
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(f'被你看了{res}次')

2.方式2
2.1在配置文件配置
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",  # 设置密码
        }
    }
}
2.2使用
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(f'被你看了{res}次')

3.方式3(借助于django的缓存使用redis)
-如果配置文件中配置了CACHES，则django的缓存数据直接放在redis中
-可以直接使用cache.set设置值，可以设置过期时间
-使用cache.set获取值
-其优势在于可以直接缓存任意python对象，底层使用pickle实现的

from django.core.cache import cache
conn = cache.set('px', '10', 3)  # 缓存到redis中，3秒后销毁

celery

celery介绍

1.celery是一个分布式的异步任务框架
1.1可以完成异步任务:可以提高项目的并发量，之前开启线程做，现在使用celery做
1.2可以完成延迟任务
1.3可以完成定时任务

2.框架
2.1消息中间件(borker)
-提交的任务(函数)都放在这里，celery本身不提供消息中间件，需要借助第三方(redis、rabbitmq)
2.2任务执行单元(worker)
-真正执行任务的地方，一个个进程，执行函数
2.3结果存储(backend)
-函数return的结果存储在这里，celery本身不提供结果存储，借助于第三方(redis、数据库、rabbitmq)

img

标签：name,redis,Redis,管道,res,类型,close,conn
From： https://www.cnblogs.com/riuqi/p/16894307.html

相关文章

  • 【Redis】PHP操作Redis的命令大全
    1、连接到redis服务<?php//连接本地的Redis服务$redis=newRedis();$redis->connect('127.0.0.1',6379);echo"Connectiontoserversucessfully";//设置redis......
  • SpringBoot 08: SpringBoot综合使用Mybatis + Dubbo + Redis
    业务背景Student表CREATETABLE`student`(`id`int(11)NOTNULLAUTO_INCREMENT,`name`varchar(255)COLLATEutf8_binDEFAULTNULL,`phone`varchar(11)......
  • 【Jedis】Jedis的操作与使用、与RedisTemplate的区别
    一、参考资料​​Redis命令参考—Redis命令参考​​​​Java使用Jedis操作Redis的5种数据类型_pan_junbiao的博客​​spring整合jedis_旅知知的博客​​​Jedis、RedisT......
  • Redis6新功能
    1、ACL1、简介RedisACL是AccessControlList（访问控制列表）的缩写，该功能允许根据可以执行的命令和可以访问的键来限制某些连接。在Redis5版本之前，Redis安全规则只有......
  • 分布式缓存(redis)
    分布式缓存--基于Redis集群解决单机Redis存在的问题单机的Redis存在四大问题：0.学习目标1.Redis持久化Redis有两种持久化方案：RDB持久化AOF持久化1.1.RDB持久化......
  • 八大基本数据类型
    publicstaticvoidmain(String[]args){//八大基本数据类型//整数intnum1=10;//最常用bytenum2=20;shor......
  • SQL语句修改datetime类型字段
    有时候我们需要批量修改一些数据的时间，那就要用到下面的SQL语句UPDATE表名SET时间字段=DATE_ADD(时间字段,INTERVAL7DAY)WHERE修改条件数字7，为所要修改的天数......
  • 今日内容，redis数据类型操作和celery介绍
    redis的使用一.redis字符串操作redis五大数据类型：字符串，hash，列表，集合，有序集合操作字符串的方法importredisconn=redis.Redis()#1set(name,value,ex=No......
  • luffy之redis操作和celery介绍
    一、redis字符串的操作#redis的vlaue有五大数据类型:字符串，列表，hash，集合，有序集合#关于字符串的操作有17种importredisconn=redis=Redis()1set(name,valu......
  • redis底层都有哪些数据结构？带你了解redis是如何存储数据的
    文章目录​​写在前面​​​​键值对的存储——哈希​​​​哈希冲突​​​​redis解决哈希冲突过多的方式——rehash​​​​双向链表​​​​数组​​​​压缩链表​​​......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99