本文还有配套的精品资源，点击获取

简介：这是一套全面、易懂的Python 3教程，专为初学者和自学者设计。教程包含廖雪峰编写的Python基础知识、面向对象编程、异常处理、文件操作、标准库和第三方库的使用、函数式编程、模块化编程、网络编程、数据分析与科学计算以及Web开发等内容。教程提供了清晰的文字描述和实践练习，旨在帮助读者快速有效地学习Python，了解其在各种实际项目中的应用。

1. Python基础入门

Python，作为当今世界最受欢迎的编程语言之一，以简洁明了的语法、强大的社区支持以及跨领域的应用潜力，吸引了无数初学者和专业人士。在这一章节中，我们将带你领略Python语言的魅力，并助你搭建坚实的基础。

1.1 理解Python的基本概念

首先，了解Python是一种解释型、高级、面向对象的编程语言。它强调代码的可读性，并且拥有一系列丰富的标准库，可以轻松地实现多种功能。Python支持多种编程范式，包括过程式、面向对象和函数式编程。

1.2 安装Python环境

为了开始编程之旅，我们需要一个Python解释器。Python的官方网站提供了针对不同操作系统的安装包。根据你的操作系统，下载相应版本的Python，并进行安装。安装完成后，通过命令行运行 python --version 确认Python已正确安装。

1.3 编写和运行你的第一个Python程序

打开文本编辑器，输入以下代码，保存为 hello.py :

print("Hello, Python World!")

打开命令行窗口，导航到保存文件的目录，然后运行 python hello.py 。如果一切正常，你应该会在屏幕上看到输出的问候语。

以上就是第一章的核心内容，相信通过这些简单明了的介绍，你已经对Python有了初步的了解。下一章我们将深入探讨Python的面向对象编程特性，进一步拓展你的编程视野。

2. 深入面向对象编程

2.1 类和对象的创建与使用

2.1.1 类的定义和构造方法

面向对象编程（OOP）是一种编程范式，它利用“对象”的概念来设计应用和计算机程序。在Python中，一切皆为对象，我们可以通过类（class）来定义对象。

类的定义：

class MyClass:

# 类体

pass

创建类实例（对象）的语法如下：

obj = MyClass()

构造方法： Python中没有专门的构造函数，但有一个特殊的方法 __init__ ，称为构造方法，它在创建对象时被自动调用，用于初始化对象状态。

class MyClass:

def __init__(self):

# 初始化方法

pass

2.1.2 对象的属性和方法

对象的属性和方法是类的实例所拥有的特性，它们定义了对象的行为和状态。

对象属性： 对象属性通常是对象的变量，用于存储状态信息。

class MyClass:

def __init__(self, attr):

self.attr = attr

obj = MyClass('value')

print(obj.attr) # 输出对象属性

对象方法： 对象方法是类中定义的函数，可以访问和修改对象的状态。

class MyClass:

def __init__(self, attr):

self.attr = attr

def my_method(self):

return self.attr

obj = MyClass('Hello')

print(obj.my_method()) # 调用对象方法

2.2 继承与多态

2.2.1 继承的概念和实现

继承是面向对象编程中的核心概念之一，它允许我们基于现有的类创建新的类，称为子类。

继承的概念： 继承允许子类拥有父类的属性和方法，并且还可以添加新的属性和方法。

class ParentClass:

def __init__(self):

self.parent_attr = 'Parent Value'

def parent_method(self):

return 'Parent Method Called'

class ChildClass(ParentClass):

def __init__(self):

super().__init__()

self.child_attr = 'Child Value'

def child_method(self):

return 'Child Method Called'

child = ChildClass()

print(child.parent_attr) # 输出从父类继承的属性

print(child.child_method()) # 输出子类特有的方法

2.2.2 方法重写与多态的表现

方法重写是指子类重新定义父类中的某个方法。多态是面向对象的另一个重要特性，它允许同一操作作用于不同对象时有不同的解释和行为。

class Animal:

def make_sound(self):

pass

class Dog(Animal):

def make_sound(self):

return 'Bark'

class Cat(Animal):

def make_sound(self):

return 'Meow'

def animal_sound(animal):

print(animal.make_sound())

dog = Dog()

cat = Cat()

animal_sound(dog) # 输出: Bark

animal_sound(cat) # 输出: Meow

2.3 面向对象高级特性

2.3.1 类的私有属性和方法

Python中使用单下划线（ _ ）和双下划线（ __ ）来表示类的私有属性和方法，这是一种约定俗成的用法。

