class RedisStore(object):
"""Caching implementation that uses Redis as data storage.
"""
def __init__(self, host='localhost', port=6379, db=0):
try:
from redis import Redis
except ImportError:
raise RuntimeError('Redis support is not available')
self.redis = Redis(host=host, port=port, db=db)
def __getitem__(self, key):
entry = self.redis.get(key)
if entry is None:
return None
entry = json.loads(entry.decode('utf-8'))
return CacheEntry.parse(entry)
def __setitem__(self, key, entry):
data = json.dumps(entry.to_dict()).encode('utf-8')
self.redis.set(key, data)
def __delitem__(self, key):
self.redis.delete(key)
def clear(self):
self.redis.flushdb()
def __len__(self):
return self.redis.dbsize()
def test_reset_user_password(self):
user_key = "user::256"
old_password ="******"
self.client.hmset(
user_key,
{
"email": "*****@*****.**",
"password": old_password
}
)
reset_user_password(self.origin, self.new)
db0 = Redis(db=self.origin,decode_responses=True)
db1 = Redis(db=self.new)
# 确保数据库 0 的用户密码已被更新
self.assertNotEqual(
db0.hgetall(user_key)["password"],
old_password
)
# 确保数据库 1 已被清空
self.assertEqual(
db1.dbsize(),
0
)
class RedisController():
def __init__(self):
self.__pool__ = ConnectionPool(host=host, port=port)
self._redis_conn = Redis(connection_pool=self.__pool__)
base_info("Redis连接成功！")
def rset(self, key, value):
self._redis_conn.set(key, value)
redis_info("插入【%s】－【%s】"%(key, value))
def rget(self, key):
return str(self._redis_conn.get(key))[2:-1]
def rdel(self, key):
self._redis_conn.delete(key)
redis_info("删除key为【%s】的缓存"%key)
@property
def dbsize(self):
return self._redis_conn.dbsize()
def rpipeset(self, lists):
pipe = self._redis_conn.pipeline(transaction=True)
for list_detail in lists:
key = list(list_detail.keys())[0]
value = list_detail[key]
self.rset(key, value)
pipe.execute()
class RedisStore(object):
"""Caching implementation that uses Redis as data storage."""
def __init__(self, host='localhost', port=6379, db=0):
try:
from redis import Redis
except ImportError:
raise RuntimeError('Redis support is not available')
self.redis = Redis(host=host, port=port, db=db)
def __getitem__(self, key):
entry = self.redis.get(key)
if entry is None:
return None
entry = loads(entry.decode('utf-8'))
return CacheEntry.parse(entry)
def __setitem__(self, key, entry):
data = dumps(entry.to_dict()).encode('utf-8')
self.redis.set(key, data)
def __delitem__(self, key):
self.redis.delete(key)
def clear(self):
self.redis.flushdb()
def __len__(self):
return self.redis.dbsize()
def find_empty_redis_database():
"""Tries to connect to a random Redis database (starting from 4), and
will use/connect it when no keys are in there.
"""
for dbnum in range(4, 16):
testconn = Redis(db=dbnum)
empty = testconn.dbsize() == 0
if empty:
return dbnum, testconn
assert False, 'No empty Redis database found to run tests in.'
def find_empty_redis_database():
"""Tries to connect to a random Redis database (starting from 4), and
will use/connect it when no keys are in there.
"""
for dbnum in range(4, 17):
testconn = Redis(db=dbnum)
empty = testconn.dbsize() == 0
if empty:
return testconn
assert False, 'No empty Redis database found to run tests in.'
class RedisController():
def __init__(self, section_name="redis_hs"):
(host, port,
self.db) = ConfigReader.read_section_keylist(section_name,
["host", "port", "db"])
self.__pool__ = ConnectionPool(host=host, port=port, db=self.db)
self._redis_conn = Redis(connection_pool=self.__pool__)
base_info("Redis连接%s创建成功！[%s:%s db%s]" %
(section_name, host, port, self.db))
def rset(self, key, value):
rvalue = self.rget(key)
if equal(str(value), str(rvalue)):
redis_info("db%s:set【%s => <=】" % (self.db, key))
elif rvalue == None:
redis_info("db%s:set【%s () => %s】" % (self.db, key, value))
else:
redis_info("db%s:set【%s %s => %s】" % (self.db, key, rvalue, value))
self._redis_conn.set(key, value)
def rget(self, key):
try:
res = self._redis_conn.get(key)
if res is not None:
return res.decode('utf-8')
else:
return None
except Exception as e:
print(str(e))
return None
def rdel(self, key):
self._redis_conn.delete(key)
redis_info("db%s:删除【%s】的缓存" % (self.db, key))
@property
def dbsize(self):
return self._redis_conn.dbsize()
def rpipeset(self, lists):
pipe = self._redis_conn.pipeline(transaction=True)
for list_detail in lists:
key = list(list_detail.keys())[0]
value = list_detail[key]
self.rset(key, value)
pipe.execute()
@property
def rscan(self):
'''扫描Redis'''
for key in self._redis_conn.keys():
yield key.decode('utf-8'), self.rget(key).replace("\'", "\"")
def find_empty_redis_database(ssl=False):
"""Tries to connect to a random Redis database (starting from 4), and
will use/connect it when no keys are in there.
"""
for dbnum in range(4, 17):
connection_kwargs = {'db': dbnum}
if ssl:
connection_kwargs['port'] = 9736
connection_kwargs['ssl'] = True
connection_kwargs['ssl_cert_reqs'] = None # disable certificate validation
testconn = Redis(**connection_kwargs)
empty = testconn.dbsize() == 0
if empty:
return testconn
assert False, 'No empty Redis database found to run tests in.'
class GatherMetricToStorage(object):
def __init__(self, duration, recsqant):
"""
Initialize storage connection
"""
echo(" * Initializing metric fetch system...")
self.baseobjc = Redis(host="127.0.0.1", port=6379)
self.duration = duration
self.recsqant = recsqant
def jsonify_system_live_updating_metrics(self):
"""
Convert metric data to a JSON-friendly format
"""
timestmp = str(time()).split(".")[0]
hashiden = sha256(timestmp.encode()).hexdigest()
keyvalpr = {
timestmp:
json.dumps({
"hashiden": hashiden,
"liveupdt": LiveUpdatingElements().return_live_data()
})
}
return keyvalpr
def continuously_store_data(self):
"""
Periodically push passive metrics to Redis store
"""
self.baseobjc.flushall()
try:
while True:
if self.baseobjc.dbsize() == self.recsqant:
self.baseobjc.keys().sort()
self.baseobjc.delete(self.baseobjc.keys()[0])
self.baseobjc.mset(self.jsonify_system_live_updating_metrics())
# echo(" * [" + ctime() + "] Stored system metrics now...")
sleep(self.duration)
except KeyboardInterrupt as expt:
self.baseobjc.close()
echo("\n" + " * Closing storage connection...")
exit()
class Catalog(dict):
def __init__(self, host='localhost', port=6379, db=0):
self.redis = Redis(host=host, port=port, db=db)
self.save = self.redis.save
def __len__(self):
return self.redis.dbsize()
def get(self, key):
subject = key.strip("() ")
key = subject.lower()
if self.redis.exists(key):
subject = cPickle.loads(self.redis.get(key))
else:
subject = Subject(key, subject)
self.set(key, subject)
return subject
def set(self, key, value):
return self.redis.set(key,
cPickle.dumps(value, cPickle.HIGHEST_PROTOCOL))
class TestCreateRandomTypeKeys(unittest.TestCase):
def setUp(self):
self.client = Redis(decode_responses=True)
self.client.flushdb()
self.key = "key"
def tearDown(self):
self.client.flushdb()
def test_create_string(self):
create_string(self.client, self.key)
self.assertEqual(self.client.type(self.key), "string")
def test_create_hash(self):
create_hash(self.client, self.key)
self.assertEqual(self.client.type(self.key), "hash")
def test_create_list(self):
create_list(self.client, self.key)
self.assertEqual(self.client.type(self.key), "list")
def test_create_set(self):
create_set(self.client, self.key)
self.assertEqual(self.client.type(self.key), "set")
def test_create_zset(self):
create_zset(self.client, self.key)
self.assertEqual(self.client.type(self.key), "zset")
def test_create_stream(self):
create_stream(self.client, self.key)
self.assertEqual(self.client.type(self.key), "stream")
def test_create_random_type_keys(self):
dbsize = 100
create_random_type_keys(self.client, dbsize)
self.assertEqual(self.client.dbsize(), dbsize)
def get_databases_of_server(server_id):
q = RedisServer.query.get(server_id)
if q.password:
redis = Redis(host=q.host, port=q.port, password=q.password)
else:
redis = Redis(host=q.host, port=q.port)
db_count = int(redis.config_get('databases')['databases'])
data = []
for i in range(db_count):
if q.password:
redis = Redis(host=q.host, port=q.port, password=q.password, db=i)
else:
redis = Redis(host=q.host, port=q.port, db=i)
if redis.dbsize() > 0 or i == 0:
data.append(
{
'leaf': True,
'label': i,
'value': i
}
)
return success_json(data=data)
#coding:utf-8
import sys
from redis import Redis
from question63_pre import buildKVSforTags
"""
正常に動作しない場合はquestion63_pre.pyを先に実行してください
(多分これだけ実行しても大丈夫なはず)
"""
if __name__ == "__main__":
client = Redis(db=2)
#DBが存在しない場合、新たに作成
if client.dbsize() == 0:
buildKVSforTags()
print("アーティスト名を入力してください")
sys.stdout.write("-> ") #改行なしの出力
sys.stdout.flush()
artist_name = input()
for artist_id, artist_tags in sorted(
list(client.hgetall(artist_name).items()),
key=lambda d: int(d[0].decode('utf-8'))):
#bytes型になってるので変換
artist_id = artist_id.decode('utf-8')
artist_tags = artist_tags.decode('utf-8')
class ZWRedis():
"""Class defining a Redis driver"""
def __init__(self, db_url, **kwargs):
self.db_url = db_url or os.environ.get('DATABASE_URL')
if not self.db_url:
raise ValueError('You must provide a db_url.')
o = utils.db_url_parser(db_url)
self.dbcfg = {
'host' : o['host'],
'port' : o['port'] or 6379,
'username' : o['usr'],
'password' : o['pwd'],
'db' : o['db'] if 'db' in o and o['db'] and o['db'] != '' else 0,
'decode_responses' : True,
}
try:
self.dbcfg['db'] = int(o['db'])
except (AttributeError, ValueError):
self.dbcfg['db'] = 0
self.dbcfg.update(kwargs)
self._conn = Redis(connection_pool=BlockingConnectionPool(**self.dbcfg))
def close(self):
self._conn.connection_pool.disconnect()
def set(self, key, value):
rtn = None
if isinstance(value, str):
rtn = self._conn.set(key, value)
elif isinstance(value, dict):
rtn = self._conn.hmset(key, value)
elif isinstance(value, list):
self._conn.delete(key)
rtn = self._conn.rpush(key, *value)
elif isinstance(value, set):
self._conn.delete(key)
rtn = self._conn.sadd(key, *value)
else:
rtn = self._conn.set(key, value)
return rtn
def get(self, key, data_type=None):
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'string':
rtn = self._conn.get(key)
elif t == 'hash':
rtn = self._conn.hgetall(key)
elif t == 'list':
rtn = self._conn.lrange(key, 0, -1)
elif t == 'set':
rtn = self._conn.smembers(key)
else:
rtn = self._conn.get(key)
return rtn
def setby(self, key, field, value, data_type=None):
'''key: key(hash) or index(list)
return None if not support
'''
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'hash':
rtn = self._conn.hset(key, field, value)
elif t == 'list':
rtn = self._conn.lset(key, field, value)
return rtn
def getby(self, key, field, data_type=None):
'''key: key(hash) or index(list)
return None if not support
'''
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'hash':
rtn = self._conn.hget(key, field)
elif t == 'list':
rtn = self._conn.lindex(key, field)
return rtn
def delby(self, key, fields, data_type=None):
'''fields: fields(hash) or indexes(list) or values(set)
return None if not support
'''
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'hash':
rtn = self._conn.hdel(key, *fields)
elif t == 'list':
with self._conn.pipeline() as p:
p.multi()
for idx in fields:
p.lset(key, idx, '__ZWREDIS_DELETED__')
rtn = p.lrem(key, 0, '__ZWREDIS_DELETED__')
p.execute()
elif t == 'set':
self._conn.srem(key, *fields)
return rtn
def append(self, key, value, data_type=None):
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'string':
rtn = self._conn.append(key, value)
elif t == 'hash':
rtn = self._conn.hmset(key, value)
elif t == 'list':
rtn = self._conn.rpush(key, *value)
elif t == 'set':
rtn = self._conn.sadd(key, *value)
else:
rtn = self._conn.append(key, value)
return rtn
def contains(self, key, field, data_type=None):
'''key: key(hash) or value(list/set) or substring(string)'''
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'string':
rtn = field in self._conn.get(field)
elif t == 'hash':
rtn = self._conn.hexists(key, field)
elif t == 'list':
with self._conn.pipeline() as p:
p.multi()
set_name = '_%s_tmp_set' % key
p.delete(set_name)
arr = self._conn.lrange(key, 0, -1)
p.sadd(set_name, *arr)
p.sismember(set_name, field)
p.delete(set_name)
rtn = p.execute()
rtn = rtn[2]
elif t == 'set':
rtn = self._conn.sismember(key, field)
else:
rtn = field in self._conn.get(field)
return rtn
def len(self, key, data_type=None):
rtn = None
t = data_type if data_type is not None else self._conn.type(key)
if t == 'string':
rtn = self._conn.strlen(key)
elif t == 'hash':
rtn = self._conn.hlen(key)
elif t == 'list':
rtn = self._conn.llen(key)
elif t == 'set':
rtn = self._conn.scard(key)
else:
rtn = self._conn.strlen(key)
return rtn
def all(self):
rtn = []
keys = self._conn.keys('*')
for key in keys:
rtn.append({
'key': key,
'value': self.get(key)
})
return rtn
def all_iter(self, cbfunc):
for key in self._conn.scan_iter():
cbfunc(key)
def delete(self, name):
return self._conn.delete(name)
def exists(self, key):
return self._conn.exists(key) == 1
def dbsize(self):
return self._conn.dbsize()
@property
def conn(self):
return self._conn
def __repr__(self):
return '<Database host={}:{}>'.format(self.dbcfg['host'], self.dbcfg['port'])
def __enter__(self):
return self
def __exit__(self, exc, val, traceback):
self.close()
class RedisBase(object):
def __init__(self, db):
self.conf = {"host": "127.0.0.1", "port": 6379, "passwd": ""}
host = self.conf['host']
port = self.conf['port']
passwd = self.conf['passwd']
self.db = db
self.__pool = ConnectionPool(host=host,
port=port,
db=self.db,
password=passwd)
self.__conn = RawRedis(connection_pool=self.__pool)
print("*** Connect to redis-server succeed.")
def rset(self, k, v):
rval = self.rget(k)
if rval is not None:
try:
rval = json.loads(rval)
except Exception:
pass
if equal(v, rval):
print("db{}:set【{} => <=】".format(self.db, k))
return
elif rval is None:
print("db{}:set【{} () => {}】".format(self.db, k, v))
else:
print("db{}:set【{} {} => {}】".format(self.db, k, rval, v))
if isinstance(v, (dict, list)):
v = json.dumps(v)
self.__conn.set(k, v)
return
def rget(self, k):
try:
res = self.__conn.get(k)
return None if res is None else res.decode('utf-8')
except Exception as e:
print("*** Get value from redis failed.", k, e)
return None
def delete(self, k):
self.__conn.delete(k)
print("*** db%s:删除【%s】的缓存" % (self.db, k))
@property
def dbsize(self):
return self.__conn.dbsize()
def pipeset(self, lists):
pipe = self.__conn.pipeline(transaction=True)
for list_detail in lists:
k = list(list_detail.keys())[0]
v = list_detail[k]
self.rset(k, v)
pipe.execute()
@property
def scan_iter(self):
''' Scan Redis db to iterator.
'''
for k in self.__conn.keys():
yield k.decode('utf-8'), self.rget(k)
def __update_dict_to_redis__(self, k, v):
''' __update_dict_to_redis__
Merge dict rather than replace it.
'''
if self.rget(k) is not None:
bf_val = self.rget(k)
try:
bf_val = json.loads(bf_val)
bf_val = dict(bf_val, **v)
self.rset(k, bf_val)
except Exception as e:
print("__update_dict_to_redis__ failed.", e)
pass
else:
self.rset(k, v)
from redis import Redis
redis_client=Redis()
print redis_client.keys()
redis_client.set('name','vvsong')
name=redis_client.get('name')
print name
redis_client.sadd('friends:vv','jenny','mike','tom')
redis_client.sadd('friends:song','kate','mike','tom')
for i in redis_client.sinter('friends:vv','friends:song'):
print i
#print co-friends
#for friend in co-friends:
# print friend
#print co-friends
print redis_client.dbsize()
#redis_client.shutdown()
class RedisStore(object):
"""Caching implementation that uses Redis as data storage.
:param host: String representing the hostname or IP of the Redis server
:param port: Port number (int) on which the Redis server is listening
:param db: DB querystring option (Default: 0, e.g. redis://localhost?db=0)
:param password: Redis server password (Default: No Password)
:param socket_timeout: Connection timeout to Redis server
:param connection_pool: ConnectionPool for Redis instance (See redis-py docs)
:param charset: Default character set
:param errors: Default error settings
:param decode_responses: Default: False (values in message dictionaries will be
byte strings (str on Python 2, bytes on Python 3)
:param unix_socket_path: Socker path. For using UnixDomainSocketConnection
(see redis-py docs for more details)
:param ttl: Default TTL
"""
DEFAULT_TTL = 5 * 60 # seconds
def __init__(self,
host='localhost',
port=6379,
db=0,
password=None,
socket_timeout=None,
connection_pool=None,
charset='utf-8',
errors='strict',
decode_responses=False,
unix_socket_path=None,
ttl=DEFAULT_TTL):
self.ttl = ttl
try:
from redis import Redis
except ImportError:
raise RuntimeError(
'Redis support is not available. Run "pip install redis".')
self.redis = Redis(host=host,
port=port,
db=db,
password=password,
socket_timeout=socket_timeout,
connection_pool=connection_pool,
charset=charset,
errors=errors,
decode_responses=decode_responses,
unix_socket_path=unix_socket_path)
def __getitem__(self, key):
entry = self.redis.get(key)
if entry is None:
return None
entry = loads(entry.decode('utf-8'))
return CacheEntry.parse(entry)
def __setitem__(self, key, entry):
data = dumps(entry.to_dict()).encode('utf-8')
self.redis.setex(key, data, self.ttl)
def __delitem__(self, key):
self.redis.delete(key)
def clear(self):
self.redis.flushdb()
def __len__(self):
return self.redis.dbsize()
class RedisStore(object):
"""Caching implementation that uses Redis as data storage.
:param host: String representing the hostname or IP of the Redis server
:param port: Port number (int) on which the Redis server is listening
:param db: DB querystring option (Default: 0, e.g. redis://localhost?db=0)
:param password: Redis server password (Default: No Password)
:param socket_timeout: Connection timeout to Redis server
:param connection_pool: ConnectionPool for Redis instance (See redis-py docs)
:param charset: Default character set
:param errors: Default error settings
:param decode_responses: Default: False (values in message dictionaries will be
byte strings (str on Python 2, bytes on Python 3)
:param unix_socket_path: Socker path. For using UnixDomainSocketConnection
(see redis-py docs for more details)
:param ttl: Default TTL
"""
DEFAULT_TTL = 5 * 60 # seconds
def __init__(self, host='localhost', port=6379, db=0, password=None,
socket_timeout=None, connection_pool=None, charset='utf-8',
errors='strict', decode_responses=False, unix_socket_path=None,
ttl=DEFAULT_TTL):
self.ttl = ttl
try:
from redis import Redis
except ImportError:
raise RuntimeError('Redis support is not available. Run "pip install redis".')
self.redis = Redis(host=host, port=port, db=db,
password=password, socket_timeout=socket_timeout,
connection_pool=connection_pool, charset=charset,
errors=errors, decode_responses=decode_responses,
unix_socket_path=unix_socket_path)
def __getitem__(self, key):
entry = self.redis.get(key)
if entry is None:
return None
entry = loads(entry.decode('utf-8'))
return CacheEntry.parse(entry)
def __setitem__(self, key, entry):
data = dumps(entry.to_dict()).encode('utf-8')
self.redis.setex(key, data, self.ttl)
def __delitem__(self, key):
self.redis.delete(key)
def clear(self):
self.redis.flushdb()
def __len__(self):
return self.redis.dbsize()
from redis import Redis
r = Redis()
#set方法
print(r.set('nosql','redis'))
print(r.get('nosql'))
#getset方法，为存在的key关联新的value，并返回旧值
print(r.getset('nosql','mongodb'))
#mget返回多个key对应的value,
print(r.mget('qq','pp','yy','star'))
print('*'*40)
#-------------------------------------------------------------
#key 操作
print(r.exists('qq'))
print(r.delete('pp'))
print(r.type('nosql'))
print(r.randomkey())
print(r.rename('yy','star'))
print(r.move('star',7))
#获取当前数据库中的key个数
print(r.dbsize())
#删除当前数据库中所有key
print(r.flushdb())
print(r.dbsize())
class RedisController(LogBase):
def __init__(self, db, project_name="sample"):
LogBase.__init__(self, project_name, "redis")
host, port = REDIS_CFG['host'], REDIS_CFG['port']
self.db = db
self.__pool__ = ConnectionPool(host=host, port=port, db=self.db)
self._redis_conn = Redis(connection_pool=self.__pool__)
self.info("Connect to redis-server SUCCEED.", host=host, port=port, db=self.db)
def rset(self, key, value):
rvalue = self.rget(key)
if rvalue is not None:
try:
rvalue = json.loads(rvalue)
except Exception:
pass
if equal(value, rvalue):
self.info("db{}:set【{} => <=】".format(self.db, key))
elif rvalue == None:
self.info("db{}:set【{} () => {}】".format(self.db, key, value))
else:
self.info("db{}:set【{} {} => {}】".format(self.db, key, rvalue, value))
if isinstance(value, dict):
value = json.dumps(value)
self._redis_conn.set(key, value)
def rget(self, key):
try:
res = self._redis_conn.get(key)
return None if res is None else res.decode('utf-8')
except Exception as e:
self.error("Get value from redis error!", key=key, err=e)
return None
def rdel(self, key):
self._redis_conn.delete(key)
self.info("db%s:删除【%s】的缓存"%(self.db,key))
@property
def dbsize(self):
return self._redis_conn.dbsize()
def rpipeset(self, lists):
pipe = self._redis_conn.pipeline(transaction=True)
for list_detail in lists:
key = list(list_detail.keys())[0]
value = list_detail[key]
self.rset(key, value)
pipe.execute()
@property
def rscan(self):
'''扫描Redis'''
for key in self._redis_conn.keys():
yield key.decode('utf-8'), self.rget(key)
def __update_dict_to_redis__(self, k, v):
'''__update_dict_to_redis__
Merge dict rather than replace it.
'''
if self.rget(k) is not None:
bf_val = self.rget(k)
try:
bf_val = json.loads(bf_val)
bf_val = dict(bf_val, **v)
self.rset(k, bf_val)
except Exception as e:
self.warn("__update_dict_to_redis__ failed.",err=e)
pass
else:
self.rset(k, v)
m.append(data['itemId'])
if getNeedJson['itemId'] not in m:
DATA.append(getNeedJson)
else:
continue
#DATA = list(set(DATA))
'''
print "添加商品成功{item_id}".format(item_id=need['itemId'])
except Exception, e:
logging.error("爬取{shopname}是出错：{e}".format(shopname=shopname, e=e.message))
return get_data(shop_id, item_ids, total_items, shopname)
# 想通过mongdb查询得到已经有的宝贝数量
# database = collection.dout({'shop_id':shop_id,'crawl_time':{'$gt':int(time)}})
# list(del_repeat(DATA))
try:
size = int(r.dbsize())
# 每次存储DATA时获取随机itemId的方法
# ranNum = random.randint(0,size-1)
# re_itemId = r.get([ranNum])['itemId']
re_itemId = r.randomkey()
# size = len(DATA)
global COUNT
print COUNT
if size == int(total_items):
logging.info("爬取数量和预期相同，数量为：{size}".format(size=size))
COUNT = 0
elif size != int(total_items):
COUNT += 1
# 当爬取次数大于100且已经爬取的数量和需求总数差2个的时候
if COUNT > 100 and size > int(total_items) - 3:
logging.info("爬取数量和目标数量差额在2个，爬取到的数量为：{size}".format(size=size))
# 测试各个类型键的创建函数
r.flushdb()
create_string(r, "str_key")
assert (r.type("str_key") == "string")
create_hash(r, "hash_key")
assert (r.type("hash_key") == "hash")
create_list(r, "list_key")
assert (r.type("list_key") == "list")
create_set(r, "set_key")
assert (r.type("set_key") == "set")
create_zset(r, "zset_key")
assert (r.type("zset_key") == "zset")
# 测试随机创建函数
r.flushdb()
create_random_type_keys(r, 10)
assert (r.dbsize() == 10)
for k in r.keys("*"):
print("Keyname:<{0}> - Type:<{1}>".format(k, r.type(k)))
