Python网络编程：从基础到实践

最新推荐文章于 2024-05-21 20:02:56 发布

极客代码

最新推荐文章于 2024-05-21 20:02:56 发布

阅读量725

点赞数 28

分类专栏：玩转Python 文章标签： python 开发语言网络

本文链接：https://blog.csdn.net/suifengme/article/details/137821569

版权

玩转Python 专栏收录该内容

69 篇文章 7 订阅

订阅专栏

Python 是一种广泛应用于网络编程的高级编程语言，它简单易学，功能强大，深受广大开发者的喜爱。本文将带你深入了解 Python 网络编程的基础知识，并通过实际案例，让你掌握如何使用 Python 进行网络编程。

第一部分：Python网络编程基础

1.1 网络协议简介

网络编程的核心是网络协议。网络协议定义了计算机之间通信的规则，常见的网络协议有 TCP、UDP 和 HTTP 等。其中，TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议；UDP（用户数据报协议）是一种无连接的、不可靠的、基于数据报的传输层通信协议；HTTP（超文本传输协议）是一种应用层协议，主要用于分布式、协作式和超媒体信息系统的应用。

1.2 Python网络编程库

Python 提供了丰富的网络编程库，让我们可以轻松地实现网络通信。下面是几个常用的 Python 网络编程库：

socket：Python 标准库中的 socket 模块提供了丰富的网络通信功能，支持 TCP 和 UDP 协议。
requests：requests 是一个简单易用的 HTTP 客户端库，支持 GET、POST、PUT、DELETE 等请求方法。
socketserver：socketserver 是一个高级的网络服务器框架，支持多线程和多进程。
asyncio：asyncio 是 Python 3.4 引入的标准库，用于编写单线程并发代码，支持异步 IO 操作。

1.3 socket编程基础

下面我们通过一个简单的 TCP 客户端和服务器程序来了解 Python 的 socket 编程。

1.3.1 TCP服务器

首先，我们创建一个简单的 TCP 服务器。服务器首先创建一个 socket 对象，然后绑定到一个地址和端口，接着监听客户端的连接请求，最后接收客户端发送的数据，并回复客户端。

import socket

def tcp_server():
    # 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定地址和端口
    server_socket.bind(('localhost', 8888))

    # 监听连接请求
    server_socket.listen(5)
    print("服务器已启动，等待客户端连接...")

    # 接收客户端连接
    client_socket, client_address = server_socket.accept()
    print(f"客户端 {client_address} 已连接")

    # 接收客户端数据
    data = client_socket.recv(1024)
    print(f"收到客户端数据：{data.decode('utf-8')}")

    # 回复客户端
    client_socket.send("收到数据".encode('utf-8'))

    # 关闭连接
    client_socket.close()
    server_socket.close()

if __name__ == '__main__':
    tcp_server()

1.3.2 TCP客户端

接下来，我们创建一个简单的 TCP 客户端。客户端首先创建一个 socket 对象，然后连接到服务器的地址和端口，接着发送数据给服务器，并接收服务器的回复。

import socket

def tcp_client():
    # 创建 socket 对象
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 连接服务器
    client_socket.connect(('localhost', 8888))
    print("客户端已连接服务器")

    # 发送数据
    client_socket.send("你好，服务器".encode('utf-8'))

    # 接收服务器回复
    data = client_socket.recv(1024)
    print(f"收到服务器回复：{data.decode('utf-8')}")

    # 关闭连接
    client_socket.close()

if __name__ == '__main__':
    tcp_client()

运行服务器和客户端程序，你会看到服务器接收到客户端发送的数据，并回复客户端。这样，一个简单的 TCP 网络通信就实现了。

1.4 小结

本部分介绍了 Python 网络编程的基础知识，包括网络协议简介、Python 网络编程库以及 socket 编程基础。通过一个简单的 TCP 客户端和服务器程序，我们了解了如何使用 Python 进行网络通信。接下来，我们将进一步学习 Python 网络编程的高级应用。

第二部分：Python网络编程进阶

