redis的基本操作

Posted 2023-04-01 冷雨大哥哥

redis数据库

一、概述：

redis数据库是一个内存数据库，基于内存进行数据存储的，redis数据库访问速度特别快。因此，redis通常被用于缓存系统、存储大量活跃数据，可以极大地提高网站的响应速度。redis数据库里面的数据是通过key-value键值对的方式进行存储的。

二、redis数据库的优点：

（1）redis数据库是完全开源免费的。
（2）支持数据持久化，redis可以通过配置将内存中的数据保存到磁盘上，redis数据库重启后再将数据加载到内存中。
（3）redis数据库支持多种数据结构，如：字符串、列表、哈希表、有序集合、无序集合等。
（4）支持原子操作，支持事务。redis数据库中的所有操作都是原子性的。
（5）支持数据过期功能。
（6）对数据有高可用性和可扩展性

三、redis数据库和memcached对比

（1）redis和memcached都是基于内存进行存储的数据库
（2）redis数据库可以用来做数据存储，但memcached通常被用来做缓存
（3）对于redis数据库来说，存储的数据是有结构的，而对于memcached来说，存储的数据只有一种类型：字符串，而redis支持字符串、列表、有序集合（zset）、无序集合（set）、哈希表等。

四、redis的一些简单操作

默认端口：6370
redis数据库一共有16个库（0-15），默认选择的是第1个库（0库）
redis中有些操作和数据类型没有关系：
keys * ：查看数据库中的所有键
expire 键名 秒数：设置过去时间
persist 键名 ：移除过期时间
select 库名：选择对用数据库
flushdb ：删除当前所在数据库的所有数据
flushall ：清空所有数据库中的数据
set key value 设置键和值
get key 获取值
del key 删除键

字符串(str)

 getrange  name  0 3		#截取字符串
 strlen   name				#获取字符串长度
 setex name 5 zhangsan      #设置带有过去时间的key-value  5秒过期
 mset name lisi sex male    #设置多个key-value
 mget name age 				#获取多个value
 append name  wangwu        #字符串结尾追加内容
 incr age					#数字自增1
 incrby age	5				#数字加上指定的整数值
 incrby age 2.5				#数字加上指定的浮点数
 decr  age					#数字自减1
 decrby age 5				#数字减去指定的整数值

哈希表

hset 						# hset 表名   设置哈希表
hset 800 name  tom 			#设置表名为800 字段为name 值为tom
hset 800 age   25			#给表800 添加一个字段age 为25
hmset						#设置哈希表多个字段
hmset 900 name tom age 25  sex male		#设置多个字段
hget						# hget 900 name 获取哈希表中的字段
hget 900 name				#获取哈希表 900下的字段name
hmget 900 name age sex 		#获取哈希表中的多个字段
hgetall 900					#获取哈希表中的所有的值
hkeys 900					#获取所有哈希表的字段名
hlen 900					#获取哈希表中字段的shul
hexists 900 name			#哈希表中是否存在某个字段
hvals 900					#获取哈希表中所有字段的值
hdel 900 name age 			#删除哈希表中的字段值
hincrby 900 age 10			#让哈希表中的某一字段增加固定的整数值(10)
hincrbyfloat 900 age 10.5  	#让哈希表中的某一字段增加固定的浮点值(10.5)

列表

rpush dname 张三 李四 王五 赵六		#向列表dname中从右添加元素
lpush dname 王麻子					#从左边向列表dname中添加元素
lset dname 2  赵斌					#修改数据，将王五修改为赵斌
lrange dame 0 -1					#获取所有元素
llen  dname							#获取列表长度
lindex dname 0						#用索引获取某个元素
linsert dname beform 张三 刘斌		#在某个元素前插入元素
lpop dname							#从左边删除一个元素
rpop dname							#从右边删除一个元素
lrem dmane 1 张三					#删除第一个张三

集合 --》不可重复，不支持索引

无序集合

sadd empno 800 						#给集合添加值
sadd empno 800 900					#给集合添加多个值
smembers empno						#获取集合中的所有元素
scard empno							#获取集合的所有元素
sismember empno 800					#判断是否含有某个元素
srem empno 800 900					#删除元素
del	empno							#删除集合
spop empno							#随机删除并返回集合的某个元素
srandmember empno 5					#随机返回集合中的5个元素

有序集合：有序集合是带有排序功能的集合，redis会按照元素分数值排序

