C語言基礎(chǔ)學(xué)習(xí)PYTHON——基礎(chǔ)學(xué)習(xí)D11

20180908內(nèi)容綱要：

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)發(fā)布訂閱

3、小結(jié)

4、練習(xí)

1 RabbitMQ消息隊列

MQ全稱為MessageQueue,消息隊列(MQ)是一種應(yīng)用程序?qū)?yīng)用程序的通信方法。應(yīng)用程序通過寫和檢索出入列隊的針對應(yīng)用程序的數(shù)據(jù)(消息)來通信，而無需專用連接來鏈接它們。消息傳遞指的是程序之間通過在消息中發(fā)送數(shù)據(jù)進(jìn)行通信，而不是通過直接調(diào)用彼此來通信，直接調(diào)用通常是用于諸如遠(yuǎn)程過程調(diào)用的技術(shù)。排隊指的是應(yīng)用程序通過隊列來通信。隊列的使用除去了接收和發(fā)送應(yīng)用程序同時執(zhí)行的要求。

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

RabbitMQ的結(jié)構(gòu)圖如下：

Broker：簡單來說就是消息隊列服務(wù)器實(shí)體。

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

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

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

Routing Key：路由關(guān)鍵字，

exchange根據(jù)這個關(guān)鍵字進(jìn)行消息投遞。

vhost：虛擬主機(jī)，一個broker里可以開設(shè)多個vhost，用作不同用戶的權(quán)限分離。

producer：消息生產(chǎn)者，就是投遞消息的程序。

consumer：消息消費(fèi)者，就是接受消息的程序。

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

當(dāng)然，也有其他消息隊列，比如ZeroMQ、ActiveMQ等。

(1)RabbitMQ的安裝

首先，因為RabbitMQ由ERLANG實(shí)現(xiàn)，下載ERLANG 源代碼。

然后，下載RabbitMQ。

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

(2)RabbitMQ基本示例

a、消息分發(fā)輪詢

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 #如果接受端先啟動不會報錯，如果沒有聲明，先啟動發(fā)送端在啟動接受端不會出錯。但是如果先啟動接受端就會有問題

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

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

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, #消費(fèi)消息。如果收到消息就調(diào)用callback，

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

27 #如果一個發(fā)送端，多個接受端呢？

28 #如果no_ack存在，當(dāng)消息正在處理的過程中接受端斷開，消息就會丟失。發(fā)送端發(fā)送的數(shù)據(jù)就會刪除。

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

30 #那么數(shù)據(jù)會一直存儲在發(fā)送端，直至有新的接受端出現(xiàn)，并且發(fā)送端收到接受端數(shù)據(jù)處理完畢的指令，數(shù)據(jù)才會在發(fā)送端被刪除

31

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

RabbitMQ_receive

在實(shí)現(xiàn)一個消費(fèi)者對應(yīng)一個生產(chǎn)者，那能不能一對多呢？

在一個生產(chǎn)者對應(yīng)多個消費(fèi)者的時候，生產(chǎn)者發(fā)出的消息會根據(jù)啟動順序依次被消費(fèi)者接收。即消息分發(fā)輪詢。

如果no_ack存在，當(dāng)消息正在處理的過程中接受端斷開，消息就會丟失。發(fā)送端發(fā)送的數(shù)據(jù)就會刪除；

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

那么數(shù)據(jù)會一直存儲在發(fā)送端，直至有新的接受端出現(xiàn)，并且發(fā)送端收到接受端數(shù)據(jù)處理完畢的指令，數(shù)據(jù)才會在發(fā)送端被刪除。

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

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

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

當(dāng)我們完成一項任務(wù)時，是時候移除此標(biāo)志并從工作人員發(fā)送適當(dāng)?shù)拇_認(rèn)信息了。

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

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可以查詢存在的隊列消息等。

那么客戶端的斷開會發(fā)生數(shù)據(jù)丟失，通過確認(rèn)函數(shù)來保證數(shù)據(jù)不會丟失。那么如果服務(wù)器端斷開呢？數(shù)據(jù)一樣會丟失。

為了防止服務(wù)器端斷開導(dǎo)致數(shù)據(jù)丟失，我們需要以下兩步：

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

1、首先要進(jìn)行聲明。

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、消息公平分發(fā)

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