2.1 多线程与多进程

在网络编程中，为了提高服务器的处理能力，我们通常需要使用多线程或多进程技术。Python 提供了 threading 和 multiprocessing 库来支持多线程和多进程编程。

2.1.1 多线程服务器

使用多线程，我们可以为每个客户端连接创建一个新的线程，从而实现并发处理多个客户端请求。

import socket
import threading

def handle_client(client_socket):
    # 接收客户端数据
    data = client_socket.recv(1024)
    print(f"收到客户端数据：{data.decode('utf-8')}")

    # 回复客户端
    client_socket.send("收到数据".encode('utf-8'))

    # 关闭连接
    client_socket.close()

def threaded_tcp_server():
    # 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定地址和端口
    server_socket.bind(('localhost', 8888))

    # 监听连接请求
    server_socket.listen(5)
    print("服务器已启动，等待客户端连接...")

    while True:
        # 接收客户端连接
        client_socket, client_address = server_socket.accept()
        print(f"客户端 {client_address} 已连接")

        # 创建新线程处理客户端连接
        client_thread = threading.Thread(target=handle_client, args=(client_socket,))
        client_thread.start()

if __name__ == '__main__':
    threaded_tcp_server()

2.1.2 多进程服务器

与多线程类似，多进程也可以用于并发处理多个客户端请求。Python 的 multiprocessing 库提供了 Process 类来创建新的进程。

import socket
import multiprocessing

def handle_client(client_socket):
    # 接收客户端数据
    data = client_socket.recv(1024)
    print(f"收到客户端数据：{data.decode('utf-8')}")

    # 回复客户端
    client_socket.send("收到数据".encode('utf-8'))

    # 关闭连接
    client_socket.close()

def multi_process_tcp_server():
    # 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定地址和端口
    server_socket.bind(('localhost', 8888))

    # 监听连接请求
    server_socket.listen(5)
    print("服务器已启动，等待客户端连接...")

    while True:
        # 接收客户端连接
        client_socket, client_address = server_socket.accept()
        print(f"客户端 {client_address} 已连接")

        # 创建新进程处理客户端连接
        client_process = multiprocessing.Process(target=handle_client, args=(client_socket,))
        client_process.start()

if __name__ == '__main__':
    multi_process_tcp_server()

2.2 异步IO与asyncio

Python 3.4 及以上版本引入了 asyncio 库，用于编写单线程并发代码，支持异步 IO 操作。asyncio 库使用 async 和 await 关键字，使得异步代码的编写更加直观和简洁。

2.2.1 异步TCP服务器

下面是一个使用 asyncio 库实现的异步 TCP 服务器示例。

import asyncio

async def handle_client(reader, writer):
    # 接收客户端数据
    data = await reader.read(1024)
    message = data.decode('utf-8')
    print(f"收到客户端数据：{message}")

    # 回复客户端
    writer.write("收到数据".encode('utf-8'))
    await writer.drain()

    # 关闭连接
    writer.close()

async def main():
    # 创建服务器
    server = await asyncio.start_server(handle_client, 'localhost', 8888)

    # 获取服务器地址
    address = server.sockets[0].getsockname()
    print(f"服务器已启动，地址：{address}")

    # 运行服务器
    async with server:
        await server.serve_forever()

if __name__ == '__main__':
    asyncio.run(main())

2.3 HTTP编程

HTTP（超文本传输协议）是互联网上应用最广泛的协议之一，它定义了客户端和服务器之间交换数据的请求和响应格式。Python 的 requests 库为我们提供了简单易用的 HTTP 客户端功能，而 http.server 库则可以用来创建简单的 HTTP 服务器。

2.3.1 HTTP客户端

使用 requests 库，我们可以轻松地发送 HTTP 请求，如下所示：

import requests

def http_get(url):
    # 发送 GET 请求
    response = requests.get(url)

    # 输出状态码
    print(f"状态码：{response.status_code}")

    # 输出响应内容
    print(response.text)

