redis 介绍与操作

参考连接： 

https://www.cnblogs.com/wupeiqi/articles/5132791.html

redis是一个软件，帮助开发者对一台机器的内存进行操作.

能干吗？

 用于操作内存的软件。

--- 可以做持久化

　　AOF ：则是将Redis执行的每次写命令记录到单独的日志文件中当Redis重启时再次执行AOF文件中的命令来恢复数据。

　　ROB ： RDB持久化是将进程数据写入文件。

-- 相当于大字典 

-- 单进程单线程

 

 数据类型

1.字符串

k1：“ 这是个忧伤的故事 “

 

2.列表

k2：[1,2,3,4,5,6,7,8]

 

3.集合

k3:{1,2,3,4,5,6}

4.字典

k4:{ name:123, age:666 }

5.有序集合

k5：｛('alex',60),('eva-j'80),('rt',70)｝

操作

redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，

并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

 

普通redis

import redis

# 1.创建一个redis连接
r = redis.Redis(host='127.0.0.1',port=6379)

# 2.只能设置一个值，放入redis
r.set('foo','Bar')

# 3.去redis中取值
print(r.get('foo'))

连接池redis

为什么要用连接池？

redis-py 使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。

可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

 

# 连接池

import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.Redis(connection_pool=pool)

# 3.放入值到redis
r.set('foo','Bar')

# 4.取值
print(r.get('foo'))

 

 字符串的操作（String）

 

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

 redis 介绍与操作

 

 

设置值

1.set 

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

在Redis中设置值，默认，不存在则创建，存在则修改

参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行
     xx，如果设置为True，则只有name存在时，岗前set操作才执行
import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.Redis(connection_pool=pool)

# 3.放入值到redism,3秒后过期
r.set('foo','Bar',ex=3)

# 4.取值
print(r.get('foo'))

 

2.setnx

setnx(name, value)

 

只有name不存在时，执行设置操作（添加）

import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.Redis(connection_pool=pool)

# 3.，只有name不存在时，执行设置操作（添加）
r.setnx('foo','Bar1')

# 4.取值
print(r.get('foo'))

 

redis 介绍与操作

 

 

3.setex

setex(name,time, value, )

　　　　# name, 设置值.

　　　　# time，过期时间（数字秒 或 timedelta对象）.

　　　　# value, 参数.
　　　
import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.Redis(connection_pool=pool)

# 3.设置k 时间 v 
r.setex('foo',5,5454)

# 4.取值
print(r.get('foo'))

 

 4.psetex

psetex(name, time_ms, value)

 

 　　# name :    设置值

　　# time_ms :  参数：
　　# time_ms :  过期时间（数字毫秒 或 timedelta对象）
import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.Redis(connection_pool=pool)

# 3.设置k 时间 v 豪秒
r.psetex('foo',5000,5454)

# 4.取值
print(r.get('foo'))

5.mset

mset(*args, **kwargs)

批量设置值





r.mset({'k1': 'v1', 'k2': 'v2'})
print(r.mget("k1", "k2"))   # 一次取出多个键对应的值
print(r.mget("k1"))






r.mset({'k1': 'v1', 'k2': 'v2'})




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mset({'k1':'riven','k2':'mark'})

# 4.获取多个值
print(r.mget('k1','k2'))






get 获取值


1.mget




mget(keys, *args)




　　批量获取值




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.获取多个值
print(r.mget('k1','k2'))




2.getset








getset(name, value)




设置新值并获取原来的值




 



redis 介绍与操作

 


 


3. getrange




getrange(key, start, end)




# 获取子序列（根据字节获取，非字符）


# 参数：


    # name，Redis 的 name


    # start，起始位置（字节）


    # end，结束位置（字节）


# 如： "武沛齐" ，0-3表示 "武" , 相当于切片


 






import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.切片取值
print(r.getrange('k1',1,2))








redis 介绍与操作


 修改字符串


 1.setrange




setrange(name, offset, value)







# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）

# 参数：



    # offse :  字符串的索引，字节（一个汉字三个字节）。




    # value :  要设置的值。



 






import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.索引指定位置 修改替换成新值
r.setrange('k1',5,'666666666666666666666666')

# 5.获取值
print(r.mget('k1'))




 






 redis 介绍与操作


 


 2.setbit




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"




# 扩展，转换二进制表示：




 # source = "武沛齐"
    source = "foo"
 
    for i in source:
        num = ord(i)
        print bin(num).replace('b','')






特别的，如果source是汉字 "武沛齐"怎么办？
    答：对于utf-8，每一个汉字占 3 个字节，那么 "武沛齐" 则有 9个字节
       对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制
       11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000




 




 查（bit）


1.getbit




getbit(name, offset)




 


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




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.获取2进制中索引的0或者1
print(r.getbit('k1',8))




2.bitcount




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




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


