redis緩存,rabbitMQ隊列

時間 2019-12-11

原文原文鏈接

緩存數據庫介紹

NoSQL(NoSQL = Not Only SQL )，意即「不只僅是SQL」，泛指非關係型的數據庫,隨着互聯網web2.0網站的興起，傳統的關係數據庫在應付web2.0網站，特別是超大規模和高併發的SNS類型的web2.0純動態網站已經顯得力不從心，暴露了不少難以克服的問題，而非關係型的數據庫則因爲其自己的特色獲得了很是迅速的發展。NoSQL數據庫的產生就是爲了解決大規模數據集合多重數據種類帶來的挑戰，尤爲是大數據應用難題。javascript

NoSQL數據庫的四大分類

鍵值(Key-Value)存儲數據庫html

這一類數據庫主要會使用到一個哈希表，這個表中有一個特定的鍵和一個指針指向特定的數據。Key/value模型對於IT系統來講的優點在於簡單、易部署。可是若是 DBA只對部分值進行查詢或更新的時候，Key/value就顯得效率低下了。[3] 舉例如：Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB.

列存儲數據庫。

這部分數據庫一般是用來應對分佈式存儲的海量數據。鍵仍然存在，可是它們的特色是指向了多個列。這些列是由列家族來安排的。如：Cassandra, HBase, Riak.

文檔型數據庫

文檔型數據庫的靈感是來自於Lotus Notes辦公軟件的，並且它同第一種鍵值存儲相相似。該類型的數據模型是版本化的文檔，半結構化的文檔以特定的格式存儲，好比JSON。文檔型數據庫可以看做是鍵值數據庫的升級版，容許之間嵌套鍵值。並且文檔型數據庫比鍵值數據庫的查詢效率更高。如：CouchDB, MongoDb. 國內也有文檔型數據庫SequoiaDB，已經開源。

圖形(Graph)數據庫

圖形結構的數據庫同其餘行列以及剛性結構的SQL數據庫不一樣，它是使用靈活的圖形模型，而且可以擴展到多個服務器上。NoSQL數據庫沒有標準的查詢語言(SQL)，所以進行數據庫查詢須要制定數據模型。許多NoSQL數據庫都有REST式的數據接口或者查詢API。[2] 如：Neo4J, InfoGrid, Infinite Graph.

所以，咱們總結NoSQL數據庫在如下的這幾種狀況下比較適用：一、數據模型比較簡單；二、須要靈活性更強的IT系統；三、對數據庫性能要求較高；四、不須要高度的數據一致性；五、對於給定key，比較容易映射覆雜值的環境。

NoSQL數據庫的四大分類表格分析

分類	Examples舉例	典型應用場景	數據模型	優勢	缺點
鍵值（key-value）[3]	Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB	內容緩存，主要用於處理大量數據的高訪問負載，也用於一些日誌系統等等。[3]	Key 指向 Value 的鍵值對，一般用hash table來實現[3]	查找速度快	數據無結構化，一般只被看成字符串或者二進制數據[3]
列存儲數據庫[3]	Cassandra, HBase, Riak	分佈式的文件系統	以列簇式存儲，將同一列數據存在一塊兒	查找速度快，可擴展性強，更容易進行分佈式擴展	功能相對侷限
文檔型數據庫[3]	CouchDB, MongoDb	Web應用（與Key-Value相似，Value是結構化的，不一樣的是數據庫可以瞭解Value的內容）	Key-Value對應的鍵值對，Value爲結構化數據	數據結構要求不嚴格，表結構可變，不須要像關係型數據庫同樣須要預先定義表結構	查詢性能不高，並且缺少統一的查詢語法。
圖形(Graph)數據庫[3]	Neo4J, InfoGrid, Infinite Graph	社交網絡，推薦系統等。專一於構建關係圖譜	圖結構	利用圖結構相關算法。好比最短路徑尋址，N度關係查找等	不少時候須要對整個圖作計算才能得出須要的信息，並且這種結構不太好作分佈式的集羣方案。[3]

redis

介紹

