Redis

最新推荐文章于 2023-07-17 14:51:54 发布
最新推荐文章于 2023-07-17 14:51:54 发布
阅读量214 收藏
点赞数
分类专栏： Redis 文章标签： redis python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1L__/article/details/112251074
版权

Redis初始

一、Redis是什么

Mysql是一个关系型数据，表与表之间是关联的，并且数据是存储在硬盘上的 ，redis是一个key-value存储方式，是一个内存数据化，取值存值都是放在内存中，操作非常快。它支持存储的value类型相对更多。

  1. string(字符串)
  2. list(链表)–相当于列表
  3. set(集合)–其他语言是没有集合的
  4. zset(sorted set --有序集合，并且不重复) 用途—排行榜
  5. hash（哈希类型）–就是咱的字典

和Memcached类似都支持集群，他们之间的不同

  1. Memcached 只支持一种数据类型，redis作为其替代者，支持更为丰富的数据类型
  2. Memcached 不支持持久化(不支持存到硬盘上，只要一断电，数据就没了)
  3. 速度比redis快一点，但是80%都是用redis

二、使用Redis的好处

  1. 速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
  2. 支持丰富数据类型，支持string，list，set，sorted set，hash
  3. 支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
  4. 丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除

三、redis为什么这么快(单线程为什么这么快)

6.0.6之后也做成了多线程多进程

1.数据在内存（最重要的）

2.io多路复用技术，epoll模型（只在linux上），window上支持select

3.因为没有进程，线程间的切换

四、Redis适合的场景

  • 排行榜
  • 网站访问量，文章访问量
  • 缓存数据库（用的最多，就是做缓存）
  • 发布订阅
  • 去重
  • 分布式（blpop）

场景其实非常多，但是使用起来也简单

五、Redis安装+使用

下载无脑下一步

链接：https://pan.baidu.com/s/1tuTXAiD1bkeVd6jQ4ZoMyg
提取码：8n8z

	-服务端和客户端
	-安装完，服务端自动启动：redis-server 配置文件.conf
	-redis-cli  ：客户端连接服务端(redis-cli -h 127.0.0.1 -p 6379)

注意，如果出现 不是内部或外部命令，也不是可运行的程序或批处理文件添加环境变量即可。

image-20201128230748237

get 查看刚刚存入的值

image-20201128230829659

也可以在软件 Redis Desktop Manage中查看

image-20201128231033640

点击即可查看我们存放的数值

image-20201128231108592

Day 02 Python操作Redis

一、普通连接

1.安装

pip install redis

2.简单使用

# 导入模块
from redis import Redis

# 实例化对象
connect = Redis(host='127.0.0.1', port=6379)

# 字符串操作+set用法
connect.set('height', 180)  # 数字类型会被自动转义为字符串
print(connect.get('height'))
-----------------------------------------------------------------------
b'180'

image-20201128230527555

二、Python操作Redis之连接池

# redis_pool.py
# redis 连接池链接
import redis
# # 造一个池子，最多能放100个链接，pool必须是单例的，最开始造出来，以后出来用
# # 最简单模式 用模块方式
# 造一个池子,最多能放100个连接
POOL = redis.ConnectionPool(host='127.0.0.1', port=6379,max_connections=100)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BqfyimzX-1609845926405)(C:\Users\S\AppData\Roaming\Typora\typora-user-images\image-20201128232543942.png)]

# redis.py

# 包内的py文件，如果想右键执行路径就会被加到环境变量里
from scripts.t_redis_pool import POOL
# 用的连接池 自动生成单例
connect = redis.Redis(connection_pool=POOL)

# 字符串操作+set用法
connect.set('height', 180)  # 数字类型会被自动转义为字符串
print(connect.get('height'))
-----------------------------------------------------------------------
b'180'

三、字符串操作

1.set用法

conn.set('height',180) #基本使用

conn.set('height','190',nx=True)
conn.set('height','190',xx=True)
conn.set('height1','190',xx=True)

image-20201128234200830

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

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

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

mset(mapping) ，mget(keys, *args)
# 批量设置值，批量取值
connect.mset({'name1': '11', 'name3': 'dasfd'})  # 设置
print(connect.mget('name1', 'name3'))  # 取值
-------------------------------------------------
[b'11', b'dasfd']

