redis

一、Redis介绍和安装
二、redis普通链接和连接池二、redis普通链接和连接池
- 2.1普通链接
- 2.2连接池链接
三、操作之String操作
四、操作之Hash操作
五、操作之List操作
六 redis管道
七、django中使用redis
八、django缓存
- 补充

详细见：https://www.cnblogs.com/liuqingzheng/articles/9833534.html

一、Redis介绍和安装

Redis ：软件，存储数据的，速度非常快，redis是一个key-value存储系统（没有表的概念），cs架构的软件
-服务端客户端（python作为客户端，java，go，图形化界面，命令窗口的命令）
es：存数据的地方

1. 关系型数据库和非关系型数据库

 -关系型：mysql，PostgreSQL，oracle，sqlserver，db2
	-PG
    -去 IOE：国产化
    	-IBM---》浪潮信息，曙光，联想
        -Oracle---》数据----》达梦。。。。
        -EMC存储--》国产存储
-非关系型数据库（nosql）：redis（缓存），mongodb（json文档数据存储），es（大数据量存储）。。。。
	-nosql 指非关系型数据库： no only sql，对关系型数据库的补充

2.redis特点：

 -开源软件，存数据，cs架构
-key-value存储 ，5大数据类型  value的类型是5种：字符串，hash(字典),列表，集合，有序集合
-速度快：
	-1 纯内存存储（核心）
    -2 使用了IO多路复用的网络模型
    -3 数据操作是单线程，避免了线程间切换,而且没有锁，也不会数据错乱
-支持持久化
	-纯内存，可以存到硬盘上，防止数据丢失
-redis又被称之为 缓存数据库

3.安装redis

 # redis 是用c语言编写的，需要在不同平台编译成可执行文件，才能在这个平台上运行
	-redis 使用了io多路复用种的epoll模型，win不支持epoll
    -redis官方，不支持win版本
    -微软官方，就把redis改动，编译成可执行，能运行在win上，滞后 3.x版本
    -第三方：5.x版本
    
# redis 官方网：https://redis.io/download/
# redis中文网：http://redis.cn
# win:3.x:https://github.com/microsoftarchive/redis/releases
# win:5.x:https://github.com/tporadowski/redis/releases/
 
 
# 安装：一路下一步
	-安装完成后，在安装路径下有
    	-redis-cli.exe     # mysql
        -redis-server.exe   # mysqld
        -redis.windows-service.conf  # my.ini
     -并且会自动做成服务
    	-服务的命令：redis-server.exe  redis.windows-service.conf
        
        
        
        
# 启动redis服务端
	-1 命令行中  redis-server 就可以启动服务
    -2 命令行中，启动服务，并指定配置文件
    	redis-server 配置文件路径
    -3 使用服务启动
 
# 客户端链接
	-1 命令行客户端：
    	-redis-cli  # 默认连本地的6379端口
        -redis-cli -p 6379 -h 127.0.0.1
    -2 图形化客户端链接
    	-1 最新版的Navicate支持链接redis了（收费的）
        -2 Redis Desktop Manager（https://resp.app/）  收费的  用的多  qt写图形化界面
        	-qt是个平台，做GUI[图形化界面]开发
            -用c写，用python写  pyqt5
            
    -3 python的模块
    	-pip install redis

二、redis普通链接和连接池二、redis普通链接和连接池

2.1普通链接

 from redis import Redis
 
# conn = Redis()  # 建立redis的链接
conn = Redis(host="127.0.0.1",
             port=6379,
             db=0,decode_responses=True)  # 建立redis的链接   decode_responses=True,查询回来返回的结果是字符串类型，否则是byte格式
res = conn.get('name')  # 获取key名为name的value值
print(res)
conn.close()  # 关闭链接

2.2连接池链接

 # 一定要保证，池是单例的，以模块导入的形式做成了单例
 
# pool.py
import redis
POOL = redis.ConnectionPool(max_connections=1000,host='127.0.0.1',port=6379)
 
# 其它.py
 
import redis
from pool import POOL # 模块导入的方式， 天然单例
conn = redis.Redis(connection_pool=POOL)  # 以后拿到链接，是从POOL种取，如果没有可用的了，默认不阻塞,可以通过某个参数配置，设置阻塞等待
res = conn.get('name')  # 获取key名为name的value值
print(res)
conn.close()  # 关闭链接

三、操作之String操作

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

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

 在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
     xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值

2.setnx(name, value)

  
设置值，只有name不存在时，执行设置操作（添加）,如果存在，不会修改
setex(name, value, time)
 