# 参数：


    # key，Redis的name


    # start，位起始位置


    # end，位结束位置


 




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.获取对应的值的二进制表示中 1 的个数
print(r.bitcount('k1',1,2))




3.bitop




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 对应的值中



 


4.strlen




strlen(name)




 


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




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.批量设置值
r.mget({'k1':'riven','k2':'mark'})

# 4.# 返回name对应值的字节长度（一个汉字3个字节）
print(r.strlen('k1'))




redis 介绍与操作


 


 


 


5.incr




incr(self, name, amount=1)




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


 


# 参数：


    # name,Redis的name


    # amount,自增数（必须是整数）


 


# 注：同incrby


 


6.incrbyfloat






incrbyfloat(self, name, amount=1.0)




 











1


2


3


4


5






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


 


# 参数：



    # name,Redis的name




    # amount,自增数（浮点型）














7.decr




decr(self, name, amount=1)




 











1


2


3


4


5






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


 


# 参数：



    # name,Redis的name




    # amount,自减数（整数）














8.append




append(key, value)




 











1


2


3


4


5






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


 


# 参数：



    key, redis的name




    value, 要追加的字符串
















 


 


Hash（字典）操作


设置值


1.hset






hset(name, key, value)




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


 


# 参数：


    # name ：redis的name


    # key ：name对应的hash中的key


    # value：name对应的hash中的value


 


# 注：


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








import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3.# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）  单个
r.hset('xx', 'name','riven')

# 4. 批量获取值
print(r.hgetall('xx'))




redis 介绍与操作


 


 


 


2.hmset






hmset(name, mapping)




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


 


# 参数：


    # name，redis的name


    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}


 


# 如：


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


 




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3. # 在name对应的hash中批量设置键值对
r.hmset('xx', {'name':'riven','age':'18'})

# 4. 批量获取值
print(r.hgetall('xx'))




redis 介绍与操作


 


 按位置获取值（数据量大的时候）


1.hscan




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




ps: field数量应该大于某个值时，分页命令才会生效




import redis
# 1.创建一个redis连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379)

# 2.每个Redis实例都会维护一个自己的连接池。
r=redis.StrictRedis(connection_pool=pool)

# 3. # 在name对应的hash中批量设置键值对
r.hmset('xx', {
    'name':'riven','age':'18.00','hogby':'gril','name2':'mark','age2':'20','hogby2':'littlgril',
'name11':'riven','age11':'18.00','hogby11':'gril','name211':'mark','age211':'20','hogby211':'littlgril',
'name222':'riven','age222':'18.00','hogby222':'gril','name2222':'mark','age2222':'20','hogby2222':'littlgril',
'name333':'riven','age333':'18.00','hogby333':'gril','name2333':'mark','age2333':'20','hogby2333':'littlgril',
})

# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=10)



print(r.hscan('xx'))



View Code
 
                    
            
                

                  
 
        

	 
        

            

                                            

        

        
相关文章：

        

      
            
 
                    
    
                                                    
  • 
                                 
                                2021-09-18
                            
    • 
                                                        
  • 
                                 
                                2022-02-07
                            
    • 
                                                        
  • 
                                 
                                2021-09-06
                            
    • 
                                                        
  • 
                                 
                                2021-10-19
                            
    • 
                                                        
  • 
                                 
                                2022-12-23
                            
    • 
                                                        
  • 
                                 
                                2021-06-08
                            
    • 
                                                        
  • 
                                 
                                2021-04-30
                            
    • 
                                                

               
   
         

    


  






 
          

    
猜你喜欢 

        
    
                                 
  • 
                     
                    2021-12-02
                
    • 
                                     
  • 
                     
                    2021-10-16
                
    • 
                                     
  • 
                     
                    2021-05-27
                
    • 
                                     
  • 
                     
                    2022-12-23
                
    • 
                                     
  • 
                     
                    2021-12-19
                
    • 
                                     
  • 
                     
                    2021-11-23
                
    • 
                            

   
 



    
相关资源 

        
   

   
    

     
相似解决方案 

         
    
                          

    

  
   

    

 
   

    
热门标签  

    

                    Java
                        Python
                        linux
                        javascript
                        Mysql
                        C#
                        Docker
                        算法
                        前端
                        SpringBoot
                        Redis
                        Vue
                        spring
                        设计模式
                        .net core
                        .net
                        kubernetes
                        c++
                        数据库
                        数据结构
                        大数据
                        js
                        机器学习
                        微服务
                        Android
                        Go
                        程序员
                        面试
                        JVM
                        ASP.net core
                        云原生
                        人工智能
                        后端
                        PHP
                        git
                        CSS
                        golang
                        k8s
                        Nginx
                        Django
                        mybatis
                        深度学习
                        多线程
                        React
                        架构
                        devops
                        爬虫
                        云计算
                        Spring Boot
                        LeetCode