[Python]静态Web服务器

已于 2022-09-24 17:44:01 修改
阅读量601 收藏 4
点赞数
分类专栏： Python学习笔记 文章标签： 服务器 python 前端 web websocket
于 2022-09-22 00:17:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53022813/article/details/126973761
版权

在这里插入图片描述

前言

系列文章目录
[Python]目录
视频及资料和课件
链接：https://pan.baidu.com/s/1LCv_qyWslwB-MYw56fjbDg?pwd=1234
提取码：1234

文章目录

搭建Python自带静态Web服务器

1. 静态Web服务器

静态Web服务器是可以为发出请求的浏览器提供静态文档的程序。

Web服务器指的是Web服务器程序，运行在服务器上的程序。

平时我们浏览百度新闻数据的时候，每天的新闻数据都会发生变化，那访问的这个页面就是动态的，而静态，页面的数据不会发生变化。

2. 如何搭建Python自带的静态Web服务器

搭建Python自带的静态Web服务器使用 python3 -m http.server 端口号这个命令即可

端口号不指定默认是8000

执行该命令需要到准备向外提供静态资源的文件夹下运行，即切换到指定的资源目录中。

如果 python3 -m http.server 端口号 不行，可以试试看 python -m http.server 端口号

  • -m选项说明:
  • -m表示运行包里面的模块，执行这个命令的时候，需要进入你自己指定静态文件的目录，然后通过浏览器就能访问对应的文件了，这样一个静态的web服务器就搭建好了。

停止运行的服务器，使用ctrl+c

服务器运行时，终端窗口不能关闭，否则服务器会停止运行，导致浏览器不能正常访问。

在这里插入图片描述
在这里插入图片描述

3. 访问搭建的静态Web服务器

通过浏览器访问搭建的静态Web服务器

因为当前服务器运行在自己的电脑上，访问本机可以使用localhost:端口号/资源路径

# 我使用浏览器访问
# 访问静态资源的根目录
localhost:9000

在这里插入图片描述
在这里插入图片描述

开发自己的静态Web服务器

1. 静态Web服务器-返回固定页面数据

1.1 实现步骤

  1. 编写一个TCP服务端程序
  2. 获取浏览器发送的http请求报文数据
  3. 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器。
  4. HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字。

1.2 静态Web服务器-返回固定页面数据的示例代码

开发的服务器只返回index.html文件
在这里插入图片描述
在这里插入图片描述

import socket


# 判断是否为主模块
if __name__=='__main__':
    # 创建tcp服务端套接字对象
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口号复用，程序退出端口号立即释放
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 绑定端口号
    tcp_server_socket.bind(('', 9090))
    # 服务端套接字监听
    tcp_server_socket.listen(128)
    # 循环等待客户端的连接
    while True:
        # 等待接受客户端的连接请求
        new_socket, ip_port = tcp_server_socket.accept()
        # 接受客户端发送的数据
        # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
        recv_client_data = new_socket.recv(4096)
        # 对二进制数据进行解码
        recv_client_content = recv_client_data.decode('utf-8')
        print(recv_client_content)
        # 打开读取需要发送给客户端的文件
        # 打开方式是以读取二进制数据的方式打开文件
        with open('./css/index.html', 'rb') as f:
            # 读取文件数据
            file_data = f.read()
        # 将读取的数据封装为http格式的数据
        # 响应行
        response_line = 'HTTP/1.1 200 OK\r\n'
        # 响应头
        response_header = 'Server: PWS1.0\r\n'
        # 响应体
        response_body = file_data
        # 拼接为响应报文
        response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
        # 发送数据给客户端
        new_socket.send(response_data)
        # 关闭与客户端的套接字
        new_socket.close()

在这里插入图片描述
在这里插入图片描述

2. 静态Web服务器-返回指定页面数据

2.1 实现步骤

  1. 获取用户请求资源的路径
  2. 根据请求资源的路径，读取指定文件的数据
  3. 组装指定文件数据的响应报文，发送给浏览器
  4. 判断请求的文件在服务端不存在，组装404状态的响应报文，发送给浏览器

2.2 静态Web服务器-返回指定页面数据的示例代码

import socket


