redis緩存數據庫及Python操做redis

時間 2019-11-10

標籤 redis 緩存數據庫 python 欄目 Redis 简体版

原文原文鏈接

緩存數據庫介紹

NoSQL(NoSQL = Not Only SQL )，意即「不只僅是SQL」，泛指非關係型的數據庫,隨着互聯網web2.0網站的興起，傳統的關係數據庫在應付web2.0網站，php

特別是超大規模和高併發的SNS類型的web2.0純動態網站已經顯得力不從心，暴露了不少難以克服的問題，而非關係型的數據庫則因爲其自己的特色獲得了很是迅速的發展。html

NoSQL數據庫的產生就是爲了解決大規模數據集合多重數據種類帶來的挑戰，尤爲是大數據應用難題。node

NoSQL數據庫的四大分類:

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

這一類數據庫主要會使用到一個哈希表，這個表中有一個特定的鍵和一個指針指向特定的數據。Key/value模型對於IT系統來講的優點在於簡單、易部署。mysql

可是若是DBA只對部分值進行查詢或更新的時候，Key/value就顯得效率低下了。[3] 舉例如：Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB.linux

列存儲數據庫:nginx

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

文檔型數據庫:github

文檔型數據庫的靈感是來自於Lotus Notes辦公軟件的，並且它同第一種鍵值存儲相相似。該類型的數據模型是版本化的文檔，半結構化的文檔以特定的格式存儲，好比JSON。web

文檔型數據庫可以看做是鍵值數據庫的升級版，容許之間嵌套鍵值。並且文檔型數據庫比鍵值數據庫的查詢效率更高。如：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(主從)同步。

Redis優勢:

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

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

安裝Redis環境:

yum安裝redis

1.yum安裝

#前提得配置好阿里雲yum源，epel源
#查看是否有redis包
yum list redis
#安裝redis
yum install redis -y
#安裝好，啓動redis
systemctl start redis

複製代碼

2.檢測redis是否工做

redis-cli    #redis 客戶端工具
#進入交互式環境後，執行ping，返回pong表示安裝成功
127.0.0.1:6379> ping
PONG

源碼安裝redis，編譯安裝

編譯安裝的優點是：

編譯安裝時能夠指定擴展的module（模塊），php、apache、nginx都是同樣有不少第三方擴展模塊，如mysql，編譯安裝時候，若是須要就定製存儲引擎（innodb，仍是MyIASM）
編譯安裝能夠統一安裝路徑，linux軟件約定安裝目錄在/opt/下面
軟件倉庫版本通常比較低，編譯源碼安裝能夠根據需求，安裝最新的版本

1.下載redis源碼
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
2.解壓縮
tar -zxf redis-4.0.10.tar.gz
3.切換redis源碼目錄
cd redis-4.0.10.tar.gz
4.編譯源文件
make 
5.編譯好後，src/目錄下有編譯好的redis指令
6.make install 安裝到指定目錄，默認在/usr/local/bin

redis可執行文件

./redis-benchmark //用於進行redis性能測試的工具
./redis-check-dump //用於修復出問題的dump.rdb文件
./redis-cli //redis的客戶端
./redis-server //redis的服務端
./redis-check-aof //用於修復出問題的AOF文件
./redis-sentinel //用於集羣管理

redis配置文件

redis配置文件名爲
redis.conf 
這個文件能夠自定義

redis.conf核心配置項

綁定ip，如須要遠程訪問，須要填寫服務器ip
bind 127.0.0.1  

端口，redis啓動端口
port 

守護進程方式運行
daemonize yes

rdb數據文件
dbfilename dump.rdb

數據文件存放路徑
dir /var/lib/redis/

日誌文件
logfile /var/log/redis/redis-server.log

主從複製
slaveof

啓動redis服務端

啓動redis很是簡單，直接./redis-server就能夠啓動服務端了，還能夠用下面的方法指定要加載的配置文件：
./redis-server ../redis.conf
默認狀況下，redis-server會以非daemon的方式來運行，且默認服務端口爲6379。

使用redis客戶端

#執行客戶端命令便可進入
./redis-cli  
#測試是否鏈接上redis
127.0.0.1:6379 > ping
返回pong表明鏈接上了

//用set來設置key、value
127.0.0.1:6379 > set name "luban"
OK
//get獲取name的值
127.0.0.1:6379 > get name
"luban"

Redis安全防禦

爲咱們的redis數據庫加層防禦，防止被黑客攻擊

http://www.javashuo.com/article/p-spojasgo-ba.html

redis數據結構

redis是一種高級的key：value存儲系統，其中value支持五種數據類型
字符串（strings）
散列（hashes）
列表（lists）
集合（sets）
有序集合（sorted sets）

基本命令

keys *         查看全部key
type key      查看key類型
expire key seconds    過時時間
ttl key     查看key過時剩餘時間        -2表示key已經不存在了
persist     取消key的過時時間   -1表示key存在，沒有過時時間

exists key     判斷key存在    存在返回1    不然0
del keys     刪除key    能夠刪除多個
dbsize         計算key的數量

