python开发学习-day10(select/poll/epoll回顾、redis、rabbitmq-pika)

s12-20160319-day10

pytho自动化开发 day10

Date:2016.03.19

    @南非波波

课程大纲：

day09

http://www.cnblogs.com/alex3714/articles/5248247.html

day10

http://www.cnblogs.com/alex3714/articles/5286889.html

一、回顾

1. 队列

   1. 队列的作业就是实现多个线程之间数据安全的交互
   2. 队列类型：先进先出、后进先出、优先级
   3. queue的数据必须按照顺序进行取出-->处理-->放回。主要作用就是不同进程之间数据的交换，manager可以进行多个进程之间的数据的共享，而且是数据安全的。
   4. 生产者-消费者模型：实现程序的松耦合

2. gevent模块：对Greenlet模块的一次封装

   1. gevent里面的socket本身可以实现IO阻塞变成非阻塞
   2. monkey.path_all()可以帮助我们实现阻塞变成非阻塞

3. 协程

   1. 实现单个线程里面的并发
   2. 无需线程上下文切换的开销，无需原子操作锁定及同步的开销，方便切换控制流，高并发+高扩展性+低成本
   3. 无法利用多核资源，但是可以实现单个进程下面起一个线程，然后一个线程下面实现多个协程并发

4. select

   

   1. select 与poll的区别

      select有一个最大文件数的限制1024，文件扫描一个列表是非常低效的；poll没有这个限制
      内核态到用户态的数据copy；Epoll直接调用C语言进行内核态的数据nat到用户态
      

   2. select代码注释

      __auther__ = 'Victor'
      
      import select
      import socket
      import sys
      import queue
      
      # 创建一个TCP/IP socket
      server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      server.setblocking(False)
      # 绑定socket到指定端口
      server_address = ('localhost', 10000)
      print(sys.stderr, 'starting up on %s port %s' % server_address)
      server.bind(server_address)
      # 监听连接的地址
      server.listen(5)
      inputs = [server]
      # Socket的读操作
      outputs = []
      # socket的写操作
      message_queues = {}
      while inputs:
          # Wait for at least one of the sockets to be ready for processing
          print( '
      waiting for the next event')
          readable, writable, exceptional = select.select(inputs, outputs, inputs)
          # 监听句柄序列，如果某个发生变化，select的第一个rLest会拿到数据，output只要有数据wLest就能获取到，select的第三个参数inputs用来监测异常，并赋值给exceptional。
          # 监听inputs，outputs，inputs  如果他们的值有变化，就将分别赋值给readable，writable，exceptional。
          for s in readable:
              # 遍历readable的值。
              if s is server:
                  connection, client_address = s.accept()
                  # 如果s 是server，那么server socket将接收连接。
                  print('new connection from', client_address)
                  # 打印出连接客户端的地址。
                  connection.setblocking(False)
                  # 设置socket 为非阻塞模式。
                  inputs.append(connection)
                  # 因为有读操作发生，所以将此连接加入inputs
                  message_queues[connection] = queue.Queue()
                  # 为每个连接创建一个queue队列。使得每个连接接收到正确的数据。
              else:
                  data = s.recv(1024)
                  # 如果s不是server，说明客户端连接来了，那么就接受客户端的数据。
                  if data:
                      # 如果接收到客户端的数据
                      print(sys.stderr, 'received "%s" from %s' % (data, s.getpeername()) )
                      message_queues[s].put(data)
                      # 将收到的数据放入队列中
                      if s not in outputs:
                          outputs.append(s)
                          # 将socket客户端的连接加入select的output中，并且用来返回给客户端数据。
                  else:
                      print('closing', client_address, 'after reading no data')
                      # 如果没有收到客户端发来的空消息，则说明客户端已经断开连接。
                      if s in outputs:
                          outputs.remove(s)
                          # 既然客户端都断开了，我就不用再给它返回数据了，所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
                      inputs.remove(s)
                      # inputs中也删除掉
                      s.close()
                      # 把这个连接关闭掉
                      del message_queues[s]
                      # 删除此客户端的消息队列
      
          for s in writable:
              # 遍历output的数据
              try:
                  next_msg = message_queues[s].get_nowait()
              except queue.Empty:
                  # 获取对应客户端消息队列中的数据，如果队列中的数据为空，从消息队列中移除此客户端连接。
                  print('output queue for', s.getpeername(), 'is empty')
                  outputs.remove(s)
              else:
                  print( 'sending "%s" to %s' % (next_msg, s.getpeername()))
                  s.send(next_msg)
                  # 如果消息队列有数据，则发送给客户端。
          for s in exceptional:
              # 处理 "exceptional conditions"
              print('handling exceptional condition for', s.getpeername() )
              inputs.remove(s)
              # 取消对出现异常的客户端的监听
              if s in outputs:
                  outputs.remove(s)
                  # 移除客户端的连接对象。
              s.close()
              # 关闭此socket连接
              del message_queues[s]
              # 删除此消息队列。
      
      '''
      
      在select/poll时代，服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态)，让操作系统内核去查询这些套接字上是否有事件发生，
      
      轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，因此，select/poll一般只能处理几千的并发连接。
      
      epoll的设计和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统(文件系统一般用什么数据结构实现？B+树)。把原先的select/poll调用分成了3个部分：
      
      1）调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)
      
      2）调用epoll_ctl向epoll对象中添加这100万个连接的套接字
      
      3）调用epoll_wait收集发生的事件的连接
      
      '''
      

   3. epoll代码注释

      __auther__ = 'Victor'
      
      
      #--------------这是一个epoll的例子--------------
      
      
      import socket, select
      # 'windows'下不支持'epoll'
      
      EOL1 = b'
      
      '
      EOL2 = b'
      
      '
      response = b'HTTP/1.0 200 OK
      Date: Mon, 1 Jan 1996 01:01:01 GMT
      '
      response += b'Content-Type: text/plain
      Content-Length: 13
      
      '
      response += b'Hello, world!'
      
      serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
      serversocket.bind(('0.0.0.0', 8080))
      serversocket.listen(1)
      # 建立socket连接。
      serversocket.setblocking(0)
      # 因为socket本身是阻塞的，setblocking（0）使得socket不阻塞
      
      epoll = select.epoll()
      # 创建一个eopll对象
      epoll.register(serversocket.fileno(), select.EPOLLIN)
      # 在服务器端socket上面注册对读event的关注，一个读event随时会触发服务器端socket去接收一个socket连接。
      
      try:
         connections = {}; requests = {}; responses = {}
      # 生成3个字典，connection字典是存储文件描述符映射到他们相应的网络连接对象
         while True:
            events = epoll.poll(1)
      # 查询epoll对象，看是否有任何关注的event被触发，参数‘1’表示，会等待一秒来看是否有event发生，如果有任何感兴趣的event发生在这次查询之前，这个查询就会带着这些event的列表立即返回
            for fileno, event in events:
              # event作为一个序列（fileno，event code）的元组返回，fileno是文件描述符的代名词，始终是一个整数。
               if fileno == serversocket.fileno():
                  # 如果一个读event在服务器端socket发生，就会有一个新的socket连接可能被创建。
                  connection, address = serversocket.accept()
                  # 服务器端开始接收连接和客户端地址
                  connection.setblocking(0)
                  # 设置新的socket为非阻塞模式
                  epoll.register(connection.fileno(), select.EPOLLIN)
                  # 为新的socket注册对读（EPOLLIN）event的关注
                  connections[connection.fileno()] = connection
                  requests[connection.fileno()] = b''
                  responses[connection.fileno()] = response
               elif event & select.EPOLLIN:
                  requests[fileno] += connections[fileno].recv(1024)
                  # 如果发生一个读event，就读取从客户端发过来的数据。
                  if EOL1 in requests[fileno] or EOL2 in requests[fileno]:
                     epoll.modify(fileno, select.EPOLLOUT)
                  # 一旦完成请求已经收到，就注销对读event的关注，注册对写（EPOLLOUT）event的关注，写event发生的时候，会回复数据给客户端。
                     print('-'*40 + '
      ' + requests[fileno].decode()[:-2])
                  # 打印完整的请求，证明虽然与客户端的通信是交错进行的，但是数据可以作为一个整体来组装和处理。
               elif event & select.EPOLLOUT:
                  # 如果一个写event在一个客户端socket上面发生，他会接受新的数据以便发送到客户端。
                  byteswritten = connections[fileno].send(responses[fileno])
                  responses[fileno] = responses[fileno][byteswritten:]
                  if len(responses[fileno]) == 0:
                      # 每次发送一部分响应数据，直到完整的响应数据都已经发送给操作系统等待传输给客户端。
                     epoll.modify(fileno, 0)
                  # 一旦完整的响应数据发送完成，就不再关注读或者写event。
                     connections[fileno].shutdown(socket.SHUT_RDWR)
                  # 如果一个连接显式关闭，那么socket shutdown是可选的，在这里这样使用，是为了让客户端首先关闭。
                  # shutdown调用会通知客户端socket没有更多的数据应该被发送或者接收，并会让功能正常的客户端关闭自己的socket连接。
               elif event & select.EPOLLHUP:
                  # HUP挂起event表明客户端socket已经断开（即关闭），所以服务器端也需要关闭，没有必要注册对HUP event的关注，在socket上面，他们总是会被epoll对象注册。
                  epoll.unregister(fileno)
                  # 注销对此socket连接的关注。
                  connections[fileno].close()
                  # 关闭socket连接。
                  del connections[fileno]
      finally:
         epoll.unregister(serversocket.fileno())
      # 去掉已经注册的文件句柄
         epoll.close()
      # 关闭epoll对象
         serversocket.close()
      # 关闭服务器连接
      # 打开的socket连接不需要关闭，因为Python会在程序结束时关闭， 这里的显示关闭是个好的习惯。
      
      
      
      '''
      
      首先我们来定义流的概念，一个流可以是文件，socket，pipe等等可以进行I/O操作的内核对象。
      
          不管是文件，还是套接字，还是管道，我们都可以把他们看作流。
      
          之后我们来讨论I/O的操作，通过read，我们可以从流中读入数据；通过write，我们可以往流写入数据。现在假定一个情形，
          我们需要从流中读数据，但是流中还没有数据，（典型的例子为，客户端要从socket读如数据，但是服务器还没有把数据传回来），
          这时候该怎么办？
      
      阻塞：阻塞是个什么概念呢？比如某个时候你在等快递，但是你不知道快递什么时候过来，而且你没有别的事可以干（或者说接下来的事要等快递来了才能做）；
      那么你可以去睡觉了，因为你知道快递把货送来时一定会给你打个电话（假定一定能叫醒你）。
      
      非阻塞忙轮询：接着上面等快递的例子，如果用忙轮询的方法，那么你需要知道快递员的手机号，然后每分钟给他挂个电话：“你到了没？”
      
          很明显一般人不会用第二种做法，不仅显很无脑，浪费话费不说，还占用了快递员大量的时间。
      
          大部分程序也不会用第二种做法，因为第一种方法经济而简单，经济是指消耗很少的CPU时间，如果线程睡眠了，就掉出了系统的调度队列，暂时不会去瓜分CPU宝贵的时间片了。
      
          为了了解阻塞是如何进行的，我们来讨论缓冲区，以及内核缓冲区，最终把I/O事件解释清楚。缓冲区的引入是为了减少频繁I/O操作而引起频繁的系统调用（你知道它很慢的），
          当你操作一个流时，更多的是以缓冲区为单位进行操作，这是相对于用户空间而言。对于内核来说，也需要缓冲区。
      
      假设有一个管道，进程A为管道的写入方，Ｂ为管道的读出方。
      
      假设一开始内核缓冲区是空的，B作为读出方，被阻塞着。然后首先A往管道写入，这时候内核缓冲区由空的状态变到非空状态，内核就会产生一个事件告诉Ｂ该醒来了，
      这个事件姑且称之为“缓冲区非空”。
      
          但是“缓冲区非空”事件通知B后，B却还没有读出数据；且内核许诺了不能把写入管道中的数据丢掉这个时候，Ａ写入的数据会滞留在内核缓冲区中，如果内核也缓冲区满了，
          B仍未开始读数据，最终内核缓冲区会被填满，这个时候会产生一个I/O事件，告诉进程A，你该等等（阻塞）了，我们把这个事件定义为“缓冲区满”。
      
      假设后来Ｂ终于开始读数据了，于是内核的缓冲区空了出来，这时候内核会告诉A，内核缓冲区有空位了，你可以从长眠中醒来了，继续写数据了，我们把这个事件叫做“缓冲区非满”
      
          也许事件Y1已经通知了A，但是A也没有数据写入了，而Ｂ继续读出数据，知道内核缓冲区空了。这个时候内核就告诉B，你需要阻塞了！，我们把这个时间定为“缓冲区空”。
      
      这四个情形涵盖了四个I/O事件，缓冲区满，缓冲区空，缓冲区非空，缓冲区非满（注都是说的内核缓冲区，且这四个术语都是我生造的，仅为解释其原理而造）。
      这四个I/O事件是进行阻塞同步的根本。（如果不能理解“同步”是什么概念，请学习操作系统的锁，信号量，条件变量等任务同步方面的相关知识）。
      
          然后我们来说说阻塞I/O的缺点。但是阻塞I/O模式下，一个线程只能处理一个流的I/O事件。如果想要同时处理多个流，要么多进程(fork)，要么多线程(pthread_create)，
          很不幸这两种方法效率都不高。
      
          于是再来考虑非阻塞忙轮询的I/O方式，我们发现我们可以同时处理多个流了（把一个流从阻塞模式切换到非阻塞模式再此不予讨论）：
      
      while true {
          for i in stream[]; {
              if i has data
                  read until unavailable
          }
      }
      
          我们只要不停的把所有流从头到尾问一遍，又从头开始。这样就可以处理多个流了，但这样的做法显然不好，因为如果所有的流都没有数据，那么只会白白浪费CPU。
          这里要补充一点，阻塞模式下，内核对于I/O事件的处理是阻塞或者唤醒，而非阻塞模式下则把I/O事件交给其他对象（后文介绍的select以及epoll）处理甚至直接忽略。
      
          为了避免CPU空转，可以引进了一个代理（一开始有一位叫做select的代理，后来又有一位叫做poll的代理，不过两者的本质是一样的）。这个代理比较厉害，
          可以同时观察许多流的I/O事件，在空闲的时候，会把当前线程阻塞掉，当有一个或多个流有I/O事件时，就从阻塞态中醒来，于是我们的程序就会轮询一遍所有的流
          （于是我们可以把“忙”字去掉了）。代码长这样:
      
      while true {
          select(streams[])
          for i in streams[] {
              if i has data
                  read until unavailable
          }
      }
      
          于是，如果没有I/O事件产生，我们的程序就会阻塞在select处。但是依然有个问题，我们从select那里仅仅知道了，有I/O事件发生了，但却并不知道是那几个流
          （可能有一个，多个，甚至全部），我们只能无差别轮询所有流，找出能读出数据，或者写入数据的流，对他们进行操作。
      
          但是使用select，我们有O(n)的无差别轮询复杂度，同时处理的流越多，没一次无差别轮询时间就越长。再次
      
      说了这么多，终于能好好解释epoll了
      
          epoll可以理解为event poll，不同于忙轮询和无差别轮询，epoll之会把哪个流发生了怎样的I/O事件通知我们。此时我们对这些流的操作都是有意义的。
          （复杂度降低到了O(1)）
      
          在讨论epoll的实现细节之前，先把epoll的相关操作列出：
      
            epoll_create 创建一个epoll对象，一般epollfd = epoll_create()
      
            epoll_ctl （epoll_add/epoll_del的合体），往epoll对象中增加/删除某一个流的某一个事件
      
      比如
      
      epoll_ctl(epollfd, EPOLL_CTL_ADD, socket, EPOLLIN);//注册缓冲区非空事件，即有数据流入
      
      epoll_ctl(epollfd, EPOLL_CTL_DEL, socket, EPOLLOUT);//注册缓冲区非满事件，即流可以被写入
      
      epoll_wait(epollfd,...)等待直到注册的事件发生
      
      （注：当对一个非阻塞流的读写发生缓冲区满或缓冲区空，write/read会返回-1，并设置errno=EAGAIN。而epoll只关心缓冲区非满和缓冲区非空事件）。
      
      一个epoll模式的代码大概的样子是：
      while true {
          active_stream[] = epoll_wait(epollfd)
          for i in active_stream[] {
              read or write till
          }
      }
      
      '''
      

二、Twsited异步网络框架

1. 事件驱动

   将自定义的类和函数注册到事件列表中，事件驱动框架就会自行去列表中获取事件并执行。

   第一，注册事件；第二，触发事件

示例代码：

#event_drive.py
#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
'''
模拟twsited异步网络框架的流程
'''
#创建一个事件列表
event_list = []

#创建一个事件驱动动作
def run():
    for event in event_list:
        obj = event()
        obj.execute()

#创建事件定义规则，用户将自定义事件注册到事件列表中需要继承此类
class BaseHandler(object):
    """
    用户必须继承该类，从而规范所有类的方法（类似于接口的功能）
    """
    def execute(self):
        raise Exception('you must overwrite execute')

#event_run.py
#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
import event_drive

#自定义事件，继承事件驱动自定义类
class MyHandler(event_drive.BaseHandler):

    #重写执行函数
    def execute(self):
        print('event-drive execute MyHandler')
class YourHandler(event_drive.BaseHandler):

    def execute(self):
        print('event-drive ezecute YourHandler')

event_drive.event_list.append(MyHandler) #将事件注册到事件列表中
event_drive.event_list.append(YourHandler)
event_drive.run()   

1. Twisted框架

Echo_server

#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
from twisted.internet import protocol
from twisted.internet import reactor

class Echo(protocol.Protocol):
    '''
    定义一个类，处理客户端传递的数据
    '''
    def dataReceived(self, data):
        '''
        一旦接收到客户端传递的数据就要调用该方法
        :param data: 客户端传递过来的数据，python3版本传递的数据需要转换成bytes
        :return: 返回的数据是将客户端传递过来的数据返回给客户端
        '''
        print("Client said:",data)
        self.transport.write(data)

def main():
    '''
    主函数，程序执行时直接从该函数调用事件类
    :return:
    '''
    factory = protocol.ServerFactory() #定义基础工厂类
    factory.protocol = Echo #相当于socketserver中的Handler方法，工厂协议直接引用自定义的Echo类

    reactor.listenTCP(5000,factory) #reactor自动重复去做一件事情。使用listenTCP监听端口
    reactor.run() #运行

if __name__ == '__main__':
    main()

Echo_client:

#!/usr/local/env python3
'''
Author:@南非波波
Blog:http://www.cnblogs.com/songqingbo/
E-mail:qingbo.song@gmail.com
'''
from twisted.internet import reactor, protocol


# a client protocol

class EchoClient(protocol.Protocol):
    '''
    客户端Echo事件
    '''
    def connectionMade(self):
        '''
        连接建立执行该方法，客户端发送数据
        :return:
        '''
        self.transport.write(b"hello alex!")

    def dataReceived(self, data):
        '''
        客户端接收服务端的数据
        :param data:
        :return:
        '''
        print("Server said:", data)
        self.transport.loseConnection()
    def connectionLost(self, reason):
        '''
        客户端接收完数据断开连接，主动执行该方法断开连接
        :param reason:
        :return:
        '''
        print("connection lost")

class EchoFactory(protocol.ClientFactory):
    '''
    自定义工厂类，继承prorocol.ClientFactory类
    '''
    protocol = EchoClient #hanld。自己重写了protocol类

    def clientConnectionFailed(self, connector, reason):
        print("Connection failed - goodbye!")
        reactor.stop()

    def clientConnectionLost(self, connector, reason):
        print("Connection lost - goodbye!")
        reactor.stop()


# this connects the protocol to a server running on port 8000
def main():
    f = EchoFactory()
    reactor.connectTCP("localhost", 5000, f)
    reactor.run()

# this only runs if the module was *not* imported
if __name__ == '__main__':
    main()

1. 升入学习

http://blog.csdn.net/hanhuili/article/details/9389433

http://krondo.com/an-introduction-to-asynchronous-programming-and-twisted/

三、非关系型数据库

1. Redis

   参考：http://www.cnblogs.com/wupeiqi/articles/5132791.html

   数据（键值对）存储在内存中，一个独立的内存管理器，可以使多个程序共享数据

   默认是非持久化的，但是可以在配置文件中进行设置

   1. redis基础使用

      cli>keys * #查看所有的键
      cli>set name swht ex 5 #设置一个键值对，其有效时间为5秒
      cli>get name #获取键值
      

   2. redis连接

      import redis
      redis_cli = redis.Redis("localhost")
      print(redis_cli.get('name')) #b'swht'  get方法只能获取字符
      

   3. redis连接池

      import redis
      pool = redis.ConnectionPool(host = 'localhost',port = 6379)
      redis_cli = redis.Redis(connection_pool=pool)
      redis_cli.set('age',56)
      print(redis_cli.get('age')) #b'56'
      

   4. 操作

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

      在Redis中设置值，默认，不存在则创建，存在则修改
      参数：
           ex，过期时间（秒）
           px，过期时间（毫秒）
           nx，如果设置为True，则只有name不存在时，当前set操作才执行
           xx，如果设置为True，则只有name存在时，岗前set操作才执行
      

      setnx(name, value)

      设置值，只有name不存在时，执行设置操作（添加）
      

      setex(name, value, time)

      # 设置值
      # 参数：
          # time，过期时间（数字秒 或 timedelta对象）
      

      psetex(name, time_ms, value)

      # 设置值
      # 参数：
          # time_ms，过期时间（数字毫秒 或 timedelta对象）
      

      mset(*args, **kwargs)

      批量设置值
      如：
          mset(k1='v1', k2='v2')
          或
          mget({'k1': 'v1', 'k2': 'v2'})
      

      get(name)

      获取值
      

      mget(keys, *args)

      批量获取
      如：
          mget('ylr', 'wupeiqi')
          或
          r.mget(['ylr', 'wupeiqi'])
      

      getset(name, value)

      设置新值并获取原来的值
      

      getrange(key, start, end)

      # 获取子序列（根据字节获取，非字符）
      # 参数：
          # name，Redis 的 name
          # start，起始位置（字节）
          # end，结束位置（字节）
      # 如： "武沛齐" ，0-3表示 "武"
      

      setrange(name, offset, value)

      # 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
      # 参数：
          # offset，字符串的索引，字节（一个汉字三个字节）
          # value，要设置的值
      

      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是汉字 "武沛齐"怎么办？
          答：对于utf-8，每一个汉字占 3 个字节，那么 "武沛齐" 则有 9个字节
             对于汉字，for循环时候会按照 字节 迭代，那么在迭代时，将每一个字节转换 十进制数，然后再将十进制数转换成二进制    
      

      假定统计UV，使用setbit可以进行相应UV数统计。

      #!/usr/local/env python3
      '''
      Author:@南非波波
      Blog:http://www.cnblogs.com/songqingbo/
      E-mail:qingbo.song@gmail.com
      '''
      import redis
      
      pool = redis.ConnectionPool(host = 'localhost',port = 6379)
      redis_cli = redis.Redis(connection_pool=pool)
      redis_cli.setbit('ip',5,1)
      redis_cli.setbit('ip',45,1)
      redis_cli.setbit('ip',15,1)
      redis_cli.setbit('ip',45,1)
      print("uv_count:",redis_cli.bitcount('ip')) 
      

      getbit(name, offset)

      # 获取name对应的值的二进制表示中的某位的值 （0或1）
      bitcount(key, start=None, end=None)
      
      # 获取name对应的值的二进制表示中 1 的个数
      # 参数：
          # key，Redis的name
          # start，位起始位置
          # end，位结束位置
      

      bitop(operation, dest, *keys)

      # 获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
      
      # 参数：
          # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
          # dest, 新的Redis的name
          # *keys,要查找的Redis的name
      
      # 如：
          bitop("AND", 'new_name', 'n1', 'n2', 'n3')
          # 获取Redis中n1,n2,n3对应的值，然后讲所有的值做位运算（求并集），然后将结果保存 new_name 对应的值中
      

      strlen(name)

      # 返回name对应值的字节长度（一个汉字3个字节）
      

      incr(self, name, amount=1)

      做pv统计比较有用
      # 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
      
      # 参数：
          # name,Redis的name
          # amount,自增数（必须是整数）
      
      # 注：同incrby
      

      incrbyfloat(self, name, amount=1.0)

      # 自增 name对应的值，当name不存在时，则创建name＝amount，否则，则自增。
      
      # 参数：
          # name,Redis的name
          # amount,自增数（浮点型）
      

      decr(self, name, amount=1)

      # 自减 name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
      
      # 参数：
          # name,Redis的name
          # amount,自减数（整数）
      

      append(key, value)

      # 在redis name对应的值后面追加内容
      
      # 参数：
          key, redis的name
          value, 要追加的字符串      
      

   5. 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时则创建（相当于添加）
      

      hmset(name, mapping)

      # 在name对应的hash中批量设置键值对
      
      # 参数：
          # name，redis的name
          # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
      
      # 如：
          # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})
      

      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')
      

      hgetall(name)

      获取name对应hash的所有键值
      

      hlen(name)

      # 获取name对应的hash中键值对的个数
      

      hkeys(name)

      # 获取name对应的hash中所有的key的值
      

      hvals(name)

      # 获取name对应的hash中所有的value的值
      

      hexists(name, key)

      # 检查name对应的hash是否存在当前传入的key
      

      hdel(name,*keys)

      # 将name对应的hash中指定key的键值对删除
      

      hincrby(name, key, amount=1)

      # 自增name对应的hash中的指定key的值，不存在则创建key=amount
      # 参数：
          # name，redis中的name
          # key， hash对应的key
          # amount，自增数（整数）
      

      hincrbyfloat(name, key, amount=1.0)

      # 自增name对应的hash中的指定key的值，不存在则创建key=amount
      
      # 参数：
          # name，redis中的name
          # key， hash对应的key
          # amount，自增数（浮点数）
      
      # 自增name对应的hash中的指定key的值，不存在则创建key=amount
      

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

      # 增量式迭代获取，对于数据大的数据非常有用，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时，表示数据已经通过分片获取完毕
      

      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
      

   6. List操作

      lpush(name,values)

      # 在name对应的list中添加元素，每个新的元素都添加到列表的最左边
      
      # 如：
          # r.lpush('oo', 11,22,33)
          # 保存顺序为: 33,22,11
      
      # 扩展：
          # rpush(name, values) 表示从右向左操作
      

      lpushx(name,value)

      # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
      
      # 更多：
          # rpushx(name, value) 表示从右向左操作
      

      llen(name)

      # name对应的list元素的个数
      

      linsert(name, where, refvalue, value))

      # 在name对应的列表的某一个值前或后插入一个新值
      
      # 参数：
          # name，redis的name
          # where，BEFORE或AFTER
          # refvalue，标杆值，即：在它前后插入数据
          # value，要插入的数据
      

      r.lset(name, index, value)

      # 对name对应的list中的某一个索引位置重新赋值
      
      # 参数：
          # name，redis的name
          # index，list的索引位置
          # value，要设置的值
      

      r.lrem(name, value, num)

      # 在name对应的list中删除指定的值
      
      # 参数：
          # name，redis的name
          # value，要删除的值
          # num，  num=0，删除列表中所有的指定值；
                 # num=2,从前到后，删除2个；
                 # num=-2,从后向前，删除2个
      

      lpop(name)

      # 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
      
      # 更多：
          # rpop(name) 表示从右向左操作
      

      lindex(name, index)

      在name对应的列表中根据索引获取列表元素
      

      lrange(name, start, end)

      # 在name对应的列表分片获取数据
      # 参数：
          # name，redis的name
          # start，索引的起始位置
          # end，索引结束位置
      

      ltrim(name, start, end)

      # 在name对应的列表中移除没有在start-end索引之间的值
      # 参数：
          # name，redis的name
          # start，索引的起始位置
          # end，索引结束位置
      

      rpoplpush(src, dst)

      # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
      # 参数：
          # src，要取数据的列表的name
          # dst，要添加数据的列表的name
      

      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 表示永远阻塞
      

      自定义增量迭代

      # 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
          # 1、获取name对应的所有列表
          # 2、循环列表
      # 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
      
      def list_iter(name):
          """
          自定义redis列表增量迭代
          :param name: redis中的name，即：迭代name对应的列表
          :return: yield 返回 列表元素
          """
          list_count = r.llen(name)
          for index in xrange(list_count):
              yield r.lindex(name, index)
      
      # 使用
      for item in list_iter('pp'):
          print item
      

   7. Set操作，Set集合就是不允许重复的列表

      sadd(name,values)

      # name对应的集合中添加元素
      

      scard(name)

      获取name对应的集合中元素个数
      

      sdiff(keys, *args)

      在第一个name对应的集合中且不在其他name对应的集合的元素集合
      

      sdiffstore(dest, keys, *args)

      # 获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
      

      sinter(keys, *args)

      # 获取多一个name对应集合的并集
      

      sinterstore(dest, keys, *args)

      # 获取多一个name对应集合的并集，再讲其加入到dest对应的集合中
      

      sismember(name, value)

      # 检查value是否是name对应的集合的成员
      

      smembers(name)

      # 获取name对应的集合的所有成员
      

      smove(src, dst, value)

      # 将某个成员从一个集合中移动到另外一个集合
      

      spop(name)

      # 从集合的右侧（尾部）移除一个成员，并将其返回
      

      srandmember(name, numbers)

      # 从name对应的集合中随机获取 numbers 个元素
      

      srem(name, values)

      # 在name对应的集合中删除某些值
      

      sunion(keys, *args)

      # 获取多一个name对应的集合的并集
      

      sunionstore(dest,keys, *args)

      # 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中
      

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

      # 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
      

   8. 有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

      zadd(name, *args, **kwargs)

      # 在name对应的有序集合中添加元素
      # 如：
           # zadd('zz', 'n1', 1, 'n2', 2)
           # 或
           # zadd('zz', n1=11, n2=22)
      

      zcard(name)

      # 获取name对应的有序集合元素的数量
      

      zcount(name, min, max)

      # 获取name对应的有序集合中分数 在 [min,max] 之间的个数
      

      zincrby(name, value, amount)

      # 自增name对应的有序集合的 name 对应的分数
      

      r.zrange( name, start, end, desc=False, withscores=False, scorecastfunc=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)
      

      zrank(name, value)

      # 获取某个值在 name对应的有序集合中的排行（从 0 开始）
      
      # 更多：
          # zrevrank(name, value)，从大到小排序
      

      zrangebylex(name, min, max, start=None, num=None)

      # 当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的 值 （lexicographical ordering）来进行排序，而这个命令则可以返回给定的有序集合键 key 中， 元素的值介于 min 和 max 之间的成员
      # 对集合中的每个成员进行逐个字节的对比（byte-by-byte compare）， 并按照从低到高的顺序， 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话， 那么命令会认为较长的字符串比较短的字符串要大
      
      # 参数：
          # name，redis的name
          # min，左区间（值）。 + 表示正无限； - 表示负无限； ( 表示开区间； [ 则表示闭区间
          # min，右区间（值）
          # start，对结果进行分片处理，索引位置
          # num，对结果进行分片处理，索引后面的num个元素
      
      # 如：
          # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
          # r.zrangebylex('myzset', "-", "[ca") 结果为：['aa', 'ba', 'ca']
      
      # 更多：
          # 从大到小排序
          # zrevrangebylex(name, max, min, start=None, num=None)
      

      zrem(name, values)

      # 删除name对应的有序集合中值是values的成员
      
      # 如：zrem('zz', ['s1', 's2'])
      

      zremrangebyrank(name, min, max)

      # 根据排行范围删除
      

      zremrangebyscore(name, min, max)

      # 根据分数范围删除
      

      zremrangebylex(name, min, max)

      # 根据值返回删除
      

      zscore(name, value)

      # 获取name对应有序集合中 value 对应的分数
      

      zinterstore(dest, keys, aggregate=None)

      # 获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作
      # aggregate的值为:  SUM  MIN  MAX
      

      zunionstore(dest, keys, aggregate=None)

      # 获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
      # aggregate的值为:  SUM  MIN  MAX
      

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

      # 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作
      

　　9. redis的发布与订阅

基础类：

    #!/usr/local/env python3
    '''
    Author:@南非波波
    Blog:http://www.cnblogs.com/songqingbo/
    E-mail:qingbo.song@gmail.com
    '''
    import redis


    class RedisHelper:

        def __init__(self):
            self.__conn = redis.Redis(host='localhost',port=6379)
            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

redis_sub.py

    #!/usr/local/env python3
    '''
    Author:@南非波波
    Blog:http://www.cnblogs.com/songqingbo/
    E-mail:qingbo.song@gmail.com
    '''
    from RedisHelper import RedisHelper

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

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

redis_pub.py

    #!/usr/local/env python3
    '''
    Author:@南非波波
    Blog:http://www.cnblogs.com/songqingbo/
    E-mail:qingbo.song@gmail.com
    '''
    from RedisHelper import RedisHelper

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

1. memcached

   非持久化轻量级缓存，使用第三方工具可以实现数据的持久化存储

2. mongodb

   天生的数据持久化，默认将数据持久化存储在本地磁盘。

四、消息队列rabbitmq

通信模式：

1. 简单生产者消费者模型

   rabbit_send

   #!/usr/local/env python3
   '''
   Author:@南非波波
   Blog:http://www.cnblogs.com/songqingbo/
   E-mail:qingbo.song@gmail.com
   '''
   import pika
   #与消息队列建立一个连接
   connection = pika.BlockingConnection(pika.ConnectionParameters(
                  'localhost'))
   #创建一个管道
   channel = connection.channel()
   
   #在管道中声明一个名称为'name'的队列
   channel.queue_declare(queue='name')
   
   #一个消息不能直接发送给消息队列，需要通过一个路由器进行转发，这个路由器就是由exchange进行设置
   channel.basic_publish(exchange='', #路由器
                         routing_key='name', #队列名称
                         body='swht') #消息
   print(" [swht] Sent a message")
   connection.close()
   

   rabbit_recive

   #!/usr/local/env python3
   '''
   Author:@南非波波
   Blog:http://www.cnblogs.com/songqingbo/
   E-mail:qingbo.song@gmail.com
   '''
   import pika
   
   #与消息队列服务器建立连接
   connection = pika.BlockingConnection(pika.ConnectionParameters(
                  'localhost'))
   #创建一个管道
   channel = connection.channel()
   #消费者声明一个队列，为了防止生产者还没有启动没有完成创建队列时代码出错的问题。如果队列已存在，则忽略该操作，否则则创建队列
   channel.queue_declare(queue='name')
   
   def callback(ch, method, properties, body):
       print(" [x] Received %r" % body)
   
   channel.basic_consume(callback,
                         queue='name',
                         no_ack=True) #接收消息不进行确认
   
   print(' [*] Waiting for messages. To exit press CTRL+C')
   channel.start_consuming()
   

2. 消息持久化

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

   已经存在的队列是不能再进行持久化设置的，所以在只有创建队列的时候设置持久化选项 bascack = (deliverytag= method.delivry_tag)

   查看当前所有的queue XX

3. 消息公平分发

   

   只在消费者添加 channel.basicqos(prefetchcount=1)

   示例代码：

   rabbit_slb_send.py
       #!/usr/local/env python3
       '''
       Author:@南非波波
       Blog:http://www.cnblogs.com/songqingbo/
       E-mail:qingbo.song@gmail.com
       '''
       import pika
   
       connection = pika.BlockingConnection(pika.ConnectionParameters(
                      '192.168.137.6'))
       channel = connection.channel()
   
       #声明queue
       channel.queue_declare(queue='task_queue')
   
       #n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.
       import sys
   
       message = ' '.join(sys.argv[1:]) or "Hello World!"
       channel.basic_publish(exchange='',
                             routing_key='task_queue',
                             body=message,
                             properties=pika.BasicProperties(
                             delivery_mode = 2, # make message persistent
                             ))
       print(" [x] Sent %r" % message)
       connection.close()
   

4. exchange路由

   

   代码：

   publisher.py
   
       #!/usr/local/env python3
       '''
       Author:@南非波波
       Blog:http://www.cnblogs.com/songqingbo/
       E-mail:qingbo.song@gmail.com
       '''
       import pika
       import sys
   
       connection = pika.BlockingConnection(pika.ConnectionParameters(
               host='localhost'))
       channel = connection.channel()
   
       channel.exchange_declare(exchange='logs',
                                type='fanout')
   
       message = ' '.join(sys.argv[1:]) or "info: Hello World!"
       channel.basic_publish(exchange='logs',
                             routing_key='',
                             body=message)
       print(" [x] Sent %r" % message)
       connection.close()
   
   subscriber.py
   
       import pika
   
       connection = pika.BlockingConnection(pika.ConnectionParameters(
               host='localhost'))
       channel = connection.channel()
   
       channel.exchange_declare(exchange='logs',
                                type='fanout')
   
       result = channel.queue_declare(exclusive=True) #不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
       queue_name = result.method.queue
   
       channel.queue_bind(exchange='logs',
                          queue=queue_name)
   
       print(' [*] Waiting for logs. To exit press CTRL+C')
   
       def callback(ch, method, properties, body):
           print(" [x] %r" % body)
   
       channel.basic_consume(callback,
                             queue=queue_name,
                             no_ack=True)
   
       channel.start_consuming()