getset(name, value)
# 设置新值并获取 新 的值
print(connect.get('name1'))
connect.getset('name1', 'newname')
print(connect.get('name1'))
-------------------------------------------------
b'11'
b'newname'

getrange(key, start, end)
# 获取键 key 从start到end位置的字符，都是闭区间
print(connect.get('name1'))
result = connect.getrange('name1', 0,3)
print(result)
-------------------------------------------------
b'newname'
b'newn'

setrange(name, offset, value)
# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加
print(connect.get('name1'))
result = connect.setrange('name1', 3, 999)
print(connect.get('name1'))
-------------------------------------------------
b'newname'
b'new999e'

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

bitcount(key, start=None, end=None)  # 用作用户统计，用户存比特位 登录为1 未登录为 0
# 获取name对应的值的二进制表示中 1 的个数
# 参数：
    # key，Redis的name
    # start，位起始位置
    # end，位结束位置
print(connect.get('name1'))    
result = connect.bitcount('name1', 1, 8)
result2 = connect.bitcount('name1', 1, 7)
print(result,result2)
----------------------------------------------------------
b'newname'
27 27  # 由此可见 这里的起始终止位置是 一个个字母  



incr ：统计网站访问量，页面访问量，接口访问量
connect.getset('name1', '1')  # 设置时必须为 数字
print(connect.get('name1'))
connect.incr('name1')  # 每执行一次 数字加一
connect.incr('name1')
connect.incr('name1')
connect.incr('name1')
print(connect.get('name1'))
----------------------------------------------------------
b'5'
b'1'
b'5'

decr 减 来一个减一个 如果小于0其余的全部退回 一般写在中间件中
connect.getset('name1', '1')
print(connect.get('name1'))
connect.incr('name1')
connect.incr('name1')
connect.incr('name1')
connect.incr('name1')
connect.decr('name1', 2)  # 可以为复数 负负得正 实则为 +2
print(connect.get('name1'))
----------------------------------------------------------
b'1'
b'3'

connect.append  往字段后面增加

connect.append('name1', 'append')
print(connect.get('name1'))
----------------------------------------------------------
b'3append'

重点

set :很多参数  get  mset  mget  incr  decr  append

四、Hash操作

也就是设置键值对

1.hset+hget

connect.hset('tag', 'name1', '小明')
print(connect.hget('tag', 'name1'))

print(connect.hget('tag', 'name1').decode('utf-8'))  # 读取默认是二进制，可以解码
--------------------------------------------------------

b'\xe5\xb0\x8f\xe6\x98\x8e'
小明

2.hmset+hmget+hgetall

connect.hmset('tag', {'name2': "小王", 'name3': '小李'})
print(connect.hmget('tag', 'name1', 'name2'))

print(connect.hmget('tag', ['name1', 'name2', 'name3']))
--------------------------------------------------------

[b'\xe5\xb0\x8f\xe6\x98\x8e', b'\xe5\xb0\x8f\xe7\x8e\x8b']
[b'\xe5\xb0\x8f\xe6\x98\x8e', b'\xe5\xb0\x8f\xe7\x8e\x8b', b'\xe5\xb0\x8f\xe6\x9d\x8e']

print(connect.hgetall('tag'))
--------------------------------------------------------
{b'name1': b'\xe5\xb0\x8f\xe6\x98\x8e', b'name2': b'\xe5\xb0\x8f\xe7\x8e\x8b', b'name3': b'\xe5\xb0\x8f\xe6\x9d\x8e'}

注意：hgetall要少用，因为他是一次性全部加载，当数据量过大时，很可能直接把内存撑爆

image-20201129222420495

3.hlen(name)

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

print(connect.hlen('tag'))
--------------------------------------------------------
3

4.hkeys(name)

# 获取name对应的hash中所有的key的值
print(connect.hkeys('tag'))
--------------------------------------------------------
[b'name1', b'name2', b'name3']

5.hvals(name)

# 获取name对应的hash中所有的values的值
print(connect.hkeys('tag'))
--------------------------------------------------------
[b'\xe5\xb0\x8f\xe6\x98\x8e', b'\xe5\xb0\x8f\xe7\x8e\x8b', b'\xe5\xb0\x8f\xe6\x9d\x8e']

6.hexists(name, key)

