C語言基礎學習PYTHON——基礎學習D11

20180908內容綱要：

1、RabbitMQ消息隊列

(1)RabbitMQ安裝

(2)Rabbits示例

模式一：fanout

模式二：direct

模式三：topic

Remote Procedure Call(RPC)

2、Redis緩存

(1)連接方式

(2)連接池

(3)操作

1、string操作

2、hash操作

3、list操作

4、set集合操作

5、其他常用操作

(4)發布訂閱

3、小結

4、練習

1 RabbitMQ消息隊列

MQ全稱為MessageQueue,消息隊列(MQ)是一種應用程序對應用程序的通信方法。應用程序通過寫和檢索出入列隊的針對應用程序的數據(消息)來通信，而無需專用連接來鏈接它們。消息傳遞指的是程序之間通過在消息中發送數據進行通信，而不是通過直接調用彼此來通信，直接調用通常是用于諸如遠程過程調用的技術。排隊指的是應用程序通過隊列來通信。隊列的使用除去了接收和發送應用程序同時執行的要求。

MQ的消費-生產者模型的一個典型的代表，一端往消息隊列中不斷的寫入消息，而另一端則可以讀取或者訂閱隊列中的消息。

RabbitMQ的結構圖如下：

Broker：簡單來說就是消息隊列服務器實體。

Exchange：消息交換機，它指定消息按什么規則，路由到哪個隊列。

Queue：消息隊列載體，每個消息都會被投入到一個或多個隊列。

Binding：綁定，它的作用就是把exchange和queue按照路由規則綁定起來。

Routing Key：路由關鍵字，

exchange根據這個關鍵字進行消息投遞。

vhost：虛擬主機，一個broker里可以開設多個vhost，用作不同用戶的權限分離。

producer：消息生產者，就是投遞消息的程序。

consumer：消息消費者，就是接受消息的程序。

channel：消息通道，在客戶端的每個連接里，可建立多個channel，每個channel代表一個會話任務。

當然，也有其他消息隊列，比如ZeroMQ、ActiveMQ等。

(1)RabbitMQ的安裝

首先，因為RabbitMQ由ERLANG實現，下載ERLANG 源代碼。

然后，下載RabbitMQ。

在windows安裝中可能會出現這樣的問題：RabbitMQ報錯Error: unable to connect to node rabbit@xxx: nodedown

(2)RabbitMQ基本示例

a、消息分發輪詢

1 #Author：ZhangKanghui

2

3 importpika4

5 #建立一個簡單的socket

6 connection =pika.BlockingConnection(7 pika.ConnectionParameters('localhost')8 )9 #聲明一個管道

10 channel =connection.channel()11

12 #聲明queue

13 channel.queue_declare(queue="hello")14

15 channel.basic_publish(exchange="",16 routing_key='hello', #queue名字

17 body='Hello world',)18

19 print("[x] send 'hello world'")20 connection.close()

RabbitMQ_send

1 #Author：ZhangKanghui

2

3 importpika4 importtime5

6 #建立一個簡單的socket

7 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))8 #聲明一個管道

9 channel =connection.channel()10

11 #you may ask why declare the queue again?

12 #we could avoid that if we were sure that the queue already exits.

13 #如果接受端先啟動不會報錯，如果沒有聲明，先啟動發送端在啟動接受端不會出錯。但是如果先啟動接受端就會有問題

14 channel.queue_declare(queue="hello")15

16 defcallback(ch,method,properties, body):17 #這個callback函數中的四個參數分別是什么呢？我們打印一下

18 print("--->>>",ch,method,properties,body)19 time.sleep(30)20 print("[x] Received %r"%body)21 ch.basic_ack(delivery_tag=method.delivery_tag)22

23 channel.basic_qos(prefetch_count=1)24 channel.basic_consume(callback, #消費消息。如果收到消息就調用callback，

25 queue='hello',26 no_ack=True) #No acknowledgement

27 #如果一個發送端，多個接受端呢？

28 #如果no_ack存在，當消息正在處理的過程中接受端斷開，消息就會丟失。發送端發送的數據就會刪除。

29 #如果no_ack不存在，發送端就會等待接受端處理完畢的指令。如果此時接受端1斷開，那么就由2接收，如果都斷開，

30 #那么數據會一直存儲在發送端，直至有新的接受端出現，并且發送端收到接受端數據處理完畢的指令，數據才會在發送端被刪除

31

