Python之路_Day10

Python之路_Day10_课堂笔记
上节回顾：
socket：
1、导入模块
2、创建socket
3、
字节
send：每次发送可能没有完全发送，send发送后会有一个返回值，是本次发送了多少。
sendall：循环发送，直到全部发送完全。
接收
recv(2048)：最多可以接收2048字节，上传文件时需要注意

粘包：
socketserver：
1、自定义类
2、继承socketserver.BaseRequestHandler类
3、重写handle方法
4、socketserver 调用上面的类
5、运行

本节内容：
一、作业问题：
1、socket发送字符串
2、socket发送文件
客户端：
文件大小
发消息
服务端：
接收消息(文件大小)

断点续传
文件打开方法：
a：追加
w：清空写
文件指针：
seek(num)

二、小知识

三、python27多继承，python35多继承

四、socketserver源码
支持并发处理socket
socket源码

五、IO多路复用

六、多线程、多进程
Alex甄嬛西游转

一、小知识
作用域
Python中无块级作用域
Java/C#                  不可以运行
python/javascript    可以运行
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # Python中无块级作用域
  6. if 1 == 1:
  7.     name = 'sandler'
  8. print(name)

Python中以函数为作用域
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # Python中以函数为作用域
  6. def func():
  7.     name = 'alex'
  8. func()
  9. print(name)

Python作用域链，由内向外找，直到找不到报错
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # Python作用域链，由内向外找，直到找不到报错
  6. name = 'sandler'
  7. def f1():
  8.     name = 'f1'
  9.     def f2():
  10.         name = 'f2'
  11.         print(name)
  12. f1()

Python在函数为执行前，作用域已经确定，作用域链也已经确定
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # Python在函数为执行前，作用域已经确定，作用域链也已经确定
  6. name = 'sandler'
  7. def f1():
  8.     print(name)
  9. def f2():
  10.     name = 'yuli'
  11.     f1()
  12. f2()


  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. li = [lambda :x for x in range(10)]
  6. # li列表
  7. # li列表中的元素：【函数，函数，函数...】
  8. # 函数在没有执行前，内部代码不执行
  9. # ？li[0],函数
  10. # ？函数()
  11. # 返回值是？？？？
  12. print(li[0]())
36672W]@8C]YZGJ6$F]0T4U.png
5T(%VD]92ZVRQ4QWVH7A$GP.png


二、python27多继承，python35多继承
Python2
新式类
经典类==>一条道走到黑
Python3







三、SocketServer源码
支持并发处理socket

Socket源码
UT9OZOD`}YNZ%RQUX`}BVGQ.png
1、TCPServer =====> __init__()
2、BaseServer =====> __init__()
3、BaseServer =====> server_forever()
4、BaseServer =====> _handle_request_noblock()
5、ThreadingMixIn ===> process_request()
6、ThreadingMixIn ===> process_request_thread()
7、BaseServer =====> finish_process()
8、BaseServer =====>
9、MyClass

  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socketserver源码
  7. import socketserver
  9. class MyClass(socketserver.BaseRequestHandler):
  11.     def handle(self):
  12.         pass
  14. # 创建socket对象
  15. # accept
  16. # server_address = ('127.0.0.1',9999)
  17. # RequestHandlerClass = MyClass == ()
  18. # self.RequestHandlerClass() = MyClass() == ()
  19. # 1、obj封装了self.RequestHandlerClass = MyClass
  20. # 2、创建了socket,bind,listen
  22. obj = socketserver.ThreadingTCPServer(('127.0.0.1',9999),MyClass)
  23. obj.serve_forever()





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

IO多路复用测试
Server
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  6. import select
  8. sk = socket.socket()
  9. sk.bind(('127.0.0.1',9999,))
  10. sk.listen(5)
  12. while True:
  13.     rlist, w, e, = select.select([sk,],[],[],1)
  14.     print(rlist)
  16.     for r in rlist:
  17.         print(r)
  18.         conn, address = r.accept()
  19.         conn.sendall(bytes('hello',encoding='utf-8'))

Client
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  7. sk = socket.socket()
  8. sk.connect(('127.0.0.1', 9999,))
  9. data = sk.recv(1024)
  10. print(data)
  11. while True:
  12.     input('>>> ')
  15. sk.close()

IO多路复用测试（第二版）
Server
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  6. import select
  8. sk = socket.socket()
  9. sk.bind(('127.0.0.1',9999,))
  10. sk.listen(5)
  12. inputs = [sk,]
  13. while True:
  14.     rlist, w, e, = select.select(inputs,[],[],1)
  15.     print(len(inputs),len(rlist))
  16.     # 监听sk（服务器端）对象，如果sk对象发送变化，表示有客户端来连接了，此时rlist值为[sk]
  17.     # 监听conn对象，如果conn发送变化，表示客户端有新消息发送过来，此时rlist的值为[客户端]
  19.     for r in rlist:
  20.         if r == sk:
  21.             conn, address = r.accept()
  22.             # conn是什么？conn其实是socket对象
  23.             inputs.append(conn)
  24.             conn.sendall(bytes('hello',encoding='utf-8'))
  25.         else:
  26.             r.recv(1024)

Client
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  7. sk = socket.socket()
  8. sk.connect(('127.0.0.1', 9999,))
  9. data = sk.recv(1024)
  10. print(data)
  11. while True:
  12.     inp = input('>>> ')
  13.     sk.sendall(bytes(inp,encoding='utf-8'))
  15. sk.close()