# 检查name对应的hash是否存在当前传入的key
print(connect.hexists('tag', 'lala'))  # 判断是否有这个 键
--------------------------------------------------------
False

7.hdel(name,*keys)

# # 将name对应的hash中指定key的键值对删除
connect.hdel('tag', 'name1')
print(connect.hget('tag', 'name1'))
--------------------------------------------------------
None

8.hincrby(name, key, amount=1)

# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
    # name，redis中的name
    # key， hash对应的key
    # amount，自增数（整数）
print(connect.hincrby('tag', 'name1'))  # 每执行一次加1 同访问量
--------------------------------------------------------
3

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

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

# 以后想取出hash类型内所有的数据，不建议用hgetall，建议用hscan_iter
# 一次性先取一部分回来（假设有1w条，先取回100条，把这100条做成了生成器）
ret=conn.hscan_iter('hash1')
print(ret)
for i in ret:
    print(i)

10.hincrbyfloat(name, key, amount=1.0)

同上不过是浮点数

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

11.hincrbyfloat(name, key, amount=1.0)

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

12.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时，表示数据已经通过分片获取完毕

重点：

# hset
# hget
#hmset
#hmget
# hincrby
# 区分hgetall和hscan_iter

五、List操作

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

1.lpush(name,values)

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

2.lpushx(name,value)

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

3.llen(name))**

# name对应的list元素的个数

4.linsert(name, where, refvalue, value))

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

5.lset(name, index, value)

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

6.lrem(name, value, num)

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

7.lpop(name)

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

8.lindex(name, index)

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

9.lrange(name, start, end)

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

10.ltrim(name, start, end)

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

11.rpoplpush(src, dst)

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

12.blpop(keys, timeout)

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

13.brpoplpush(src, dst, timeout=0)

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

14.自定义增量迭代)**

# 由于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)

重点

lpush	lpop	blpop	lrange	llen

六、Set操作

Set操作，Set集合就是不允许重复的列表

使用

七、其他使用

delete(*names)

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

exists(name)

# 检测redis的name是否存在

# 根据模型获取redis的name
 
# 更多：
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

expire(name ,time)

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

rename(src, dst)

# 对redis的name重命名为

move(name, db))

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

randomkey()

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

type(name)

# 获取name对应值的类型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

# 同字符串操作，用于增量迭代获取key

八、管道

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

import redis
 
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()

九、Django中使用redis

# 方式一（通用方式）
模块导入 pip install redis
# 方式二：django-redis
	-pip install django-redis
    -setting中配置
    	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",
                    }
                }
            }
   	-使用两种方式
    	1 使用cache
        from django.core.cache import cache
        cache.set('name',user) 
        2 直接使用conn对象
        from django_redis import get_redis_connection
        conn = get_redis_connection('default')
        print(conn.hgetall('xxx'))

Django实现购物车

class ShoppingCarAPIView(APIView):
    message = {}
    
    # 初始化函数
    def __init__(self):
        self.connect = get_redis_connection('default')
    
    def get(self, request, *args, **kwargs):
        user_name = kwargs.get('name')
        key = f'cart_{user_name}'
        tmp = self.connect.hgetall(key)
        if not tmp:
            message = {
                'status': 101,
                "message": "购物车为空！"
            }
            return Response(data=message)
        # 字典生成器获取 商品id：数量
        data = {k.decode('utf-8'): v.decode('utf-8') for k, v in tmp.items()}
        print(data)
        # 筛选商品
        goods = models.Goods.objects.filter(id__in=data).all()
        data_list = []
        for good in goods:
            good_info = {'good_id': good.pk, 'good_title': good.title, 'store': good.store.name,
                         'price': good.sale_price}
            data_list.append(good_info)
        message = {
            'status': 200,
            "message": "",
            'data': data_list
        }
        return Response(data=message)
    
    def put(self, request, *args, **kwargs):
        data = request.data
        user_name = data.get('user_name')
        good_id = data.get('good_id')
        count = data.get('count', 0)
        key = 'cart_' + str(user_name)
        print(key, good_id, count)
        # 存入redis
        
        self.connect.hset(key, good_id, count)
        return Response({
            "msg": "添加成功！"
        })

    def delete(self, request, *args, **kwargs):
        data = request.data
        user_name = data.get('user_name')
        good_id = data.get('good_id')
        # 存入redis
        key = 'cart_' + str(user_name)
        tmp = self.connect.hdel(key, good_id)
        print(tmp)
        return Response({
            "msg": "删除成功！"
        })