# 设置值
# 参数：
    # time，过期时间（数字秒 或 timedelta对象）
psetex(name, time_ms, value)
 
# 设置值
# 参数：
    # time_ms，过期时间（数字毫秒 或 timedelta对象

3.mset(args,kwargs)

 批量设置值
如：
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'})

4.get(name)

 获取值
mget(keys, *args)
 
批量获取
如：
    mget('k1', 'k2')
    或
    r.mget(['k3', 'k4'])

5.getset(name, value)

 设置新值并获取原来的值
getrange(key, start, end)
 
复制代码
# 获取子序列（根据字节获取，非字符）
# 参数：
    # name，Redis 的 name
    # start，起始位置（字节）
    # end，结束位置（字节）
# 如： "刘清政" ，0-3表示 "刘"
复制代码

6.setrange(name, offset, value)

 # 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
    # offset，字符串的索引，字节（一个汉字三个字节）
    # value，要设置的值

7.setbit(name, offset, value)

 # 对name对应值的二进制表示的位进行操作
 
# 参数：
    # name，redis的name
    # offset，位的索引（将值变换成二进制后再进行索引）
    # value，值只能是 1 或 0
 
# 注：如果在Redis中有一个对应： n1 = "foo"，
        那么字符串foo的二进制表示为：01100110 01101111 01101111
    所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
        那么最终二进制则变成 01100111 01101111 01101111，即："goo"

getbit(name, offset)

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

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

 # 获取name对应的值的二进制表示中 1 的个数
# 参数：
    # key，Redis的name
    # start，位起始位置
    # end，位结束位置

bitop(operation, dest, *keys)

 # 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
 
# 参数：
    # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name
 
# 如：
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中

8.strlen(name)

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

9.incr(self, name, amount=1)

  
# 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（必须是整数）
 
# 注：同incrby

10.incrbyfloat(self, name, amount=1.0)

 # 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
 
# 参数：
    # name,Redis的name
    # amount,自增数（浮点型）
decr(self, name, amount=1)
 
# 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
 
# 参数：
    # name,Redis的name
    # amount,自减数（整数）

11.append(key, value)

  
 
# 在redis name对应的值后面追加内容
 
# 参数：
    key, redis的name
    value, 要追加的字符串

四、操作之Hash操作

Hash操作，redis中Hash在内存中的存储格式如下图：

hset(name, key, value)

 # name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
 
# 参数：
    # name，redis的name
    # key，name对应的hash中的key
    # value，name对应的hash中的value
 
# 注：
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

hmset(name, mapping)

 # 在name对应的hash中批量设置键值对
 
# 参数：
    # name，redis的name
    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

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

hmget(name, keys, *args)

  
# 在name对应的hash中获取多个key的值
 
# 参数：
    # name，reids对应的name
    # keys，要获取key集合，如：['k1', 'k2', 'k3']
    # *args，要获取的key，如：k1,k2,k3
 
# 如：
    # r.mget('xx', ['k1', 'k2'])
    # 或
    # print r.hmget('xx', 'k1', 'k2')

hgetall(name)

 # 获取name对应hash的所有键值
print(re.hgetall('xxx').get(b'name'))

hlen(name)

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

hkeys(name)

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

hvals(name)

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

hexists(name, key)

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

hdel(name,*keys)

 # 将name对应的hash中指定key的键值对删除
print(re.hdel('xxx','sex','name'))

hincrby(name, key, amount=1)

 # 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（整数）

hincrbyfloat(name, key, amount=1.0)

 # 自增name对应的hash中的指定key的值，不存在则创建key=amount
 
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（浮点数）
 
# 自增name对应的hash中的指定key的值，不存在则创建key=amount

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

  
# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
 
# 参数：
    # name，redis的name
    # cursor，游标（基于游标分批取获取数据）
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕

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

  
# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
 
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print item
 
 
## 2 redis其它操作
 