FI~1TYYN[(CTEY1JU90){XV.png
YI_ZDU[4YV066P0PLT[DG_7.png

IO多路复用测试之读写分离
Server
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 读写分离测试服务端
  7. import socket
  8. import select
  10. sk = socket.socket()
  11. sk.bind(('127.0.0.1',9999,))
  12. sk.listen(5)
  14. inputs = [sk,]
  15. outputs = []
  16. while True:
  17.     rlist, wlist, e, = select.select(inputs,outputs,[],1)
  18.     print(len(inputs),len(rlist),len(outputs),len(wlist))
  19.     # 监听sk（服务器端）对象，如果sk对象发送变化，表示有客户端来连接了，此时rlist值为[sk]
  20.     # 监听conn对象，如果conn发送变化，表示客户端有新消息发送过来，此时rlist的值为[客户端]
  22.     for r in rlist:
  23.         if r == sk:
  24.             conn, address = r.accept()
  25.             # conn是什么？conn其实是socket对象
  26.             inputs.append(conn)
  27.             conn.sendall(bytes('hello',encoding='utf-8'))
  28.         else:
  29.             print('========')
  30.             try:
  31.                 ret = r.recv(1024)
  32.                 if not ret:
  33.                     raise Exception('断开连接')
  34.                 else:
  35.                     outputs.append(r)
  36.             except Exception as e:
  37.                 inputs.remove(r)
  39.     for w in wlist:
  40.         w.sendall(bytes('response',encoding='utf-8'))
  41.         outputs.remove(w)

Client
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 读写分离测试客户端
  7. import socket
  9. sk = socket.socket()
  10. sk.connect(('127.0.0.1', 9999,))
  11. data = sk.recv(1024)
  12. print(data)
  13. while True:
  14.     inp = input('>>> ')
  15.     sk.sendall(bytes(inp,encoding='utf-8'))
  16.     print(sk.recv(1024))
  17. sk.close()

IO多路复用测试之读写分离（升级版）
Server
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 读写分离测试服务端
  7. import socket
  8. import select
  10. sk = socket.socket()
  11. sk.bind(('127.0.0.1',9999,))
  12. sk.listen(5)
  14. inputs = [sk,]
  15. outputs = []
  16. messages = {}
  17. while True:
  18.     rlist, wlist, e, = select.select(inputs,outputs,[],1)
  19.     print(len(inputs),len(rlist),len(outputs),len(wlist))
  20.     # 监听sk（服务器端）对象，如果sk对象发送变化，表示有客户端来连接了，此时rlist值为[sk]
  21.     # 监听conn对象，如果conn发送变化，表示客户端有新消息发送过来，此时rlist的值为[客户端]
  23.     for r in rlist:
  24.         if r == sk:
  25.             conn, address = r.accept()
  26.             # conn是什么？conn其实是socket对象
  27.             inputs.append(conn)
  28.             messages[conn] = []
  29.             conn.sendall(bytes('hello',encoding='utf-8'))
  30.         else:
  31.             print('========')
  32.             try:
  33.                 ret = r.recv(1024)
  34.                 if not ret:
  35.                     raise Exception('断开连接')
  36.                 else:
  37.                     outputs.append(r)
  38.                     messages[r].appent(ret)
  39.             except Exception as e:
  40.                 inputs.remove(r)
  41.                 del messages[r]
  43.     for w in wlist:
  44.         msg = messages[w].pop()
  45.         resp = msg + bytes('response',encoding='utf-8')
  46.         w.sendall(resp)
  47.         outputs.remove(w)

Client
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 读写分离测试客户端
  7. import socket
  9. sk = socket.socket()
  10. sk.connect(('127.0.0.1', 9999,))
  11. data = sk.recv(1024)
  12. print(data)
  13. while True:
  14.     inp = input('>>> ')
  15.     sk.sendall(bytes(inp,encoding='utf-8'))
  16.     print(sk.recv(1024))
  17. sk.close()




五、多线程、多进程

1、一个应用程序，可以有多进程和多线程
2、默认：单进程，单线程
3、单进程，多线程
IO操作，不占用CPU
多线程提高并发
计算型操作，占用CPU
多进程提供并发

4、GIL，全局解释器锁
==================================>>
多线程、多进程 提供并发
IO密集型：使用多线程
计算密集型：使用多进程

多线程示例：
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 多线程并发
  7. import threading
  8. import time
  10. def f1(args):
  11.     time.sleep(1)
  12.     print(args)
  14. t = threading.Thread(target=f1, args=(123,))
  15. t.start()
  16. f1(111)

多线程示例2：
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # 多线程并发
  7. import threading
  8. import time
  10. def f1(args):
  11.     time.sleep(5)
  12.     print(args)
  14. # 单进程，单线程的应用程序
  15. for i in range(10):
  16.     f1(i)
  18. # 单进程，多线程的应用程序
  19. for i in range(10):
  20.     t = threading.Thread(target=f1, args=(i,))
  21.     t.setDaemon(True)   # true,表示主线程不等此子线程结束，
  22.     t.start()   # 不代表当前线程会被立即执行
  23.     t.join()    # 表示主线程到此，等待子线程执行结束，才会继续往下执行，参数表示主线程在此最多等待几秒














































posted @ 2016-07-15 20:42  滚动的沙砾  阅读(214)  评论(0)  编辑  收藏  举报