32 print('[*] waiting for message .To exit')33 channel.start_consuming()

RabbitMQ_receive

在實現一個消費者對應一個生產者，那能不能一對多呢？

在一個生產者對應多個消費者的時候，生產者發出的消息會根據啟動順序依次被消費者接收。即消息分發輪詢。

如果no_ack存在，當消息正在處理的過程中接受端斷開，消息就會丟失。發送端發送的數據就會刪除；

如果no_ack不存在，發送端就會等待接受端處理完畢的指令。如果此時接受端1斷開，那么就由2接收，如果都斷開；

那么數據會一直存儲在發送端，直至有新的接受端出現，并且發送端收到接受端數據處理完畢的指令，數據才會在發送端被刪除。

Message acknowledgments are turned on by default. In previous examples we explicitly turned them off via the?no_ack=True?flag.

消息確認在默認情況下是打開的。在前面的示例中，我們通過no_ack=True標志顯式地關閉了它們。

It's time to remove this flag and send a proper acknowledgment from the worker, once we're done with a task.

當我們完成一項任務時，是時候移除此標志并從工作人員發送適當的確認信息了。

如果客戶端突然斷開，數據則會丟失，為了防止數據丟失需要下面一段代碼：

1 defcallback(ch,method,properties, body):2 print("--->>>",ch,method,properties,body)3 time.sleep(30)4 print("[x] Received %r"%body)5 ch.basic_ack(delivery_tag=method.delivery_tag)

ch.basic_ack(delivery_tag=method.delivery_tag)

b、消息持久化

在RabbitMQ的安裝路徑下C:\Program Files\RabbitMQ Server\rabbitmq_server-3.6.5\sbin>在sbin文件夾中rabbit的一些指令

比如rabbitmqctl.bat list_queues可以查詢存在的隊列消息等。

那么客戶端的斷開會發生數據丟失，通過確認函數來保證數據不會丟失。那么如果服務器端斷開呢？數據一樣會丟失。

為了防止服務器端斷開導致數據丟失，我們需要以下兩步：

durable隊列持久化　　　　　　delievery消息持久化

1、首先要進行聲明。

channel.queue_declare(queue='hello', durable=True)

2、雖然在這里聲明，但并不能真的持久，還需這樣。

channel.queue_declare(queue='task_queue', durable=True)

這樣，即使RabbitMQ重新啟動，task_queue隊列也不會丟失。

1 channel.basic_publish(exchange='',2 routing_key="task_queue",3 body=message,4 properties=pika.BasicProperties(5 delivery_mode = 2, #make message persistent

6 ))

消息持久化

c、消息公平分發

如果Rabbit只管按順序把消息發到各個消費者身上，不考慮消費者負載的話，很可能出現，一個機器配置不高的消費者那里堆積了很多消息處理不完，同時配置高的消費者卻一直很輕松。那么解決辦法？

channel.basic_qos(prefetch_count=1)

這行代碼只需加入到消費者端即可。

1 #Author：ZhangKanghui

2

3 importpika4 importtime5

6 #建立一個簡單的socket

7 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))8 #聲明一個管道

9 channel =connection.channel()10

11 #you may ask why declare the queue again?

12 #we could avoid that if we were sure that the queue already exits.

13 #如果接受端先啟動不會報錯，如果沒有聲明，先啟動發送端在啟動接受端不會出錯。但是如果先啟動接受端就會有問題

14 channel.queue_declare(queue="hello")15

16 defcallback(ch,method,properties, body):17 #這個callback函數中的四個參數分別是什么呢？我們打印一下

18 print("--->>>",ch,method,properties,body)19 time.sleep(30)20 print("[x] Received %r"%body)21 ch.basic_ack(delivery_tag=method.delivery_tag)22

23 channel.basic_qos(prefetch_count=1) #消息分發

24 channel.basic_consume(callback, #消費消息。如果收到消息就調用callback，

25 queue='hello',26 no_ack=True) #No acknowledgement

27 #如果一個發送端，多個接受端呢？

28 #如果no_ack存在，當消息正在處理的過程中接受端斷開，消息就會丟失。發送端發送的數據就會刪除。

29 #如果no_ack不存在，發送端就會等待接受端處理完畢的指令。如果此時接受端1斷開，那么就由2接收，如果都斷開，

30 #那么數據會一直存儲在發送端，直至有新的接受端出現，并且發送端收到接受端數據處理完畢的指令，數據才會在發送端被刪除

