码迷,mamicode.com
首页 > 编程语言 > 详细

python day11

时间:2016-07-23 12:03:26      阅读:237      评论:0      收藏:0      [点我收藏+]

标签:

python 线程

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
  
def show(arg):
    time.sleep(1)
    print (‘thread‘+str(arg))
  
for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()
  
print (‘main thread stop‘)

  

更多方法:

      • start            线程准备就绪,等待CPU调度
    • setName      为线程设置名称
    • getName      获取线程名称
    • setDaemon   设置为后台线程或前台线程(默认)
                         如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止
                          如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止
    • join              逐个执行每个线程,执行完毕后继续往下执行,该方法使得多线程变得无意义
    • run              线程被cpu调度后自动执行线程对象的run方法
      • #!/usr/bin/env python
        #-*-coding:utf-8-*-
        import threading
        import time
         
         
        class MyThread(threading.Thread):
            def __init__(self,num):
                threading.Thread.__init__(self)
                self.num = num
         
            def run(self):#定义每个线程要运行的函数
         
                print("running on number:%s" %self.num)
         
                time.sleep(3)
         
        if __name__ == __main__:
         
            t1 = MyThread(1)
            t2 = MyThread(2)
            t1.start()
            t2.start()

        线程锁(Lock、RLock)

        由于线程之间是进行随机调度,并且每个线程可能只执行n条执行之后,当多个线程同时修改同一条数据时可能会出现脏数据,所以,出现了线程锁 - 同一时刻允许一个线程执行操作。

      •  1 复制代码
         2 #!/usr/bin/env python
         3 # -*- coding:utf-8 -*-
         4 import threading
         5 import time
         6 
         7 gl_num = 0
         8 
         9 def show(arg):
        10     global gl_num
        11     time.sleep(1)
        12     gl_num +=1
        13     print (gl_num)
        14 
        15 for i in range(10):
        16     t = threading.Thread(target=show, args=(i,))
        17     t.start()
        18 
        19 print (main thread stop)
        #!/usr/bin/env python
        #coding:utf-8
           
        import threading
        import time
           
        gl_num = 0
           
        lock = threading.RLock()
           
        def Func():
            lock.acquire()
            global gl_num
            gl_num +=1
            time.sleep(1)
            print (gl_num)
            lock.release()
               
        for i in range(10):
            t = threading.Thread(target=Func)
            t.start()
        

        信号量(Semaphore)

        互斥锁 同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程更改数据 ,比如厕所有3个坑,那最多只允许3个人上厕所,后面的人只能等里面有人出来了才能再进去。

      • #!/usr/bin/env python
        #-*-coding:utf-8-*-
        import threading,time
         
        def run(n):
            semaphore.acquire()
            time.sleep(1)
            print("run the thread: %s" %n)
            semaphore.release()
         
        if __name__ == ‘__main__‘:
         
            num= 0
            semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
            for i in range(20):
                t = threading.Thread(target=run,args=(i,))
                t.start()
        

        事件(event)

        python线程的事件用于主线程控制其他线程的执行,事件主要提供了三个方法 set、wait、clear。

        事件处理的机制:全局定义了一个“Flag”,如果“Flag”值为 False,那么当程序执行 event.wait 方法时就会阻塞,如果“Flag”值为True,那么event.wait 方法时便不再阻塞。

        • clear:将“Flag”设置为False
        • set:将“Flag”设置为True
          • #!/usr/bin/env python
            # -*- coding:utf-8 -*-
             
            import threading
             
             
            def do(event):
                print (‘start‘)
                event.wait()
                print ‘execute‘
             
             
            event_obj = threading.Event()
            for i in range(10):
                t = threading.Thread(target=do, args=(event_obj,))
                t.start()
             
            event_obj.clear()
            inp = input(‘input:‘)
            if inp == ‘true‘:
                event_obj.set()
            

            条件(Condition)

            使得线程等待,只有满足某条件时,才释放n个线程

          • #!/usr/bin/env python
            #-*-coding:utf-8-*-
            import threading
             
            def run(n):
                con.acquire()
                con.wait()
                print("run the thread: %s" %n)
                con.release()
             
            if __name__ == ‘__main__‘:
             
                con = threading.Condition()
                for i in range(10):
                    t = threading.Thread(target=run, args=(i,))
                    t.start()
             
                while True:
                    inp = input(‘>>>‘)
                    if inp == ‘q‘:
                        break
                    con.acquire()
                    con.notify(int(inp))
                    con.release()
            
            复制代码
            def condition_func():
            
                ret = False
                inp = input(>>>)
                if inp == 1:
                    ret = True
            
                return ret
            
            
            def run(n):
                con.acquire()
                con.wait_for(condition_func)
                print("run the thread: %s" %n)
                con.release()
            
            if __name__ == __main__:
            
                con = threading.Condition()
                for i in range(10):
                    t = threading.Thread(target=run, args=(i,))
                    t.start()

            Timer

          • 定时器,指定n秒后执行某操作

          • from threading import Timer
             
             
            def hello():
                print("hello, world")
             
            t = Timer(1, hello)
            t.start()  # after 1 seconds, "hello, world" will be printed
            

              

          • python 进程
            • from multiprocessing import Process
              import threading
              import time
                
              def foo(i):
                  print ‘say hi‘,i
                
              for i in range(10):
                  p = Process(target=foo,args=(i,))
                  p.start()
              

                

            • 进程数据共享

              进程各自持有一份数据,默认无法共享数据

            • 技术分享
               1 #!/usr/bin/env python
               2 #coding:utf-8
               3  
               4 from multiprocessing import Process
               5 from multiprocessing import Manager
               6  
               7 import time
               8  
               9 li = []
              10  
              11 def foo(i):
              12     li.append(i)
              13     print (say hi,li)
              14   
              15 for i in range(10):
              16     p = Process(target=foo,args=(i,))
              17     p.start()
              18      
              19 print (ending,li)
              进程间默认无法数据共享
              #方法一,Array
              from multiprocessing import Process,Array
              temp = Array(‘i‘, [11,22,33,44])
               
              def Foo(i):
                  temp[i] = 100+i
                  for item in temp:
                      print (i,‘----->‘,item)
               
              for i in range(2):
                  p = Process(target=Foo,args=(i,))
                  p.start()
               
              #方法二:manage.dict()共享数据
              from multiprocessing import Process,Manager
               
              manage = Manager()
              dic = manage.dict()
               
              def Foo(i):
                  dic[i] = 100+i
                  print (dic.values())
               
              for i in range(2):
                  p = Process(target=Foo,args=(i,))
                  p.start()
                  p.join()
              

                

              技术分享
              1   c: ctypes.c_char,  u: ctypes.c_wchar,
              2     b: ctypes.c_byte,  B: ctypes.c_ubyte,
              3     h: ctypes.c_short, H: ctypes.c_ushort,
              4     i: ctypes.c_int,   I: ctypes.c_uint,
              5     l: ctypes.c_long,  L: ctypes.c_ulong,
              6     f: ctypes.c_float, d: ctypes.c_double
              类型对应表
              技术分享
               1 from multiprocessing import Process, queue
               2 
               3 def f(i,q):
               4     print(i,q.get())
               5 
               6 if __name__ == __main__:
               7     q = Queue()
               8 
               9     q.put("h1")
              10     q.put("h2")
              11     q.put("h3")
              12 
              13     for i in range(10):
              14         p = Process(target=f, args=(i,q,))
              15         p.start()
              View Code

               

            •  

              • 当创建进程时(非使用时),共享数据会被拿到子进程中,当进程中执行完毕后,再赋值给原值。
              • 技术分享
                 1 复制代码
                 2 #!/usr/bin/env python
                 3 # -*- coding:utf-8 -*-
                 4 
                 5 from multiprocessing import Process, Array, RLock
                 6 
                 7 def Foo(lock,temp,i):
                 8     """
                 9     将第0个数加100
                10     """
                11     lock.acquire()
                12     temp[0] = 100+i
                13     for item in temp:
                14         print (i,----->,item)
                15     lock.release()
                16 
                17 lock = RLock()
                18 temp = Array(i, [11, 22, 33, 44])
                19 
                20 for i in range(20):
                21     p = Process(target=Foo,args=(lock,temp,i,))
                22     p.start()
                进程锁实例

                 

              • 进程池

                进程池内部维护一个进程序列,当使用时,则去进程池中获取一个进程,如果进程池序列中没有可供使用的进进程,那么程序就会等待,直到进程池中有可用进程为止。

                进程池中有两个方法:

                  • apply
                  • apply_async
                    • #!/usr/bin/env python
                      # -*- coding:utf-8 -*-
                      from  multiprocessing import Process,Pool
                      import time
                        
                      def Foo(i):
                          time.sleep(2)
                          return i+100
                        
                      def Bar(arg):
                          print arg
                        
                      pool = Pool(5)
                      #print( pool.apply(Foo,(1,)))
                      #print (pool.apply_async(func =Foo, args=(1,)).get())
                        
                      for i in range(10):
                          pool.apply_async(func=Foo, args=(i,),callback=Bar)
                        
                      print (‘end‘)
                      pool.close()
                      pool.join()#进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
                      

                        

                  • 协程
                  • 线程和进程的操作是由程序触发系统接口,最后的执行者是系统;协程的操作则是程序员。

                    协程存在的意义:对于多线程应用,CPU通过切片的方式来切换线程间的执行,线程切换时需要耗时(保存状态,下次继续)。协程,则只使用一个线程,在一个线程中规定某个代码块执行顺序。

                    协程的适用场景:当程序中存在大量不需要CPU的操作时(IO),适用于协程;

                  • greenlet
                    
                    #!/usr/bin/env python
                    # -*- coding:utf-8 -*-
                     
                     
                    from greenlet import greenlet
                     
                     
                    def test1():
                        print (12)
                        gr2.switch()
                        print (34)
                        gr2.switch()
                     
                     
                    def test2():
                        print (56)
                        gr1.switch()
                        print (78)
                     
                    gr1 = greenlet(test1)
                    gr2 = greenlet(test2)
                    gr1.switch()
                    

                      gevent

                    • import gevent
                       
                      def foo():
                          print(‘Running in foo‘)
                          gevent.sleep(0)
                          print(‘Explicit context switch to foo again‘)
                       
                      def bar():
                          print(‘Explicit context to bar‘)
                          gevent.sleep(0)
                          print(‘Implicit context switch back to bar‘)
                       
                      gevent.joinall([
                          gevent.spawn(foo),
                          gevent.spawn(bar),
                      ])
                      

                       

                    • python 操作memcached

                    • Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信。

                      Memcached安装和基本使用

                      Memcached安装:

                    • wget http://memcached.org/latest
                      tar -zxvf memcached-1.x.x.tar.gz
                      cd memcached-1.x.x
                      ./configure && make && make test && sudo make install
                       
                      PS:依赖libevent
                             yum install libevent-devel
                             apt-get install libevent-dev
                      

                        启动memcached

                    • memcached -d -m 10    -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid
                       
                      参数说明:
                          -d 是启动一个守护进程
                          -m 是分配给Memcache使用的内存数量,单位是MB
                          -u 是运行Memcache的用户
                          -l 是监听的服务器IP地址
                          -p 是设置Memcache监听的端口,最好是1024以上的端口
                          -c 选项是最大运行的并发连接数,默认是1024,按照你服务器的负载量来设定
                          -P 是设置保存Memcache的pid文件
                      

                        memcached命令

                    • 存储命令: set/add/replace/append/prepend/cas
                      获取命令: get/gets
                      其他命令: delete/stats..
                      

                        python操作memcached

                    • 安装api
                      python操作Memcached使用Python-memcached模块
                      下载安装:https://pypi.python.org/pypi/python-memcached
                      

                        1.第一次操作

                    • import memcache
                       
                      mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                      mc.set("foo", "bar")
                      ret = mc.get(‘foo‘)
                      print (ret)
                      

                        Ps:debug = True 表示运行出现错误时,现实错误信息,上线后移除该参数。

                    • 2、天生支持集群

                    •  

                        python-memcached模块原生支持集群操作,其原理是在内存维护一个主机列表,且集群中主机的权重值和主机在列表中重复出现的次数成正比

                    •      主机    权重
                          1.1.1.1   1
                          1.1.1.2   2
                          1.1.1.3   1
                       
                      那么在内存中主机列表为:
                          host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]
                      

                        

                      如果用户根据如果要在内存中创建一个键值对(如:k1 = "v1"),那么要执行一下步骤:

                      • 根据算法将 k1 转换成一个数字
                      • 将数字和主机列表长度求余数,得到一个值 N( 0 <= N < 列表长度 )
                      • 在主机列表中根据 第2步得到的值为索引获取主机,例如:host_list[N]
                      • 连接 将第3步中获取的主机,将 k1 = "v1" 放置在该服务器的内存中

                      代码实现如下:

                      • mc = memcache.Client([(‘1.1.1.1:12000‘, 1), (‘1.1.1.2:12000‘, 2), (‘1.1.1.3:12000‘, 1)], debug=True)
                         
                        mc.set(‘k1‘, ‘v1‘)
                        

                          3、add

                      • 添加一条键值对,如果已经存在的 key,重复执行add操作异常

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                        mc.add(‘k1‘, ‘v1‘)
                        # mc.add(‘k1‘, ‘v2‘) # 报错,对已经存在的key重复添加,失败!!!
                        

                          

                        4、replace
                        replace 修改某个key的值,如果key不存在,则异常

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                        # 如果memcache中存在kkkk,则替换成功,否则一场
                        mc.replace(‘kkkk‘,‘999‘)
                        

                          

                        5、set 和 set_multi

                        set            设置一个键值对,如果key不存在,则创建,如果key存在,则修改
                        set_multi   设置多个键值对,如果key不存在,则创建,如果key存在,则修改

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                         
                        mc.set(‘key0‘, ‘wupeiqi‘)
                         
                        mc.set_multi({‘key1‘: ‘val1‘, ‘key2‘: ‘val2‘})
                        

                          

                        6、delete 和 delete_multi

                        delete             在Memcached中删除指定的一个键值对
                        delete_multi    在Memcached中删除指定的多个键值对

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                         
                        mc.delete(‘key0‘)
                        mc.delete_multi([‘key1‘, ‘key2‘])
                        

                          

                        7、get 和 get_multi

                        get            获取一个键值对
                        get_multi   获取多一个键值对

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                         
                        val = mc.get(‘key0‘)
                        item_dict = mc.get_multi(["key1", "key2", "key3"])
                        

                          

                        8、append 和 prepend

                        append    修改指定key的值,在该值 后面 追加内容
                        prepend   修改指定key的值,在该值 前面 插入内容

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                        # k1 = "v1"
                         
                        mc.append(‘k1‘, ‘after‘)
                        # k1 = "v1after"
                         
                        mc.prepend(‘k1‘, ‘before‘)
                        # k1 = "beforev1after"
                        

                          

                        9、decr 和 incr  

                        incr  自增,将Memcached中的某一个值增加 N ( N默认为1 )
                        decr 自减,将Memcached中的某一个值减少 N ( N默认为1 )

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                         
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True)
                        mc.set(‘k1‘, ‘777‘)
                         
                        mc.incr(‘k1‘)
                        # k1 = 778
                         
                        mc.incr(‘k1‘, 10)
                        # k1 = 788
                         
                        mc.decr(‘k1‘)
                        # k1 = 787
                         
                        mc.decr(‘k1‘, 10)
                        # k1 = 777
                        

                          

                        10、gets 和 cas

                        如商城商品剩余个数,假设改值保存在memcache中,product_count = 900
                        A用户刷新页面从memcache中读取到product_count = 900
                        B用户刷新页面从memcache中读取到product_count = 900

                        如果A、B用户均购买商品

                        A用户修改商品剩余个数 product_count=899
                        B用户修改商品剩余个数 product_count=899

                        如此一来缓存内的数据便不在正确,两个用户购买商品后,商品剩余还是 899
                        如果使用python的set和get来操作以上过程,那么程序就会如上述所示情况!

                        如果想要避免此情况的发生,只要使用 gets 和 cas 即可,如:

                      • #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                        import memcache
                        mc = memcache.Client([‘10.211.55.4:12000‘], debug=True, cache_cas=True)
                         
                        v = mc.gets(‘product_count‘)
                        # ...
                        # 如果有人在gets之后和cas之前修改了product_count,那么,下面的设置将会执行失败,剖出异常,从而避免非正常数据的产生
                        mc.cas(‘product_count‘, "899")
                        

                          Ps:本质上每次执行gets时,会从memcache中获取一个自增的数字,通过cas去修改gets的值时,会携带之前获取的自增值和memcache中的自增值进行比较,如果相等,则可以提交,如果不想等,那表示在gets和cas执行之间,又有其他人执行了gets(获取了缓冲的指定值), 如此一来有可能出现非正常数据,则不允许修改。

                      • Redis
                      • redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。

                        一、Redis安装和基本使用

                        1
                        2
                        3
                        4
                        wget http://download.redis.io/releases/redis-3.0.6.tar.gz
                        tar xzf redis-3.0.6.tar.gz
                        cd redis-3.0.6
                        make

                        启动服务端

                        1
                        src/redis-server

                        启动客户端

                        1
                        2
                        3
                        4
                        5
                        src/redis-cli
                        redis> set foo bar
                        OK
                        redis> get foo
                        "bar"

                        二、Python操作Redis

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        sudo pip install redis
                        or
                        sudo easy_install redis
                        or
                        源码安装
                         
                        详见:https://github.com/WoLpH/redis-py

                        API使用

                        redis-py 的API的使用可以分类为:

                        • 连接方式
                        • 连接池
                        • 操作
                          • String 操作
                          • Hash 操作
                          • List 操作
                          • Set 操作
                          • Sort Set 操作
                        • 管道
                        • 发布订阅

                         

                        1、操作模式

                        redis-py提供两个类Redis和StrictRedis用于实现Redis的命令,StrictRedis用于实现大部分官方的命令,并使用官方的语法和命令,Redis是StrictRedis的子类,用于向后兼容旧版本的redis-py。

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                         
                        import redis
                         
                        = redis.Redis(host=‘10.211.55.4‘, port=6379)
                        r.set(‘foo‘‘Bar‘)
                        print r.get(‘foo‘)

                        2、连接池

                        redis-py使用connection pool来管理对一个redis server的所有连接,避免每次建立、释放连接的开销。默认,每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池,然后作为参数Redis,这样就可以实现多个Redis实例共享一个连接池。

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                         
                        import redis
                         
                        pool = redis.ConnectionPool(host=‘10.211.55.4‘, port=6379)
                         
                        = redis.Redis(connection_pool=pool)
                        r.set(‘foo‘‘Bar‘)
                        print r.get(‘foo‘)

                        3、操作

                        String操作,redis中的String在在内存中按照一个name对应一个value来存储。如图:

                        技术分享

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

                        1
                        2
                        3
                        4
                        5
                        6
                        在Redis中设置值,默认,不存在则创建,存在则修改
                        参数:
                             ex,过期时间(秒)
                             px,过期时间(毫秒)
                             nx,如果设置为True,则只有name不存在时,当前set操作才执行
                             xx,如果设置为True,则只有name存在时,岗前set操作才执行

                        setnx(name, value)

                        1
                        设置值,只有name不存在时,执行设置操作(添加)

                        setex(name, value, time)

                        1
                        2
                        3
                        # 设置值
                        # 参数:
                            # time,过期时间(数字秒 或 timedelta对象)

                        psetex(name, time_ms, value)

                        1
                        2
                        3
                        # 设置值
                        # 参数:
                            # time_ms,过期时间(数字毫秒 或 timedelta对象)

                        mset(*args, **kwargs)

                        1
                        2
                        3
                        4
                        5
                        批量设置值
                        如:
                            mset(k1=‘v1‘, k2=‘v2‘)
                            
                            mget({‘k1‘‘v1‘‘k2‘‘v2‘})

                        get(name)

                        1
                        获取值

                        mget(keys, *args)

                        1
                        2
                        3
                        4
                        5
                        批量获取
                        如:
                            mget(‘ylr‘‘wupeiqi‘)
                            
                            r.mget([‘ylr‘‘wupeiqi‘])

                        getset(name, value)

                        1
                        设置新值并获取原来的值

                        getrange(key, start, end)

                        1
                        2
                        3
                        4
                        5
                        6
                        # 获取子序列(根据字节获取,非字符)
                        # 参数:
                            # name,Redis 的 name
                            # start,起始位置(字节)
                            # end,结束位置(字节)
                        # 如: "武沛齐" ,0-3表示 "武"

                        setrange(name, offset, value)

                        1
                        2
                        3
                        4
                        # 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
                        # 参数:
                            # offset,字符串的索引,字节(一个汉字三个字节)
                            # value,要设置的值

                        setbit(name, offset, value)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        14
                        15
                        16
                        17
                        18
                        19
                        20
                        21
                        22
                        23
                        24
                        25
                        26
                        27
                        # 对name对应值的二进制表示的位进行操作
                         
                        # 参数:
                            # name,redis的name
                            # offset,位的索引(将值变换成二进制后再进行索引)
                            # value,值只能是 1 或 0
                         
                        # 注:如果在Redis中有一个对应: n1 = "foo",
                                那么字符串foo的二进制表示为:01100110 01101111 01101111
                            所以,如果执行 setbit(‘n1‘71),则就会将第7位设置为1
                                那么最终二进制则变成 01100111 01101111 01101111,即:"goo"
                         
                        # 扩展,转换二进制表示:
                         
                            # source = "武沛齐"
                            source = "foo"
                         
                            for in source:
                                num = ord(i)
                                print bin(num).replace(‘b‘,‘‘)
                         
                            特别的,如果source是汉字 "武沛齐"怎么办?
                            答:对于utf-8,每一个汉字占 3 个字节,那么 "武沛齐" 则有 9个字节
                               对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
                                11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000
                                -------------------------- ----------------------------- -----------------------------
                                            武                         沛                           齐

                        getbit(name, offset)

                        1
                        # 获取name对应的值的二进制表示中的某位的值 (0或1)

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

                        1
                        2
                        3
                        4
                        5
                        # 获取name对应的值的二进制表示中 1 的个数
                        # 参数:
                            # key,Redis的name
                            # start,位起始位置
                            # end,位结束位置

                        bitop(operation, dest, *keys)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        # 获取多个值,并将值做位运算,将最后的结果保存至新的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)

                        1
                        # 返回name对应值的字节长度(一个汉字3个字节)

                        incr(self, name, amount=1)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        # 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
                         
                        # 参数:
                            # name,Redis的name
                            # amount,自增数(必须是整数)
                         
                        # 注:同incrby

                        incrbyfloat(self, name, amount=1.0)

                        1
                        2
                        3
                        4
                        5
                        # 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
                         
                        # 参数:
                            # name,Redis的name
                            # amount,自增数(浮点型)

                        decr(self, name, amount=1)

                        1
                        2
                        3
                        4
                        5
                        # 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。
                         
                        # 参数:
                            # name,Redis的name
                            # amount,自减数(整数)

                        append(key, value)

                        1
                        2
                        3
                        4
                        5
                        # 在redis name对应的值后面追加内容
                         
                        # 参数:
                            key, redis的name
                            value, 要追加的字符串

                          

                        Hash操作,redis中Hash在内存中的存储格式如下图:

                        技术分享

                        hset(name, key, value)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        # name对应的hash中设置一个键值对(不存在,则创建;否则,修改)
                         
                        # 参数:
                            # name,redis的name
                            # key,name对应的hash中的key
                            # value,name对应的hash中的value
                         
                        # 注:
                            # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)

                        hmset(name, mapping)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        # 在name对应的hash中批量设置键值对
                         
                        # 参数:
                            # name,redis的name
                            # mapping,字典,如:{‘k1‘:‘v1‘, ‘k2‘: ‘v2‘}
                         
                        # 如:
                            # r.hmset(‘xx‘, {‘k1‘:‘v1‘, ‘k2‘: ‘v2‘})

                        hget(name,key)

                        1
                        # 在name对应的hash中获取根据key获取value

                        hmget(name, keys, *args)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        # 在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)

                        1
                        获取name对应hash的所有键值

                        hlen(name)

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

                        hkeys(name)

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

                        hvals(name)

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

                        hexists(name, key)

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

                        hdel(name,*keys)

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

                        hincrby(name, key, amount=1)

                        1
                        2
                        3
                        4
                        5
                        # 自增name对应的hash中的指定key的值,不存在则创建key=amount
                        # 参数:
                            # name,redis中的name
                            # key, hash对应的key
                            # amount,自增数(整数)

                        hincrbyfloat(name, key, amount=1.0)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        # 自增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)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        # 增量式迭代获取,对于数据大的数据非常有用,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)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        # 利用yield封装hscan创建生成器,实现分批去redis中获取数据
                         
                        # 参数:
                            # match,匹配指定key,默认None 表示所有的key
                            # count,每次分片最少获取个数,默认None表示采用Redis的默认分片个数
                         
                        # 如:
                            # for item in r.hscan_iter(‘xx‘):
                            #     print item

                          

                        List操作,redis中的List在在内存中按照一个name对应一个List来存储。如图:

                        技术分享

                        lpush(name,values)

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

                        lpushx(name,value)

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

                        llen(name)

                        1
                        # name对应的list元素的个数

                        linsert(name, where, refvalue, value))

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        # 在name对应的列表的某一个值前或后插入一个新值
                         
                        # 参数:
                            # name,redis的name
                            # where,BEFORE或AFTER
                            # refvalue,标杆值,即:在它前后插入数据
                            # value,要插入的数据

                        r.lset(name, index, value)

                        1
                        2
                        3
                        4
                        5
                        6
                        # 对name对应的list中的某一个索引位置重新赋值
                         
                        # 参数:
                            # name,redis的name
                            # index,list的索引位置
                            # value,要设置的值

                        r.lrem(name, value, num)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        # 在name对应的list中删除指定的值
                         
                        # 参数:
                            # name,redis的name
                            # value,要删除的值
                            # num,  num=0,删除列表中所有的指定值;
                                   # num=2,从前到后,删除2个;
                                   # num=-2,从后向前,删除2个

                        lpop(name)

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

                        lindex(name, index)

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

                        lrange(name, start, end)

                        1
                        2
                        3
                        4
                        5
                        # 在name对应的列表分片获取数据
                        # 参数:
                            # name,redis的name
                            # start,索引的起始位置
                            # end,索引结束位置

                        ltrim(name, start, end)

                        1
                        2
                        3
                        4
                        5
                        # 在name对应的列表中移除没有在start-end索引之间的值
                        # 参数:
                            # name,redis的name
                            # start,索引的起始位置
                            # end,索引结束位置

                        rpoplpush(src, dst)

                        1
                        2
                        3
                        4
                        # 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
                        # 参数:
                            # src,要取数据的列表的name
                            # dst,要添加数据的列表的name

                        blpop(keys, timeout)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        # 将多个列表排列,按照从左到右去pop对应列表的元素
                         
                        # 参数:
                            # keys,redis的name的集合
                            # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞
                         
                        # 更多:
                            # r.brpop(keys, timeout),从右向左获取数据

                        brpoplpush(src, dst, timeout=0)

                        1
                        2
                        3
                        4
                        5
                        6
                        # 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
                         
                        # 参数:
                            # src,取出并要移除元素的列表对应的name
                            # dst,要插入元素的列表对应的name
                            # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

                        自定义增量迭代

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        14
                        15
                        16
                        17
                        18
                        # 由于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

                        Set操作,Set集合就是不允许重复的列表

                        sadd(name,values)

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

                        scard(name)

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

                        sdiff(keys, *args)

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

                        sdiffstore(dest, keys, *args)

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

                        sinter(keys, *args)

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

                        sinterstore(dest, keys, *args)

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

                        sismember(name, value)

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

                        smembers(name)

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

                        smove(src, dst, value)

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

                        spop(name)

                        1
                        # 从集合的右侧(尾部)移除一个成员,并将其返回

                        srandmember(name, numbers)

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

                        srem(name, values)

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

                        sunion(keys, *args)

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

                        sunionstore(dest,keys, *args)

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

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

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

                         

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

                        zadd(name, *args, **kwargs)

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

                        zcard(name)

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

                        zcount(name, min, max)

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

                        zincrby(name, value, amount)

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

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

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        14
                        15
                        16
                        17
                        18
                        # 按照索引范围获取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)

                        1
                        2
                        3
                        4
                        # 获取某个值在 name对应的有序集合中的排行(从 0 开始)
                         
                        # 更多:
                            # zrevrank(name, value),从大到小排序

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

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        14
                        15
                        16
                        17
                        # 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (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)

                        1
                        2
                        3
                        # 删除name对应的有序集合中值是values的成员
                         
                        # 如:zrem(‘zz‘, [‘s1‘, ‘s2‘])

                        zremrangebyrank(name, min, max)

                        1
                        # 根据排行范围删除

                        zremrangebyscore(name, min, max)

                        1
                        # 根据分数范围删除

                        zremrangebylex(name, min, max)

                        1
                        # 根据值返回删除

                        zscore(name, value)

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

                        zinterstore(dest, keys, aggregate=None)

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

                        zunionstore(dest, keys, aggregate=None)

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

                        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,用来对分数进行操作

                          

                        其他常用操作

                        delete(*names)

                        1
                        # 根据删除redis中的任意数据类型

                        exists(name)

                        1
                        # 检测redis的name是否存在

                        keys(pattern=‘*‘)

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        # 根据模型获取redis的name
                         
                        # 更多:
                            # KEYS * 匹配数据库中所有 key 。
                            # KEYS h?llo 匹配 hello , hallo 和 hxllo 等。
                            # KEYS h*llo 匹配 hllo 和 heeeeello 等。
                            # KEYS h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo

                        expire(name ,time)

                        1
                        # 为某个redis的某个name设置超时时间

                        rename(src, dst)

                        1
                        # 对redis的name重命名为

                        move(name, db))

                        1
                        # 将redis的某个值移动到指定的db下

                        randomkey()

                        1
                        # 随机获取一个redis的name(不删除)

                        type(name)

                        1
                        # 获取name对应值的类型

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

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

                         

                        4、管道

                        redis-py默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,并且默认情况下一次pipline 是原子性操作。

                        1
                        2
                        3
                        4
                        5
                        6
                        7
                        8
                        9
                        10
                        11
                        12
                        13
                        14
                        15
                        16
                        #!/usr/bin/env python
                        # -*- coding:utf-8 -*-
                         
                        import redis
                         
                        pool = redis.ConnectionPool(host=‘10.211.55.4‘, port=6379)
                         
                        = redis.Redis(connection_pool=pool)
                         
                        # pipe = r.pipeline(transaction=False)
                        pipe = r.pipeline(transaction=True)
                         
                        r.set(‘name‘‘alex‘)
                        r.set(‘role‘‘sb‘)
                         
                        pipe.execute()

                        5、发布订阅

                        技术分享

                        发布者:服务器

                        订阅者:Dashboad和数据处理

                        Demo如下:

                      • 技术分享
                         1 #!/usr/bin/env python
                         2 # -*- coding:utf-8 -*-
                         3  
                         4 from monitor.RedisHelper import RedisHelper
                         5  
                         6 obj = RedisHelper()
                         7 redis_sub = obj.subscribe()
                         8  
                         9 while True:
                        10     msg= redis_sub.parse_response()
                        11     print msg
                        View Code

                         

                  • 备注

python day11

标签:

原文地址:http://www.cnblogs.com/zl-py/p/5698116.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!