私有属性：

class MyClass:

def __init__(self):

self.public_attr = 'Public Value'

self._semi_private_attr = 'Semi Private Value'

self.__private_attr = 'Private Value'

my_obj = MyClass()

print(my_obj.public_attr) # 访问公有属性

print(my_obj._semi_private_attr) # 访问半私有属性

# print(my_obj.__private_attr) # 报错：AttributeError

2.3.2 静态方法和类方法

静态方法和类方法都是不依赖于类实例的方法。

静态方法： 不接收实例或类作为隐式参数的方法。

class MyClass:

@staticmethod

def static_method():

print('This is a static method')

MyClass.static_method() # 直接通过类调用静态方法

类方法： 接收类作为隐式第一个参数的方法。

class MyClass:

@classmethod

def class_method(cls):

print(f'This is a class method of {cls}')

MyClass.class_method() # 直接通过类调用类方法

2.3.3 元类和动态创建类

元类（metaclass）是类的类，它定义了创建类的行为。

class Meta(type):

def __new__(cls, name, bases, dct):

# 在这里可以动态创建类

return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=Meta):

pass

本章介绍了面向对象编程的基础知识，包括类的创建、对象的使用、继承、多态，以及Python语言特有的私有属性、静态方法、类方法和元类的概念。这些概念是构建复杂应用程序和设计软件架构的基础。

3. 异常处理机制

3.1 常见的异常类型

3.1.1 内置异常类的介绍

在Python中，异常是程序运行中遇到的不正常情况，必须进行处理，否则会引发错误并导致程序终止。Python的内置异常类位于内置命名空间中，它们构成了一个异常类层次结构，为不同类型的错误提供了标准分类。

内置异常可以分为几个主要类别，包括但不限于以下几类：

BaseException ：这是所有异常的基类，但不推荐直接捕获此类异常，因为它包括了所有在Python中可能会引发的退出事件，如 SystemExit 、 KeyboardInterrupt 和 GeneratorExit 。 Exception ：这是大多数用户自定义异常的基类，用于处理大部分错误情况。 ArithmeticError ：数学运算中出现的错误，如 OverflowError 、 ZeroDivisionError 等。 TypeError ：对类型不合适的操作。 ValueError ：对值不合适的操作，如整数转浮点数时，如果给定的值无法转换，则引发此类错误。 IOError ：与输入/输出有关的错误，如文件不存在或者权限不足等。

每个异常类都可以提供更具体的信息来帮助我们了解问题所在，并采取相应的措施。

3.1.2 异常的捕获和处理

Python使用 try...except 语句块来处理异常。基本用法如下：

try:

# 尝试执行的代码块

risky_code()

except SomeException as e:

# 如果在try代码块中发生了SomeException异常，则会执行这里的代码

handle_exception(e)

else:

# 如果try代码块没有引发异常，则执行else代码块

no_exceptions()

finally:

# 不管是否发生异常，都会执行finally代码块

always_execute()

try 语句后面跟随的代码块是需要进行异常处理的代码。 except 语句指定要捕获的异常类型，并为该类型的异常提供处理代码。 else 语句在没有异常发生的情况下执行。 finally 语句无论是否发生异常都将执行，常用于清理操作，如关闭文件或网络连接。

代码逻辑分析与参数说明：

try:

result = 10 / 0 # 故意引发一个除以零的错误

except ZeroDivisionError as e:

print(f"捕获到一个除零错误: {e}") # 处理ZeroDivisionError异常

else:

print("没有发生异常，继续执行。")

finally:

print("尝试结束，无论是否发生异常。")

在上述示例中，当执行除零操作时，会引发 ZeroDivisionError 异常。 except 块捕获该异常，并打印出错误信息。 finally 块中的代码会在程序尝试结束后执行，不管是否发生异常。

3.2 异常处理的高级应用

3.2.1 自定义异常类

自定义异常是根据特定程序需要来创建的异常类，它们继承自 Exception 基类或其子类。自定义异常可以提供额外的信息，有助于程序的健壮性和维护性。

下面是一个自定义异常的示例：

class MyCustomError(Exception):

def __init__(self, message):

super().__init__(message)

self.message = message

# 使用自定义异常

try:

raise MyCustomError("这是一个自定义错误！")

except MyCustomError as e:

print(f"捕获到一个自定义异常: {e.message}")

在上面的代码中， MyCustomError 是一个自定义异常类，它接受一个错误消息作为构造函数的参数。通过抛出该异常并捕获它，我们可以对这个错误进行特殊处理。

