day19-20180515筆記

時間 2019-11-10

標籤 day19 day 筆記简体版

原文原文鏈接

筆記：NOSQL非關係型數據庫之python3操做redispython

1、NOSQLmysql

一、Nosql簡介

對於NoSQL並無一個明確的範圍和定義，可是他們都廣泛存在下面一些共同特徵：
1. 不須要預約義模式：不須要事先定義數據模式，預約義表結構。數據中的每條記錄均可能有不一樣的屬性和格式。當插入數據時，並不須要預先定義它們的模式。
2. 無共享架構：相對於將全部數據存儲的存儲區域網絡中的全共享架構。NoSQL每每將數據劃分後存儲在各個本地服務器上。由於從本地磁盤讀取數據的性能每每好於經過網絡傳輸讀取數據的性能，從而提升了系統的性能。
3. 彈性可擴展：能夠在系統運行的時候，動態增長或者刪除結點。不須要停機維護，數據能夠自動遷移。
4.分區：相對於將數據存放於同一個節點，NoSQL數據庫須要將數據進行分區，將記錄分散在多個節點上面。而且一般分區的同時還要作複製。這樣既提升了並行性能，又能保證沒有單點失效的問題。
5.異步複製：和RAID存儲系統不一樣的是，NoSQL中的複製，每每是基於日誌的異步複製。這樣，數據就能夠儘快地寫入一個節點，而不會被網絡傳輸引發遲延。缺點是並不老是能保證一致性，這樣的方式在出現故障的時候，可能會丟失少許的數據。
6. BASE：相對於事務嚴格的ACID特性，NoSQL數據庫保證的是BASE特性。BASE是最終一致性和軟事務。
NoSQL數據庫並無一個統一的架構，兩種NoSQL數據庫之間的不一樣，甚至遠遠超過兩種關係型數據庫的不一樣。能夠說，NoSQL各有所長，成功的NoSQL必然特別適用於某些場合或者某些應用，在這些場合中會遠遠賽過關係型數據庫和其餘的NoSQLlinux

經常使用的Nosql數據庫redis

2、python3之redissql

一、redis簡介

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

1. 使用Redis有哪些好處？

(1) 速度快，由於數據存在內存中，相似於HashMap，HashMap的優點就是查找和操做的時間複雜度都是O(1)

(2) 支持豐富數據類型，支持string，list，set，sorted set，hash

(3) 支持事務，操做都是原子性，所謂的原子性就是對數據的更改要麼所有執行，要麼所有不執行

(4) 豐富的特性：可用於緩存，消息，按key設置過時時間，過時後將會自動刪除


2. redis相比memcached有哪些優點？

(1) memcached全部的值均是簡單的字符串，redis做爲其替代者，支持更爲豐富的數據類型

(2) redis的速度比memcached快不少

(3) redis能夠持久化其數據


3. redis常見性能問題和解決方案：

(1) Master最好不要作任何持久化工做，如RDB內存快照和AOF日誌文件

(2) 若是數據比較重要，某個Slave開啓AOF備份數據，策略設置爲每秒同步一次

(3) 爲了主從複製的速度和鏈接的穩定性，Master和Slave最好在同一個局域網內

(4) 儘可能避免在壓力很大的主庫上增長從庫

(5) 主從複製不要用圖狀結構，用單向鏈表結構更爲穩定，即：Master <- Slave1 <- Slave2 <- Slave3...

這樣的結構方便解決單點故障問題，實現Slave對Master的替換。若是Master掛了，能夠馬上啓用Slave1作Master，其餘不變。

4. MySQL裏有2000w數據，redis中只存20w的數據，如何保證redis中的數據都是熱點數據

 相關知識：redis 內存數據集大小上升到必定大小的時候，就會施行數據淘汰策略。redis 提供 6種數據淘汰策略：

voltile-lru：從已設置過時時間的數據集（server.db[i].expires）中挑選最近最少使用的數據淘汰

volatile-ttl：從已設置過時時間的數據集（server.db[i].expires）中挑選將要過時的數據淘汰

volatile-random：從已設置過時時間的數據集（server.db[i].expires）中任意選擇數據淘汰

allkeys-lru：從數據集（server.db[i].dict）中挑選最近最少使用的數據淘汰

allkeys-random：從數據集（server.db[i].dict）中任意選擇數據淘汰

no-enviction（驅逐）：禁止驅逐數據

