def string(): redis = StrictRedis(host='localhost', port=6379, password='', db=0) # result=redis.set('name','zengshuai') # print(result) # redis.set('age',25) # redis.set('gender','male') # redis.set('score',100) #通用方法 print(redis.exists('name')) print(redis.type('name')) print(redis.keys('a*')) #a 开头的 键值 print(redis.randomkey()) #随机取一个键值 # redis.rename('score','English') #重命名 # print(redis.get('English')) print(redis.dbsize()) #size redis.expire('English', 2) #设置键值过期时间 print(redis.ttl('English')) #获取键值过期时间 redis.move('age', 1) #将键移动到其他数据库 # redis.flushdb() #清空本数据库 # redis.flushall() #清空所有数据库 #字符串操作 redis.getset('name', 'kate') print(redis.get('name'))
class redis_op(object): """ 确保单例模式 """ def __new__(cls, *arg, **kw): if not hasattr(cls, "_instance"): cls._instance = super().__new__(cls) return cls._instance def __init__(self, redis_key): self.rc = StrictRedis( connection_pool=ConnectionPool(host="127.0.0.1", port=6379, db=0)) self._lock = 0 self._lock_key = f"{redis_key}_lock_key" def __getattr__(self, name): return getattr(self.rc, name) def __enter__(self): while not self._lock: time_out = time.time() + 10 + 1 self._lock = self.rc.setnx(self._lock_key, time_out) if self._lock or (time.time() > float(self.rc.get(self._lock_key)) and time.time() > float( self.rc.getset(self._lock_key, time_out))): return self else: time.sleep(0.3) def __exit__(self, exc_type, exc_val, exc_tb): if time.time() < float(self.rc.get(self._lock_key)): self.rc.delete(self._lock_key)
def kill_duplicates(chunk, unique_id, host, port, db, password): """ Identify duplicates with Redis """ printer = prefix_print("CHUNK{0}".format(chunk)) redis_host = host redis_port = int(port) redis_db = int(db) redis_password = password startup_nodes = [{ "host": redis_host, "port": redis_port, "password": redis_password }] if not CLUSTER: redis_client = StrictRedis(host=redis_host, port=redis_port, password=redis_password, db=redis_db) else: redis_client = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True, skip_full_coverage_check=True) printer("Initialized Redis client") node_manager = NodeManager(startup_nodes) printer("Created NodeManager") k_signal = redis_client.getset(unique_id, "Y") printer("Checked if lambda already launched") if k_signal == "Y": printer("Found duplicate - killing.") return None return redis_client, node_manager
class RedisStorage(Storage): def __init__(self, settings): host = settings.get('TRACKER_RADIS_HOST', 'localhost') port = settings.getint('TRACKER_RADIS_PORT', 6379) db = settings.getint('TRACKER_RADIS_DB', 0) password = settings.get('TRACKER_RADIS_PASSWORD', None) self._redis = StrictRedis(host, port, db, password=password) drop_all_keys = settings.getbool('TRACKER_RADIS_FLUSH_DB', False) if drop_all_keys: self._redis.flushdb() def getset(self, key, checksum): return self._redis.getset(key, checksum)
class redisUtil: def __init__(self): self.redis = StrictRedis(host='localhost', port=6379, db=0) def setValue(self, key, value): self.redis.set(key, value) def getValue(self, key): result = self.redis.get(key) if (result == None): return result return self.redis.get(key).decode() def getDbSize(self): return self.redis.dbsize() def updateAndReturn(self, key, value): return self.redis.getset(key, value) def delete(self, key): return self.redis.delete(key)
# 移动key 到其他的数据库 redis.move('name',2) # 2为数据库代号 # 删除当前选择数据库数据 redis.flushdb() # 删除所有数据库数据 redis.flushall() # ------- string 相关 -------- # 给 key 赋予新 value 并返回原本 value print(redis.getset('name', 'Jerry')) # 返回多个 key 的 value print(redis.mget(['name', 'nikename'])) # 如果 key 不存在就创建键值对, 否则保持不变 redis.setnx('newname', 'James') # 给 key 赋值, 并且设置过期时间. 单位为秒 redis.setex('name', 1, 'James') # 在 string value 中指定的位置插入文本内容, offset 为偏移量
class RedisConn(object): """docstring for RedisConn""" def __init__(self, startup_nodes=None, host="localhost", port=6379, db=0, password=None, encoding='utf-8', socket_keepalive=False, connection_pool=None, max_connections=None, project="", decode_responses=True, **kwargs): if project: project = f'{project}:' self.cluster_flag = False self.project = project if startup_nodes: from rediscluster import StrictRedisCluster if isinstance(startup_nodes, (str, bytes)): startup_nodes = _normalize_startup_nodes(startup_nodes) self._redis = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=decode_responses, skip_full_coverage_check=True, **kwargs) self.cluster_flag = True else: self._redis = StrictRedis(host=host, port=port, db=db, password=password, socket_keepalive=socket_keepalive, connection_pool=connection_pool, max_connections=max_connections, **kwargs) def add_head(self, key): return f'{self.project}{key}' def format_key(): def make_wrapper(func): def wrapper(self, key, *args, **kwargs): new_key = self.add_head(key) return func(self, new_key, *args, **kwargs) return wrapper return make_wrapper def format_key_keys(): def make_wrapper(func): def wrapper(self, key, keys, *args, **kwargs): new_key = self.add_head(key) new_keys = list(map(self.add_head, keys)) return func(self, new_key, new_keys, *args, **kwargs) return wrapper return make_wrapper def format_args(): def make_wrapper(func): def wrapper(self, *args, **kwargs): new_args = list(map(self.add_head, list(args))) return func(self, *new_args, **kwargs) return wrapper return make_wrapper def format_two_key(): def make_wrapper(func): def wrapper(self, src, dst, *args, **kwargs): new_src = self.add_head(src) new_dst = self.add_head(dst) return func(self, new_src, new_dst, *args, **kwargs) return wrapper return make_wrapper def format_keys(): def make_wrapper(func): def wrapper(self, keys, *args): new_keys = list(map(self.add_head, keys)) return func(self, new_keys, *args) return wrapper return make_wrapper def format_dicts(): def make_wrapper(func): def wrapper(self, mapping, *args): new_mapping = {} for key in mapping.keys(): new_key = self.add_head(key) new_mapping[new_key] = mapping[key] return func(self, new_mapping, *args) return wrapper return make_wrapper @format_args() def unlink(self, *keys): """ time complexity O(1) redis异步删除keys """ return self._redis.unlink(*keys) def pipeline(self, transaction=True, shard_hint=None): """ 返回一个pipe对象 """ return self._redis.pipeline(transaction, shard_hint) """===============================string-start==========================""" # } @format_key() def set(self, key, value, ex=None, px=None, nx=False, xx=False): """ time complexity O(1) Set the value at key ``key`` to ``value`` Arguments: key (str): key key value (str): key value ex(int): 过期时间(秒) px(int): 过期时间(豪秒) nx(bool): 如果设置为True,则只有key不存在时,当前set操作才执行(新建) xx(bool): 如果设置为True,则只有key存在时,当前set操作才执行 (修改) Returns: result(bool): 是否成功成功是True失败可能是None """ return self._redis.set(key, value, ex, px, nx, xx) @format_key() def get(self, key): """ time complexity O(1) Return the value at ``key``, or None if the key doesn't exist Arguments: key (str): key Returns: value (str):返回value """ return self._redis.get(key) @format_key() def getset(self, key, value): """ time complexity O(1) 设置新值并获取原来的值 """ return self._redis.getset(key, value) @format_key() def strlen(self, key): """ time complexity O(1) 获得key对应的value长度 """ return self._redis.strlen(key) @format_key() def getrange(self, key, start, end): """ time complexity O(1) 获得key对应的value的start到end长度字符返回 """ return self._redis.getrange(key, start, end) @format_key() def setrange(self, key, offset, value): """ time complexity O(1) 设置key对应的value从offset地方用新value替换 """ return self._redis.setrange(key, offset, value) @format_key() def setbit(self, key, offset, value): """ time complexity O(1) value值只能是1或0 设置key对应的value二进制在offset位用value替换 """ return self._redis.setbit(key, offset, value) @format_key() def getbit(self, key, offset): """ time complexity O(1) 获取key对应的value二进制在offset位的值 """ return self._redis.getbit(key, offset) @format_key() def expire(self, key, time): """ time complexity O(1) 设置key的过期时间s """ return self._redis.expire(key, time) @format_key() def pexpire(self, key, time): """ time complexity O(1) 设置key的过期时间ms """ return self._redis.pexpire(key, time) @format_key() def pexpireat(self, key, when): """ time complexity O(1) 设置key的过期时间(在什么时候过期) when是uninx的时间戳ms """ return self._redis.pexpireat(key, when) @format_key() def pttl(self, key): """ time complexity O(1) 获得key过期时间(ms),没有设置过期时间返回-1 """ return self._redis.pttl(key) @format_key() def ttl(self, key): """ time complexity O(1) 获得name过期时间(s),没有设置过期时间返回-1 """ return self._redis.ttl(key) @format_dicts() def mset(self, mapping): """ time complexity O(n) Arguments: mapping (dict): {name: value,name1: value1} Returns: return ok """ return self._redis.mset(mapping) @format_dicts() def msetnx(self, mapping): """ time complexity O(n) Arguments: mapping (dict): {name: value,name1: value1} Returns: return (bool): 与mset区别是指定的key中有任意一个已存在,则不进行任何操作,返回错误 """ return self._redis.msetnx(mapping) @format_keys() def mget(self, keys, *args): """ time complexity O(n) Arguments: keys (list): [name, name1] Returns: return (list): 返回对应keys的value, name在数据库不存在返回None Mind!: 一次性取多个key确实比get提高了性能,但是mget的时间复杂度O(n), 实际使用过程中测试当key的数量到大于100之后性能会急剧下降, 建议mget每次key数量不要超过100。在使用前根据实列的redis吞吐量可能会不一样。 """ return self._redis.mget(keys, *args) @format_key() def incr(self, key, amount=1): """ time complexity O(1) 将key对应的value值自增amount,并返回自增后的值。只对可以转换为整型的String数据起作用。 用于统计sql型数据库大表里面的数据量 """ return self._redis.incr(key, amount) @format_key() def incrbyfloat(self, key, amount=1.0): """ time complexity O(1) amount 可以为负数代表减法 将key对应的value值自增amount,并返回自增后的值。只对可以转换为float的String数据起作用。 用于统计sql型数据库大表里面的数据量 """ return self._redis.incrbyfloat(key, amount) @format_key() def decr(self, key, amount=1): """ time complexity O(1) 将key对应的value值自减amount,并返回自减后的值。只对可以转换为整型的String数据起作用。 用于统计sql型数据库大表里面的数据量 """ return self._redis.decr(key, amount) def keys(self, pattern='*'): """ time complexity O(n) 获取匹配pattern的所有key.实际项目中慎用 """ return self._redis.keys(pattern) @format_key() def move(self, key, db): """ time complexity O(1) 移动key到其他db """ return self._redis.move(key, db) def randomkey(self): """ time complexity O(1) 随机返回一个key """ return self._redis.randomkey() @format_args() def rename(self, src, dst): """ time complexity O(1) 重命名key src to dst """ return self._redis.rename(src, dst) @format_args() def exists(self, *keys): """ time complexity O(1) 查看keys是否存在返回存在的key数量 """ return self._redis.exists(*keys) @format_args() def delete(self, *keys): """ time complexity O(1) 删除keys """ return self._redis.delete(*keys) @format_key() def type(self, key): """ time complexity O(1) 查看key对应value类型 """ return self._redis.type(key) # { """===============================string-end============================""" """===============================list-start============================""" # } @format_keys() def blpop(self, keys, timeout=0): """ 如果keys里面有list为空要求整个服务器被阻塞以保证块执行时的原子性, 该行为阻止了其他客户端执行 LPUSH 或 RPUSH 命令 阻塞的一个命令,用来做轮询和会话配合使用 Arguments: keys(list): [keys, keys] timeout(int): S """ return self._redis.blpop(keys, timeout) @format_keys() def brpop(self, keys, timeout=0): """ 同上,取数据的方向不同 """ return self._redis.brpop(keys, timeout) @format_two_key() def brpoplpush(self, src, dst, timeout=0): """ 从src表尾取一个数据插入dst表头。同上src为空阻塞 """ return self._redis.brpoplpush(src, dst, timeout) @format_key() def lpush(self, key, *values): """ time complexity O(n) Set the value at key ``key`` to ``value`` Arguments: key (str): key key value (list): key value Returns: result(int): 插入成功之后list长度 """ return self._redis.lpush(key, *values) @format_key() def lpushx(self, key, *values): """ time complexity O(n) only key not exists Arguments: key (str): key value (list): key value Returns: result(int): 插入成功之后list长度 """ return self._redis.lpushx(key, *values) @format_key() def lpop(self, key): """ time complexity O(1) 移除并返回列表 key 的头元素。 """ return self._redis.lpop(key) @format_key() def rpush(self, key, *values): """ time complexity O(n) Set the value at key ``key`` to ``value`` Arguments: key (str): key key value (list): key value Returns: result(int): 插入成功之后list长度 """ return self._redis.rpush(key, *values) @format_key() def rpushx(self, key, *values): """ time complexity O(n) only key not exists Arguments: key (str): key value (list): key value Returns: result(int): 插入成功之后list长度 """ return self._redis.rpushx(key, *values) @format_key() def rpop(self, key): """ time complexity O(1) 移除并返回列表 key尾元素。 """ return self._redis.rpop(key) @format_key() def lrange(self, key, start, end): """ time complexity O(n) 获取list数据包含start,end.在不清楚list的情况下尽量不要使用lrange(key, 0, -1)操作 应尽可能控制一次获取的元素数量 """ return self._redis.lrange(key, start, end) @format_args() def rpoplpush(self, src, dst): """ 从src表尾取一个数据插入dst表头 """ return self._redis.rpoplpush(src, dst) @format_key() def llen(self, key): """ time complexity O(1) 获取list长度,如果key不存在返回0,如果key不是list类型返回错误 """ return self._redis.llen(key) @format_key() def lindex(self, key, index): """ time complexity O(n) n为经过的元素数量 返回key对应list的index位置的value """ return self._redis.lindex(key, index) @format_key() def linsert(self, key, where, refvalue, value): """ time complexity O(n) n为经过的元素数量 key或者refvalue不存在就不进行操作 Arguments: where(str): BEFORE|AFTER 后|前 refvalue(str): list里面的值 """ return self._redis.linsert(key, where, refvalue, value) @format_key() def lrem(self, key, count, value): """ time complexity O(n) 删除count数量的value Arguments: count(int): count>0 表头开始搜索 count<0 表尾开始搜索 count=0 删除所有与value相等的数值 Returns: result(int): 删除的value的数量 """ if self.cluster_flag: return self._redis.lrem(key, value, count) return self._redis.lrem(key, count, value) @format_key() def lset(self, key, index, value): """ time complexity O(n) 设置list的index位置的值,没有key和超出返回错误 """ return self._redis.lset(key, index, value) @format_key() def ltrim(self, key, start, end): """ time complexity O(n) n为被删除的元素数量 裁剪让列表只保留指定区间内的元素,不在指定区间之内的元素都将被删除。 """ return self._redis.ltrim(key, start, end) @format_key() def sort(self, key, start=None, num=None, by=None, get=None, desc=False, alpha=False, store=None, groups=False): """ time complexity O(n) O(N+M*log(M)), N 为要排序的列表或集合内的元素数量, M 为要返回的元素数量。 删除count数量的value Arguments: by(str): 让排序按照外部条件排序, 可以先将权重插入redis然后再作为条件进行排序如(user_level_*) get(str): redis有一组user_name_*然后*是按照list里面的值, 按照排序取一个个key的value store(str): 保留sort之后的结果,可以设置expire过期时间作为结果缓存 alpha: 按照字符排序 desc: 逆序 Returns: result(list): 排序之后的list """ return self._redis.sort(key, start, num, by, get, desc, alpha, store, groups) def scan(self, cursor=0, match=None, count=None): """ time complexity O(1) 单次 增量迭代返回redis数据库里面的key,因为是增量迭代过程中返回可能会出现重复 Arguments: cursor(int): 游标 match(str): 匹配 count(int): 每次返回的key数量 Returns: result(set): 第一个是下次scan的游标,后面是返回的keys(list)当返回的游标为0代表遍历完整个redis """ return self._redis.scan(cursor, match, count) # { """===============================list-end====================================""" """===============================hash-start===================================""" # } @format_key() def hdel(self, key, *names): """ time complexity O(n) n为names长度 Return the value at ``key``, or None if the key doesn't exist Arguments: key (str): key names(list): hash里面的域 Returns: result (int): 成功删除的个数 """ return self._redis.hdel(key, *names) @format_key() def hexists(self, key, name): """ time complexity O(1) 判断key中是否有name域 """ return self._redis.hexists(key, name) @format_key() def hget(self, key, name): """ time complexity O(1) """ return self._redis.hget(key, name) @format_key() def hgetall(self, key): """ time complexity O(n) """ return self._redis.hgetall(key) @format_key() def hincrby(self, key, name, amount=1): """ time complexity O(1) amount可以为负数,且value值为整数才能使用否则返回错误 """ return self._redis.hincrby(key, name, amount) @format_key() def hincrbyfloat(self, key, name, amount=1.0): """ time complexity O(1) """ return self._redis.hincrbyfloat(key, name, amount) @format_key() def hkeys(self, key): """ time complexity O(n) """ return self._redis.hkeys(key) @format_key() def hlen(self, key): """ time complexity O(1) """ return self._redis.hlen(key) @format_key() def hset(self, key, name, value): """ time complexity O(1) """ return self._redis.hset(key, name, value) @format_key() def hsetnx(self, key, name, value): """ time complexity O(1) """ return self._redis.hsetnx(key, name, value) @format_key() def hmset(self, key, mapping): """ time complexity O(n) """ return self._redis.hmset(key, mapping) @format_key() def hmget(self, key, names, *args): """ time complexity O(n) """ return self._redis.hmget(key, names, *args) @format_key() def hvals(self, key): """ time complexity O(n) 返回hash表所有的value """ return self._redis.hvals(key) @format_key() def hstrlen(self, key, name): """ time complexity O(1) """ return self._redis.hstrlen(key, name) # { """=================================hash-end===================================""" """=================================set-start=================================""" # } @format_key() def sadd(self, key, *values): """ time complexity O(n) n为values长度 """ return self._redis.sadd(key, *values) @format_key() def scard(self, key): """ time complexity O(n) set长度 返回set大小 """ return self._redis.scard(key) @format_args() def sdiff(self, key, *args): """ time complexity O(n) N 是所有给定集合的成员数量之和 返回差集成员的列表。 """ return self._redis.sdiff(key, *args) @format_args() def sdiffstore(self, dest, keys, *args): """ time complexity O(n) N 是所有给定集合的成员数量之和 返回差集成员的数量。并将结果保存到dest这个set里面 """ return self._redis.sdiffstore(dest, keys, *args) @format_args() def sinter(self, key, *args): """ time complexity O(N * M), N 为给定集合当中基数最小的集合, M 为给定集合的个数。 返回交集数据的list """ return self._redis.sinter(key, *args) @format_args() def sinterstore(self, dest, keys, *args): """ time complexity O(n) N 是所有给定集合的成员数量之和 返回交集成员的数量。并将结果保存到dest这个set里面 """ return self._redis.sinterstore(dest, keys, *args) @format_key() def sismember(self, key, name): """ time complexity O(1) 判断name是否在key中 """ return self._redis.sismember(key, name) @format_key() def smembers(self, key): """ time complexity O(n) 返回set里面所有成员 """ return self._redis.smembers(key) @format_two_key() def smove(self, src, dst, value): """ time complexity O(1) 将value从src移动到dst原子性操作 """ return self._redis.smove(src, dst, value) @format_key() def spop(self, key, count=None): """ time complexity O(n) n 默认随机删除一条, 删除count条 """ return self._redis.spop(key, count) @format_key() def srandmember(self, key, number=None): """ time complexity O(n) n 默认随机返回一条, 返回number条 """ return self._redis.srandmember(key, number) @format_key() def srem(self, key, *values): """ time complexity O(n) n为values长度 移除key里面values """ return self._redis.srem(key, *values) @format_args() def sunion(self, keys, *args): """ time complexity O(N), N 是所有给定集合的成员数量之和 返回并集 """ return self._redis.sunion(keys, *args) @format_args() def sunionstore(self, dest, keys, *args): """ time complexity O(N), N 是所有给定集合的成员数量之和。 求并集并保存 """ return self._redis.sunionstore(dest, keys, *args) @format_key() def sscan(self, key, cursor=0, match=None, count=None): """ time complexity O(1) 同scan只是这个是set使用 """ return self._redis.sscan(key, cursor, match, count) # { """==================================set-end==================================""" """===============================SortedSet-start=============================""" # } @format_key() def zadd(self, key, mapping, nx=False, xx=False, ch=False, incr=False): """ time complexity O(M*log(N)), N 是有序集的基数, M 为成功添加的新成员的数量。 Arguments: mapping(dict): (value:score) XX(bool): 仅仅更新存在的成员,不添加新成员。 NX(bool): 不更新存在的成员。只添加新成员。 CH(bool): 修改返回值为发生变化的成员总数,原始是返回新添加成员的总数 (CH 是 changed 的意思)。 更改的元素是新添加的成员,已经存在的成员更新分数。 所以在命令中指定的成员有相同的分数将不被计算在内。 注:在通常情况下,ZADD返回值只计算新添加成员的数量。 INCR(bool): 当ZADD指定这个选项时,成员的操作就等同ZINCRBY命令,对成员的分数进行递增操作。 Returns: result(int): 成功插入数量 """ if self.cluster_flag: return self._redis.zadd(key, **mapping) return self._redis.zadd(key, mapping, nx, xx, ch, incr) @format_key() def zcard(self, key): """ time complexity O(1) 返回zset()基数 """ return self._redis.zcard(key) @format_key() def zcount(self, key, minz, maxz): """ time complexity O(log(N)), N 为有序集的基数。 返回score在min和max之间的value的个数 """ return self._redis.zcount(key, minz, maxz) @format_key() def zincrby(self, key, amount, value): """ time complexity O(log(N)), N 为有序集的基数。 amount 可以为负数 """ if self.cluster_flag: return self._redis.zincrby(key, value, amount) return self._redis.zincrby(key, amount, value) @format_key_keys() def zinterstore(self, dest, keys, aggregate=None): """ time complexity O(N*K)+O(M*log(M)), N 为给定 key 中基数最小的有序集, K 为给定有序集的数量, M 为结果集的基数。 求交集并按照aggregate做处理之后保存到dest。默认是求和 Arguments: aggregate(str):sum 和, min 最小值, max 最大值 返回新zset里面的value个数 """ return self._redis.zinterstore(dest, keys, aggregate) @format_key() def zrange(self, key, start, end, desc=False, withscores=False, score_cast_func=float): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 Arguments: start,有序集合索引起始位置(非分数) end,有序集合索引结束位置(非分数) desc,排序规则,默认按照分数从小到大排序 withscores,是否获取元素的分数,默认只获取元素的值 score_cast_func,对分数进行数据转换的函数 """ return self._redis.zrange(key, start, end, desc, withscores, score_cast_func) @format_key() def zrevrange(self, key, start, end, withscores=False, score_cast_func=float): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 Arguments: start,有序集合索引起始位置(非分数) end,有序集合索引结束位置(非分数) withscores,是否获取元素的分数,默认只获取元素的值 score_cast_func,对分数进行数据转换的函数 """ return self._redis.zrevrange(key, start, end, withscores, score_cast_func) @format_key() def zrangebyscore(self, key, minz, maxz, start=None, num=None, withscores=False, score_cast_func=float): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 有序集成员按 score 值递增(从小到大)次序排列。 """ return self._redis.zrangebyscore(key, minz, maxz, start, num, withscores, score_cast_func) @format_key() def zrevrangebyscore(self, key, minz, maxz, start=None, num=None, withscores=False, score_cast_func=float): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 有序集成员按 score 值递减(从大到小)次序排列。 """ return self._redis.zrevrangebyscore(key, minz, maxz, start, num, withscores, score_cast_func) @format_key() def zrangebylex(self, key, minz, maxz, start=None, num=None): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 有序集成员按 value 字典序递增(从小到大)次序排列。 """ return self._redis.zrangebylex(key, minz, maxz, start, num) @format_key() def zrevrangebylex(self, key, minz, maxz, start=None, num=None): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为结果集的基数。 有序集成员按 value 字典序递减(从大到小)次序排列。 """ return self._redis.zrevrangebylex(key, minz, maxz, start, num) @format_key() def zrank(self, key, value): """ time complexity O(log(N)) 查找zset里面这个value的rank排名从0开始 """ return self._redis.zrank(key, value) @format_key() def zrevrank(self, key, value): """ time complexity O(log(N)) 查找zset里面这个value的rank排名从0开始 """ return self._redis.zrevrank(key, value) @format_key() def zrem(self, key, *values): """ time complexity O(M*log(N)), N 为有序集的基数, M 为被成功移除的成员的数量 删除zset里面单个或者多个成员 """ return self._redis.zrem(key, *values) @format_key() def zremrangebylex(self, key, minz, maxz): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为被移除成员的数量。 按照字典增序范围删除 """ return self._redis.zremrangebylex(key, minz, maxz) @format_key() def zremrangebyrank(self, key, minz, maxz): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为被移除成员的数量。 按照rank范围删除 """ return self._redis.zremrangebyrank(key, minz, maxz) @format_key() def zremrangebyscore(self, key, minz, maxz): """ time complexity O(log(N)+M), N 为有序集的基数,而 M 为被移除成员的数量。 按照score范围删除 """ return self._redis.zremrangebyscore(key, minz, maxz) @format_key() def zscore(self, key, value): """ time complexity O(log(N)) 查找zset里面这个value的score排名从0开始 """ return self._redis.zscore(key, value) @format_key_keys() def zunionstore(self, dest, keys, aggregate=None): """ time complexity O(N)+O(M log(M)), N 为给定有序集基数的总和, M 为结果集的基数。 求并集保存 """ return self._redis.zunionstore(dest, keys, aggregate) @format_key() def zscan(self, key, cursor=0, match=None, count=None, score_cast_func=float): """ time complexity O(1) 同SCAN """ return self._redis.zscan(key, cursor, match, count, score_cast_func) def zlexcount(self, key, minz, maxz): """ time complexity O(log(N)),其中 N 为有序集合包含的元素数量。 min -负无限 [闭空间不包括自己 (开空间包括自己 max +正无限 [a, (c """ return self._redis.zlexcount(key, minz, maxz) # { """===============================SortedSet-end=================================""" """===============================HyperLogLog-start===============================""" # } @format_key() def pfadd(self, key, *values): """ time complexity O(n) """ return self._redis.pfadd(key, *values) @format_args() def pfcount(self, *sources): """ time complexity O(1) 计算key的基数 """ return self._redis.pfcount(*sources) @format_args() def pfmerge(self, dest, *sources): """ time complexity O(n) 其中 N 为被合并的 HyperLogLog 数量,不过这个命令的常数复杂度比较高 合并HyperLogLog """ return self._redis.pfmerge(dest, *sources) # { """===============================HyperLogLog-end=================================""" """==================================GEO-start====================================""" # } @format_key() def geoadd(self, key, *values): """ time complexity O(log(N)) 每添加一个元素的复杂度为 O(log(N)) , 其中 N 为键里面包含的位置元素数量。 """ return self._redis.geoadd(key, *values) @format_key() def geopos(self, key, *values): """ time complexity O(log(N)) 从键里面返回所有给定位置元素的位置(经度和纬度)。 """ return self._redis.geopos(key, *values) @format_key() def geohash(self, key, *values): """ time complexity O(log(N)) 命令返回的 geohash 的位置与用户给定的位置元素的位置一一对应 """ return self._redis.geohash(key, *values) @format_key() def geodist(self, key, place1, place2, unit=None): """ time complexity O(log(N)) 返回两个给定位置之间的距离。 Argument: unit : m: 米,km: 千米,mi: 英里,ft: 英尺 """ return self._redis.geodist(key, place1, place2, unit) @format_key() def georadius(self, key, longitude, latitude, radius, unit=None, withdist=False, withcoord=False, withhash=False, count=None, sort=None, store=None, store_dist=None): """ time complexity O(N+log(M)), 其中 N 为指定半径范围内的位置元素数量, 而 M 则是被返回位置元素的数量。 以给定的经纬度为中心, 返回键包含的位置元素当中, 与中心的距离不超过给定最大距离的所有位置元素。 Argument: longitude: 经度 latitude: 纬度 radius: 距离 unit: 距离单位 withdist: 在返回位置元素的同时, 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。 withcoord: 将位置元素的经度和维度也一并返回 withhash: 以 52 位有符号整数的形式, 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试, 实际中的作用并不大。 sort: 根据中心的位置排序 ASC,DESC count: 取前多少个 store: 保存 store_dist: 存储地名和距离 Return: list(list) [['Foshan', 109.4922], ['Guangzhou', 105.8065]] """ return self._redis.georadius(key, longitude, latitude, radius, unit, withdist, withcoord, withhash, count, sort, store, store_dist) @format_key() def georadiusbymember(self, key, member, radius, unit=None, withdist=False, withcoord=False, withhash=False, count=None, sort=None, store=None, store_dist=None): """ time complexity O(N+log(M)), 其中 N 为指定半径范围内的位置元素数量, 而 M 则是被返回位置元素的数量。 以给定的经纬度为中心, 返回键包含的位置元素当中, 与中心的距离不超过给定最大距离的所有位置元素。 Argument: member: 位置元素 radius: 距离 unit: 距离单位 withdist: 在返回位置元素的同时, 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。 withcoord: 将位置元素的经度和维度也一并返回 withhash: 以 52 位有符号整数的形式, 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试, 实际中的作用并不大。 sort: 根据中心的位置排序 ASC,DESC count: 取前多少个 store: 保存 store_dist: 存储地名和距离 Return: list(list) [['Foshan', 109.4922], ['Guangzhou', 105.8065]] """ return self._redis.georadiusbymember(key, member, radius, unit, withdist, withcoord, withhash, count, sort, store, store_dist) # { """==================================GEO-end======================================"""
# redis = StrictRedis(host='localhost',port=6379) # redis.set('name','Bob') # print(redis.get('a')) url = 'redis://:@localhost:6379' pool = ConnectionPool.from_url(url) redis = StrictRedis(connection_pool=pool) # 字符串 redis.set('name','Bob') print(redis.get('name')) print(redis.type('a')) print(redis.get(redis.randomkey())) print(redis.getset('name','Mike')) print(redis.get('name')) #列表 print(redis.rpush('list',1,2,3,4,5,6,7,8,9)) print(redis.lindex('list',3)) #集合 print(redis.sadd('set',1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9)) print(redis.scard('set')) #有序集合 print(redis.zadd('grade',100,'Bob','88','Mike')) print(redis.zrank('grade','Bob')) #Hash
# coding=utf-8 from redis import StrictRedis redis = StrictRedis(password='******') # 字符串操作 # 给数据库中键名为name的string赋予值value print(redis.set('name', 'jason')) # 返回数据库中键名为name的string的value print(redis.get('name')) # 给数据库中键名name的string赋予值value并返回上一次的value print(redis.getset('name', 'sam')) # 返回多个键对应的value组成的列表 print(redis.mget(['name', 'nickname'])) # 如果不存在这个键值对,则更新value,否则不变 print(redis.setnx('newname', 'Tom'))
print(redis.randomkey()) #获取一个随机的键 print(redis.rename('name', 'nickname')) print(redis.dbsize()) #获取当前数据键数 print(redis.expire('nickname', 60)) print(redis.ttl('nickname')) print(redis.move('nickname', 1)) print(redis.flushdb()) #清空当前数据库中的键 print(redis.flushall()) #清空所有数据库中的键 # 3.字符串操作 print() print(redis.set('emotion', 'smile')) redis.set('name', 'Leo') redis.set('age', '19') print(redis.get('emotion')) print(redis.getset('emotion', 'humour')) print(redis.mget(['emotion', 'name', 'age'])) print(redis.setnx('newname', 'James')) # 不存在键才更新 print(redis.setex('country', 1, 'china')) redis.setrange('name', 3, '2019') print(redis.get('name')) print(redis.mset({'name1': 'Modric', 'name2': 'Van Dik'})) print(redis.msetnx({'name3': 'Salah', 'name4': 'Mane'})) #键均不存在才批量更新 print(redis.incr('age', 1)) print(redis.decr('age', 1)) print(redis.append('name', 'ooo')) print(redis.substr('name', 1, 4)) print(redis.getrange('name', 0, 3)) # 4.列表操作 print(redis.rpush('list', 1, 2, 3, 4, 5))
# Make parser.py work with airmsc.models # (do not move import at the beginning of file!) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "airmsc.settings") path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) if path not in sys.path: sys.path.append(path) django.setup() from airmsc_main.models import Member, MemberData Q = Queue(connection=Redis()) r = StrictRedis() r.setnx("sent_today", 0) if r.exists("today"): old_date = r.getset("today", str(datetime.date.today())) else: r.set("today", str(datetime.date.today())) old_date = "" if old_date != datetime.date.today(): r.set("sent_today", 0) STATIONS_LINKS = [ ("Мещанский", "http://mosecom.ru/air/air-today/station/suhar/table.html", "meschansky"), ("Басманный (Казакова)", "http://mosecom.ru/air/air-today/station/kazak/table.html", "basmanniykazakova"), ("Пресненский", "http://mosecom.ru/air/air-today/station/spirid/table.html", "presnenskiy"), ( "Басманный (Спартаковская)", "http://mosecom.ru/air/air-today/station/spartakovskaya/table.html", "basmanniyspartak", ),
from redis import StrictRedis host = '' pwd = '' redis = StrictRedis(host=host, port=6379, db=3, password=pwd) redis.set('name', 'Bob') print(redis.get('name')) print(redis.getset('name', 'Micheal'))
redis = StrictRedis(connection_pool=pool) # 使用url方式连接到数据库 pool = ConnectionPool.from_url('redis://@localhost:6379/1') redis = StrictRedis(connection_pool=pool) # 构造url方式连接到数据库,有以下三种模式: redis://[:password]@host:port/db # TCP连接 rediss://[:password]@host:port/db # Redis TCP+SSL 连接 unix://[:password]@/path/to/socket.sock?db=db # Redis Unix Socket 连接 \String操作 方法 作用 示例 示例结果 set(name, value) 给name赋值为value redis.set('name', 'Bob') True get(name) 返回数据库中key为name的string的value redis.get('name') b'Bob' getset(name, value) 给数据库中key为name的string赋予值value并返回上次的value redis.getset('name', 'Mike') b'Bob' mget(keys, *args) 返回多个key对应的value redis.mget(['name', 'nickname']) [b'Mike', b'Miker'] setnx(name, value) 如果key不存在才设置value redis.setnx('newname', 'James') 第一次运行True,第二次False setex(name, time, value) 设置可以对应的值为string类型的value,并指定此键值对应的有效期 redis.setex('name', 1, 'James') True setrange(name, offset, value) 设置指定key的value值的子字符串 redis.set('name', 'Hello') redis.setrange('name', 6, 'World') 11,修改后的字符串长度 mset(mapping) 批量赋值 redis.mset({'name1': 'Durant', 'name2': 'James'}) True msetnx(mapping) key均不存在时才批量赋值 redis.msetnx({'name3': 'Smith', 'name4': 'Curry'}) True incr(name, amount=1) key为name的value增值操作,默认1,key不存在则被创建并设为amount redis.incr('age', 1) 1,即修改后的值 decr(name, amount=1) key为name的value减值操作,默认1,key不存在则被创建并设置为-amount redis.decr('age', 1) -1,即修改后的值 append(key, value) key为name的string的值附加value redis.append('nickname', 'OK') 13,即修改后的字符串长度 substr(name, start, end=-1) 返回key为name的string的value的子串 redis.substr('name', 1, 4) b'ello' getrange(key, start, end) 获取key的value值从start到end的子字符串 redis.getrange('name', 1, 4) b'ello' # 源码 def set(self, name, value, ex=None, px=None, nx=False, xx=False): """
# 重命名键名 print(redis.rename('name', 'nickname')) # 获取键的数目 print(redis.dbsize()) # 设定键的过期时间 单位 秒 # print(redis.expire('nickname', 2)) # 获取键的过期时间 print(redis.ttl('nickname')) # 键移动数据库 不要设置过期时间 否则 =来不及=move # print(redis.move('nickname', 1)) # 删除当前数据库所有键值 # print(redis.flushdb()) # 删除所有数据库所有键 # print(redis.flushall()) # 给赋值 并且返回原来的值 print(redis.getset('nickname', 'newname')) # 返回多个键值对应的value print(redis.mget(['nickname', 'name2'])) # 批量赋值 print(redis.mset({'n': 1, 'x': 2})) # 如果键不存在就设置值 否则不设置值 (只新增 不更新)第二条不起作用 print(redis.setnx('ni', 'wo')) print(redis.setnx('ni', '2')) # 如果键不存在就设置值 否则不设置值 (只新增 不更新)第二条不起作用 批量 print(redis.msetnx({'nix': 1, 'wox': 2})) print(redis.msetnx({'nix': 3, 'wox': 4})) # 设置键的值以及过期时间 可以新增以及更新 print(redis.setex('wo', 120, 'Lucy')) # 往value插入字符串 如果字符不存在会新建 如果位置不存在 会为空类型变成binary 如果是0就可以 print(redis.setrange('ni', 2, 'hao')) print(redis.setrange('nini', 2, 'hao'))
redis.expire('name', 2) # 获取键的过期时间 -1表示永远不过期 redis.ttl('name') # 将键移动到其他数据库 移动到2号数据库 redis.move('name', 2) # 删除当前选择数据库中所有的键 redis.flushdb() # 删除所有数据库中的所有键 redis.flushall() """字符串操作""" # 设值 redis.set('age', 20) # 取值 redis.get('age') # 设置新值 返回旧值 redis.getset('name', 'newValue') # 返回多个键对应的值 redis.mget(['name', 'nikename']) # 如果不存在这个键值对 则更新value 否则不变 redis.setnx('newname', 'heihei') # 设值饼设值有效期 redis.setex('name', 1, 'James') # 设值指定键的value 的子字符串 redis.set('name', 'Hello') redis.setrange('name', 6, 'World') # 批量赋值 redis.mset({'name1': 'Smith', 'name2': 'Curry'}) # 键都不存在时才批量赋值 redis.msetnx({'name3': 'Smith', 'name4': 'Curry'}) # 增操作 redis.incr('age', 1)
class RedisOp: def __init__(self, obj, data_base_config): # if hasattr(obj, "Log") and obj.Log.get("output_console", True): # self.log = Logger(level="info") # else: # self.log = None self.log = obj.log if hasattr(obj, "log") else None self.host = data_base_config["host"] self.port = data_base_config["port"] self.user = data_base_config["user"] self.password = data_base_config["password"] self.db = data_base_config["database"] self.charset = data_base_config.get("charset", "UTF-8") self.decode_responses = data_base_config.get("decode_responses", True) self.pool = ConnectionPool(host=self.host, port=self.port, password=self.password, db=self.db, decode_responses=self.decode_responses) # 获取连接 self.connection = StrictRedis(connection_pool=self.pool) def close(self): # 关闭连接池所有连接,PS:慎用 self.connection.connection_pool.disconnect() """ string 类型 redis 操作:{"key": "value"} """ @log_wrapper def set(self, key, value, time=None): """ 单条插入 key_value :param key: :param value: :param time: 单位为秒 :return: """ if isinstance(value, dict): value = json.dumps(value, ensure_ascii=False) if time: ret = self.connection.setex(key, time, value) else: ret = self.connection.set(key, value) return ret @log_wrapper def setnx(self, key, value): """ key 不存在时 插入数据 :param key: :param value: :return: """ return self.connection.setnx(key, value) @log_wrapper def psetex(self, name, time_ms, value): """ 插入含过期时间的 key_value :param name: :param time_ms: 单位为毫秒 :param value: :return: """ return self.connection.psetex(name, time_ms, value) @log_wrapper def mset(self, key_value_dict): """ 批量插入 key_value :param key_value_dict: :return: """ for key, value in key_value_dict.items(): if isinstance(value, dict): key_value_dict[key] = json.dumps(value, ensure_ascii=False) return self.connection.mset(key_value_dict) @log_wrapper def msetnx(self, key_value_dict): """ key 均不存在时才插入 :param key_value_dict: :return: """ return self.connection.msetnx(key_value_dict) @log_wrapper def get(self, key): """ 获取 key 的 value :param key: :return: """ return self.connection.get(key) @log_wrapper def mget(self, key_list): """ 回多个 key 对应的 value :param key_list: 格式为 列表 :return: """ return self.connection.mget(key_list) @log_wrapper def getset(self, key): """ 给数据库中 key 赋予值 value 并返回上次的 value :param key: :return: """ return self.connection.getset(key) @log_wrapper def keys(self, key): """ 获取所有符合规则的 key :param key: eg: "n*" :return: """ return self.connection.keys(key) """ redis key 操作 """ @log_wrapper def exists(self, key): """ 判断 key 是否存在 :param key: :return: """ return self.connection.exists(key) @log_wrapper def expire(self, key, time): """ 设定key的过期时间,单位秒 :param key: :param time: 单位秒 :return: """ return self.connection.expire(key, time) @log_wrapper def delete(self, key): """ 删除一个 key :param key: :return: """ return self.connection.delete(key) @log_wrapper def mdelete(self, key_list): """ 删除多个指定的 key :param key_list: :return: """ for key in key_list: self.connection.delete(key) """ hash 类型 redis 操作:{"name":{"key": "value"}} """ # TODO hash 类型 redis 操作 """