• Python3操作Redis最新版|CRUD基本操作(保姆级)

    Python3中类的高级语法及实战

    Python3(基础|高级)语法实战(|多线程|多进程|线程池|进程池技术)|多线程安全问题解决方案

    Python3数据科学包系列(一):数据分析实战

    Python3数据科学包系列(二):数据分析实战

    Python3数据科学包系列(三):数据分析实战

    Win11查看安装的Python路径及安装的库

    Python PEP8 代码规范常见问题及解决方案

    Python3操作MySQL8.XX创建表|CRUD基本操作

    Python3操作SQLite3创建表主键自增长|CRUD基本操作

    anaconda3最新版安装|使用详情|Error: Please select a valid Python interpreter

    Python函数绘图与高等代数互融实例(一):正弦函数与余弦函数

    Python函数绘图与高等代数互融实例(二):闪点函数

    Python函数绘图与高等代数互融实例(三):设置X|Y轴|网格线

    Python函数绘图与高等代数互融实例(四):设置X|Y轴参考线|参考区域

    Python函数绘图与高等代数互融实例(五): 则线图综合案例

    Python3操作MongoDb7最新版创建文档及CRUD基本操作

     Python3操作Redis官方详细文档

    Java OR Mapping  Redis文档: 

    Adding Redis OM Spring Java对象到Redis对象关系映射高级应用

    对象关系映射Maven三角坐标

    Python操作Redis高级方式: 异步操作Redis|管道|事务等操作 

    找准文档,对症下药,精准匹配,求人不如求文档,码农小菜鸟

                                                                  精准扶贫|保姆服务 

     

    一: Redis连接

    认知升维

    Python3连接Redis操作 StrictRedis跟Redis的区别在于，StrictRedis用于实现大部分官方命令，并使用官方的语法和命令，Redis是StrictRedis的子类，兼容一些老版本。 Redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。

    1. import redis
    2.  
    3. """
    4.     Python3连接Redis操作
    5.     StrictRedis跟Redis的区别在于，StrictRedis用于实现大部分官方命令，并使用官方的语法和命令，Redis是StrictRedis的子类，兼容一些老版本。
    6.     Redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。
    7. """
    8. print("当前python引入的Redis版本", redis.__version__)
    9. linkRedis = None
    10. try:
    11.     linkRedis = redis.StrictRedis(host='192.168.1.111', port=6379, db=0)  # 指定IP地址、端口、指定存放数据库
    12.     # 如果指定一些其他参数，可以看源码，将需要的参数进行指定。
    13.     print(linkRedis.dbsize())
    14. except Exception as err:
    15.     print("redis连接异常: ", err)
    16. finally:
    17.     if linkRedis is not None:
    18.         print("释放连接资源")
    19.         linkRedis.close()
    20.  
    21. print("""
    22.    连接池：
    23.        redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。每个redis实例都会维护一个自己的连接池。
    24.        可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
    25. """)
    26.  
    27. pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    28. redisLink = None
    29. try:
    30.     redisLink = redis.Redis(connection_pool=pool)
    31. except Exception as err:
    32.     print("redis连接异常: ", err)
    33. finally:
    34.     if linkRedis is not None:
    35.         print("redis连接还给连接池")
    36.         redisLink.close()

    1. 运行效果:
    2.  
    3. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorLinkcreate.py 
    4. 当前python引入的Redis版本 5.0.1
    5. 0
    6. 释放连接资源
    7.  
    8.    连接池：
    9.        redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。每个redis实例都会维护一个自己的连接池。
    10.        可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
    11.  
    12. redis连接还给连接池
    13.  
    14. Process finished with exit code 0

    二: Python操作Redis插入数据

    1. import time
    2.  
    3. import redis
    4.  
    5. """
    6.    Python3连接Redis插入数据
    7. """
    8. pool = None
    9. redisLink = None
    10. try:
    11.     pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    12.     redisLink = redis.Redis(connection_pool=pool)
    13.     result = redisLink.set('key', '你好,欢迎来到Python3操作(Redis7.2.0)Redis应用')  # key 代表是键  value:hello redis 代表是值
    14.     print("""
    15. 字符串操作，redis中的String再内存中按照一个name对应一个value来存储。
    16. set(name, value, ex=None, px=None, nx=False, xx=False)
    17. 再Redis中设置值，不存在则创建、存在即修改
    18. 参数：
    19.     ex：过期时间(秒)
    20.     px：过期时间(毫秒)
    21.     nx：如果为True，当name不存在时，当前set操作会执行
    22.     xx：如果为True，当name存在时，当前set操作会执行
    24.     """)
    25.     print(result)  # 打印结果：True 说明设置成功
    26.     print("获取Key对应的值: ", redisLink.get('key'))
    27.  
    28.     # ex: 设置过期时间(单位:秒)  name为Key  '老杨' 为value
    29.     redisLink.set("name", "老杨", ex=3)
    30.     time.sleep(1)
    31.     resultValue = redisLink.get('name')
    32.     print("请叫我:%s" % resultValue)
    33.     time.sleep(3)
    34.     print("3秒后请叫我无名小卒")
    35.     print('name = %s' % (redisLink.get('name')))
    36.  
    37. except Exception as err:
    38.     print("redis连接异常: ", err)
    39. finally:
    40.     print()
    41.     if redisLink is not None:
    42.         print("释放资源,连接还给连接池")
    43.         redisLink.close()
    44.  
    45.  
    46.  
    47.  
    48. 运行效果:
    49.  
    50. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorInsert.py 
    51.  
    52. 字符串操作，redis中的String再内存中按照一个name对应一个value来存储。
    53. set(name, value, ex=None, px=None, nx=False, xx=False)
    54. 再Redis中设置值，不存在则创建、存在即修改
    55. 参数：
    56.     ex：过期时间(秒)
    57.     px：过期时间(毫秒)
    58.     nx：如果为True，当name不存在时，当前set操作会执行
    59.     xx：如果为True，当name存在时，当前set操作会执行
    60.  
    61.     
    62. True
    63. 获取Key对应的值:  你好,欢迎来到Python3操作(Redis7.2.0)Redis应用
    64. 请叫我:老杨
    65. 3秒后请叫我无名小卒
    66. name = None
    67.  
    68. 释放资源,连接还给连接池
    69.  
    70. Process finished with exit code 0

    三: Python3操作Redis查询数据

    1. import time
    2. import redis
    3.  
    4. """
    5.    Python3连接Redis查询数据
    6. """
    7. pool = None
    8. redisLink = None
    9. try:
    10.     pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    11.     redisLink = redis.Redis(connection_pool=pool, encoding='UTF-8')
    12.     print("""
    13.     getrange(key, start, end):
    14.     获取子序列(根据字节获取,非字符)
    15.     一个汉字3个字节 1个字母一个字节 每个字节8bit
    16.     参数：
    17.         name：redis的name
    18.         start：起始位置(字节)
    19.         end：结束位置(字节)
    20.     """)
    21.     redisLink.set('detail', '详情信息')
    22.     # 取索引号是0-2 前3位字节
    23.     print(redisLink.getrange('detail', 0, 2))
    24.     # 取所有的信息
    25.     print(redisLink.getrange('detail', 0, -1))
    26.     # 输出结果：详情信息
    27.     redisLink.set('title', 'good')
    28.     print(redisLink.getrange('title', 0, 2))
    29.     # 输出结果：goo
    30.     print(redisLink.getrange('title', 0, -1))
    31.     # 输出结果：good
    32.     print()
    33.     print("""
    34.        incr(name, amount=1)：
    35.         自增name对应的值，当name不存在时，创建name=amount，存在则自增
    36.         参数：
    37.             name：redis的name
    38.             amount：自增数(必须是整数)
    39.     """)
    40.     print()
    41.     # 自增name='incr' 每次自增 +1
    42.     redisLink.incr('incr', amount=1)
    43.     print(redisLink.get('incr'))
    44.     # 输出结果：+1
    45.     # 应用场景：记录页面的点击次数。
    46.  
    47.     print()
    48.     print("""
    49.        incrbyfloat(name, amount=1.0):
    50.             自增name对应得值，当name不存在时，创建name=amount，存在则自增
    51.             参数：
    52.                 name：redis的name
    53.                 amount：自然数(浮点数)
    54.     """)
    55.     # 设置name='num'
    56.     redisLink.set('num', '0.00')
    57.     print(redisLink.get('num'))
    58.     # 输出结果：0.00
    59.  
    60.     # 自增浮点数
    61.     redisLink.incrbyfloat('num', amount=1.0)
    62.     print(redisLink.get('num'))
    63.  
    64.     print("""
    65.         decr(name, amout=1):
    66.         自减name对应的值，当name不存在时，创建name=amount，存在则自增
    67.         参数：
    68.             name：redis的name
    69.             amount：自减数(整数)
    70.     """)
    71.     # 先查询name='num' 是否存在, 若存在 将对应的value 自减 1 ，不存在创建
    72.     redisLink.decr('num', amount=1)
    73.     print(redisLink.get('num'))
    74.     # 输出结果： -1
    75.     print()
    76.     print("""
    77.        append(key, value):
    78.         再redis name对应的值后面追加内容
    79.         参数：
    80.             key：redis的name
    81.             value：追加的字符串
    82.     """)
    83.     # 原name='name' 对应的value='老杨'
    84.     redisLink.append('name', 'laogao')
    85.     print('拼接后的字符串为: ', redisLink.mget('name'))
    86.     # 输出结果：['老杨laogao'] 将value 拼接再一起
    87.     print("操作列表")
    88.     print()
    89.     print("""
    90.         lpush(name, values):
    91.         从左边新增加，不存在就新建
    92.     """)
    93.     # 往name='list' 中从左添加value=[11, 22, 33]
    94.     redisLink.lpush('list', 11, 22, 33)
    95.  
    96.     print(redisLink.lrange('list', 0, -1))
    97.     # 输出结果：['33', '22', '11']  保存顺序为 33，22，11
    98.     print("""
    99.        rpush(name, values):
    100.        从右边新增加，不存在就新建
    101.     """)
    102.     # name='list1' 中从右添加value=[66, 55, 44]
    103.     redisLink.rpush('list1', 66, 55, 44)
    104.  
    105.     print(redisLink.lrange('list1', 0, -1))
    106.     # 输出结果：['66', '55', '44']
    107.     print("""
    108.       llen(name):
    109.       获取列表长度
    110.     """)
    111.     # 获取name='list1' 列表中的长度 value=[66, 55, 44]
    112.     print(redisLink.llen('list1'))
    113.     # 输出结果： 3
    114.     print("""
    115.        lpushx(name, value):
    116.        往已经有的name的列表的左边添加元素，没有的话无法创建
    117.     """)
    118.     # 首先redis数据库中没有name='list2'
    119.     redisLink.lpushx('list2', 10)
    120.     print(redisLink.lrange('list2', 0, -1))
    121.     # 输出结果： []
    122.     print("""
    123.       rpushx(name, value):
    124.       往已经有的name的列表的右边添加元素，没有的话无法创建
    125.     """)
    126.     # 首先redis数据库中没有name='list2'
    127.     redisLink.rpushx('list2', '10')
    128.     print(redisLink.lrange('list2', 0, -1))
    129.     # 输出结果： []
    130.     print("""
    131.        linsert(name, where, refvalue, value):
    132.         在name对应的列表的某一个值前或后插入一个新值
    133.         参数：
    134.         name：redis的name
    135.         where：BEFORE或AFTER
    136.         refvalue：标杆值 (以它为基础, 前后插入新值)
    137.         value：要插入的数据
    138.     """)
    139.     # 往列表中左边第一个出现的元素"66"前插入元素"77", 若name不存在, 不会新创建, 会返回[]
    140.     redisLink.linsert('list1', 'before', '66', '77')  # 目前数据库list1=[66, 55, 44]
    141.     print(redisLink.lrange('list1', 0, -1))
    142.     # 输出结果： ['77', '66', '55', '44']
    143.     print("""
    144.        lset(name, index, value)：
    145.         对name对应的list中的某一个索引位置重新赋值
    146.         参数：
    147.         name：redis的name
    148.         index：list的索引位置
    149.         value：要设置的新值
    150.     """)
    151.     # 将list1中索引为3, 替换成'33', list1=['77', '66', '55', '44']
    152.     redisLink.lset('list1', 3, '33')
    153.     print(redisLink.lrange('list1', 0, -1))
    154.     # 输出结果: ['77', '66', '55', '33']
    155.     print("""
    156.       lrem(name, value, num):
    157.         name对应的list中删除指定的值
    158.         参数：
    159.         name：redis的name
    160.         value：要删除得值
    161.         num：num=0，删除列表中所有的值
    162.         num=2，从前向后，删除2个；
    163.         num=-2， 从后向前，删除2个；
    164.     """)
    165.     # list1=['77', '66', '55', '33']
    166.  
    167.     # 从左向右, 找到value='66' 删除一个
    168.     redisLink.lrem("list1", 1, "66")
    169.     print(redisLink.lrange('list1', 0, -1))
    170.     # 输出结果：['77', '55', '33']
    171.  
    172.     # list1=['77', '55', '33']
    173.     # 从右向左, 找到value='55', 删除一个
    174.     redisLink.lrem('list1', -1, '55')
    175.     print(redisLink.lrange('list1', 0, -1))
    176.     # 输出结果：['77', '33']
    177.  
    178.     # list1=['77', '77', '33']
    179.     # 删除name='list1'中 value='77'的所有值
    180.     redisLink.lrem('list1', 0, '77')
    181.     print(redisLink.lrange('list1', 0, -1))
    182.     # 输出结果：
    183.     print("""
    184.       lpop(name) 、rpop(name):
    185.         在name对应的列表的左侧/右侧获取第一个元素并在列表中移除，返回值则是第一个元素
    186.     """)
    187.     # list1 = ['77', '66', '55']
    188.  
    189.     result = redisLink.lpop('list1')
    190.     print(result)  # 输出结果：77
    191.     print(redisLink.lrange('list1', 0, -1))  # 输出结果：['66', '55']
    192.  
    193.     # list1 = ['66', '55']
    194.  
    195.     result = redisLink.rpop('list1')
    196.     print(result)  # 输出结果：55
    197.     print(redisLink.lrange('list1', 0, -1))  # 输出结果：['66']
    198.  
    199.     print("""
    200.       ltrim(name, start, end):
    201.         name对应的列表中移除没有在start-end索引之间的值
    202.         参数：
    203.         name：redis的name
    204.         start：索引的起始位置
    205.         end：索引的结束位置
    206.     """)
    207.     # list1=['77', '66', '55', '44', '33']
    208.  
    209.     # 删除name='list1'中, 不包含索引0-2的value
    210.     redisLink.ltrim('list1', 0, 2)
    211.     print(redisLink.lrange('list1', 0, -1))
    212.     # 输出结果：['77', '66', '55']
    213.     print()
    214.     print("""
    215.       lindex(name, index):
    216.         在name对应的列表中根据索引获取列表元素
    217.     """)
    218.     # list1=['77', '66', '55']
    219.  
    220.     # 取出name='list1'中索引为1的值
    221.     print(redisLink.lindex('list1', 1))  # 输出结果：66
    222.     print()
    223.     print("""
    224.       brpoplpush(src, dst, timeout=0):
    225.         从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
    226.         参数：
    227.             src：取出并要移除元素的列表对应的name
    228.             dst：要插入元素的列表对应的name
    229.             timeout：当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
    230.     """)
    231.     # list = ['33', '22', '11']
    232.     # list1 = ['77', '66', '55']
    233.  
    234.     # 将name='list1' 中的Value 全部插入到name='list'中
    235.     redisLink.brpoplpush('list1', 'list', timeout=2)
    236.     print(redisLink.lrange('list', 0, -1))
    237.     # 输出结果：['77', '66', '55', '33', '22', '11']
    238.  
    239.  
    240. except Exception as err:
    241.     print("redis连接异常: ", err)
    242. finally:
    243.     print()
    244.     if redisLink is not None:
    245.         print("释放资源,连接还给连接池")
    246.         redisLink.close()
    1. 运行效果：
    2.  
    3. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorQuery.py 
    4.  
    5.     getrange(key, start, end):
    6.     获取子序列(根据字节获取,非字符)
    7.     一个汉字3个字节 1个字母一个字节 每个字节8bit
    8.     参数：
    9.         name：redis的name
    10.         start：起始位置(字节)
    11.         end：结束位置(字节)
    12.     
    13. 详
    14. 详情信息
    15. goo
    16. good
    17.  
    18.  
    19.        incr(name, amount=1)：
    20.         自增name对应的值，当name不存在时，创建name=amount，存在则自增
    21.         参数：
    22.             name：redis的name
    23.             amount：自增数(必须是整数)
    24.     
    25.  
    26. 26
    27.  
    28.  
    29.        incrbyfloat(name, amount=1.0):
    30.             自增name对应得值，当name不存在时，创建name=amount，存在则自增
    31.             参数：
    32.                 name：redis的name
    33.                 amount：自然数(浮点数)
    34.     
    35. 0.00
    36. 1
    37.  
    38.         decr(name, amout=1):
    39.         自减name对应的值，当name不存在时，创建name=amount，存在则自增
    40.         参数：
    41.             name：redis的name
    42.             amount：自减数(整数)
    43.     
    44. 0
    45.  
    46.  
    47.        append(key, value):
    48.         再redis name对应的值后面追加内容
    49.         参数：
    50.             key：redis的name
    51.             value：追加的字符串
    52.     
    53. 拼接后的字符串为:  ['老杨laogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogaolaogao']
    54. 操作列表
    55.  
    56.  
    57.         lpush(name, values):
    58.         从左边新增加，不存在就新建
    59.     
    60. ['33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11']
    61.  
    62.        rpush(name, values):
    63.        从右边新增加，不存在就新建
    64.     
    65. ['33', '44', '33', '44', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '55', '44']
    66.  
    67.       llen(name):
    68.       获取列表长度
    69.     
    70. 36
    71.  
    72.        lpushx(name, value):
    73.        往已经有的name的列表的左边添加元素，没有的话无法创建
    74.     
    75. []
    76.  
    77.       rpushx(name, value):
    78.       往已经有的name的列表的右边添加元素，没有的话无法创建
    79.     
    80. []
    81.  
    82.        linsert(name, where, refvalue, value):
    83.         在name对应的列表的某一个值前或后插入一个新值
    84.         参数：
    85.         name：redis的name
    86.         where：BEFORE或AFTER
    87.         refvalue：标杆值 (以它为基础, 前后插入新值)
    88.         value：要插入的数据
    89.     
    90. ['33', '44', '33', '44', '55', '44', '77', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '55', '44']
    91.  
    92.        lset(name, index, value)：
    93.         对name对应的list中的某一个索引位置重新赋值
    94.         参数：
    95.         name：redis的name
    96.         index：list的索引位置
    97.         value：要设置的新值
    98.     
    99. ['33', '44', '33', '33', '55', '44', '77', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '55', '44']
    100.  
    101.       lrem(name, value, num):
    102.         name对应的list中删除指定的值
    103.         参数：
    104.         name：redis的name
    105.         value：要删除得值
    106.         num：num=0，删除列表中所有的值
    107.         num=2，从前向后，删除2个；
    108.         num=-2， 从后向前，删除2个；
    109.     
    110. ['33', '44', '33', '33', '55', '44', '77', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '55', '44']
    111. ['33', '44', '33', '33', '55', '44', '77', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '44']
    112. ['33', '44', '33', '33', '55', '44', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '44']
    113.  
    114.       lpop(name) 、rpop(name):
    115.         在name对应的列表的左侧/右侧获取第一个元素并在列表中移除，返回值则是第一个元素
    116.     
    117. 33
    118. ['44', '33', '33', '55', '44', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66', '44']
    119. 44
    120. ['44', '33', '33', '55', '44', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '55', '44', '66', '44', '66', '66']
    121.  
    122.       ltrim(name, start, end):
    123.         name对应的列表中移除没有在start-end索引之间的值
    124.         参数：
    125.         name：redis的name
    126.         start：索引的起始位置
    127.         end：索引的结束位置
    128.     
    129. ['44', '33', '33']
    130.  
    131.  
    132.       lindex(name, index):
    133.         在name对应的列表中根据索引获取列表元素
    134.     
    135. 33
    136.  
    137.  
    138.       brpoplpush(src, dst, timeout=0):
    139.         从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
    140.         参数：
    141.             src：取出并要移除元素的列表对应的name
    142.             dst：要插入元素的列表对应的name
    143.             timeout：当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
    144.     
    145. ['33', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11']
    146.  
    147. 释放资源,连接还给连接池
    148.  
    149. Process finished with exit code 0

     

    四: Python3操作Redis删除数据

     

     

    1. import time
    2. import redis
    3.  
    4. """
    5.    Python3连接Redis删除数据
    6. """
    7. pool = None
    8. redisLink = None
    9. try:
    10.     pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    11.     redisLink = redis.Redis(connection_pool=pool, encoding='UTF-8')
    12.     print("""
    13.       delete(*names) :
    14.         根据删除redis中的任意数据类型（string、hash、list、set、有序set）
    15.     """)
    16.     result = redisLink.delete('hash1')  # 删除key为hash1的键值对
    17.     print(result)
    18.     result = redisLink.delete('name')  # 删除key为name的值对
    19.     print(result)
    20.     result = redisLink.delete('list1')  # 删除key为list1的值对
    21.     print(result)
    22. except Exception as err:
    23.     print("redis连接异常: ", err)
    24. finally:
    25.     print()
    26.     if redisLink is not None:
    27.         print("释放资源,连接还给连接池")
    28.         redisLink.close()
    29.  
    30.  
    31.  
    32.  
    33. 运行效果
    34.  
    35. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorDelete.py 
    36.  
    37.       delete(*names) :
    38.         根据删除redis中的任意数据类型（string、hash、list、set、有序set）
    39.     
    40. 0
    41. 1
    42. 1
    43.  
    44. 释放资源,连接还给连接池
    45.  
    46. Process finished with exit code 0
    47.  
    48.

    五: Python3操作Redis常规操作

     

     

     

    1. import redis
    2.  
    3. """
    4.    Python3常规操作数据
    5. """
    6. pool = None
    7. redisLink = None
    8. try:
    9.     pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    10.     redisLink = redis.Redis(connection_pool=pool, encoding='UTF-8')
    11.     print("""
    12.        exists(name)：
    13.         检测redis的name是否存在，存在就是True，False 不存在
    14.     """)
    15.     print(redisLink.exists('hash1'))  # 输出结果：False 说明key 不存在
    16.     print(redisLink.exists('set1'))  # 输出结果：True  说明key存在
    17.     print(redisLink.exists('list1'))  # 输出结果：True  说明key存在
    18.     print(redisLink.exists('name'))  # 输出结果：True  说明key存在
    19.     print()
    20.     print("""
    21.        expire(name ,time) :
    22.        为某个redis的某个name设置超时时间
    23.     """)
    24.     redisLink.lpush('list5', 11, 22)
    25.     redisLink.expire('list5', time=3)
    26.     print(redisLink.lrange('list5', 0, -1))
    27.     # 输出结果：['22', '11']
    28.     import time
    29.  
    30.     time.sleep(3)
    31.     print(redisLink.lrange('list5', 0, -1))
    32.     # 输出结果：[]
    33.     print()
    34.     print("""
    35.       rename(src, dst) ：
    36.         对redis的name重命名
    37.     """)
    38.     redisLink.lpush('list5', 11, 22)
    39.     print(redisLink.rename('list5', 'list-5'))
    40.     # 输出结果： True 说明重命名成功
    41.     print("""
    42.       type(name) :
    43.         获取name对应值的类型
    44.     """)
    45.     print("""
    46.        查看所有元素
    47.     """)
    48.     print(redisLink.hscan("hash"))
    49.     print(redisLink.sscan("set"))
    50.     print(redisLink.zscan("zset"))
    51.     print(redisLink.getrange("string", 0, -1))
    52.     print(redisLink.lrange("list", 0, -1))
    53.     print(redisLink.smembers("set3"))
    54.     print(redisLink.zrange("zset3", 0, -1))
    55.     print(redisLink.hgetall("hash1"))
    56. except Exception as err:
    57.     print("redis连接异常: ", err)
    58. finally:
    59.     print()
    60.     if redisLink is not None:
    61.         print("释放资源,连接还给连接池")
    62.         redisLink.close()
    63.  
    64.  
    65.  
    66.  
    67. 运行效果:
    68.  
    69. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorUpdate.py 
    70.  
    71.        exists(name)：
    72.         检测redis的name是否存在，存在就是True，False 不存在
    73.     
    74. 0
    75. 0
    76. 0
    77. 1
    78.  
    79.  
    80.        expire(name ,time) :
    81.        为某个redis的某个name设置超时时间
    82.     
    83. ['22', '11']
    84. []
    85.  
    86.  
    87.       rename(src, dst) ：
    88.         对redis的name重命名
    89.     
    90. True
    91.  
    92.       type(name) :
    93.         获取name对应值的类型
    94.     
    95.  
    96.        查看所有元素
    97.     
    98. (0, {})
    99. (0, [])
    100. (0, [])
    101.  
    102. ['33', '33', '22', '11', '33', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11', '33', '22', '11']
    103. set()
    104. []
    105. {}
    106.  
    107. 释放资源,连接还给连接池
    108.  
    109. Process finished with exit code 0
     

     
     

     六: Python3操作Redis对Set集合操作
     

     
 
     

     

     

    1. import time
    2. import redis
    3.  
    4. """
    5.    Python3连接Redis集合Set数据操作
    6. """
    7. pool = None
    8. redisLink = None
    9. try:
    10.     pool = redis.ConnectionPool(host='192.168.1.111', port=6379, decode_responses=True)
    11.     redisLink = redis.Redis(connection_pool=pool, encoding='UTF-8')
    12.     print("""
    13.        sadd(name, values)：
    14.         name对应的集合中添加元素
    15.     """)
    16.     # 往集合中添加元素 name='set1'
    17.     redisLink.sadd('set1', 1, 2, 3, 4, 5, 6)
    18.     print(redisLink.smembers('set1'))
    19.     # 输出结果:set(['1', '3', '2', '5', '4', '6'])
    20.     print("""
    21.        scard(name):
    22.         name对应集合中元素个数
    23.     """)
    24.     # 'set1' = set(['1', '3', '2', '5', '4', '6'])
    25.     print(redisLink.scard('set1'))
    26.     # 输出结果： 6
    27.     print("""
    28.       smembers(name):
    29.         name对应的集合所有成员
    30.     """)
    31.     # 获取name='set1' 中的所有values值
    32.     print(redisLink.smembers('set1'))
    33.     # 输出结果: set(['1', '3', '2', '5', '4', '6'])
    34.     print("""
    35.        sscan(name, cursor=0, match=None, count=None):
    36.         name对应集合所有成员(元组形式)
    37.     """)
    38.     print(redisLink.sscan('set1'))
    39.     # 输出结果：(0L, ['1', '2', '3', '4', '5', '6'])
    40.     print("""
    41.       sscan_iter(name, match=None, count=None):
    42.         name对应集合所有成员(迭代器的方式)
    43.     """)
    44.     for item in redisLink.sscan_iter('set1'):
    45.         print(item)
    46.  
    47.     print("""
    48.       sdiff(key, *args)：
    49.         求集合中的差集
    50.     """)
    51.     # name是set1、set2中values的值
    52.     # set1 = set(['1', '3', '2', '5', '4', '6'])
    53.     # set2 = set(['8', '5', '7', '6'])
    54.  
    55.     # 在集合set1中但是不在集合set2中的values值
    56.     print(redisLink.sdiff('set1', 'set2'))
    57.     # 输出结果:set(['1', '3', '2', '4'])
    58.  
    59.     # 在集合set2中但是不在集合set1中的values值
    60.     print(redisLink.sdiff('set2', 'set1'))
    61.     # 输出结果：set(['8', '7'])
    62.     print("""
    63.        sdiffstore(dest, keys, *args)：
    64.         将两个集合中的差集，存储到第三个集合中
    65.     """)
    66.     # 在集合set1但是不再集合set3中的values值, 存储到set3集合中
    67.     redisLink.sdiffstore('set3', 'set1', 'set2')
    68.     print(redisLink.smembers('set3'))
    69.     # 输出结果：set(['1', '3', '2', '4'])
    70.     print("""
    71.        sinter(keys，*args)：
    72.         获取两个集合中的交集
    73.     """)
    74.  
    75.     # 求集合set1与set2的交集
    76.     print(redisLink.sinter('set1', 'set2'))
    77.  
    78.     print("""
    79.         sunion(keys, *args):
    80.         获取多个name对应的集合并集
    81.     """)
    82.     # 获取set1与set2集合中的并集
    83.     print(redisLink.sunion('set1', 'set2'))
    84.     # 输出结果：set(['1', '3', '2', '5', '4', '7', '6', '8'])
    85.  
    86.     print("""
    87.       sunionstore(dest, keys, *args)：
    88.         将两个集合中的并集，存储到第三个集合中
    89.     """)
    90.     # 将set1与set2集合中的并集, 存储到set3中
    91.     print(redisLink.sunionstore('set3', 'set1', 'set2'))
    92.     print(redisLink.smembers('set3'))
    93.     # 输出结果：set(['1', '3', '2', '5', '4', '7', '6', '8'])
    94.     print("""
    95.       sismember(name, value):
    96.         判断是否是集合的成员
    97.     """)
    98.     # 校验value=3 是否在name=set1集合中
    99.     print(redisLink.sismember('set1', 3))
    100.     # 输出结果：True表示在集合中
    101.  
    102.     print(redisLink.sismember('set1', 33))
    103.     # 输出结果： False表示不在集合中
    104.     print("""
    105.        smove(src, dst, value):
    106.         将某个成员从一个集合中移动到另外一个集合
    107.     """)
    108.     # 目前集合set1、set2中的元素
    109.     # set1=set(['1', '3', '2', '5', '4', '6'])
    110.     # set2=set(['8', '5', '7', '6'])
    111.  
    112.     # 将set1中的value=4的元素, 移动到set2集合中
    113.     redisLink.smove('set1', 'set2', 4)
    114.     print(redisLink.smembers('set1'))
    115.     # 输出结果：set(['1', '3', '2', '5', '6'])
    116.  
    117.     print(redisLink.smembers('set2'))
    118.     # 输出结果：set(['8', '5', '4', '7', '6'])
    119.     print("""
    120.        spop(name):
    121.         从集合移除一个成员, 并将其返回(集合是无序的，所有移除也是随机的)
    122.     """)
    123.     # 目前set1集合中元素 set1=set(['1', '3', '2', '5', '6'])
    124.     # 随机删除'set1'中的Value值
    125.     print(redisLink.spop('set1'))
    126.     # 输出结果：1  说明删除的个数
    127.  
    128.     print(redisLink.smembers('set1'))
    129.     # 输出结果：set(['3', '2', '5', '6'])
    130.     print("""
    131.        srem(name, values):
    132.         在name对应的集合中删除某些值
    133.     """)
    134.     # 目前set1=set(['3', '2', '5', '6'])
    135.     print(redisLink.srem('set1', 2))
    136.     # 输出结果：1
    137.  
    138.     print(redisLink.smembers('set1'))
    139.     # 输出结果：set(['3', '5', '6'])
    140.  
    141. except Exception as err:
    142.     print("redis连接异常: ", err)
    143. finally:
    144.     print()
    145.     if redisLink is not None:
    146.         print("释放资源,连接还给连接池")
    147.         redisLink.close()
    148.  
    149.  
    150.  
    151. 运行效果：
    152.  
    153. D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\ClassGrammarRedisExecutorSet.py 
    154.  
    155.        sadd(name, values)：
    156.         name对应的集合中添加元素
    157.     
    158. {'1', '4', '6', '2', '5', '3'}
    159.  
    160.        scard(name):
    161.         name对应集合中元素个数
    162.     
    163. 6
    164.  
    165.       smembers(name):
    166.         name对应的集合所有成员
    167.     
    168. {'1', '4', '6', '2', '5', '3'}
    169.  
    170.        sscan(name, cursor=0, match=None, count=None):
    171.         name对应集合所有成员(元组形式)
    172.     
    173. (0, ['1', '2', '3', '4', '5', '6'])
    174.  
    175.       sscan_iter(name, match=None, count=None):
    176.         name对应集合所有成员(迭代器的方式)
    177.     
    178. 1
    179. 2
    180. 3
    181. 4
    182. 5
    183. 6
    184.  
    185.       sdiff(key, *args)：
    186.         求集合中的差集
    187.     
    188. {'1', '6', '2', '5', '3'}
    189. set()
    190.  
    191.        sdiffstore(dest, keys, *args)：
    192.         将两个集合中的差集，存储到第三个集合中
    193.     
    194. {'1', '6', '2', '5', '3'}
    195.  
    196.        sinter(keys，*args)：
    197.         获取两个集合中的交集
    198.     
    199. {'4'}
    200.  
    201.         sunion(keys, *args):
    202.         获取多个name对应的集合并集
    203.     
    204. {'1', '4', '6', '2', '5', '3'}
    205.  
    206.       sunionstore(dest, keys, *args)：
    207.         将两个集合中的并集，存储到第三个集合中
    208.     
    209. 6
    210. {'1', '4', '6', '2', '5', '3'}
    211.  
    212.       sismember(name, value):
    213.         判断是否是集合的成员
    214.     
    215. 1
    216. 0
    217.  
    218.        smove(src, dst, value):
    219.         将某个成员从一个集合中移动到另外一个集合
    220.     
    221. {'1', '6', '2', '5', '3'}
    222. {'4'}
    223.  
    224.        spop(name):
    225.         从集合移除一个成员, 并将其返回(集合是无序的，所有移除也是随机的)
    226.     
    227. 1
    228. {'5', '3', '2', '6'}
    229.  
    230.        srem(name, values):
    231.         在name对应的集合中删除某些值
    232.     
    233. 1
    234. {'5', '3', '6'}
    235.  
    236. 释放资源,连接还给连接池
    237.  
    238. Process finished with exit code 0
    239.  
    240.  
     

     
     

     
 
    忙着去耍帅, 后期有时间补充完整......................
     

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
【docker容器 redis密码没有生效解决办法】                            
    
java List                            
    
es（Elasticsearch）客户端Elasticsearch-head安装使用（03Elasticsearch-head安装篇）                            
    
Java的垃圾回收机制详解——从入门到出土，学不会接着来砍我！                            
    
gprof 分析程序执行时间和函数调用次数                            
    
[软件安装] tmux安装及相关事项                            
    
微泡排气除污装置有哪几种叫法吗？                            
    
Redis 分布式锁                            
    
运放电路中何时加入偏置电流补偿电阻-运算放大器                            
    
redis-Modules(TairHash)                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/u014635374/article/details/133623656
                
    •