python操作redis用法詳解

轉(zhuǎn)載地址

1、redis連接

            redis提供兩個類Redis和StrictRedis用于實現(xiàn)Redis的命令，StrictRedis用于實現(xiàn)大部分官方的命令，并使用官方的語法和命令，Redis是StrictRedis的子類，用于向后兼容舊版本的redis-py。

            redis連接實例是線程安全的，可以直接將redis連接實例設(shè)置為一個全局變量，直接使用。如果需要另一個Redis實例（or Redis數(shù)據(jù)庫）時，就需要重新創(chuàng)建redis連接實例來獲取一個新的連接。同理，python的redis沒有實現(xiàn)select命令。

安裝redis

            pip install redis

連接redis，加上decode_responses=True，寫入的鍵值對中的value為str類型，不加這個參數(shù)寫入的則為字節(jié)類型。

            
              import
            
             redis   
            
              #
            
            
               導(dǎo)入redis模塊，通過python操作redis 也可以直接在redis主機的服務(wù)端操作緩存數(shù)據(jù)庫
            
            
              
r 
            
            = redis.Redis(host=
            
              '
            
            
              localhost
            
            
              '
            
            , port=6379, decode_responses=True)   
            
              #
            
            
               host是redis主機，需要redis服務(wù)端和客戶端都啟動 redis默認(rèn)端口是6379
            
            
r.set(
            
              '
            
            
              name
            
            
              '
            
            , 
            
              '
            
            
              junxi
            
            
              '
            
            )  
            
              #
            
            
               key是"foo" value是"bar" 將鍵值對存入redis緩存
            
            
              print
            
            (r[
            
              '
            
            
              name
            
            
              '
            
            
              ])

            
            
              print
            
            (r.get(
            
              '
            
            
              name
            
            
              '
            
            ))  
            
              #
            
            
               取出鍵name對應(yīng)的值
            
            
              print
            
            (type(r.get(
            
              '
            
            
              name
            
            
              '
            
            )))

2、連接池

            redis-
            
              py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認(rèn)，每個Redis實例都會維護一個自己的連接池。
可以直接建立一個連接池，然后作為參數(shù)Redis，這樣就可以實現(xiàn)多個Redis實例共享一個連接池

連接池

            
              import
            
             redis    
            
              #
            
            
               導(dǎo)入redis模塊，通過python操作redis 也可以直接在redis主機的服務(wù)端操作緩存數(shù)據(jù)庫
            
            
              
pool 
            
            = redis.ConnectionPool(host=
            
              '
            
            
              localhost
            
            
              '
            
            , port=6379, decode_responses=True)   
            
              #
            
            
               host是redis主機，需要redis服務(wù)端和客戶端都起著 redis默認(rèn)端口是6379
            
            
r = redis.Redis(connection_pool=
            
              pool)
r.set(
            
            
              '
            
            
              gender
            
            
              '
            
            , 
            
              '
            
            
              male
            
            
              '
            
            )     
            
              #
            
            
               key是"gender" value是"male" 將鍵值對存入redis緩存
            
            
              print
            
            (r.get(
            
              '
            
            
              gender
            
            
              '
            
            ))      
            
              #
            
            
               gender 取出鍵male對應(yīng)的值

3、redis基本命令 String

                set(name, value, ex=None, px=None, nx=False, xx=False)

在Redis中設(shè)置值，默認(rèn)，不存在則創(chuàng)建，存在則修改
參數(shù)：
ex，過期時間（秒）
px，過期時間（毫秒）
nx，如果設(shè)置為True，則只有name不存在時，當(dāng)前set操作才執(zhí)行
xx，如果設(shè)置為True，則只有name存在時，當(dāng)前set操作才執(zhí)行

1.ex，過期時間（秒）這里過期時間是3秒，3秒后p，鍵food的值就變成None

                
                  import
                
                
                   redis

pool 
                
                = redis.ConnectionPool(host=
                
                  '
                
                
                  localhost
                
                
                  '
                
                , port=6379, decode_responses=
                
                  True)
r 
                
                = redis.Redis(connection_pool=
                
                  pool)
r.set(
                
                
                  '
                
                
                  food
                
                
                  '
                
                , 
                
                  '
                
                
                  mutton
                
                
                  '
                
                , ex=3)    
                
                  #
                
                
                   key是"food" value是"mutton" 將鍵值對存入redis緩存
                
                
                  print
                
                (r.get(
                
                  '
                
                
                  food
                
                
                  '
                
                ))  
                
                  #
                
                
                   mutton 取出鍵food對應(yīng)的值

2.px，過期時間（豪秒）這里過期時間是3豪秒，3毫秒后，鍵foo的值就變成None

                
                  import
                
                
                   redis

pool 
                
                = redis.ConnectionPool(host=
                
                  '
                
                
                  localhost
                
                
                  '
                
                , port=6379, decode_responses=
                
                  True)
r 
                
                = redis.Redis(connection_pool=
                
                  pool)
r.set(
                
                
                  '
                
                
                  food
                
                
                  '
                
                , 
                
                  '
                
                
                  beef
                
                
                  '
                
                , px=3
                
                  )

                
                
                  print
                
                (r.get(
                
                  '
                
                
                  food
                
                
                  '
                
                ))

3.nx，如果設(shè)置為True，則只有name不存在時，當(dāng)前set操作才執(zhí)行（新建）

                
                  import
                
                
                   redis

pool 
                
                = redis.ConnectionPool(host=
                
                  '
                
                
                  localhost
                
                
                  '
                
                , port=6379, decode_responses=
                
                  True)
r 
                
                = redis.Redis(connection_pool=
                
                  pool)

                
                
                  print
                
                (r.set(
                
                  '
                
                
                  fruit
                
                
                  '
                
                , 
                
                  '
                
                
                  watermelon
                
                
                  '
                
                , nx=True))    
                
                  #
                
                
                   True--不存在
                
                
                  
#
                
                
                   如果鍵fruit不存在，那么輸出是True；如果鍵fruit已經(jīng)存在，輸出是None

4.xx，如果設(shè)置為True，則只有name存在時，當(dāng)前set操作才執(zhí)行（修改）

                
                  print
                
                ((r.set(
                
                  '
                
                
                  fruit
                
                
                  '
                
                , 
                
                  '
                
                
                  watermelon
                
                
                  '
                
                , xx=True)))   
                
                  #
                
                
                   True--已經(jīng)存在
                
                
                  
#
                
                
                   如果鍵fruit已經(jīng)存在，那么輸出是True；如果鍵fruit不存在，輸出是None

5.setnx(name, value)
設(shè)置值，只有name不存在時，執(zhí)行設(shè)置操作（添加）

                
                  print
                
                (r.setnx(
                
                  '
                
                
                  fruit1
                
                
                  '
                
                , 
                
                  '
                
                
                  banana
                
                
                  '
                
                ))  
                
                  #
                
                
                   fruit1不存在，輸出為True

6.setex(name, value, time)
設(shè)置值
參數(shù)：
time，過期時間（數(shù)字秒或 timedelta對象）

                
                  import
                
                
                   redis

                
                
                  import
                
                
                   time

pool 
                
                = redis.ConnectionPool(host=
                
                  '
                
                
                  localhost
                
                
                  '
                
                , port=6379, decode_responses=
                
                  True)