def http_post(url, data):
    # 发送 POST 请求
    response = requests.post(url, data=data)

    # 输出状态码
    print(f"状态码：{response.status_code}")

    # 输出响应内容
    print(response.text)

# 使用示例
http_get('https://www.example.com')
http_post('https://www.example.com/post', data={'key': 'value'})

2.3.2 HTTP服务器

使用 http.server 库，我们可以快速创建一个简单的 HTTP 服务器。这个服务器默认处理 GET 请求，并将服务器的文件目录作为可访问的资源。

import http.server
import socketserver

def simple_http_server(directory):
    # 设置服务器的文件目录
    os.chdir(directory)

    # 设置服务器的地址和端口
    address = ('', 8000)
    server = http.server.HTTPServer(address, http.server.SimpleHTTPRequestHandler)

    # 启动服务器
    print(f"服务器已启动，访问 http://localhost:8000/ 查看文件")
    server.serve_forever()

# 使用示例
simple_http_server('/path/to/your/directory')

2.4 Web框架

对于更复杂的 HTTP 服务器，我们通常使用 Web 框架来处理 URL 路由、请求和响应处理等任务。Python 有许多流行的 Web 框架，如 Flask、Django 和 FastAPI。

2.4.1 Flask入门

Flask 是一个轻量级的 Web 框架，非常适合快速开发和简单应用。下面是一个 Flask 应用的基本结构：

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

运行这个 Flask 应用，访问 http://localhost:5000/，你会看到它显示 “Hello, World!”。

2.5 小结

在本部分，我们介绍了 Python 网络编程的进阶知识，包括多线程与多进程、异步 IO 与 asyncio、HTTP 编程以及 Web 框架。通过这些内容，我们了解了如何使用 Python 处理更复杂的网络任务和 Web 应用。在下一部分，我们将深入探讨网络编程中的安全性问题，包括 SSL/TLS 和数据加密。

第三部分：Python网络编程的安全性

3.1 SSL/TLS协议

在网络通信中，为了保证数据的安全性和完整性，通常会使用SSL/TLS协议对传输的数据进行加密。SSL（Secure Sockets Layer）和其继任者TLS（Transport Layer Security）是用于网络通信的安全协议，它们在传输层与应用层之间提供加密通信。

3.1.1 创建一个安全的TCP服务器

使用Python的ssl模块，我们可以为TCP服务器添加SSL/TLS支持。首先，我们需要一个证书和一个私钥，可以使用openssl命令行工具生成它们。

import socket
import ssl
import threading

def handle_client(client_socket):
    # 接收客户端数据
    data = client_socket.recv(1024)
    print(f"收到客户端数据：{data.decode('utf-8')}")

    # 回复客户端
    client_socket.send("收到数据".encode('utf-8'))

    # 关闭连接
    client_socket.close()

def ssl_tcp_server(certfile, keyfile):
    # 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 绑定地址和端口
    server_socket.bind(('localhost', 8888))

    # 使用 SSL/TLS 包装套接字
    server_socket = ssl.wrap_socket(server_socket, certfile=certfile, keyfile=keyfile, server_side=True)

    # 监听连接请求
    server_socket.listen(5)
    print("服务器已启动，等待客户端连接...")

    while True:
        # 接收客户端连接
        client_socket, client_address = server_socket.accept()
        print(f"客户端 {client_address} 已连接")

        # 创建新线程处理客户端连接
        client_thread = threading.Thread(target=handle_client, args=(client_socket,))
        client_thread.start()

if __name__ == '__main__':
    ssl_tcp_server('server.crt', 'server.key')

3.1.2 创建一个安全的TCP客户端

同样地，我们也可以创建一个使用SSL/TLS的TCP客户端。

import socket
import ssl

def ssl_tcp_client(certfile):
    # 创建 socket 对象
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 使用 SSL/TLS 包装套接字
    client_socket = ssl.wrap_socket(client_socket, certfile=certfile)

    # 连接服务器
    client_socket.connect(('localhost', 8888))
    print("客户端已连接服务器")

    # 发送数据
    client_socket.send("你好，服务器".encode('utf-8'))

    # 接收服务器回复
    data = client_socket.recv(1024)
    print(f"收到服务器回复：{data.decode('utf-8')}")

    # 关闭连接
    client_socket.close()

