day10 Python作用域 Python2.7与Python3.x的类继承的区别及其他

if 1 == 1:
    name = ‘test‘

print(name)

#输出会报错，因为name的作用域仅限于if下的代码块，而不属于全局

def func():
    func_name = ‘func_test‘

print(func_name)

#这里同样会报错，因为变量func_name的作用于func函数中

name = ‘test‘
def f1():
    print(name)

def f2():
    name = ‘f2_test‘
    return f1

res = f2()
res()


#最终输出结果为test

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
‘‘‘

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

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

#!/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 = []

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，全局解释器锁