r 
                
                = redis.Redis(connection_pool=
                
                  pool)
r.setex(
                
                
                  "
                
                
                  fruit2
                
                
                  "
                
                , 
                
                  "
                
                
                  orange
                
                
                  "
                
                , 5
                
                  )
time.sleep(
                
                5
                
                  )

                
                
                  print
                
                (r.get(
                
                  '
                
                
                  fruit2
                
                
                  '
                
                ))  
                
                  #
                
                
                   5秒后，取值就從orange變成None

7.psetex(name, time_ms, value)
設(shè)置值
參數(shù)：
time_ms，過期時間（數(shù)字毫秒或 timedelta對象）

                r.psetex(
                
                  "
                
                
                  fruit3
                
                
                  "
                
                , 5000, 
                
                  "
                
                
                  apple
                
                
                  "
                
                
                  )
time.sleep(
                
                5
                
                  )

                
                
                  print
                
                (r.get(
                
                  '
                
                
                  fruit3
                
                
                  '
                
                ))  
                
                  #
                
                
                   5000毫秒后，取值就從apple變成None

8.mset(*args, **kwargs)
批量設(shè)置值
如：

                r.mget({
                
                  '
                
                
                  k1
                
                
                  '
                
                : 
                
                  '
                
                
                  v1
                
                
                  '
                
                , 
                
                  '
                
                
                  k2
                
                
                  '
                
                : 
                
                  '
                
                
                  v2
                
                
                  '
                
                
                  })
r.mset(k1
                
                =
                
                  "
                
                
                  v1
                
                
                  "
                
                , k2=
                
                  "
                
                
                  v2
                
                
                  "
                
                ) 
                
                  #
                
                
                   這里k1 和k2 不能帶引號 一次設(shè)置對個鍵值對
                
                
                  print
                
                (r.mget(
                
                  "
                
                
                  k1
                
                
                  "
                
                , 
                
                  "
                
                
                  k2
                
                
                  "
                
                ))   
                
                  #
                
                
                   一次取出多個鍵對應(yīng)的值
                
                
                  print
                
                (r.mget(
                
                  "
                
                
                  k1
                
                
                  "
                
                ))

9.mget(keys, *args)
批量獲取
如：

                
                  print
                
                (r.mget(
                
                  '
                
                
                  k1
                
                
                  '
                
                , 
                
                  '
                
                
                  k2
                
                
                  '
                
                
                  ))

                
                
                  print
                
                (r.mget([
                
                  '
                
                
                  k1
                
                
                  '
                
                , 
                
                  '
                
                
                  k2
                
                
                  '
                
                
                  ]))

                
                
                  print
                
                (r.mget(
                
                  "
                
                
                  fruit
                
                
                  "
                
                , 
                
                  "
                
                
                  fruit1
                
                
                  "
                
                , 
                
                  "
                
                
                  fruit2
                
                
                  "
                
                , 
                
                  "
                
                
                  k1
                
                
                  "
                
                , 
                
                  "
                
                
                  k2
                
                
                  "
                
                ))  
                
                  #
                
                
                   將目前redis緩存中的鍵對應(yīng)的值批量取出來

10.getset(name, value)
設(shè)置新值并獲取原來的值

                
                  print
                
                (r.getset(
                
                  "
                
                
                  food
                
                
                  "
                
                , 
                
                  "
                
                
                  barbecue
                
                
                  "
                
                ))  
                
                  #
                
                
                   設(shè)置的新值是barbecue 設(shè)置前的值是beef

11.getrange(key, start, end)
獲取子序列（根據(jù)字節(jié)獲取，非字符）
參數(shù)：
name，Redis 的 name
start，起始位置（字節(jié)）
end，結(jié)束位置（字節(jié)）
如： "君惜大大" ，0-3表示 "君"

                r.set(
                
                  "
                
                
                  cn_name
                
                
                  "
                
                , 
                
                  "
                
                
                  君惜大大
                
                
                  "
                
                ) 
                
                  #
                
                
                   漢字
                
                
                  print
                
                (r.getrange(
                
                  "
                
                
                  cn_name
                
                
                  "
                
                , 0, 2))   
                
                  #
                
                
                   取索引號是0-2 前3位的字節(jié) 君 切片操作 （一個漢字3個字節(jié) 1個字母一個字節(jié) 每個字節(jié)8bit）
                
                
                  print
                
                (r.getrange(
                
                  "
                
                
                  cn_name
                
                
                  "
                
                , 0, -1))  
                
                  #
                
                
                   取所有的字節(jié) 君惜大大 切片操作
                
                
r.set(
                
                  "
                
                
                  en_name
                
                
                  "
                
                ,
                
                  "
                
                
                  junxi
                
                
                  "
                
                ) 
                
                  #
                
                
                   字母
                
                
                  print
                
                (r.getrange(
                
                  "
                
                
                  en_name
                
                
                  "
                
                , 0, 2))  
                
                  #
                
                
                   取索引號是0-2 前3位的字節(jié) jun 切片操作 （一個漢字3個字節(jié) 1個字母一個字節(jié) 每個字節(jié)8bit）
                
                
                  print
                
                (r.getrange(
                
                  "
                
                
                  en_name
                
                
                  "
                
                , 0, -1)) 
                
                  #
                
                
                   取所有的字節(jié) junxi 切片操作

12.setrange(name, offset, value)
修改字符串內(nèi)容，從指定字符串索引開始向后替換（新值太長時，則向后添加）
參數(shù)：
offset，字符串的索引，字節(jié)（一個漢字三個字節(jié)）
value，要設(shè)置的值

                r.setrange(
                
                  "
                
                
                  en_name
                
                
                  "
                
                , 1, 
                
                  "
                
                
                  ccc
                
                
                  "
                
                
                  )

                
                
                  print
                
                (r.get(
                
                  "
                
                
                  en_name
                
                
                  "
                
                ))    
                
                  #
                
                
                   jccci 原始值是junxi 從索引號是1開始替換成ccc 變成 jccci

13.setbit(name, offset, value)
對name對應(yīng)值的二進制表示的位進行操作
參數(shù)：
name，redis的name
offset，位的索引（將值變換成二進制后再進行索引）
value，值只能是 1 或 0

              
                注：如果在Redis中有一個對應(yīng)： n1 = 
                
                  "foo"，
那么字符串foo的二進制表示為：01100110 01101111 01101111
所以，如果執(zhí)行 setbit(
                  
                    'n1', 7, 1)，則就會將第7位設(shè)置為1，
那么最終二進制則變成 01100111 01101111 01101111，即：
                    
                      "goo"

擴展，轉(zhuǎn)換二進制表示：

                      
                        source = 
                        
                          "陳思維" 
                          
                            source = 
                            
                              "foo" 
                              
                                for i 
                                
                                  in 
                                  
                                    source: num = ord(i) 
                                    
                                      print bin(num).replace(
                                      
                                        'b',
                                        
                                          '') 特別的，如果
                                          
                                            source是漢字 
                                            
                                              "陳思維"怎么辦？ 答：對于utf-8，每一個漢字占 3 個字節(jié)，那么 
                                              
                                                "陳思維" 則有 9個字節(jié) 對于漢字，
                                                
                                                  for循環(huán)時候會按照 字節(jié) 迭代，那么在迭代時，將每一個字節(jié)轉(zhuǎn)換 十進制數(shù)，然后再將十進制數(shù)轉(zhuǎn)換成二進制 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