3.2.2 异常与日志记录

在软件开发中，记录和跟踪错误对于调试和监控软件状态非常关键。Python的 logging 模块可以记录应用程序的错误信息和其他重要消息。

下面展示了如何将异常信息记录到日志文件：

import logging

# 配置日志

logging.basicConfig(filename='app.log', level=logging.ERROR)

try:

# 可能会引发异常的操作

raise ValueError("这会记录到日志文件中")

except Exception as e:

logging.error(f"发生错误: {e}") # 将错误信息记录到日志文件中

# 查看app.log文件内容

在这段代码中，如果 try 块中发生了异常，它会被捕获并记录到名为 app.log 的日志文件中。该文件将保存错误信息，同时还可以设置日志的详细级别，包括 DEBUG , INFO , WARNING , ERROR 和 CRITICAL 。

3.3 异常与资源管理

3.3.1 使用上下文管理器

上下文管理器是一种资源管理的机制，它通过 with 语句来管理资源的进入（enter）和退出（exit）。这对于资源需要被明确释放的场景非常有用，如文件操作、数据库连接等。

一个简单的上下文管理器示例如下：

class ManagedFile:

def __init__(self, filename):

self.filename = filename

def __enter__(self):

self.file = open(self.filename, 'w')

return self.file

def __exit__(self, exc_type, exc_val, exc_tb):

if self.file:

self.file.close()

with ManagedFile("test.txt") as f:

f.write("这是一段测试文本。")

# 'test.txt'文件被正确关闭

在这个示例中， ManagedFile 类定义了如何打开和关闭文件。使用 with 语句可以保证文件在离开 with 代码块时一定会关闭。

3.3.2 异常与文件操作

在文件操作过程中，经常会遇到异常情况，如文件不存在、磁盘空间不足等。正确的处理这些异常可以防止程序因错误而中断，并且允许程序以更稳定的方式运行。

下面的代码展示了如何安全地进行文件读写操作，并处理可能出现的异常：

def safe_file_read(path):

try:

with open(path, 'r') as f:

return f.read()

except FileNotFoundError:

print(f"错误：文件 {path} 不存在。")

except IOError as e:

print(f"文件读取错误：{e}")

return None

# 使用函数

read_content = safe_file_read("example.txt")

if read_content:

print("文件内容：", read_content)

在上述示例中， safe_file_read 函数尝试读取指定路径的文件，如果在读取过程中发生任何IO错误，它将捕获异常并打印错误消息。如果文件成功读取，函数将返回文件内容。通过这种方式，我们可以确保文件操作的安全性和代码的健壮性。

4. 文件操作的探索

文件操作是任何编程语言中不可或缺的一部分，特别是在进行数据分析、日志记录、持久化存储等任务时。Python提供了强大的内置库来执行各种文件操作，使得文件的读写变得异常简单。本章节深入探讨Python中的文件操作，从基础的读写操作开始，逐步深入到文件和目录的高级操作，最终介绍一些高级文件处理技术。

4.1 文件读写操作

4.1.1 打开和关闭文件

在Python中，处理文件的第一步是使用 open() 函数打开文件，然后进行读写操作。完成操作后，使用 close() 方法关闭文件以释放系统资源。

# 打开文件

file = open("example.txt", "r") # "r"表示读取模式

# 文件内容处理

content = file.read()

print(content)

# 关闭文件

file.close()

上述代码块演示了如何以只读模式打开一个名为 example.txt 的文件，并在读取内容后关闭文件。除了 "r" ，文件打开模式还包括 "w" （写入模式）、 "a" （追加模式）、 "b" （二进制模式）等。

4.1.2 文件的读取与写入

Python中读写文件非常直观。使用 read() 、 write() 和 readline() 等方法可以轻松读取和写入文件内容。

# 打开文件用于写入

file = open("example.txt", "w")

# 写入内容到文件

file.write("Hello, Python!\n")

# 写入多个字符串

file.writelines(["This is line 1\n", "This is line 2\n"])

# 关闭文件

file.close()

在写入文件时，推荐使用 with 语句，这样Python会在代码块执行完毕后自动关闭文件。

with open("example.txt", "w") as file:

file.write("Using 'with' statement for safe file handling.")

读取文件时也有多种方法：

# 读取整个文件内容

with open("example.txt", "r") as file:

content = file.read()

# 逐行读取

with open("example.txt", "r") as file:

for line in file:

print(line.strip())

# 读取特定行