Python操做Redis:

 
    sudo pip install redis 
   
   詳見：https://github.com/WoLpH/redis-py 
  
   Redis API使用 
   redis-py 的API的使用能夠分類爲： 
   鏈接方式
鏈接池
操做 
     String 操做
Hash 操做
List 操做
Set 操做
Sort Set 操做
 
管道
發佈訂閱
 
鏈接方式一、操做模式
redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，
Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。

    import redis r = redis.Redis(host='localhost', port=6379) r.set('foo', 'Bar') print r.get('foo') 
   
二、鏈接池
redis-py使用connection pool來管理對一個redis server的全部鏈接，避免每次創建、釋放鏈接的開銷。默認，每一個Redis實例都會維護一個本身的鏈接池。
能夠直接創建一個鏈接池，而後做爲參數Redis，這樣就能夠實現多個Redis實例共享一個鏈接池。
 
鏈接池code：
 
    #Author:Yun

import redis pool = redis.ConnectionPool(host='localhost',port = 6379) r = redis.Redis(connection_pool=pool) r.set('foo2','Bar2') print(r.get('foo2')) 
   
 操做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操做才執行
 
    127.0.0.1:6379> set name luban OK 127.0.0.1:6379> set age 22 OK 127.0.0.1:6379> keys * #獲取全部的key 1) "age" 2) "name" 
      
    127.0.0.1:6379> set  name  hehe  ex 2#ex 2是指只存活兩秒鐘 OK 127.0.0.1:6379> get name (nil) 
      
setnx(name, value)
 
    設置值，只有name不存在時，執行設置操做（添加） 
   
get(name)
 
    獲取值

    127.0.0.1:6379> get name "luban" 127.0.0.1:6379> get age "22" 
      
setex(name, value, time)
 
    設置值 參數： time，過時時間（數字秒 或 timedelta對象） 
   
 mget(keys, *args)
 
    批量獲取

127.0.0.1:6379> mget n1  n2#批量獲取Value
1) "1"
2) "2"

 getset(name, value)
 
    1 設置新值並獲取原來的值
127.0.0.1:6379> set  n3  3
OK
127.0.0.1:6379> get n3 
"3"
127.0.0.1:6379> getset n3  hehe#設置新值並獲取原來的值
"3"
 
getrange(key, start, end)
 
    獲取子序列（根據字節獲取，非字符） # 參數：
    # name，Redis 的 name
    # start，起始位置（字節）
    # end，結束位置（字節） # 如： "武沛齊" ，0-3表示 "武"

127.0.0.1:6379> set  n1 luban
OK
127.0.0.1:6379> getrange  n1  0  2#切片
"lub"
 
 setrange(name, offset, value)
 
     修改字符串內容，從指定字符串索引開始向後替換（新值太長時，則向後添加） # 參數： # offset，字符串的索引，字節（一個漢字三個字節） # value，要設置的值
127.0.0.1:6379> set n2 houyi
OK
127.0.0.1:6379> setrange  n2  1 ee#替換
(integer) 5
127.0.0.1:6379> get n2
"heeyi"
 
   setbit(name, offset, value) 
  
    # 對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是漢字 "魯班"怎麼辦？
　　>>> ord('魯')
　　40065
　　>>> bin(40065)
　　'0b1001110010000001'
　　>>> 答：對於utf-8，每個漢字佔 3 個字節，那麼 "魯班" 則有 6個字節 對於漢字，for循環時候會按照 字節 迭代，那麼在迭代時，將每個字節轉換 十進制數，而後再將十進制數轉換成二進制
------------------------魯班-------------------------------------------------------- 00000000 10011100 10000001 00000000 01110011 11101101

應用場景：
*用途舉例，用最省空間的方式，存儲在線用戶數及分別是哪些用戶在線
setbit n5 100 1#設置用戶登陸狀態位，n5是用戶名，100是用戶id
127.0.0.1:6379> setbit  bb  1000 1#來一個用戶標記一下
(integer) 0
127.0.0.1:6379> setbit  bb  100 1#來一個在標記一個
(integer) 0
127.0.0.1:6379> setbit  bb  230 1
(integer) 0
 
   getbit(name, offset) 
  
     獲取name對應的值的二進制表示中的某位的值 （0或1）
應用場景：
 
    getbit  n5 100 #檢測用戶登陸狀態位，是否在線，1-在線；0-不在線 
    127.0.0.1:6379> getbit bb 230#檢測用戶230 是否在線
(integer) 1        #在線
127.0.0.1:6379> getbit bb 233#檢測用戶233是否在線
(integer) 0        #不在線
127.0.0.1:6379> 

    應用：能夠將10億用戶的的登錄狀態和在線人數存儲到10MB空間中去 
      
bitcount(key, start=None, end=None)
 
    獲取name對應的值的二進制表示中 1 的個數 # 參數：
    # key，Redis的name
    # start，位起始位置
    # end，位結束位置

127.0.0.1:6379> bitcount bb#統計上線用戶數量
(integer) 3 
   
strlen(name)
 
127.0.0.1:6379> set  hh  '你好' OK 127.0.0.1:6379> strlen hh (integer) 6
127.0.0.1:6379> 返回name對應值的字節長度（一個漢字3個字節） 
   
