zoukankan      html  css  js  c++  java
  • day10 Python作用域 Python2.7与Python3.x的类继承的区别、异步IO、多进程,多线程简介

    一、Python作用域

      1、Python中无块级作用域

    if 1 == 1:
        name = 'test'
    
    print(name)
    
    #输出会报错,因为name的作用域仅限于if下的代码块,而不属于全局

      2、Python中以函数为作用域

    def func():
        func_name = 'func_test'
    
    print(func_name)
    
    #这里同样会报错,因为变量func_name的作用于func函数中

      3、Python作用域链,层层嵌套,使用时从内向外找

      4、Python的作用域在执行之前已经确定

    name = 'test'
    def f1():
        print(name)
    
    def f2():
        name = 'f2_test'
        return f1
    
    res = f2()
    res()
    
    
    #最终输出结果为test

    eg:

    li = [lambda :x for x in range(10)]
    # print(li)
    print(li[0]())   #输出为9
    '''
    lambda :x for x in range(10)
    将以上分解
    lambda :x =:
    def func():
        return x
    
    x for x in range(10)
    x分别等于0-9
    
    x for x in range(10)为一个代码块,所以x为全局变量
    lambda :x为一个函数,函数中未定义x的值,所以x取全局变量中x的值,上面的for循环结束后x最后的值为9,所以lamdba中x的值为9
    '''

    二、Python2.7与Python3.x的类继承的区别

    代码示例:

    class A(object):
        def f1(self):
            print('A')
    
    class B(A):
        def f2(self):
            print('B')
    class C(A):
        def f1(self):
            print('C')
    
    class D(B):
        def f2(self):
            print('D')
    
    class E(C):
        def f1(self):
            print('E')
    
    class F(D,E):
        def f2(self):
            print('f')
    
    obj = F()
    obj.f1()

    以下为上面代码在Python2.7及Python3.x中的类继承区别

       Python2.7(默认不继承object的类叫经典类,默认继承object的类叫新式类,Python3中默认都继承object,所以Python3中无新式类和经典类的区别)

    在寻找某个方法时,寻找的顺序如下(先左后右)

    python2.7

    Python3.x

    python3

    三、IO异步

    IO多路复用
        概述
            select,poll,epoll
        监听socket对象内部是否变化了?
        什么时候变化?连接或收发消息
        服务器端的socket对象发生变化 -》 有新连接来了...
        sk: 有新连接来了...
        conn:要收“发”消息了
        IO多路复用 -- 监听socket对象内部是否变化了?
        

    使用select实现IO异步

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    # Author:Alex Li
    import socket
    import select
    
    sk = socket.socket()
    sk.bind(('127.0.0.1', 9999,))
    sk.listen(5)
    
    inputs = [sk,]
    outputs = []
    messages = {}
    # del messages[白宇]
    # messages = {
    #    白宇:[消息1,消息2,]
    #    吴文煜:[消息1,消息2,]
    # }
    while True:
        rlist,wlist,elist, = select.select(inputs, outputs,[sk,],1)
        print(len(inputs),len(rlist),len(wlist), len(outputs))
        # 监听sk(服务器端)对象,如果sk对象发生变化,表示有客户端来连接了,此时rlist值为【sk】
        # 监听conn对象,如果conn发生变化,表示客户端有新消息发送过来了,此时rlist的之为 【客户端】
        # rlist = 【吴文煜,】
        # rlist = 【张磊,白宇,】
        # rlist = [sk,]
        for r in rlist:
            if r == sk:
                # 新客户来连接
                conn, address = r.accept()
                # conn是什么?其实socket对象
                inputs.append(conn)
                messages[conn] = []
                conn.sendall(bytes('hello', encoding='utf-8'))
            else:
                # 有人给我发消息了
                print('=======')
                try:
                    ret = r.recv(1024)
                    # r.sendall(ret)
                    if not ret:
                        raise Exception('断开连接')
                    else:
                        outputs.append(r)
                        messages[r].append(ret)
                except Exception as e:
                    inputs.remove(r)
                    del messages[r]
    
        # 所有给我发过消息的人
          #实现读写分离
        for w in wlist:
            msg = messages[w].pop()
            resp = msg + bytes('response', encoding='utf-8')
            w.sendall(resp)
            outputs.remove(w)
    
    
    
    # rlist = [sk,],rlist=[sk1,],rlist = [sk1,sk2]
    # rlist = []

    四、多线程(threading模块)

    import time
    def f1(i):
        time.sleep(1)
        print(i)
    
    import threading
    for j in range(10):
        t1 = threading.Thread(target=f1, args=(j,))
        t1.start()
    
    
    #最终输出不会按照0-9的顺序输出,t1.start()是随机进行的
    import time
    def f1(arg, t=None):
        if t:
            t._delete()
        time.sleep(5)
        print(arg)
    
    
    # for i in range(10):
    #     f1(i)
    # 单进程、单线程的应用程序
    import threading
    t1 = threading.Thread(target=f1, args=(1,))
    #t.setDaemon(True) # true,表示主线程不等此子线程
    t1.start()# 不代表当前线程会被立即执行
    #t.join(2)          # 表示主线程到此,等待 ... 直到子线程执行完毕
                       # 参数,表示主线程在此最多等待n秒
    
    t2 = threading.Thread(target=f1, args=(2,t1))
    t2.start()# 不代表当前线程会被立即执行
    print('end')
    print('end')
    print('end')
    print('end')
    print('end')

    五、多线程、多进程

    概述:
        1、一个应用程序,可以有多进程和多线程
        2、默认:单进程,单线程
        3、单进程,多线程:IO操作,不占用CPU
            IO操作,不占用CPU
                多线程提高并发
            计算性操作,占用CPU
                多进程提高并发
        4、GIL,全局解释器锁
        ===》
            多线程、多进程  提供并发
            IO密集型:多线程
            计算密集型:多进程
               PS:IO操作,不占用CPU     GIL,全局解释器锁
  • 相关阅读:
    桌面工具集
    运维工具集
    使用Maven插件构建Spring Boot应用程序Docker镜像
    解决Ubuntu 17.10设置面板打不开的问题
    防止Web表单重复提交的方法总结
    深入浅出mybatis之启动详解
    yum方式安装mysql
    在Java中调用Python
    UUID在Java中的实现与应用
    VM克隆后找不到eth0的问题解决
  • 原文地址:https://www.cnblogs.com/xuanouba/p/5674977.html
Copyright © 2011-2022 走看看