31

32 print('[*] waiting for message .To exit')33 channel.start_consuming()

持久化+消息分發

d、消息發布/訂閱

如果服務器發出一條消息，是否所有的客戶端都能收到消息呢？

Exchange在定義的時候是有類型的，以決定到底是哪些Queue符合條件，可以接收消息。

fanout:所有bind到此exchange的queue都可以接收消息；direct:通過routingKey和exchange決定的那個唯一的queue可以接收消息；topic:所有符合routingKey(此時可以是一個表達式)的routingKey所bind的queue可以接收消息；

headers: 通過headers 來決定把消息發給哪些queue　　　　這個不常用。

表達式符號說明：#代表一個或多個字符，*代表任何字符? ? ? 例：#.a會匹配a.a，aa.a，aaa.a等? ? ? ? ? *.a會匹配a.a，b.a，c.a等

模式一：fanout廣播

1 #Author：ZhangKanghui

2

3 importpika4 importsys5

6 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='logs',10 type='fanout')11 message = ''.join(sys.argv[1:]) or "info:hello world！"

12 channel.basic_publish(exchange='logs',13 routing_key='',14 body =message)15 print("[x] send %r"%message)16 connection.close()

fanout_publisher

1 #Author：ZhangKanghui

2

3 importpika4

5 connection =pika.BlockingConnection(pika.ConnectionParameters(6 host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='logs',10 type='fanout')11 result = channel.queue_declare(exclusive=True) #exclusive排他的，唯一的

12 #在這里聲明隊列的原因？

13 #不指定queue的名字，rabbit會隨機分配一個名字，exclusive=True會使次queue的消費者斷開后，自動將queue刪除

14 queue_name =result.method.queue15 print(queue_name)16

17 channel.queue_bind(exchange='logs',18 queue=queue_name)19 print('[*] waiting for logs.to exit')20

21 defcallback(ch,method,properties,body):22 print("[x] %r"%body)23

24

25 channel.basic_consume(callback,26 queue=queue_name,27 no_ack=True)28 channel.start_consuming()

fanout_subscriber

模式二：direct有選擇的接收消息

1 #Author：ZhangKanghui

2

3 importpika4 importsys5

6 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='logs',10 type='direct')11

12 severity = sys.argv[1:] if len(sys.argv) > 1 else 'info'

13 message = ''.join(sys.argv[2:]) or "info:hello world！"

14

15 channel.basic_publish(exchange='direct_logs',16 routing_key=severity,17 body =message)18 print("[x] send %r:%r"%(severity,message))19 connection.close()

direct_publisher

1 #Author：ZhangKanghui

2

3 importpika4 importsys5

6 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='direct_logs',10 type='direct')11 result = channel.queue_declare(exclusive=True)12 queue_name =result.method.queue13

14 severities = sys.argv[1:]15 if notseverities:16 sys.stderr.write("usage:%s [info] [warining] [error]\n"%sys.argv[0])17 sys.exit(1)18 print(severities)19 for severity inseverities:20 channel.queue_bind(exchange='direct_logs',21 queue=queue_name,22 routing_key=severity)23 channel.basic_consume(callback,24 queue=queue_name,25 no_ack=True)26 channel.start_consuming()

direct_subscriber

模式三：topic更細致的消息過濾

*.orange.*所有中間包含orange

*.*.rabbit所有以rabbit結尾的

lazy.#所有以lazy開頭的

1 #Author：ZhangKanghui

2

3 importpika4 importsys5

6 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='topic_logs',10 type='topic')11

12 routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous info'

13 message = ''.join(sys.argv[2:]) or "info:hello world！"

14 channel.basic_publish(exchange='direct_logs',15 routing_key=routing_key,16 body =message)17 print("[x] send %r:%r"%(routing_key,message))18 connection.close()

topic_publisher

1 #Author：ZhangKanghui

2

3 importpika4 importsys5

6 connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))7 channel =connection.channel()8

9 channel.exchange_declare(exchange='topic_logs',10 type='topic')11

12 result = channel.queue_declare(exclusive=True)13 queue_name =result.method.queue14

15 binding_keys = sys.argv[1:]16 if notbinding_keys:17 sys.stderr.write("Usage:%s [binding_key] ...\n"%sys.argv[0])18 sys.exit(1)19

20 print("[*] waiting for logs .to exit")21