redis是業界主流的key-value nosql 數據庫之一。和Memcached相似，它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。這些數據類型都支持push/pop、add/remove及取交集並集和差集及更豐富的操做，並且這些操做都是原子性的。在此基礎上，redis支持各類不一樣方式的排序。與memcached同樣，爲了保證效率，數據都是緩存在內存中。區別的是redis會週期性的把更新的數據寫入磁盤或者把修改操做寫入追加的記錄文件，而且在此基礎上實現了master-slave(主從)同步。java

Redis優勢

異常快速 : Redis是很是快的，每秒能夠執行大約110000設置操做，81000個/每秒的讀取操做。node
支持豐富的數據類型 : Redis支持最大多數開發人員已經知道如列表，集合，可排序集合，哈希等數據類型。python

這使得在應用中很容易解決的各類問題，由於咱們知道哪些問題處理使用哪一種數據類型更好解決。
操做都是原子的 : 全部 Redis 的操做都是原子，從而確保當兩個客戶同時訪問 Redis 服務器獲得的是更新後的值（最新值）。git
MultiUtility工具：Redis是一個多功能實用工具，能夠在不少如：緩存，消息傳遞隊列中使用（Redis原生支持發佈/訂閱），在應用程序中，如：Web應用程序會話，網站頁面點擊數等任何短暫的數據；

安裝Redis環境

要在 Ubuntu 上安裝 Redis，打開終端，而後輸入如下命令：

$sudo apt-get update
$sudo apt-get install redis-server

這將在您的計算機上安裝Redis

啓動 Redis程序員

$redis-server

查看 redis 是否還在運行github

$redis-cli

這將打開一個 Redis 提示符，以下圖所示：

redis 127.0.0.1:6379>

在上面的提示信息中：127.0.0.1 是本機的IP地址，6379是 Redis 服務器運行的端口。如今輸入 PING 命令，以下圖所示：

redis 127.0.0.1:6379> ping
PONG

這說明如今你已經成功地在計算機上安裝了 Redis。

Python操做Redis

 
           sudo pip install redis 
          
           or 
          
           sudo easy_install redis 
          
           or 
          
           源碼安裝 
          
           詳見：https: 
           / 
           / 
           github.com 
           / 
           WoLpH 
           / 
           redis 
           - 
           py

在Ubuntu上安裝Redis桌面管理器

要在Ubuntu 上安裝 Redis桌面管理，能夠從 http://redisdesktop.com/download 下載包並安裝它。web

Redis 桌面管理器會給你用戶界面來管理 Redis 鍵和數據。

Redis API使用

redis-py 的API的使用能夠分類爲：redis

鏈接方式
鏈接池
操做
- String 操做
- Hash 操做
- List 操做
- Set 操做
- Sort Set 操做
管道
發佈訂閱

鏈接方式

一、操做模式

redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。

 
           import  
           redis 
          
           r  
           =  
           redis.Redis(host 
           = 
           '10.211.55.4' 
           , port 
           = 
           6379 
           ) 
          
           r. 
           set 
           ( 
           'foo' 
           ,  
           'Bar' 
           ) 
          
           print  
           r.get( 
           'foo' 
           )

二、鏈接池

redis-py使用connection pool來管理對一個redis server的全部鏈接，避免每次創建、釋放鏈接的開銷。默認，每一個Redis實例都會維護一個本身的鏈接池。能夠直接創建一個鏈接池，而後做爲參數Redis，這樣就能夠實現多個Redis實例共享一個鏈接池。

操做

1. String操做

redis中的String在在內存中按照一個name對應一個value來存儲。如圖：

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

 
           在Redis中設置值，默認，不存在則建立，存在則修改 
          
           參數： 
          
           ex，過時時間（秒） 
          
           px，過時時間（毫秒） 
          
           nx，若是設置爲True，則只有name不存在時，當前set操做才執行 
          
           xx，若是設置爲True，則只有name存在時，崗前set操做才執行

# EX 和 PX 能夠同時出現，但後面給出的選項會覆蓋前面給出的選項

redis 127.0.0.1:6379> SET key "value" EX 1000 PX 5000000
OK

redis 127.0.0.1:6379> TTL key
(integer) 4993  # 這是 PX 參數設置的值

redis 127.0.0.1:6379> SET another-key "value" PX 5000000 EX 1000
OK

redis 127.0.0.1:6379> TTL another-key
(integer) 997   # 這是 EX 參數設置的值

get(name)

返回 key 所關聯的字符串值。