5. Memcache與Redis的區別都有哪些？

1)、存儲方式

Memecache把數據所有存在內存之中，斷電後會掛掉，數據不能超過內存大小。

Redis有部份存在硬盤上，這樣能保證數據的持久性。

2)、數據支持類型
Memcache對數據類型支持相對簡單。
Redis有複雜的數據類型。
3），value大小
redis最大能夠達到1GB，而memcache只有1MB

6. Redis 常見的性能問題都有哪些？如何解決？
1).Master寫內存快照，save命令調度rdbSave函數，會阻塞主線程的工做，當快照比較大時對性能影響是很是大的，會間斷性暫停服務，因此Master最好不要寫內存快照。
2).Master AOF持久化，若是不重寫AOF文件，這個持久化方式對性能的影響是最小的，可是AOF文件會不斷增大，AOF文件過大會影響Master重啓的恢復速度。Master最好不要作任何持久化工做，包括內存快照和AOF日誌文件，特別是不要啓用內存快照作持久化,若是數據比較關鍵，某個Slave開啓AOF備份數據，策略爲每秒同步一次。
3).Master調用BGREWRITEAOF重寫AOF文件，AOF在重寫的時候會佔大量的CPU和內存資源，致使服務load太高，出現短暫服務暫停現象。
4). Redis主從複製的性能問題，爲了主從複製的速度和鏈接的穩定性，Slave和Master最好在同一個局域網內

7, redis 最適合的場景
Redis最適合全部數據in-momory的場景，雖然Redis也提供持久化功能，但實際更多的是一個disk-backed的功能，跟傳統意義上的持久化有比較大的差異，那麼可能你們就會有疑問，彷佛Redis更像一個增強版的Memcached，那麼什麼時候使用Memcached,什麼時候使用Redis呢?
       若是簡單地比較Redis與Memcached的區別，大多數都會獲得如下觀點：
     1 、Redis不只僅支持簡單的k/v類型的數據，同時還提供list，set，zset，hash等數據結構的存儲。
     2 、Redis支持數據的備份，即master-slave模式的數據備份。
     3 、Redis支持數據的持久化，能夠將內存中的數據保持在磁盤中，重啓的時候能夠再次加載進行使用。
（1）、會話緩存（Session Cache）
最經常使用的一種使用Redis的情景是會話緩存（session cache）。用Redis緩存會話比其餘存儲（如Memcached）的優點在於：Redis提供持久化。當維護一個不是嚴格要求一致性的緩存時，若是用戶的購物車信息所有丟失，大部分人都會不高興的，如今，他們還會這樣嗎？
幸運的是，隨着 Redis 這些年的改進，很容易找到怎麼恰當的使用Redis來緩存會話的文檔。甚至廣爲人知的商業平臺Magento也提供Redis的插件。
（2）、全頁緩存（FPC）
除基本的會話token以外，Redis還提供很簡便的FPC平臺。回到一致性問題，即便重啓了Redis實例，由於有磁盤的持久化，用戶也不會看到頁面加載速度的降低，這是一個極大改進，相似PHP本地FPC。
再次以Magento爲例，Magento提供一個插件來使用Redis做爲全頁緩存後端。
此外，對WordPress的用戶來講，Pantheon有一個很是好的插件  wp-redis，這個插件能幫助你以最快速度加載你曾瀏覽過的頁面。
（3）、隊列
Reids在內存存儲引擎領域的一大優勢是提供 list 和 set 操做，這使得Redis能做爲一個很好的消息隊列平臺來使用。Redis做爲隊列使用的操做，就相似於本地程序語言（如Python）對 list 的 push/pop 操做。
若是你快速的在Google中搜索「Redis queues」，你立刻就能找到大量的開源項目，這些項目的目的就是利用Redis建立很是好的後端工具，以知足各類隊列需求。例如，Celery有一個後臺就是使用Redis做爲broker，你能夠從這裏去查看。
（4），排行榜/計數器
Redis在內存中對數字進行遞增或遞減的操做實現的很是好。集合（Set）和有序集合（Sorted Set）也使得咱們在執行這些操做的時候變的很是簡單，Redis只是正好提供了這兩種數據結構。因此，咱們要從排序集合中獲取到排名最靠前的10個用戶–咱們稱之爲「user_scores」，咱們只須要像下面同樣執行便可：
固然，這是假定你是根據你用戶的分數作遞增的排序。若是你想返回用戶及用戶的分數，你須要這樣執行：
ZRANGE user_scores 0 10 WITHSCORES
Agora Games就是一個很好的例子，用Ruby實現的，它的排行榜就是使用Redis來存儲數據的，你能夠在這裏看到。
（5）、發佈/訂閱
最後（但確定不是最不重要的）是Redis的發佈/訂閱功能。發佈/訂閱的使用場景確實很是多。我已看見人們在社交網絡鏈接中使用，還可做爲基於發佈/訂閱的腳本觸發器，甚至用Redis的發佈/訂閱功能來創建聊天系統！（不，這是真的，你能夠去核實）。
Redis提供的全部特性中，我感受這個是喜歡的人最少的一個，雖然它爲用戶提供若是此多功能。