incr(self, name, amount=1)
自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。 
       
      參數： 
    
         name,Redis的name 
    
         amount,自增數（必須是整數） 
    
127.0.0.1:6379> incr  login_users#統計在線計數器
(integer) 1
127.0.0.1:6379> incr login_users (integer) 2
127.0.0.1:6379> incr login_users (integer) 3
127.0.0.1:6379> incr login_users (integer) 4
127.0.0.1:6379> incr login_users (integer) 5
127.0.0.1:6379> decr login_users (integer) 4
127.0.0.1:6379> decr login_users (integer) 3
127.0.0.1:6379> 
 
incrbyfloat(self, name, amount=1.0)
 
    自增 name對應的值，當name不存在時，則建立name＝amount，不然，則自增。  參數：  name,Redis的name  amount,自增數（浮點型）

127.0.0.1:6379> INCRBYFLOAT  2  1.2
"1.2"
127.0.0.1:6379> INCRBYFLOAT  2  1.2
"2.4"
127.0.0.1:6379> INCRBYFLOAT  2  1.2
"3.6"  
   
   decr(self, name, amount=1) 
  
    # 自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減。 # 參數： # name,Redis的name # amount,自減數（整數） 
   
   append(key, value) 
  
    # 在redis name對應的值後面追加內容
 
# 參數：
 key, redis的name value, 要追加的字符串
127.0.0.1:6379> set  s1  sea
OK
127.0.0.1:6379> append  s1  blue
(integer) 7
127.0.0.1:6379> get  s1
"seablue"
127.0.0.1:6379>
 
2. Hash操做hash表現形式上有些像pyhton中的dict,能夠存儲一組關聯性較強的數據 ， redis中Hash在內存中的存儲格式以下圖：
 
hset(name, key, value)
 
    # name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改） # 參數： # name，redis的name # key，name對應的hash中的key # value，name對應的hash中的value # 注： # hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）
127.0.0.1:6379> hset  info  name luban
(integer) 1
127.0.0.1:6379> hset  info  age   22
(integer) 1
127.0.0.1:6379> hset  info  id    8848
(integer) 1
127.0.0.1:6379> hgetall info#獲取info下的全部key-value
1) "name"
2) "luban"
3) "age"
4) "22"
5) "id"
6) "8848"  
   
   hmset(name, mapping)  
  
    # 在name對應的hash中批量設置鍵值對 # 參數： # name，redis的name # mapping，字典，如：{'k1':'v1', 'k2': 'v2'} # 如： # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
127.0.0.1:6379> hmset  info2  k1  2  k2  3#批量設置
OK
127.0.0.1:6379> hkeys  info2
1) "k1"
2) "k2"
 
    hget(name,key) 
  
    # 在name對應的hash中獲取根據key獲取value 
   
    hmget(name, keys, *args) 
  
    # 在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')
127.0.0.1:6379> hmget  info3  n1 n2
1) "1"
2) "2"

    hgetall(name) 
  
    獲取name對應hash的全部鍵值對

127.0.0.1:6379> hgetall  info2
1) "k1"
2) "2"
3) "k2"
4) "3"
 
    hlen(name) 
  
    # 獲取name對應的hash中鍵值對的個數

127.0.0.1:6379> hlen  info2#獲取info2中有幾個key
(integer) 2
 
    hkeys(name) 
  
     獲取name對應的hash中全部的key的值

127.0.0.1:6379> hkeys  info2
1) "k1"
2) "k2" 
   
    hvals(name) 
  
    # 獲取name對應的hash中全部的value的值

127.0.0.1:6379> hvals  info#獲取info下的全部value
1) "luban"
2) "22"
3) "8848"
 
    hexists(name, key) 
  
    # 檢查name對應的hash是否存在當前傳入的key

127.0.0.1:6379> hexists  info2   k1#檢查info2下的k1這個key是否存在，存在返回1，不然0
(integer) 1
127.0.0.1:6379> hexists  info2   k3
(integer) 0 
   
   hdel(name,*keys) 
  
    # 將name對應的hash中指定key的鍵值對刪除

127.0.0.1:6379> hdel  info2  k2#刪除info2下的k2及其value
(integer) 1
127.0.0.1:6379> hget  info2  k2
(nil) 
   
    hincrby(name, key, amount=1) 
  
    # 自增name對應的hash中的指定key的值，不存在則建立key=amount # 參數： # name，redis中的name # key， hash對應的key # amount，自增數（整數）

127.0.0.1:6379> hincrby  info2  k2 1#自增name對應的hash中指定key的值，不存在則建立，value=amount
(integer) 1
127.0.0.1:6379> hincrby  info2  k2 1
(integer) 2
127.0.0.1:6379> hincrby  info2  k2 1
(integer) 3
127.0.0.1:6379> hincrby  info2  k2 1
(integer) 4
127.0.0.1:6379> hincrby  info2  k2 1
(integer) 5 
   
    hincrbyfloat(name, key, amount=1.0) 
  
    # 自增name對應的hash中的指定key的值，不存在則建立key=amount # 參數： # name，redis中的name # key， hash對應的key # amount，自增數（浮點數） # 自增name對應的hash中的指定key的值，不存在則建立key=amount