channel.basic_qos(prefetch_count=1)

這行代碼只需加入到消費(fèi)者端即可。

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 #如果接受端先啟動不會報錯，如果沒有聲明，先啟動發(fā)送端在啟動接受端不會出錯。但是如果先啟動接受端就會有問題

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

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

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) #消息分發(fā)

24 channel.basic_consume(callback, #消費(fèi)消息。如果收到消息就調(diào)用callback，

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

27 #如果一個發(fā)送端，多個接受端呢？

28 #如果no_ack存在，當(dāng)消息正在處理的過程中接受端斷開，消息就會丟失。發(fā)送端發(fā)送的數(shù)據(jù)就會刪除。

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

30 #那么數(shù)據(jù)會一直存儲在發(fā)送端，直至有新的接受端出現(xiàn)，并且發(fā)送端收到接受端數(shù)據(jù)處理完畢的指令，數(shù)據(jù)才會在發(fā)送端被刪除

31

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

持久化+消息分發(fā)

d、消息發(fā)布/訂閱

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

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

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

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

表達(dá)式符號說明：#代表一個或多個字符，*代表任何字符? ? ? 例：#.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會隨機(jī)分配一個名字，exclusive=True會使次queue的消費(fèi)者斷開后，自動將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更細(xì)致的消息過濾

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

*.*.rabbit所有以rabbit結(jié)尾的

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)遠(yuǎn)程過程調(diào)用

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

.

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() #相當(dāng)于非阻塞的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存儲系統(tǒng)。和Memcached類似，它支持存儲的value類型相對更多。

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

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

與memcached一樣，為了保證效率，數(shù)據(jù)都是緩存在內(nèi)存中。

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

memcached 的使用：

Windows下安裝Redis教程：

(1)連接方式

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

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的所有連接，避免每次建立、釋放連接的開銷。默認(rèn)，每個Redis實(shí)例都會維護(hù)一個自己的連接池。

可以直接建立一個連接池，然后作為參數(shù)Redis，這樣就可以實(shí)現(xiàn)多個Redis實(shí)例共享一個連接池。

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在在內(nèi)存中按照一個name對應(yīng)一個value來存儲。如圖：

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

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

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

setnx(name, value)

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

setnx(name, value)

setex(name, value, time)

1 #設(shè)置值

2 #參數(shù)：

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

setex(name, value, time)

psetex(name, time_ms, value)

1 #設(shè)置值

2 #參數(shù)：

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

psetex(name, time_ms, value)

mset(*args, **kwargs)

1 批量設(shè)置值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 設(shè)置新值并獲取原來的值

getset(name, value)

getrange(key, start, end)

getrange(key, start, end)

setrange(name, offset, value)

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

2 #參數(shù)：

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

4 #value，要設(shè)置的值

setrange(name, offset, value)

setbit(name, offset, value)

1 #對name對應(yīng)值的二進(jìn)制表示的位進(jìn)行操作

2

3 #參數(shù)：

4 #name，redis的name

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

6 #value，值只能是 1 或 0

7

8 #注：如果在Redis中有一個對應(yīng)： n1 = "foo"，

9 那么字符串foo的二進(jìn)制表示為：01100110 01101111 01101111

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

12

13 #擴(kuò)展，轉(zhuǎn)換二進(jìn)制表示：

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 個字節(jié)，那么 "撒拉黑"則有 9個字節(jié)24 對于漢字，for循環(huán)時候會按照 字節(jié) 迭代，那么在迭代時，將每一個字節(jié)轉(zhuǎn)換 十進(jìn)制數(shù)，然后再將十進(jìn)制數(shù)轉(zhuǎn)換成二進(jìn)制25 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

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

27 撒 拉 黑

setbit(name, offset, value)

getbit(name, offset)

1 #獲取name對應(yīng)的值的二進(jìn)制表示中的某位的值 (0或1)

getbit(name, offset)

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

1 #獲取name對應(yīng)的值的二進(jìn)制表示中 1 的個數(shù)

2 #參數(shù)：

3 #key，Redis的name

4 #start，位起始位置

5 #end，位結(jié)束位置

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

strlen(name)

1 #返回name對應(yīng)值的字節(jié)長度(一個漢字3個字節(jié))

strlen(name)

incr(self, name, amount=1)