14.getbit(name, offset)
獲取name對應(yīng)的值的二進制表示中的某位的值（0或1）

              
                
                  print(r.getbit(
                  
                    "foo1", 0)) 
                    
                      # 0 foo1 對應(yīng)的二進制 4個字節(jié) 32位 第0位是0還是1

15.bitcount(key, start=None, end=None)
獲取name對應(yīng)的值的二進制表示中 1 的個數(shù)
參數(shù)：
key，Redis的name
start 字節(jié)起始位置
end，字節(jié)結(jié)束位置

              
                
                  print(r.get(
                  
                    "foo"))  
                    
                      # goo1 01100111

                      
                        print(r.bitcount(
                        
                          "foo",0,1)) 
                          
                            # 11 表示前2個字節(jié)中，1出現(xiàn)的個數(shù)

16.bitop(operation, dest, *keys)
獲取多個值，并將值做位運算，將最后的結(jié)果保存至新的name對應(yīng)的值

參數(shù)：
operation,AND（并）、 OR（或）、 NOT（非）、 XOR（異或）
dest, 新的Redis的name
*keys,要查找的Redis的name

如：

              
                bitop(
                
                  "AND", 
                  
                    'new_name', 
                    
                      'n1', 
                      
                        'n2', 
                        
                          'n3') 獲取Redis中n1,n2,n3對應(yīng)的值，然后講所有的值做位運算（求并集），然后將結(jié)果保存 new_name 對應(yīng)的值中 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) 
                                                                              
                                                                                # 打印每個字母字符或者漢字字符對應(yīng)的ascii碼值 f-102-0b100111-01100111 
                                                                                
                                                                                  print(bin(num)) 
                                                                                  
                                                                                    # 打印每個10進制ascii碼值轉(zhuǎn)換成二進制的值 0b1100110（0b表示二進制） 
                                                                                    
                                                                                      print bin(num).replace(
                                                                                      
                                                                                        'b',
                                                                                        
                                                                                          '') 
                                                                                          
                                                                                            # 將二進制0b1100110替換成01100110

17.strlen(name)
返回name對應(yīng)值的字節(jié)長度（一個漢字3個字節(jié)）

              
                
                  print(r.strlen(
                  
                    "foo"))  
                    
                      # 4 'goo1'的長度是4

18.incr(self, name, amount=1)
自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。
參數(shù)：
name,Redis的name
amount,自增數(shù)（必須是整數(shù)）
注：同incrby

              
                r.set(
                
                  "foo", 123)

                  
                    print(r.mget(
                    
                      "foo", 
                      
                        "foo1", 
                        
                          "foo2", 
                          
                            "k1", 
                            
                              "k2")) r.incr(
                              
                                "foo", amount=1) 
                                
                                  print(r.mget(
                                  
                                    "foo", 
                                    
                                      "foo1", 
                                      
                                        "foo2", 
                                        
                                          "k1", 
                                          
                                            "k2"))

應(yīng)用場景 – 頁面點擊數(shù)
假定我們對一系列頁面需要記錄點擊次數(shù)。例如論壇的每個帖子都要記錄點擊次數(shù)，而點擊次數(shù)比回帖的次數(shù)的多得多。如果使用關(guān)系數(shù)據(jù)庫來存儲點擊，可能存在大量的行級鎖爭用。所以，點擊數(shù)的增加使用redis的INCR命令最好不過了。
當(dāng)redis服務(wù)器啟動時，可以從關(guān)系數(shù)據(jù)庫讀入點擊數(shù)的初始值（12306這個頁面被訪問了34634次）

              
                
                  r
                  
                    .set("
                    
                      visit
                      
                        :12306
                        
                          :totals", 34634) 
                          
                            print(
                            
                              r
                              
                                .get("
                                
                                  visit
                                  
                                    :12306
                                    
                                      :totals"))

每當(dāng)有一個頁面點擊，則使用INCR增加點擊數(shù)即可。

頁面載入的時候則可直接獲取這個值

19.incrbyfloat(self, name, amount=1.0)
自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。
參數(shù)：
name,Redis的name
amount,自增數(shù)（浮點型）

              
                r.set(
                
                  "foo1", 
                  
                    "123.0")
r.set(
                    
                      "foo2", 
                      
                        "221.0")

                        
                          print(r.mget(
                          
                            "foo1", 
                            
                              "foo2")) r.incrbyfloat(
                              
                                "foo1", amount=2.0) r.incrbyfloat(
                                
                                  "foo2", amount=3.0) 
                                  
                                    print(r.mget(
                                    
                                      "foo1", 
                                      
                                        "foo2"))

20.decr(self, name, amount=1)
自減 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自減。
參數(shù)：
name,Redis的name
amount,自減數(shù)（整數(shù))

              
                r.decr(
                
                  "foo4", amount=3) 
                  
                    # 遞減3
r.decr(
                    
                      "foo1", amount=1) 
                      
                        # 遞減1

                        
                          print(r.mget(
                          
                            "foo1", 
                            
                              "foo4"))

21.append(key, value)
在redis name對應(yīng)的值后面追加內(nèi)容
參數(shù)：
key, redis的name
value, 要追加的字符串

              
                r.append(
                
                  "name", 
                  
                    "haha")    
                    
                      # 在name對應(yīng)的值junxi后面追加字符串haha

                      
                        print(r.mget(
                        
                          "name"))

4、redis基本命令 hash

1.單個增加--修改(單個取出)--沒有就新增，有的話就修改
hset(name, key, value)
name對應(yīng)的hash中設(shè)置一個鍵值對（不存在，則創(chuàng)建；否則，修改）
參數(shù)：
name，redis的name
key，name對應(yīng)的hash中的key
value，name對應(yīng)的hash中的value
注：
hsetnx(name, key, value),當(dāng)name對應(yīng)的hash中不存在當(dāng)前key時則創(chuàng)建（相當(dāng)于添加）

              
                
                  import redis

                  
                    import time

pool = redis.ConnectionPool(host=
                    
                      'localhost', port=
                      
                        6379, decode_responses=
                        
                          True) r = redis.Redis(connection_pool=pool) r.hset(
                          
                            "hash1", 
                            
                              "k1", 
                              
                                "v1") r.hset(
                                
                                  "hash1", 
                                  
                                    "k2", 
                                    
                                      "v2") print(r.hkeys(
                                      
                                        "hash1")) 
                                        
                                          # 取hash中所有的key print(r.hget(
                                          
                                            "hash1", 
                                            
                                              "k1")) 
                                              
                                                # 單個取hash的key對應(yīng)的值 print(r.hmget(
                                                
                                                  "hash1", 
                                                  
                                                    "k1", 
                                                    
                                                      "k2")) 
                                                      
                                                        # 多個取hash的key對應(yīng)的值 r.hsetnx(
                                                        
                                                          "hash1", 
                                                          
                                                            "k2", 
                                                            
                                                              "v3") 
                                                              
                                                                # 只能新建 print(r.hget(
                                                                
                                                                  "hash1", 
                                                                  
                                                                    "k2"))