127.0.0.1:6379> HINCRBYFLOAT   info5  n2  1.2
"1.2"
127.0.0.1:6379> HINCRBYFLOAT   info5  n2  1.2
"2.4"
127.0.0.1:6379> HINCRBYFLOAT   info5  n2  1.2
"3.6"
127.0.0.1:6379> hget info5 n2
"3.6"
127.0.0.1:6379> 

    hscan(name, cursor=0, match=None, count=None) 
  
    使用如下命令啓動完整哈希掃描 HSCAN myhash 0 使用與模式匹配的字段開始哈希掃描： HSCAN myhash 0 MATCH order_* 使用與模式匹配的字段啓動哈希掃描，並強制掃描命令執行更多操做 掃描： HSCAN myhash 0 MATCH order_* COUNT 1000

 # 增量式迭代獲取，對於數據大的數據很是有用，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時，表示數據已經經過分片獲取完畢

127.0.0.1:6379> HSCAN  info  0
1) "0"
2) 1) "name"
   2) "luban"
   3) "age"
   4) "22"
   5) "id"
   6) "8848"
127.0.0.1:6379> hscan  info2  0  match  k*#過濾以k開頭的key
1) "0"
2) 1) "k1"
   2) "2"
   3) "k2"
   4) "6"
127.0.0.1:6379>  
   
   hscan_iter(name, match=None, count=None) 
  
    # 利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
  
# 參數：
    # match，匹配指定key，默認None 表示全部的key
    # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
  
# 如：
    # for item in r.hscan_iter('xx'):
    # print(item) 
   
   3. list 
   List操做，redis中的List在在內存中按照一個name對應一個List來存儲。如圖： 
  
   lpush(name,values)  
  
    # 在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊
 
# 如：
    # r.lpush('oo', 11,22,33)
    # 保存順序爲: 33,22,11
 
# 擴展：
    # rpush(name, values) 表示從右向左操做
127.0.0.1:6379> lpush  names   luban  houyi  daji#先入後出建立列表
(integer) 3

    lrange(name, start, end) 
  
    # 在name對應的列表分片獲取數據 # 參數： # name，redis的name # start，索引的起始位置 # end，索引結束位置

    127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "luban" 
      
    lpushx(name,value) 
  
    #在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊 # 更多： # rpushx(name, value) 表示從右向左操做
127.0.0.1:6379> lpushx   l5   hehe
(integer) 0
127.0.0.1:6379> lrange l5  0  -1
(empty list or set)

127.0.0.1:6379> lpush  L5  1 2 3 4
(integer) 4
127.0.0.1:6379> lrange L5 0 -1
1) "4"
2) "3"
3) "2"
4) "1"
127.0.0.1:6379> lpushx  L5  hehe
(integer) 5
127.0.0.1:6379> lrange L5 0 -1
1) "hehe"
2) "4"
3) "3"
4) "2"
5) "1"
127.0.0.1:6379>  
   
   llen(name) 
  
    # name對應的list元素的個數
 
    127.0.0.1:6379> lrange L5 0 -1
1) "hehe"
2) "4"
3) "3"
4) "2"
5) "1"
127.0.0.1:6379> llen  L5
(integer) 5

    linsert(name, where, refvalue, value)) 
  
    # 在name對應的列表的某一個值前或後插入一個新值 # 參數： # name，redis的name # where，BEFORE或AFTER # refvalue，標杆值，即：在它先後插入數據 # value，要插入的數據

127.0.0.1:6379> linsert  names  before  luban  houzi#在luban 前面插入數據
(integer) 6
127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "houzi"
4) "luban"
5) "hanxin"
6) "laofuzi"
127.0.0.1:6379> linsert  names  after  luban  kai#在luban 後面插入數據
(integer) 7
127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "houzi"
4) "luban"
5) "kai"
6) "hanxin"
7) "laofuzi"
 
   lset(name, index, value) 
  
    # 對name對應的list中的某一個索引位置從新賦值 # 參數： # name，redis的name # index，list的索引位置 # value，要設置的值
127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "houzi"
4) "luban"
5) "kai"
6) "hanxin"
7) "laofuzi"
127.0.0.1:6379> lset  names  3 LuBan#從新給names列表中 索引爲3的位置賦值
OK
127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "houzi"
4) "LuBan"
5) "kai"
6) "hanxin"
7) "laofuzi"
 
   lrem(name, value, num) 
  
    # 在name對應的list中刪除指定的值 # 參數： # name，redis的name # value，要刪除的值 # num， num=0，刪除列表中全部的指定值； # num=2,從前到後，刪除2個； # num=-2,從後向前，刪除2個

127.0.0.1:6379> lrem  names 1  houzi  #刪除指定的值
(integer) 1
127.0.0.1:6379> lrange  names 0  -1
1) "daji"
2) "houyi"
3) "LuBan"
4) "kai"
5) "hanxin"
6) "laofuzi"
 
    lpop(name) 
  
    # 在name對應的列表的左側獲取第一個元素並在列表中移除，返回值則是第一個元素 # 更多： # rpop(name) 表示從右向左操做
