redis

import redis

# 连接服务端
r = redis.Redis(host="127.0.0.1", port=6379,db=0)
# 默认redis有16个数据库，这里的db是指我们要使用的数据库


# 1、string类型操作

"""
#在Redis中设置值，默认不存在则创建，存在则修改
red.set('key', 'value')
#参数：
#     set(name, value, ex=None, px=None, nx=False, xx=False)
#     ex，过期时间（秒）
#     px，过期时间（毫秒）
#     nx，如果设置为True，则只有key不存在时，当前set操作才执行,同#setnx(key, value)
#     xx，如果设置为True，则只有key存在时，当前set操作才执行

"""

"""
import time
r.set("key1","value1",ex=5)

print(r.get("key1"))
# b'value1
time.sleep(6)
print(r.get("key1"))
# None
"""


"""
r.set("key1","value1",ex=5)
r.setnx("key1","test1")   #==r.set("key1","test2",nx=True)
# setnx:只有当key不存在时，才会设置
print(r.get("key1"),"1")
# b'value1' 1
r.set("key1","test2",xx=True)
# 只有当key存在的时，才会设置

print(r.get("key1"),"2")
# b'test2' 2
"""


"""
r.set("key1","value1",ex=5)
r.set("key2","value2",ex=5)

print(r.mget(["key1","key2"]))
# 批量获取value

# [b'value1', b'value2']
"""


"""
r.mset({"key1":"value1","key2":"value2"})
#批量设置
print(r.mget(["key1","key2"]))
# [b'value1', b'value2']
"""


"""
r.set("name","zhang")

r.getset("name","wang")
#设置新的值，并且获取到旧的值

print(r.get("name"))
"""


"""
#getrange:获取value的子序列，根据字节提取，非字符,区间是闭区间，一个汉字是3个字节
#    参数：
#         name Redis的name的值
#         start  起始位置字节
#         end    结束位置字节
r.set("name","wang母亲")

print(r.getrange("name",start=0,end=6).decode())
# wang母

"""


"""
#修改字符串的内容，从指定的字符串索引开始向后替换，如果新的值过长，则向后添加
  # 参数：
  #       offset 字符串的索引，字节，一个汉字3个字节
  #       value   要设置的值


print(r.get("name").decode())
# wang母亲


r.setrange("name",offset=0,value="zang父")

print(r.get("name").decode())
# zang父亲

"""


# 对name对应的二进制表示的位进行操作
# 参数
#     name      redis的name
#     offect    位的索引（将值变换成二进制后进行索引）
#     value     值只能是1或者0
#

# r.setbit(name,7,0)
# 把name的value值用SCSI码表示，然后把第七位替换为0或者1
# r.setbit()


# 查看第6位的SCSI码数，从1开始数
# r.getbit("name",6)


"""
print(r.get("name").decode("utf-8"))
# zang父亲


# 返回value的长度，一个汉字是3个字节
print(r.strlen("name"))
# 10
"""


"""
# key存在，则在key对应的value上加2
# key不存在，则创建key，并赋值为2
r.incr("age",2)

print(r.get("age"))

r.incr("age",2)

print(r.get("age"))

# key存在，则在key对应的value上减2
# key不存在，则创建key，并赋值为2
r.decr("age",3)
print(r.get("age"))

r.decr("count",12)
"""


"""
#在原有的values上追加字符串，相当于拼接
print(r.get("name").decode("utf-8"))
# zang父亲test1234

r.append("name","test1234")

print(r.get("name").decode("utf-8"))
# zang父亲test1234test1234
"""



# 2、Hash类型操作：这个意思就是name对应的是一个字典或者叫Hash

# name             hash
#
# name1 ----------> k1-->v1
#                   k2-->v2
#                   k3-->v3
#
#
#
#
# name2 ----------> k1-->v1
#                   k2-->v2
#                   k3-->v3

"""
#单独设置hash
r.hset("stu_info","stu1","a")
r.hset("stu_info","stu2","b")
r.hset("stu_info","stu3","c")

print(r.hget("stu_info","stu3"))

# b'c'
"""


"""
#批量set和批量get
r.hmset("stu_info",{"stu4":"d","stu5":"e","stu6":"f"})

print(r.hmget("stu_info",["stu4","stu5"]))
# [b'd', b'e']
"""


"""
#获取name对应的dict
print(r.hgetall("stu_info"))
# {b'stu1': b'a', b'stu2': b'b', b'stu3': b'c', b'stu4': b'd', b'stu5': b'e', b'stu6': b'f'}
"""

"""
# 获取name对应的hash的key的个数
print(r.hlen("stu_info"))
# 6

"""

"""
# 获取name对应的key和value
print(r.hkeys("stu_info"))
# [b'stu1', b'stu2', b'stu3', b'stu4', b'stu5', b'stu6']

print(r.hvals("stu_info"))
# [b'a', b'b', b'c', b'd', b'e', b'f']
"""

"""
# 判断name对应的key是否存在
print(r.hexists("stu_info","test1"))
# False
print(r.hexists("stu_info","stu1"))
# True
"""


"""
# 删除name对应的hash的key
print(r.hdel("stu_info","stu1"))
# 1
print(r.hexists("stu_info","stu1"))
# False

"""

"""
# 对name对应的hash的key对应的value加指定的数
r.hset("stu_info","stu7",100)
print(r.hget("stu_info","stu7"))
# b'100'
r.hincrby("stu_info","stu7",100)
print(r.hget("stu_info","stu7"))
# b'200'
"""


# 3、List类型操作：这个意思就是name对应的是一个字典或者叫list