with open("example.txt", "r") as file:

file.seek(0) # 将文件指针移动到文件开头

lines = file.readlines() # 读取所有行

specific_line = lines[1] # 获取第二行

4.1.3 文件读写进阶操作

文件读写还包含许多进阶操作，如使用 seek() 方法移动文件指针，以及使用 truncate() 方法裁剪文件大小。

# 使用seek()方法移动文件指针到指定位置

with open("example.txt", "r+") as file:

file.seek(5) # 移动到第5个字符的位置

file.write("Python is fun!") # 在第五个字符后追加内容

# 使用truncate()方法裁剪文件大小

with open("example.txt", "r+") as file:

file.truncate(10) # 裁剪到文件前10个字符

进阶操作允许开发者在读写文件时具有更高的灵活性和控制力，以适应复杂的应用场景。

4.2 文件和目录的操作

文件系统中除了文件还有目录，它们一起构成了程序存储和管理数据的基础。Python标准库提供了 os 和 shutil 模块，能够轻松进行文件和目录的创建、删除与管理。

4.2.1 遍历目录与子目录

遍历目录是许多应用场景的基础，Python中的 os 模块可以帮助我们轻松实现。

import os

# 列出当前目录

for item in os.listdir('.'):

print(item)

# 遍历目录树

def listdir_full(path):

for root, dirs, files in os.walk(path):

level = root.replace(path, '').count(os.sep)

indent = ' ' * 4 * (level)

print('{}{}/'.format(indent, os.path.basename(root)))

subindent = ' ' * 4 * (level + 1)

for f in files:

print('{}{}'.format(subindent, f))

listdir_full('.')

4.2.2 文件和目录的创建、删除与重命名

创建和删除文件和目录是常见的操作。 os 模块提供了 mkdir 和 remove 等函数来执行这些任务。

# 创建目录

os.mkdir('new_directory')

# 删除文件

os.remove('example.txt')

# 删除目录

os.rmdir('new_directory')

# 重命名文件或目录

os.rename('oldname.txt', 'newname.txt')

4.2.3 文件操作的高级应用

除了基本操作之外， shutil 模块还提供了复制、移动文件或目录的功能，甚至支持文件内容的比较。

import shutil

# 复制文件

shutil.copy('example.txt', 'example_backup.txt')

# 移动文件

shutil.move('example_backup.txt', 'backup/')

# 文件内容比较

if not os.path.exists('example.txt') or not os.path.exists('example_backup.txt'):

print("One of the files does not exist")

else:

if os.path.getsize('example.txt') == os.path.getsize('example_backup.txt'):

print("The files are the same size!")

else:

print("Different file sizes!")

这些高级应用可以满足更复杂的文件管理需求，例如备份、迁移和文件同步等。

4.3 文件操作的高级技术

4.3.1 使用标准库进行文件操作

Python标准库提供了丰富的API来执行文件操作，从读写到路径管理，从文件属性到文件系统遍历，无所不包。

# 获取文件状态

file_stats = os.stat('example.txt')

print(file_stats.st_size) # 输出文件大小

# 分离文件名和扩展名

filename, file_extension = os.path.splitext('example.txt')

print(filename) # 输出文件名

print(file_extension) # 输出文件扩展名

4.3.2 文件的二进制处理

文件操作不仅限于文本，有时需要处理二进制文件，如图片、音视频等。Python提供了直接读写二进制数据的方法。

# 读取二进制文件

with open('image.png', 'rb') as file:

binary_data = file.read()

# 写入二进制文件

with open('new_image.png', 'wb') as file:

file.write(binary_data)

4.3.3 文件的内存映射

在处理大型文件时，将整个文件内容加载到内存可能会导致资源紧张。Python的 mmap 模块可以对文件进行内存映射，从而提高效率。

import mmap

# 打开文件进行内存映射

with open('large_file.dat', 'r+b') as f:

mapped = mmap.mmap(f.fileno(), 0) # 0 表示映射整个文件

# 进行文件内容处理...

mapped.close()

文件操作的高级技术为开发者提供了处理复杂文件任务的能力，比如大文件、二进制文件和系统级文件管理。

通过深入探索Python中的文件操作，开发者可以获得从基础到高级的全面技能，以便更好地管理程序中的数据持久化和资源。下一章将介绍如何使用Python的标准库与第三方库进行更多功能的实现。

5. 标准库与第三方库的应用

5.1 标准库的强大功能

