Python之路_Day9

Python之路_Day9_课堂笔记
本期内容
OSI七层模型
Socket


OSI七层模型
TCP/IP
Transmission Controll Protocol And Internet Protocol
tcp/ip协议是主机接入互联网以及接入互联网两台主机通信标准
socket抽象层
socket流程


Socket
示例标准版：
Socket_server服务端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  6. ip_port = ('127.0.0.1',9999)
  8. # 创建socket
  9. s=socket.socket()
  11. # 创建地址
  12. s.bind(ip_port)
  14. # 监听
  15. s.listen(5)
  17. # 等待连接
  18. conn,addr=s.accept()
  20. # 收消息
  21. recv_data=conn.recv(1024)
  22. print('--------------------',type(recv_data))
  24. # 发消息
  25. send_data=recv_data.upper()
  26. print(send_data)
  27. conn.send(send_data)
  29. # 退出
  30. conn.close()

Socket_client客户端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socket
  6. ip_port=('127.0.0.1',9999)
  9. # 创建socket
  10. s=socket.socket()
  12. # 连接
  13. s.connect(ip_port)
  15. # 发送消息
  16. send_data=input(">>: ").strip()
  17. s.send(bytes(send_data,encoding='utf8'))
  19. # 收消息
  20. recv_data=s.recv(1024)
  21. print(str(recv_data,encoding='utf8'))
  23. # 退出
  24. s.close()

Socket模块功能(Python2.7中解释，3.0以上有变动)：
  1. sk.bind(address)
  2. 　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。
  4. sk.listen(backlog)
  5. 　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。
  6.    backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
  7.    这个值不能无限大，因为要在内核中维护连接队列
  9. sk.setblocking(bool)
  10. 　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。
  12. sk.accept()
  13. 　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
  14. 　　接收TCP 客户的连接（阻塞式）等待连接的到来
  16. sk.connect(address)
  17. 　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。
  19. sk.connect_ex(address)
  20. 　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061
  22. sk.close()
  23. 　　关闭套接字
  25. sk.recv(bufsize[,flag])
  26. 　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。
  28. sk.recvfrom(bufsize[.flag])
  29. 　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
  31. sk.send(string[,flag])
  32. 　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。
  34. sk.sendall(string[,flag])
  35. 　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
  36.    内部通过递归调用send，将所有内容发送出去。
  38. sk.sendto(string[,flag],address)
  39. 　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。
  41. sk.settimeout(timeout)
  42. 　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）
  44. sk.getpeername()
  45. 　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
  47. sk.getsockname()
  48. 　　返回套接字自己的地址。通常是一个元组(ipaddr,port)
  50. sk.fileno()
  51. 　　套接字的文件描述符