若是 key 不存在那麼返回特殊值 nil 。

 
     setnx 
     (name, value)

 
     將  
     key 
      的值設爲  
     value 
      ，當且僅當  
     key 
      不存在。 
    

若給定的 key 已經存在，則 SETNX 不作任何動做。

redis> EXISTS job                # job 不存在
(integer) 0

redis> SETNX job "programmer"    # job 設置成功
(integer) 1

redis> SETNX job "code-farmer"   # 嘗試覆蓋 job ，失敗
(integer) 0

redis> GET job                   # 沒有被覆蓋
"programmer"

setex(name, time,value)

將值 value 關聯到 key ，並將 key 的生存時間設爲 seconds (以秒爲單位)。

若是 key 已經存在， SETEX 命令將覆寫舊值。

# key 已經存在時，SETEX 覆蓋舊值

redis> SET cd "timeless"
OK

redis> SETEX cd 3000 "goodbye my love"
OK

psetex (name, time_ms, value)

這個命令和 SETEX 命令類似，但它以毫秒爲單位設置 key 的生存時間，而不是像 SETEX 命令那樣，以秒爲單位。

redis> PSETEX mykey 1000 "Hello"
OK

redis> PTTL mykey
(integer) 999

redis> GET mykey
"Hello"

mset(*args, **kwargs)

批量設置值

MSET key value [key value ...]

同時設置一個或多個 key-value 對。

redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"
OK

redis> MGET date time weather
1) "2012.3.30"
2) "11:00 a.m."
3) "sunny"

mget(keys, *args)

返回全部(一個或多個)給定 key 的值。

redis> MGET redis mongodb

getrange(key, start, end)

返回 key 中字符串值的子字符串，字符串的截取範圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)。

負數偏移量表示從字符串最後開始計數， -1 表示最後一個字符， -2 表示倒數第二個，以此類推

redis> SET greeting "hello, my friend"
OK

redis> GETRANGE greeting 0 4          # 返回索引0-4的字符，包括4。
"hello"

redis> GETRANGE greeting -1 -5        # 不支持迴繞操做
""

redis> GETRANGE greeting -3 -1        # 負數索引
"end"

redis> GETRANGE greeting 0 -1         # 從第一個到最後一個
"hello, my friend"

redis> GETRANGE greeting 0 1008611    # 值域範圍不超過實際字符串，超過部分自動被符略
"hello, my friend"

setrange(name, offset, value)

 
           # 修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加） 
          
           # 參數： 
          
           # offset，字符串的索引，字節（一個漢字三個字節） 
          
           # value，要設置的值

redis> SET greeting "hello world"
OK

redis> SETRANGE greeting 6 "Redis"
(integer) 11

redis> GET greeting
"hello Redis"


# 對空字符串/不存在的 key 進行 SETRANGE

redis> EXISTS empty_string
(integer) 0

redis> SETRANGE empty_string 5 "Redis!"   # 對不存在的 key 使用 SETRANGE
(integer) 11

redis> GET empty_string                   # 空白處被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"

redis> SET greeting "hello world"
OK

redis> SETRANGE greeting 6 "Redis"
(integer) 11

redis> GET greeting
"hello Redis"


# 對空字符串/不存在的 key 進行 SETRANGE

redis> EXISTS empty_string
(integer) 0

redis> SETRANGE empty_string 5 "Redis!"   # 對不存在的 key 使用 SETRANGE
(integer) 11

redis> GET empty_string                   # 空白處被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"

setbit(name, offset, value)

redis> SET greeting "hello world"
OK

redis> SETRANGE greeting 6 "Redis"
(integer) 11

redis> GET greeting
"hello Redis"


# 對空字符串/不存在的 key 進行 SETRANGE

redis> EXISTS empty_string
(integer) 0

redis> SETRANGE empty_string 5 "Redis!"   # 對不存在的 key 使用 SETRANGE
(integer) 11