2 批量增加（取出）
hmset(name, mapping)
在name對應(yīng)的hash中批量設(shè)置鍵值對
參數(shù)：
name，redis的name
mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
如：

hget(name,key)
在name對應(yīng)的hash中獲取根據(jù)key獲取value
hmget(name, keys, *args)
在name對應(yīng)的hash中獲取多個key的值
參數(shù)：
name，reids對應(yīng)的name
keys，要獲取key集合，如：['k1', 'k2', 'k3']
*args，要獲取的key，如：k1,k2,k3
如：

              
                
                  print(r.hget(
                  
                    "hash2", 
                    
                      "k2"))  
                      
                        # 單個取出"hash2"的key-k2對應(yīng)的value

                        
                          print(r.hmget(
                          
                            "hash2", 
                            
                              "k2", 
                              
                                "k3")) 
                                
                                  # 批量取出"hash2"的key-k2 k3對應(yīng)的value --方式1 
                                  
                                    print(r.hmget(
                                    
                                      "hash2", [
                                      
                                        "k2", 
                                        
                                          "k3"])) 
                                          
                                            # 批量取出"hash2"的key-k2 k3對應(yīng)的value --方式2

3.取出所有的鍵值對
hgetall(name)
獲取name對應(yīng)hash的所有鍵值

              
                
                  print(r.hgetall(
                  
                    "hash1"))

4.得到所有鍵值對的格式 hash長度
hlen(name)
獲取name對應(yīng)的hash中鍵值對的個數(shù)

              
                
                  print(r.hlen(
                  
                    "hash1"))

5.得到所有的keys（類似字典的取所有keys）
hkeys(name)
獲取name對應(yīng)的hash中所有的key的值

              
                
                  print(r.hkeys(
                  
                    "hash1"))

6.得到所有的value（類似字典的取所有value）
hvals(name)
獲取name對應(yīng)的hash中所有的value的值

              
                
                  print(r.hvals(
                  
                    "hash1"))

7.判斷成員是否存在（類似字典的in）
hexists(name, key)
檢查name對應(yīng)的hash是否存在當(dāng)前傳入的key

              
                
                  print(r.hexists(
                  
                    "hash1", 
                    
                      "k4"))  
                      
                        # False 不存在

                        
                          print(r.hexists(
                          
                            "hash1", 
                            
                              "k1")) 
                              
                                # True 存在

8.刪除鍵值對
hdel(name,*keys)
將name對應(yīng)的hash中指定key的鍵值對刪除

              
                
                  print(r.hgetall(
                  
                    "hash1"))
r.hset(
                    
                      "hash1", 
                      
                        "k2", 
                        
                          "v222") 
                          
                            # 修改已有的key k2 r.hset(
                            
                              "hash1", 
                              
                                "k11", 
                                
                                  "v1") 
                                  
                                    # 新增鍵值對 k11 r.hdel(
                                    
                                      "hash1", 
                                      
                                        "k1") 
                                        
                                          # 刪除一個鍵值對 
                                          
                                            print(r.hgetall(
                                            
                                              "hash1"))

9.自增自減整數(shù)(將key對應(yīng)的value--整數(shù) 自增1或者2，或者別的整數(shù) 負(fù)數(shù)就是自減)
hincrby(name, key, amount=1)
自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
參數(shù)：
name，redis中的name
key， hash對應(yīng)的key
amount，自增數(shù)（整數(shù)）

              
                r.hset(
                
                  "hash1", 
                  
                    "k3", 123)
r.hincrby(
                    
                      "hash1", 
                      
                        "k3", amount=-1)

                        
                          print(r.hgetall(
                          
                            "hash1")) r.hincrby(
                            
                              "hash1", 
                              
                                "k4", amount=1) 
                                
                                  # 不存在的話，value默認(rèn)就是1 
                                  
                                    print(r.hgetall(
                                    
                                      "hash1"))

10.自增自減浮點數(shù)(將key對應(yīng)的value--浮點數(shù) 自增1.0或者2.0，或者別的浮點數(shù) 負(fù)數(shù)就是自減)
hincrbyfloat(name, key, amount=1.0)
自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount
參數(shù)：
name，redis中的name
key， hash對應(yīng)的key
amount，自增數(shù)（浮點數(shù)）
自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount

              
                r.hset(
                
                  "hash1", 
                  
                    "k5", 
                    
                      "1.0")
r.hincrbyfloat(
                      
                        "hash1", 
                        
                          "k5", amount=-1.0) 
                          
                            # 已經(jīng)存在，遞減-1.0 
                            
                              print(r.hgetall(
                              
                                "hash1")) r.hincrbyfloat(
                                
                                  "hash1", 
                                  
                                    "k6", amount=-1.0) 
                                    
                                      # 不存在，value初始值是-1.0 每次遞減1.0 
                                      
                                        print(r.hgetall(
                                        
                                          "hash1"))

11.取值查看--分片讀取
hscan(name, cursor=0, match=None, count=None)
增量式迭代獲取，對于數(shù)據(jù)大的數(shù)據(jù)非常有用，hscan可以實現(xiàn)分片的獲取數(shù)據(jù)，并非一次性將數(shù)據(jù)全部獲取完，從而放置內(nèi)存被撐爆
參數(shù)：
name，redis的name
cursor，游標(biāo)（基于游標(biāo)分批取獲取數(shù)據(jù)）
match，匹配指定key，默認(rèn)None 表示所有的key
count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)
如：
第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
...
直到返回值cursor的值為0時，表示數(shù)據(jù)已經(jīng)通過分片獲取完畢

              
                
                  print(r.hscan(
                  
                    "hash1"))

12.hscan_iter(name, match=None, count=None)
利用yield封裝hscan創(chuàng)建生成器，實現(xiàn)分批去redis中獲取數(shù)據(jù)
參數(shù)：
match，匹配指定key，默認(rèn)None 表示所有的key
count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)
如：

              
                
                  for item 
                  
                    in r.hscan_iter(
                    
                      'hash1'):
    
                      
                        print(item)

                        
                          print(r.hscan_iter(
                          
                            "hash1")) 
                            
                              # 生成器內(nèi)存地址

5、redis基本命令 list

1.增加（類似于list的append，只是這里是從左邊新增加）--沒有就新建
lpush(name,values)
在name對應(yīng)的list中添加元素，每個新的元素都添加到列表的最左邊
如：

              
                
                  import redis

                  
                    import time

pool = redis.ConnectionPool(host=
                    
                      'localhost', port=
                      
                        6379, decode_responses=
                        
                          True) r = redis.Redis(connection_pool=pool) r.lpush(
                          
                            "list1", 
                            
                              11, 
                              
                                22, 
                                
                                  33) print(r.lrange(
                                  
                                    'list1', 
                                    
                                      0, 
                                      
                                        -1))

保存順序為: 33,22,11

擴展：

              
                r.rpush(
                
                  "list2", 11, 22, 33)  
                  
                    # 表示從右向左操作

                    
                      print(r.llen(
                      
                        "list2"))  
                        
                          # 列表長度 
                          
                            print(r.lrange(
                            
                              "list2", 0, 3)) 
                              
                                # 切片取出值，范圍是索引號0-3