zadd keyword 0 '鹿晗' 0 '张朝阳' 0 '马云'	#为集合中添加元素
zincrby keyword 1 '鹿晗'
zincrby keyword 5 '马云'
zincrby keyword 2 '张朝阳'					#为集合添加值
zrevrange keyword 0 -1						#获取所有的值，并降序(rev)
zrange keyword	0 -1						#获取所有的值，并升序
zcard keyword								#获取有序集合的长度
zcount keyword 5 10							#查询某个分数区间的元素数量
zscore keyword '马云'						#返回元素的分数值
zrangebyscore 								#获取分数值区间内的集合内容(升序)
zrangebyscore keyword 5 10	
zrangebyscore keyword 5 (10   				#( 不包含10
zrangebyscore keyword 100+inf				#100以上的所有数据
zrevrangebyscore							#获取分数值区间内的集合内容(降序)
zrevrangebyscore keyword 10 5				#参数为也为倒序
zrank keyword '马云'						#获取元素的升序排名（从0开始）
zrevrank keyword '马云'						#获取元素的降序排名（从0开始）
zrem keyword '马云' '张朝阳'				#删除有序集合中的元素
zremrangebyrank keyword 0 2					#删除排名区间内的元素
zremrangebyscore keyword -inf (500			#删除负无穷到500的值

key的一些命令

del keyword						#删除记录
exists keyword					#判断是否存在某个key
expire keyword 5				#设置过期时间  秒
pexpire keyword 1000			#设置过期时间  毫秒
expireat keyword 1544803200		#设置过期时间  时间戳
more	keyword 1				#把记录迁移到其他逻辑库
rename keyword tem				#修改key的名称（重命名）
persist keyword					#移除过期时间
type keyword					#判断value数据类型

python操作redis数据库

#安装redis  pip install redis

import redis
#链接redis
r =redis.Redis(
    host='localhost',		#主机
    port=6379, 				#端口
    password='',			#密码
    db=0
)


#创建连接池
pool =redis.ConnectionPool(
    host='localhost',
    port=6379,
    password='',
    db=0,
    max_connections=20
)
#操作集合
con =redis.Redis(
    connection_pool =pool
)
con.set("country","英国")
con.set("city","伦敦")
city =con.get("city").decode("utf-8")		#要编码
print(city)

con =redis.Redis(
    connection_pool=pool
)
#删除操作，集合
try:
    con.delete("country","city")
    con.mset("country":"德国","city":"柏林")
    result =con.mget("country","city")
    for one in result:
        print(one.decode("utf-8"))
except Exception as e:
    print(e)

#操作列表
con =redis.Redis(
    connection_pool=pool
)

try:
    con.rpush("dname","董事会","秘书处","财务部","技术部")
    con.lpop("dname")
    result =con.lrange("dname",0,-1)
    for one in result:
        print(one.decode('utf-8'))
except Exception as e:
    print(e)
finally:

    del con

#操作无序集合
con =redis.Redis(
    connection_pool=pool
)

try:
    con.sadd("employee",8001,8002,8003)
    con.srem("employee",8002)
    result =con.smembers("employee")
    for one in result:
        print(one.decode('utf-8'))

    con.zadd("keyword","马云":0,"张朝阳":0,"丁磊":0)
    con.zincrby("keyword",10,"马云")
    result =con.zrevrange("keyword",0,-1)
    for one in result:
        print(one.decode('utf-8'))

except Exception as e:
    print(e)

#操作哈希表
con =redis.Redis(
    connection_pool=pool
)
try:
    con.hmset("9527","name":"scott","sex":"male","age":38)
    con.hset("9527","city","纽约")
    con.hdel("9527","age")
    result =con.hexists("9527","name")
    print(result)
    result =con.hgetall("9527")
    for one in result:
        print(one.decode('utf-8'),result[one].decode('utf-8'))
except Exception as e:
    print(e)

Redis的基本操作

Redis的基本操作

redis普通连接与连接池

# 安装redis模块
pip install redis

# 普通连接
from redis import Redis
# 创建连接对象
conn = Redis(host=‘localhost‘, port=6379)
ret = conn.get(‘name‘)

python操作之连接池

# redis使用connection pool来管理对一个redis Server的所有连接，以避免每次建立，释放连接的开销。

import redis

POOL = redis.ConnectionPool(host=‘127.0.0.1‘,port=6379)
ret = redis.Redis(connection_pool=POOL)
ret.set(‘name‘,‘cherry‘)
print(ret.get(‘name‘))

# 单例的实现
# redis_pool.py

import redis

POOL = redis.ConnectionPool(host=‘127.0.0.1‘,port=6379,max_connections=100) # z造一个池子，最多创建100个连接
ret = redis.Redis(connection_pool=POOL)  # 从连接池中取出一个连接

单例实现方式（模块导入）

redis_pool.py

import redis

POOL = redis.ConnectionPool(host=‘127.0.0.1‘,port=6379,max_connections=100) # z造一个池子，最多创建100个连接

这样就可以避免每执行一次，就创建一个连接池

# 使用方式（包导入）
from redis_pool import POOL
import redis

ret = redis.Redis(connection_pool=POOL)  # 从连接池取出一个连接

?注意

如果是运行包内的文件，在该文件导入包内的文件时，注意不能用‘.’;
在外部使用可以带点

redis之字符串的操作

重点掌握

set操作

def set(self, name, value,ex=None, px=None, nx=False, xx=False, keepttl=False):
    
ex: 过期时间（ 秒）
px: 过期时间（毫秒）
nx: 如果设置为True, 当name不存在的时候，set操作才会执行；如果存在，则不会执行。（新增操作）
xx，如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值。（更新操作）

exp:

conn.set(‘perfect‘,‘surpass‘,ex=5)   # 设置过期时间5秒
conn.set(‘sex‘,‘Female‘,nx=True)   # key不存在创建，存在不做任何操作
conn.set(‘name‘,‘cherry1‘,xx=True) # key存在才更新新值，不存在不做任何操作

get操作

# 获取值
name = conn.get(‘name‘)

mset操作

# 批量设置值
mset(self, mapping)
conn.mset({‘name1‘:‘egon‘,‘name2‘:‘lqz‘})

mget操作

# 批量获取值
mget(self, keys, *args):

ret = conn.mget([‘name1‘,‘name2‘,‘name3‘])  # [b‘egon‘, b‘lqz‘, None]

incr操作

# 应用场景，统计某网站的访问数量，页面的访问量，接口的访问量
ret = conn.incr(‘num‘,amount=1)  # 只要一执行，数字就加1

decr操作

# 应用场景，设计秒杀
ret = conn.decr(‘num‘,amount=1) 
 等于
ret = conn.incr(‘num‘,amount=1)

了解

setnx(name,value)  ==>  set(name,value,nx=True)
setex(name,value,time) ==> set(name,value,ex=5)
psetx(name,time_ms,value)  # 毫秒

# 先获取值在设置值，将两次IO操作变为1次
ret = conn.getset(‘name1‘,‘egon_dsb‘)  # ret  是获取到的值

# 根据key截取字符串
ret = conn.getrange(‘name1‘,0,0)  #  b‘e‘

# 修改字符串内容，从指定字符串索引开始向后替换
 ret = conn.setrange(‘name1‘,2,‘8888‘) # 从第三个位置开始替换后面的字符串

# 获取name对应的值的二进制表示中的某位的值 （0或1）
ret = conn.getbit(‘name1‘,9)   # 1

# append
在redis name对应的值后面追加内容
ret = conn.append(‘num‘,‘oo‘)

redis之hash操作

重点掌握

hset操作

hset(self, name, key=None, value=None, mapping=None)

ret = conn.hset(‘beast‘,‘name‘,‘huangliang‘)
ret = conn.hset(‘beast‘,‘name‘,‘lqz‘)   # 直接覆盖

hget操作

hget(self, name, key)

ret = conn.hget(‘beast‘,‘name2‘)  # b‘lqz‘

hmget操作

# 支持传多个key ,或者传一个keys的列表
def hmget(self, name, keys, *args):
    "Returns a list of values ordered identically to ``keys``"
    args = list_or_args(keys, args)
    return self.execute_command(‘HMGET‘, name, *args)


ret = conn.hmget(‘beast‘,‘name‘,‘name2‘)
ret = conn.hmget(‘beast‘,[‘name‘,‘name2‘])

hmset操作

# 批量设置多个值
conn.mset({‘name1‘:‘egon‘,‘name2‘:‘lqz‘})

hincrby操作

# 应用场景 个人博客文章的访问量
conn.hmset(‘blog‘:{‘第一篇博客‘:‘55‘,‘第二篇博客‘:‘66‘})

ret = conn.hincrby(‘blog‘,‘第一篇博客‘)  # 点击一次，自增一次

hscan_iter操作

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据
 
# 参数：
    # match，匹配指定key，默认None 表示所有的key
    # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数

ret = conn.hscan_iter(‘hash3‘)
print(ret)
for i in ret:
    print(i)

了解

# 获取name对应的hash中所有的key的值
ret = conn.hkeys(‘hash3‘)
# 获取name对应的hash中所有的value的值
ret = conn.hvals(‘hash3‘)
# 检查name对应的hash是否存在当前传入的key
ret = conn.hexists(‘hash3‘,‘key4‘)  #  存在作为True,不存在则为False
# 将name对应的hash中指定key的键值对删除
ret = conn.hdel(‘hash3‘,‘key2‘)  # 
# 获取name对应的hash中键值对的个数
 ret=conn.hlen(‘hash3‘)

redis之list操作

重点掌握

lpush操作

# 在name对应的List中添加元素，每个新元素都添加到列表的最左边 
ret = conn.lpush(‘list1‘,1,2,3,4,5)
"""
实现队列
先进先出
"""

rpush操作

# 在name对应的List中添加元素，每个新元素都添加到列表的最右边 
ret = conn.rpush(‘list1‘,777,888)
"""
实现堆栈
后进先出
"""

blpop操作

消息队列（生产者消费者模型）
# block,阻塞操作,可以写一个超时时间
# 应用场景：分布式爬虫

ret=conn.blpop(‘list1‘,timeout=10)
print(ret)

其他

# lpushx(name,value) 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
lpushx(‘list1‘,888)
# rpushx(name,value) 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最右边
rpushx(‘list1‘,999)
# llen(name)  统计一下name对应list的总长度
ret = conn.llen(‘list1‘)

# 在name对应的列表的某一个值前或后插入一个新值
ret = conn.linsert(‘list1‘,‘before‘,‘3‘,‘88887‘) # 在‘3’前面插入一条数据
ret = conn.linsert(‘list1‘,‘after‘,‘3‘,‘18887‘)  # 在‘3’后面插入一条数据

#  对name对应的list中的某一个索引位置重新赋值
ret = conn.lset(‘list1‘,‘0‘,‘1111‘)

# 在name对应的list中删除指定的值
def lrem(self, name, count, value):
    """
    The count argument influences the operation in the following ways:
        count > 0: Remove elements equal to value moving from head to tail.
        count < 0: Remove elements equal to value moving from tail to head.
        count = 0: Remove all elements equal to value.
    """
    return self.execute_command(‘LREM‘, name, count, value)
ret=conn.lrem(‘list1‘,2,‘5‘)   # 从前往后删除两个5  (+ 从前往后)
ret=conn.lrem(‘list1‘,-1,‘5‘)  # 从后往前删除1个5   (- 从后往前)
ret=conn.lrem(‘list1‘,0,‘5‘)   # 删除所有5  (0-all)

# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
ret = conn.lpop(‘list1‘)

# 在name对应的列表的右侧获取第一个元素并在列表中移除，返回值则是第一个元素
ret = conn.rpop(‘list1‘)

# 在name对应的列表中根据索引获取列表元素
ret = conn.lindex(‘list1‘,‘0‘)   #取出索引为0的位置的值

# 对name对应的list进行切片取值
ret = conn.lrange(‘list1‘,‘0‘,‘2‘)  #[b‘4‘, b‘88887‘, b‘3‘]

# 在name对应的列表中移除没有在start-end索引之间的值
ret = conn.ltrim(‘list1‘,‘0‘,‘2‘)

自定义增量迭代

# yield的应用场景

# 自定制分批取列表的数据
# 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

Redis之管道

# 在redis中使用管道来实现事务
事务的一致性：要么都成功，要么都失败
 
import redis
from xxx import POOL

conn = 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()

单例模式封装

import redis
POOL = redis.ConnectionPool(host=‘10.211.55.4‘, port=6379)

Redis的其它使用

# 删除操作
conn.delete(‘list1‘)
ret=conn.delete(‘hash1‘)

# 判断name是否存在
ret=conn.exists(‘hash2‘)

#根据模型获取redis的name
ret=conn.keys(‘cache*‘)  #查询以cache开头的所有key

#为某个redis的某个name设置超时时间
ret=conn.expire(‘hash2‘,2)

# 获取name对应值的类型
ret=conn.type(‘name3‘)
ret=conn.type(‘test‘)
ret=conn.type(‘test‘)