python study to 10 socket、I/0多路复用、多线程、多进程

python作用域

1、 python中无块级作用域;java、c#是由有块级作用域的

if 1 == 1:
name = "alex"
print(name)

for i in range(10):
 name = 1
print(name)

2、函数为块级作用域

def func():
name = "alex"
print(name)

3、python的作用域在执行之前已经确认作用域，作用域链在找的由内到外

例1：
name = “alex”
def f1():
   name = “a”
   def f2():
      name = “b”
      print(name)
   f2()
f1()

例2：
name = "alex"
def f1():
print(name)
def f2():
name = "eric"
f1()
f2()

4、特殊语法

li = [ x+100 for x in range(10)] #循环列表中的for循环，x+100生成一个元素,循环几次生成几个新的元素，产生一个新的列表。
print(li)

li = [lambda :x for x in range(10)]
r = li[0]()
print(r) #为9
#li是一个列表
#li中的每个元素是一个函数
#函数在没有执行之前，内部代码不执行
#？li[0],函数
#？函数（）
#返回值是9
以上拆开后功能和下面的相同
li = []
for i in range(10):
def f1():
    return i
li.append(f1)
#li 是列表，内部元素是相同功能的函数
r = li[0]()
print(r)

python2.7与3.5的继承关系

总结：

Python 3所有的类都默认继承object，称新式类

Python 2所有的类默认不继承object，称经典类；经典类继承方式，一直继承到最后的父类。

IO多路复用

多并发连接实现：

server：

import socket
import select

sk = socket.socket()
sk.bind(('127.0.0.1', 999, ))
sk.listen(5)

while True:
    rlist,w,e, = select.select([sk,], [], [], 1) #1为超时时间
    print(rlist)
    # rlist中socket对象列表，[sk, ]
    # 有新连接 rlist = [sk]
    # 无连接 rlist = []
    for r in rlist:
        print(r)
        conn, address = r.accept() 
        conn.sendall(bytes('hello', encoding='utf-8'))

client：

import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 999, ))

data = sk.recv(1024)
print(data)
while True:
    input(">>>")
sk.close()

IO多路复用的实现，伪并发

server：

import socket
import select
sk = socket.socket()
sk.bind(('127.0.0.1', 999, ))
sk.listen(5)

inputs = [sk,]
while True:
    rlist,w,e, = select.select(inputs, [], [], 1) #1为超时时间
    print(len(inputs), len(rlist))
    # 监听sk(服务器端)对象，如果sk对象发生变化，表示有客户端来连接了，些时rlist值为[sk]
    # 监听conn对象，如果conn发生变化，表示客户端有新消息发送过来了，些时rlist的值为[客户端]
    # rlist中socket对象列表，[sk, ]
    # 有新连接 rlist = [sk]
    # 无连接 rlist = []
    for r in rlist:
        if r == sk:
            # 新客户来连接
            conn, address = r.accept()
            # conn是什么？其实也是socket对象
            inputs.append(conn)
            conn.sendall(bytes('hello', encoding='utf-8'))
        else:
            # 有人给我发消息了
            r.recv(1024)

client：

import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 999, ))

data = sk.recv(1024)
print(data)
while True:
    inp = input(">>>")
    sk.sendall(bytes(inp, encoding='utf-8'))
sk.close()

读写分离：

server：

import socket
import select
sk = socket.socket()
sk.bind(('127.0.0.1', 9998, ))
sk.listen(5)

inputs = [sk,]
outputs = []
while True:
    rlist,wlist,e, = select.select(inputs, outputs, [], 1) #1为超时时间
    print(len(inputs), len(rlist), len(wlist), len(outputs))
    # 监听sk(服务器端)对象，如果sk对象发生变化，表示有客户端来连接了，些时rlist值为[sk]
    # 监听conn对象，如果conn发生变化，表示客户端有新消息发送过来了，些时rlist的值为[客户端]
    # rlist中socket对象列表，[sk, ]
    # 有新连接 rlist = [sk]
    # 无连接 rlist = []
    for r in rlist:
        if r == sk:
            # 新客户来连接
            conn, address = r.accept()
            # conn是什么？其实也是socket对象
            inputs.append(conn)
            conn.sendall(bytes('hello', encoding='utf-8'))
        else:
            # 有人给我发消息了
            try:
                ret = r.recv(1024)
                if not ret:
                    raise Exception('断开连接')
                else:
                    outputs.append(r)
            except Exception as e:
                inputs.remove(r)
    # 所有给我发过消息的人
    for w in wlist:
        w.sendall(bytes('response', encoding='utf-8'))  #回复消息
        outputs.remove(w) # 删除已回复消息的人

client:

import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 9998, ))

data = sk.recv(1024)
print(data)
while True:
    inp = input(">>>")
    sk.sendall(bytes(inp, encoding='utf-8'))
    print(sk.recv(1024))
sk.close()

读写分离后实现+response

server:

import socket
import select
sk = socket.socket()
sk.bind(('127.0.0.1', 9998, ))
sk.listen(5)

inputs = [sk,]
outputs = []
messages = {}
# del messages[alex] #删除alex的消息
# message = {
#     alex:[msg1, msg2, ]
#     eric:[msg1, msg2, ]
# }

while True:
    rlist,wlist,e, = select.select(inputs, outputs, [], 1) #1为超时时间
    print(len(inputs), len(rlist), len(wlist), len(outputs))
    # 监听sk(服务器端)对象，如果sk对象发生变化，表示有客户端来连接了，些时rlist值为[sk]
    # 监听conn对象，如果conn发生变化，表示客户端有新消息发送过来了，些时rlist的值为[客户端]
    # rlist中socket对象列表，[sk, ]
    # 有新连接 rlist = [sk]
    # 无连接 rlist = []
    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:
            # 有人给我发消息了
            try:
                ret = r.recv(1024)
                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) # 删除已回复消息的wlist

client:

import socket
sk = socket.socket()
sk.connect(('127.0.0.1', 9998, ))

data = sk.recv(1024)
print(data)
while True:
    inp = input(">>>")
    sk.sendall(bytes(inp, encoding='utf-8'))
    print(sk.recv(1024))
sk.close()

Threading源码执行流程

　　

进程与线程

概述：

1、一个应用程序，可以有多进程和多线程

2、默认：单进程，单线程

3、单进程，多线程

• IO操作，不占用CPU

             多线程提高并发

• 计算性操作，占用CPU

            多进程提高并发

4、GIL，全局解释器锁

创建主线程、子线程

def f1(arg):
    print(arg)

# for i in range(10):
#    f1(i)
# 单进程、单线程的应用程序
import threading

t = threading.Thread(target=f1, args=(123,))
t.start() #不代表当前纯种会被立即执行
f1(111) #主线程

基本配置参数：

import time
def f1(arg):
    time.sleep(2)
    print(arg)

# for i in range(10):
#    f1(i)
# 单进程、单线程的应用程序
import threading

t = threading.Thread(target=f1, args=(123,))
t.setDaemon(True) # true，表示主线程不等此子线程
t.start() # 不代表当前纯种会被立即执行
t.join(5)  # 表示主线程至此，等待....，直到子线程执行完毕
           # 参数：表示主线程最多等待时间n秒
# f1(111) #主线程
print('end')
print('end')
print('end')
print('end')