1 #自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。

2

3 #參數(shù)：

4 #name,Redis的name

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

6

7 #注：同incrby

incr(self, name, amount=1)

incrbyfloat(self, name, amount=1.0)

1 #自增 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自增。

2

3 #參數(shù)：

4 #name,Redis的name

5 #amount,自增數(shù)(浮點(diǎn)型)

incrbyfloat(self, name, amount=1.0)

decr(self, name, amount=1)

1 #自減 name對應(yīng)的值，當(dāng)name不存在時，則創(chuàng)建name＝amount，否則，則自減。

2

3 #參數(shù)：

4 #name,Redis的name

5 #amount,自減數(shù)(整數(shù))

decr(self, name, amount=1)

append(key, value)

1 #在redis name對應(yīng)的值后面追加內(nèi)容

2

3 #參數(shù)：

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

append(key, value)

2、hash操作

hash表現(xiàn)形式上有些像pyhton中的dict,可以存儲一組關(guān)聯(lián)性較強(qiáng)的數(shù)據(jù) ， redis中Hash在內(nèi)存中的存儲格式如下圖：

hset(name, key, value)

1 #name對應(yīng)的hash中設(shè)置一個鍵值對(不存在，則創(chuàng)建；否則，修改)

2

3 #參數(shù)：

4 #name，redis的name

5 #key，name對應(yīng)的hash中的key

6 #value，name對應(yīng)的hash中的value

7

8 #注：

9 #hsetnx(name, key, value),當(dāng)name對應(yīng)的hash中不存在當(dāng)前key時則創(chuàng)建(相當(dāng)于添加)

hset(name, key, value)

hmset(name, mapping)

1 #在name對應(yīng)的hash中批量設(shè)置鍵值對

2

3 #參數(shù)：

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對應(yīng)的hash中獲取根據(jù)key獲取value

hget(name,key)

hmget(name, keys, *args)

1 #在name對應(yīng)的hash中獲取多個key的值

2

3 #參數(shù)：

4 #name，reids對應(yīng)的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對應(yīng)hash的所有鍵值

hgetall(name)

hlen(name)

1 #獲取name對應(yīng)的hash中鍵值對的個數(shù)

hlen(name)

hkeys(name)

1 #獲取name對應(yīng)的hash中所有的key的值

hkeys(name)

hvals(name)

1 #獲取name對應(yīng)的hash中所有的value的值

hvals(name)

hexists(name, key)

1 #檢查name對應(yīng)的hash是否存在當(dāng)前傳入的key

hexists(name, key)

hdel(name,*keys)

1 #將name對應(yīng)的hash中指定key的鍵值對刪除

hdel(name,*keys)

hincrby(name, key, amount=1)

1 #自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount

2 #參數(shù)：

3 #name，redis中的name

4 #key， hash對應(yīng)的key

5 #amount，自增數(shù)(整數(shù))

hincrby(name, key, amount=1)

hincrbyfloat(name, key, amount=1.0)

1 #自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建key=amount

2

3 #參數(shù)：

4 #name，redis中的name

5 #key， hash對應(yīng)的key

6 #amount，自增數(shù)(浮點(diǎn)數(shù))

7

8 #自增name對應(yīng)的hash中的指定key的值，不存在則創(chuàng)建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 #增量式迭代獲取，對于數(shù)據(jù)大的數(shù)據(jù)非常有用，hscan可以實(shí)現(xiàn)分片的獲取數(shù)據(jù)，并非一次性將數(shù)據(jù)全部獲取完，從而放置內(nèi)存被撐爆

2

3 #參數(shù)：

4 #name，redis的name

5 #cursor，游標(biāo)(基于游標(biāo)分批取獲取數(shù)據(jù))

6 #match，匹配指定key，默認(rèn)None 表示所有的key

7 #count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)

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時，表示數(shù)據(jù)已經(jīng)通過分片獲取完畢

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

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

1 #利用yield封裝hscan創(chuàng)建生成器，實(shí)現(xiàn)分批去redis中獲取數(shù)據(jù)

2

3 #參數(shù)：

4 #match，匹配指定key，默認(rèn)None 表示所有的key

5 #count，每次分片最少獲取個數(shù)，默認(rèn)None表示采用Redis的默認(rèn)分片個數(shù)

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在在內(nèi)存中按照一個name對應(yīng)一個List來存儲。如圖：