127.0.0.1:6379> lpop  names#從列表最左邊取出一個元素刪除，相似於隊列
"daji"
127.0.0.1:6379> lrange  names 0  -1
1) "houyi"
2) "LuBan"
3) "kai"
4) "hanxin"
5) "laofuzi"
127.0.0.1:6379>  
   
    lindex(name, index) 
  
    在name對應的列表中根據索引獲取列表元素

127.0.0.1:6379> lindex L5  1
"4"
127.0.0.1:6379> lindex L5  0
"hehe"
127.0.0.1:6379> lindex L5  2
"3"
127.0.0.1:6379>   
   
    ltrim(name, start, end) 
  
    # 在name對應的列表中移除沒有在start-end索引之間的值 # 參數： # name，redis的name # start，索引的起始位置 # end，索引結束位置

127.0.0.1:6379> lrange  names 0  -1
1) "houyi"
2) "LuBan"
3) "kai"
4) "hanxin"
5) "laofuzi"
127.0.0.1:6379> ltrim  names  1 2#只保留列表names 索引爲 1 -2 的元素
OK
127.0.0.1:6379> lrange  names 0  -1
1) "LuBan"
2) "kai"
 
    rpoplpush(src, dst) 
  
    # 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊 # 參數： # src，要取數據的列表的name # dst，要添加數據的列表的name

127.0.0.1:6379> lrange  names 0  -1
1) "LuBan"
2) "kai"
127.0.0.1:6379> lrange  names2 0  -1
1) "hehe"
127.0.0.1:6379> rpoplpush  names  names2#移除names最右邊的元素，同時添加到names2的最左邊
"kai"
127.0.0.1:6379> lrange  names2 0  -1
1) "kai"
2) "hehe"
127.0.0.1:6379> lrange  names 0  -1
1) "LuBan" 
   
    blpop(keys, timeout) 
  
    # 將多個列表排列，按照從左到右去pop對應列表的元素 # 參數： # keys，redis的name的集合 # timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞 # 更多： # r.brpop(keys, timeout)，從右向左獲取數據

   brpoplpush(src, dst, timeout=0) 
  
    # 從一個列表的右側移除一個元素並將其添加到另外一個列表的左側 # 參數： # src，取出並要移除元素的列表對應的name # dst，要插入元素的列表對應的name # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞
127.0.0.1:6379> brpoplpush  names names2  40
#從列表names的最右端移除一個元素並添加到另外一個列表names2的左側
#當列表中沒有數據阻塞等待40s
"hehhe"
(12.69s)
127.0.0.1:6379> lrange  names2 0 -1
1) "hehhe"
2) "LuBan"
3) "kai"
4) "hehe"

應用場景：
兩個進程，一個進程放數據，另外一個進程取數據；
保證數據一致性，同步放數據，同步取數據並刪除，雙方不影響 
   
   4.set集合操做 
  
   Set操做，Set集合就是不容許重複的列表 
  
    sadd(name,values) 
  
    # name對應的集合中添加元素

127.0.0.1:6379> sadd  names3  luban  luban  hehe  hehe  2323#集合天生去重
(integer) 3  
   
   smembers(name) 
  
    # 獲取name對應的集合的全部成員
 
    127.0.0.1:6379> smembers  names3
1) "2323"
2) "luban"
3) "hehe 
   
   scard(name) 
  
    獲取name對應的集合中元素個數
127.0.0.1:6379> scard  names3#獲取names3集合中的元素個數
(integer) 3  
   
    sdiff(keys, *args) 
  
    在第一個name對應的集合中且不在其餘name對應的集合的元素集合

127.0.0.1:6379> sadd  names4   hanxin  houzi  kai  2323 hehe

127.0.0.1:6379> sdiff  names3  names4#返回names3有的而names4中沒有的元素
1) "luban" 
   
 sdiffstore(dest, keys, *args)
 
    # 獲取第一個name對應的集合中且不在其餘name對應的集合，再將其新加入到dest對應的集合中
127.0.0.1:6379> sdiffstore n5  names3  names4
#將names3有的而names4中沒有的元素從新加入到集合n5中
(integer) 1
127.0.0.1:6379> smembers n5
1) "luban"
 
    sinter(keys, *args) 
  
    # 獲取多一個name對應集合的交集
127.0.0.1:6379> sinter  names3  names4#返回呢兩個集合的交集
1) "2323"
2) "hehe"
 
    sinterstore(dest, keys, *args) 
  
    # 獲取多一個name對應集合的交集，再講其加入到dest對應的集合中
127.0.0.1:6379> SINTERSTORE  names34   names3  names4
(integer) 2
127.0.0.1:6379> SMEMBERS  names34
1) "hehe"
2) "2323"  
   
    sismember(name, value) 
  
    # 檢查value是不是name對應的集合的成員

127.0.0.1:6379> SISMEMBER  names34  'hehe'#是返回1
(integer) 1
127.0.0.1:6379> SISMEMBER  names34  123#不是返回0
(integer) 0

    smove(src, dst, value) 
  
    # 將某個成員從一個集合中移動到另一個集合