redis> GET empty_string                   # 空白處被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"

 
         
          
            
              # 對name對應值的二進制表示的位進行操做 
             

                 
             
 
              # 參數： 
             
 
                   
              # name，redis的name 
             
 
                   
              # offset，位的索引（將值變換成二進制後再進行索引） 
             
 
                   
              # value，值只能是 1 或 0 
             

                 
             
 
              # 注：若是在Redis中有一個對應： n1 = "foo"， 
             
 
                       
              那麼字符串foo的二進制表示爲： 
              01100110  
              01101111  
              01101111 
             
 
                   
              因此，若是執行 setbit( 
              'n1' 
              ,  
              7 
              ,  
              1 
              )，則就會將第 
              7 
              位設置爲 
              1 
              ， 
             
 
                       
              那麼最終二進制則變成  
              01100111  
              01101111  
              01101111 
              ，即： 
              "goo" 
             

                 
             
 
              # 擴展，轉換二進制表示： 
             

                 
             
 
                   
              # source = "薩德" 
             
 
                   
              source  
              =  
              "foo" 
             

                 
             
 
                   
              for  
              i  
              in  
              source: 
             
 
                       
              num  
              =  
              ord 
              (i) 
             
 
                       
              print  
              bin 
              (num).replace( 
              'b' 
              ,'') 
             

                 
             
 
                   
              特別的，若是source是漢字  
              "薩德" 
              怎麼辦？ 
             
 
                   
              答：對於utf 
              - 
              8 
              ，每個漢字佔  
              3  
              個字節，那麼  
              "薩德"  
              則有  
              9 
              個字節 
             
 
                      
              對於漢字， 
              for 
              循環時候會按照 字節 迭代，那麼在迭代時，將每個字節轉換 十進制數，而後再將十進制數轉換成二進制 
             
 
                       
              11100110  
              10101101  
              10100110  
              11100110  
              10110010  
              10011011  
              11101001  
              10111101  
              10010000 
             
 
                       
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              -  
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              -  
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
              - 
             
 
                                  
             
 
          
 
         
       

getbit(name, offset)

 
              # 獲取name對應的值的二進制表示中的某位的值 （0或1）

redis> SET greeting "hello world"
OK

redis> SETRANGE greeting 6 "Redis"
(integer) 11

redis> GET greeting
"hello Redis"


# 對空字符串/不存在的 key 進行 SETRANGE

redis> EXISTS empty_string
(integer) 0

redis> SETRANGE empty_string 5 "Redis!"   # 對不存在的 key 使用 SETRANGE
(integer) 11

redis> GET empty_string                   # 空白處被"\x00"填充
"\x00\x00\x00\x00\x00Redis!"

bitcount(key, start=None, end=None)

strlen(name)

1

# 獲取字符串的長度

redis> SET mykey "Hello world"
OK

redis> STRLEN mykey
(integer) 11

incr(self, name, amount=1)

redis> SET page_view 20
OK

redis> INCR page_view
(integer) 21

redis> GET page_view    # 數字值在 Redis 中以字符串的形式保存
"21"

incrbyfloat(self, name, amount=1.0)

redis> SET mykey 10.50
OK

redis> INCRBYFLOAT mykey 0.1
"10.6"

decr(self, name, amount=1)

redis> SET failure_times 10
OK

redis> DECR failure_times
(integer) 9

append(key, value)

redis> EXISTS myphone               # 確保 myphone 不存在
(integer) 0

redis> APPEND myphone "nokia"       # 對不存在的 key 進行 APPEND ，等同於 SET myphone "nokia"
(integer) 5                         # 字符長度

2. Hash操做

hash表現形式上有些像pyhton中的dict,能夠存儲一組關聯性較強的數據， redis中Hash在內存中的存儲格式以下圖：　　

hset(name, key, value)

redis> HSET website google "www.g.cn"       # 設置一個新域
(integer) 1

redis> HSET website google "www.google.com" # 覆蓋一箇舊域
(integer) 0

hmset(name, mapping)

127.0.0.1:6379> hmset go k1 2 k2 3
OK
127.0.0.1:6379> hget go k1
"2"
# 獲取name對應的值的二進制表示中 1 的個數# 參數： # key，Redis的name # start，位起始位置 # end，位結束位置# 返回name對應值的字節長度（一個漢字3個字節）# 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。# 參數： # name,Redis的name # amount,自增數（必須是整數）# 注：同incrby# 自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。# 參數： # name,Redis的name # amount,自增數（浮點型# 自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。# 參數： # name,Redis的name # amount,自減數（整數）# 在redis name對應的值後面追加內容# 參數： key, redis的name value, 要追加的字符串# name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）# 參數： # name，redis的name # key，name對應的hash中的key # value，name對應的hash中的value# 注： # hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）# 在name對應的hash中批量設置鍵值對# 參數： # name，redis的name # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}# 如： # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