二、redis安裝

Redis通常都是安裝在linux系統中，具體安裝步驟以下：數據庫

#cd /usr/local/src
#wget http://download.redis.io/releases/redis-3.0.1.tar.gz 
#tar xzf redis-3.0.1.tar.gz 
#cd redis-3.0.1 
#make
#src/redis-server &

或者在他的配置文件中把demon 改爲yes後端

檢查redis是否啓動成功緩存

ps –ef |grep redis
netstat –lnp |grep 6379

三、python連接redis操做

python安裝redis模塊

pip3 install redis

redis 模塊使用能夠分類爲：服務器

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

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/16 14:16
# @Author  : yangyuanqiang
# @File    : demon1.py


import redis

#建立redis連接對象
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
#存儲鍵值對
r.set('site','www.qi.cn')
#獲取值
print(r.get('site'))
#指定decode_responses爲True，表示輸出爲字符串
red = redis.StrictRedis(host='193.168.3.20',port=6379,decode_responses=True)

#默認redis入庫編碼是utf-8，若是要修改的話，須要指明 charset 和 decode_responsers 爲True
#test = redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None)

red.lpush('list1','mongdb','redis','mysql')
print(r.lrange('list1',0,-1))
print(r.llen('list1'))

以上實例輸出的結果

www.qi.cn
['mysql', 'redis', 'mongdb']
3

鏈接池：

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/16 14:16
# @Author  : yangyuanqiang
# @File    : demon1.py


import redis
#建立鏈接池
pool = redis.ConnectionPool(host='192.168.3.20',port=6379,decode_responses=True)
#建立連接對象
r=redis.Redis(connection_pool=pool)
#設置集合
r.sadd('set1','v1','v2','v3')
r.sadd('set1','v2')
#顯示集合的值
print(r.smembers('set1'))

#使用strictRedis鏈接池
rs = redis.StrictRedis(connection_pool=pool)
r.lpush('l1','python','memcache','redis','mongodb')
print(r.lrange('l1',0,-1))

以上實例輸出的結果

{'v3', 'v1', 'v2'}
['mongodb', 'redis', 'memcache', 'python']

關於編碼

class redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None)
# 默認redis入庫編碼是utf-8，若是要修改的話，須要指明 charset 和 decode_responsers 爲True. 下面是GBK編碼。
 
class  redis.StrictRedis (host='localhost', port=6379, db=0, password=None, socket_timeout=None,connection_pool=None,  charset='GBK ' , errors='strict',  decode_responses=True)

（1）數據string操做

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

set key value [EX seconds] [PX milliseconds] [NX|XX]

參數：

ex，過時時間（秒）

px，過時時間（毫秒）

nx，若是設置爲 True ，則只有name不存在時，當前 set 操做才執行

xx，若是設置爲 True ，則只有name存在時，崗前 set 操做才執行

import redis
#建立鏈接池
pool = redis.ConnectionPool(host='192.168.3.20',port=6379,decode_responses=True)
#建立連接對象
r=redis.Redis(connection_pool=pool)
r.set('test','dddddddddddd',ex=3,nx=True)
print(r.get('test'))

以上實例輸出的結果

dddddddddddd

setnx(name,value)：設置值，只有在name不存在是才執行操做

setex(name,value,time)：設置值過時時間，單位爲秒

psetex(name,time_ms,value)：設置值，過時時間爲毫秒

mset(*args,**kwargs)：批量設置多個值

get(name)：獲取值

getrange(key,start,end)：獲取子序列,根據字節獲取

setrange(name,oofset,value)：修改字符串內容，從指定字符串索引開始向後替換