lpush(name,values)

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

2

3 #如：

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

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

6

7 #擴(kuò)展：

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

lpush(name,values)

lpushx(name,value)

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

2

3 #更多：

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

lpushx(name,value)

llen(name)

1 #name對應(yīng)的list元素的個數(shù)

llen(name)

linsert(name, where, refvalue, value))

1 #在name對應(yīng)的列表的某一個值前或后插入一個新值

2

3 #參數(shù)：

4 #name，redis的name

5 #where，BEFORE或AFTER

6 #refvalue，標(biāo)桿值，即：在它前后插入數(shù)據(jù)

7 #value，要插入的數(shù)據(jù)

linsert(name, where, refvalue, value))

r.lset(name, index, value)

1 #對name對應(yīng)的list中的某一個索引位置重新賦值

2

3 #參數(shù)：

4 #name，redis的name

5 #index，list的索引位置

6 #value，要設(shè)置的值

r.lset(name, index, value)

r.lrem(name, value, num)

1 #在name對應(yīng)的list中刪除指定的值

2

3 #參數(shù)：

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對應(yīng)的列表的左側(cè)獲取第一個元素并在列表中移除，返回值則是第一個元素

2

3 #更多：

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

lpop(name)

lindex(name, index)

1 在name對應(yīng)的列表中根據(jù)索引獲取列表元素

lindex(name, index)

lrange(name, start, end)

1 #在name對應(yīng)的列表分片獲取數(shù)據(jù)

2 #參數(shù)：

3 #name，redis的name

4 #start，索引的起始位置

5 #end，索引結(jié)束位置

lrange(name, start, end)

ltrim(name, start, end)

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

2 #參數(shù)：

3 #name，redis的name

4 #start，索引的起始位置

5 #end，索引結(jié)束位置

ltrim(name, start, end)

rpoplpush(src, dst)

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

2 #參數(shù)：

3 #src，要取數(shù)據(jù)的列表的name

4 #dst，要添加數(shù)據(jù)的列表的name

rpoplpush(src, dst)

blpop(keys, timeout)

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

2

3 #參數(shù)：

4 #keys，redis的name的集合

5 #timeout，超時時間，當(dāng)元素所有列表的元素獲取完之后，阻塞等待列表內(nèi)有數(shù)據(jù)的時間(秒), 0 表示永遠(yuǎn)阻塞

6

7 #更多：

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

blpop(keys, timeout)

brpoplpush(src, dst, timeout=0)

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

2

3 #參數(shù)：

4 #src，取出并要移除元素的列表對應(yīng)的name

5 #dst，要插入元素的列表對應(yīng)的name

6 #timeout，當(dāng)src對應(yīng)的列表中沒有數(shù)據(jù)時，阻塞等待其有數(shù)據(jù)的超時時間(秒)，0 表示永遠(yuǎn)阻塞

brpoplpush(src, dst, timeout=0)

3、set集合操作

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

sadd(name,values)

1 #name對應(yīng)的集合中添加元素

sadd(name,values)

scard(name)

1 獲取name對應(yīng)的集合中元素個數(shù)

scard(name)

sdiff(keys, *args)

1 在第一個name對應(yīng)的集合中且不在其他name對應(yīng)的集合的元素集合

sdiff(keys, *args)

sdiffstore(dest, keys, *args)

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

sdiffstore(dest, keys, *args)

sinter(keys, *args)

1 #獲取多一個name對應(yīng)集合的并集

sinter(keys, *args)

sinterstore(dest, keys, *args)

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

sinterstore(dest, keys, *args)

sismember(name, value)

1 #檢查value是否是name對應(yīng)的集合的成員

sismember(name, value)

smembers(name)

1 #獲取name對應(yīng)的集合的所有成員

smembers(name)

smove(src, dst, value)

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

smove(src, dst, value)

spop(name)

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

spop(name)

srandmember(name, numbers)

1 #從name對應(yīng)的集合中隨機(jī)獲取 numbers 個元素

srandmember(name, numbers)

srem(name, values)

1 #在name對應(yīng)的集合中刪除某些值

srem(name, values)

sunion(keys, *args)

1 #獲取多一個name對應(yīng)的集合的并集