ssage)

def put(self, request, *args, **kwargs):
    data = request.data
    user_name = data.get('user_name')
    good_id = data.get('good_id')
    count = data.get('count', 0)
    key = 'cart_' + str(user_name)
    print(key, good_id, count)
    # 存入redis
    
    self.connect.hset(key, good_id, count)
    return Response({
        "msg": "添加成功！"
    })

def delete(self, request, *args, **kwargs):
    data = request.data
    user_name = data.get('user_name')
    good_id = data.get('good_id')
    # 存入redis
    key = 'cart_' + str(user_name)
    tmp = self.connect.hdel(key, good_id)
    print(tmp)
    return Response({
        "msg": "删除成功！"
    })
A1L__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python3操作redis
renpingsheng66的博客
11-17 216
redis也被称为缓存 1.redis是一个key-value存储系统，没有ForeignKey和ManyToMany的字段. 2.在redis中创建的数据彼此之间是没有关系的,所以也被称为是非关系型数据库 3.它支持存储包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）等数据类型。 4.redis支持的数据...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
redis操作篇
weixin_30344795的博客
07-21 103
操作 String操作，redis中的String在在内存中按照一个name对应一个value来存储。如图： set(name, value, ex=None, px=None, nx=False, xx=False) 在Redis中设置值，默认，不存在则创建，存在则修改 参数： ex，过期时间（秒） px，过期时间（毫秒） ...
Redis简介及基本使用
我的博客
09-06 232
Redis简介、安装、启动停止及通用指令 1.Redis简介 1.Redis是一款基于内存进行数据存储，亦可支持持久化、日志型、KV数据库。（NoSQL） 2.优点： 性能高：由于基于内存来读写数据，所以性能远远高于基于硬盘进行文件读写操作的数据库（关系型数据库）。 支持比较丰富的数据类型： String List Set Hash ZSet 主从复制 高可用以及分布式 2.安装 window Linux wget http://download.redis.io/releases/redis-
Python3 操作 Redis
Richardlygo的博客
08-31 1207
一、简单介绍 redis是一个key-value存储系统，和Memcached类似。它支持存储的value类型相对更多，包括string(字符串)、list(链表、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。 这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各...
redis-windows-7.2.4.zip
01-14
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值对存储系统，它支持数据的持久化，可以作为数据库、缓存和消息中间件使用。Redis以其高速度和丰富的数据结构而闻名，广泛应用于互联网服务，如计数...
redis-windows-7.2.3.zip
11-09
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以其高效的数据处理能力，丰富的数据结构以及简单易用的API赢得了广大开发者青睐。...
redis 7.0.0 windows版
05-07
redis 7.0.0 windows版，直接解压即可使用。 Redis 7.0 包括了以下一些重要的变化： 1. 将AOF文件的存储方式改为在一个文件夹下存储多个文件。 2. 将持久化文件RDB的版本升级为10，与之前的RDB文件版本不再兼容。 3....
redis-windows-7.2.1.zip
09-13
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值对存储系统，常用于数据缓存、消息队列和数据库等场景。在Windows环境下安装和使用Redis，可以通过下载对应的二进制压缩包来实现，比如"redis-...
Python连接Redis的基本配置方法
12-24
在Linux系统下Python连接Redis的基本配置方法具体操作步骤 系统环境： OS：Oracle Linux Enterprise 5.6 Redis：redis-2.6.8 Python：Python-2.7.3 redis的python包版本：redis-2.7.2.tar 前提条件： 1.确保Redis已成功安装并且正确配置，参考文档 主从配置文档： //www.jb51.net/article/147397.htm 2.确保Python环境已成功配置，参考文档 https://www.jb51.net/article/109765.htm 配置python连接redis: 1.安
pygeosearch:带有 Redis 的 Python 地理空间搜索库
07-13
Py-GeoSearch 介绍 Py-GeoSearch 允许您使用 Redis 作为唯一的内存数据存储来执行地理空间搜索。 这个库与与地理位置相关的键一起工作，您可以使用它从地理空间中添加/更新/删除键，并有效地查询键。 与其他 Redis 数据或关系数据库配对，Py-GeoSearch 可以帮助您实现高级地理空间搜索算法。 系统要求 Redis Python 2.7.x python 开发头文件（sudo apt-get install python-dev） 安装 pip install pygeosearch 或者 python setup.py install 测试 运行单元测试： python setup.py test 例子 import pygeosearch client = pygeosearch.GeoSearch() lat0 = 42.6 lon
python3 操作 redis
热门推荐
AdleyTales的技术博客
09-12 1万+
安装redis包 pip3 install redis 使用 import redis conn = redis.Redis(host='192.168.1.51', port=6379) ## set # conn.set('test', 'redis test') ## get print(conn.get('test'))
缓存系统之Redis
weixin_39543992的博客
09-11 209
作用:特殊大并发场景下高性能键值对 缓存 优势: 消息队列:双十一抢购,大量存入数据库行为同时发生,导致服务器瘫痪.使用消息队列,把任务存在队列中,由程序拿出来依次执行,面对打请求就不会直接瘫痪. 服务器集群,分工提高效率:具备主从复制能力,使得主服务器专门写,从服务器专门读,灵活布置高效实现 高效率 :每秒11万次set,8万次get,因为运行在内存所以有极高效率, 可持久化:同时可借
缓存之Redis了解及使用
chuanyuan8669的博客
05-21 267
介绍 redis是一种支持Key-Value等多种数据结构的存储系统。可用于缓存，事件发布或订阅，高速队列等场景。该数据库使用ANSI C语言编写，支持网络，提供字符串，哈希，列表，队列，集合结构直接存取，基于内存，可持久化。 安装 由于开发机器一般都是windows...
Redis 缓存
sinat_34814635的博客
01-08 3125
缓存类型 客户端缓存 对于BS架构的互联网应用来说客户端缓存主要分为页面缓存和浏览器缓存两种，对于APP而言主要是自身所使用的缓存。 清理缓存的方式： 以网页浏览器为例 1.使用Ctrl+F5可以强制刷新浏览器本地缓存 2.浏览器中的参数设置的时间已过期如：Expires，Cache-control: max-age， Last-Modified标签等 网络中缓存 网络中的缓存主要是指代理服务器对...
[bigdata-55] python3 操作redis
大数据和机器学习研究
03-17 839
1. 安装 pip3 install redis 2. 测试连接 #!/usr/bin/env python3 #! -*- coding:utf-8 -*- import redis r = redis.StrictRedis(host='192.168.1.xxx', port=63790, db=0, password='z88') ret = r.set('foo', '
基于 Python 的 Redis 操作
伤心的辣条
07-17 361
redis类型介绍： redis有五种基本类型：字符串类型、散列类型、列表类型、集合类型、有序集合类型。 每种不同的类型，reids客户端提供了很多不同的操作方法，下面即将演示最常用的一些基于python的操作
Python操作redis
Besion王
08-14 935
第一部分转自：http://blog.csdn.net/chenggong2dm/article/details/6102540 首先确保redis已经正常启动。   安装    可以去pypi上找到redis的Python模块：    http://pypi.python.org/pypi?%3Aaction=search&term=redis&submit=sea
scrapy redis
最新发布
06-25
Scrapy Redis是一个扩展，用于Scrapy爬虫框架，它可以将Scrapy项目的item存储在Redis数据库中，从而简化爬取数据的过程并提高效率。使用Scrapy Redis，你可以： 1. **队列管理**：Scrapy Redis作为爬虫的队列，可以有效地管理待抓取的URL，避免了重复和无序的抓取，支持批量抓取。 2. **分布式爬虫**：通过Redis的发布/订阅机制，可以轻松地在多个Scrapy爬虫之间分发任务，实现分布式爬取。 3. **数据持久化**：Redis提供强大的数据持久化，即使在服务器重启后，也可以从上次爬取的位置继续。 4. **实时过滤**：Redis允许实时过滤已抓取的内容，避免重复抓取和存储。 要使用Scrapy Redis，你需要安装scrapy-redis库，然后在Scrapy项目设置中配置redis连接信息。接下来，定义一个RedisPipeline，它会在爬虫运行过程中自动将抓取的item添加到Redis中。此外，你还需要配置Spider以从Redis中获取待抓取的URL。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值