import redis
#建立鏈接池
pool = redis.ConnectionPool(host='192.168.3.20',port=6379,decode_responses=True)
#建立連接對象
r=redis.Redis(connection_pool=pool)
r.set('test','12345',nx=True)
r.setrange('test',0,'8888')
print(r.get('test'))

以上實例輸出的結果

8888888888888

setbit(name,offset,value)：對name對應值的二進制表示的位進行操做

getbit(name,offset)：獲取name對應的二進制位表示的值，只能是0或1

import redis
r=redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.set('name','p')
print(r.get('name'))
#打印p,q對應的ascii碼
print(ord('p'),ord('q'))
#打印ascii碼對應的二進制
print(bin(ord('p')),bin(ord('q')))
print('修改前7位的值：',r.getbit('name','7'))
#設置二進制位的第7位爲1，至關於移動ascii碼位112爲113對應的字符爲q
r.setbit('name','7','1')
print('修改後7位的值：',r.getbit('name','7'))
print(r.get('name'))

以上實例輸出的結果

p
112 113
0b1110000 0b1110001
修改前7位的值： 0
修改後7位的值： 1
q

strlen(name)：返回name對應值的字節長度，一個漢字3個字節

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.set('name','python')
print(r.strlen('name'))  #輸出6個字節

incr(self,name,amount=1)：自增name對應的值，當name不存在時，則建立name=amount，不然自增

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
#r.set('name','python')
r.set('age','1')
print(r.incr('age','3')) #結果爲4

decr(self,name,amount=1)：自減 name對應的值，當name不存在時，則建立name＝amount，不然，則自減

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)

r.set('age','10')
print(r.decr('age','3'))  #輸出爲7

append(key,value)：在name對應的值後面追加內容

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.set('age','10')
print(r.get('age'))
print(r.append('age','11'))
print(r.get('age'))

以上實例輸出的結果

10
4
1011

（2）hash操做

hset(name,key,value)：在name對應的hash中設置一個鍵值對，不存在則建立不然修改

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hset('haset','python','3.5')
print(r.hget('haset','python'))
r.hset('haset','redis','1.8')
print(r.hgetall('haset'))

以上實例輸出的結果

3.5
{'python': '3.5', 'redis': '1.8'}

hmset(name,mapping)：在name對應的hash中批量設置鍵值對

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hmget('hashmore','k1','k2','k3'))
print(r.hgetall('hashmore'))

以上實例輸出的結果

['v1', 'v2', 'v3']
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

hget(name,key)：獲取hash中的value

hmget(name,keys,*args)：獲取過個hash的key的值

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

hlen(name)：獲取hash中鍵值對的個數

hkeys(name)：獲取hash中全部keys的值

hvals(name):獲取hash中全部value的值

hexists(name,key)：檢查hash中是否存在key

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hmget('hashmore','k1','k2','k3'))
print(r.hgetall('hashmore'))
print(r.hexists('hashmore','k2'))
print(r.hexists('hashmore','k4'))

以上實例輸出的結果

['v1', 'v2', 'v3']
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
True
False

hdel(name,*key)：刪除hash中的key

import redis
r= redis.Redis(host='192。168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'})
print(r.hgetall('hashmore'))
print(r.hdel('hashmore','k3'))
print(r.hgetall('hashmore'))

以上實例輸出的結果