1

hmget(name, keys, *args)

hmget go k1 k2

hgetall(name)

1

hlen(name)

1

hkeys(name)

1

hvals(name)

1

hexists(name, key)

1

hdel(name,*keys)

1

hincrby(name, key, amount=1)

127.0.0.1:6379> hincrby count page 200 (integer) 200 127.0.0.1:6379> hget count page "200" 127.0.0.1:6379> hincrby count var 200 (integer) 200 127.0.0.1:6379> hget count var "200" 127.0.0.1:6379> hincrby count var -50 (integer) 150 127.0.0.1:6379> hget count var "150"

hincrbyfloat(name, key, amount=1.0)

# 值和增量都是普通小數
redis> HSET mykey field 10.50
(integer) 1
redis> HINCRBYFLOAT mykey field 0.1
"10.6"
# 值和增量都是指數符號
redis> HSET mykey field 5.0e3
(integer) 0
redis> HINCRBYFLOAT mykey field 2.0e2
"5200"
# 對不存在的鍵執行 HINCRBYFLOAT
redis> EXISTS price
(integer) 0
redis> HINCRBYFLOAT price milk 3.5
"3.5"
redis> HGETALL price
1) "milk"
2) "3.5"
# 對不存在的域進行 HINCRBYFLOAT
redis> HGETALL price
1) "milk"
2) "3.5"
redis> HINCRBYFLOAT price coffee 4.5   # 新增 coffee 域
"4.5"
redis> HGETALL price
1) "milk"
2) "3.5"
3) "coffee"
4) "4.5"

hscan(name, cursor=0, match=None, count=None)

hscan_iter(name, match=None, count=None)

3. list

List操做，redis中的List在在內存中按照一個name對應一個List來存儲。如圖：　　

lpush(name,values)

redis> LPUSH languages python
(integer) 1
# 加入重複元素
redis> LPUSH languages python
(integer) 2
redis> LRANGE languages 0 -1     # 列表容許重複元素
1) "python"
2) "python"
# 加入多個元素
redis> LPUSH mylist a b c
(integer) 3
redis> LRANGE mylist 0 -1
1) "c"
2) "b"
3) "a"

lpushx(name,value)

llen(name)

1

linsert(name, where, refvalue, value))

lset(name, index, value)

>>lset my 0 3

lrem(name, value, num)

redis> LRANGE greet 0 4         # 查看全部元素
1) "morning"
2) "hello"
3) "morning"
4) "hello"
5) "morning"
redis> LREM greet 2 morning     # 移除從表頭到表尾，最早發現的兩個 morning
(integer) 2                     # 兩個元素被移除

lpop(name)
    
    
    
    
    
     
     
     
     
      
       
        
         
          
           
           
             1 
            
           
             2 
            
           
             3 
            
           
             4 
            
           
            
              
             
            
                
             
              
             
               
             
            
          
         
        
       
     
    
    
    
    
    
lindex(name, index)
    
    
    
    
    
     
     
     
     
      
       
        
         
          
           
           
             1 
            
           
            
              
             
            
          
         
        
       
     
    
    
    
    
    
lrange(name, start, end)
    
    
    
    
    
     
     
     
     
      
       
        
         
          
           
           
             1 
            
           
             2 
            
           
             3 
            
           
             4 
            
           
             5 
            
           
            
              
             
              
             
               
             
               
             
               
             
            
          
         
       >>rpush var ship a b c 1 2 3 
       
      
        >>lrange var 0 2 
       
      
        >>1) "lisp" 
       
       
       >>2) "a" 
       
       
       >>3) "b"

ltrim(name, start, end)

rpoplpush(src, dst)

blpop(keys, timeout)

redis> LPUSH command "update system..."  # 爲command列表增長一個值
(integer) 1

redis> LPUSH request "visit page"        # 爲request列表增長一個值
(integer) 1

redis> BLPOP job command  0       # job 列表爲空，被跳過，緊接着 command 列表的第一個元素被彈出。
1) "command"                             # 彈出元素所屬的列表
2) "update system..."                    # 彈出元素所屬的值