if __name__ == '__main__':
    ssl_tcp_client('client.crt')

3.2 数据加密

除了使用SSL/TLS协议对整个通信过程进行加密，我们还可以对传输的数据进行单独的加密。Python的cryptography模块提供了强大的加密功能。

3.2.1 对称加密

对称加密是指加密和解密使用同一个密钥。AES（Advanced Encryption Standard）是一种常用的对称加密算法。

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def encrypt_symmetric(data, key):
    # 生成随机的初始向量
    iv = os.urandom(16)

    # 创建加密对象
    cipher = Cipher(algorithms.AES(key), modes.CFB(iv), backend=default_backend())

    # 加密数据
    encryptor = cipher.encryptor()
    encrypted_data = encryptor.update(data.encode('utf-8')) + encryptor.finalize()

    return iv + encrypted_data

def decrypt_symmetric(encrypted_data, key):
    # 从加密数据中分离初始向量
    iv = encrypted_data[:16]
    actual_data = encrypted_data[16:]

    # 创建解密对象
    cipher = Cipher(algorithms.AES(key), modes.CFB(iv), backend=default_backend())

    # 解密数据
    decryptor = cipher.decryptor()
    decrypted_data = decryptor.update(actual_data) + decryptor.finalize()

    return decrypted_data.decode('utf-8')

# 使用示例
key = os.urandom(32)  # AES-256位密钥
data = "要加密的数据"
encrypted_data = encrypt_symmetric(data, key)
decrypted_data = decrypt_symmetric(encrypted_data, key)

print(f"加密数据：{encrypted_data}")
print(f"解密数据：{decrypted_data}")

3.2.2 非对称加密

非对称加密使用一对密钥：公钥和私钥。公钥用于加密数据，而私钥用于解密数据。RSA是一种常用的非对称加密算法。

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import padding
import os

def generate_keys():
    # 生成 RSA 密钥对
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
        backend=default_backend()
    )
    public_key = private_key.public_key()
    return private_key, public_key

def encrypt_asymmetric(data, public_key):
    # 使用公钥加密数据
    encrypted_data = public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        ),
        backend=default_backend()
    )
    return encrypted_data

def decrypt_asymmetric(encrypted_data, private_key):
    # 使用私钥解密数据
    decrypted_data = private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        ),
        backend=default_backend()
    )
    return decrypted_data

# 使用示例
private_key, public_key = generate_keys()
data = "要加密的数据"
encrypted_data = encrypt_asymmetric(data.encode('utf-8'), public_key)
decrypted_data = decrypt_asymmetric(encrypted_data, private_key)

print(f"加密数据：{encrypted_data}")
print(f"解密数据：{decrypted_data.decode('utf-8')}")

3.3 HTTPS与安全Web服务器

HTTPS（Hypertext Transfer Protocol Secure）是HTTP的安全版本，它使用SSL/TLS协议加密数据传输。在Python中，我们可以使用ssl模块创建一个安全的Web服务器。

3.3.1 创建一个安全的Web服务器

from http.server import HTTPServer, BaseHTTPRequestHandler
import ssl