sunion(keys, *args)

sunionstore(dest,keys, *args)

1 #獲取多一個name對應(yīng)的集合的并集，并將結(jié)果保存到dest對應(yīng)的集合中

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)

有序集合，在集合的基礎(chǔ)上，為每元素排序；元素的排序需要根據(jù)另外一個值來進(jìn)行比較

所以，對于有序集合，每一個元素有兩個值，即：值和分?jǐn)?shù)，分?jǐn)?shù)專門用來做排序。

zadd(name, *args, **kwargs)

1 #在name對應(yīng)的有序集合中添加元素

2 #如：

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

4 #或

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

zadd(name, *args, **kwargs)

zcard(name)

1 #獲取name對應(yīng)的有序集合元素的數(shù)量

zcard(name)

zcount(name, min, max)

1 #獲取name對應(yīng)的有序集合中分?jǐn)?shù) 在 [min,max] 之間的個數(shù)

zcount(name, min, max)

zincrby(name, value, amount)

1 #自增name對應(yīng)的有序集合的 name 對應(yīng)的分?jǐn)?shù)

zincrby(name, value, amount)

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

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

2

3 #參數(shù)：

4 #name，redis的name

5 #start，有序集合索引起始位置(非分?jǐn)?shù))

6 #end，有序集合索引結(jié)束位置(非分?jǐn)?shù))

7 #desc，排序規(guī)則，默認(rèn)按照分?jǐn)?shù)從小到大排序

8 #withscores，是否獲取元素的分?jǐn)?shù)，默認(rèn)只獲取元素的值

9 #score_cast_func，對分?jǐn)?shù)進(jìn)行數(shù)據(jù)轉(zhuǎn)換的函數(shù)

10

11 #更多：

12 #從大到小排序

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

14

15 #按照分?jǐn)?shù)范圍獲取name對應(yīng)的有序集合的元素

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對應(yīng)的有序集合中的排行(從 0 開始)

2

3 #更多：

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

zrank(name, value)

zrem(name, values)

1 #刪除name對應(yīng)的有序集合中值是values的成員

2

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

zrem(name, values)

zremrangebyrank(name, min, max)

1 #根據(jù)排行范圍刪除

zremrangebyrank(name, min, max)

zremrangebyscore(name, min, max)

1 #根據(jù)分?jǐn)?shù)范圍刪除

zremrangebyscore(name, min, max)

zscore(name, value)

1 #獲取name對應(yīng)有序集合中 value 對應(yīng)的分?jǐn)?shù)

zscore(name, value)

zinterstore(dest, keys, aggregate=None)

1 #獲取兩個有序集合的交集，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作

2 #aggregate的值為: SUM MIN MAX

zinterstore(dest, keys, aggregate=None)

zunionstore(dest, keys, aggregate=None)

1 #獲取兩個有序集合的并集，如果遇到相同值不同分?jǐn)?shù)，則按照aggregate進(jìn)行操作

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，用來對分?jǐn)?shù)進(jìn)行操作

zscan

4、常用其他操作

delete(*names)

1 #根據(jù)刪除redis中的任意數(shù)據(jù)類型

delete(*names)

exists(name)

1 #檢測redis的name是否存在

exists(name)

keys(pattern='*')

1 #根據(jù)模型獲取redis的name

2

3 #更多：

4 #KEYS * 匹配數(shù)據(jù)庫中所有 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設(shè)置超時時間

expire(name ,time)

rename(src, dst)

1 #對redis的name重命名為

rename(src, dst)

move(name, db))

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

move(name, db))

randomkey()

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

randomkey()

type(name)

1 #獲取name對應(yīng)值的類型

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)發(fā)布訂閱

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

發(fā)布者

1 from monitor.RedisHelper importRedisHelper2

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

訂閱者

3 小結(jié)

路漫漫其修遠(yuǎn)兮，吾將上下而求索~!

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

間歇性躊躇滿志，持續(xù)性混吃等死。

4 練習(xí)

題目：rpc命令端

需求：

可以異步的執(zhí)行多個命令

對多臺機(jī)器

作業(yè)是真的不會做。有機(jī)會有勇氣可以點(diǎn)進(jìn)來看看：

我是尾巴~

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

雖不才，才要堅持。

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。