127.0.0.1:6379> sadd  s2  1 2  3
(integer) 3
127.0.0.1:6379> sadd  s3  4 5  6 
(integer) 3
127.0.0.1:6379> SMOVE  s2   s3  1
(integer) 1
127.0.0.1:6379> smembers  s2
1) "2"
2) "3"
127.0.0.1:6379> smembers  s3  
   
    spop(name) 
  
    # 從集合的右側（尾部）移除一個成員，並將其返回

127.0.0.1:6379> smembers  s3
1) "1"
2) "4"
3) "5"
4) "6"
127.0.0.1:6379> spop s3
"6"  
   
    srandmember(name, numbers) 
  
    # 從name對應的集合中隨機獲取 numbers 個元素

127.0.0.1:6379> SRANDMEMBER  s3  2
1) "5"
2) "4"
127.0.0.1:6379> SRANDMEMBER  s3  2
1) "1"
2) "4"
127.0.0.1:6379> SRANDMEMBER  s3  2
1) "5"
2) "4"
 
    srem(name, values) 
  
    # 在name對應的集合中刪除某些值

127.0.0.1:6379> smembers  s3
1) "1"
2) "4"
3) "5"
127.0.0.1:6379> srem  s3   1#刪除s3集合中的成員1
(integer) 1
127.0.0.1:6379> smembers  s3
1) "4"
2) "5"

    sunion(keys, *args) 
  
    # 獲取多個或一個name對應的集合的並集

127.0.0.1:6379> sunion   s2  
1) "2"
2) "3"
127.0.0.1:6379> sunion   s2  s3
1) "2"
2) "3"
3) "4"
4) "5"  
   
    sunionstore(dest,keys, *args) 
  
    # 獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中
127.0.0.1:6379> sunionstore  s23_union s2  s3
(integer) 4
127.0.0.1:6379> smembers  s23_union
1) "2"
2) "3"
3) "4"
4) "5" 
 
   sscan(name, cursor=0, match=None, count=None) 
  
   sscan_iter(name, match=None, count=None) 
  
    # 同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大 
   
 五、有序集合 
 
   有序集合，在集合的基礎上，爲每元素排序；元素的排序須要根據另一個值來進行比較， 
  
   因此，對於有序集合，每個元素有兩個值，即：值和分數，分數專門用來作排序。  
  
   zadd(name, *args, **kwargs) 
  
    # 在name對應的有序集合中添加元素 # 如： # zadd('zz', 'n1', 1, 'n2', 2) # 或 # zadd('zz', n1=11, n2=22)
127.0.0.1:6379> zadd  z1  10  he  3  hehe   6   hehe
(integer) 2
127.0.0.1:6379> zadd  z1  10  he  3  hehe   6   hehehe
(integer) 1
127.0.0.1:6379> ZRANGE  z1  0  -1 withscores
1) "hehe"
2) "3"
3) "hehehe"
4) "6"
5) "he"
6) "10"
 
   zrange( name, start, end, desc=False, withscores=False, score_cast_func=float) 
  
    # 按照索引範圍獲取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) 
   
    zcard(name) 
  
    # 獲取name對應的有序集合元素的數量
127.0.0.1:6379> ZRANGE  z1  0  -1  withscores
1) "daji"
2) "3"
3) "hehe"
4) "3"
5) "houyi"
6) "7"
7) "luban"
8) "10"
127.0.0.1:6379> zcard  z1
(integer) 4  
   
    zcount(name, min, max) 
  
    # 獲取name對應的有序集合中分數 在 [min,max] 之間的個數
127.0.0.1:6379> ZRANGE  z1  0  -1  withscores
1) "daji"
2) "3"
3) "hehe"
4) "3"
5) "houyi"
6) "7"
7) "luban"
8) "10"
127.0.0.1:6379> zcount  z1  3 4
(integer) 2  
   
    zincrby(name, value, amount) 
  
    # 自增name對應的有序集合的 name 對應的分數
127.0.0.1:6379> zincrby  z3  3  num
"3"
127.0.0.1:6379> zincrby  z3  3  num
"6"
127.0.0.1:6379> zincrby  z3  3  num
"9"
127.0.0.1:6379> zincrby  z3  3  num
"12"
127.0.0.1:6379> zrange  z3  0  -1  withscores
1) "hehe"
2) "6"
3) "daji"
4) "8"
5) "num"
6) "12"  
   
    zrank(name, value) 
  
    # 獲取某個值在 name對應的有序集合中的排行（從 0 開始） # 更多： # zrevrank(name, value)，從大到小排序
127.0.0.1:6379> zrange  z3  0  -1  withscores
1) "hehe"
2) "6"
3) "daji"
4) "8"
5) "num"
6) "12"
127.0.0.1:6379> zrank  z3  daji
(integer) 1  
   
   zrem(name, values)  
  
    # 刪除name對應的有序集合中值是values的成員 # 如：zrem('zz', ['s1', 's2'])
