python之day10(socketserver)

Day10

上节回顾：      

 socket
            1 导入模块
            2 创建socket
            3
                字节
                send    sendall
                10字节 = send("alex123123deqasdsa")
                sendall:        #会源源不断的发送完
                    while True:
                        10字节 = send("alex123123deqasdsa")
                        10字节 = send("alex123123deqasdsa")
                        10字节 = send("alex123123deqasdsa")
                recv(2048)        #最多接收2048字节
        粘包：ack
        socketserver
            
            1 自定义类
            2 继承类
            3 handle方法
            4 socketserver == 调用自定义类
            5 运行 forever

上节作业

    1 socket 发送字符串
    2 socket发送文件
        客户端：
            文件大小
            发消息
            
        服务器端：
            接收消息（根据文件大小）
            
        客户端：
            json ->用户 密码
            字符串
        服务端：
            用户验证
            接受，subprocess > win > gbk编码的字节
            上传文件（大小）
            发消息

作业问题：
    断点续传
        文件：
            a 追加
            w 清空写
        文件指针：
            seek(num)

小知识点：

    作用域：
    python中无块级作用域
        java/c#        不可
        python/javascript    可以
        if 1==1：
            name = "alex"
        print(name)

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

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

name = "alex"

def f1():
    print(name)

def f2():
    name = "eric"
    return f1

ret = f2()
ret()

    python以函数作为一个作用域

    python 作用域链，由内向外找。，直到找不到报错。
    对于作用域来说，在函数为执行之前，作用域和作用域链都已经确定了
    li = [lambda :x for x in range(10)]
    print(li)
    #函数在没有执行前 ，内部代码不执行。
    li = [lambda :x for x in range(10)]
    print(li)
    print(li[0]())    
    #函数在没有执行前 ，内部代码不执行。
    9

li = [x for x in range(10)]
print(li)


li = [lambda :x for x in range(10)]
print(li)
print(li[0]())
# #函数在没有执行前 ，内部代码不执行。

li = []

for i in range(10):
    def f1():
        return i
    li.append(f1)

li[0]()

py27多继承 py35多继承

py35都继承object 27中的新式类


socketserver源码***
    ****支持并发处理socket****

    

IO多路复用：

    概述：
        select,poll,epoll
    select 个数限制 1024
    poll 无个数限制 不能跨平台
    epoll 谁变化了 主动告诉epoll
    监听socket对象内部是否变化了？
    什么时候变化？连接或收发消息
    服务器端的socket对象发生变化？就有新链接来了
    sk:有新连接来了。。。
    conn：要收"发"消息了
    
    IO多路复用 == 监听socket对象内部是否变化了？
    win--select
    rlist,w,e = select.select([sk,],[],[],1)  1是超时时间 1s
    #rlist中socket对象列表
    #sk有变化 rlist=[sk,]
    #sk无变化 rlist= []
    
    for r in rlist:
        conn, address = r.accept()
        conn,sendall(byte("hello"))
        
    实现读写分离

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import socket
import select

sk = socket.socket()
sk.bind(("127.0.0.1", 9999))
sk.listen(5)

inputs = [sk, ]
outputs = []
message = {}

while True:
    rlist, wlist, e, = select.select(inputs, outputs, [], 1)
    print(len(inputs), len(rlist), len(wlist), len(outputs))

    for r in rlist:
        if r == sk:

            print(r)
            conn,addr = r.accept()
            inputs.append(conn)
            message[conn] = []
            conn.sendall(bytes("hello",encoding="utf-8"))

        else:
            # r.recv(1024)
            print("==========")
            try:
                ret = r.recv(1024)
                if not ret:
                    raise Exception ("断开连接")
                else:
                    outputs.append(r)
                    message[r].append(ret)
            except Exception as e:
                inputs.remove(r)
                del message[r]

    for w in wlist:
        msg = message[w].pop()
        rspe = msg + bytes("response", encoding="utf-8")
        w.sendall(rspe)
        outputs.remove(w)

#!/usr/bin/env  python
# -*- coding: UTF-8 -*-
# Author: Aaron Shen

import socket
sk = socket.socket()
sk.connect(("127.0.0.1",9999))

date = sk.recv(1024)
print(date)

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

sk.close()

多线程，多进程，协程    

　　概述：
        
    Alex甄嬛西游传
    
    1  一个应用程序，可以有多进程和多线程，默认是单进程，单线程
    2 默认：单进程，单线程。
    3 单进程，多线程
    
        多线程： IO操作 -- 不占用cpu  可以提高并发
                        多线程提高并发
                计算性操作，需要占用cpu ，无法提高并发
                        多进程提高并发
    4 GIL 全局解释器锁
    ====
        多线程，多进程 提供并发
        IO密集型：多线程
        计算密集型 多进程提高并发    
            PS IO操作 不占用cpu  GIL 全局解释器
            
如何创建线程
def f1(arg):
    print(arg)
    
#for i in range(10):

import threading

t = threading.Thread(target=f1, args=(123, ))  #子线程
t.setDaemon(True)  #true 表示主线程不等此子线程 默认是False
t.start()    #不代表当前线程会被立即执行。
t.join(2)    #主线程停止，等待子线程执行完在执行
            #参数2 表示主线程最多等待2秒
f1(111)
print("end")

def f1(arg):
	print(arg)

#for i in range(10):

import threading

t = threading.Thread(target=f1, args=(123, ))  #子线程
t.setDaemon(True)  #true 表示主线程不等此子线程
t.start()	#不代表当前线程会被立即执行。
t.join(2)	#主线程停止，等待子线程执行完在执行
			#参数2 表示主线程最多等待2秒
f1(111)
print("end")