Java學習筆記-Pair和Map
阿新 • • 發佈：2020-12-27
技術標籤：Redis
目錄
redis學習 （key）鍵，Python操作redis 鍵 （二）
Python操作redis系列以 雜湊(Hash)命令詳解（四）
Python操作redis學習系列之（集合）set，redis set詳解 （六）
python 操作redis之——有序集合(sorted set) （七）
python 操作redis之——HyperLogLog （八）
redis安裝和配置（一） http://www.cnblogs.com/xuchunlin/p/6676308.html
redis學習 （key）鍵，Python操作redis 鍵 （二） http://www.cnblogs.com/xuchunlin/p/7061524.html
Python操作redis字串(String)詳解 (三) http://www.cnblogs.com/xuchunlin/p/7062065.html
Python操作redis系列以 雜湊(Hash)命令詳解（四） http://www.cnblogs.com/xuchunlin/p/7064860.html
Python操作redis系列之 列表（list） (五) http://www.cnblogs.com/xuchunlin/p/7067154.html
Python操作redis學習系列之（集合）set，redis set詳解 （六）http://www.cnblogs.com/xuchunlin/p/7070267.html
python 操作redis之——有序集合(sorted set) （七） http://www.cnblogs.com/xuchunlin/p/7097272.html
python 操作redis之——HyperLogLog （八） http://www.cnblogs.com/xuchunlin/p/7097272.html
redis.windows.conf各項配置引數介紹 （九） http://www.cnblogs.com/xuchunlin/p/7097729.html
redis安裝和配置（一）
Redis 的官方下載站是http://redis.io/download
怎麼安裝 Redis 資料庫呢？下面將介紹Linux 版本的安裝方法
步驟一: 下載Redis
下載安裝包：wget http://redis.googlecode.com/files/redis-2.2.12.tar.gz
[[email protected] 4setup]# wget http://redis.googlecode.com/files/redis-2.2.12.tar.gz
--19:06:56-- http://redis.googlecode.com/files/redis-2.2.12.tar.gz
正在解析主機 redis.googlecode.com... 74.125.71.82
Connecting to redis.googlecode.com|74.125.71.82|:80... 已連線。
已發出 HTTP 請求，正在等待迴應... 200 OK
長度：455240 (445K) [application/x-gzip]
Saving to: `redis-2.2.12.tar.gz'
100%[==========================================>] 455,240 34.8K/s in 13s
19:07:16 (34.8 KB/s) - `redis-2.2.12.tar.gz' saved [455240/455240]
[[email protected] 4setup]#
步驟二: 編譯源程式
[[email protected] 4setup]# ll
總計 29168
-rw-r--r-- 1 root root 455240 2011-07-22 redis-2.2.12.tar.gz
[[email protected] 4setup]# tar xzf redis-2.2.12.tar.gz
[[email protected] 4setup]# cd redis-2.2.12
[[email protected] redis-2.2.12]# make
cd src && make all
make[1]: Entering directory `/root/4setup/redis-2.2.12/src'
步驟三: 啟動Redis 服務
[[email protected] redis-2.2.12]# src/redis-server
[6246] 05 Aug 19:17:22 # Warning: no config file specified, using the default config. In order to
specify a config file use 'redis-server /path/to/redis.conf'
[6246] 05 Aug 19:17:22 * Server started, Redis version 2.2.12
[6246] 05 Aug 19:17:22 # WARNING overcommit_memory is set to 0! Background save may fail
under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to
/etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this
to take effect.
[6246] 05 Aug 19:17:22 * The server is now ready to accept connections on port 6379
[6246] 05 Aug 19:17:22 - 0 clients connected (0 slaves), 539544 bytes in use
Redis 服務端的預設連線埠是 6379
步驟四: 將Redis 作為 Linux 服務隨機啟動
vi /etc/rc.local, 使用vi 編輯器開啟隨機啟動配置檔案，並在其中加入下面一行程式碼
/root/4setup/redis-2.2.12/src/redis-server
步驟五: 客戶端連線驗證
新開啟一個Session 輸入：src/redis-cli，如果出現下面提示，那麼您就可以開始Redis 之旅了
[[email protected] redis-2.2.12]# src/redis-cli
redis 127.0.0.1:6379>步驟六: 檢視Redis 日誌
檢視伺服器端session，即可對Redis 的執行狀況進行檢視或分析了
[6246] 05 Aug 19:24:33 - 0 clients connected (0 slaves), 539544 bytes in use
[6246] 05 Aug 19:24:37 - Accepted 127.0.0.1:51381
[6246] 05 Aug 19:24:38 - 1 clients connected (0 slaves), 547372 bytes in use以上的幾個步驟就OK 了！！這樣一個簡單的Redis 資料庫就可以暢通無阻地執行起來了。
步驟七: 停止Redis 例項
最簡單的方法是在啟動例項的session 中，直接使用Control-C 來將例項停止。
我們還可以用客戶端來停止服務，如可以用shutdown 來停止Redis 例項, 具體如下:
[[email protected] redis-2.2.12]# src/redis-cli shutdown步驟八：
如果是一個專業的DBA，那麼例項啟動時會加很多的引數以便使系統執行的非常穩定，這樣就可能會在啟動時在Redis 後面加一個引數，以指定配置檔案的路徑，就象mysql 一樣的讀取啟動配置檔案的方式來啟動資料庫。原始碼編譯完成後，在redis-2.2.12 目錄下有一個redis.conf 檔案，這個檔案即是Redis 的配置檔案，用配置檔案來啟動Redis 的方法如下:
[[email protected] redis-2.2.12]# src/redis-server redis.conf
[6353] 05 Aug 19:36:45 * Server started, Redis version 2.2.12
[6353] 05 Aug 19:36:45 # WARNING overcommit_memory is set to 0! Background save may fail
under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to
/etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this
to take effect.
[6353] 05 Aug 19:36:45 * The server is now ready to accept connections on port 6379
[6353] 05 Aug 19:36:45 - 0 clients connected (0 slaves), 539540 bytes in use
Redis 支援很多的引數，但都有預設值。
<>daemonize:
預設情況下，redis 不是在後臺執行的，如果需要在後臺執行，把該項的值更改為yes
<>pidfile
當Redis 在後臺執行的時候，Redis 預設會把pid 檔案放在/var/run/redis.pid，你可以配置到其他地址。當執行多個redis 服務時，需要指定不同的pid 檔案和埠
<>bind
指定Redis 只接收來自於該IP 地址的請求，如果不進行設定，那麼將處理所有請求，在生產環境中最好設定該項
<>port
監聽埠，預設為6379
<>timeout
設定客戶端連線時的超時時間，單位為秒。當客戶端在這段時間內沒有發出任何指令，那麼關閉該連線
<>loglevel
log 等級分為4 級，debug, verbose, notice, 和warning。生產環境下一般開啟notice
<>logfile
配置log 檔案地址，預設使用標準輸出，即列印在命令列終端的視窗上
<>databases
設定資料庫的個數，可以使用SELECT <dbid>命令來切換資料庫。預設使用的資料庫是0
<>save
設定Redis 進行資料庫映象的頻率。
if(在60 秒之內有10000 個keys 發生變化時){進行映象備份
}else if(在300 秒之內有10 個keys 發生了變化){進行映象備份
}else if(在900 秒之內有1 個keys 發生了變化){進行映象備份
}
<>rdbcompression
在進行映象備份時，是否進行壓縮
<>dbfilename
映象備份檔案的檔名
<>dir
資料庫映象備份的檔案放置的路徑。這裡的路徑跟檔名要分開配置是因為Redis 在進行備份時，先會將當前資料庫的狀態寫入到一個臨時檔案中，等備份完成時，再把該該臨時檔案替換為上面所指定的檔案，而這裡的臨時檔案和上面所配置的備份檔案都會放
在這個指定的路徑當中
<>slaveof
設定該資料庫為其他資料庫的從資料庫
<>masterauth
當主資料庫連線需要密碼驗證時，在這裡指定
<>requirepass
設定客戶端連線後進行任何其他指定前需要使用的密碼。警告：因為redis 速度相當快，所以在一臺比較好的伺服器下，一個外部的使用者可以在一秒鐘進行150K 次的密碼嘗試，這意味著你需要指定非常非常強大的密碼來防止暴力破解。
<>maxclients
限制同時連線的客戶數量。當連線數超過這個值時，redis 將不再接收其他連線請求，客戶端嘗試連線時將收到error 資訊。
<>maxmemory
設定redis 能夠使用的最大記憶體。當記憶體滿了的時候，如果還接收到set 命令，redis 將先嚐試剔除設定過expire 資訊的key，而不管該key 的過期時間還沒有到達。在刪除時，將按照過期時間進行刪除，最早將要被過期的key 將最先被刪除。如果帶有expire 資訊的key 都刪光了，那麼將返回錯誤。這樣，redis 將不再接收寫請求，只接收get 請求。
maxmemory 的設定比較適合於把redis 當作於類似memcached 的快取來使用。
<>appendonly
預設情況下，redis 會在後臺非同步的把資料庫映象備份到磁碟，但是該備份是非常耗時的，而且備份也不能很頻繁，如果發生諸如拉閘限電、拔插頭等狀況，那麼將造成比較大範圍的資料丟失。所以redis 提供了另外一種更加高效的資料庫備份及災難恢復方式。開啟append only 模式之後，redis 會把所接收到的每一次寫操作請求都追加到appendonly.aof 檔案中，當redis 重新啟動時，會從該檔案恢復出之前的狀態。但是這樣會造成appendonly.aof 檔案過大，所以redis 還支援了BGREWRITEAOF 指令，對appendonly.aof 進行重新整理。所以我認為推薦生產環境下的做法為關閉映象，開啟appendonly.aof，同時可以選擇在訪問較少的時間每天對appendonly.aof 進行重寫一次。
<>appendfsync
設定對appendonly.aof 檔案進行同步的頻率。always 表示每次有寫操作都進行同步，everysec 表示對寫操作進行累積，每秒同步一次。這個需要根據實際業務場景進行配置
<>vm-enabled
是否開啟虛擬記憶體支援。因為redis 是一個記憶體資料庫，而且當記憶體滿的時候，無法接收新的寫請求，所以在redis 2.0 中，提供了虛擬記憶體的支援。但是需要注意的是，redis中，所有的key 都會放在記憶體中，在記憶體不夠時，只會把value 值放入交換區。這樣保證了雖然使用虛擬記憶體，但效能基本不受影響，同時，你需要注意的是你要把vm-max-memory 設定到足夠來放下你的所有的key
<>vm-swap-file
設定虛擬記憶體的交換檔案路徑
<>vm-max-memory
這裡設定開啟虛擬記憶體之後，redis 將使用的最大實體記憶體的大小。預設為0，redis 將把他所有的能放到交換檔案的都放到交換檔案中，以儘量少的使用實體記憶體。在生產環境下，需要根據實際情況設定該值，最好不要使用預設的0
<>vm-page-size
設定虛擬記憶體的頁大小，如果你的value 值比較大，比如說你要在value 中放置部落格、新聞之類的所有文章內容，就設大一點，如果要放置的都是很小的內容，那就設小一點。
<>vm-pages
設定交換檔案的總的page 數量，需要注意的是，page table 資訊會放在實體記憶體中，每8 個page 就會佔據RAM 中的1 個byte。總的虛擬記憶體大小 ＝ vm-page-size * vm-pages
<>vm-max-threads
設定VM IO 同時使用的執行緒數量。因為在進行記憶體交換時，對資料有編碼和解碼的過程，所以儘管IO 裝置在硬體上本上不能支援很多的併發讀寫，但是還是如果你所儲存的vlaue 值比較大，將該值設大一些，還是能夠提升效能的
<>glueoutputbuf
把小的輸出快取放在一起，以便能夠在一個TCP packet 中為客戶端傳送多個響應，具體原理和真實效果我不是很清楚。所以根據註釋，你不是很確定的時候就設定成yes
<>hash-max-zipmap-entries
在redis 2.0 中引入了hash 資料結構。當hash 中包含超過指定元素個數並且最大的元素沒有超過臨界時，hash 將以一種特殊的編碼方式（大大減少記憶體使用）來儲存，這裡可以設定這兩個臨界值
<>activerehashing
開啟之後，redis 將在每100 毫秒時使用1 毫秒的CPU 時間來對redis 的hash 表進行重新hash，可以降低記憶體的使用。當你的使用場景中，有非常嚴格的實時性需要，不能夠接受Redis 時不時的對請求有2 毫秒的延遲的話，把這項配置為no。如果沒有這麼嚴格的實時性要求，可以設定為yes，以便能夠儘可能快的釋放記憶體
redis學習 （key）鍵，Python操作redis 鍵 （二）
# -*- coding: utf-8 -*-
import redis
#這個redis 連線不能用，請根據自己的需要修改
r =redis.Redis(host="123.516.174.910",port=6379,password="11111608")1. delete DEL 命令用於刪除已存在的鍵。不存在的 key 會被忽略
print r.set('1', '4028b2883d3f5a8b013d57228d760a93') #set 設定指定 key 的值， 如果設定正確返回 True
print r.get('1') # 得到 鍵為1 的值 4028b2883d3f5a8b013d57228d760a93
print r.delete('1') # 刪除 鍵為1 的值
print r.get('1') #因為上面已經把鍵為1 的值刪除掉，所以返回的是None
2. exists#設定鍵為2的值是 4028b2883d3f5a8b013d57228d760a93
r.set('2', '4028b2883d3f5a8b013d57228d760a93')
# 存在就返回True 不存在就返回False
print r.exists('2') #返回True
print r.exists('33') #返回False3. Expire 命令用於設定 key 的過期時間。key 過期後將不再可用。r.set('2', '4028b2883d3f5a8b013d57228d760a93')
#成功就返回True 失敗就返回False，下面的20表示是20秒
print r.expire('2',20)
#如果時間沒事失效我們能得到鍵為2的值，否者是None
print r.get('2') 4. Expireat 命令用於以 UNIX 時間戳(unix timestamp)格式設定 key 的過期時間。key 過期後將不再可用。主意:時間精確到秒，時間戳是10為數字r.set('2', '4028b2883d3f5a8b013d57228d760a93')
#成功就返回True 失敗就返回False，下面的1598033936表示是在2020-08-22 02:18:56 鍵2 過期
print r.expireat('2',1598033936)
print r.get('2')5.PEXPIREAT 命令用於設定 key 的過期時間，已毫秒技。key 過期後將不再可用。主意:時間精確到毫秒，時間戳是13位數字
r.set('2', '4028b2883d3f5a8b013d57228d760a93')
#成功就返回True 失敗就返回False。
print r.expireat('2',1598033936000)
print r.get('2')6. Keys 命令用於查詢所有符合給定模式 pattern 的 key 。print r.set('111', '11')
print r.set('122', '12')
print r.set('113', '13')
print r.keys(pattern='11*')
# 輸出的結果是 ['113', '111'] 因為鍵122不和 11* 匹配7. MOVE 命令用於將當前資料庫的 key 移動到給定的資料庫 db 當中,select可以設定當前的資料庫，如有需要請看select命令
因為我們預設使用的資料庫是db0，我們可以使用下面的命令鍵 2 移動到資料庫 1 中去r.move(2,1)8. PERSIST 命令用於移除給定 key 的過期時間，使得 key 永不過期
#設定鍵為 1 的值為11
print r.set('1', '11')
#設定鍵 1 過期時間為100秒
print r.expire(1,100)
# 檢視鍵 1 的過期時間還剩下多少
print r.ttl('1')
# 目的是13秒後移除鍵 1 的過期時間
import time
time.sleep(3)
# 檢視鍵 1 的過期時間還剩下多少
print r.ttl('1')
#移除鍵 1 的過期時間
r.persist(1)
# 檢視鍵 1 的過期時間還剩下多少 輸出的結果是 None，我們可以通過redis desktop manager 檢視鍵 1 的過期時間
print r.ttl('1')
9. Pttl 命令以毫秒為單位返回 key 的剩餘過期時間。
# 當 key 不存在時，返回 -2 。 當 key 存在但沒有設定剩餘生存時間時，返回 -1 。 否則，以毫秒為單位，返回 key 的剩餘生存時間。
#設定鍵為 1 的值為11
print r.set('1', '11')
#設定鍵 1 過期時間為100秒
print r.expire(1,100)
import time
time.sleep(3)
#返回的結果是 96994 ，執行的結果不是固定的，大於是97秒鐘，主意是為了展示出返回的結果是毫秒，一秒等於1000毫秒
print r.pttl('1')
10. TTL 命令以秒為單位返回 key 的剩餘過期時間。
# 當 key 不存在時，返回 -2 。 當 key 存在但沒有設定剩餘生存時間時，返回 -1 。 否則，以毫秒為單位，返回 key 的剩餘生存時間。
#設定鍵為 1 的值為11
print r.set('1', '11')
print r.expire(1,100) #設定鍵 1 過期時間為100秒
import time
time.sleep(3)
print r.ttl('1') #返回的結果是 97
print r.ttl('123') #因為鍵 123 不存在 所以返回的結果是None
11.RANDOMKEY 命令從當前資料庫中隨機返回一個 key。當資料庫不為空時，返回一個 key 。 當資料庫為空時，返回 nil 。print r.randomkey() #資料庫返回的是預設的資料庫 key12 .Rename 命令用於修改 key 的名稱 。改名成功時提示 OK ，失敗時候返回一個錯誤。print r.rename(1,1111) #修改成功返回 True
print r.rename(222,1111) #如果key 不存在 修改失敗返回 redis.exceptions.ResponseError: no such key13. Renamenx 命令用於在新的 key 不存在時修改 key 的名稱 。print r.exists(123123) #返回false
print r.renamenx(1111,123123) #成功返回True
print r.renamenx(1111,123123) #失敗返回 redis.exceptions.ResponseError: no such key14. Type 命令用於返回 key 所儲存的值的型別
# 返回 key 的資料型別，資料型別有：none (key不存在)，string (字串)，list (列表)，set (集合)，zset (有序集)，hash (雜湊表)，
print r.set('1',"111111111")
print r.type('1') #返回的結果是string
print r.sadd('2','222222222222')
print r.type('2') #返回的結果是set
print r.lpush('3','33333333')
print r.type('3') #返回的結果是list
| 命令 | 描述 |
| 該命令用於在 key 存在是刪除 key。 | |
| 序列化給定 key ，並返回被序列化的值。 | |
| 檢查給定 key 是否存在。 | |
| seconds 為給定 key 設定過期時間。 | |
| EXPIREAT 的作用和 EXPIRE 類似，都用於為 key 設定過期時間。不同在於 EXPIREAT 命令接受的時間引數是 UNIX 時間戳(unix timestamp)。 | |
| 設定 key 的過期時間億以毫秒計。 | |
| 設定 key 過期時間的時間戳(unix timestamp) 以毫秒計 | |
| 查詢所有符合給定模式( pattern)的 key 。 | |
| 將當前資料庫的 key 移動到給定的資料庫 db 當中。 | |
| 移除 key 的過期時間，key 將持久保持。 | |
| 以毫秒為單位返回 key 的剩餘的過期時間。 | |
| 以秒為單位，返回給定 key 的剩餘生存時間(TTL, time to live)。 | |
| 從當前資料庫中隨機返回一個 key 。 | |
| 修改 key 的名稱 | |
| 僅當 newkey 不存在時，將 key 改名為 newkey 。 | |
| 返回 key 所儲存的值的型別。 |
Python操作redis字串(String)詳解 (三)
# -*- coding: utf-8 -*-
import redis
#這個redis不能用，請根據自己的需要修改
r =redis.Redis(host="123.516.74.190",port=6379,password="6666666666")1.SET 命令用於設定給定 key 的值。如果 key 已經儲存其他值， SET 就覆寫舊值，且無視型別。print r.set('123','123') # 插入成功後返回True
print r.set('123','[123,dffd]') # 插入成功後返回True2. Get 命令用於獲取指定 key 的值。如果 key 不存在，返回 None 。如果key 儲存的值不是字串型別，返回一個錯誤。print r.get('123') #返回的結果是[123,dffd]
print r.get('1234')#返回的結果是 None3. Getrange 命令用於獲取儲存在指定 key 中字串的子字串。字串的擷取範圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)。print r.set('getrange','wo shi hao ren ')
print r.getrange('getrange',2,4) #返回的結果是sh
print r.getrange('getrange',2,6) #返回的結果是shi
print r.getrange('getrange',2,10) #返回的結果是shi hao4.Getset 命令用於設定指定 key 的值，並返回 key 舊的值，當 key 存在但不是字串型別時，返回一個錯誤。print r.getset('getrange','hello word') #返回的結果是wo shi hao ren
print r.getset('getrange11','hello word') #當鍵不存在的時候，返回的結果是None 5.Getbit 命令用於對 key 所儲存的字串值，獲取指定偏移量上的位(bit)字串值指定偏移量上的位(bit)。當偏移量 getrange 比字串值的長度大，或者 key 不存在時，返回 0。print r.get('getrange') #返回的結果是 hello word
print r.getbit('getrange',1) #返回的結果是 1
print r.getbit('getrange',3) #返回的結果是 0
print r.getbit('getr22222ange',3) #字串的鍵不存在的時候返回的結果是 0
print r.getbit('getrange',300) #偏移量超過字串長度，返回的結果是 06.Mget 命令返回所有(一個或多個)給定 key 的值。 如果給定的 key 裡面，有某個 key 不存在，那麼這個 key 返回特殊值 Noneprint r.set('1','1') #返回的結果是 True
print r.set('11','11') #返回的結果是 True
print r.set('111','111') #返回的結果是 True
print r.mget('1','11','111') #返回的結果是 ['1', '11', '111']
print r.mget('1','11','222222') #因為鍵222222不存在，返回的結果是 ['1', '11', None] 7. Setbit 命令用於對 key 所儲存的字串值，設定或清除指定偏移量上的位(bit)。print r.get('getrange') #返回的結果是 hello word
print r.setbit('getrange',4,10086) #返回的結果是 1
print r.getbit('getrange',10086) #返回的結果是 0
print r.setbit('getrange',5,100861) #返回的結果是 0
print r.getbit('getrange',100861) #返回的結果是 08.Setex 命令為指定的 key 設定值及其過期時間。如果 key 已經存在， SETEX 命令將會替換舊的值。
print r.setex('1','123',10) #返回的結果是 True
import time
time.sleep(5)
print r.ttl('1') #返回的結果是 4
print r.get('1') #返回的結果是 123
time.sleep(6)
print r.get('1') #返回的結果是 None
9.Setnx（SET if Not eXists） 命令在指定的 key 不存在時，為 key 設定指定的值。設定成功，返回 1 。 設定失敗，返回 0 。print r.exists('22') #返回的結果是 False
print r.setnx('22','2222222') #返回的結果是 True
print r.setnx('22','123456') #返回的結果是 False
print r.get('22') #返回的結果是 222222210. Setrange 命令用指定的字串覆蓋給定 key 所儲存的字串值，覆蓋的位置從偏移量 offset 開始。print r.set('11','hello world') #返回的結果是 True
print r.setrange('11',6,"redis") #返回的結果是 11
print r.get('11') #返回的結果是 hello redis11. Strlen 命令用於獲取指定 key 所儲存的字串值的長度。當 key 儲存的不是字串值時，返回一個錯誤。print r.get('11') #返回的結果是 hello redis
print r.strlen('11') #返回的結果是 11
print r.strlen('121') # 當key不存在的時候，返回的結果是 012.Mset 命令用於同時設定一個或多個 key-value 對。
#第一種方法
print r.mset(name1="1", name2='2') #返回的結果是 True
#第二種方法
print r.mset({"name3":'3', "name4":'4'}) #返回的結果是 True
print r.get('name1') #返回的結果是 1
print r.get('name2') #返回的結果是 2
print r.get('name3') #返回的結果是 3
print r.get('name4') #返回的結果是 4
13. Msetnx 命令用於所有給定 key 都不存在時，同時設定一個或多個 key-value 對。
當所有 key 都成功設定，返回 1 。 如果所有給定 key 都設定失敗(至少有一個 key 已經存在)，那麼返回 0 。print r.msetnx(name5="5", name6='6') #返回的結果是 True
print r.msetnx(name5="55", name7='7') #返回的結果是 False
print r.get('name5') #返回的結果是 5
print r.get('name6') #返回的結果是 6
print r.get('name7') #返回的結果是 None14. Psetex 命令以毫秒為單位設定 key 的生存時間。主意：SETEX 命令那樣，以秒為單位。print r.psetex('name8',1000,"nihao") #返回的結果是 True
print r.pttl('name8') #返回的結果是 690
print r.get('name8') #返回的結果是 nihao 時間過期後返回的是 None15.Incr 命令將 key 中儲存的數字值增一如果 key 不存在，那麼 key 的值會先被初始化為 0 ，然後再執行 INCR 操作。
如果值包含錯誤的型別，或字串型別的值不能表示為數字，那麼返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。
print r.set('11',20) #返回的結果是 True
print r.incr('11') #返回的結果是 21
print r.get('11') #返回的結果是 21
print r.incr('11',amount=2) #返回的結果是 23
print r.get('11') #返回的結果是 23
print r.incr('21',amount=2) #返回的結果是 2
print r.incr('22') #返回的結果是 1
16.Redis Incrby 命令將 key 中儲存的數字加上指定的增量值。
如果 key 不存在，那麼 key 的值會先被初始化為 0 ，然後再執行 INCRBY 命令。
如果值包含錯誤的型別，或字串型別的值不能表示為數字，那麼返回一個錯誤。print r.set("13",13) #返回的結果是 True
print r.incrby('13',12) #返回的結果是 25
print r.incrby('15',12) #返回的結果是 12
print r.incrby('15',12) #返回的結果是 2417.Redis Incrbyfloat 命令為 key 中所儲存的值加上指定的浮點數增量值。
如果 key 不存在，那麼 INCRBYFLOAT 會先將 key 的值設為 0 ，再執行加法操作。print r.set('1',1.1) #返回的結果是 True
print r.incrbyfloat('1',2.32) #返回的結果是 3.42
print r.get('1') #返回的結果是 3.42
print r.incrbyfloat('1',amount=1.2) #返回的結果是 4.6218.Redis Decr 命令將 key 中儲存的數字值減一。
如果 key 不存在，那麼 key 的值會先被初始化為 0 ，然後再執行 DECR 操作。
如果值包含錯誤的型別，或字串型別的值不能表示為數字，那麼返回一個錯誤。
本操作的值限制在 64 位(bit)有符號數字表示之內。print r.decr('22') #如果 key 22 不存在，返回的結果是 -1
print r.set('bb',20) #返回的結果是 True
print r.decr('bb',amount=2) #返回的結果是 18
print r.decr('cc') #返回的結果是 -119. Redis Append 命令用於為指定的 key 追加值。
如果 key 已經存在並且是一個字串， APPEND 命令將 value 追加到 key 原來的值的末尾。
如果 key 不存在， APPEND 就簡單地將給定 key 設為 value ，就像執行 SET key value 一樣。
print r.set("11",12) #返回的結果是 True
print r.append('11',12) #返回的結果是 4
print r.append('11',1) #返回的結果是 5
print r.append('11',2) #返回的結果是 6
print r.get('11') #返回的結果是 121212
print r.exists('14') #返回的結果是 False
print r.append('14','hello world') #返回的結果是 11
print r.get('14') #返回的結果是 hello world
附錄：redis string 命令
| 命令 | 描述 |
| 設定指定 key 的值 | |
| 獲取指定 key 的值。 | |
| 返回 key 中字串值的子字元 | |
| 將給定 key 的值設為 value ，並返回 key 的舊值(old value)。 | |
| 對 key 所儲存的字串值，獲取指定偏移量上的位(bit)。 | |
| 獲取所有(一個或多個)給定 key 的值。 | |
| 對 key 所儲存的字串值，設定或清除指定偏移量上的位(bit)。 | |
| 將值 value 關聯到 key ，並將 key 的過期時間設為 seconds (以秒為單位)。 | |
| 只有在 key 不存在時設定 key 的值。 | |
| 用 value 引數覆寫給定 key 所儲存的字串值，從偏移量 offset 開始。 | |
| 返回 key 所儲存的字串值的長度。 | |
| 同時設定一個或多個 key-value 對。 | |
| 同時設定一個或多個 key-value 對，當且僅當所有給定 key 都不存在。 | |
| 這個命令和 SETEX 命令相似，但它以毫秒為單位設定 key 的生存時間，而不是像 SETEX 命令那樣，以秒為單位。 | |
| 將 key 中儲存的數字值增一。 | |
| 將 key 所儲存的值加上給定的增量值（increment） 。 | |
| 將 key 所儲存的值加上給定的浮點增量值（increment） 。 | |
| 將 key 中儲存的數字值減一。 | |
| key 所儲存的值減去給定的減量值（decrement） 。 | |
| 如果 key 已經存在並且是一個字串， APPEND 命令將 value 追加到 key 原來的值的末尾。 |
Python操作redis系列以 雜湊(Hash)命令詳解（四）
# -*- coding: utf-8 -*-
import redis
#這個redis不能用，請根據自己的需要修改
r =redis.Redis(host="123.56.74.190",port=6379,password="66666666666")1. Hset 命令用於為雜湊表中的欄位賦值 。如果雜湊表不存在，一個新的雜湊表被建立並進行 HSET 操作。如果欄位已經存在於雜湊表中，舊值將被覆蓋。
如果欄位是雜湊表中的一個新建欄位，並且值設定成功，返回 1 。 如果雜湊表中域欄位已經存在且舊值已被新值覆蓋，返回 0 。print r.hset(name="name",key="key1",value="value") #返回的結果是 1
print r.hget(name="name",key="key1") #返回的結果是 value
print r.hset(name="name",key="key1",value="hello world") #返回的結果是 0,原因是雜湊表中域欄位已經存在且舊值已被新值覆蓋
print r.hget(name="name",key="key1") #返回的結果是 hello world2.Hdel 命令用於刪除雜湊表 key 中的一個或多個指定欄位，不存在的欄位將被忽略。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.delete(1) # 刪除成功後 返回的結果是 1
print r.delete(1) # 因為上一步已經刪除，刪除失敗後 返回的結果是 03. Hexists 命令用於檢視雜湊表的指定欄位是否存在。如果雜湊表含有給定欄位，返回 True 。 如果雜湊表不含有給定欄位，或 key 不存在，返回False 。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hexists(name="1",key="1") # 返回的結果是 True
print r.hexists(name="1",key="2") # 返回的結果是 False
print r.hexists(name="2",key="2") # 返回的結果是 False
print r.hexists(name="2",key="1") # 返回的結果是 False4.Hget 命令用於返回雜湊表中指定欄位的值。返回給定欄位的值。如果給定的欄位或 key 不存在時，返回 None 。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hget("1","1") # 返回的結果是 1
print r.hget("2","1") # 因為欄位2不存在。所以返回的結果是 None
print r.hget("1","2") # 因為key 2 不存在。所以返回的結果是 None
print r.hget("2","2") # 因為key和欄位都不存在，所以返回的結果是 None5. Hgetall 命令用於返回雜湊表中，所有的欄位和值。在返回值裡，緊跟每個欄位名(field name)之後是欄位的值(value)，所以返回值的長度是雜湊表大小的兩倍。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hset(name="1", key="3", value="2") # 返回的結果是 1
print r.hset(name="1", key="2", value="3") # 返回的結果是 1
print r.hset(name="1", key="2", value="4") # 返回的結果是 0 如果不知道為什麼返回的結果是0，請看hset
print r.hgetall("1") # 返回的結果是 {'1': '1', '3': '2', '2': '4'} 主意返回的資料格式
print r.hgetall("2") # 因為字典名2 不存在，所以返回的結果是 {}
在資料庫中儲存的資料格式
6. Hincrby 命令用於為雜湊表中的欄位值加上指定增量值。
增量也可以為負數，相當於對指定欄位進行減法操作。
如果雜湊表的 key 不存在，一個新的雜湊表被建立並執行 HINCRBY 命令。
如果指定的欄位不存在，那麼在執行命令前，欄位的值被初始化為 0 。
對一個儲存字串值的欄位執行 HINCRBY 命令將造成一個錯誤。
print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hincrby(name="1",key="1",amount=2) # 返回的結果是 3
print r.hget(name="1",key="1") # 返回的結果是 3
print r.hincrby(name="2", key="2", value="3") # 欄位不存在，返回的結果是 TypeError: hincrby() got an unexpected keyword argument 'value'
print r.hincrby(name="1",key="2",amount=4) # 這步是因為key為2不存在，返回的結果是 4，說明雜湊表的 key 不存在，一個新的雜湊表被建立並執行 HINCRBY 命令
print r.hget(name="1",key="2") # 返回的結果是 4
7. Hincrbyfloat 命令用於為雜湊表中的欄位值加上指定浮點數增量值。如果指定的欄位不存在，那麼在執行命令前，欄位的值被初始化為 0 。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hincrbyfloat(name="1",key="1",amount="1.2") # 返回的結果是 2.2
print r.hget("1","1") # 返回的結果是 2.2
print r.hincrbyfloat(name="2",key="1",amount="1.2") # 指定的欄位2不存在，返回的結果是 1.2，說明如果指定的欄位不存在，那麼在執行命令前，欄位的值被初始化為 0 8.Hkeys 命令用於獲取雜湊表中的所有欄位名。包含雜湊表中所有欄位的列表。 當 key 不存在時，返回一個空列表。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hset(name="1", key="1", value="2") # 返回的結果是 0
print r.hset(name="1", key="2", value="2") # 返回的結果是 1
print r.hset(name="1", key="3", value="2") # 返回的結果是 1
print r.hkeys(1) # 返回的結果是 ['1', '2', '3']
print r.hkeys(2) # 因為指定的欄位名不存在，所以返回的結果是 []9. Hlen 命令用於獲取雜湊表中欄位的數量。雜湊表中欄位的數量。 當 key 不存在時，返回 0 。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hset(name="1", key="2", value="2") # 返回的結果是 1
print r.hlen(1) # 返回的結果是 2
print r.hset(name="1", key="4", value="3") # 返回的結果是 1
print r.hset(name="1", key="3", value="2") # 返回的結果是 1
print r.hlen(1) # 返回的結果是 410. Hmget 命令用於返回雜湊表中，一個或多個給定欄位的值。如果指定的欄位不存在於雜湊表，那麼返回一個 nil 值。
一個包含多個給定欄位關聯值的表，表值的排列順序和指定欄位的請求順序一樣。print r.hset(name="1", key="1", value="1") # 返回的結果是 1
print r.hset(name="1", key="2", value="2") # 返回的結果是 1
print r.hmget(name="1",keys="1") # 返回的結果是 ['1']
print r.hmget(name="1",keys="2") # 返回的結果是['2']
print r.hmget(name="2",keys="1") # 返回的結果是 [None]11. Hmset 命令用於同時將多個 field-value (欄位-值)對設定到雜湊表中。
此命令會覆蓋雜湊表中已存在的欄位。
如果雜湊表不存在，會建立一個空雜湊表，並執行 HMSET 操作。aa = {"a":"a","b":"b"} # 返回的結果是 ['1']
print r.hmset("name",aa) # 返回的結果是 True
print r.hget(name="name",key="a") # 返回的結果是 a
print r.hget(name="name",key="b") # 返回的結果是 b12. Hsetnx 命令用於為雜湊表中不存在的的欄位賦值 。
如果雜湊表不存在，一個新的雜湊表被建立並進行 HSET 操作。
如果欄位已經存在於雜湊表中，操作無效。
如果 key 不存在，一個新雜湊表被建立並執行 HSETNX 命令。
設定成功，返回 1 。 如果給定欄位已經存在且沒有操作被執行，返回 0 。print r.hsetnx(name="1",key="1",value="1") # 返回的結果是 1
print r.hsetnx(name="1",key="1",value="2") # 返回的結果是 0
print r.hsetnx(name="2",key="1",value="2") # 返回的結果是 013 Hvals 命令返回雜湊表所有欄位的值。一個包含雜湊表中所有值的表。 當 key 不存在時，返回一個空表。print r.hset(name="1", key="1", value="11") # 返回的結果是 1
print r.hset(name="1", key="2", value="22") # 返回的結果是 1
print r.hset(name="1", key="3", value="33") # 返回的結果是 1
print r.hset(name="1", key="4", value="44") # 返回的結果是 1
print r.hvals("1") # 返回的結果是 ['11', '22', '33', '44']
print r.hvals("2") # 返回的結果是 []附錄：
| 命令 | 描述 |
|---|---|
| Redis Hdel 命令 | 刪除一個或多個雜湊表字段 |
| Redis Hexists 命令 | 檢視雜湊表 key 中，指定的欄位是否存在。 |
| Redis Hget 命令 | 獲取儲存在雜湊表中指定欄位的值/td> |
| Redis Hgetall 命令 | 獲取在雜湊表中指定 key 的所有欄位和值 |
| Redis Hincrby 命令 | 為雜湊表 key 中的指定欄位的整數值加上增量 increment 。 |
| Redis Hincrbyfloat 命令 | 為雜湊表 key 中的指定欄位的浮點數值加上增量 increment 。 |
| Redis Hkeys 命令 | 獲取所有雜湊表中的欄位 |
| Redis Hlen 命令 | 獲取雜湊表中欄位的數量 |
| Redis Hmget 命令 | 獲取所有給定欄位的值 |
| Redis Hmset 命令 | 同時將多個 field-value (域-值)對設定到雜湊表 key 中。 |
| Redis Hset 命令 | 將雜湊表 key 中的欄位 field 的值設為 value 。 |
| Redis Hsetnx 命令 | 只有在欄位 field 不存在時，設定雜湊表字段的值。 |
| Redis Hvals 命令 | 獲取雜湊表中所有值 |
Python操作redis系列之 列表（list） (五)
# -*- coding: utf-8 -*-
import redis
r =redis.Redis(host="123.156.74.190",port=6379,password="66666666666")1. Lpush 命令將一個或多個值插入到列表頭部。 如果 key 不存在，一個空列表會被建立並執行 LPUSH 操作。 當 key 存在但不是列表型別時，返回一個錯誤。
執行 LPUSH 命令後，列表的長度。
print r.lpush("1",1) #輸出的結果是1
print r.lpush("1",1) #輸出的結果是2
print r.lpush("1",2,3,4) #輸出的結果是5
print r.set("2",1) #輸出的結果是 True
print r.lpush("2",2) #輸出的結果是 redis.exceptions.ResponseError: WRONGTYPE Operation against a key holding the wrong kind of value,原因是鍵 2 是字串型別，我們用list中的lpush給他新增元素
2. Rpush 命令用於將一個或多個值插入到列表的尾部(最右邊)。
如果列表不存在，一個空列表會被建立並執行 RPUSH 操作。 當列表存在但不是列表型別時，返回一個錯誤。
執行 RPUSH 操作後，列表的長度。print r.rpush("2",1) #輸出的結果是1
print r.rpush("2",2,3) #輸出的結果是3
print r.rpush("2",4,5) #輸出的結果是5資料格式：
3.Blpop 命令移出並獲取列表的第一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。
如果列表為空，返回一個 None 。 否則，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的 key ，第二個元素是被彈出元素的值。print r.rpush("3",1,2,3,4,5,6,) #輸出的結果是6
print r.blpop("3") #輸出的結果是('3', '1')
print r.blpop("3") #輸出的結果是('3', '2')
print r.blpop("3") #輸出的結果是('3', '3')
print r.blpop("4",timeout=2) #因為鍵 4 不存在，所以2秒後輸出的結果是None4.Brpop 命令移出並獲取列表的最後一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。
假如在指定時間內沒有任何元素被彈出，則返回一個None 和等待時長。 反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素所屬的 key ，第二個元素是被彈出元素的值。print r.rpush("4",1,2,3,4,5,6,) #輸出的結果是6
print r.brpop("4") #輸出的結果是('4', '6')
print r.brpop("4") #輸出的結果是('4', '5')
print r.brpop("4") #輸出的結果是('4', '4')
print r.brpop("5",timeout=2) #因為鍵 4 不存在，所以2秒後輸出的結果是None5. Brpoplpush 命令從列表中彈出一個值，將彈出的元素插入到另外一個列表中並返回它； 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。
假如在指定時間內沒有任何元素被彈出，則返回一個 None 和等待時長。 反之，返回一個含有兩個元素的列表，第一個元素是被彈出元素的值，第二個元素是等待時長。print r.rpush("11",1,2,3) #輸出的結果是3
print r.rpush("22",4,5,6,) #輸出的結果是3
print r.brpoplpush(src="11",dst="22",timeout=2) #輸出的結果是3
print r.brpoplpush(src="44",dst="22",timeout=2) #鍵44 不存在，輸出的結果是None| 鍵 11 的值：
| 鍵22 的值：
|
6. Lindex 命令用於通過索引獲取列表中的元素。你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。
列表中下標為指定索引值的元素。 如果指定索引值不在列表的區間範圍內，返回 None 。
print r.rpush("6",1,2,3) #輸出的結果是3
print r.lindex("6",1) #輸出的結果是2
print r.lindex("6",2) #輸出的結果是3
print r.lindex("6",3) #輸出的結果是None
print r.lindex("6",4) #輸出的結果是None
print r.lindex("6",-1) #輸出的結果是37. Linsert 命令用於在列表的元素前或者後插入元素。
當指定元素不存在於列表中時，不執行任何操作。 當列表不存在時，被視為空列表，不執行任何操作。 如果 key 不是列表型別，返回一個錯誤。
如果命令執行成功，返回插入操作完成之後，列表的長度。 如果沒有找到指定元素 ，返回 -1 。 如果 key 不存在或為空列表，返回 0 。
print r.rpush("7",1) #輸出的結果是1
print r.rpush("7",2) #輸出的結果是2
print r.linsert("7","BEFORE","2",12) #輸出的結果是2插入後的結果是：
8. Llen 命令用於返回列表的長度。 如果列表 key 不存在，則 key 被解釋為一個空列表，返回 0 。 如果 key 不是列表型別，返回一個錯誤。print r.llen("8") #key 不存在，輸出的結果是0
print r.rpush("8",1) #輸出的結果是1
print r.llen("8") #輸出的結果是1
print r.rpush("8",2,3) #輸出的結果是3
print r.llen("8") #輸出的結果是39. Lpop 命令用於移除並返回列表的第一個元素。
列表的第一個元素。 當列表 key 不存在時，返回 None 。print r.lpop("9") #輸出的結果是None
print r.rpush("9",1) #輸出的結果是1
print r.rpush("9",2) #輸出的結果是2
print r.lpop("9") #輸出的結果是1說明：被移除掉的是第一個值 1, 值2沒有被移除
10.Lpushx 將一個或多個值插入到已存在的列表頭部，列表不存在時操作無效。print r.rpush("10",1) #輸出的結果是1
print r.rpushx("10",2) #輸出的結果是2
print r.rpushx("10",3) #輸出的結果是3
print r.rpushx("11",3) #輸出的結果是5
print r.lrange("10",0,-1) #輸出的結果是['1', '2', '3']
print r.lrange("11",0,-1) #輸出的結果是['1', '2', '1', '2', '3']11.Lrange 返回列表中指定區間內的元素，區間以偏移量 START 和 END 指定。 其中 0 表示列表的第一個元素， 1 表示列表的第二個元素，以此類推。
你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。print r.rpush("11",1,2) #輸出的結果是2
print r.rpush("11",3,4) #輸出的結果是4
print r.lrange("11",0,-1) #輸出的結果是['1', '2', '3', '4']
print r.lrange("11",1,2) #輸出的結果是['2', '3']12.Lrem 根據引數 COUNT 的值，移除列表中與引數 VALUE 相等的元素。
COUNT 的值可以是以下幾種：
count > 0 : 從表頭開始向表尾搜尋，移除與 VALUE 相等的元素，數量為 COUNT 。
count < 0 : 從表尾開始向表頭搜尋，移除與 VALUE 相等的元素，數量為 COUNT 的絕對值。
count = 0 : 移除表中所有與 VALUE 相等的值。
被移除元素的數量。 列表不存在時返回 0 。print r.rpush("12", 1) # 輸出的結果是1
print r.rpush("12", 1) # 輸出的結果是2
print r.rpush("12", 2) # 輸出的結果是3
print r.rpush("12", 1) # 輸出的結果是4
print r.lrem("12",1,-2) # 輸出的結果是2
print r.lrange("12",0,-1) # 輸出的結果是['1', '2']13. Lset 通過索引來設定元素的值。
當索引引數超出範圍，或對一個空列表進行 LSET 時，返回一個錯誤
操作成功返回 True ，否則返回錯誤資訊。print r.rpush("13",1,2,3,4) # 輸出的結果是4
print r.lset("13",1,5) # 輸出的結果是True
print r.lrange("13",0,-1) # 輸出的結果是['1', '5', '3', '4']14. Ltrim 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間之內的元素都將被刪除。
下標 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。
你也可以使用負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。print r.rpush("14",1,2,3,4) # 輸出的結果是4
print r.ltrim("14",1,-2) # 輸出的結果是True
print r.lrange("14",0,-1) # 輸出的結果是['2', '3']15. Rpop 命令用於移除並返回列表的最後一個元素。
列表的最後一個元素。 當列表不存在時，返回 None 。print r.rpush("15",1,2,3,4) # 輸出的結果是4
print r.rpop("15") # 輸出的結果是4
print r.lrange("15",0,-1) # 輸出的結果是['1', '2', '3']16.Rpoplpush 命令用於移除列表的最後一個元素，並將該元素新增到另一個列表並返回。print r.rpush("16",1,2,3,4) # 輸出的結果是4
print r.rpush("17",1,2,3,4) # 輸出的結果是4
print r.rpoplpush("16","17") # 輸出的結果是4
print r.lrange("16",0,-1) # 輸出的結果是['1', '2', '3']
print r.lrange("17",0,-1) # 輸出的結果是['4', '1', '2', '3', '4']17.Rpushx 命令用於將一個或多個值插入到已存在的列表尾部(最右邊)。如果列表不存在，操作無效。print r.rpushx("18",1) # 因為鍵18 不存在，所以插入失敗，輸出的結果是0
print r.rpush("18",2) # 輸出的結果是1
print r.rpushx("18",3) # 輸出的結果是2
print r.lrange("18",0,-1) # 輸出的結果是['2', '3']
附錄：redis命令| 命令 | 描述 |
|---|---|
| Redis Blpop 命令 | 移出並獲取列表的第一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。 |
| Redis Brpop 命令 | 移出並獲取列表的最後一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。 |
| Redis Brpoplpush 命令 | 從列表中彈出一個值，將彈出的元素插入到另外一個列表中並返回它； 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止。 |
| Redis Lindex 命令 | 通過索引獲取列表中的元素 |
| Redis Linsert 命令 | 在列表的元素前或者後插入元素 |
| Redis Llen 命令 | 獲取列表長度 |
| Redis Lpop 命令 | 移出並獲取列表的第一個元素 |
| Redis Lpush 命令 | 將一個或多個值插入到列表頭部 |
| Redis Lpushx 命令 | 將一個或多個值插入到已存在的列表頭部 |
| Redis Lrange 命令 | 獲取列表指定範圍內的元素 |
| Redis Lrem 命令 | 移除列表元素 |
| Redis Lset 命令 | 通過索引設定列表元素的值 |
| Redis Ltrim 命令 | 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間之內的元素都將被刪除。 |
| Redis Rpop 命令 | 移除並獲取列表最後一個元素 |
| Redis Rpoplpush 命令 | 移除列表的最後一個元素，並將該元素新增到另一個列表並返回 |
| Redis Rpush 命令 | 在列表中新增一個或多個值 |
| Redis Rpushx 命令 | 為已存在的列表新增值 |
Python操作redis學習系列之（集合）set，redis set詳解 （六）
# -*- coding: utf-8 -*-
import redis
r = redis.Redis(host="126.56.74.190",port=639,password="66666666")1. Sadd 命令將一個或多個成員元素加入到集合中，已經存在於集合的成員元素將被忽略。
假如集合 key 不存在，則建立一個只包含新增的元素作成員的集合。當集合 key 不是集合型別時，返回一個錯誤。print r.sadd("1",1) #輸出的結果是1
print r.sadd("1",2) #輸出的結果是1
print r.sadd("1",2) #因為2已經存在，不能再次田間，所以輸出的結果是0
print r.sadd("1",3,4) #輸出的結果是2
print r.sinter("1") #輸出的結果是set(['1', '3', '2', '4'])2.Scard 命令返回集合中元素的數量。集合的數量。 當集合 key 不存在時，返回 0 。print r.sadd("2",1) #輸出的結果是1
print r.sadd("2",2,3,4,5) #輸出的結果是1
print r.scard("2") #輸出的結果是53.Sdiff 命令返回給定集合之間的差集。不存在的集合 key 將視為空集。print r.sadd("31",1,2,3,4,5,6) #輸出的結果是6
print r.sadd("32",4,5,6,7,8,9) #輸出的結果是6
print r.sdiff(31,32) #輸出的結果是set(['1', '3', '2'])
print r.sdiff(32,31) #輸出的結果是set(['9', '8', '7'])
print r.sdiff(31,31) #輸出的結果是set([])4.Sdiffstore 命令將給定集合之間的差集儲存在指定的集合中。如果指定的集合 key 已存在，則會被覆蓋。print r.sadd("41",1,2,3,4,5,6) #輸出的結果是6
print r.sadd("42",4,5,6,7,8,9) #輸出的結果是6
print r.sadd("43",0) #輸出的結果是1
print r.sdiffstore("43","41","42") #輸出的結果是3
print r.sinter("43") #輸出的結果是 set(['1', '3', '2'])5.Sinter 命令返回給定所有給定集合的交集。 不存在的集合 key 被視為空集。 當給定集合當中有一個空集時，結果也為空集(根據集合運算定律)。
print r.sadd("51",3,4,5,6) #輸出的結果是4
print r.sadd("52",1,2,3,4) #輸出的結果是4
print r.sinter(51,52) #輸出的結果是set(['3', '4'])
print r.sadd("53",1,2,3,4,5,6) #輸出的結果是6
print r.sadd("54",3,4,5,6,7,8,9)#輸出的結果是7
print r.sinter(53,54) #輸出的結果是set(['3', '5', '4', '6'])
print r.sinter(53,56) #輸出的結果是set([])
6.Sinterstore 命令將給定集合之間的交集儲存在指定的集合中。如果指定的集合已經存在，則將其覆蓋。print r.sadd("61",3,4,5,6) #輸出的結果是4
print r.sadd("62",1,2,3,4) #輸出的結果是4
print r.sadd("63",0) #輸出的結果是1
print r.sinterstore(63,61,62) #輸出的結果是2
print r.sinter(63) #輸出的結果是set(['3', '4'])7.Sismember 命令判斷成員元素是否是集合的成員。
如果成員元素是集合的成員，返回 1 。 如果成員元素不是集合的成員，或 key 不存在，返回 0 。print r.sadd("71",1,2,3,4,5,6) #輸出的結果是6
print r.sismember("71",1) #輸出的結果是True
print r.sismember("71",2) #輸出的結果是True
print r.sismember("71",7) #輸出的結果是False
print r.sismember("71",8) #輸出的結果是False8.Smembers 命令返回集合中的所有的成員。 不存在的集合 key 被視為空集合。print r.sadd("81",1,2,3,4,5,6) #輸出的結果是6
print r.smembers(81) #輸出的結果是set(['1', '3', '2', '5', '4', '6'])
print r.smembers(82) #輸出的結果是set([])9.Smove 命令將指定成員 member 元素從 source 集合移動到 destination 集合。
SMOVE 是原子性操作。
如果 source 集合不存在或不包含指定的 member 元素，則 SMOVE 命令不執行任何操作，僅返回 False 。否則， member 元素從 source 集合中被移除，並新增到 destination 集合中去。
當 destination 集合已經包含 member 元素時， SMOVE 命令只是簡單地將 source 集合中的 member 元素刪除。
當 source 或 destination 不是集合型別時，返回一個錯誤。
如果成員元素被成功移除，返回 True。 如果成員元素不是 source 集合的成員，並且沒有任何操作對 destination 集合執行，那麼返回 False
print r.sadd("91",1,2,) #輸出的結果是2
print r.sadd("92",3,4,) #輸出的結果是2
print r.smove(91,92,1) #把91中的1移動到92中去，輸出的結果是True
print r.smembers("91") #輸出的結果是set(['2'])
print r.smembers("92") #輸出的結果是set(['1', '3', '4'])
print r.smove(91,92,5) #91不存在5，輸出的結果是False
print r.smembers("91") #輸出的結果是set(['2'])
print r.smembers("92") #輸出的結果是set(['1', '3', '4'])
10. Spop 命令用於移除並返回集合中的一個隨機元素。print r.sadd("10",1,2,3,4,5,6) #輸出的結果是6
print r.spop("10") #輸出的結果是3
print r.smembers("10") #輸出的結果是set(['1', '2', '5', '4', '6'])
print r.spop("10") #輸出的結果是1
print r.smembers("10") #輸出的結果是set(['2', '5', '4', '6'])11.Srandmember 命令用於返回集合中的一個隨機元素。從 Redis 2.6 版本開始， Srandmember 命令接受可選的 count 引數：
如果 count 為正數，且小於集合基數，那麼命令返回一個包含 count 個元素的陣列，陣列中的元素各不相同。如果 count 大於等於集合基數，那麼返回整個集合。
如果 count 為負數，那麼命令返回一個數組，陣列中的元素可能會重複出現多次，而陣列的長度為 count 的絕對值。
該操作和 SPOP 相似，但 SPOP 將隨機元素從集合中移除並返回，而 Srandmember 則僅僅返回隨機元素，而不對集合進行任何改動。print r.sadd("11",1,2,3,4,5,6) #輸出的結果是6
print r.srandmember(11) #輸出的結果是4
print r.smembers(11) #輸出的結果是set(['1', '3', '2', '5', '4', '6'])
print r.srandmember(11,3) #輸出的結果是['6', '3', '1']
print r.smembers(11) #輸出的結果是set(['1', '3', '2', '5', '4', '6'])12. Srem 命令用於移除集合中的一個或多個成員元素，不存在的成員元素會被忽略。
當 key 不是集合型別，返回一個錯誤。
被成功移除的元素的數量，不包括被忽略的元素。print r.sadd("12",1,2,3,4,5,6,7) #輸出的結果是7
print r.srem("12",1) #輸出的結果是1
print r.smembers("12") #輸出的結果是set(['3', '2', '5', '4', '7', '6'])
print r.srem("12",8) #輸出的結果是0
print r.smembers("12") #輸出的結果是set(['3', '2', '5', '4', '7', '6']) 13.Sunion 命令返回給定集合的並集。不存在的集合 key 被視為空集。print r.sadd("131",1,2,3,4,5,6,7) #輸出的結果是7
print r.sadd("132",0,1,2,7,8,9) #輸出的結果是6
print r.sunion(131,132) #輸出的結果是set(['1', '0', '3', '2', '5', '4', '7', '6', '9', '8'])
print r.sunion(131,134) #輸出的結果是set(['1', '3', '2', '5', '4', '7', '6']) 14.Sunionstore 命令將給定集合的並集儲存在指定的集合 destination 中。print r.sadd("141",1,2,3,4,5,6,7) #輸出的結果是7
print r.sadd("142",0,1,2,3,4) #輸出的結果是5
print r.sunionstore(143,141,142) #輸出的結果是8
print r.smembers(143) #輸出的結果是set(['1', '0', '3', '2', '5', '4', '7', '6']) 15.Sscan 命令用於迭代集合鍵中的元素。print r.sadd("151",1,2,3,4,5,6,7) #輸出的結果是7
print r.sscan(151,cursor=2,match=1,count=1) #輸出的結果是 (0L, ['1'])附錄： 字串命令 Redis 集合(Set) 命令
| 命令 | 描述 |
|---|---|
| Redis Sadd 命令 | 向集合新增一個或多個成員 |
| Redis Scard 命令 | 獲取集合的成員數 |
| Redis Sdiff 命令 | 返回給定所有集合的差集 |
| Redis Sdiffstore 命令 | 返回給定所有集合的差集並存儲在 destination 中 |
| Redis Sinter 命令 | 返回給定所有集合的交集 |
| Redis Sinterstore 命令 | 返回給定所有集合的交集並存儲在 destination 中 |
| Redis Sismember 命令 | 判斷 member 元素是否是集合 key 的成員 |
| Redis Smembers 命令 | 返回集合中的所有成員 |
| Redis Smove 命令 | 將 member 元素從 source 集合移動到 destination 集合 |
| Redis Spop 命令 | 移除並返回集合中的一個隨機元素 |
| Redis Srandmember 命令 | 返回集合中一個或多個隨機數 |
| Redis Srem 命令 | 移除集合中一個或多個成員 |
| Redis Sunion 命令 | 返回所有給定集合的並集 |
| Redis Sunionstore 命令 | 所有給定集合的並集儲存在 destination 集合中 |
| Redis Sscan 命令 | 迭代集合中的元素 |
python 操作redis之——有序集合(sorted set) （七）
#coding:utf8
import redis
r =redis.Redis(host="23.226.74.190",port=63279,password="66666666666")1.Zadd 命令用於將一個或多個成員元素及其分數值加入到有序集當中。
如果某個成員已經是有序集的成員，那麼更新這個成員的分數值，並通過重新插入這個成員元素，來保證該成員在正確的位置上。
分數值可以是整數值或雙精度浮點數。
如果有序集合 key 不存在，則建立一個空的有序集並執行 ZADD 操作。
當 key 存在但不是有序集型別時，返回一個錯誤。| 1 2 3 4 5 |
|
2.Zcard 命令用於計算集合中元素的數量。
當 key 存在且是有序集型別時，返回有序集的基數。 當 key 不存在時，返回 0 。print r.zadd("1","1",1,"3",3) #輸出的結果是2
print r.zadd("1","2",2) #輸出的結果是1
print r.zadd("1","2",4) #輸出的結果是1
print r.zcard(1) #輸出的結果是3
print r.zcard(2) #輸出的結果是03.Zcount 命令用於計算有序集合中指定分數區間的成員數量。分數值在 min 和 max 之間的成員的數量。print r.zadd("2","1",1,"3",3) #輸出的結果是2
print r.zadd("2","2",2) #輸出的結果是1
print r.zadd("2","1",4) #輸出的結果是0
print r.zcount("2",min=0,max=5) #輸出的結果是3
print r.zcount("2",min=0,max=3) #輸出的結果是2
print r.zcount("2",min=1,max=3) #輸出的結果是24.Zincrby 命令對有序集合中指定成員的分數加上增量 increment
可以通過傳遞一個負數值 increment ，讓分數減去相應的值，比如 ZINCRBY key -5 member ，就是讓 member 的 score 值減去 5 。
當 key 不存在，或分數不是 key 的成員時， ZINCRBY key increment member 等同於 ZADD key increment member 。
當 key 不是有序集型別時，返回一個錯誤。
分數值可以是整數值或雙精度浮點數。
member 成員的新分數值，以字串形式表示。print r.zadd("4","1",1,"2",2,"3",3,"4",4) #輸出的結果是4
print r.zincrby(name=4,value=1,amount=5) #輸出的結果是6.0
print r.zincrby(name=4,value=2,amount=55) #輸出的結果是57.0
print r.zrange(name=4,start=0,end=-1,withscores=False) #輸出的結果是['1', '3', '2', '4']5.Zinterstore 命令計算給定的一個或多個有序集的交集，其中給定 key 的數量必須以 numkeys 引數指定，並將該交集(結果集)儲存到 destination 。
預設情況下，結果集中某個成員的分數值是所有給定集下該成員分數值之和。print r.zadd("41", "a1", 6, "a2", 2,"a3",5) #輸出的結果是3
print r.zadd('42', a1=7,b1=10, b2=5) #輸出的結果是3
# 獲取兩個有序集合的交集並放入dest集合，如果遇到相同值不同分數，則按照aggregate進行操作
# aggregate的值為: SUM MIN MAX
print r.zinterstore("43",("42","41"),aggregate="MAX") #輸出的結果是4
print(r.zscan("43")) #輸出的結果是(0L, [('a1', 7.0)])6. Zlexcount 命令在計算有序集合中指定字典區間內成員數量。
print r.zadd("6", "a", 1, "b", 2,"c",3) #輸出的結果是3
print r.zlexcount(name=6,min="-",max="+") #輸出的結果是3
print r.zadd("6", "e", 4, "f", 5,"d",6) #輸出的結果是3
print r.zlexcount(name=6,min="-",max="+") #輸出的結果是6
print r.zlexcount(name=6,min="[a",max="[b") #輸出的結果是2
print r.zlexcount(name=6,min="[a",max="[f") #輸出的結果是6
print r.zlexcount(name=6,min="[a",max="[e") #輸出的結果是4
7.Zrange 返回有序集中，指定區間內的成員。
其中成員的位置按分數值遞增(從小到大)來排序。
具有相同分數值的成員按字典序(lexicographical order )來排列。
如果你需要成員按值遞減(從大到小)來排列，請使用 ZREVRANGE 命令。
下標引數 start 和 stop 都以 0 為底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。
你也可以使用負數下標，以 -1 表示最後一個成員， -2 表示倒數第二個成員，以此類推。print r.zadd("7", "1", 1, "2", 2,"3",3,"4",4,"5",5) #輸出的結果是5
print r.zrange("7",start=0,end=-1,desc=False) #輸出的結果是['1', '2', '3', '4', '5']
print r.zrange("7",start=0,end=2,desc=False) #輸出的結果是['1', '2', '3']8. Zrangebylex 通過字典區間返回有序集合的成員。
當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值 （lexicographical ordering）來進行排序，而這個命令則可以返回給定的有序集合鍵 key 中， 元素的值介於 min 和 max 之間的成員
對集合中的每個成員進行逐個位元組的對比（byte-by-byte compare）， 並按照從低到高的順序， 返回排序後的集合成員。 如果兩個字串有一部分內容是相同的話， 那麼命令會認為較長的字串比較短的字串要大print r.zadd("8", "a", 1, "b", 2,"c",3) #輸出的結果是3
print r.zrangebylex(name="8",min="-",max="[c") #輸出的結果是 ['a', 'b', 'c']
print r.zrangebylex(name="8",min="-",max="(c") #輸出的結果是 ['a', 'b']
print r.zadd("8", "e", 4, "f", 5,"d",6) #輸出的結果是3
print r.zrangebylex(name=8,min="[b",max="[f") #輸出的結果是 ['b', 'c', 'e', 'f', 'd']
print r.zrangebylex(name=8,min="(b",max="[f") #輸出的結果是 ['c', 'e', 'f', 'd']9.Zrangebyscore 返回有序集合中指定分數區間的成員列表。有序整合員按分數值遞增(從小到大)次序排列。
具有相同分數值的成員按字典序來排列(該屬性是有序集提供的，不需要額外的計算)。
預設情況下，區間的取值使用閉區間 (小於等於或大於等於)，你也可以通過給引數前增加 ( 符號來使用可選的開區間 (小於或大於)。print r.zadd("9", "a", 1, "b", 2,"c",3) #輸出的結果是3
print r.zrangebyscore("9","1","6") #輸出的結果是['a', 'b', 'c']
print r.zadd("9", "c", 11, "d", 21,"e",32) #輸出的結果是3
print r.zrangebyscore("9","3","16") #輸出的結果是['c']
print r.zrangebyscore("9","3","36") #輸出的結果是['c', 'd', 'e']10.Zrank 返回有序集中指定成員的排名。其中有序整合員按分數值遞增(從小到大)順序排列。
如果成員是有序集 key 的成員，返回 member 的排名。 如果成員不是有序集 key 的成員，返回 None 。
print r.zadd("10", "a", 1, "b", 2, "c", 3) # 輸出的結果是3
print r.zadd("10", "f", 11, "d", 21,"e",32) #輸出的結果是3
print r.zrank("10","a") #輸出的結果是0
print r.zrank("10","b") #輸出的結果是1
print r.zrank("10","e") #輸出的結果是5
print r.zrank("10","d") #輸出的結果是4
print r.zrank("10","h") #輸出的結果是None
11. Zrem 命令用於移除有序集中的一個或多個成員，不存在的成員將被忽略。
當 key 存在但不是有序集型別時，返回一個錯誤。
print r.zadd("11", "a", 1, "b", 2, "c", 3) # 輸出的結果是3
print r.zadd("11", "f", 11, "d", 21,"e",32) #輸出的結果是3
print r.zrem("11","a") #輸出的結果是1
print r.zrem("11","f") #輸出的結果是1
print r.zrem("11","h") #輸出的結果是0
print r.zrange("11",start=0,end=32) #輸出的結果是['b', 'c', 'd', 'e'], 其中 a f 已經移除掉
print r.zrange("11",start=2,end=32) #輸出的結果是['d', 'e'], 其中 a f 已經移除掉，d e 沒有被包涵
12.Zremrangebylex 命令用於移除有序集合中給定的字典區間的所有成員。
被成功移除的成員的數量，不包括被忽略的成員。print r.zadd("12", "a", 1, "b", 2, "c", 3) # 輸出的結果是3
print r.zadd("12", "d", 11, "e", 21,"f",32) #輸出的結果是3
print r.zremrangebylex("12",min="[a",max="[c") #輸出的結果是3
print r.zrange("12",0,-1) #輸出的結果是 ['d', 'e', 'f'] 因為 a，b，c已經被移除13. Zremrangebyrank 命令用於移除有序集中，指定排名(rank)區間內的所有成員。# print r.zadd("13", "a", 1, "b", 2, "c", 3) # 輸出的結果是3
# print r.zadd("13", "d", 8, "e", 21,"f",32) #輸出的結果是3
# print r.zremrangebyrank(name=13,min=1,max=3) #輸出的結果是3
# print r.zrange("13","0","-1") #輸出的結果是['a', 'e', 'f'] 因為刪除了 b，c，d14.Zremrangebyscore 命令用於移除有序集中，指定分數（score）區間內的所有成員。print r.zadd("14", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zadd("14", "d", 8, "e", 21,"f",32) #輸出的結果是3
print r.zremrangebyscore(name="14",min="1",max="8") #輸出的結果是4,刪除的a，b，c，d
print r.zrange(name="14",start=0,end=-1) #輸出的結果是 ['e', 'f']15.Zrevrange 命令返回有序集中，指定區間內的成員。
其中成員的位置按分數值遞減(從大到小)來排列。
具有相同分數值的成員按字典序的逆序(reverse lexicographical order)排列。
除了成員按分數值遞減的次序排列這一點外， ZREVRANGE 命令的其他方面和 ZRANGE 命令一樣。print r.zadd("15", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zadd("15", "d", 8, "e", 21,"f",32) #輸出的結果是3
print r.zrevrange(name="15",start=0,end=-1) #輸出的結果是['f', 'e', 'd', 'c', 'b', 'a']
print r.zrevrange(name="15",start=1,end=21) #輸出的結果是['e', 'd', 'c', 'b', 'a']
print r.zrevrange(name="15",start=3,end=21) #輸出的結果是['c', 'b', 'a']16.Zrevrangebyscore 返回有序集中指定分數區間內的所有的成員。有序整合員按分數值遞減(從大到小)的次序排列。
具有相同分數值的成員按字典序的逆序(reverse lexicographical order )排列。
除了成員按分數值遞減的次序排列這一點外， ZREVRANGEBYSCORE 命令的其他方面和 ZRANGEBYSCORE 命令一樣。print r.zadd("16", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zadd("16", "d", 8, "e", 21,"f",32) #輸出的結果是3
print r.zrevrangebyscore(name="16",max=33,min=0) #輸出的結果是['f', 'e', 'd', 'c', 'b', 'a']
print r.zrevrangebyscore(name="16",max=20,min=2) #輸出的結果是['d', 'c', 'b']17. Zrevrank 命令返回有序集中成員的排名。其中有序整合員按分數值遞減(從大到小)排序。
排名以 0 為底，也就是說， 分數值最大的成員排名為 0 。
使用 ZRANK 命令可以獲得成員按分數值遞增(從小到大)排列的排名。print r.zadd("17", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zadd("17", "d", 4, "e", 5,"f",6) #輸出的結果是3
print r.zrevrank(name=17,value="a") #輸出的結果是5
print r.zrevrank(name=17,value="c") #輸出的結果是3
print r.zrevrank(name=17,value="d") #輸出的結果是2
print r.zrevrank(name=17,value="h") #輸出的結果是None18.Zscore 命令返回有序集中，成員的分數值。 如果成員元素不是有序集 key 的成員，或 key 不存在，返回 None 。print r.zadd("18", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zadd("18", "d", 4, "e", 5,"f",6) #輸出的結果是3
print r.zscore(name="18",value="a") #輸出的結果是1.0
print r.zscore(name="18",value="c") #輸出的結果是3.0
print r.zscore(name="18",value="f") #輸出的結果是6.0
print r.zscore(name="18",value="h") #輸出的結果是None19.Zunionstore 命令計算給定的一個或多個有序集的並集，其中給定 key 的數量必須以 numkeys 引數指定，並將該並集(結果集)儲存到 destination 。
預設情況下，結果集中某個成員的分數值是所有給定集下該成員分數值之和 。
儲存到 destination 的結果集的成員數量。
20. Zscan 命令用於迭代有序集合中的元素（包括元素成員和元素分值）
返回的每個元素都是一個有序集合元素，一個有序集合元素由一個成員（member）和一個分值（score）組成。print r.zadd("20", "a", 1, "b", 2, "c", 3) #輸出的結果是3
print r.zscan(name="20") #輸出的結果是(0L, [('a', 1.0), ('b', 2.0), ('c', 3.0)])
print r.zadd("20", "d", 4, "e", 5,"f",3) #輸出的結果是3
print r.zscan(name="20") #輸出的結果是 (0L, [('a', 1.0), ('b', 2.0), ('c', 3.0), ('f', 3.0), ('d', 4.0), ('e', 5.0)])python 操作redis之——HyperLogLog （八）
#coding:utf8
import redis
# python 操作redis之——HyperLogLog
r =redis.Redis(host="33.23.724.12190",port=6222,password="666666")
# 1.Pfadd 命令將所有元素引數新增到 HyperLogLog 資料結構中。
print r.pfadd("1","1","2") #輸出結果是1
print r.pfadd("1","3","4") #輸出結果是1
print r.pfadd("1","4","5") #輸出結果是1
# 2. Pfcount 命令返回給定 HyperLogLog 的基數估算值。
print r.pfcount("1") #輸出結果是5, 因為 4 重複了兩次
print r.pfcount("2") #輸出結果是0,