Python连接方式
1，
import redis
#decode_responses=True 自动解码
r = redis.Redis(host='127.0.0.1',port=6379,password='123456',db=0,decode_responses=True) #默认数据库为0
r = redis.StrictRedis(host='10.10.2.14',port=6379,password='123456',decode_responses=True)
2,连接池
import redis
pool = redis.ConnectionPool(host='192.168.190.132', port=6379, decode_responses=True)
r = redis.StrictRedis(connection_pool=pool)
# r.setrange("name", 2, "zzzzz")
# print(r.strlen("name"))
# r.append('name', "1tttttt2")
print(r.type("name"))
字符串操作
- r.set 设置值
#在Redis中设置值，默认不存在则创建，存在则修改
r.set('name', 'zhangsan')
'''参数：
set(name, value, ex=None, px=None, nx=False, xx=False)
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行,同setnx(name, value)
xx，如果设置为True，则只有name存在时，当前set操作才执行'''
- r.get 获取值
r.get('name')
3,mset 批量设置值
import redis
pool = redis.ConnectionPool(host='192.168.190.132', port=6379, decode_responses=True)
r = redis.StrictRedis(connection_pool=pool)
r.mset(mapping={"name4": "wangwu", "name5": "wangwu4", "name6": "wangwu6"})
print(r.mget("name4", "name5"))
# 或
li = ["name5", "name4"]
print(r.mget(li))
4，getset 设置新值，打印原值
getset(name, value)
print(r.getset('name4', 'ttttt'))
print(r.get("name4"))
5，getrange 根据字节获取子序列
print(r.getrange("name4", 0, 3))
6，setrange 修改字符串内容，从指定字符串索引开始向后替换，如果新值太长时，则向后添加
setrange(name, offset, value)
import redis
pool = redis.ConnectionPool(host='192.168.190.132', port=6379, decode_responses=True)
r = redis.StrictRedis(connection_pool=pool)
# r.mset(mapping={"name4": "wangwu", "name5": "wangwu4", "name6": "wangwu6"})
r.set("name", "李四")
r.setrange("name", 3, "zzzz") #偏移量从字符数+1开始，不然报错
print(r.get("name"))
7，strlen(name) 返回name对应值的字节长度
print(r.strlen("name"))
8， incr 值的累加 amount为累加的值
incr(self, name, amount=1)
print(r.incr("mount",amount=2))#输出:2
print(r.incr("mount"))#输出:3
print(r.incr("mount",amount=3))#输出:6
print(r.incr("mount",amount=6))#输出:12
print(r.get("mount")) #输出:12
9，append在name 值后追加内容
print(r.get('name'))
r.append("name", "lisiss")
print(r.get('name'))
10，查看类型
type 查看类型
应用
点击页面增加数量
import redis
pool = redis.ConnectionPool(host='192.168.190.132', port=6379, decode_responses=True)
r = redis.StrictRedis(connection_pool=pool)
# # r.mset(mapping={"name4": "wangwu", "name5": "wangwu4", "name6": "wangwu6"})
# r.set("name", "李四")
# r.setrange("name", 3, "zzzz")
# print(r.get('name'))
# r.append("name", "lisiss")
# print(r.get('name'))
# r.set("visit:1237:totals", 34634)
r.incr("visit:1237:totals")
print(r.get("visit:1237:totals"))
有序集合命令操作
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
命令
ZADD test 1 redis
127.0.0.1:6379> ZRANGE test 0 10 WITHSCORES
1) "redis"
2) "1"
3) "zhangsan"
4) "20"
5) "zhangsan1"
6) "30"
7) "lisi"
8) "50"
9) "127.0.0.1"
10) "100"
常用命令
#ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员，或者更新已存在成员的分数
如果某个成员已经是有序集的成员，那么更新这个成员的分数值，并通过重新插入这个成员元素，来保证该成员在正确的位置上。
分数值可以是整数值或双精度浮点数。
如果有序集合 key 不存在，则创建一个空的有序集并执行 ZADD 操作。
当 key 存在但不是有序集类型时，返回一个错误。
ZADD KEY_NAME SCORE1 VALUE1.. SCOREN VALUEN
#ZCARD key 获取有序集合的成员数
用于计算集合中元素的数量
#ZCOUNT key min max 计算在有序集合中指定区间分数的成员数
#ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment
ZINCRBY myzset 2 "one"
#ZINTERSTORE destination numkeys key [key ...] 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
#ZLEXCOUNT key min max 在有序集合中计算指定字典区间内成员数量
#ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合成指定区间内的成员
#ZRANGEBYLEX key min max [LIMIT offset count] 通过字典区间返回有序集合的成员
#ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT] 通过分数返回有序集合指定区间内的成员
#ZRANK key member 返回有序集合中指定成员的索引
#ZREM key member [member ...] 移除有序集合中的一个或多个成员
#ZREMRANGEBYLEX key min max 移除有序集合中给定的字典区间的所有成员
#ZREMRANGEBYRANK key start stop 移除有序集合中给定的排名区间的所有成员
#ZREMRANGEBYSCORE key min max 移除有序集合中给定的分数区间的所有成员
#ZREVRANGE key start stop [WITHSCORES] 返回有序集中指定区间内的成员，通过索引，分数从高到底
#ZREVRANGEBYSCORE key max min [WITHSCORES] 返回有序集中指定分数区间内的成员，分数从高到低排序
#ZREVRANK key member 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
#ZSCORE key member 返回有序集中，成员的分数值
#ZUNIONSTORE destination numkeys key [key ...] 计算给定的一个或多个有序集的并集，并存储在新的 key 中
#ZSCAN key cursor [MATCH pattern] [COUNT count] 迭代有序集合中的元素（包括元素成员和元素分值）
python操作
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port='6379',)
r = redis.StrictRedis(connection_pool=pool, decode_responses=True)
r.zadd('test', {"zhangsan1": 30, "lisi": 50} )
def zadd(self,
name: Any,
mapping: {__len__, items, iteritems},
nx: bool = False,
xx: bool = False,
ch: bool = False,
incr: bool = False) -> Any
#r.zadd("proxies", {'192.168.0.2': 10, '192.168.2.10': 20})
zcard(name)
# 获取name对应的有序集合元素的数量
zcount(name, min, max)
# 获取name对应的有序集合中分数 在 [min,max] 之间的个数
zincrby(name, value, amount)
# 自增name对应的有序集合的 name 对应的分数
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
# 按照索引范围获取name对应的有序集合的元素
# 参数：
# name，redis的name
# start，有序集合索引起始位置（非分数）
# end，有序集合索引结束位置（非分数）
# desc，排序规则，默认按照分数从小到大排序
# withscores，是否获取元素的分数，默认只获取元素的值
# score_cast_func，对分数进行数据转换的函数
# 更多：
# 从大到小排序
# zrevrange(name, start, end, withscores=False, score_cast_func=float)
# 按照分数范围获取name对应的有序集合的元素
# zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
# 从大到小排序
# zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
zrank(name, value)
# 获取某个值在 name对应的有序集合中的排行（从 0 开始）
# 更多：
# zrevrank(name, value)，从大到小排序
zrem(name, values)
# 删除name对应的有序集合中值是values的成员
# 如：zrem('zz', ['s1', 's2'])
zremrangebyrank(name, min, max)
# 根据排行范围删除
zremrangebyscore(name, min, max)
# 根据分数范围删除
zscore(name, value)
# 获取name对应有序集合中 value 对应的分数
zinterstore(dest, keys, aggregate=None)
# 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM MIN MAX
zunionstore(dest, keys, aggregate=None)
# 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
# aggregate的值为: SUM MIN MAX
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)
# 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作