127.0.0.1:6379> zrem  z3  'daji'
(integer) 1
127.0.0.1:6379> zrange  z3  0  -1  withscores
1) "hehe"
2) "6"
3) "num"
4) "12"  
   
    zremrangebyrank(name, min, max) 
  
    # 根據排行範圍刪除
127.0.0.1:6379> zrange  z1  0  -1  withscores
1) "daji"
2) "3"
3) "hehe"
4) "3"
5) "houyi"
6) "7"
7) "luban"
8) "10"
127.0.0.1:6379> zremrangebyrank  z1  0  1
(integer) 2
127.0.0.1:6379> zrange  z1  0  -1  withscores
1) "houyi"
2) "7"
3) "luban"
4) "10"  
   
    zremrangebyscore(name, min, max) 
  
    # 根據分數範圍刪除
127.0.0.1:6379> zrange  z4  0  -1  withscores
 1) "luban"
 2) "2"
 3) "wangzhaojun"
 4) "3"
 5) "daji"
 6) "6"
 7) "diaochan"
 8) "9"
 9) "zhenji"
10) "10"
127.0.0.1:6379> zremrangebyscore  z4  3  6#刪除成績在[3,6]
(integer) 2
127.0.0.1:6379> zrange  z4  0  -1  withscores
1) "luban"
2) "2"
3) "diaochan"
4) "9"
5) "zhenji"
6) "10"  
   
   zscore(name, value) 
  
    # 獲取name對應有序集合中 value 對應的分數
127.0.0.1:6379> zrange  z4  0  -1  withscores
1) "luban"
2) "2"
3) "diaochan"
4) "9"
5) "zhenji"
6) "10"
127.0.0.1:6379> zscore  z4  'zhenji'
"10"  
   
   zinterstore(dest, keys, aggregate=None) 
  
    # 獲取兩個有序集合的交集，若是遇到相同值，則按照aggregate進行操做 # aggregate的值爲: SUM MIN MAX
127.0.0.1:6379> zadd  z5  3  luban
(integer) 1
127.0.0.1:6379> zrange  z5  0  -1  withscores
1) "luban"
2) "3"
127.0.0.1:6379> zrange  z4  0  -1  withscores
1) "luban"
2) "2"
3) "diaochan"
4) "9"
5) "zhenji"
6) "10"
127.0.0.1:6379> zinterstore  z45_sum  2  z4  z5
(integer) 1
127.0.0.1:6379> zrange  z45_sum  0  -1  withscores
1) "luban"
2) "5"  
   
   zunionstore(dest, keys, aggregate=None) 
  
    # 獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做 # aggregate的值爲: SUM MIN MAX
127.0.0.1:6379> zrange  z6  0  -1 withscores
1) "luban"
2) "2"
127.0.0.1:6379> zrange  z4  0  -1 withscores
1) "luban"
2) "2"
3) "diaochan"
4) "9"
5) "zhenji"
6) "10"
127.0.0.1:6379> zunionstore  z46_union  2  z4  z6
(integer) 3
127.0.0.1:6379> zrange   z46_union  0 -1  withscores
1) "luban"
2) "4"
3) "diaochan"
4) "9"
5) "zhenji"
6) "10"
 
   zscan(name, cursor=0, match=None, count=None, score_cast_func=float) 
   
   zscan_iter(name, match=None, count=None,score_cast_func=float) 
  
    # 同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做 
   
其餘經常使用操做:delete(*names)
 
    # 根據刪除redis中的任意數據類型

 select(num) 
    redis 默認有16個db 0-15,select 5切換db 
   
    exists(name) 
  
    # 檢測redis的name是否存在 
   
    keys(pattern='*') 
  
    # 根據模型獲取redis的name # 更多： # KEYS * 匹配數據庫中全部 key 。 # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。 # KEYS h*llo 匹配 hllo 和 heeeeello 等。 # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 
   
    expire(name ,time) 
  
    # 爲某個redis的某個name設置超時時間 
   
    rename(src, dst) 
  
    # 對redis的name重命名爲 
   
    move(name, db)) 
  
    # 將redis的某個值移動到指定的db下 
   
    randomkey() 
  
    # 隨機獲取一個redis的name（不刪除） 
   
    type(name) 
  
    # 獲取name對應值的類型 
   
   scan(cursor=0, match=None, count=None) 
   
   scan_iter(match=None, count=None) 
  
    # 同字符串操做，用於增量迭代獲取key 
   
 管道
      
   　　redis-py默認在執行每次請求都會建立（鏈接池申請鏈接）和斷開（歸還鏈接池）一次鏈接操做，若是想要在一次請求中指定多個命令， 
  
   則可使用pipline實現一次請求指定多個命令，而且默認狀況下一次pipline 是原子性操做。Redis的管道能夠在大量數據須要一次性操做完成的時候, 
  
   使用Pipeline進行批處理,將一大堆的操做合併成一次操做,能夠減小鏈路層的時間消耗,畢竟頻繁操做是很差的。 
  
   　使用redis客戶端 在本地測試Redis 10W條數據的讀寫 
  
　　不使用管道：import redis
from time import time
pool = redis.ConnectionPool(db=2,)

r = redis.Redis(connection_pool=pool,)
start_time = time()
for i in range(100000):
    r.set('{}'.format(i), '{}'.format(i))