{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
1
{'k1': 'v1', 'k2': 'v2'}

hincrby(name,key,amount=1)：自增hash中指定的key的值，不存在則建立key=amount

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3'})
print(r.hgetall('hashmore'))
r.hincrby('hashmore','k1','2')
print(r.hgetall('hashmore'))

以上實例輸出的結果

{'k1': '1', 'k2': '2', 'k3': '3'}
{'k1': '3', 'k2': '2', 'k3': '3'}

hincrbyfloat(name,key,amount=1.0)：自增hash中指定的key的值，同上針對浮點數

hscan(name,cursor=0,match=None,count=None)：增量迭代獲取hash中數據，cursor遊標，match匹配key默認全部，count獲取的個數。

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4'})
print(r.hgetall('hashmore'))
print(r.hscan('hashmore',cursor=2,match='k2',count=1))
print(r.hscan('hashmore',count=4))

以上實例輸出的結果

{'k1': '1', 'k2': '2', 'k3': '3', 'k4': '4'}
(0, {'k2': '2'})
(0, {'k1': '1', 'k2': '2', 'k3': '3', 'k4': '4'})

hscan_iter(name,match=None,count=None)：利用yield封裝hscan建立生成器，實現分批獲取數據

import redis
r= redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4','k5':'5','k6':'6','k7':'7','k8':'8'})
oo = r.hscan_iter('hashmore')
print(next(oo))
print(next(oo))
print(next(oo))
print(next(oo))

以上實例輸出的結果

('k1', '1')
('k2', '2')
('k3', '3')
('k4', '4')

（3）list操做

lpush(name,values)：在列表中添加元素，每一個新元素都從左邊開始添加

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.lpush('l3',1,2)
print(r.lrange('l3',0,-1))
r.lpush('l3','88')
print(r.lrange('l3',0,-1))

以上實例輸出的結果

['2', '1']
['88', '2', '1']

lpushx(name,value)：在列表中添加元素，只有在name存在時才添加

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.lpushx('l4',1)
print(r.lrange('l4',0,-1))
r.lpush('l4',2)
r.lpushx('l4',1)
print(r.lrange('l4',0,-1))

以上實例輸出的結果

[]
['1', '2']

llen(name)：name對應的list元素的長度

linsert(name,where,refvalue,value)：在name對應的列表的某個值前或後插入一個新值，where指定前或後(befor/after)，refvalue參考值即指定的元素，value要插入的值

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.lpush('num','1','2')
r.linsert('num','after','2','python')#在2後面添加python元素值
r.linsert('num','before','1','redis') #在1以前插入redis
print(r.lrange('num',0,-1))

以上實例輸出的結果

['2', 'python', 'redis', '1']

lset(name,index,value)：對列表中的某個索引位的值修改

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
print(r.lrange('num',0,-1))
r.lset('num','0','hello')
print(r.lrange('num',0,-1))

以上實例輸出的結果

['2', 'python', 'redis', '1']
['hello', 'python', 'redis', '1']

lrem(name,value,num)：在name對應的list中刪除指定的值

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
print(r.lrange('num',0,-1))
r.lrem('num','1','2')   #2爲num指定的值的個數,能夠指定-2從後往前刪除
print(r.lrange('num',0,-1))

以上實例輸出的結果

['hello', 'python', 'redis', '1']
['hello', 'python', 'redis']

lpop(name)：在name對應的列表的左側獲取第一個元素並刪除，並返回參數的元素

lindex(name,index)：在name對應的列表中根據索引獲取列表元素

ltrim(name,start,end)：在name對應的列表中移除start到end之間的值

lrange(name,start,end)：列表分片獲取數據

rpoplush(src,dst):獲取源列表最後一個元素的值，並將它添加到目標列表中的最左邊

blpop(keys,timeout)：將多個列表排列，按照從左到右去pop對應列表的元素

brpoplpush(src,dst,timeout=0)：從一個列表的右側移除一個元素並將其添加到另外一個列表的左側

（4）set操做

sadd(name,values)：添加元素到集合

scard(name)：獲取集合中元素的個數

sdiff(keys,*args)：在第一個集合中的元素且不在其餘集合的元素的集合

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.sadd('s1',1,2,3)
r.sadd('s2',4,5,2)
r.sadd('s3',7,8,1)
print(r.sdiff('s1','s2','s3'))

以上實例輸出的結果

{'3'}

sdiffstore(dest,keys,*args)：在第一個keys中的集合元素且不在其餘集合中的元素添加到dest新集合中

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
# r.sadd('s1',1,2,3)
# r.sadd('s2',4,5,2)
# r.sadd('s3',7,8,1)
print(r.sdiffstore('s4','s1','s2','s3'))
print(r.smembers('s4'))

以上實例輸出的結果

1
{'3'}

sinter(keys,*args)：獲取多個集合的並集

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.sadd('s1',1,2,3)
r.sadd('s2',4,5,2)
print(r.sinter('s1','s2'))

以上實例輸出的結果

{'2'}

interstore(dest,keys,*args)：獲取多個集合的並集並將結果加入到dest集合中

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.sadd('sex1',1,2,3,4)
r.sadd('sex2',4,5,2,7)
r.sadd('sex3',7,8,1,4,2)
r.sinterstore('sex4','sex1','sex2','sex3')
print(r.smembers('sex4'))

以上實例輸出的結果

{'2', '4'}

sismember(name,value)：檢查value是否在集合中

import redis
r = redis.Redis(host='192.168.3.20',port=6379,decode_responses=True)
r.sadd('sex3',7,8,1,4,2)
print(r.sismember('sex3','8'))

以上實例輸出的結果

True

smembers(name)：獲取集合的全部成員

smove(src,dst,value)：將源集合中的某個成員移動到目標集合中

spop(name)：從集合的右側（尾部）移除一個成員，並將其返回

srandmember(name,numbers)：從name對應的集合中隨機獲取 numbers 個元素

srem(name,values)：在name對應的集合中刪除某些值

sunion(keys,*args)：並集顯示多個集合元素

sunionstore(dest,keys,*args)：獲取多一個name對應的集合的並集，並將結果保存到dest對應的集合中

sscan(name,cursor=0,match=None,count=None)：同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大

sscan_iter(name,match=None,count=None)：同字符串的操做，用於增量迭代分批獲取元素，避免內存消耗太大

5）有序集合操做

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

zadd(name,*args,**kwargs)：在name對應的有序集合中添加元素
zcard(name)：獲取name對應的有序集合元素的數量
zcount(name,min,max)：獲取name對應的有序集合中分數在 [min,max] 之間的個數
zincrby(name,value,amount)：自增name對應的有序集合的 name 對應的分數
r.zrange(name, start, end, desc=False, withscores=Flase, score_cast_func=float)：按照索引範圍獲取name對應的有序集合的元素
zrank(name, value)：獲取某個值在 name對應的有序集合中的排行（從 0 開始）
zrangebylex(name, min, max, start=None, num=None)：當有序集合的全部成員都具備相同的分值時，有序集合的元素會根據成員的值
zrem(name, values)：刪除name對應的有序集合中值是values的成員
zremrangebyrank(name, min, max)：根據排行範圍刪除
zremrangebyscore(name, min, max)：根據分數範圍刪除
zremrangebylex(name, min, max)：根據值返回刪除
zscore(name, values)：獲取name對應有序集合中 value 對應的分數
zinterstore(dest, keys, aggregate=None)：獲取兩個有序集合的交集，若是遇到相同值不一樣分數，則按照aggregate進行操做
zunionstore(dest, keys, aggregate=None)：獲取兩個有序集合的並集，若是遇到相同值不一樣分數，則按照aggregate進行操做
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做
zscan_iter(name, match=None, count=None,score_cast_func=float)：同字符串類似，相較於字符串新增score_cast_func，用來對分數進行操做

（6）其餘操做

delete(*name)：根據刪除redis中的任意數據類型
exists(name)：檢測redis的name是否存在
keys(pattern='*')：根據模型獲取redis的name
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)：同字符串操做，用於增量迭代獲取key
scan_iter(match=None,count=None)：同字符串操做，用於增量迭代獲取key

