• 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. 附加功能：支持文件的断点续传
  • 相关阅读:
    bzoj3524: [Poi2014]Couriers（主席树）
    51nod 1275 连续子段的差异（twopointer+单调队列）
    51nod 1274 最长递增路径（DP）
    51nod 1273 旅行计划（思维题）
    51nod 1257 背包问题 V3（分数规划）
    CSS 几款比较常用的翻转特效
    css文字飞入效果
    jQuery使用方法
    数据库
    关系型数据库基本概念及MySQL简述
  • 原文地址：https://www.cnblogs.com/sandler613/p/5651415.html
Copyright © 2020-2023  润新知