def main():
    # 创建tcp服务端套接字对象
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口号复用，程序退出端口号立即释放
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 绑定端口号
    tcp_server_socket.bind(('', 9090))
    # 服务端套接字监听
    tcp_server_socket.listen(128)
    # 循环等待客户端的连接
    while True:
        # 等待接受客户端的连接请求
        new_socket, ip_port = tcp_server_socket.accept()
        # 接受客户端发送的数据
        # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
        recv_client_data = new_socket.recv(4096)
        # 判断客户端是否处于连接转态
        if len(recv_client_data) == 0:
            new_socket.close()
            return

        # 对二进制数据进行解码
        recv_client_content = recv_client_data.decode('utf-8')
        print(recv_client_content)
        # 对字符串进行分割，分割两次，因为访问的资源路径在第二个位置
        request_list = recv_client_content.split(' ', maxsplit=2)
        # 获取请求资源地址
        request_path = request_list[1]
        print('请求的资源地址为：', request_path)
        # 如果请求的资源地址为 '/', 默认为首页index.html
        if request_path == '/':
            request_path = '/index.html'
        # 打开读取需要发送给客户端的文件
        with open('static' + request_path, 'rb') as f:
            # 读取文件数据
            file_data = f.read()
        # 将读取的数据封装为http格式的数据
        # 响应行
        response_line = 'HTTP/1.1 200 OK\r\n'
        # 响应头
        response_header = 'Server: PWS1.0\r\n'
        # 响应体
        response_body = file_data
        # 拼接为响应报文
        response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
        # 发送数据给客户端
        new_socket.send(response_data)
        # 关闭与客户端的套接字
        new_socket.close()

# 判断是否为主模块
if __name__=='__main__':
    main()

在这里插入图片描述
在这里插入图片描述

2.3 判断请求的文件在服务端不存在，组装404状态的响应报文，发送给浏览器

import socket


def main():
    # 创建tcp服务端套接字对象
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口号复用，程序退出端口号立即释放
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 绑定端口号
    tcp_server_socket.bind(('', 9090))
    # 服务端套接字监听
    tcp_server_socket.listen(128)
    # 循环等待客户端的连接
    while True:
        # 等待接受客户端的连接请求
        new_socket, ip_port = tcp_server_socket.accept()
        # 接受客户端发送的数据
        # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
        recv_client_data = new_socket.recv(4096)
        # 判断客户端是否处于连接转态
        if len(recv_client_data) == 0:
            new_socket.close()
            return

        # 对二进制数据进行解码
        recv_client_content = recv_client_data.decode('utf-8')
        print(recv_client_content)
        # 对字符串进行分割，分割两次，因为访问的资源路径在第二个位置
        request_list = recv_client_content.split(' ', maxsplit=2)
        # 获取请求资源地址
        request_path = request_list[1]
        print('请求的资源地址为：', request_path)
        # 如果请求的资源地址为 '/', 默认为首页index.html
        if request_path == '/':
            request_path = '/index.html'
        try:
            # 打开读取需要发送给客户端的文件
            with open('static' + request_path, 'rb') as f:
                # 读取文件数据
                file_data = f.read()
        except Exception as e:
            # 打开错误页面
            with open('static/error.html', 'rb') as f:
                # 读取文件数据
                file_data = f.read()
                # 将读取的数据封装为http格式的数据
                # 响应行
                response_line = 'HTTP/1.1 404 Not Found\r\n'
                # 响应头
                response_header = 'Server: PWS1.0\r\n'
                # 响应体
                response_body = file_data
                # 拼接为响应报文
                response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
                # 发送数据给客户端
                new_socket.send(response_data)
        else:
            # 将读取的数据封装为http格式的数据
            # 响应行
            response_line = 'HTTP/1.1 200 OK\r\n'
            # 响应头
            response_header = 'Server: PWS1.0\r\n'
            # 响应体
            response_body = file_data
            # 拼接为响应报文
            response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
            # 发送数据给客户端
            new_socket.send(response_data)
        finally:
            # 关闭与客户端的套接字
            new_socket.close()


# 判断是否为主模块
if __name__ == '__main__':
    main()

在这里插入图片描述

3. 静态Web服务器-多任务版