示例升级版：
Socket_server服务端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：服务端
  7. import socket
  8. ip_port = ('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.bind(ip_port) # 创建连接地址
  14. s.listen(5) # 监听端口
  16. conn,addr=s.accept()    # 等待客户端连接
  18. while True:
  20.     try:
  21.         recv_data=conn.recv(1024)   # 接收客户端消息
  22.         if str(recv_data,encoding='utf8') == 'exit' : break
  24.         send_data=recv_data.upper() # 处理客户端消息
  25.         print(send_data)
  26.         conn.send(send_data)    # 发送消息给客户端
  27.     except Exception:
  28.         break
  30. conn.close()    # 退出

Socket_client客户端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：客户端
  7. import socket
  8. ip_port=('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.connect(ip_port)  # 连接服务端
  14. while True:
  16.     send_data=input(">>: ").strip() # 用户输入信息
  17.     if len(send_data) == 0 : continue   # 判断用户输入信息是否为空
  18.     s.send(bytes(send_data,encoding='utf8'))    # 发送消息给服务端
  19.     if send_data == 'exit' : break  # 判断用户输入是否为“exit”，是则跳出循环
  21.     recv_data=s.recv(1024)  # 接收服务端返回消息
  22.     print(str(recv_data,encoding='utf8'))
  24. s.close()   # 退出

Socket功能：
1、基于python3.5.2版本的socket只能收发字节（python2.7可以发送str）
2、退出只在客户端退出就ok
3、s.accept()和s.recv()是阻塞的(基于连接正常)
4、listen(n) n代表：能挂起的连接数，如果n=1 代表可以连接一个，挂起一个，其他的连接失败
5、解决服务端端口冲突，更换监听端口号
6、服务端：
1.send # 数据长度
4.recv # 收到确认信息，开始下一步发送

send # 发送数据
      客户端：
2.recv # 获取数据长度
3.send # 发送确认信息

recv # 循环接收数据




示例升级版（多客户端）：
Socket_server服务端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：服务端
  7. import socket
  8. ip_port = ('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.bind(ip_port) # 创建连接地址
  14. s.listen(5) # 监听端口
  16. while True:
  17.     conn,addr=s.accept()    # 等待客户端连接
  19.     while True:
  21.         try:
  22.             recv_data=conn.recv(1024)   # 接收客户端消息
  23.             if len(recv_data) == 0 : break
  25.             send_data=recv_data.upper() # 处理客户端消息
  26.             print(send_data)
  27.             conn.send(send_data)    # 发送消息给客户端
  28.         except Exception:
  29.             break
  31.     conn.close()    # 退出

Socket_client客户端1
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：客户端
  7. import socket
  8. ip_port=('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.connect(ip_port)  # 连接服务端
  14. while True:
  16.     send_data=input(">>: ").strip() # 用户输入信息
  17.     if send_data == 'exit' : break  # 判断用户输入是否为“exit”，是则跳出循环
  18.     if len(send_data) == 0 : continue   # 判断用户输入信息是否为空
  19.     s.send(bytes(send_data,encoding='utf8'))    # 发送消息给服务端
  20.     
  22.     recv_data=s.recv(1024)  # 接收服务端返回消息
  23.     print(str(recv_data,encoding='utf8'))
  25. s.close()   # 退出

Socket_client客户端2
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：客户端
  7. import socket
  8. ip_port=('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.connect(ip_port)  # 连接服务端
  14. while True:
  16.     send_data=input(">>: ").strip() # 用户输入信息
  17.     if send_data == 'exit' : break  # 判断用户输入是否为“exit”，是则跳出循环
  18.     if len(send_data) == 0 : continue   # 判断用户输入信息是否为空
  19.     s.send(bytes(send_data,encoding='utf8'))    # 发送消息给服务端
  20.     
  22.     recv_data=s.recv(1024)  # 接收服务端返回消息
  23.     print(str(recv_data,encoding='utf8'))
  25. s.close()   # 退出

示例升级版（基于socket实现类ssh远程执行命令）：
Socket_server服务端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：服务端
  7. import socket
  8. import subprocess
  9. ip_port = ('127.0.0.1',9999)
  11. s=socket.socket()   # 创建socket
  13. s.bind(ip_port) # 创建连接地址
  15. s.listen(5) # 监听端口
  17. while True:
  18.     conn,addr=s.accept()    # 等待客户端连接
  20.     while True:
  22.         try:
  23.             recv_data=conn.recv(1024)   # 接收客户端消息
  24.             if len(recv_data) == 0 : break
  25.             # send_data=recv_data.upper() # 处理客户端消息
  26.             p = subprocess.Popen(str(recv_data,encoding='utf8'),shell=True,stdout=subprocess.PIPE)
  27.             res = p.stdout.read()
  28.             if len(res) == 0:
  29.                 send_data = 'cmd err'
  30.             else:
  31.                 send_data = str(res,encoding='gbk')
  33.             print(send_data)
  34.             conn.send(bytes(send_data,encoding='utf8'))    # 发送消息给客户端
  35.         except Exception:
  36.             break
  38.     conn.close()    # 退出

Socket_client客户端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：客户端
  7. import socket
  8. ip_port=('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.connect(ip_port)  # 连接服务端
  14. while True:
  16.     send_data=input(">>: ").strip() # 用户输入信息
  17.     if send_data == 'exit' : break  # 判断用户输入是否为“exit”，是则跳出循环
  18.     if len(send_data) == 0 : continue   # 判断用户输入信息是否为空
  19.     s.send(bytes(send_data,encoding='utf8'))    # 发送消息给服务端
  22.     recv_data=s.recv(1024)  # 接收服务端返回消息
  23.     print(str(recv_data,encoding='utf8'))
  25. s.close()   # 退出

示例升级版（解决服务端发包的粘包现象）：
Socket_server服务端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：服务端
  7. import socket
  8. import subprocess
  9. ip_port = ('127.0.0.1',9999)    # 定义元祖
  11. s=socket.socket()   # 绑定协议，生成套接字
  13. s.bind(ip_port) # 绑定IP+协议+端口，用来唯一标识一个进程，ip_port必须是元祖
  15. s.listen(5) # 定义最大可以挂起的连接数
  17. while True:
  18.     conn,addr=s.accept()    # 用来重复接受新的连接
  20.     while True:
  22.         try:
  23.             recv_data=conn.recv(1024)   # 接收客户端消息
  24.             if len(recv_data) == 0 : break
  25.             # send_data=recv_data.upper() # 处理客户端消息
  26.             p = subprocess.Popen(str(recv_data,encoding='utf8'),shell=True,stdout=subprocess.PIPE)
  27.             res = p.stdout.read()
  28.             if len(res) == 0:
  29.                 send_data = 'cmd err'
  30.             else:
  31.                 send_data = str(res,encoding='gbk')
  33.             send_data = bytes(send_data,encoding='utf8')
  35.             ready_tag = 'Ready|%s' %len(send_data)
  36.             conn.send(bytes(ready_tag,encoding='utf8'))
  37.             feedback = conn.recv(1024)
  38.             feedback = str(feedback,encoding='utf8')
  40.             if feedback.startswith('Start'):
  41.                 conn.send(send_data)
  42.             # print(send_data)
  43.             # conn.send(bytes(send_data,encoding='utf8'))    # 发送消息给客户端
  44.         except Exception:
  45.             break
  47.     conn.close()    # 退出

Socket_client客户端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. # socket示例：客户端
  7. import socket
  8. ip_port=('127.0.0.1',9999)
  10. s=socket.socket()   # 创建socket
  12. s.connect(ip_port)  # 连接服务端
  14. while True:
  16.     send_data=input(">>: ").strip() # 用户输入信息
  17.     if send_data == 'exit' : break  # 判断用户输入是否为“exit”，是则跳出循环
  18.     if len(send_data) == 0 : continue   # 判断用户输入信息是否为空
  19.     s.send(bytes(send_data,encoding='utf8'))    # 发送消息给服务端
  21.     ready_tag = s.recv(1024)
  22.     ready_tag = str(ready_tag,encoding='utf8')
  23.     if ready_tag.startswith('Ready'):
  24.         msg_size = int(ready_tag.split('|')[-1])
  25.     start_tag = 'Start'
  26.     s.send(bytes(start_tag,encoding='utf8'))
  28.     recv_size = 0
  29.     recv_msg = b''
  31.     while recv_size < msg_size:
  32.         recv_data = s.recv(1024)
  33.         recv_msg += recv_data
  34.         recv_size += len(recv_data)
  35.         print('MSG size %s RECE size %s' %(msg_size,recv_size))
  37.     print(str(recv_msg,encoding='utf8'))
  39.     # recv_data=s.recv(8192)  # 接收服务端返回消息
  40.     # print(str(recv_data,encoding='utf8'))
  42. s.close()   # 退出

socketserver(多线程)：
server端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  5. import socketserver
  7. class MyServer(socketserver.BaseRequestHandler):
  9.     def handle(self):
  10.         self.request.sendall(bytes('welcome',encoding='utf8'))
  11.         while True:
  12.             data = self.request.recv(1024)
  13.             print('[%s] says: %s' % (self.client_address,data.decode()))
  14.             self.request.sendall(data.upper())
  16. if __name__ == '__main__':
  17.     server = socketserver.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
  18.     server.serve_forever()

client端
  1. #!/usr/bin/env python
  2. # -.- coding: utf-8 -.-
  3. # By sandler
  6. import socket
  8. ip_port = ('127.0.0.1',8009)
  9. s = socket.socket()
  10. s.connect(ip_port)
  11. welcome_msg = s.recv(1024)
  12. print(welcome_msg.decode())
  14. while True:
  15.     send_data = input('>>: ').strip()
  16.     if len(send_data) == 0 :continue
  17.     s.send(bytes(send_data,encoding='utf8'))
  18.     recv_data = s.recv(1024)
  19.     print(recv_data.decode())
  20. s.close()






作业：开发一个支持多用户在线的FTP程序

要求：

  1. 用户加密认证
  2. 允许同时多用户登录
  3. 每个用户有自己的家目录 ，且只能访问自己的家目录
  4. 对用户进行磁盘配额，每个用户的可用空间不同
  5. 允许用户在ftp server上随意切换目录
  6. 允许用户查看当前目录下文件
  7. 允许上传和下载文件，保证文件一致性
  8. 文件传输过程中显示进度条
  9. 附加功能：支持文件的断点续传









posted @ 2016-07-07 19:59  滚动的沙砾  阅读(245)  评论(0)  编辑  收藏  举报