```python
'''
 
delete(*names)
exists(name)
keys(pattern='*')
expire(name ,time)
rename(src, dst)
move(name, db))
randomkey()
type(name)
 
'''
 
import redis
 
conn=redis.Redis()
# delete(*names)
# conn.delete('eggs','hobbys')
# exists(name)
# conn.set('name','lqz')
 
# print(conn.exists('name'))  #
 
# keys(pattern='*')
# res=conn.keys('*')
# res=conn.keys('nam?')
# print(res)
 
# expire(name ,time)
# conn.expire('hobby',5)
 
# rename(src, dst)
# conn.rename('name','name1')
 
# move(name, db))
# conn.move('name1',2)
 
# randomkey()
# res=conn.randomkey()
# print(res)
 
# type(name)
res=conn.type('name1')
print(res)
conn.close()

五、操作之List操作

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

lpush(name,values)

 # 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11
 
# 扩展：
    # rpush(name, values) 表示从右向左操作

lpushx(name,value)

 # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
 
# 更多：
    # rpushx(name, value) 表示从右向左操作

llen(name)

 # name对应的list元素的个数

linsert(name, where, refvalue, value))

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

r.lset(name, index, value)

 # 对name对应的list中的某一个索引位置重新赋值
 
# 参数：
    # name，redis的name
    # index，list的索引位置
    # value，要设置的值

r.lrem(name, value, num)

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

lpop(name)

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

lindex(name, index)

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

lrange(name, start, end)

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

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中取值，爬取数据，实现简单分布式

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管道

 # 事务四大特性
	-原子性：要么都成功，要么都失败
    -一致性：数据前后要一致
    -隔离性：多个事务之间相互不影响
    -持久性：事务一旦完成，数据永久改变
    
    
# redis 有没有事务？支持事务
	-redis要支持事务，要完成事务的几大特性，需要使用管道来支持
    -单实例redis是支持管道的
    -集群模式下，不支持管道，就不支持事务
 
# redis通过管道实现事务
import redis
conn = redis.Redis()
pipline = conn.pipeline(transaction=True)
pipline.decrby('a1', 10)  # 没有真正执行，把命令先放到管道中
raise Exception('出错了')
pipline.incrby('a2', 10)
 
pipline.execute()  # 把管道中的命令，一次性执行
conn.close()

七、django中使用redis

 # 两种方式
	-方式一：自定义的通用方案（跟框架无关）
    	-写一个py文件：redis_pool.py
        	import redis
            POOL=redis.ConnectionPool(max_connections=10)
        -在用的位置，导入直接使用
             conn = redis.Redis(connection_pool=POOL)
        	conn.incrby('a1')
    -django中有个模块，django-redis，方便我们快速集成redis
    	-1 下载：pip install django-redis
        -2 配置文件配置：
            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",
                    }
                }
            }
            
        -3 在使用的地方，导入直接使用
        from django_redis import get_redis_connection
        class MyResponseView(APIView):
            def get(self, request):
                conn = get_redis_connection()  # 从连接池中拿出一个链接
                conn.incrby('a1')
                conn.set('name','彭于晏')
                return APIResponse()

八、django缓存

 # django 是大而全的框架，内置了很多web开发需要的东西，缓存内置了
 
# 缓存：可以把django中的一个变量(数据)，存放到某个位置，下次还可以取出来
 
# 之前用过：默认放在：内存中，其实可以放在文件中，数据库，redis。。。。
from django.core.cache import cache
cache.set('key','value',5) # 存放值
res=cache.get('key') # 取值
 
 
# 通过配置，控制存放在哪，只要如下写，就会放在redis中
   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",
           }
       }
   }
 
# django缓存最强大之处在于，只要是python的变量，任意类型都可以，尽管使用set设置值
       l = [1, 'lqz', [1, 3, 4, 5, 6], '彭于晏']
       cache.set('ll1', l)
	
# 以后再django中往redis放数据，就用cache即可
 
# redis的5大数据类型，只支持一层
 
 
# 看一下这篇文章：https://www.cnblogs.com/liuqingzheng/articles/9803351.html
 
# 超过5k就要交税
	-公司正常报税，工资中扣
    -6月份开始工作，按1w工资报税， 退税

补充

 #序列化
	-json序列化---》得到字符串
    	json不能序列化对象(自定义的类的对象) 
        	-数据结构：数据的组织形式跟下面不一样
        能序列化： 数字，字符串，布尔，列表，字典  时间对象
    -pickle序列化
    	-python独有的，二进制形式
        -python可以序列化所有对象---》二进制形式
        -二进制---》返序列化回来---》对象：属性，有方法

上一篇注册功能，前端登录注册页面

下一篇双写一致性之定时更新、异步发送短信、异步秒杀逻辑前后端、课程页页面前端、课程相关表分析、课程表数据录入、课程主页接口

本文作者：岳宗柯

本文链接：https://www.cnblogs.com/yuezongke/p/17509698.html

posted @ 2023-06-29 20:02 岳宗柯阅读(9) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

Python学习之旅

别让世界左右你的情绪，别让情绪影响你的理性！

redis

一、Redis介绍和安装

1. 关系型数据库和非关系型数据库

2.redis特点：

3.安装redis

二、redis普通链接和连接池二、redis普通链接和连接池

2.1普通链接

2.2连接池链接

三、操作之String操作

四、操作之Hash操作

五、操作之List操作

六 redis管道

七、django中使用redis

八、django缓存

补充

公告

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	-关系型：mysql，PostgreSQL，oracle，sqlserver，db2
	-PG
	-去 IOE：国产化
	-IBM---》浪潮信息，曙光，联想
	-Oracle---》数据----》达梦。。。。
	-EMC存储--》国产存储
	-非关系型数据库（nosql）：redis（缓存），mongodb（json文档数据存储），es（大数据量存储）。。。。
	-nosql 指非关系型数据库： no only sql，对关系型数据库的补充

	-开源软件，存数据，cs架构
	-key-value存储，5大数据类型 value的类型是5种：字符串，hash(字典),列表，集合，有序集合
	-速度快：
	-1 纯内存存储（核心）
	-2 使用了IO多路复用的网络模型
	-3 数据操作是单线程，避免了线程间切换,而且没有锁，也不会数据错乱
	-支持持久化
	-纯内存，可以存到硬盘上，防止数据丢失
	-redis又被称之为缓存数据库

	# redis 是用c语言编写的，需要在不同平台编译成可执行文件，才能在这个平台上运行
	-redis 使用了io多路复用种的epoll模型，win不支持epoll
	-redis官方，不支持win版本
	-微软官方，就把redis改动，编译成可执行，能运行在win上，滞后 3.x版本
	-第三方：5.x版本

	# redis 官方网：https://redis.io/download/
	# redis中文网：http://redis.cn
	# win:3.x:https://github.com/microsoftarchive/redis/releases
	# win:5.x:https://github.com/tporadowski/redis/releases/


	# 安装：一路下一步
	-安装完成后，在安装路径下有
	-redis-cli.exe # mysql
	-redis-server.exe # mysqld
	-redis.windows-service.conf # my.ini
	-并且会自动做成服务
	-服务的命令：redis-server.exe redis.windows-service.conf




	# 启动redis服务端
	-1 命令行中 redis-server 就可以启动服务
	-2 命令行中，启动服务，并指定配置文件
	redis-server 配置文件路径
	-3 使用服务启动

	# 客户端链接
	-1 命令行客户端：
	-redis-cli # 默认连本地的6379端口
	-redis-cli -p 6379 -h 127.0.0.1
	-2 图形化客户端链接
	-1 最新版的Navicate支持链接redis了（收费的）
	-2 Redis Desktop Manager（https://resp.app/）收费的用的多 qt写图形化界面
	-qt是个平台，做GUI[图形化界面]开发
	-用c写，用python写 pyqt5

	-3 python的模块
	-pip install redis

	from redis import Redis

	# conn = Redis() # 建立redis的链接
	conn = Redis(host="127.0.0.1",
	port=6379,
	db=0,decode_responses=True) # 建立redis的链接 decode_responses=True,查询回来返回的结果是字符串类型，否则是byte格式
	res = conn.get('name') # 获取key名为name的value值
	print(res)
	conn.close() # 关闭链接

	# 一定要保证，池是单例的，以模块导入的形式做成了单例

	# pool.py
	import redis
	POOL = redis.ConnectionPool(max_connections=1000,host='127.0.0.1',port=6379)

	# 其它.py

	import redis
	from pool import POOL # 模块导入的方式，天然单例
	conn = redis.Redis(connection_pool=POOL) # 以后拿到链接，是从POOL种取，如果没有可用的了，默认不阻塞,可以通过某个参数配置，设置阻塞等待
	res = conn.get('name') # 获取key名为name的value值
	print(res)
	conn.close() # 关闭链接

	在Redis中设置值，默认，不存在则创建，存在则修改
	参数：
	ex，过期时间（秒）
	px，过期时间（毫秒）
	nx，如果设置为True，则只有name不存在时，当前set操作才执行,值存在，就修改不了，执行没效果
	xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值


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

	# 设置值
	# 参数：
	# time，过期时间（数字秒或 timedelta对象）
	psetex(name, time_ms, value)

	# 设置值
	# 参数：
	# time_ms，过期时间（数字毫秒或 timedelta对象

	批量设置值
	如：
	mset(k1='v1', k2='v2')
	或
	mget({'k1': 'v1', 'k2': 'v2'})

	获取值
	mget(keys, *args)

	批量获取
	如：
	mget('k1', 'k2')
	或
	r.mget(['k3', 'k4'])

	设置新值并获取原来的值
	getrange(key, start, end)

	复制代码
	# 获取子序列（根据字节获取，非字符）
	# 参数：
	# name，Redis 的 name
	# start，起始位置（字节）
	# end，结束位置（字节）
	# 如： "刘清政" ，0-3表示 "刘"
	复制代码

	# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
	# 参数：
	# offset，字符串的索引，字节（一个汉字三个字节）
	# value，要设置的值

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

	# 参数：
	# name，redis的name
	# offset，位的索引（将值变换成二进制后再进行索引）
	# value，值只能是 1 或 0

	# 注：如果在Redis中有一个对应： n1 = "foo"，
	那么字符串foo的二进制表示为：01100110 01101111 01101111
	所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，
	那么最终二进制则变成 01100111 01101111 01101111，即："goo"

	# 获取name对应的值的二进制表示中 1 的个数
	# 参数：
	# key，Redis的name
	# start，位起始位置
	# end，位结束位置

	# 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值

	# 参数：
	# operation,AND（并）、 OR（或）、 NOT（非）、 XOR（异或）
	# dest, 新的Redis的name
	# *keys,要查找的Redis的name

	# 如：
	bitop("AND", 'new_name', 'n1', 'n2', 'n3')
	# 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中


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

	# 参数：
	# name,Redis的name
	# amount,自增数（必须是整数）

	# 注：同incrby



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

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

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

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

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

	# 在name对应的hash中批量设置键值对

	# 参数：
	# name，redis的name
	# mapping，字典，如：{'k1':'v1', 'k2': 'v2'}

	# 如：
	# r.hmset('xx', {'k1':'v1', 'k2': 'v2'})


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

	# 参数：
	# name，reids对应的name
	# keys，要获取key集合，如：['k1', 'k2', 'k3']
	# *args，要获取的key，如：k1,k2,k3

	# 如：
	# r.mget('xx', ['k1', 'k2'])
	# 或
	# print r.hmget('xx', 'k1', 'k2')

	# 获取name对应hash的所有键值
	print(re.hgetall('xxx').get(b'name'))

Python学习之旅

别让世界左右你的情绪，别让情绪影响你的理性！

redis

一、Redis介绍和安装

1. 关系型数据库和非关系型数据库

2.redis特点：

3.安装redis

二、redis普通链接和连接池 二、redis普通链接和连接池

2.1普通链接

2.2连接池链接

三、操作之String操作

四、操作之Hash操作

五、操作之List操作

六 redis管道

七、django中使用redis

八、django缓存

补充

公告

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

二、redis普通链接和连接池二、redis普通链接和连接池

	# 将name对应的hash中指定key的键值对删除
	print(re.hdel('xxx','sex','name'))

	# 自增name对应的hash中的指定key的值，不存在则创建key=amount
	# 参数：
	# name，redis中的name
	# key， hash对应的key
	# amount，自增数（整数）


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

	# 参数：
	# name，redis的name
	# cursor，游标（基于游标分批取获取数据）
	# match，匹配指定key，默认None 表示所有的key
	# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数

	# 如：
	# 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
	# 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
	# ...
	# 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕


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

	# 参数：
	# match，匹配指定key，默认None 表示所有的key
	# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数

	# 如：
	# for item in r.hscan_iter('xx'):
	# print item


	## 2 redis其它操作

	```python
	'''

	delete(*names)
	exists(name)
	keys(pattern='*')
	expire(name ,time)
	rename(src, dst)
	move(name, db))
	randomkey()
	type(name)

	'''

	import redis

	conn=redis.Redis()
	# delete(*names)
	# conn.delete('eggs','hobbys')
	# exists(name)
	# conn.set('name','lqz')

	# print(conn.exists('name')) #

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

	# expire(name ,time)
	# conn.expire('hobby',5)

	# rename(src, dst)
	# conn.rename('name','name1')

	# move(name, db))
	# conn.move('name1',2)

	# randomkey()
	# res=conn.randomkey()
	# print(res)

	# type(name)
	res=conn.type('name1')
	print(res)
	conn.close()

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

	# 如：
	# r.lpush('oo', 11,22,33)
	# 保存顺序为: 33,22,11

	# 扩展：
	# rpush(name, values) 表示从右向左操作

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

	# 更多：
	# rpushx(name, value) 表示从右向左操作

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

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

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

	# 参数：
	# name，redis的name
	# index，list的索引位置
	# value，要设置的值

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

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

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

	# 更多：
	# rpop(name) 表示从右向左操作