end_time = time()
print('讀寫10W條數據，共耗時(ms)：', (end_time-start_time)*1000)

　　使用管道：import redis
from time import time
pool = redis.ConnectionPool(host='localhost', port=6379, db=4,)

r = redis.Redis( connection_pool=pool,)
pipe = r.pipeline(transaction=True)
start_time = time()
pipe.multi()
for i in range(100000):
    pipe.set(i, i)
pipe.execute()
end_time = time()
print('讀寫10W條數據，共耗時(ms)：', (end_time-start_time)*1000)

   若是是頻繁的操做Redis,使用管道技術去進行操做是可取的.不只減小服務器壓力,還能減小鏈路層中的時間消耗,批量處理頻繁的操做, 
  
   將大量操做結合成少許的操做..這是十分可取的. 
  
發佈訂閱                                      
 
發佈者：服務器
訂閱者：Dashboad和數據處理
Demo以下：
 
     #Author:Yun
import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='localhost',port=6379,db=0)
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()#打開收音機
        pub.subscribe(self.chan_sub)#調頻
        pub.parse_response()#準備接收
        return pub 
    
View Code
 
    發佈者： 
  
    #發佈方 from redishelper import RedisHelper obj = RedisHelper() obj.public('hello') ''' 命令行發佈： PUBLISH fm104.5 hello ''' 
   
   訂閱者： 
  
    #訂閱方 from redishelper import RedisHelper obj = RedisHelper() redis_sub = obj.subscribe() while True: msg = redis_sub.parse_response() print(msg) 
   
   更多參見： 
  
   https://github.com/andymccurdy/redis-py/ 
  
   http://doc.redisfans.com/ 
  
 何時用關係型數據庫，何時 用NoSQL?
      
   在如下狀況下轉到遺留關係數據庫（RDBMS）： 
   
    一、數據結構良好，適用於關係數據庫中的表格排列（行和列）。典型示例：銀行賬戶信息，客戶訂單信息，客戶信息，員工信息，部門信息等。
    二、上述觀點的另外一方面是：面向模式的數據模型。當您爲潛在使用RDBMS設計數據模型（表，關係等）時，您須要提出一個定義良好的模式：將有這麼多表， 
  
   每一個表都有一組已知的列，用於存儲已知的數據鍵入格式（CHAR，NUMBER，BLOB等）。
    三、很是重要：考慮數據是否具備事務性質。換句話說，是否將在提供ACID語義的事務的上下文中存儲，訪問和更新數據，或者是否能夠妥協某些/全部這些屬性。
    四、正確性也很重要，任何妥協都是不可接受的。這源於這樣一個事實：在大多數NoSQL數據庫中，一致性被用於支持性能和可伸縮性（NoSQL數據庫上的要點將在下面詳述）。
    五、對於橫向擴展架構沒有強烈/迫切的需求;數據庫，線性擴展（水平擴展）到羣集中的多個節點。
    六、用例不適用於「高速數據攝取」。
   七、 若是客戶端應用程序指望快速地將大量數據流入/流出數據庫，那麼關係數據庫可能不是一個好的選擇，由於它們並不是真正用於擴展寫入繁重的工做負載。
    八、爲了實現ACID屬性，特別是在編寫器（INSERT，UPDATE，DELETE）代碼路徑中進行了大量額外的後臺工做。這確定會影響性能。
    九、用例不是「存儲數PB範圍內的大量數據」。 
  
   在如下狀況下訪問NoSQL數據庫： 
   
     一、數據不適用於固定（和預約）架構：
     二、可擴展性，性能（高吞吐量和低操做延遲），連續可用性是數據庫底層架構必須知足的很是重要的要求。
     三、 「高速數據攝取」的不錯選擇。 這樣的應用程序（例如IoT樣式）在一秒鐘內產生數百萬個數據點，而且須要可以提供極端寫入可伸縮性的數據庫。
     四、橫向擴展的固有能力容許在羣集中的商用服務器上存儲大量數據。 它們一般使用低成本資源，而且可以隨着需求的增加線性增長計算和存儲能力。 
  
value 在1K以上時，1000M網卡輕鬆的被跑慢，並且redis-server cpu連一個核心都沒佔用到，可見redis高效，redis的服務也不須要過高配置，瓶頸在網卡速度。 

 Django配置Redis 
安裝django項目中配置redis做爲cache緩存，須要先安裝django-redis模塊
 
   pip install django-redis 
  
 配置在settings.py中，按以下配置CACHE鏈接的redis信息：
 
   CACHES = { "default": { "BACKEND": "django_redis.cache.RedisCache", "LOCATION": "redis://127.0.0.1:6379", "OPTIONS": { "CLIENT_CLASS": "django_redis.client.DefaultClient", "CONNECTION_POOL_KWARGS": {"max_connections": 100}, # "PASSWORD": "密碼",
            "DECODE_RESPONSES":True } }, } 
  
 使用先獲取redis鏈接：
 
   import django_redis CACHE = django_redis.get_redis_connection() 
  
在視圖中
 
   ...
CACHE.set(key, value)
...