3.1 实现步骤

  1. 当客户端和服务端建立连接成功，创建子线程，使用子线程专门处理客户端的请求，防止主线程阻塞。
  2. 把创建的子线程设置成为守护主线程，防止主线程无法退出。

3.2 静态Web服务器-多任务版的示例代码

import socket
import threading


def handle_client_request(new_socket):
    # 接受客户端发送的数据
    # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
    recv_client_data = new_socket.recv(4096)
    # 判断客户端是否处于连接转态
    if len(recv_client_data) == 0:
        new_socket.close()
        return

    # 对二进制数据进行解码
    recv_client_content = recv_client_data.decode('utf-8')
    print(recv_client_content)
    # 对字符串进行分割，分割两次，因为访问的资源路径在第二个位置
    request_list = recv_client_content.split(' ', maxsplit=2)
    # 获取请求资源地址
    request_path = request_list[1]
    print('请求的资源地址为：', request_path)
    # 如果请求的资源地址为 '/', 默认为首页index.html
    if request_path == '/':
        request_path = '/index.html'
    try:
        # 打开读取需要发送给客户端的文件
        with open('static' + request_path, 'rb') as f:
            # 读取文件数据
            file_data = f.read()
    except Exception as e:
        # 打开错误页面
        with open('static/error.html', 'rb') as f:
            # 读取文件数据
            file_data = f.read()
            # 将读取的数据封装为http格式的数据
            # 响应行
            response_line = 'HTTP/1.1 404 Not Found\r\n'
            # 响应头
            response_header = 'Server: PWS1.0\r\n'
            # 响应体
            response_body = file_data
            # 拼接为响应报文
            response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
            # 发送数据给客户端
            new_socket.send(response_data)
    else:
        # 将读取的数据封装为http格式的数据
        # 响应行
        response_line = 'HTTP/1.1 200 OK\r\n'
        # 响应头
        response_header = 'Server: PWS1.0\r\n'
        # 响应体
        response_body = file_data
        # 拼接为响应报文
        response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
        # 发送数据给客户端
        new_socket.send(response_data)
    finally:
        # 关闭与客户端的套接字
        new_socket.close()


def main():
    # 创建tcp服务端套接字对象
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口号复用，程序退出端口号立即释放
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 绑定端口号
    tcp_server_socket.bind(('', 9090))
    # 服务端套接字监听
    tcp_server_socket.listen(128)
    # 循环等待客户端的连接
    while True:
        # 等待接受客户端的连接请求
        new_socket, ip_port = tcp_server_socket.accept()
        print(ip_port)
        # 客户端与服务端建立连接后，创建子线程
        sub_thread = threading.Thread(target=handle_client_request, args=(new_socket,))
        # 设置守护主线程
        sub_thread.setDaemon(True)
        # 启动线程
        sub_thread.start()

# 判断是否为主模块
if __name__ == '__main__':
    main()

在这里插入图片描述

4. 静态Web服务器-面向对象开发

4.1 实现步骤

  1. 把提供服务的Web服务器抽象成一个类(HTTPWebServer)
  2. 提供Web服务器的初始化方法，在初始化方法里面创建socket对象
  3. 提供一个开启Web服务器的方法，让Web服务器处理客户端请求操作。

4.2 静态Web服务器-面向对象开发的示例代码

import socket
import threading