Python的标准库提供了丰富的模块和函数，它们是Python编程的核心组成部分，能够帮助开发者轻松完成许多常见的编程任务。在这一节中，我们将深入了解集合和数据结构以及网络与并发编程中的标准库应用。

5.1.1 集合和数据结构

Python的 collections 模块提供了许多用于特定任务的容器类型，这些容器比标准的Python容器（如列表、元组和字典）更加专业和高效。例如， Counter 是一个字典的子类，用于计数可哈希对象。

from collections import Counter

words = ["apple", "banana", "cherry", "apple", "banana", "apple"]

word_counts = Counter(words)

print(word_counts)

# 输出: Counter({'apple': 3, 'banana': 2, 'cherry': 1})

在上述代码块中，我们使用了 Counter 来统计一个单词列表中每个单词出现的次数。标准库中的 defaultdict 也可以用来处理不存在的键，它会返回一个默认值而不是抛出 KeyError 异常。

5.1.2 网络与并发编程

网络编程是编写能够与远程系统交换数据的软件的过程。Python的标准库中的 socket 模块为底层网络协议提供了支持。

import socket

def print_messages(sock, message):

while True:

incoming = sock.recv(2048)

if incoming:

print(message + incoming.decode('utf-8'))

else:

break

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.connect(('localhost', 12345))

print_messages(sock, "Hello, server!")

上述代码展示了如何使用 socket 模块创建一个TCP/IP连接。此外， threading 和 multiprocessing 模块提供了创建并发运行的线程和进程的接口，这些是实现多任务程序的基础。

5.2 第三方库的选择与使用

Python的第三方库是全球开发者社区贡献的宝贵资源，它们通常通过包管理工具 pip 安装和管理。

5.2.1 第三方库的安装和管理

使用 pip ，你可以安装几乎任何第三方库：

pip install numpy

这个命令会下载并安装NumPy库，这是科学计算领域常用的库之一。为了避免潜在的版本冲突，建议使用虚拟环境来管理不同项目的依赖。

5.2.2 常见第三方库的使用案例

让我们以 requests 库为例，展示如何通过第三方库进行网络请求。 requests 库简化了向服务器发送各种HTTP请求的方式。

import requests

response = requests.get('https://api.github.com')

print(response.status_code)

在这个代码块中，我们向GitHub的API发起了一个GET请求，并打印出响应的HTTP状态码。 requests 库自动处理了许多底层的网络编程细节。

5.3 从标准库到第三方库的扩展

在Python中，理解和利用标准库与第三方库对于开发高效、可靠的程序至关重要。

5.3.1 库的版本管理和兼容性

当使用第三方库时，版本管理是一个不可忽视的问题。你可以使用 pip freeze 来列出当前环境中的所有库的版本：

pip freeze > requirements.txt

这样，你可以通过 requirements.txt 文件共享你的项目依赖。在新环境中，使用以下命令来安装相同版本的依赖：

pip install -r requirements.txt

5.3.2 实践：构建自己的Python项目

最后，让我们通过一个实例来展示如何将标准库与第三方库结合起来构建一个项目。假设我们要创建一个简单的爬虫，它能够从网页上抓取数据并进行处理。

import requests

from bs4 import BeautifulSoup

def fetch_and_parse(url):

response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')

articles = soup.find_all('article')

return [article.get_text() for article in articles]

url = 'https://www.example.com/articles'

articles = fetch_and_parse(url)

上述代码展示了如何结合使用 requests 和 BeautifulSoup 库来抓取网页文章并提取其文本。这个实例演示了如何灵活运用库来解决实际问题。

到目前为止，我们已经深入探讨了Python的标准库和第三方库的使用及其在不同编程场景中的应用。下一章节将带领读者进一步探索Python的高级编程范式与应用，包括函数式编程和模块化编程，以及如何将这些概念应用在实际的编程实践中。

6. 高级编程范式与应用

6.1 函数式编程的特点

6.1.1 高阶函数与闭包

函数式编程是一种编程范式，其中函数是一等公民，即函数可以作为参数传递、作为返回值，也可以赋值给变量。Python虽然不完全是函数式编程语言，但提供了许多支持函数式编程的特性。

高阶函数是指至少满足下列一个条件的函数： - 接受一个或多个函数作为输入 - 输出一个函数

闭包是一个函数，它能够记住并访问其定义时的词法作用域，即便是在当前作用域之外执行。下面是一个简单的闭包示例：

def make_multiplier_of(n):

def multiplier(x):

return x * n

return multiplier

# 使用闭包创建一个乘以3的函数

times3 = make_multiplier_of(3)