22 defcallback(ch,method,propertities,body):23 print("[x] %r:%r"%(method.routing_key,body))24

25 channel.basic_consume(callback,26 queue=queue_name,27 no_ack=True)28 channel.start_consuming()

topic_subscriber

To receive all the logs run:

python receive_logs_topic.py "#"

To receive all logs from the facility "kern":

python receive_logs_topic.py "kern.*"

Or if you want to hear only about "critical" logs:

python receive_logs_topic.py "*.critical"

You can create multiple bindings:

python receive_logs_topic.py "kern.*" "*.critical"

And to emit a log with a routing key "kern.critical" type:

python emit_log_topic.py "kern.critical" "A critical kernel error"

Remote procedure call (RPC)遠程過程調用

RPC(Remote?Procedure?Call Protocol)——遠程過程調用協議，它是一種通過網絡從遠程計算機程序上請求服務，而不需要了解底層網絡技術的協議。該協議允許運行于一臺計算機的程序調用另一臺計算機的子程序，而程序員無需額外地為這個交互作用編程。RPC協議假定某些傳輸協議的存在，如TCP或UDP，為通信程序之間攜帶信息數據。在OSI網絡通信模型中，RPC跨越了傳輸層和應用層。RPC使得開發包括網絡分布式多程序在內的應用程序更加容易。

.

1 #Author：ZhangKanghui

2

3 importpika4 importtime5

6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))7 channel =connection.channel()8 channel.queue_declare(queue='rpc_queue')9

10 deffib(n):11 if n ==0:12 return013 elif n == 1:14 return 1

15 else:16 return fib(n-1) + fib(n-2)17

18 defon_request(ch,method,props,body):19 n =int(body)20 print("[.] fib (%s)"%n)21 reponse =fib(n)22 ch.basic_publish(exchange='',23 routing_key=props.rely_to,24 properties=pika.BasicProperties(correlation_id=props.correlation_id),25 body=str(reponse))26 ch.basic_ack(delivery_tag=method.delivery_tag)27

28 channel.basic_qos(prefetch_count=1)29 channel.basic_consume(on_request,queue='rpc_queue')30

31 print("[x] waiting rpc request")32 channel.start_consuming()

rpc_server

1 #Author：ZhangKanghui

2

3 importpika4 importuuid5 importtime6

7 classFibonacciRpcClient(object):8 def __init__(self):9 self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))10 self.channel =self.connection.channel()11 result = self.channel.queue_declare(exclusive=True)12 self.callback_queue =result.method.queue13 self.channel.basic_consume(self.on_response,no_ack=True,queue=self.callback_queue)14

15 defon_response(self,ch,method,props,body):16 if self.corr_id ==props.correlation_id:17 self.response =body18

19 defcall(self,n):20 self.response =None21 self.corr_id =str(uuid.uuid4())22 self.channel.basic_publish(exchange='',23 routing_key='rpc_queue',24 properties=pika.BasicProperties(reply_to=self.callback_queue,25 correlation_id=self.corr_id),26 body=str(n))27 while self.response isNone:28 self.connection.process_data_events() #相當于非阻塞的start_consuming

29 print("no msg...")30 time.sleep(0.5)31 returnint(self.response)32

33 fibonacci_rpc =FibonacciRpcClient()34

35 print("[x] Requesting fib (30)")36 reponse = fibonacci_rpc.call(30)37 print("[.] Got %r"% reponse)

rpc_client

2 Redis緩存

Redis是一個Key-Value存儲系統。和Memcached類似，它支持存儲的value類型相對更多。

包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set --有序集合)和hash(哈希類型)。

這些數據類型都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支持各種不同方式的排序。

與memcached一樣，為了保證效率，數據都是緩存在內存中。

區別的是redis會周期性的把更新的數據寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎上實現了master-slave(主從)同步。

memcached 的使用：

Windows下安裝Redis教程：

(1)連接方式

redis-py提供兩個類Redis和StrictRedis用于實現Redis的命令，StrictRedis用于實現大部分官方的命令，并使用官方的語法和命令.

Redis是StrictRedis的子類，用于向后兼容舊版本的redis-py。

#Author：ZhangKanghui

importredis

r= redis.Redis(host='localhost',port=6379)

r.set('foo','bar')

r.get('foo')print(r.get('foo'))

redis_connection

(2) 連接池

redis-py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認，每個Redis實例都會維護一個自己的連接池。