三、python對redis管道操做

redis默認在執行每次請求都會建立（鏈接池申請連接）和斷開（歸還鏈接池）一次鏈接操做，若是想要再一次請求中指定多個命令，則可使用pipline實現一次請求指定多個命令，而且默認狀況下一次pipline是原子性操做。

import redis
 
pool = redis.ConnectionPool(host='0.0.0.0', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
 
r.set('name', 'python')
r.set('age', '18')
 
pipe.execute()

四、python對redis發佈與訂閱

demo：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/16 21:44
# @Author  : yangyuanqiang
# @File    : demo.py


import redis


class RedisHelper:
    '''類'''

    def __init__(self):
        # 連接
        self.__conn = redis.Redis(host='192.168.3.20')
        self.chan_sub = 'fm104.5'
        # 建立頻道
        self.chan_pub = 'fm104.5'

    def public(self, info):
        '''公共的'''
        self.__conn.publish(self.chan_pub, info)
        '''將內容發佈到頻道'''
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub

發佈者：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/16 21:46
# @Author  : yangyuanqiang
# @File    : fbz.py


#導入模塊
# from redis_demo.demo import RedisHelper
from day19.demo import RedisHelper
#實例化
obj = RedisHelper()
#把內容發佈到頻道
obj.public('python')

訂閱者：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2018/5/16 21:47
# @Author  : yangyuanqiang
# @File    : dyz.py


# from redis_demo.demo import RedisHelper
from day19.demo import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)
    print(type(msg))

運行方式：

　　　　先啓動demo, 啓動訂閱者，啓動發佈者，訂閱者接受消息。

總結：一、熟悉redis基礎命令，redis用的最可能是hash操做

相關標籤/搜索

每日一句

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