class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):

    def do_GET(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()
        self.wfile.write(b'Hello, world!')

def run_server(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler, port=443):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    httpd.socket = ssl.wrap_socket(httpd.socket, certfile='server.pem', server_side=True)
    print(f"Starting https server on port {port}...")
    httpd.serve_forever()

if __name__ == '__main__':
    run_server()

在这个例子中，我们创建了一个简单的HTTPS服务器，它使用SSL/TLS加密所有通信。服务器需要一个包含私钥和证书的PEM文件（server.pem）。

3.4 小结

在本部分，我们探讨了Python网络编程中的安全性问题，包括SSL/TLS协议的使用、数据加密以及HTTPS和安全Web服务器的创建。通过这些内容，我们了解了如何在网络通信中保护数据的安全性和完整性。在下一部分，我们将学习网络编程中的高级主题，如网络爬虫、API开发和使用WebSocket进行实时通信。

第四部分：Python网络编程高级应用

4.1 网络爬虫

网络爬虫是一种自动化获取网络页面内容的程序，常用于数据挖掘、舆情监控和搜索引擎索引。Python 提供了多个库来帮助开发者编写网络爬虫，其中最著名的是 requests 和 BeautifulSoup。

4.1.1 使用requests和BeautifulSoup进行爬虫

import requests
from bs4 import BeautifulSoup

url = 'https://www.example.com/'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

# 提取网页中的所有链接
for link in soup.find_all('a'):
    print(link.get('href'))

# 提取网页中的特定内容
title = soup.find('h1').text
print(f'网页标题：{title}')

4.1.2 遵守robots.txt规则

在进行网络爬虫时，应当遵守网站的 robots.txt 文件规则，该文件定义了哪些页面或内容是允许爬虫访问的。

4.2 API开发

API（Application Programming Interface）是软件组件之间交互的接口。随着微服务架构的流行，API成为了前后端分离的关键。Python 的 Flask 和 Django 框架都支持快速搭建 API。

4.2.1 使用Flask创建API

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/hello', methods=['GET'])
def hello_world():
    return jsonify(message='Hello, World!')

if __name__ == '__main__':
    app.run()

4.2.2 使用Django REST framework创建API

Django REST framework 是一个强大且灵活的工具，用于构建 Web API。

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

class HelloAPIView(APIView):
    def get(self, request, format=None):
        content = {'message': 'Hello, World!'}
        return Response(content)

# 在 Django 的 URL 配置中添加 API 路由
from django.urls import path
from . import views

urlpatterns = [
    path('api/hello/', views.HelloAPIView.as_view(), name='hello_api'),
]

4.3 WebSocket通信

WebSocket 提供了在单个 TCP 连接上进行全双工通信的能力。Python 的 websockets 库允许我们轻松实现 WebSocket 服务器和客户端。

4.3.1 创建WebSocket服务器

import websockets
import asyncio

async def echo(websocket, path):
    async for message in websocket:
        print(f"收到消息：{message}")
        await websocket.send(f"回复：{message}")

start_server = websockets.serve(echo, 'localhost', 8765)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

4.3.2 创建WebSocket客户端

import websockets
import asyncio

async def hello():
    uri = 'ws://localhost:8765'
    async with websockets.connect(uri) as websocket:
        await websocket.send('Hello, Server!')
        response = await websocket.recv()
        print(f"收到服务器回复：{response}")

asyncio.get_event_loop().run_until_complete(hello())

4.4 小结

在本部分，我们介绍了 Python 网络编程的高级应用，包括网络爬虫、API 开发和 WebSocket 通信。这些应用展示了 Python 在处理复杂网络任务方面的强大能力。在最后一部分，我们将学习如何测试和调试 Python 网络应用程序。

第五部分：Python网络编程的测试与调试

5.1 网络编程的测试

网络编程的测试通常包括单元测试、集成测试和端到端测试。Python 提供了多个库来帮助开发者进行网络应用的测试，如 unittest、pytest 和 requests。

5.1.1 使用unittest进行单元测试

unittest 是 Python 的标准库中的单元测试框架。它可以用于测试单个函数或方法是否按预期工作。

import unittest
from my_module import my_function

class TestMyFunction(unittest.TestCase):
    def test_my_function(self):
        self.assertEqual(my_function(1, 2), 3)

if __name__ == '__main__':
    unittest.main()

5.1.2 使用pytest进行集成测试

pytest 是一个成熟的全功能测试框架，它支持复杂的测试配置和参数化测试。

from my_module import my_function

def test_my_function():
    assert my_function(1, 2) == 3

def test_my_function_with_params():
    assert my_function(1, 2) == 3
    assert my_function(2, 2) == 4

5.1.3 使用requests进行端到端测试

requests 库可以用于模拟客户端请求，测试服务器端的响应。

import requests

def test_api_endpoint():
    response = requests.get('http://localhost:5000/api/hello')
    assert response.status_code == 200
    assert response.json() == {'message': 'Hello, World!'}

5.2 网络编程的调试

调试是识别和修复代码中错误的过程。Python 提供了多种调试工具，如 pdb、ipdb 和 IDE 自带的调试器。

5.2.1 使用pdb进行调试

pdb 是 Python 的标准库中的调试器。它可以用于设置断点、单步执行、查看变量值等。

import pdb

def my_function(a, b):
    result = a + b
    pdb.set_trace()  # 设置断点
    return result

my_function(1, 2)

5.2.2 使用IDE进行调试

现代IDE如 PyCharm、Visual Studio Code 等，提供了图形化的调试界面，可以更方便地进行调试。

5.3 性能测试

性能测试是评估应用程序在正常和峰值负载下的表现。Python 的 timeit 模块可以用于简单的性能测试。

import timeit

setup_code = """
def my_function(n):
    return sum(range(n))
"""

test_code = """
my_function(10000)
"""

# 执行性能测试
times = timeit.repeat(setup=setup_code, stmt=test_code, repeat=3, number=100)
print(min(times))

5.4 小结

在本部分，我们学习了 Python 网络编程的测试与调试方法。通过单元测试、集成测试和端到端测试，我们可以确保网络应用的各个部分按预期工作。使用 pdb 和 IDE 进行调试，可以帮助我们快速定位和修复代码中的错误。性能测试则确保了应用程序在高负载下仍然能够稳定运行。这些技能对于开发健壮和高效的网络应用程序至关重要。

知识点总结

以下是本文涵盖的知识点总结：

Python网络编程基础
- 网络协议简介：介绍了TCP、UDP和HTTP等常用网络协议。
- Python网络编程库：讲解了socket、requests等库的基本使用。
- socket编程基础：通过TCP客户端和服务器示例，演示了socket编程的基本步骤。
Python网络编程进阶
- 多线程与多进程：介绍了如何使用多线程和多进程提高服务器处理能力。
- 异步IO与asyncio：讲解了异步编程的基本概念和asyncio库的使用。
- HTTP编程：通过HTTP客户端和服务器示例，展示了HTTP请求和响应的处理。
- Web框架：介绍了Flask和Django等Web框架的基本使用。
Python网络编程的安全性
- SSL/TLS协议：讲解了如何在TCP服务器和客户端中添加SSL/TLS支持。
- 数据加密：介绍了对称加密（如AES）和非对称加密（如RSA）的使用。
- HTTPS与安全Web服务器：演示了如何创建一个安全的Web服务器。
Python网络编程高级应用
- 网络爬虫：介绍了requests和BeautifulSoup库在爬虫中的应用。
- API开发：展示了使用Flask和Django REST framework创建API的方法。
- WebSocket通信：讲解了如何使用websockets库实现WebSocket服务器和客户端。
Python网络编程的测试与调试
- 网络编程的测试：介绍了单元测试、集成测试和端到端测试的方法。
- 网络编程的调试：讲解了pdb和IDE调试的使用。
- 性能测试：演示了如何使用timeit进行简单的性能测试。

这些知识点为Python网络编程提供了全面的技术视角，从基础到进阶，再到高级应用，最后是测试与调试，构成了一个完整的知识体系。掌握这些知识点，可以帮助开发者有效地进行网络应用程序的开发和维护。

极客代码

关注

28
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Python网络编程：从基础到实践

网络编程的核心是网络协议。网络协议定义了计算机之间通信的规则，常见的网络协议有 TCP、UDP 和 HTTP 等。其中，TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议；UDP（用户数据报协议）是一种无连接的、不可靠的、基于数据报的传输层通信协议；HTTP（超文本传输协议）是一种应用层协议，主要用于分布式、协作式和超媒体信息系统的应用。
复制链接

扫一扫