可以直接建立一個連接池，然后作為參數Redis，這樣就可以實現多個Redis實例共享一個連接池。

1 #Author：ZhangKanghui

2

3 importredis4

5 pool = redis.ConnectionPool(host='localhost',port=6379)6

7 r = redis.Redis(connection_pool=pool)8 r.set('foo','bar')9 r.get('foo')10 print(r.get('foo'))

redis_connection pool

(3) 操作

1、string操作

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

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

1 在Redis中設置值，默認，不存在則創建，存在則修改2 參數：3 ex，過期時間(秒)4 px，過期時間(毫秒)5 nx，如果設置為True，則只有name不存在時，當前set操作才執行6 xx，如果設置為True，則只有name存在時，崗前set操作才執行

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

setnx(name, value)

1 設置值，只有name不存在時，執行設置操作(添加)

setnx(name, value)

setex(name, value, time)

1 #設置值

2 #參數：

3 #time，過期時間(數字秒 或 timedelta對象)

setex(name, value, time)

psetex(name, time_ms, value)

1 #設置值

2 #參數：

3 #time_ms，過期時間(數字毫秒 或 timedelta對象)

psetex(name, time_ms, value)

mset(*args, **kwargs)

1 批量設置值2 如：3 mset(k1='v1', k2='v2')4 或5 mget({'k1': 'v1', 'k2': 'v2'})

mset(*args, **kwargs)

get(name)

1 獲取值

get(name)

mget(keys, *args)

1 批量獲取2 如：3 mget('ylr', 'wupeiqi')4 或5 r.mget(['ylr', 'wupeiqi'])

mget(keys, *args)

getset(name, value)

1 設置新值并獲取原來的值

getset(name, value)

getrange(key, start, end)

getrange(key, start, end)

setrange(name, offset, value)

1 #修改字符串內容，從指定字符串索引開始向后替換(新值太長時，則向后添加)

2 #參數：

3 #offset，字符串的索引，字節(一個漢字三個字節)

4 #value，要設置的值

setrange(name, offset, value)

setbit(name, offset, value)

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

2

3 #參數：

4 #name，redis的name

5 #offset，位的索引(將值變換成二進制后再進行索引)

6 #value，值只能是 1 或 0

7

8 #注：如果在Redis中有一個對應： n1 = "foo"，

9 那么字符串foo的二進制表示為：01100110 01101111 01101111

10 所以，如果執行 setbit('n1', 7, 1)，則就會將第7位設置為1，11 那么最終二進制則變成 01100111 01101111 01101111，即："goo"

12

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

14

15 #source = "撒拉黑"

16 source = "foo"

17

18 for i insource:19 num =ord(i)20 print bin(num).replace('b','')21

22 特別的，如果source是漢字 "撒拉黑"怎么辦？23 答：對于utf-8，每一個漢字占 3 個字節，那么 "撒拉黑"則有 9個字節24 對于漢字，for循環時候會按照 字節 迭代，那么在迭代時，將每一個字節轉換 十進制數，然后再將十進制數轉換成二進制25 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

26 -------------------------- ----------------------------- -----------------------------

27 撒 拉 黑

setbit(name, offset, value)

getbit(name, offset)

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

getbit(name, offset)

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

1 #獲取name對應的值的二進制表示中 1 的個數

2 #參數：

3 #key，Redis的name

4 #start，位起始位置

5 #end，位結束位置

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

strlen(name)

1 #返回name對應值的字節長度(一個漢字3個字節)

strlen(name)

incr(self, name, amount=1)

1 #自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。

2

3 #參數：

4 #name,Redis的name

5 #amount,自增數(必須是整數)

6

7 #注：同incrby

incr(self, name, amount=1)

incrbyfloat(self, name, amount=1.0)

1 #自增 name對應的值，當name不存在時，則創建name＝amount，否則，則自增。

2

3 #參數：

4 #name,Redis的name

5 #amount,自增數(浮點型)

incrbyfloat(self, name, amount=1.0)

decr(self, name, amount=1)

1 #自減 name對應的值，當name不存在時，則創建name＝amount，否則，則自減。

2

3 #參數：

4 #name,Redis的name

5 #amount,自減數(整數)

decr(self, name, amount=1)

append(key, value)

1 #在redis name對應的值后面追加內容

2

3 #參數：

4 key, redis的name5 value, 要追加的字符串

append(key, value)

2、hash操作

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

hset(name, key, value)