2.增加（從右邊增加）--沒有就新建

              
                r.rpush(
                
                  "list2", 44, 55, 66)    
                  
                    # 在列表的右邊，依次添加44,55,66

                    
                      print(r.llen(
                      
                        "list2"))  
                        
                          # 列表長度 
                          
                            print(r.lrange(
                            
                              "list2", 0, -1)) 
                              
                                # 切片取出值，范圍是索引號0到-1(最后一個元素)

3.往已經(jīng)有的name的列表的左邊添加元素，沒有的話無法創(chuàng)建
lpushx(name,value)
在name對應(yīng)的list中添加元素，只有name已經(jīng)存在時，值添加到列表的最左邊
更多：

              
                r.lpushx(
                
                  "list10", 10)   
                  
                    # 這里list10不存在

                    
                      print(r.llen(
                      
                        "list10"))  
                        
                          # 0 
                          
                            print(r.lrange(
                            
                              "list10", 0, -1)) 
                              
                                # []

              
                r.lpushx(
                
                  "list2", 77)   
                  
                    # 這里"list2"之前已經(jīng)存在，往列表最左邊添加一個元素，一次只能添加一個

                    
                      print(r.llen(
                      
                        "list2"))  
                        
                          # 列表長度 
                          
                            print(r.lrange(
                            
                              "list2", 0, -1)) 
                              
                                # 切片取出值，范圍是索引號0到-1(最后一個元素

4.往已經(jīng)有的name的列表的右邊添加元素，沒有的話無法創(chuàng)建

              
                r.rpushx(
                
                  "list2", 99)   
                  
                    # 這里"foo_list1"之前已經(jīng)存在，往列表最右邊添加一個元素，一次只能添加一個

                    
                      print(r.llen(
                      
                        "list2"))  
                        
                          # 列表長度 
                          
                            print(r.lrange(
                            
                              "list2", 0, -1)) 
                              
                                # 切片取出值，范圍是索引號0到-1(最后一個元素)

5.新增（固定索引號位置插入元素）
linsert(name, where, refvalue, value))
在name對應(yīng)的列表的某一個值前或后插入一個新值
參數(shù)：
name，redis的name
where，BEFORE或AFTER
refvalue，標(biāo)桿值，即：在它前后插入數(shù)據(jù)
value，要插入的數(shù)據(jù)

              
                r.linsert(
                
                  "list2", 
                  
                    "before", 
                    
                      "11", 
                      
                        "00")   
                        
                          # 往列表中左邊第一個出現(xiàn)的元素
                          
                            "11"前插入元素
                            
                              "00" print(r.lrange(
                              
                                "list2", 
                                
                                  0, 
                                  
                                    -1)) 
                                    
                                      # 切片取出值，范圍是索引號0-最后一個元素

6.修改（指定索引號進行修改）
r.lset(name, index, value)
對name對應(yīng)的list中的某一個索引位置重新賦值
參數(shù)：
name，redis的name
index，list的索引位置
value，要設(shè)置的值

              
                r.lset(
                
                  "list2", 0, -11)    
                  
                    # 把索引號是0的元素修改成-11

                    
                      print(r.lrange(
                      
                        "list2", 0, -1))

7.刪除（指定值進行刪除）
r.lrem(name, value, num)
在name對應(yīng)的list中刪除指定的值
參數(shù)：
name，redis的name
value，要刪除的值
num， num=0，刪除列表中所有的指定值；
num=2,從前到后，刪除2個； num=1,從前到后，刪除左邊第1個
num=-2,從后向前，刪除2個

              
                r.lrem(
                
                  "list2", 
                  
                    "11", 1)    
                    
                      # 將列表中左邊第一次出現(xiàn)的"11"刪除

                      
                        print(r.lrange(
                        
                          "list2", 0, -1)) r.lrem(
                          
                            "list2", 
                            
                              "99", -1) 
                              
                                # 將列表中右邊第一次出現(xiàn)的"99"刪除 
                                
                                  print(r.lrange(
                                  
                                    "list2", 0, -1)) r.lrem(
                                    
                                      "list2", 
                                      
                                        "22", 0) 
                                        
                                          # 將列表中所有的"22"刪除 
                                          
                                            print(r.lrange(
                                            
                                              "list2", 0, -1))

8.刪除并返回
lpop(name)
在name對應(yīng)的列表的左側(cè)獲取第一個元素并在列表中移除，返回值則是第一個元素
更多：
rpop(name) 表示從右向左操作

              
                r.lpop(
                
                  "list2")    
                  
                    # 刪除列表最左邊的元素，并且返回刪除的元素

                    
                      print(r.lrange(
                      
                        "list2", 0, -1))
r.rpop(
                        
                          "list2") 
                          
                            # 刪除列表最右邊的元素，并且返回刪除的元素 
                            
                              print(r.lrange(
                              
                                "list2", 0, -1))

9.刪除索引之外的值
ltrim(name, start, end)
在name對應(yīng)的列表中移除沒有在start-end索引之間的值
參數(shù)：
name，redis的name
start，索引的起始位置
end，索引結(jié)束位置

              
                r.ltrim(
                
                  "list2", 0, 2)    
                  
                    # 刪除索引號是0-2之外的元素，值保留索引號是0-2的元素

                    
                      print(r.lrange(
                      
                        "list2", 0, -1))

10.取值（根據(jù)索引號取值）
lindex(name, index)
在name對應(yīng)的列表中根據(jù)索引獲取列表元素

              
                
                  print(r.lindex(
                  
                    "list2", 0))  
                    
                      # 取出索引號是0的值

11.移動元素從一個列表移動到另外一個列表
rpoplpush(src, dst)
從一個列表取出最右邊的元素，同時將其添加至另一個列表的最左邊
參數(shù)：
src，要取數(shù)據(jù)的列表的name
dst，要添加數(shù)據(jù)的列表的name

              
                r.rpoplpush(
                
                  "list1", 
                  
                    "list2")

                    
                      print(r.lrange(
                      
                        "list2", 0, -1))

12.移動元素從一個列表移動到另外一個列表可以設(shè)置超時
brpoplpush(src, dst, timeout=0)
從一個列表的右側(cè)移除一個元素并將其添加到另一個列表的左側(cè)
參數(shù)：
src，取出并要移除元素的列表對應(yīng)的name
dst，要插入元素的列表對應(yīng)的name
timeout，當(dāng)src對應(yīng)的列表中沒有數(shù)據(jù)時，阻塞等待其有數(shù)據(jù)的超時時間（秒），0 表示永遠阻塞

              
                r.brpoplpush(
                
                  "list1", 
                  
                    "list2", timeout=2)

                    
                      print(r.lrange(
                      
                        "list2", 0, -1))

13.一次移除多個列表
blpop(keys, timeout)
將多個列表排列，按照從左到右去pop對應(yīng)列表的元素
參數(shù)：
keys，redis的name的集合
timeout，超時時間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時間（秒）, 0 表示永遠阻塞
更多：
r.brpop(keys, timeout) 同blpop，將多個列表排列,按照從右像左去移除各個列表內(nèi)的元素

              
                r.lpush(
                
                  "list10", 
                  
                    3, 
                    
                      4, 
                      
                        5)