# 定义web服务器类
class HttpWebServer(object):
    def __init__(self):
        # 创建tcp服务端套接字对象
        tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 设置端口号复用，程序退出端口号立即释放
        tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        # 绑定端口号
        tcp_server_socket.bind(('', 9090))
        # 服务端套接字监听
        tcp_server_socket.listen(128)
        # 将tcp服务端套接字对象作为属性
        self.tcp_server_socket = tcp_server_socket

    # 启动web服务器进行工作
    def start(self):
        # 循环等待客户端的连接
        while True:
            # 等待接受客户端的连接请求
            new_socket, ip_port = self.tcp_server_socket.accept()
            print(ip_port)
            # 客户端与服务端建立连接后，创建子线程
            sub_thread = threading.Thread(target=self.handle_client_request, args=(new_socket,))
            # 设置守护主线程
            sub_thread.setDaemon(True)
            # 启动线程
            sub_thread.start()

    # 处理客户端的请求
    @staticmethod
    def handle_client_request(new_socket):
        # 接受客户端发送的数据
        # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
        recv_client_data = new_socket.recv(4096)
        # 判断客户端是否处于连接转态
        if len(recv_client_data) == 0:
            new_socket.close()
            return

        # 对二进制数据进行解码
        recv_client_content = recv_client_data.decode('utf-8')
        print(recv_client_content)
        # 对字符串进行分割，分割两次，因为访问的资源路径在第二个位置
        request_list = recv_client_content.split(' ', maxsplit=2)
        # 获取请求资源地址
        request_path = request_list[1]
        print('请求的资源地址为：', request_path)
        # 如果请求的资源地址为 '/', 默认为首页index.html
        if request_path == '/':
            request_path = '/index.html'
        try:
            # 打开读取需要发送给客户端的文件
            with open('static' + request_path, 'rb') as f:
                # 读取文件数据
                file_data = f.read()
        except Exception as e:
            # 打开错误页面
            with open('static/error.html', 'rb') as f:
                # 读取文件数据
                file_data = f.read()
                # 将读取的数据封装为http格式的数据
                # 响应行
                response_line = 'HTTP/1.1 404 Not Found\r\n'
                # 响应头
                response_header = 'Server: PWS1.0\r\n'
                # 响应体
                response_body = file_data
                # 拼接为响应报文
                response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
                # 发送数据给客户端
                new_socket.send(response_data)
        else:
            # 将读取的数据封装为http格式的数据
            # 响应行
            response_line = 'HTTP/1.1 200 OK\r\n'
            # 响应头
            response_header = 'Server: PWS1.0\r\n'
            # 响应体
            response_body = file_data
            # 拼接为响应报文
            response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
            # 发送数据给客户端
            new_socket.send(response_data)
        finally:
            # 关闭与客户端的套接字
            new_socket.close()


# 程序入口函数
def main():
    # 创建web服务器对象
    web_server = HttpWebServer()
    # 启动web服务器进行工作
    web_server.start()


# 判断是否为主模块
if __name__ == '__main__':
    main()

在这里插入图片描述

5. 静态Web服务器-命令行启动动态绑定端口号

5.1 实现步骤

  1. 获取执行python程序的终端命令行参数
  2. 判断参数的类型，设置端口号必须是整型
  3. 给Web服务器类的初始化方法添加一个端口号参数，用于绑定端口号

5.2 获取执行python程序的终端命令行参数

import sys

# 获取执行python程序的终端命令行参数
# 即执行文件后面的输入值
argv = sys.argv
print(argv)

在这里插入图片描述

在pycharm中输入命令行参数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.3 静态Web服务器-命令行启动动态绑定端口号的示例代码

import socket
import sys
import threading