1 #name對應的hash中設置一個鍵值對(不存在，則創建；否則，修改)

2

3 #參數：

4 #name，redis的name

5 #key，name對應的hash中的key

6 #value，name對應的hash中的value

7

8 #注：

9 #hsetnx(name, key, value),當name對應的hash中不存在當前key時則創建(相當于添加)

hset(name, key, value)

hmset(name, mapping)

1 #在name對應的hash中批量設置鍵值對

2

3 #參數：

4 #name，redis的name

5 #mapping，字典，如：{'k1':'v1', 'k2': 'v2'}

6

7 #如：

8 #r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hmset(name, mapping)

hget(name,key)

1 #在name對應的hash中獲取根據key獲取value

hget(name,key)

hmget(name, keys, *args)

1 #在name對應的hash中獲取多個key的值

2

3 #參數：

4 #name，reids對應的name

5 #keys，要獲取key集合，如：['k1', 'k2', 'k3']

6 #*args，要獲取的key，如：k1,k2,k3

7

8 #如：

9 #r.mget('xx', ['k1', 'k2'])

10 #或

11 #print r.hmget('xx', 'k1', 'k2')

hmget(name, keys, *args)

hgetall(name)

1 獲取name對應hash的所有鍵值

hgetall(name)

hlen(name)

1 #獲取name對應的hash中鍵值對的個數

hlen(name)

hkeys(name)

1 #獲取name對應的hash中所有的key的值

hkeys(name)

hvals(name)

1 #獲取name對應的hash中所有的value的值

hvals(name)

hexists(name, key)

1 #檢查name對應的hash是否存在當前傳入的key

hexists(name, key)

hdel(name,*keys)

1 #將name對應的hash中指定key的鍵值對刪除

hdel(name,*keys)

hincrby(name, key, amount=1)

1 #自增name對應的hash中的指定key的值，不存在則創建key=amount

2 #參數：

3 #name，redis中的name

4 #key， hash對應的key

5 #amount，自增數(整數)

hincrby(name, key, amount=1)

hincrbyfloat(name, key, amount=1.0)

1 #自增name對應的hash中的指定key的值，不存在則創建key=amount

2

3 #參數：

4 #name，redis中的name

5 #key， hash對應的key

6 #amount，自增數(浮點數)

7

8 #自增name對應的hash中的指定key的值，不存在則創建key=amount

hincrbyfloat(name, key, amount=1.0)

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

Start a full hash scan with:

HSCAN myhash 0

Start a hash scan with fields matching a pattern with:

HSCAN myhash 0 MATCH order_*

Start a hash scan with fields matching a pattern and forcing the scan command to do more scanning with:

HSCAN myhash 0 MATCH order_* COUNT 1000

1 #增量式迭代獲取，對于數據大的數據非常有用，hscan可以實現分片的獲取數據，并非一次性將數據全部獲取完，從而放置內存被撐爆

2

3 #參數：

4 #name，redis的name

5 #cursor，游標(基于游標分批取獲取數據)

6 #match，匹配指定key，默認None 表示所有的key

7 #count，每次分片最少獲取個數，默認None表示采用Redis的默認分片個數

8

9 #如：

10 #第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)

11 #第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)

12 #...

13 #直到返回值cursor的值為0時，表示數據已經通過分片獲取完畢

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

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

1 #利用yield封裝hscan創建生成器，實現分批去redis中獲取數據

2

3 #參數：

4 #match，匹配指定key，默認None 表示所有的key

5 #count，每次分片最少獲取個數，默認None表示采用Redis的默認分片個數

6

7 #如：

8 #for item in r.hscan_iter('xx'):

9 #print item

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

3、list操作

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

lpush(name,values)

1 #在name對應的list中添加元素，每個新的元素都添加到列表的最左邊

2

3 #如：

4 #r.lpush('oo', 11,22,33)

5 #保存順序為: 33,22,11

6

7 #擴展：

8 #rpush(name, values) 表示從右向左操作

lpush(name,values)

lpushx(name,value)

1 #在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊

2

3 #更多：

4 #rpushx(name, value) 表示從右向左操作

lpushx(name,value)

llen(name)

1 #name對應的list元素的個數

llen(name)

linsert(name, where, refvalue, value))

1 #在name對應的列表的某一個值前或后插入一個新值

2

3 #參數：

4 #name，redis的name

5 #where，BEFORE或AFTER

