首页手记 Python操作Redis

Python操作Redis

标签：

Python Redis 源码

一、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》高洪涛刘河飞编著

点击查看更多内容