r.lpush(
                        
                          "list11", 
                          
                            3, 
                            
                              4, 
                              
                                5) 
                                
                                  while 
                                  
                                    True: r.blpop([
                                    
                                      "list10", 
                                      
                                        "list11"], timeout=
                                        
                                          2) 
                                          
                                            print(r.lrange(
                                            
                                              "list10", 
                                              
                                                0, 
                                                
                                                  -1), r.lrange(
                                                  
                                                    "list11", 
                                                    
                                                      0, 
                                                      
                                                        -1))

14.自定義增量迭代
由于redis類庫中沒有提供對列表元素的增量迭代，如果想要循環(huán)name對應(yīng)的列表的所有元素，那么就需要：

獲取name對應(yīng)的所有列表
循環(huán)列表

但是，如果列表非常大，那么就有可能在第一步時就將程序的內(nèi)容撐爆，所有有必要自定義一個增量迭代的功能：

              
                
                  
                    def 
                    
                      list_iter
                      
                        (name):
    
                        
                          """ 自定義redis列表增量迭代 :param name: redis中的name，即：迭代name對應(yīng)的列表 :return: yield 返回 列表元素 """ list_count = r.llen(name) 
                          
                            for index 
                            
                              in range(list_count): 
                              
                                yield r.lindex(name, index) 
                                
                                  # 使用 
                                  
                                    for item 
                                    
                                      in list_iter(
                                      
                                        'list2'): 
                                        
                                          # 遍歷這個列表 print(item)

6、redis基本命令 set

1.新增
sadd(name,values)
name對應(yīng)的集合中添加元素

              
                r.sadd(
                
                  "set1", 33, 44, 55, 66)  
                  
                    # 往集合中添加元素

                    
                      print(r.scard(
                      
                        "set1"))  
                        
                          # 集合的長度是4 
                          
                            print(r.smembers(
                            
                              "set1")) 
                              
                                # 獲取集合中所有的成員

2.獲取元素個數(shù) 類似于len
scard(name)
獲取name對應(yīng)的集合中元素個數(shù)

              
                
                  print(r.scard(
                  
                    "set1"))  
                    
                      # 集合的長度是4

3.獲取集合中所有的成員
smembers(name)
獲取name對應(yīng)的集合的所有成員

              
                
                  print(r.smembers(
                  
                    "set1"))   
                    
                      # 獲取集合中所有的成員

獲取集合中所有的成員--元組形式
sscan(name, cursor=0, match=None, count=None)

              
                
                  print(r.sscan(
                  
                    "set1"))

獲取集合中所有的成員--迭代器的方式
sscan_iter(name, match=None, count=None)
同字符串的操作，用于增量迭代分批獲取元素，避免內(nèi)存消耗太大

              
                
                  for i 
                  
                    in r.sscan_iter(
                    
                      "set1"):
    
                      
                        print(i)

4.差集
sdiff(keys, *args)
在第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合的元素集合

              
                r.sadd(
                
                  "set2", 11, 22, 33)

                  
                    print(r.smembers(
                    
                      "set1"))   
                      
                        # 獲取集合中所有的成員

                        
                          print(r.smembers(
                          
                            "set2")) 
                            
                              print(r.sdiff(
                              
                                "set1", 
                                
                                  "set2")) 
                                  
                                    # 在集合set1但是不在集合set2中 
                                    
                                      print(r.sdiff(
                                      
                                        "set2", 
                                        
                                          "set1")) 
                                          
                                            # 在集合set2但是不在集合set1中

5.差集--差集存在一個新的集合中
sdiffstore(dest, keys, *args)
獲取第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合，再將其新加入到dest對應(yīng)的集合中

              
                r.sdiffstore(
                
                  "set3", 
                  
                    "set1", 
                    
                      "set2")    
                      
                        # 在集合set1但是不在集合set2中

                        
                          print(r.smembers(
                          
                            "set3")) 
                            
                              # 獲取集合3中所有的成員

6.交集
sinter(keys, *args)
獲取多一個name對應(yīng)集合的交集

              
                
                  print(r.sinter(
                  
                    "set1", 
                    
                      "set2")) 
                      
                        # 取2個集合的交集

7.交集--交集存在一個新的集合中
sinterstore(dest, keys, *args)
獲取多一個name對應(yīng)集合的并集，再將其加入到dest對應(yīng)的集合中

              
                
                  print(r.sinterstore(
                  
                    "set3", 
                    
                      "set1", 
                      
                        "set2")) 
                        
                          # 取2個集合的交集 
                          
                            print(r.smembers(
                            
                              "set3"))

并集
sunion(keys, *args)
獲取多個name對應(yīng)的集合的并集

              
                
                  print(r.sunion(
                  
                    "set1", 
                    
                      "set2")) 
                      
                        # 取2個集合的并集

并集--并集存在一個新的集合
sunionstore(dest,keys, *args)
獲取多一個name對應(yīng)的集合的并集，并將結(jié)果保存到dest對應(yīng)的集合中

              
                
                  print(r.sunionstore(
                  
                    "set3", 
                    
                      "set1", 
                      
                        "set2")) 
                        
                          # 取2個集合的并集 
                          
                            print(r.smembers(
                            
                              "set3"))

8.判斷是否是集合的成員類似in
sismember(name, value)
檢查value是否是name對應(yīng)的集合的成員，結(jié)果為True和False

              
                
                  print(r.sismember(
                  
                    "set1", 33))  
                    
                      # 33是集合的成員

                      
                        print(r.sismember(
                        
                          "set1", 23)) 
                          
                            # 23不是集合的成員

9.移動
smove(src, dst, value)
將某個成員從一個集合中移動到另外一個集合

              
                r.smove(
                
                  "set1", 
                  
                    "set2", 44)

                    
                      print(r.smembers(
                      
                        "set1"))

                        
                          print(r.smembers(
                          
                            "set2"))

10.刪除--隨機刪除并且返回被刪除值
spop(name)
從集合移除一個成員，并將其返回,說明一下，集合是無序的，所有是隨機刪除的

              
                
                  print(r.spop(
                  
                    "set2"))   
                    
                      # 這個刪除的值是隨機刪除的，集合是無序的

                      
                        print(r.smembers(
                        
                          "set2"))

11.刪除--指定值刪除
srem(name, values)
在name對應(yīng)的集合中刪除某些值

              
                
                  print(r.srem(
                  
                    "set2", 11))   
                    
                      # 從集合中刪除指定值 11

                      
                        print(r.smembers(
                        
                          "set2"))

7、redis基本命令有序set

Set操作，Set集合就是不允許重復(fù)的列表，本身是無序的
有序集合，在集合的基礎(chǔ)上，為每元素排序；元素的排序需要根據(jù)另外一個值來進行比較，
所以，對于有序集合，每一個元素有兩個值，即：值和分?jǐn)?shù)，分?jǐn)?shù)專門用來做排序。

1.新增
zadd(name, *args, **kwargs)
在name對應(yīng)的有序集合中添加元素
如：

              
                
                  import redis

                  
                    import time