print(times3(10)) # 输出：30

在这个例子中， make_multiplier_of 是一个高阶函数，它返回了 multiplier 这个闭包，闭包记住了乘数 n 。

6.1.2 函数装饰器与偏函数应用

函数装饰器是 Python 的一个特性，它允许你在不改变原函数定义的前提下，增加原函数的功能。装饰器本质上是一个高阶函数，它接受一个函数作为参数，并返回一个新的函数。

下面是一个简单的装饰器应用：

def my_decorator(func):

def wrapper():

print("Something is happening before the function is called.")

func()

print("Something is happening after the function is called.")

return wrapper

@my_decorator

def say_hello():

print("Hello!")

say_hello()

在上面的代码中， my_decorator 是一个装饰器，它在 say_hello 函数执行前后添加了额外的打印语句。

偏函数应用是创建一个新的可调用对象的过程，这个对象会预先填充一些参数。 functools.partial 允许你固定某个函数的部分参数，从而得到一个新的可以调用的对象。

from functools import partial

def power(x, n):

return x**n

square = partial(power, n=2)

cube = partial(power, n=3)

print(square(2)) # 输出：4

print(cube(2)) # 输出：8

在这个例子中， partial 被用来创建两个新的函数： square 和 cube ，它们预先设置了 power 函数的 n 参数。

6.2 模块化编程的技巧

6.2.1 模块与包的概念

模块是 Python 程序架构的一个核心概念，它是一个包含 Python 定义和语句的文件，文件名为 .py 。模块可以定义函数、类和变量，也可以包含可执行的代码。模块能够使代码组织得更加模块化，便于重用。

包是一种包含多个模块的方式。一个包通常包含了一个 __init__.py 文件，这个文件用来标识包内的模块属于同一个包。包的目的是为了防止全局命名空间的冲突。

6.2.2 模块的导入与分发

导入模块使用 import 语句。模块可以被导入到其他模块中，并提供其功能。例如：

# some_module.py

def some_function():

print("This is a function inside some_module.")

# another_module.py

import some_module

some_module.some_function()

在 Python 中分发模块通常涉及到使用 setuptools 。一个模块需要一个 setup.py 文件来指定模块的元数据和依赖关系，之后可以使用 pip 进行安装。

# setup.py

from setuptools import setup, find_packages

setup(

name='example',

version='0.1',

packages=find_packages(),

# 其他元数据

)

之后，用户可以使用以下命令来安装这个模块：

pip install .

6.3 网络编程的实践

6.3.1 网络基础知识回顾

网络编程涉及创建客户端和服务器端的程序，使得它们能够通过网络进行通信。在 Python 中， socket 模块是进行网络编程的基础，它提供了底层的网络通信功能。

客户端和服务器使用 IP 地址和端口号在网络上定位对方。端口号是一个 16 位的无符号整数，范围从 0 到 65535，用来标识网络上的一个服务。

6.3.2 实现简单的Web服务器与客户端

下面是一个简单的 TCP 服务器端实现：

import socket

def run_server(host, port):

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server_socket.bind((host, port))

server_socket.listen(5)

print(f"Server listening on {host}:{port}")

conn, addr = server_socket.accept()

with conn:

print(f"Connected by {addr}")

while True:

data = conn.recv(1024)

if not data:

break

conn.sendall(data)

if __name__ == '__main__':

run_server('127.0.0.1', 8000)

这个服务器监听本地主机的 8000 端口，并将接收到的数据原样发送回去。

一个简单的客户端示例：

import socket

def run_client(server_host, server_port):

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:

sock.connect((server_host, server_port))

sock.sendall(b'Hello, server')

data = sock.recv(1024)

print(f"Received: {data.decode()}")

if __name__ == '__main__':

run_client('127.0.0.1', 8000)

在上面的例子中，客户端连接到服务器，并发送一条消息。然后等待服务器的响应，并将响应打印到控制台。这些代码片段展示了网络编程中最基本的客户端-服务器模型。

本文还有配套的精品资源，点击获取

简介：这是一套全面、易懂的Python 3教程，专为初学者和自学者设计。教程包含廖雪峰编写的Python基础知识、面向对象编程、异常处理、文件操作、标准库和第三方库的使用、函数式编程、模块化编程、网络编程、数据分析与科学计算以及Web开发等内容。教程提供了清晰的文字描述和实践练习，旨在帮助读者快速有效地学习Python，了解其在各种实际项目中的应用。

本文还有配套的精品资源，点击获取