# 添加元素，从左边push,从右边pus


"""
# 从左边插入
# 从右边插入
#获取指定索引范围的值
r.lpush("listtest","list1","list2")
r.rpush("listtest","listA","listB")
#
print(r.lrange("listtest",start=0,end=10))
# [b'list2', b'list1', b'listA', b'listB']
"""



"""
# 获取长度
print(r.llen("listtest"))
# 4
"""


"""
# 插入值
r.linsert("listtest",where="before",refvalue="list1",value="list0")

print(r.lrange("listtest",start=0,end=10))

# where = before|after
# refvalue  list中某个元素的值，在这个值后面获取前面插入一个值,在找到的第一个元素前面或者后面
# value    插入的值

"""


"""
# 在name对应的列表中移除没有在start-end索引之间的值
r.ltrim("listtest",start=0,end=1)
print(r.lrange("listtest",start=0,end=10))
"""


"""
# 对指定索引的元素重新赋值，最后一个值的索引是-1
print(r.lrange("listtest",start=0,end=10))
# [b'list2', b'list0']
r.lset("listtest",1,"list3")

print(r.lrange("listtest",start=0,end=10))
# [b'list2', b'list3']
"""



"""
#删除name对应的list中的指定值
r.lrem("listtest",count=0,value="list3")

# 参数：
#    name:  redis的name
#    value: 要删除的值
#    count:   count=0 删除列表中所有的指定值；
#           count=2 从前到后，删除2个；
#           count=-2 从后向前，删除2个'''

print(r.lrange("listtest",start=0,end=10))
# [b'list2']
"""


"""
# 移除左侧的第一个元素
r.lpop("listtest")
print(r.lrange("listtest",start=0,end=10))
# []
"""


"""
# 移除右侧的第一个元素
# r.lpush("listtest","list1","list2")
# r.rpush("listtest","listA","listB")
print(r.lrange("listtest",start=0,end=10))
# [b'list2', b'list1', b'listA', b'listB']
r.rpop("listtest")
print(r.lrange("listtest",start=0,end=10))
# [b'list2', b'list1', b'listA']
"""

"""
#通过索引获取name对应的list的值
print(r.lindex("listtest",0))
# b'list2'
"""



# 4、Set操作，集合操作，set集合就是不允许重复的列表

"""
# 设置值，获取值，获取值的个数
#最终的list中只有一个1和一个3，为name对应的集合添加元素
# r.sadd("set_list","1","3","1")

# 查看某个name的集合的元素，但是会带一个优先级
print(r.sscan("set_list"))
# (0, [b'1', b'3'])

# 获取name对应的集合的元素的个数
print(r.scard("set_list"))
# 2
"""



# 比较2个都在redis中的set的差集，求在set1对应的集合，且不在set2对应的集合的值的集合
# r.sdiff("set1", "set2")

# 把a和b对应的集合存到c对应的集合中
# r.sdiffstore("a", "b", "c")
r.sadd("set_list","1","3","2")
r.sadd("set_list1","1","3","2","abc")
r.sadd("set_list2","1","a")

r.sdiffstore("set_list","set_list1","set_list2")
print(r.sscan("set_list2"))
print(r.sscan("set_list1"))

# 求name为a对应的集合和name为b对应的集合的交集
# r.sinter("a", "b")

# 判断value是否在name对应的集合中

# r.sismember(name,value)



# 获取某个name对应的集合的元素
# r.smembers()

# 将name为a对应的集合中的元素"c"移到name为b对应的集合中，a中就没有这个原始怒
# r.smove("a", "b", "c")

# 从集合的右侧（尾部）移除第一个成员，并将其返回
# r.spop()

# 删除随机的h获取number个元素
# r.srandmember("name", 20)

##删除某个值
# r.srem()

# 获取多个name对应的集合的并集
# r.sunion()

# 获取b、c、d。。。。。的集合的并集，并将结果保存到a对应的集合中
# r.sunionstore("a","b","d","d".....)





"""
# 删除某个k
# r.delete("set_list1")

# 判断某个k是否存在,存在为1，不存在为0
print(r.exists("set_list"))

# 给某个k设置超时时间
r.expire("set_list",time=2)

import time
time.sleep(5)

print(r.exists("set_list"))

"""

"""
# g重命名某个k的名字
r.rename("stu_info","stu_info1")

print(r.exists("stu_info"))

# 将name中的某个值移到db中
# r.move(name,db)
"""



"""
# 随机获取个name的值，但是不删除
print(r.randomkey())

# b'k2'
# 获取name对应的值类型
print(r.type("stu_info"))


# b'hash'
"""


"""
# 清库操作
# flushdb(self,asynchronous=False)
#清空当前db中的数据,默认是同步。若开启异步asynchronous=True，会新起一个线程进行清空操作，不阻塞主线程

# flushall(self,asynchronous=False)
#清空所有db中的数据，默认是同步。异步同flushdb
"""


"""
#有序集合的操作
#有序集合，在集合的基础上，为每个元素排序，元素的排序需要根据另外一个值来决定，
#元素有2个值，即值和分数，分数专门用来做排序
 
#值为a，分数为10，值为b，分数为4，分数小的靠前
r.zadd("name","a",10,"b",4)
 
#查看有序集合的元素的值
r.zscan()
 
#获取有序集合的长度
r.zcard()
 
 
#获取有序集合中分数在[min，max]之间的个数
r.zcount()
 
#可以自增有序集合中某个元素的分数
r.zincrby()
 
 
#获取name对应的集合中分数在34和59的元素
r.zrangebyscore("name",34,59)
"""