本文整理汇总了Python中redis.StrictRedis.zadd方法的典型用法代码示例。如果您正苦于以下问题:Python StrictRedis.zadd方法的具体用法?Python StrictRedis.zadd怎么用?Python StrictRedis.zadd使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类redis.StrictRedis
的用法示例。
在下文中一共展示了StrictRedis.zadd方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: zset_score_min_max_example
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def zset_score_min_max_example():
""" Example sorted set with min/max score pagination.
"""
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ZSetPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
# 97-114 is 'a' to 'r' in ASCII
for x in range(1, 18):
conn.zadd(key, x, chr(96 + x))
p = ZSetPaginator(conn, key, 2, score_min=5, score_max=13)
print(p.count) # 9
print(p.num_pages) # 5
print(p.page_range) # [1, 2, 3, 4, 5]
page = p.page(3)
print(page) # <Page 3 of 5>
print(page.object_list) # ['i', 'j']
conn.delete(key)
示例2: zset_example
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def zset_example():
""" Example sorted set pagination.
"""
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ZSetPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
# 97-114 is 'a' to 'r' in ASCII
for x in range(1, 18):
conn.zadd(key, x, chr(96 + x))
p = ZSetPaginator(conn, key, 6)
print(p.count) # 17
print(p.num_pages) # 3
print(p.page_range) # [1, 2, 3]
page = p.page(3)
print(page) # <Page 3 of 3>
print(page.object_list) # ['m', 'n', 'o', 'p', 'q']
conn.delete(key)
示例3: push
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def push(payload, ttl, priority, redis_host='localhost', redis_port=6379):
"""
Push a package to the queue
"""
connection = StrictRedis(host=redis_host, port=redis_port)
package = create_package_with_ttl(
payload=payload, ttl=float(ttl), score=float(priority))
connection.zadd(DEFAULT_REDIS_KEY, package.score, package.raw_entry)
connection.publish(DEFAULT_REDIS_KEY, 'new_message')
示例4: __init__
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class WordList:
def __init__(self):
self.conn = Redis()
self.CACHE_SIZE = 50
self.CACHE_KEYS = "words-keys"
self.CACHE_STORE = "words-store"
self.WORD_FILE = os.path.join(os.path.expanduser("~"), '.words.txt')
def _reorganize(self):
pop_n = self.conn.zcard(self.CACHE_KEYS) - self.CACHE_SIZE
if pop_n >= 0:
to_pop = self.conn.zrange(self.CACHE_KEYS, 0, pop_n)
#print pop_n, to_pop
self.conn.zremrangebyrank(self.CACHE_KEYS, 0, pop_n)
for k in to_pop:
self.conn.hdel(self.CACHE_STORE, k)
def _add_word(self, key, value):
result = self.conn.hget(self.CACHE_STORE, key)
if result:
self.conn.zincrby(self.CACHE_KEYS, key, 1.0)
else:
self._reorganize()
self.conn.hset(self.CACHE_STORE, key, value)
self.conn.zadd(self.CACHE_KEYS, 1, key)
def _get_words(self):
try:
words = self.conn.zrevrange(self.CACHE_KEYS, 0, -1, True)
#hashs = self.conn.hgetall(self.CACHE_STORE)
#print words
#print hashs
return words
except redis.exceptions.ConnectionError:
return None
def dump_console(self):
if os.path.isfile(self.WORD_FILE):
with open(self.WORD_FILE, 'r') as f:
print f.read()
def write_file(self):
words = self._get_words()
if words is None:
return
content = '\n'.join(["%d. %s\t %d"%(i, x[0], int(x[1])) for i, x in enumerate(words)])
with open(self.WORD_FILE, 'w+') as f:
f.write(content)
f.write('\n')
def add_word(self, key):
try:
self._add_word(key,key)
self.write_file()
except redis.exceptions.ConnectionError:
return
示例5: RedisDB
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisDB(object):
def __init__(self):
if not hasattr(RedisDB, 'pool'):
RedisDB.createPool()
self.r = StrictRedis(connection_pool = RedisDB.pool)
@staticmethod
def createPool():
RedisDB.pool = redis.ConnectionPool(
host = '127.0.0.1',
port = 6379,
db = 0
)
def saveToRedis(self, receiver, to_station_ab, to_station_name, from_station_ab, from_station_name, querydate, purpose_code, noticetime, publishtime):
'''将需要抓取的信息存入redis'''
uid = self.r.incr('uid')
tickets_info = {'uid':uid, 'receiver':receiver, 'to_station_ab':to_station_ab, 'to_station_name':to_station_name, 'from_station_ab':from_station_ab,'from_station_name':from_station_name, 'querydate':querydate, 'purpose_code':purpose_code, 'noticetime':noticetime, 'publishtime': publishtime}
self.r.zadd('email_que_set_all', uid, str(tickets_info))
if noticetime == '9am':
self.r.zadd('email_que_set_9am', uid, str(tickets_info))
elif noticetime == '11am':
self.r.zadd('email_que_set_11am', uid, str(tickets_info))
elif noticetime == '3pm':
self.r.zadd('email_que_set_3pm', uid, str(tickets_info))
elif noticetime == '5pm':
self.r.zadd('email_que_set_5pm', uid, str(tickets_info))
self.r.save()
def getStation(self, set, name):
return self.r.hget(set, name)
def zrevrange(self, set, begin, end):
return self.r.zrevrange(set, begin, end)
def zremrangebyscore(self, queue, uid):
return self.r.zremrangebyscore(queue, uid, uid)
def station_validate(self, form, field):
'''
表单tostation和tostation验证函数
'''
if not self.r.getStation(field.data):
raise ValidationError(u'木有这个站')
def saveJSONToSet(self, setName, json):
if not self.r.exists(setName):
for i, name in enumerate(json):
self.r.hset(setName, name, json[name])
print 'insert'+name
self.r.save()
else:
pass
示例6: _fill_fake_task
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def _fill_fake_task():
r = StrictRedis(host='127.0.0.1', port=6379, password='[email protected])')
for url in open('url.list'):
url = url.strip()
ret = urlparse(url)
domain = ret.netloc
task = {
'tid': str(uuid.uuid4()).replace('-', ''),
'method': 'GET',
'url': url
}
r.zadd('CQ:10001:%s' % domain, 1, json.dumps(task))
示例7: seed
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def seed(task):
priority = 5
if pattern.match(task['url']):
priority = 15
if task['url'].startswith('http://www.xiami.com/album/'):
priority = 16
if task['url'].startswith('http://www.xiami.com/artist/album/id/'):
priority = 16
if task['url'].startswith('http://www.xiami.com/artist/album-id'):
priority = 15
logger.info('schedule %s %s %d' % (task['url'], task['attr']['type'], priority))
r = StrictRedis(host='127.0.0.1', port=6379)
r.zadd('CQ:10001:%s' % task['attr']['domain'], priority, json.dumps(task))
示例8: tfidf_reduce
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def tfidf_reduce(args):
if args is None:
return
key, doc_id, value = args
import json
import math
counts = None
r = StrictRedis(db=1)
def freq(word, doc_id):
return r.zscore(word, doc_id)
def word_count(doc_id):
try:
with open("counts/" + doc_id, "r+") as f:
return float(f.read())
except:
return 1.0
def num_docs_containing(word):
return r.zcard(word)
def tf(word, doc_id):
return (freq(word, doc_id) / float(word_count(doc_id)))
def idf(word):
return math.log(doc_count / float(num_docs_containing(word)))
def tf_idf(word, doc_id):
return (tf(word, doc_id) * idf(word))
if doc_id not in db:
print("Deleted " + doc_id + " from " + key)
r.zrem(key, doc_id)
return
doc = db[doc_id]
multiplier = 1
try:
if key.lower() in doc['title'].lower():
multiplier = 4
elif key.lower() in doc['description'].lower():
multiplier = 2
except:
pass
rank = tf_idf(key, doc_id) * multiplier
if rank is None :
rank = 0
print("{0}: {1} is {2}".format(doc_id, key, rank))
r.zadd(key, rank, doc_id)
return rank
示例9: copy_values
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def copy_values():
source = StrictRedis()
dest = StrictRedis(db=1)
for key in source.keys():
try:
for doc_id, value in source.zrevrange(key, 0, -1, "WITHSCORES"):
print(dest.zadd(key, value, doc_id))
source.zrem(key, doc_id)
except redis.exceptions.ResponseError:
pass
print key
示例10: RedisDupeFilter
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisDupeFilter(BaseDupeFilter):
def __init__(self, path=None):
self.redis_cli = StrictRedis(host='localhost', port=6379, db=0)
@classmethod
def from_settings(cls, settings):
return cls(job_dir(settings))
def request_seen(self, request):
fp = request_fingerprint(request)
domain = request.url.split('/')[2]
suffix = 'category'
if request.meta.has_key('skip'):
suffix = 'content'
key = '%s_%s' % (domain, suffix)
timestamp = self.redis_cli.zscore(key, fp)
if timestamp:
#log.msg('skip %s' % request.url, level=log.INFO)
return True
self.redis_cli.zadd(key, time(), fp)
return False
示例11: _fill_fake_task
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
def _fill_fake_task():
r = StrictRedis(host='127.0.0.1', port=6379, password='[email protected])')
for url in open('url.list.all'):
url = url.strip()
ret = urlparse(url)
r.zadd('CQ:10001:%s' % ret.netloc, 1, url)
示例12: RedisTopTalkerTracker
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
class RedisTopTalkerTracker(object):
def __init__(self, size=16384, redis_host='localhost', redis_port=6379,
redis_table='top_talkers'):
self.size = size
self.redis_table = 'top_talkers'
self.client = StrictRedis(host=redis_host, port=redis_port)
self.is_saturated = self.decide_is_saturated()
def decide_is_saturated(self):
return self.client.zcard(self.redis_table) >= self.size
def clear(self):
self.client.zremrangebyrank(self.redis_table, 0, -1)
self.is_saturated = self.decide_is_saturated()
def is_full(self):
if self.is_saturated:
return True
self.is_saturated = self.decide_is_saturated()
return self.is_saturated
def get(self, key):
count = self.client.zscore(self.redis_table, key)
if count is None:
return count
return int(count)
def contains(self, key):
count = self.client.zscore(self.redis_table, key)
return count is not None
def add(self, key):
# If it's already in there, increment its count and we're done.
count = self.client.zscore(self.redis_table, key)
if count is not None:
self.client.zincrby(self.redis_table, key, 1)
return
# Else if the key is new to us but we're full, pop the lowest key/count
# pair and insert the new key as count + 1.
if self.is_full():
keys_counts = self.client.zrange(
self.redis_table, 0, 0, withscores=True, score_cast_func=int)
old_count = keys_counts[0][1]
self.client.zremrangebyrank(self.redis_table, 0, 0)
new_count = old_count + 1
self.client.zadd(self.redis_table, new_count, key)
return
# Or if the key is new to us and we have space, just insert it.
self.client.zadd(self.redis_table, 1, key)
def top_n_keys(self, n):
return self.client.zrevrange(
self.redis_table, 0, n - 1, score_cast_func=int)
def top_n_keys_counts(self, n):
keys_counts = self.client.zrevrange(
self.redis_table, 0, n - 1, withscores=True, score_cast_func=int)
if self.is_full():
lowest_keys_counts = self.client.zrange(
self.redis_table, 0, 0, withscores=True, score_cast_func=int)
the_min = lowest_keys_counts[0][1] - 1
else:
the_min = 0
return map(lambda (key, count): (key, count - the_min), keys_counts)
示例13: Leaderboard
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
#.........这里部分代码省略.........
# invert the timestamp for proper ordering
ts = 3000000000 - ts
to_dec = 0.0000000001
return float(value) + (ts * to_dec)
def _decode_value_with_time(self, combo):
from_dec = 10000000000
value = int(combo)
ts = (combo - value) * from_dec
if self.reverse == self.tie_oldest_wins:
ts = datetime.utcfromtimestamp(3000000000 - ts)
return value, ts
def _leaders_with_ranks(self, key, offset, end):
total = self.r.zcard(key)
l = self._range(key, offset, end)
if self.timed_ties:
l = [((m,) + self._decode_value_with_time(s)) for (m, s) in l]
else:
l = [(m, s, 0) for (m, s) in l]
log.info(l)
with_ranks = self._add_ranks(l, offset)
return total, with_ranks
def set_metric(self, user, value, ts=None):
"""
Set a new peak value for this user, e.g. high score
"""
if self.timed_ties:
value = self._encode_value_with_time(value, ts)
for r in self.ranges:
key = self._board_key(r)
self.r.zadd(key, value, user)
if r != self.RANGE_ALLTIME:
self.r.expire(key, r.expiration)
def inc_metric(self, user, value, ts=None):
"""
Increment the current value for this user, e.g. total earned
"""
if ts:
log.warn('inc_metric: timestamps not supported yet')
for r in self.ranges:
key = self._board_key(r)
self.r.zincrby(key, user, value)
if r != self.RANGE_ALLTIME:
self.r.expire(key, r.expiration)
def leaders(self, range, limit=-1, offset=0, id=None, slots_ago=0):
"""
Retrieve a list of global leaders.
:param range: The TimeRange to query
:param limit: Maximum number of entries to return
:param offset: Rank to start at, ignored if id is provided
:param id: Member to center the range of entries around, i.e. "leaders near me"
:param slots_ago: number of time slots prior, e.g. 1 for yesterday, last week, etc.
"""
key = self._board_key(range, slots_ago)
if id:
if self.reverse:
rank = self.r.zrevrank(key, id)
else:
示例14: Auth
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
BUCKET_NAME = "elfin"
Proxy = {"http": "http://127.0.0.1:48657"}
qiniu = Auth(ACCESS_KEY, SECRET_KEY)
def get_name():
name = str(time())
return name.replace(".", "")
def upload_media(media):
key = get_name()
data = media
token = qiniu.upload_token(BUCKET_NAME)
return put_data(token, key, data)
if __name__ == "__main__":
while 1:
media_url = redis.blpop("media_url")
if media_url:
media = get(url=media_url[1], proxies=Proxy)
try:
ret, info = upload_media(media.content)
except Exception, e:
redis.rpush("media_url", media_url)
logbook.error(e)
else:
media_name = ret["key"]
redis.zadd("image_name", int(media_name), int(media_name))
finally:
logbook.info("work on {}".format(media_url))
示例15: load
# 需要导入模块: from redis import StrictRedis [as 别名]
# 或者: from redis.StrictRedis import zadd [as 别名]
pass
print key
if __name__ == "__main__":
mapping = load()
params = {"from": "2013-06-14T15:00:00Z"}
while params is not None:
rt = harvest(params, mapping)
params = None
if rt is not None and rt != "null":
params = {RESUMPTION_TOKEN: rt}
r = StrictRedis(db=1)
db = couchdb.Database("http://localhost:5984/lr-data")
for doc in docs.itervalues():
keys = doc['keywords']
del doc['keywords']
try:
del db[doc['_id']]
db.save(doc)
print(keys)
for k, v in keys.iteritems():
mult = 1
if k in doc['title'].lower():
mult = 10
elif k in doc['description'].lower():
mult = 6
r.zadd(k, v * mult, doc['_id'])
except:
pass