brpoplpush(src, dst, timeout=0)

4.set集合操做

Set操做，Set集合就是不容許重複的列表

sadd(name,values)

1

# 添加單個元素
redis> SADD bbs "discuz.net"
(integer) 1
# 添加劇復元素
redis> SADD bbs "discuz.net"
(integer) 0
# 添加多個元素
redis> SADD bbs "tianya.cn" "groups.google.com"
(integer) 2
redis> SMEMBERS bbs
1) "discuz.net"
2) "groups.google.com"
3) "tianya.cn"

scard(name)

1

sdiff(keys, *args)

1

redis> SMEMBERS peter's_movies
1) "bet man"
2) "start war"
3) "2012"

redis> SMEMBERS joe's_movies
1) "hi, lady"
2) "Fast Five"
3) "2012"

redis> SDIFF peter's_movies joe's_movies
1) "bet man"
2) "start war"

sdiffstore(dest, keys, *args)

1

sinter(keys, *args)

1

sinterstore(dest, keys, *args)

1

sismember(name, value)

1

smembers(name)

1

smove(src, dst, value)

 
            redis> SMEMBERS songs
1) "Billie Jean"
2) "Believe Me"

redis> SMEMBERS my_songs
(empty list or set)

redis> SMOVE songs my_songs "Believe Me"
(integer) 1

redis> SMEMBERS songs
1) "Billie Jean"

redis> SMEMBERS my_songs
1) "Believe Me"

spop(name)

1

srandmember(name, numbers)

1

srem(name, values)

 
            # 移除多個元素

redis> SREM languages lisp python c
(integer) 3

sunion(keys, *args)

 
            redis> SMEMBERS songs
1) "Billie Jean"

redis> SMEMBERS my_songs
1) "Believe Me"

redis> SUNION songs my_songs
1) "Billie Jean"
2) "Believe Me"

sunionstore(dest,keys, *args)

 
            redis> SMEMBERS NoSQL
1) "MongoDB"
2) "Redis"

redis> SMEMBERS SQL
1) "sqlite"
2) "MySQL"

redis> SUNIONSTORE db NoSQL SQL
(integer) 4

redis> SMEMBERS db
1) "MySQL"
2) "sqlite"
3) "MongoDB"
4) "Redis"

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None)

1

SortedSet（有序集合）

有序集合，在集合的基礎上，爲每元素排序；元素的排序須要根據另一個值來進行比較，因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。

zadd(name, *args, **kwargs)

 
            # 添加單個元素

redis> ZADD page_rank 10 google.com
(integer) 1

# 添加多個元素

redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2

redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"

zcard(name)

1

zcount(name, min, max)

1

zincrby(name, value, amount)

 
            redis> ZSCORE salary tom
"2000"

redis> ZINCRBY salary 2000 tom   # tom 加薪啦！
"4000"

zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

 
            redis > ZRANGE salary 0 -1 WITHSCORES             # 顯示整個有序集成員
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis > ZRANGE salary 1 2 WITHSCORES              # 顯示有序集下標區間 1 至 2 的成員
1) "tom"
2) "5000"
3) "boss"
4) "10086"

redis > ZRANGE salary 0 200000 WITHSCORES         # 測試 end 下標超出最大下標時的狀況
1) "jack"
2) "3500"
3) "tom"
4) "5000"
5) "boss"
6) "10086"

redis > ZRANGE salary 200000 3000000 WITHSCORES   # 測試當給定區間不存在於有序集時的狀況
(empty list or set)

zrank(name, value)

 
            redis> ZRANGE salary 0 -1 WITHSCORES        # 顯示全部成員及其 score 值
1) "peter"
2) "3500"
3) "tom"
4) "4000"
5) "jack"
6) "5000"

redis> ZRANK salary tom                     # 顯示 tom 的薪水排名，第二
(integer) 1

zrem(name, values)

 
            redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10" 
            # 移除單個元素

redis> ZREM page_rank google.com
(integer) 1

redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"# 移除多個元素

redis> ZREM page_rank baidu.com bing.com

zremrangebyrank(name, min, max)

 
            redis> ZADD salary 2500 jack                        # 測試數據
(integer) 0
redis> ZADD salary 5000 tom
(integer) 0
redis> ZADD salary 12000 peter
(integer) 0