pool = redis.ConnectionPool(host=
                    
                      'localhost', port=
                      
                        6379, decode_responses=
                        
                          True) r = redis.Redis(connection_pool=pool) r.zadd(
                          
                            "zset1", n1=
                            
                              11, n2=
                              
                                22) r.zadd(
                                
                                  "zset2", 
                                  
                                    'm1', 
                                    
                                      22, 
                                      
                                        'm2', 
                                        
                                          44) print(r.zcard(
                                          
                                            "zset1")) 
                                            
                                              # 集合長度 print(r.zcard(
                                              
                                                "zset2")) 
                                                
                                                  # 集合長度 print(r.zrange(
                                                  
                                                    "zset1", 
                                                    
                                                      0, 
                                                      
                                                        -1)) 
                                                        
                                                          # 獲取有序集合中所有元素 print(r.zrange(
                                                          
                                                            "zset2", 
                                                            
                                                              0, 
                                                              
                                                                -1, withscores=
                                                                
                                                                  True)) 
                                                                  
                                                                    # 獲取有序集合中所有元素和分?jǐn)?shù)

2.獲取有序集合元素個數(shù) 類似于len
zcard(name)
獲取name對應(yīng)的有序集合元素的數(shù)量

              
                
                  print(r.zcard(
                  
                    "zset1")) 
                    
                      # 集合長度

3.獲取有序集合的所有元素
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
按照索引范圍獲取name對應(yīng)的有序集合的元素
參數(shù)：
name，redis的name
start，有序集合索引起始位置（非分?jǐn)?shù)）
end，有序集合索引結(jié)束位置（非分?jǐn)?shù)）
desc，排序規(guī)則，默認(rèn)按照分?jǐn)?shù)從小到大排序
withscores，是否獲取元素的分?jǐn)?shù)，默認(rèn)只獲取元素的值
score_cast_func，對分?jǐn)?shù)進行數(shù)據(jù)轉(zhuǎn)換的函數(shù)

3-1 從大到小排序(同zrange，集合是從大到小排序的)
zrevrange(name, start, end, withscores=False, score_cast_func=float)

              
                
                  print(r.zrevrange(
                  
                    "zset1", 
                    
                      0, 
                      
                        -1))    
                        
                          # 只獲取元素，不顯示分?jǐn)?shù) 
                          
                            print(r.zrevrange(
                            
                              "zset1", 
                              
                                0, 
                                
                                  -1, withscores=
                                  
                                    True)) 
                                    
                                      # 獲取有序集合中所有元素和分?jǐn)?shù),分?jǐn)?shù)倒序

3-2 按照分?jǐn)?shù)范圍獲取name對應(yīng)的有序集合的元素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)

              
                
                  for i 
                  
                    in range(
                    
                      1, 
                      
                        30):
   element = 
                        
                          'n' + str(i) r.zadd(
                          
                            "zset3", element, i) print(r.zrangebyscore(
                            
                              "zset3", 
                              
                                15, 
                                
                                  25)) 
                                  
                                    # # 在分?jǐn)?shù)是15-25之間，取出符合條件的元素 print(r.zrangebyscore(
                                    
                                      "zset3", 
                                      
                                        12, 
                                        
                                          22, withscores=
                                          
                                            True)) 
                                            
                                              # 在分?jǐn)?shù)是12-22之間，取出符合條件的元素（帶分?jǐn)?shù)）

3-3 按照分?jǐn)?shù)范圍獲取有序集合的元素并排序（默認(rèn)從大到小排序）
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

              
                
                  print(r.zrevrangebyscore(
                  
                    "zset3", 
                    
                      22, 
                      
                        11, withscores=
                        
                          True)) 
                          
                            # 在分?jǐn)?shù)是22-11之間，取出符合條件的元素 按照分?jǐn)?shù)倒序

3-4 獲取所有元素--默認(rèn)按照分?jǐn)?shù)順序排序
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

              
                
                  print(r.zscan(
                  
                    "zset3"))

3-5 獲取所有元素--迭代器
zscan_iter(name, match=None, count=None,score_cast_func=float)

              
                
                  for i 
                  
                    in r.zscan_iter(
                    
                      "zset3"): 
                      
                        # 遍歷迭代器
    
                        
                          print(i)

4.zcount(name, min, max)
獲取name對應(yīng)的有序集合中分?jǐn)?shù) 在 [min,max] 之間的個數(shù)

              
                
                  print(r.zrange(
                  
                    "zset3", 
                    
                      0, 
                      
                        -1, withscores=
                        
                          True)) 
                          
                            print(r.zcount(
                            
                              "zset3", 
                              
                                11, 
                                
                                  22))

5.自增
zincrby(name, value, amount)
自增name對應(yīng)的有序集合的 name 對應(yīng)的分?jǐn)?shù)

              
                r.zincrby(
                
                  "zset3", 
                  
                    "n2", amount=
                    
                      2)    
                      
                        # 每次將n2的分?jǐn)?shù)自增2

                        
                          print(r.zrange(
                          
                            "zset3", 
                            
                              0, 
                              
                                -1, withscores=
                                
                                  True))

6.獲取值的索引號
zrank(name, value)
獲取某個值在 name對應(yīng)的有序集合中的索引（從 0 開始）
更多：
zrevrank(name, value)，從大到小排序

              
                
                  print(r.zrank(
                  
                    "zset3", 
                    
                      "n1"))   
                      
                        # n1的索引號是0 這里按照分?jǐn)?shù)順序（從小到大）

                        
                          print(r.zrank(
                          
                            "zset3", 
                            
                              "n6")) 
                              
                                # n6的索引號是1 
                                
                                  print(r.zrevrank(
                                  
                                    "zset3", 
                                    
                                      "n1")) 
                                      
                                        # n1的索引號是29 這里安照分?jǐn)?shù)倒序（從大到小）

7.刪除--指定值刪除
zrem(name, values)
刪除name對應(yīng)的有序集合中值是values的成員

              
                r.zrem(
                
                  "zset3", 
                  
                    "n3")   
                    
                      # 刪除有序集合中的元素n3 刪除單個

                      
                        print(r.zrange(
                        
                          "zset3", 0, -1))

8.刪除--根據(jù)排行范圍刪除，按照索引號來刪除
zremrangebyrank(name, min, max)
根據(jù)排行范圍刪除

              
                r.zremrangebyrank(
                
                  "zset3", 0, 1)  
                  
                    # 刪除有序集合中的索引號是0, 1的元素

                    
                      print(r.zrange(
                      
                        "zset3", 0, -1))

9.刪除--根據(jù)分?jǐn)?shù)范圍刪除
zremrangebyscore(name, min, max)
根據(jù)分?jǐn)?shù)范圍刪除

              
                r.zremrangebyscore(
                
                  "zset3", 11, 22)   
                  
                    # 刪除有序集合中的分?jǐn)?shù)是11-22的元素

                    
                      print(r.zrange(
                      
                        "zset3", 0, -1))

10.獲取值對應(yīng)的分?jǐn)?shù)
zscore(name, value)
獲取name對應(yīng)有序集合中 value 對應(yīng)的分?jǐn)?shù)

              
                
                  print(r.zscore(
                  
                    "zset3", 
                    
                      "n27"))   
                      
                        # 獲取元素n27對應(yīng)的分?jǐn)?shù)27

8、其他常用操作

1.刪除
delete(*names)
根據(jù)刪除redis中的任意數(shù)據(jù)類型（string、hash、list、set、有序set）

              
                r.delete(
                
                  "gender")  
                  
                    # 刪除key為gender的鍵值對