# 定义web服务器类
class HttpWebServer(object):
    def __init__(self, port):
        # 创建tcp服务端套接字对象
        tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 设置端口号复用，程序退出端口号立即释放
        tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        # 绑定端口号
        tcp_server_socket.bind(('', port))
        # 服务端套接字监听
        tcp_server_socket.listen(128)
        # 将tcp服务端套接字对象作为属性
        self.tcp_server_socket = tcp_server_socket

    # 启动web服务器进行工作
    def start(self):
        # 循环等待客户端的连接
        while True:
            # 等待接受客户端的连接请求
            new_socket, ip_port = self.tcp_server_socket.accept()
            print(ip_port)
            # 客户端与服务端建立连接后，创建子线程
            sub_thread = threading.Thread(target=self.handle_client_request, args=(new_socket,))
            # 设置守护主线程
            sub_thread.setDaemon(True)
            # 启动线程
            sub_thread.start()

    # 处理客户端的请求
    @staticmethod
    def handle_client_request(new_socket):
        # 接受客户端发送的数据
        # 由于浏览器一般不会发送大量的数据，所以一次接受的数据大小不用指定很大
        recv_client_data = new_socket.recv(4096)
        # 判断客户端是否处于连接转态
        if len(recv_client_data) == 0:
            new_socket.close()
            return

        # 对二进制数据进行解码
        recv_client_content = recv_client_data.decode('utf-8')
        print(recv_client_content)
        # 对字符串进行分割，分割两次，因为访问的资源路径在第二个位置
        request_list = recv_client_content.split(' ', maxsplit=2)
        # 获取请求资源地址
        request_path = request_list[1]
        print('请求的资源地址为：', request_path)
        # 如果请求的资源地址为 '/', 默认为首页index.html
        if request_path == '/':
            request_path = '/index.html'
        try:
            # 打开读取需要发送给客户端的文件
            with open('static' + request_path, 'rb') as f:
                # 读取文件数据
                file_data = f.read()
        except Exception as e:
            # 打开错误页面
            with open('static/error.html', 'rb') as f:
                # 读取文件数据
                file_data = f.read()
                # 将读取的数据封装为http格式的数据
                # 响应行
                response_line = 'HTTP/1.1 404 Not Found\r\n'
                # 响应头
                response_header = 'Server: PWS1.0\r\n'
                # 响应体
                response_body = file_data
                # 拼接为响应报文
                response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
                # 发送数据给客户端
                new_socket.send(response_data)
        else:
            # 将读取的数据封装为http格式的数据
            # 响应行
            response_line = 'HTTP/1.1 200 OK\r\n'
            # 响应头
            response_header = 'Server: PWS1.0\r\n'
            # 响应体
            response_body = file_data
            # 拼接为响应报文
            response_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body
            # 发送数据给客户端
            new_socket.send(response_data)
        finally:
            # 关闭与客户端的套接字
            new_socket.close()


# 程序入口函数
def main():
    # 获取命令行输入的参数
    argv = sys.argv
    # 限制输入的参数只能是两个
    # 即一个是文件路径一个是需要的端口参数
    if len(argv) != 2:
        print('输入的端口参数大于1个，执行命令格式如下: python3 xxx.py 端口号')
        return

    # 判断字符串是否都是数字组成
    if not argv[1].isdigit():
        print("执行命令格式如下: python3 xxx.py 8000")
        return

    # 获取需要绑定的端口号
    # 由于命令行参数每个的数据类型都为字符串，需要转型
    port = int(argv[1])
    # 创建web服务器对象
    web_server = HttpWebServer(port)
    # 启动web服务器进行工作
    web_server.start()


# 判断是否为主模块
if __name__ == '__main__':
    main()

在这里插入图片描述
在这里插入图片描述