redis> ZRANGEBYSCORE salary -inf +inf               # 顯示整個有序集
1) "jack"
2) "tom"
3) "peter"

redis> ZRANGEBYSCORE salary -inf +inf WITHSCORES    # 顯示整個有序集及成員的 score 值
1) "jack"
2) "2500"
3) "tom"
4) "5000"
5) "peter"
6) "12000"

redis> ZRANGEBYSCORE salary -inf 5000 WITHSCORES    # 顯示工資 <=5000 的全部成員
1) "jack"
2) "2500"
3) "tom"
4) "5000"

redis> ZRANGEBYSCORE salary (5000 400000            # 顯示工資大於 5000 小於等於 400000 的成員
1) "peter"

zremrangebyscore(name, min, max)

1

  
           
redis> ZRANGE salary 0 -1 WITHSCORES          # 顯示有序集內全部成員及其 score 值
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis> ZREMRANGEBYSCORE salary 1500 3500      # 移除全部薪水在 1500 到 3500 內的員工
(integer) 2

redis> ZRANGE salary 0 -1 WITHSCORES          # 剩下的有序集成員
1) "jack"
2) "5000"

zscore(name, value)

 
            redis> ZRANGE salary 0 -1 WITHSCORES    # 測試數據
1) "tom"
2) "2000"
3) "peter"
4) "3500"
5) "jack"
6) "5000"

redis> ZSCORE salary peter              # 注意返回值是字符串
"3500"

zinterstore(dest, keys, aggregate=None)

 
            redis > ZADD mid_test 70 "Li Lei"
(integer) 1
redis > ZADD mid_test 70 "Han Meimei"
(integer) 1
redis > ZADD mid_test 99.5 "Tom"
(integer) 1

redis > ZADD fin_test 88 "Li Lei"
(integer) 1
redis > ZADD fin_test 75 "Han Meimei"
(integer) 1
redis > ZADD fin_test 99.5 "Tom"
(integer) 1

redis > ZINTERSTORE sum_point 2 mid_test fin_test
(integer) 3

redis > ZRANGE sum_point 0 -1 WITHSCORES     # 顯示有序集內全部成員及其 score 值
1) "Han Meimei"
2) "145"
3) "Li Lei"
4) "158"
5) "Tom"
6) "199"

zunionstore(dest, keys, aggregate=None)

 
       
        
          
           
           
  
           
  
            redis> ZRANGE programmer 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"

redis> ZRANGE manager 0 -1 WITHSCORES
1) "herry"
2) "2000"
3) "mary"
4) "3500"
5) "bob"
6) "4000"

redis> ZUNIONSTORE salary 2 programmer manager WEIGHTS 1 3   # 公司決定加薪。。。除了程序員。。。
(integer) 6

redis> ZRANGE salary 0 -1 WITHSCORES
1) "peter"
2) "2000"
3) "jack"
4) "3500"
5) "tom"
6) "5000"
7) "herry"
8) "6000"
9) "mary"
10) "10500"
11) "bob"
12) "12000" 
           
 
        
 
       
     

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

1

其餘經常使用操做

delete(*names)