6 #refvalue，標桿值，即：在它前后插入數據

7 #value，要插入的數據

linsert(name, where, refvalue, value))

r.lset(name, index, value)

1 #對name對應的list中的某一個索引位置重新賦值

2

3 #參數：

4 #name，redis的name

5 #index，list的索引位置

6 #value，要設置的值

r.lset(name, index, value)

r.lrem(name, value, num)

1 #在name對應的list中刪除指定的值

2

3 #參數：

4 #name，redis的name

5 #value，要刪除的值

6 #num， num=0，刪除列表中所有的指定值；

7 #num=2,從前到后，刪除2個；

8 #num=-2,從后向前，刪除2個

r.lrem(name, value, num)

lpop(name)

1 #在name對應的列表的左側獲取第一個元素并在列表中移除，返回值則是第一個元素

2

3 #更多：

4 #rpop(name) 表示從右向左操作

lpop(name)

lindex(name, index)

1 在name對應的列表中根據索引獲取列表元素

lindex(name, index)

lrange(name, start, end)

1 #在name對應的列表分片獲取數據

2 #參數：

3 #name，redis的name

4 #start，索引的起始位置

5 #end，索引結束位置

lrange(name, start, end)

ltrim(name, start, end)

1 #在name對應的列表中移除沒有在start-end索引之間的值

2 #參數：

3 #name，redis的name

4 #start，索引的起始位置

5 #end，索引結束位置

ltrim(name, start, end)

rpoplpush(src, dst)

1 #從一個列表取出最右邊的元素，同時將其添加至另一個列表的最左邊

2 #參數：

3 #src，要取數據的列表的name

4 #dst，要添加數據的列表的name

rpoplpush(src, dst)

blpop(keys, timeout)

1 #將多個列表排列，按照從左到右去pop對應列表的元素

2

3 #參數：

4 #keys，redis的name的集合

5 #timeout，超時時間，當元素所有列表的元素獲取完之后，阻塞等待列表內有數據的時間(秒), 0 表示永遠阻塞

6

7 #更多：

8 #r.brpop(keys, timeout)，從右向左獲取數據

blpop(keys, timeout)

brpoplpush(src, dst, timeout=0)

1 #從一個列表的右側移除一個元素并將其添加到另一個列表的左側

2

3 #參數：

4 #src，取出并要移除元素的列表對應的name

5 #dst，要插入元素的列表對應的name

6 #timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間(秒)，0 表示永遠阻塞

brpoplpush(src, dst, timeout=0)

3、set集合操作

Set操作，Set集合就是不允許重復的列表

sadd(name,values)

1 #name對應的集合中添加元素

sadd(name,values)

scard(name)

1 獲取name對應的集合中元素個數

scard(name)

sdiff(keys, *args)

1 在第一個name對應的集合中且不在其他name對應的集合的元素集合

sdiff(keys, *args)

sdiffstore(dest, keys, *args)

1 #獲取第一個name對應的集合中且不在其他name對應的集合，再將其新加入到dest對應的集合中

sdiffstore(dest, keys, *args)

sinter(keys, *args)

1 #獲取多一個name對應集合的并集

sinter(keys, *args)

sinterstore(dest, keys, *args)

1 #獲取多一個name對應集合的并集，再講其加入到dest對應的集合中

sinterstore(dest, keys, *args)

sismember(name, value)

1 #檢查value是否是name對應的集合的成員

sismember(name, value)

smembers(name)

1 #獲取name對應的集合的所有成員

smembers(name)

smove(src, dst, value)

1 #將某個成員從一個集合中移動到另外一個集合

smove(src, dst, value)

spop(name)

1 #從集合的右側(尾部)移除一個成員，并將其返回

spop(name)

srandmember(name, numbers)

1 #從name對應的集合中隨機獲取 numbers 個元素

srandmember(name, numbers)

srem(name, values)

1 #在name對應的集合中刪除某些值

srem(name, values)

sunion(keys, *args)

1 #獲取多一個name對應的集合的并集

sunion(keys, *args)

sunionstore(dest,keys, *args)

1 #獲取多一個name對應的集合的并集，并將結果保存到dest對應的集合中

sunionstore(dest,keys, *args)

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

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

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

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

有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較

所以，對于有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。

zadd(name, *args, **kwargs)

1 #在name對應的有序集合中添加元素

2 #如：

3 #zadd('zz', 'n1', 1, 'n2', 2)

