一、Python操作Redis字符串类型
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis字符串类型
def redis_string():
#set(name, value, ex=None, px=None, nx=False, xx=False) #设置值
# ex，过期时间（秒）
r.set('juck-food1', 'Pork', ex=10)
# px，过期时间（毫秒）
r.set('juck-food2', 'mutton', px = 100)
# nx，如果设置为True，则只有name不存在时，当前set操作才执行
r.set('juck-food3', 'fish', nx = True)
# xx，如果设置为True，则只有name存在时，当前set操作才执行
r.set('juck-food4', 'beef', xx = False)
print("键juck-food1: ", r.get('juck-food1'),"键juck-food2: ", r.get('juck-food2'))
print("键juck-food3: ", r.get('juck-food3'), "键juck-food4: ", r.get('juck-food4'))
#setnx(name, value) 设置值，只有name不存在时，执行设置操作（添加）
r.setnx('animal1', 'dog')
#setex(name, value, time) 设置值，time是过期时间,单位为秒
r.setex('animal2', 'cat', 10)
print('animal1: ' , r.get('animal1'), 'animal2: ', r.get('animal2'))
#psetex(name, time_ms, value) 设置值，time_ms过期时间，单位为毫秒
r.psetex("birthday", 10000, '1994-01-01')
#mset(key..., value...) 批量设置值
#mget(key...) 批量获取值
r.mset({'a':'96','b':'97','c':'98'})
r.mset(A='65',B='66',C='67')
print(r.mget('a= ','a','b= ','b','c= ','c'))
print(r.mget(['A','C','B']))
#getset(name, value) 设置新值并获取原来的值
print(r.getset('animal1','tiger'))
#getrange(key, start, end) 获取子序列（根据字节获取，非字符）
r.set('mess','How are you?')
print('mess = ',r.getrange('mess', 0, -1))
print('mess = ', r.getrange('mess', 0, 3))
#修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
#setrange(name, offset, value)
#参数：offset，字符串的索引，字节（一个汉字三个字节）;value，要设置的值
r.setrange('mess', 3, 'come on!')
print('mess = ' , r.get('mess'))
#对name对应值的二进制表示的位进行操作
#setbit(name, offset, value)
#参数：name，redis的name;
# offset，位的索引（将值变换成二进制后再进行索引）;
# value，值只能是 1 或 0
# 对应utf-8编码，每个汉字占3个字节
str = "没有了你"
# 对于汉字for循环会按照字节迭代，先将字节转化为十进制，然后转化为二进制
for i in str:
num = ord(i)
print(bin(num).replace('a',''))
#获取name对应的值的二进制表示中的某位的值 （0或1）
#getbit(name, offset)
#a对应的二进制位，第6位是0或1
print('a的二进制：', r.getbit('a', 6))
#获取name对应的值的二进制表示中 1 的个数
#bitcount(key, start=None, end=None)
print('animal2= ', r.get('animal2'), 'animal2对应的值的二进制1的个数：', r.bitcount('animal2', 0,-1))
#获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
#bitop(operation, dest, *keys)
#参数：operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
#dest, 新的Redis的name ; *keys,要查找的Redis的name
print('位运算：',r.bitop("OR", 'color', 'red', 'blue', 'yellow', 'green'))
#strlen(name) 返回name对应值的字节长度（一个汉字3个字节）
#append(key, value) 在redis name对应的值后面追加内容
r.set('article','没有了你，万杯觥筹只不过是提醒寂寞')
print('字节长度：',r.strlen('article'))
print('追加内容：', r.append('article', '天国虽热闹'))
print('article = ', r.get('article'))
#自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。整数型
#incr(self, name, amount=1)
#自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
#decr(self, name, amount=1)
r.set('age','5')
print('age = ', r.incr('age', 10))
print('age = ', r.incr('age', amount= 5))
print('age = ', r.decr('age', amount= 6))
#自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。浮点型
#incrbyfloat(self, name, amount=1.0)
r.set('price', '5.6')
print('price = ', r.incrbyfloat('price', 3.3))
print('price = ', r.incrbyfloat('price', amount= 2.4))
if __name__ == "__main__":
redis_string()二、Python操作Redis列表类型
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis列表类型
def redis_list():
#在name对应的list中添加元素，每个新的元素都添加到列表的最左边
#lpush(name,values)
#返回列表 name 中指定区间内的元素，区间以偏移量 start 和 end 指定
#lrange(name,start,end)
#llen(name) 获取列表name的长度
r.lpush('myList', 100,200,300,400,500)
print('列表Mylist元素：', r.lrange('myList',0, -1))
print('列表MyList的长度：', r.llen('myList'))
#rpush(name,values) 向列表name的右边添加多个值
r.rpush('list1',1,2,3,4,5,6,6,6,6)
#在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
#lpushx(name,value)
r.lpushx('list-1',70) #list-1不存在
print('list-1 = ', r.lrange('list-1',0,-1))
#已经有的name的列表的右边添加元素，没有的话无法创建,一次只能添加一个
#rpushx(name,value)
r.rpushx('list1',64)
print('list1 = ', r.lrange('list1', 0, -1))
#在name对应的列表的某一个值前或后插入一个新值
#linsert(name, where, refvalue, value))
# 参数：name，redis的name; where，BEFORE或AFTER ;
# refvalue，标杆值，即：在它前后插入数据; value，要插入的数据
#往列表中左边第一个出现的元素"3"后面插入元素"100"
r.linsert('list1','after',3, 100)
print('list11 = ', r.lrange('list1', 0, -1))
#对name对应的list中的某一个索引位置重新赋值
#r.lset(name, index, value)
#参数：name，redis的name； index，list的索引位置； value，要设置的值
r.lset('list1', 1, 10000)
print('list111 = ', r.lrange('list1', 0, -1))
#r.lrem(name, value, num)在name对应的list中删除指定的值
#value，要删除的值；num， num=0，删除列表中所有的指定值；
# num=3,从前到后，删除3个； num=1,从前到后，删除左边第1个
# num=-3,从后向前，删除3个
# 将列表中左边第一次出现的"1"删除
r.lrem('list1', '1', 1)
# 将列表中所有的"6"删除
r.lrem('list1', '6', 0)
print('list12 = ', r.lrange('list1', 0, -1))
#在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
#lpop(name)
r.lpop('list1')
print('list13 = ', r.lrange('list1', 0, -1))
#在name对应的列表中移除没有在start-end索引之间的值
#ltrim(name, start, end)
r.ltrim('list1',3, 12)
print('list14 = ', r.lrange('list1', 0, -1))
#lindex(name, index)在name对应的列表中根据索引获取列表元素
print('list1索引为5的元素：', r.lindex('list1', 5))
#rpoplpush(src, dst)从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
#参数：src，要取数据的列表的name; dst，要添加数据的列表的name
r.rpoplpush('list1','list2')
print('list2 = ', r.lrange('list2', 0, 5))
#从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
#brpoplpush(src, dst, timeout=0)
# 参数：src，取出并要移除元素的列表对应的name; dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
r.brpoplpush('list1','list3', timeout= 4)
print('lsit3 = ', r.lrange('list3', 0, -1))
#blpop(keys, timeout)将多个列表排列，按照从左到右去pop对应列表的元素
# 参数：keys，redis的name的集合;
# timeout，超时时间，当元素所有列表的元素获取完之后，
# 阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
r.lpush('list4',3,4,5,6)
r.lpush('list5',7,8,9,10)
r.blpop(['lsit4','list5'], timeout= 4)
print('list4 = ', r.lrange('lsit4',0,-1), 'lsit5 = ', r.lrange('list5', 0, -1))
if __name__ == "__main__":
redis_list()三、Python操作Redis集合类型
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
import time
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis 集合（set)无序
def redis_set():
#sadd(name,values)name对应的集合中添加元素
#scard(name) 获取name对应的集合中元素个数
#smembers(name) 获取name对应的集合的所有成员
#获取集合中所有的成员--元组形式
#sscan(name, cursor=0, match=None, count=None)
# 获取集合中所有的成员--迭代器的方式;
#sscan_iter(name, match=None, count=None)
r.sadd('set1', 100,98,60,56,88,70,93,40)
r.sadd('set2', 89, 70, 44, 30, 67, 80, 93, 1, 5)
print('集合的长度：', r.scard('set1'))
print('集合中的所有成员：', r.smembers('set1'))
print('集合中所有的成员--元组形式: ', r.sscan('set1'))
for i in r.sscan_iter('set1'):
print('集合set1：', i)
#sdiff(keys, *args)
# 差集，在第一个name对应的集合中且不在其他name对应的集合的元素集合
#sdiffstore(dest, keys, *args)
# 获取第一个name对应的集合中且不在其他name对应的集合，
#再将其新加入到dest对应的集合中
print('set1和set2的差集：', r.sdiff('set1', 'set2'))
print('set1和set2的差集，并存入set3: ', r.sdiffstore('set3', 'set1', 'set2'))
print('set3 = ', r.smembers('set3'))
#sinter(keys, *args)
#交集，获取多一个name对应集合的交集
#sinterstore(dest, keys, *args)
#获取多一个name对应集合的并集，再将其加入到dest对应的集合中
print('set1和set2的交集：', r.sinter('set1', 'set2'))
print('set1和set2的交集,并存入set4: ', r.sinterstore('set4','set1','set2'))
print('set4 = ', r.smembers('set4'))
#sunion(keys, *args)
#并集，获取多个name对应的集合的并集
#sunionstore(dest, keys, *args)
#获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
print('set1和set2的并集：', r.sunion('set1','set2'))
print('set1和set2的并集,并存入set5: ', r.sunion('set5', 'set1', 'set2'))
print('set5 = ', r.smembers('set5'))
#sismember(name, value)
#判断value是否是name对应的集合的成员，结果为True和False
print('元素100是否在集合set1中：', r.sismember('set1', '100'))
#smove(src, dst, value)
#将某个成员从一个集合中移动到另外一个集合
r.smove('set4', 'set5',100)
print('集合元素移动set4：', r.smembers('set4'))
print('集合元素移动set5：', r.smembers('set5'))
#spop(name)
#从集合移除一个成员，并将其返回，集合是无序的，所有是随机删除的
print('随机返回一个集合元素：', r.spop('set1'))
#srem(name, values)在name对应的集合中删除某些值
print('删除指定的值：', r.srem('set1', 100))
if __name__ == "__main__":
redis_set()四、Python操作Redis有序集合类型
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis 有序集合（SortedSet)
def redis_sortedset():
#zadd(name, *args, **kwargs)在name对应的有序集合中添加元素
#zcard(name)获取name对应的有序集合元素的数量
#zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
# 按照索引范围获取name对应的有序集合的元素
#参数：name，redis的name;start，有序集合索引起始位置（非分数）;
# end，有序集合索引结束位置（非分数）
#desc，排序规则，默认按照分数从小到大排序;withscores，是否获取元素的分数，
# 默认只获取元素的值
# score_cast_func，对分数进行数据转换的函数
r.zadd('zset1', a1=100, a2=80, a3=90, a4=70, a5=60)
r.zadd('zset2', 'b1', 45,'b2', 70, 'b3', 100, 'b4', 60, 'b5', 90, 'b6',75)
print('集合zset1的长度：', r.zcard('zset1'))
print('获取有序集合中所有元素和分数：', r.zrange('zset1', 0, -1, withscores=True))
#zrevrange(name, start, end, withscores=False, score_cast_func=float)
# 从大到小排序(同zrange，集合是从大到小排序的)
print('集合从大到小1：', r.zrevrange('zset1', 0, 1))
#获取有序集合中所有元素和分数,分数倒序
print('集合从大到小2：', r.zrevrange('zset1', 0, 1,withscores=True))
#zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
#按照分数范围获取name对应的有序集合的元素
for i in range(1,50):
param = 'p' + str(i)
r.zadd('zset3', param, i)
print('取出分数在20到30之间的元素：', r.zrangebyscore('zset3', 20, 30))
print('取出分数在10到40之间的元素带分数：', r.zrangebyscore('zset3', 10, 40, withscores=True))
#zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
#按照分数范围获取有序集合的元素并排序（默认从大到小排序）
print('取出分数在40到20之间的元素(逆序): ', r.zrevrangebyscore('zset3',40, 20, withscores=True))
#zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
#获取所有元素--默认按照分数顺序排序
print('获取所有元素：', r.zscan('zset2'))
#zscan_iter(name, match=None, count=None,score_cast_func=float)
# 获取所有元素--迭代器
for i in r.zscan_iter('zset2'):
print('zset2 = ', i)
#zcount(name, min, max)
# 获取name对应的有序集合中分数 在 [min,max] 之间的个数
print('分数在30到70之间的元素个数：', r.zcount('zset2', 30, 70))
#zincrby(name, value, amount)
# 自增name对应的有序集合的 name 对应的分数
r.zincrby('zset2', 'b1', amount= 5) #每次将b1的分数值加5
r.zincrby('zset2', 'b2', amount= -5) #每次将b1的分数值减5
print('zset2 =' , r.zrange('zset2', 0, -1, withscores=True))
#zrank(name, value)
# 获取某个值在 name对应的有序集合中的索引（从 0 开始）
#zrevrank(name, value)
# 获取某个值在 name对应的有序集合中的索引, 从大到小排序
print('获取a1在对应的有序集合zset1中的索引: ',r.zrank('zset1', 'a1'))
print('获取a1在对应的有序集合zset1中的索引(倒序): ', r.zrevrank('zset1', 'a1'))
#zrem(name, values)
# 删除name对应的有序集合中值是values的成员
r.zrem('zset1', 'a1')
print('删除a1的zset1 = ', r.zrem('zset1', 'a1'))
#zremrangebyrank(name, min, max)
# 根据排行范围删除, 按照索引号来删除
r.zremrangebyrank('zset2',0,1)
#删除有序集合中的索引号是0, 1的元素
print('删除集合zset2中索引为0和1的元素：', r.zrange('zset2',0, -1))
#zremrangebyscore(name, min, max)
# 根据分数范围删除
r.zremrangebyscore('zset2', 70,80)
# 删除有序集合中的分数是70-80的元素
print('删除有序集合中的分数是70-80的元素: ', r.zrange('zset2',0, -1))
#zscore(name, value)
# 获取name对应有序集合中 value 对应的分数
print('b4的分数值：', r.zscore('zset2', 'b4'))
if __name__ == "__main__":
redis_sortedset()五、Python操作Redis哈希类型
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
import time
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis hash类型
def redis_hash():
#hset(name, key, value)
#name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
#hget(name,key)在name对应的hash中获取根据key获取value
#hmset(name, mapping) 在name对应的hash中批量设置键值对
#hmget(name, keys, *args)在name对应的hash中获取多个key的值
#hkeys(name) 获取name中的所有键
r.hset('user','name','xiaosan')
r.hset('user','city','beijing')
print('用户信息：', r.hget('user','name'),'---',r.hget('user', 'city'))
r.hmset('user', {'age':'23','sex':'男','birthday':'1996-08-08'})
r.hmset('user',{'height':'180','weight':'140'})
print('用户信息1：', r.hmget('user','age','sex','birthday','height','weight'))
print('用户信息2：', r.hmget('user', ['age', 'sex', 'birthday'], 'height', 'weight'))
print('获取user中的所有键: ', r.hkeys('user'))
#hgetall(name)获取name对应hash的所有键值
print('user中的所有键值对：',r.hgetall('user'))
#hlen(name)获取name对应的hash中键值对的个数
print('获取user对应的hash中键值对的个数: ', r.hlen('user'))
#hvals(name)获取name对应的hash中所有的value的值
print('获取user对应的hash中所有的值: ', r.hvals('user'))
#hexists(name, key) 检查name对应的hash是否存在当前传入的key
print('检查user对应的hash是否存在当前传入的city: ', r.hexists('user', 'city'))
#hdel(name,*keys)将name对应的hash中指定key的键值对删除
print('删除键值对：', r.hdel('user', 'city'))
#hincrby(name, key, amount=1)
#自增name对应的hash中的指定key的值，不存在则创建key=amount
print('用户年龄加10， 身高减5：', r.hincrby('user','age', 10),
r.hincrby('user', 'height',amount=-5))
#hincrbyfloat(name, key, amount=1.0)
#自增name对应的hash中的指定key的值，不存在则创建key=amount
print('用户的体重加3.6，身高减1.5：', r.hincrbyfloat('user', 'weight',3.6),
r.hincrbyfloat('user','height',amount=-1.5))
#hscan(name, cursor=0, match=None, count=None)
#(取值查看--分片读取)增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据
#参数：cursor，游标（基于游标分批取获取数据）；
# match，匹配指定key，默认None 表示所有的key
#count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
print(r.hscan('user', cursor=2, count= 4))
#hscan_iter(name, match=None, count=None)
#利用yield封装hscan创建生成器，实现分批去redis中获取数据
#参数：match，匹配指定key，默认None 表示所有的key;
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
for item in r.hscan_iter('user'):
print('item = ', item)
print(r.hscan_iter('user'))
if __name__ == "__main__":
redis_hash()六、Python操作Redis的其他键操作
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
#author:liuhefei
import redis
import time
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
#Redis其他操作键
def redis_key():
#delete(*names)
# 根据删除redis中的任意数据类型（string、hash、list、set、有序set）
r.delete('name')
#exists(name)检测redis的name是否存在，存在就是True，False 不存在
print('user是否存在：', r.exists('user'))
#keys(pattern='') 根据模型获取redis的name,模糊匹配
#KEYS * 匹配数据库中所有 key
print('模糊匹配：', r.keys('*'))
#expire(name ,time)为某个redis的某个name设置超时时间
r.lpush('Mylist', 0,1,2,3,4)
r.expire('Mylist', time= 10)
print('Mylist = ', r.lrange('Mylist', 0, -1))
time.sleep(10)
print('10秒后，Mylist = ', r.lrange('Mylist', 0, -1))
r.set("user","liuhefei")
#rename(src, dst) 对redis的name重命名
r.rename('user','userInfo')
print('user中的所有键值对：', r.hgetall('user'))
print('user的值：', r.get('userInfo'))
#randomkey() 随机获取一个redis的key（不删除）
print('随机获取一个key: ', r.randomkey())
#type(name) 获取name对应值的类型
print('age的类型：', r.type('age'))
if __name__ == "__main__":
redis_key()本文来源于：《从零开始学Redis》高洪涛 刘河飞 编著
随时随地看视频