# 在name對應的hash中獲取根據key獲取value# 在name對應的hash中獲取多個key的值# 參數： # name，reids對應的name # keys，要獲取key集合，如：['k1', 'k2', 'k3'] # *args，要獲取的key，如：k1,k2,k3# 如： # r.mget('xx', ['k1', 'k2']) # 或 # print r.hmget('xx', 'k1', 'k2')獲取name對應hash的全部鍵值# 獲取name對應的hash中鍵值對的個數# 獲取name對應的hash中全部的key的值# 獲取name對應的hash中全部的value的值# 檢查name對應的hash是否存在當前傳入的key# 將name對應的hash中指定key的鍵值對刪除# 自增name對應的hash中的指定key的值，不存在則建立key=amount# 參數： # name，redis中的name # key， hash對應的key # amount，自增數（整數）# 自增name對應的hash中的指定key的值，不存在則建立key=amount# 參數： # name，redis中的name # key， hash對應的key # amount，自增數（浮點數）# 自增name對應的hash中的指定key的值，不存在則建立key=amount# 增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆# 參數： # name，redis的name # cursor，遊標（基於遊標分批取獲取數據） # match，匹配指定key，默認None 表示全部的key # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數# 如： # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None) # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None) # ... # 直到返回值cursor的值爲0時，表示數據已經經過分片獲取完畢# 利用yield封裝hscan建立生成器，實現分批去redis中獲取數據 # 參數： # match，匹配指定key，默認None 表示全部的key # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數 # 如： # for item in r.hscan_iter('xx'): # print item# 在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊# 如： # r.lpush('oo', 11,22,33) # 保存順序爲: 33,22,11# 擴展： # rpush(name, values) 表示從右向左操做# 在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊# 更多： # rpushx(name, value) 表示從右向左操做# name對應的list元素的個數# 在name對應的列表的某一個值前或後插入一個新值# 參數： # name，redis的name # where，BEFORE或AFTER # refvalue，標杆值，即：在它先後插入數據 # value，要插入的數據# 對name對應的list中的某一個索引位置從新賦值# 參數： # name，redis的name # index，list的索引位置 # value，要設置的值# 在name對應的list中刪除指定的值# 參數： # name，redis的name # value，要刪除的值 # num， num=0，刪除列表中全部的指定值； # num=2,從前到後，刪除2個； # num=-2,從後向前，刪除2個# 在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素# 更多： # rpop(name) 表示從右向左操做在name對應的列表中根據索引獲取列表元素# 在name對應的列表分片獲取數據# 參數： # name，redis的name # start，索引的起始位置 # end，索引結束位置# 在name對應的列表中移除沒有在start-end索引之間的值# 參數： # name，redis的name # start，索引的起始位置 # end，索引結束位置# 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊# 參數： # src，要取數據的列表的name # dst，要添加數據的列表的name# 將多個列表排列，按照從左到右去pop對應列表的元素# 參數： # keys，redis的name的集合 # timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞# 更多： # r.brpop(keys, timeout)，從右向左獲取數據# 從一個列表的右側移除一個元素並將其添加到另外一個列表的左側# 參數： # src，取出並要移除元素的列表對應的name # dst，要插入元素的列表對應的name # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞# name對應的集合中添加元素獲取name對應的集合中元素個數在第一個name對應的集合中且不在其餘name對應的集合的元素集合# 獲取第一個name對應的集合中且不在其餘name對應的集合，再將其新加入到dest對應的集合中# 獲取多一個name對應集合的並集# 獲取多一個name對應集合的並集，再講其加入到dest對應的集合中# 檢查value是不是name對應的集合的成員# 獲取name對應的集合的全部成員# 將某個成員從一個集合中移動到另一個集合# 從集合的右側（尾部）移除一個成員，並將其返回# 從name對應的集合中隨機獲取 numbers 個元素# 在name對應的集合中刪除某些值# 獲取多一個name對應的集合的並集# 獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中# 同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大# 在name對應的有序集合中添加元素# 如： # zadd('zz', 'n1', 1, 'n2', 2) # 或 # zadd('zz', n1=11, n2=22)# 獲取name對應的有序集合元素的數量# 獲取name對應的有序集合中分數在 [min,max] 之間的個數# 自增name對應的有序集合的 name 對應的分數# 按照索引範圍獲取name對應的有序集合的元素# 參數： # name，redis的name # start，有序集合索引發始位置（非分數） # end，有序集合索引結束位置（非分數） # desc，排序規則，默認按照分數從小到大排序 # withscores，是否獲取元素的分數，默認只獲取元素的值 # score_cast_func，對分數進行數據轉換的函數# 更多： # 從大到小排序 # zrevrange(name, start, end, withscores=False, score_cast_func=float) # 按照分數範圍獲取name對應的有序集合的元素 # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float) # 從大到小排序 # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)# 獲取某個值在 name對應的有序集合中的排行（從 0 開始）# 更多： # zrevrank(name, value)，從大到小排序# 刪除name對應的有序集合中值是values的成員# 如：zrem('zz', ['s1', 's2'])# 根據排行範圍刪除# 根據分數範圍刪除# 獲取name對應有序集合中 value 對應的分數# 獲取兩個有序集合的交集，若是遇到相同值不一樣分數，則按照aggregate進行操做# aggregate的值爲: SUM MIN MAX# 獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做# aggregate的值爲: SUM MIN MAX# 同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。