4 #或

5 #zadd('zz', n1=11, n2=22)

zadd(name, *args, **kwargs)

zcard(name)

1 #獲取name對應的有序集合元素的數量

zcard(name)

zcount(name, min, max)

1 #獲取name對應的有序集合中分數 在 [min,max] 之間的個數

zcount(name, min, max)

zincrby(name, value, amount)

1 #自增name對應的有序集合的 name 對應的分數

zincrby(name, value, amount)

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

1 #按照索引范圍獲取name對應的有序集合的元素

2

3 #參數：

4 #name，redis的name

5 #start，有序集合索引起始位置(非分數)

6 #end，有序集合索引結束位置(非分數)

7 #desc，排序規則，默認按照分數從小到大排序

8 #withscores，是否獲取元素的分數，默認只獲取元素的值

9 #score_cast_func，對分數進行數據轉換的函數

10

11 #更多：

12 #從大到小排序

13 #zrevrange(name, start, end, withscores=False, score_cast_func=float)

14

15 #按照分數范圍獲取name對應的有序集合的元素

16 #zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)

17 #從大到小排序

18 #zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

r.zrange

zrank(name, value)

1 #獲取某個值在 name對應的有序集合中的排行(從 0 開始)

2

3 #更多：

4 #zrevrank(name, value)，從大到小排序

zrank(name, value)

zrem(name, values)

1 #刪除name對應的有序集合中值是values的成員

2

3 #如：zrem('zz', ['s1', 's2'])

zrem(name, values)

zremrangebyrank(name, min, max)

1 #根據排行范圍刪除

zremrangebyrank(name, min, max)

zremrangebyscore(name, min, max)

1 #根據分數范圍刪除

zremrangebyscore(name, min, max)

zscore(name, value)

1 #獲取name對應有序集合中 value 對應的分數

zscore(name, value)

zinterstore(dest, keys, aggregate=None)

1 #獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作

2 #aggregate的值為: SUM MIN MAX

zinterstore(dest, keys, aggregate=None)

zunionstore(dest, keys, aggregate=None)

1 #獲取兩個有序集合的并集，如果遇到相同值不同分數，則按照aggregate進行操作

2 #aggregate的值為: SUM MIN MAX

zunionstore(dest, keys, aggregate=None)

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

zscan_iter(name, match=None, count=None,score_cast_func=float)

1 #同字符串相似，相較于字符串新增score_cast_func，用來對分數進行操作

zscan

4、常用其他操作

delete(*names)

1 #根據刪除redis中的任意數據類型

delete(*names)

exists(name)

1 #檢測redis的name是否存在

exists(name)

keys(pattern='*')

1 #根據模型獲取redis的name

2

3 #更多：

4 #KEYS * 匹配數據庫中所有 key 。

5 #KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。

6 #KEYS h*llo 匹配 hllo 和 heeeeello 等。

7 #KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

keys(pattern='*')

expire(name ,time)

1 #為某個redis的某個name設置超時時間

expire(name ,time)

rename(src, dst)

1 #對redis的name重命名為

rename(src, dst)

move(name, db))

1 #將redis的某個值移動到指定的db下

move(name, db))

randomkey()

1 #隨機獲取一個redis的name(不刪除)

randomkey()

type(name)

1 #獲取name對應值的類型

type(name)

scan(cursor=0, match=None, count=None)

scan_iter(match=None, count=None)

1 #同字符串操作，用于增量迭代獲取key

scan(cursor=0, match=None, count=None)

(4)發布訂閱

1 from monitor.RedisHelper importRedisHelper2

3 obj =RedisHelper()4 redis_sub =obj.subscribe()5

6 whileTrue:7 msg=redis_sub.parse_response()8 print msg

發布者

1 from monitor.RedisHelper importRedisHelper2

3 obj =RedisHelper()4 obj.public('hello')

訂閱者

3 小結

路漫漫其修遠兮，吾將上下而求索~!

真的是這樣，有好多事情，你不經歷過，真的是不知道有多niux！

間歇性躊躇滿志，持續性混吃等死。

4 練習

題目：rpc命令端

需求：

可以異步的執行多個命令

對多臺機器

作業是真的不會做。有機會有勇氣可以點進來看看：

我是尾巴~

這次推薦：如何用幾個簡單的命令改善你的Linux安全

雖不才，才要堅持。

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的c语言基础学python_D11——C语言基础学PYTHON的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。