2.檢查名字是否存在
exists(name)
檢測redis的name是否存在，存在就是True，F(xiàn)alse 不存在

              
                
                  print(r.exists(
                  
                    "zset1"))

3.模糊匹配
keys(pattern=' ')
根據(jù)模型獲取redis的name
更多：
KEYS * 匹配數(shù)據(jù)庫中所有 key 。
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
KEYS h llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

              
                
                  print(r.keys(
                  
                    "foo*"))

4.設(shè)置超時時間
expire(name ,time)
為某個redis的某個name設(shè)置超時時間

              
                r.lpush(
                
                  "list5", 11, 22)
r.expire(
                  
                    "list5", time=3)

                    
                      print(r.lrange(
                      
                        "list5", 0, -1))
time.sleep(3)

                        
                          print(r.lrange(
                          
                            "list5", 0, -1))

5.重命名
rename(src, dst)
對redis的name重命名

              
                r.lpush(
                
                  "list5", 11, 22)
r.rename(
                  
                    "list5", 
                    
                      "list5-1")

6.隨機獲取name
randomkey()
隨機獲取一個redis的name（不刪除）

              
                
                  print(r.randomkey())

7.獲取類型
type(name)
獲取name對應(yīng)值的類型

8.查看所有元素
scan(cursor=0, match=None, count=None)

                
                  print
                
                (r.hscan(
                
                  "
                
                
                  hash2
                
                
                  "
                
                
                  ))

                
                
                  print
                
                (r.sscan(
                
                  "
                
                
                  set3
                
                
                  "
                
                
                  ))

                
                
                  print
                
                (r.zscan(
                
                  "
                
                
                  zset2
                
                
                  "
                
                
                  ))

                
                
                  print
                
                (r.getrange(
                
                  "
                
                
                  foo1
                
                
                  "
                
                , 0, -1
                
                  ))

                
                
                  print
                
                (r.lrange(
                
                  "
                
                
                  list2
                
                
                  "
                
                , 0, -1
                
                  ))

                
                
                  print
                
                (r.smembers(
                
                  "
                
                
                  set3
                
                
                  "
                
                
                  ))

                
                
                  print
                
                (r.zrange(
                
                  "
                
                
                  zset3
                
                
                  "
                
                , 0, -1
                
                  ))

                
                
                  print
                
                (r.hgetall(
                
                  "
                
                
                  hash1
                
                
                  "
                
                ))

9.查看所有元素--迭代器
scan_iter(match=None, count=None)

                
                  for
                
                 i 
                
                  in
                
                 r.hscan_iter(
                
                  "
                
                
                  hash1
                
                
                  "
                
                
                  ):
    
                
                
                  print
                
                
                  (i)


                
                
                  for
                
                 i 
                
                  in
                
                 r.sscan_iter(
                
                  "
                
                
                  set3
                
                
                  "
                
                
                  ):
    
                
                
                  print
                
                
                  (i)


                
                
                  for
                
                 i 
                
                  in
                
                 r.zscan_iter(
                
                  "
                
                
                  zset3
                
                
                  "
                
                
                  ):
    
                
                
                  print
                
                (i)

other 方法

                
                  print
                
                (r.get(
                
                  '
                
                
                  name
                
                
                  '
                
                ))    
                
                  #
                
                
                   查詢key為name的值
                
                
r.delete(
                
                  "
                
                
                  gender
                
                
                  "
                
                )  
                
                  #
                
                
                   刪除key為gender的鍵值對
                
                
                  print
                
                (r.keys()) 
                
                  #
                
                
                   查詢所有的Key
                
                
                  print
                
                (r.dbsize())   
                
                  #
                
                
                   當(dāng)前redis包含多少條數(shù)據(jù)
                
                
r.save()    
                
                  #
                
                
                   執(zhí)行"檢查點"操作，將數(shù)據(jù)寫回磁盤。保存時阻塞
                
                
                  
#
                
                
                   r.flushdb()        # 清空r中的所有數(shù)據(jù)

管道（pipeline）

redis默認(rèn)在執(zhí)行每次請求都會創(chuàng)建（連接池申請連接）和斷開（歸還連接池）一次連接操作，
如果想要在一次請求中指定多個命令，則可以使用pipline實現(xiàn)一次請求指定多個命令，并且默認(rèn)情況下一次pipline 是原子性操作。

管道（pipeline）是redis在提供單個請求中緩沖多條服務(wù)器命令的基類的子類。它通過減少服務(wù)器-客戶端之間反復(fù)的TCP數(shù)據(jù)庫包，從而大大提高了執(zhí)行批量命令的功能。

              
                import
              
              
                 redis

              
              
                import
              
              
                 time

pool 
              
              = redis.ConnectionPool(host=
              
                '
              
              
                localhost
              
              
                '
              
              , port=6379, decode_responses=
              
                True)
r 
              
              = redis.Redis(connection_pool=
              
                pool)


              
              
                #
              
              
                 pipe = r.pipeline(transaction=False)    # 默認(rèn)的情況下，管道里執(zhí)行的命令可以保證執(zhí)行的原子性，執(zhí)行pipe = r.pipeline(transaction=False)可以禁用這一特性。
              
              
                
#
              
              
                 pipe = r.pipeline(transaction=True)
              
              
pipe = r.pipeline() 
              
                #
              
              
                 創(chuàng)建一個管道
              
              
                
pipe.set(
              
              
                '
              
              
                name
              
              
                '
              
              , 
              
                '
              
              
                jack
              
              
                '
              
              
                )
pipe.set(
              
              
                '
              
              
                role
              
              
                '
              
              , 
              
                '
              
              
                sb
              
              
                '
              
              
                )
pipe.sadd(
              
              
                '
              
              
                faz
              
              
                '
              
              , 
              
                '
              
              
                baz
              
              
                '
              
              
                )
pipe.incr(
              
              
                '
              
              
                num
              
              
                '
              
              )    
              
                #
              
              
                 如果num不存在則vaule為1，如果存在，則value自增1
              
              
                pipe.execute()


              
              
                print
              
              (r.get(
              
                "
              
              
                name
              
              
                "
              
              
                ))

              
              
                print
              
              (r.get(
              
                "
              
              
                role
              
              
                "
              
              
                ))

              
              
                print
              
              (r.get(
              
                "
              
              
                num
              
              
                "
              
              ))

管道的命令可以寫在一起，如：

              pipe.set(
              
                '
              
              
                hello
              
              
                '
              
              , 
              
                '
              
              
                redis
              
              
                '
              
              ).sadd(
              
                '
              
              
                faz
              
              
                '
              
              , 
              
                '
              
              
                baz
              
              
                '
              
              ).incr(
              
                '
              
              
                num
              
              
                '
              
              
                ).execute()

              
              
                print
              
              (r.get(
              
                "
              
              
                name
              
              
                "
              
              
                ))

              
              
                print
              
              (r.get(
              
                "
              
              
                role
              
              
                "
              
              
                ))

              
              
                print
              
              (r.get(
              
                "
              
              
                num
              
              
                "
              
              ))

更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索：z360901061

微信掃一掃加我為好友

QQ號聯(lián)系： 360901061

您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。

【本文對您有幫助就好】元

2元

5元

10元

20元

自定義