小炜1128
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python实现静态web服务器
09-18
主要为大家详细介绍了python实现静态web服务器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
python自带静态web服务器搭建代码实现（一）
我的个人博客
10-20 1575
静态web服务器，搭建python自带的静态web服务器，浏览器访问搭建的静态web服务器及其通信过程，静态Web服务器-返回固定页面数据、返回指定页面数据代码实现
小白如何搭建Python自带静态Web服务器？
weixin_68789096的博客
05-22 108
小白如何搭建Python自带静态Web服务器？利用Python自带的包可以建立简单的web服务器，静态Web服务器是为发出请求的浏览器提供静态文档的程序。
Python搭建静态web服务器
KK_2018的技术博客_程序员不止是程序员
01-24 1887
核心还是使用Python的socket实现的，socket的具体用法前面文章有写，这里不写太多注释。 1.本地搭建python静态web服务器 在资源目录打开命令终端，输入命令：python -m http.server [端口号]，端口号不写默认8000即可 然后在浏览器输入localhost:8000/资源路径即可访问你想访问的页面 2.返回固定数据的静态web服务器 ''' 返回固定数据的静态web服务器 ''' # 导入模块 import socket # 创建socket对象 sta
Python学习----静态web服务器
m0_48639280的博客
12-05 954
开发步骤： 1、编写一个TCP服务端程序 2、获取浏览器发送的HTTP请求报文数据 3、读取固定页面数据，把页面数据组装HTTP响应报文数据发送给浏览器 4、HTTP响应报文数据发送完成之后，关闭服务于客户端的套接字 和之前服务端编写差不多，差别在于，首先客户端不需要我们编写了，是通过浏览器发送请求。 然后，因为浏览器遵循的是http请求，所以我们在用socket进行返回时，需要遵循http响应的格式，将数据进行返回。 目前为止，还没有学习框架，不能像java的spring那样。目前端口是写死在程序中，如果
python的静态WEB服务器的搭建
qq_45724328的博客
11-16 756
python基础，静态web服务器的搭建
python静态web服务器-返回固定页面.py
10-28
python静态web服务器-返回固定页面.py
Python Web静态服务器非堵塞模式实现方法示例
09-18
主要介绍了Python Web静态服务器非堵塞模式实现方法,结合实例形式分析了Python单进程非堵塞模式实现的Web静态服务器相关操作技巧,需要的朋友可以参考下
web静态服务器
09-12
web静态服务器，使用python３的socket模块，符合http协议，使用的tcp传输数据，可以通过局域网内浏览器实现访问服务器的静态页面
Python简易web静态服务器程序搭建
ncu5509121083的博客
06-05 3374
http.server模块介绍,Python多任务与TCP实现简易静态web服务器程序
python自带的静态web服务器
jun的博客
07-02 963
搭建Python自带的静态Web服务器使用 python3 -m http.server 端口号，不加端口号，默认为8000 m表示运行包里面的模块，执行这个命令的时候，需要进入你自己指定静态文件的目录，然后通过浏览器就能访问对应的 html文件了，这样一个静态的web服务器就搭建好了。 ...
搭建Python自带静态Web服务器
但行好事，莫问前程
09-10 6962
搭建Python自带静态Web服务器
python web服务器接收客户端的图片方式
RayChiu757374816的博客
07-29 3336
web服务python接收base64图片流的方式
python模拟浏览器请求web服务器的网页过程
anyiVIP的博客
04-07 5255
一、浏览器请求的基本流程：用户输入网址.浏览器请求DNS服务器, 获取域名对应的IP地址.请求连接该IP地址服务器.发送资源请求. (HTTP协议)web服务器接收到请求, 并解析请求, 判断用户意图.获取用户想要的资源.将资源返回给web服务器程序.web服务器程序将资源数据通过网络发送给浏览器.浏览器解析请求的数据并且完成网页数据的显示.通过火狐或者谷歌可以调出开发者工具，浏览器右侧菜单--&...
通过python建立一个web服务查看服务器上的文本、图片、视频等文件
求真、务实
06-12 2734
通过python建立一个web服务查看服务器上的文本、图片、视频等文件文章目录：1 在服务器端开启一个服务2 在本地浏览器中输入服务器的ip地址 1 在服务器端开启一个服务 python -m http.server 8099 2 在本地浏览器中输入服务器的ip地址 http://192.168.0.134:8099/ 然后就打开了服务器的文件目录，如下： 然后可以在浏览器中查看服务器上的图片、视频等文件，如下是我查看服务器上的视频： ...
#Python&web请求演示图片
weixin_48321071的博客
01-25 81
#　需要知道是怎么一个请求过程 　介绍： 　　　 演示图 操作流程
Python 实现简单实用的Webserver，并且支持图片加载！！！
zZZxiaozhi的博客
10-17 764
—static：静态文件目录 —templates：前端页面模板文件（index.html和main.html） ——application.py：监听和处理收发数据 ——request：解析http请求 ——response：用来封装和发送数据的模块 ——runserver：服务器启动模块 具体的代码如下： application.py import socket import threadi...
python-flask项目的服务器线上部署
最新发布
weixin_74314406的博客
06-05 1188
在 Flask 项目中，打包通常不是指将代码本身打包成一个可执行文件（因为 Flask 是一个 WSGI 应用，它通常运行在 Web 服务器和 WSGI 容器如 Gunicorn、uWSGI 等之上），而是指准备项目的所有必要文件和依赖，以便在其他环境（如生产服务器）上部署。如果你的 Flask 项目使用了如 Flask-Assets 这样的库来处理静态文件（如 CSS 和 JavaScript），你可能需要运行一个命令来收集这些文件到一个目录中，以便在生产环境中服务。这可以帮助您诊断任何潜在的问题。
python web部署服务器
05-16
无论你使用哪一种框架，部署Web服务器的步骤大致相同，下面是一些基本的步骤： 1. 选择一个云服务器，如AWS、阿里云、腾讯云等。购买一台云服务器，并确保操作系统为Linux系统。 2. 在服务器上安装Python环境。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值