实际代码只有一点，其他的为备忘
# -*- coding:utf-8 -*-
import MySQLdb
import redis
class Config:
def __init__(self):
self.mysql_host = ‘192.168.44.60‘
self.mysql_user = ‘root‘
self.mysql_port = 3306
self.mysql_password = ‘123456‘
self.mysql_db = ‘bamboo‘
self.mysql_charset = ‘utf8‘
self.mysql_show_tables = "show tables"
self.mysql_desc_table = "desc %s"
self.mysql_query_info = "select * from %s"
self.redis_host = "192.168.44.60"
self.redis_port = 6379
self.redis_passwd = 123456
self.redis_db = 0
config = Config()
class MySQLHelper:
myVersion = 0.1
def __init__(self):
self.host = config.mysql_host
self.user = config.mysql_user
self.password = config.mysql_password
self.charset = config.mysql_charset
self.db = config.mysql_db
try:
self.conn = MySQLdb.connect(host=self.host, user=self.user, passwd=self.password,db=self.db,charset=self.charset)
self.cursor = self.conn.cursor()
except MySQLdb.Error as e:
print (‘MySql Error : %d %s‘ % (e.args[0], e.args[1]))
def query(self, sql):
try:
cursor = self.cursor
cursor.execute(sql)
return cursor
except MySQLdb.Error as e:
print(‘MySql Error: %s SQL: %s‘ % (e, sql))
def queryOnlyRow(self, sql):
try:
cursor = self.query(sql)
result = cursor.fetchall()
desc = cursor.description
row = {}
for i in range(0, len(result)):
row[desc[i][0]] = result[i]
return row
except MySQLdb.Error as e:
print(‘MySql Error: %s SQL: %s‘ % (e, sql))
def queryAll(self, sql):
try:
cursor = self.query(sql)
result = cursor.fetchall()
desc = cursor.description
rows = []
for cloumn in result:
row = {}
for i in range(0, len(cloumn)):
row[desc[i][0]] = cloumn[i]
rows.append(row)
return rows
except MySQLdb.Error as e:
print(‘MySql Error: %s SQL: %s‘ % (e, sql))
def queryTableNums(self,sql):
try:
cursor = self.query(sql)
result = cursor.fetchall()
row = []
for cloumn in result:
row.append(cloumn[0])
return row
except MySQLdb.Error as e:
print(‘Mysql Error: %s SQL: %s‘ %(e,sql))
def insert(self, tableName, pData):
try:
newData = {}
for key in pData:
newData[key] = "‘" + str(pData[key]) + "‘"
key = ‘,‘.join(newData.keys())
value = ‘,‘.join(map(str,newData.values()))
sql = "insert into " + tableName + "(" + key + ") values(" + value + ")"
self.query("set names ‘utf8‘")
self.query(sql)
self.commit()
except MySQLdb.Error as e:
self.conn.rollback()
print(‘MySql Error: %s %s‘ % (e.args[0], e.args[1]))
def update(self, tableName, pData, whereData):
try:
newData = []
keys = pData.keys()
for i in keys:
item = "%s=%s" % (i, "‘" + pData[i] + "‘")
newData.append(item)
items = ‘,‘.join(newData)
newData2 = []
keys = whereData.keys()
for i in keys:
item = "%s=%s" % (i, "‘" + whereData[i] + "‘")
newData2.append(item)
whereItems = " AND ".join(newData2)
sql = "update " + tableName + " set " + items + " where " + whereItems
self.query("set names ‘utf8‘")
self.query(sql)
self.commit()
except MySQLdb.Error as e:
self.conn.rollback()
print(‘MySql Error: %s %s‘ % (e.args[0], e.args[1]))
def getLastInsertRowId(self):
return self.cursor.lastrowid
def getRowCount(self):
return self.cursor.rowcount
def commit(self):
self.conn.commit()
def close(self):
self.cursor.close()
self.conn.close()
class RedisHelper():
__redis_instance = None
def __init__(self):
self.host = config.redis_host
self.port = config.redis_port
self.passwd = config.redis_passwd
self.db = config.redis_db
try:
self.connPoor = redis.ConnectionPool(host=self.host,port=self.port,db=self.db,password=self.passwd)
self.rd = redis.Redis(connection_pool=self.connPoor)
except redis.DataError as e:
print(‘Redis Error : %d %s‘ % (e.args[0], e.args[1]))
@staticmethod
def getObj():
if RedisHelper.__redis_instance:
return RedisHelper.__redis_instance
else:
RedisHelper.__redis_instance = RedisHelper().rd
return RedisHelper.__redis_instance
# string 操作
def setkey(self,key,value,**kwargs):
"""
set(name, value, ex=None, px=None, nx=False, xx=False)
:param key: 键
:param value: 值
:param kwargs:
在Redis中设置值，默认，不存在则创建，存在则修改
参数：
ex，过期时间（秒）
px，过期时间（毫秒）
nx，如果设置为True，则只有name不存在时，当前set操作才执行
xx，如果设置为True，则只有name存在时，当前set操作才执行
:return: True or False
"""
res = self.rd.set(key,value,**kwargs)
return res
def getkey(self,key):
return self.rd.get(key)
def setnxkey(self,key,value):
"""
:param key:
:param value:
:return: True or False
设置值，只有key不存在时，执行设置操作（添加）
"""
return self.rd.setnx(key,value)
def setexkey(self,key,value,time=5):
"""
:param key:
:param value:
:param time: 过期时间 (秒 或 timedelta对象)
:return: True or False
"""
return self.rd.setex(key,time,value)
def psetexkey(self,key,value,time):
"""
:param key:
:param value:
:param time: time_ms，过期时间（数字毫秒 或 timedelta对象）
:return:
"""
return self.rd.psetex(key,time,value)
def msetkey(self,mapping):
"""
批量设置多个值
:param mapping: {‘k1‘:‘v1‘,‘k2‘:‘v2‘} or k1=‘v1‘,k2=‘v2‘
:return:
"""
return self.rd.mset(mapping)
def mgetkey(self,keys,*args):
"""
批量获取多个值
‘k1‘,‘k2‘ or [‘k1‘,‘k2‘]
:param keys:
:param args:
:return:
"""
return self.rd.mget(keys,args)
def getsetkey(self,key,value):
"""
获取值并设置新值
:param key:
:param value:
:return:
"""
return self.rd.getset(key,value)
def getrangekey(self,key,start,end):
"""
获取子序列（根据字节获取，非字符） 一个汉字，是占3个字节
:param key:
:param start: bytes 起始位置(包含)
:param end: bytes 结束位置（包含）
:return:
set ‘name‘ ‘helloworld‘
OK
GETRANGE ‘name‘ 0 2
"hel"
getrange ‘name‘ 0 -1
"helloworld"
"""
return self.rd.getrange(key,start,end)
def setrange(self,key,index,value):
"""
修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
参数：
:param key:
:param index: 字符串的索引，字节（一个汉字三个字节）
:param value: 要设置的值
:return:
"""
return self.rd.setrange(key,index,value)
def strlenkey(self,key):
"""
返回name对应值的字节长度（一个汉字3个字节）
:param key:
:return:
"""
return self.rd.strlen(key)
def incrkey(self,key):
"""
自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
:param key:
:param amount: 自增数 必须是整数 一次只能自增一个
:return:
"""
return self.rd.incr(key,1)
def incrbykey(self,key,amount=1):
"""
自增 key对应的值，当key不存在时，则创建key＝amount，否则，则自增。
:param key:
:param amount: 自增数 必须是整数
:return:
"""
try:
if not isinstance(amount,int):
raise TypeError(‘amount 必须是整数‘)
return self.rd.incrby(key,amount)
except Exception as e:
return "Func incrbykey Error : %d %s" % (e.args[0], e.args[1])
def incrbyfloatkey(self,key,amount=1.0):
"""
自增 key对应的值，当key不存在时，则创建key＝amount，否则，则自增。
:param key:
:param amount: 自增数(浮点型)
:return:
"""
try:
if not isinstance(amount,float):
raise TypeError(‘amount 必须是浮点数‘)
return self.rd.incrbyfloat(key,amount)
except Exception as e:
return "Func incrbyfloatkey Error : %d %s" % (e.args[0], e.args[1])
def decrkey(self,key):
"""
自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减
:param name:
:return:
"""
self.rd.decr(key,1)
def decrbykey(self,key,amount=1):
"""
自减 key对应的值，当key不存在时，则创建key＝amount，否则，则自减。
:param key:
:param amount: 自减数 必须是整数
:return:
"""
try:
if not isinstance(amount, int):
raise TypeError(‘amount 必须是整数‘)
return self.rd.decrby(key, amount)
except Exception as e:
return "Func decrbykey Error : %d %s" % (e.args[0], e.args[1])
def appendkey(self,key,value):
"""
在redis key对应的值后面追加内容
:param key:
:param value: 要追加的字符串
:return:
"""
return self.rd.append(key,value)
def setbitkey(self,key,index,value):
"""
注：如果在Redis中有一个对应： n1 = "foo"，
那么字符串foo的二进制表示为：01100110 01101111 01101111
所以，如果执行 setbit(‘n1‘, 7, 1)，则就会将第7位设置为1，
那么最终二进制则变成 01100111 01101111 01101111，即："goo"
扩展，转换二进制表示：
source = "陈思维"
source = "foo"
for i in source:
num = ord(i)
print bin(num).replace(‘b‘,‘‘)
特别的，如果source是汉字 "陈思维"怎么办？
答：对于utf-8，每一个汉字占 3 个字节，那么 "陈思维" 则有 9个字节
对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制
11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000
对name对应值的二进制表示的位进行操作
:param key:
:param index: 位的索引（将值变换成二进制后再进行索引）
:param value: 值只能是 1 或 0
:return:
"""
try:
if not isinstance(index,int):
raise TypeError(‘index 只能是数字‘)
if value not in [0,1]:
raise ValueError(‘value 只能是0或1‘ )
return self.rd.setbit(key,index,value)
except Exception as e:
return "Redis Error : %d %s" % (e.args[0], e.args[1])
def getbitkey(self,key,index):
"""
获取name对应的值的二进制表示中的某位的值 （0或1）
:param key:
:param index: 0 or 1
:return:
"""
try:
if index not in [0,1]:
raise ValueError("index 值只能是0或1")
return self.rd.getbit(key,index)
except Exception as e:
return "Redis Error : %d %s" % (e.args[0], e.args[1])
def bitcountkey(self,key,start=None,end=None):
"""
获取name对应的值的二进制表示中 1 的个数
:param key:
:param start:
:param end:
:return:
"""
return self.rd.bitcount(key,start,end)
def bitopkey(self,operation,new_key,*keys):
"""
bitop("AND", ‘new_name‘, ‘n1‘, ‘n2‘, ‘n3‘)
获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
r.set("foo","1") # 0110001
r.set("foo1","2") # 0110010
print(r.mget("foo","foo1")) # [‘goo1‘, ‘baaanew‘]
print(r.bitop("AND","new","foo","foo1")) # "new" 0 0110000
print(r.mget("foo","foo1","new"))
source = "12"
for i in source:
num = ord(i)
print(num) # 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
print(bin(num)) # 打印每个10进制ascii码值转换成二进制的值 0b1100110（0b表示二进制）
print bin(num).replace(‘b‘,‘‘) # 将二进制0b1100110替换成01100110
获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
:param operation: AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
:param new_key: new key
:param keys: 要查找的Redis的name
:return:
"""
return self.rd.bitop(operation,new_key,keys)
# hash 操作
def hsetkey(self,name,key,value):
"""
name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
:param name: redis的name
:param key: name对应的hash中的key
:param value: name对应的hash中的value
:return:
"""
return self.rd.hset(name,key,value)
def hmsetkey(self,name,mapping):
"""
在name对应的hash中批量设置键值对
:param name:
:param mapping: {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
:return:
"""
return self.rd.hmset(name,mapping)
def hgetkey(self,name,key):
"""
在name对应的hash中获取根据key获取value
:param name:
:param key:
:return:
"""
return self.rd.hget(name,key)
def hgetallkey(self,name):
"""
获取hash中对应name的所有值
:param name:
:return:
"""
return self.rd.hgetall(name)
def hmgetkey(self,name,keys,*args):
"""
在name对应的hash中获取多个key的值
:param name:
:param keys: [‘k1‘,‘k2‘,‘k3‘]
:param args: ‘k1‘,‘k2‘,‘k3‘
:return:
"""
return self.rd.hmget(name,keys,args)
def hlenkey(self,name):
"""
获取name对应的hash中的键值对的个数
:param name:
:return:
"""
return self.rd.hlen(name)
def hallkeys(self,name):
"""
获取name对应的hash中所有的key的值
:param name:
:return:
"""
return self.rd.hkeys(name)
def hvalskeys(self, name):
"""
获取name对应的hash中所有的value的值
:param name:
:return:
"""
return self.rd.hvals(name)
def hexistskeys(self,name,key):
"""
检查name对应的hash是否存在当前传入的key 类似字典的in
:param name:
:param key:
:return:
"""
return self.rd.hexists(name,key)
def hdelkeys(self,name,*keys):
"""
将name值对应的hash中指定key的键值对删除
:param name:
:param keys: ‘k1‘ or ‘k1‘,‘k2‘
:return:
"""
return self.rd.hdel(name,keys)
def hincrby(self,name,key,amount=1):
"""
将key对应的value--整数 自增1或者2，或者别的整数 负数就是自减(自增name对应的hash中的指定key的值，不存在则创建key=amount)
:param name:
:param key:
:param amount:
:return:
"""
try:
if not isinstance(amount,int):
raise TypeError(‘amount 只能是整数‘)
return self.rd.hincrby(name,key,amount)
except Exception as e:
return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])
def hincrbyfloatkeys(self,name,key,amount=1.0):
"""
将key对应的value--浮点数 自增1.0或者2.0，或者别的浮点数 负数就是自减 (自增name对应的hash中的指定key的值，不存在则创建key=amount)
:param name:
:param key:
:param amount: 自增数（浮点数）
:return:
"""
try:
if not isinstance(amount,float):
raise TypeError(‘amount 只能是浮点数‘)
return self.rd.hincrbyfloat(name, key, amount)
except Exception as e:
return "Func hincrby Error : %d %s" % (e.args[0], e.args[1])
def hscankeys(self,name,cursor=0,match=None,count=None):
"""
增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
:param name:
:param curosr: 游标（基于游标分批取获取数据）
:param match: 匹配指定key，默认None 表示所有的key
:param count: 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
:return:
"""
return self.rd.hscan(name,cursor,match,count)
def hscaniterkeys(self,name,match=None,count=None):
"""
利用yield 封装hscan创建生成器，实现分批器redis中获取数据
:param name:
:param match: 匹配指定key，默认表示所有key
:param count: 每次分片最少获取个数，默认None表示采用Redis的默认分片个数
:return:
"""
return self.rd.hscan_iter(name,match,count)
# list 操作
def lpushkeys(self,key,values):
"""
增加（类似于list的append，只是这里是从左边新增加）--没有就新建
在name对应的list中添加元素，每个新的元素都添加到列表的最左边
lpush(‘xx‘,11,12,13)
:param key:
:param values:
:return:
"""
return self.rd.lpush(key,values)
def rpushkeys(self,key,values):
"""
增加（类似于list的append，只是这里是从右边新增加）--没有就新建
在name对应的list中添加元素，每个新的元素都添加到列表的最右边
rpush(‘xx‘,11,12,13)
:param key:
:param values:
:return:
"""
return self.rd.rpush(key,values)
def lpushxkeys(self,key,value):
"""
在key对应的list中添加一个元素，只有key存在时，值添加到列表的最左边，key不存在则不能创建，但是不报错
:param key:
:param values:
:return:
"""
return self.rd.lpushx(key,value)
def rpushxkeys(self,key,value):
"""
在key对应的list中添加一个元素，只有key存在时，值添加到列表的最右边，key不存在则不能创建,但是不报错
:param key:
:param value:
:return:
"""
return self.rd.rpushx(key,value)
def linsertkeys(self,key,where,refvalue,value):
"""
在key对应的列表的某一个值前或后插入一个新值
r.linsert("list2", "before", "11", "00") # 往列表中左边第一个出现的元素"11"前插入元素"00"
:param key:
:param where: before or after
:param refvalue: 标杆值，即：在它前后插入数据
:param value: 要插入的数据
:return:
"""
try:
if str(where).lower() not in [‘before‘,‘after‘]:
raise ValueError(‘where 值只能是 before 或 after‘)
return self.rd.linsert(key,where,refvalue,value)
except Exception as e:
return "Func linsertkeys Error: %d %s"%(e.args[0],e.args[1])
def lsetkeys(self,key,index,value):
"""
对key对应的list中的某一个索引位置重新赋值
:param key:
:param index: 索引值，从0 开始
:param value:
:return:
"""
try:
if not isinstance(index,int):
raise TypeError(‘index 只能是整数‘)
return self.rd.lset(key,index,value)
except Exception as e:
return "Func lsetkeys: %d %s"%(e.args[0],e.args[1])
def lremkeys(self,key,num,value):
"""
在key对应的list中删除指定的值
:param key:
:param value:
:param num: num=0,删除列表中所有指定值，num=2，从前到后，删除2个，num=1，从前到后，删除左边第一个，num=-2，从后到前，删除两个
:return:
"""
return self.rd.lrem(key,num,value)
def lpopkeys(self,key):
"""
在key 对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
:param key:
:return:
"""
return self.rd.lpop(key)
def rpopkeys(self,key):
"""
在key 对应的列表的右侧获取第一个元素并在列表中移除，返回值则是第一个元素
:param key:
:return:
"""
return self.rd.rpop(key)
def ltrimkeys(self,key,start,end):
"""
在key对应的list中移除没有在start - end 索引之间的值
:param key:
:param start: 索引的开始位置
:param end: 索引的结束位置
:return:
"""
return self.rd.ltrim(key,start,end)
def lindexkeys(self,key,index):
"""
在name对应的list中根据索引获取列表元素
:param key:
:param index:
:return:
"""
return self.rd.lindex(key,index)
def rpoplpushkeys(self,srckey,dstkey):
"""
将元素从一个表移动到另一个表中(从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边)
:param srckey:
:param detkey:
:return:
"""
return self.rd.rpoplpush(srckey,dstkey)
def brpoplpushkeys(self,srckey,dstkey,timeout=0):
"""
从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧，可以设置超时
:param srckey:
:param dstkey:
:param timeout: 当seckey对应的list中没有数据时，阻塞等待其有数据的超时时间 单位为秒,0表示永远阻塞
:return:
"""
return self.rd.brpoplpush(srckey,dstkey,timeout)
def blpopkeys(self,keys,timeout):
"""
将多个列表排序，按照从左到右去pop对应的list元素
:param keys:
:param timeout: 超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
:return:
"""
return self.rd.blpop(keys,timeout)
def brpopkeys(self,keys,timeout):
"""
将多个列表排序，按照从右到左去pop对应的list元素
:param keys:
:param timeout: 超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
:return:
"""
return self.rd.brpop(keys,timeout)
def llenkeys(self,key):
"""
返回key的数据长度
:param key:
:return:
"""
return self.rd.llen(key)
def lrangekeys(self,key,start=0,end=-1):
"""
获取key的全部数据值 通常与llen联用
:param key:
:param start: 起始位置(包括)
:param end: 结束位置(包括)
:return:
"""
return self.rd.lrange(key,start,end)
def listiterkeys(self,key):
"""
list增量迭代
:param key:
:return: 返回yield 生成器
"""
list_count = self.rd.llen(key)
for index in range(list_count):
yield self.rd.lindex(key,index)
# set 操作
def saddkeys(self,key,values):
"""
:key对应的集合中添加元素,重复的元素将忽略
saddkeys(‘xxx‘,1,2,3,4,5)
:param key:
:param values:
:return:
"""
return self.rd.sadd(key,values)
def scardkeys(self,key):
"""
获取元素个数，类似于len
:param key:
:return:
"""
return self.rd.scard(key)
def smemnerkeys(self,key):
"""
获取key对应的集合的所有成员
:param key:
:return:
"""
return self.rd.smembers(key)
def sscankeys(self, key, cursor=0, match=None, count=None):
"""
获取集合中所有的成员 -- 元组形式
:param key:
:param cursor:
:param match:
:param count:
:return:
"""
return self.rd.sscan(key,cursor,match,count)
def sscaniterkeys(self,key,match=0,count=None):
"""
获取集合中所有的成员 --迭代器方式
:param key:
:param match:
:param count:
:return:
"""
return self.rd.sscan_iter(key,match,count)
def sdiffkeys(self,keys,*args):
"""
在第一个key对应的集合中且不在其他key对应的集合的元素集合
sdiffkeys(‘a‘,‘b) 在集合a中并且不再集合b中
:param keys:
:param args:
:return:
"""
return self.rd.sdiff(keys,args)
def sdiffstorekeys(self,dstkey,keys,*args):
"""
获取第一个key对应的集合中且不在其他name对应的结合，在将其加入到dstkey对应的集合中
:param dstkey:
:param keys:
:param args:
:return:
"""
res = self.rd.sdiffstore(dstkey,keys,args)
return res
def sinterkeys(self,keys,*args):
"""
获取多个keys对应集合的交集
:param keys:
:param args:
:return:
"""
return self.rd.sinter(keys,args)
def sinterstorekeys(self,dstkey,keys,*args):
"""
获取多个keys对应集合的交集，再将其加入到dstkey对应的集合中
:param dstkey:
:param keys:
:param args:
:return:
"""
res = self.rd.sinterstore(dstkey,keys,args)
return res
def sunionkeys(self,keys,*args):
"""
获取多个key对应的集合的并集
:param keys:
:param args:
:return:
"""
return self.rd.sunion(keys,args)
def sunionstorekeys(self,dstkey,keys,*args):
"""
获取多个key对应集合的并集，并将其结果保存到dstkey对应的集合中
:param dstkey:
:param keys:
:param args:
:return:
"""
return self.rd.sunionstore(dstkey,keys,args)
def sismemberkeys(self,key,value):
"""
检查value是否是key对应的结合的成员，结果返回True or False
:param key:
:param value:
:return: True or False
"""
return self.rd.sismember(key,value)
def smovekeys(self,srckey,dstkey,value):
"""
将某个成员从一个集合中移动到另一个集合
:param srckey:
:param dstkey:
:param value:
:return:
"""
return self.rd.smove(srckey,dstkey,value)
def spopkeys(self,key):
"""
从集合移除一个成员，并将其返回，说明一下，集合是无序的，所有都是随机删除的
:param key:
:return:
"""
return self.rd.spop(key)
def sremkeys(self,key,values):
"""
在key对应的集合中删除某些值
sremkeys(‘xx‘,‘a‘,‘b‘)
:param key:
:param values:
:return:
"""
return self.rd.srem(key,values)
# 有序集合 zset 操作
def zaddkeys(self,key,mapping):
"""
在key对应的有序集合中添加元素
zaddkeys(‘xx‘,{‘k1‘:1,‘k2‘:2})
:param key:
:param args:
:param kwargs:
:return:
"""
return self.rd.zadd(key,mapping)
def zcardkeys(self,key):
"""
获取有序集合元素的个数
:param key:
:return:
"""
return self.rd.zcard(key)
def zrangekeys(self,key,start,stop,desc=False,withscores=False,score_cast_func=float):
"""
获取有序集合索引范围内的元素
:param key:
:param start: 索引起始位置
:param stop: 索引结束位置
:param desc: 排序规则，默认按照分数从小到大排序
:param withscores: 是否获取元素的分数，默认之火去元素的值
:param score_cast_func: 对分数进行数据转换的函数
:return:
"""
return self.rd.zrange(key,start,stop,desc,withscores,score_cast_func)
def zrevrangekeys(self,key,start,end,withscores=False,score_cast_func=float):
"""
从大到小排序
:param key:
:param start:
:param end:
:param withscores:
:param score_cast_func:
:return:
"""
return self.rd.zrevrange(key,start,end,withscores,score_cast_func)
def zrangebyscorekeys(self,key,min,max,start=None,num=None,withscores=False,score_cast_func=float):
"""
按照分数返回获取key对应的有序集合的元素
zrangebyscore("zset3", 15, 25)) # # 在分数是15-25之间，取出符合条件的元素
zrangebyscore("zset3", 12, 22, withscores=True) # 在分数是12-22之间，取出符合条件的元素（带分数）
:param key:
:param min:
:param max:
:param start:
:param num:
:param withscores:
:param score_cast_func:
:return:
"""
return self.rd.zrangebyscore(key,min,max,start,num,withscores,score_cast_func)
def zrevrangebyscorekeys(self,key,max,min,start=None,num=None,withscores=False,score_cast_func=float):
"""
按照分数范围获取有序集合的元素并排序（默认按照从大到小排序）
:param key:
:param max:
:param min:
:param start:
:param num:
:param withscores:
:param score_cast_func:
:return:
"""
return self.rd.zrevrangebyscore(key,max,min,start,num,withscores,score_cast_func)
def zscankeys(self,key,cursor=0,match=None,count=None,score_cast_func=float):
"""
获取所有元素 -- 默认按照分数顺序排序
:param key:
:param cursor:
:param match:
:param count:
:param score_cast_func:
:return:
"""
return self.rd.zscan(key,cursor,match,count,score_cast_func)
def zscaniterkeys(self,key,match=None,count=None,score_cast_func=float):
"""
获取所有元素的迭代器
:param key:
:param match:
:param count:
:param score_cast_func:
:return:
"""
return self.rd.zscan_iter(key,match,count,score_cast_func)
def zcountkeys(self,key,min,max):
"""
获取key对应的有序集合中分数在[min,max] 之间的个数
:param key:
:param min:
:param max:
:return:
"""
return self.rd.zcount(key,min,max)
def zincrbykey(self,key,value,amount=1):
"""
自增key对应的有序集合key对应的分数
:param key:
:param value:
:param amount:
:return:
"""
return self.rd.zincrby(key,amount,value)
def zrankeys(self,key,value):
"""
获取某个值在key对应的有序集合中的索引(从0开始),默认是从小到大顺序
:param key:
:param value:
:return:
"""
return self.rd.zrank(key,value)
def zrevrankey(self,key,value):
"""
获取某个值在key对应的有序集合中的索引,默认是从大到小顺序
:param key:
:param value:
:return:
"""
return self.rd.zrevrank(key,value)
def zremkeys(self,key,values):
"""
删除key对应的有序集合中值是value的成员
:param key:
:param value:
:return:
"""
return self.rd.zrem(key,values)
def zremrangebyrankeys(self,key,min,max):
"""
删除根据排行范围删除，按照索引删除
:param key:
:param min:
:param max:
:return:
"""
return self.rd.zremrangebyrank(key,min,max)
def zremrangebyscoreskeys(self,key,min,max):
"""
删除根据分数范围删除，按照分数范围删除
:param key:
:param min:
:param max:
:return:
"""
return self.rd.zremrangebyscore(key,min,max)
def zscoreskeys(self,key,value):
"""
获取key对应有序集合中value对应的分数
:param key:
:param value:
:return:
"""
return self.rd.zscore(key,value)
# 其他常用操作
def deletekeys(self,*keys):
"""
根据删除redis中的任意数据类型
deletekeys(‘gender‘,‘cname‘) 可以删除多个key
:param keys:
:return:
"""
return self.rd.delete(*keys)
def existskeys(self,key):
"""
检测redis的key 是否存在，存在就返回True,False则不存在
:param key:
:return:
"""
return self.rd.exists(key)
def getkeys(self,pattern=""):
"""
根据模型获取redis的key
getkeys * 匹配数据库中所有 key 。
getkeys h?llo 匹配 hello ， hallo 和 hxllo 等。
getkeys hllo 匹配 hllo 和 heeeeello 等。
getkeys h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo
:param pattern:
:return:
"""
return self.rd.keys(pattern)
def expirekeys(self,key,time):
"""
设置超时时间，为某个key设置超时时间
:param key:
:param time: 秒
:return:
"""
return self.rd.expire(key,time)
def renamekeys(self,srckey,dstkey):
"""
对key进行重命名
:param srckey:
:param dstkey:
:return:
"""
return self.rd.rename(srckey,dstkey)
def randomkeys(self):
"""
随即获取一个key(不删除)
:return:
"""
return self.rd.randomkey()
def getkeytypes(self,key):
"""
获取key的类型
:param key:
:return:
"""
return self.rd.type(key)
def scankeys(self,cursor=0,match=None,count=None):
"""
查看所有key，终极大招
:param cursor:
:param match:
:param count:
:return:
"""
return self.rd.scan(cursor,match,count)
def scaniterkeys(self,match=None,count=None):
"""
查看所有key的迭代器，防止内存被撑爆
:param match:
:param count:
:return:
"""
return self.rd.scan_iter(match,count)
def dbsizekeys(self):
"""
当前redis包含多少条数据
:return:
"""
return self.rd.dbsize()
def savekeys(self):
"""
将数据刷入磁盘中，保存时阻塞
:return:
"""
return self.rd.save()
def flushdbkeys(self,asynchronous=False):
"""
清空当前数据库的所有数据,请谨慎使用
:param asynchronous：异步
:return:
"""
return self.rd.flushdb(asynchronous)
def flushallkeys(self,asynchronous=False):
"""
清空redis所有库中的数据，不到最后时刻 请不要使用
:param asynchronous: 异步
:return:
"""
return self.rd.flushall(asynchronous)
# 创建管道
"""
redis默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，
如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，
并且默认情况下一次pipline 是原子性操作。
管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。
它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。
"""
def createpipe(self):
"""
pipeline(transaction=False) # 默认的情况下，管道里执行的命令可以保证执行的原子性，执行pipe = r.pipeline(transaction=False)可以禁用这一特性。
pipe = r.pipeline() # 创建一个管道
pipe.set(‘name‘, ‘jack‘)
pipe.set(‘role‘, ‘sb‘)
pipe.sadd(‘faz‘, ‘baz‘)
pipe.incr(‘num‘) # 如果num不存在则vaule为1，如果存在，则value自增1
pipe.execute()
pipe.set(‘hello‘, ‘redis‘).sadd(‘faz‘, ‘baz‘).incr(‘num‘).execute()
:return:
"""
return self.rd.pipeline()
def disconectkeys(self):
return self.connPoor.disconnect()
class QueryAllData():
def __init__(self):
self.show_tables = config.mysql_show_tables
self.desc_table = config.mysql_desc_table
self.query_info = config.mysql_query_info
def query_tables_info(self):
mhelper = MySQLHelper()
tables_list = mhelper.queryTableNums(self.show_tables)
tables_attr = {}
for table in tables_list:
rows = mhelper.queryAll(self.query_info %table)
tables_attr[table] = rows
mhelper.close()
return tables_attr
def mysql2redis(self,redisobj):
mysql_data = self.query_tables_info()
for keys, values in mysql_data.items():
# keys 为表名字
for val in values:
# val 为每一行的数据
keysorted = sorted(val.keys())
for s in keysorted:
#s 为数据的key
item = ‘%s:%s‘%(keys,str(val[‘id‘]))
ischange = redisobj.hgetkey(item,s)
if ischange != val[s]:
redisobj.hsetkey(item,s,val[s])
if __name__ == "__main__":
queryalldata = QueryAllData()
rhelper = RedisHelper()
while True:
queryalldata.mysql2redis(rhelper)
redis 库用法借鉴 君惜 的内容
原文地址：http://blog.51cto.com/wuyebamboo/2324441
时间： 2024-10-01 10:47:21