1. Python解释器是如何执行代码的？
Python解释器执行代码的过程可以概括为以下几个步骤：
1. **源代码文件读取**：
- 用户编写Python代码并保存为`.py`文件。
- 运行Python程序时，解释器首先读取源代码文件。2. **词法分析**：
- 解释器对源代码进行词法分析，将代码分解为一个个的词素（tokens），如关键字、标识符、运算符等。3. **语法分析**：
- 将词素组合成语法结构，检查代码的语法是否正确。这一步会构建出一个抽象语法树（Abstract Syntax Tree, AST）。4. **编译**：
- 将AST编译成字节码（Bytecode）。Python的字节码是一种中间形式，它不是机器码，但比源代码更接近机器指令。
- 字节码会被存储在`.pyc`文件中，以便下次执行时可以快速加载。5. **执行**：
- 字节码由Python虚拟机（Python Virtual Machine, PVM）执行。虚拟机会逐行解释执行字节码。6. **运行时环境**：
- 解释器会管理运行时环境，包括内存分配、垃圾回收、调用栈等。7. **执行结果输出**：
- 程序执行过程中产生的输出会被发送到标准输出（通常是控制台）。8. **异常处理**：
- 如果代码执行过程中出现异常，解释器会根据异常类型和位置进行处理，可能输出错误信息或触发异常处理机制。9. **程序结束**：
- 一旦代码执行完毕或遇到终止条件（如`return`语句或`sys.exit()`调用），解释器会清理资源并退出程序。### 额外的说明：
- **全局解释器锁（GIL）**：
- 在CPython（Python的官方和最常用的实现）中，有一个全局解释器锁（GIL），它确保在多线程环境中，同一时刻只有一个线程可以执行Python字节码。这是为了简化内存管理，但也限制了多线程程序的性能。- **即时编译（JIT）**：
- 从Python 3.2开始，Python引入了即时编译器（如Psyco、PyPy等），它可以在运行时将热点代码（频繁执行的代码）编译成机器码，从而提高执行效率。- **多态性**：
- Python是一种动态类型语言，解释器在运行时会根据变量的实际类型来决定如何调用方法或访问属性。通过这些步骤，Python解释器能够将编写的代码转换为机器可以执行的指令，并最终输出程序的执行结果。
2. Python中"=="和"is"有什么区别？
==运算符：
==是等值运算符，用于比较两个对象的值是否相等。- 当使用
==时，Python会检查两个对象的值或内容是否相同。对于可变类型（如列表、字典、类实例等），它们的内容需要相同；对于不可变类型（如整数、字符串、元组等），它们的值需要相同。
is运算符：
is是身份运算符，用于比较两个对象的内存地址（即它们的标识）是否相同。- 当使用
is时，Python会检查两个对象是否是同一个对象，即它们是否指向内存中的同一位置。区别和使用场景：
- 值比较：当你想检查两个对象的值是否相同时，使用
==。- 身份比较：当你想检查两个变量是否引用同一对象时，使用
is。- 内存效率：
is通常用于检查对象是否是同一个实例，这在处理对象的身份或在处理单例模式时很有用。- 性能：
is比较通常比==更快，因为它只比较内存地址。
3. Python中的装饰器是什么？请给出一个例子。
Python中的装饰器是一种设计模式，用于修改或增强函数、方法或类的行为而无需改变其本身的代码。装饰器本质上是一个函数，它接受一个函数作为参数并返回一个新的函数。
样本：
def decorator_function(original_function): def wrapper(*args, **kwargs): # 在调用原始函数之前执行的代码 result = original_function(*args, **kwargs) # 在调用原始函数之后执行的代码 return result return wrapper# 定义一个装饰器 def my_decorator(func): def wrapper(): print("Something is happening before the function is called.") result = func() print("Something is happening after the function is called.") return result return wrapper # 使用装饰器 @my_decorator def say_hello(): print("Hello!") say_hello()
4. Python中如何实现多态？
继承和方法重写（Override）
抽象类
from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def sound(self): pass class Dog(Animal): def sound(self): print("Woof!") class Cat(Animal): def sound(self): print("Meow!") def make_sound(animal): animal.sound() dog = Dog() cat = Cat() make_sound(dog) # 输出: Woof! make_sound(cat) # 输出: Meow!
5. 请解释Python中的闭包。
在Python中，闭包（Closure）是一个由函数定义、包含了其所在作用域的引用的函数对象。闭包允许一个函数访问创建时的作用域中的变量，即使该函数在其原始作用域之外被调用。
闭包通常在以下情况下形成：
- 当一个嵌套函数访问了其外部函数的非全局变量时。
- 当外部函数返回了这个嵌套函数时。
闭包的关键特点：
- 数据封闭：闭包可以记住并访问创建时的作用域内的变量，即使外部函数已经执行完毕。
- 延迟计算：闭包可以在需要时才计算并返回结果，实现延迟执行。
- 封装：闭包可以隐藏内部实现细节，只暴露出一个可以被外界访问的接口。
def outer_function(x): def inner_function(y): return x + y return inner_function # 创建闭包 closure = outer_function(10) # 使用闭包 result = closure(5) # 输出: 15 print(result)
6. Python中有哪些魔术方法（dunder methods）？
在Python中，魔术方法（也称为双下方法，dunder是"double underscore"的缩写）是一些具有特殊意义的预定义方法。这些方法通常不需要直接调用，而是由Python解释器在特定的情况下自动调用。以下是一些常见的魔术方法：
__init__(self, ...)：
- 类的构造器，创建对象时初始化对象状态。
__del__(self)：
- 类的析构器，当对象被销毁时调用。
__str__(self)：
- 当使用
print()函数或str()时调用，返回对象的字符串表示。
__repr__(self)：
- 当使用
repr()函数时调用，返回对象的官方字符串表示，通常可以用来重新创建该对象。
__len__(self)：
- 当使用
len()函数时调用，返回容器类型的长度。
__getitem__(self, key)：
- 用于获取序列的元素，如
obj[key]。
__setitem__(self, key, value)：
- 用于设置序列的元素，如
obj[key] = value。
__delitem__(self, key)：
- 用于删除序列的元素，如
del obj[key]。
__iter__(self)：
- 返回对象的迭代器，用于迭代操作，如
for x in obj。
__next__(self)：
- 迭代器的下一个元素，用于
for循环。
__call__(self, ...)：
- 允许一个对象像函数那样被调用，如
obj()。
__eq__(self, other)：
- 定义等于符号的行为，如
obj == other。
7、请解释Python中的生成器和迭代器。
在Python中，生成器（Generator）和迭代器（Iterator）是两种用于处理数据集合的协议，它们都允许你逐个元素地访问集合，但它们之间存在一些关键的区别。
迭代器（Iterator）
迭代器是一个遵循迭代器协议的对象，该协议包括以下两个基本方法：
__iter__()：返回迭代器对象本身（通常返回self）。__next__()：返回序列中的下一个元素。迭代器用于访问集合中的元素，而不需要一次性将所有元素加载到内存中。这是处理大型数据集或无限序列的一种有效方式。
生成器（Generator）
生成器是一种特殊的迭代器，它是通过在函数中使用
yield语句创建的。当生成器函数被调用时，它返回一个生成器对象，而不是执行函数体。
- 当你迭代生成器时，Python会执行生成器函数，直到遇到
yield语句，然后返回yield后面的表达式值。- 每次迭代都会从上一次离开的地方继续执行，直到生成器函数完成。
生成器非常适合于实现延迟计算（lazy evaluation），因为它们只有在请求下一个元素时才计算该元素。
def my_generator(n): for i in range(n): yield i # 使用生成器 gen = my_generator(5) for item in gen: print(item)生成器和迭代器的比较：
- 内存使用：生成器通常比迭代器更节省内存，因为它们只在需要时生成下一个元素。
- 写法：生成器通过
yield语句实现，而迭代器需要实现__iter__和__next__方法。- 可读性：生成器通常更简洁，易于编写和理解。
- 控制流：生成器函数可以使用
return语句提前退出，而迭代器需要通过抛出StopIteration异常来结束迭代。
8、请解释Python中的全局解释器锁（GIL）
全局解释器锁（Global Interpreter Lock，简称GIL）是Python编程语言中的一个概念，特别是在CPython（Python的官方和最常用的实现）中。GIL的主要作用是同步对共享资源（如内存管理）的访问，确保在任何时刻只有一个线程执行Python字节码。
GIL的工作原理：
- 线程同步：在CPython中，GIL确保一次只有一个线程可以执行Python代码。这意味着即使在多线程环境中，Python字节码的执行也是序列化的。
- 内存管理：Python使用引用计数机制来管理内存。GIL确保在内存分配和释放时，引用计数的更新是原子操作，防止多线程同时修改内存。
GIL的影响：
- 多线程性能：由于GIL的存在，多线程Python程序在执行CPU密集型任务时可能不会获得预期的性能提升。GIL限制了多线程的并行执行，使得多线程程序在某些情况下可能无法充分利用多核处理器。
- I/O密集型任务：对于I/O密集型任务（如文件读写、网络通信等），GIL的影响较小。因为在等待I/O操作完成时，GIL会被释放，允许其他线程运行。
- 扩展性：GIL使得CPython在多线程扩展性方面受到限制，特别是在需要大量并行计算的场景中。
如何绕过GIL：
- 使用多进程：通过
multiprocessing模块，可以创建多个进程，每个进程有自己的Python解释器和内存空间，从而绕过GIL的限制。- 使用其他Python实现：如PyPy、Jython等，这些实现可能不使用GIL或使用不同的并发机制。
- 使用C扩展：通过编写C语言扩展，可以释放GIL并在C代码中执行计算密集型任务，然后再重新获取GIL。
- 使用第三方库：如
numpy和pandas，这些库内部使用C语言编写，可以绕过GIL进行高效的数组计算。GIL的优点：
- 简化内存管理：GIL使得内存管理变得更加简单，因为不需要担心多线程同时修改内存。
- 减少内存消耗：由于GIL的存在，CPython只需要维护一个线程的内存状态，减少了内存消耗。
尽管GIL在某些情况下限制了Python的并行性能，但它也带来了内存管理和实现上的便利。在实际应用中，开发者需要根据任务类型和性能需求选择合适的并发策略。
9、Python中如何使用模块和包？
在Python中，模块和包是组织代码和实现代码重用的重要方式。
模块（Module）： 模块是一个包含Python定义和语句的.py文件。它定义了一个独立的命名空间，可以用来存储变量、函数和类等。要导入一个模块，可以使用
import语句。包（Package）： 包是一个包含多个模块的文件夹，通常以.py结尾。包的目的是将一组相关的模块组织在一起，以便于管理和使用。要导入一个包，可以使用
import语句，并在包名后加上冒号和子包名。例如，要导入math包中的cmath模块，可以使用以下代码import math.cmath print(math.cmath.sqrt(-1)) import math print(math.pi) print(math.cmath.sqrt(-1)) import math as m print(m.pi) from math import pi print(pi)
9、请解释Python中的lambda函数。
lambda函数是一种简单的匿名函数，即没有具体名称的函数。lambda函数通常用于需要一个小函数的地方，例如作为其他函数的参数。
# 一个简单的Lambda函数，计算两个数的和 add = lambda x, y: x + y # 使用Lambda函数 print(add(5, 3)) # 输出: 8 # Lambda函数作为映射操作的参数 numbers = [1, 2, 3, 4, 5] squared = list(map(lambda x: x**2, numbers)) print(squared) # 输出: [1, 4, 9, 16, 25] # Lambda函数作为排序操作的参数 sorted_numbers = sorted(numbers, key=lambda x: -x) print(sorted_numbers) # 输出: [5, 4, 3, 2, 1]
10、如何在Python中实现多线程和多进程？
在Python中实现多线程和多进程，可以通过标准库中的
threading和multiprocessing模块来完成。import threading def print_numbers(): for i in range(5): print(i) if __name__ == "__main__": thread = threading.Thread(target=print_numbers) thread.start() print("主线程继续执行") thread.join() print("所有线程执行完毕") from multiprocessing import Process def print_numbers(): for i in range(5): print(i) if __name__ == "__main__": process = Process(target=print_numbers) process.start() print("主进程继续执行") process.join() print("所有进程执行完毕")
- 全局解释器锁（GIL）：在CPython中，由于GIL的存在，多线程可能不会带来预期的性能提升，特别是对于CPU密集型任务。对于I/O密集型任务，多线程仍然是有用的。
- 进程间通信：进程间通信（IPC）可以通过
multiprocessing模块提供的Queue、Pipe等机制实现。- 数据共享：进程间的数据共享需要通过特定的方式实现，如使用
multiprocessing模块的Manager。- 安全：多进程比多线程更安全，因为每个进程有自己的内存空间，避免了数据竞争和同步问题
11、请解释Python中的深拷贝和浅拷贝。
在Python中，深拷贝和浅拷贝是两种不同的对象复制机制，它们在复制对象时的行为有所不同。
浅拷贝（Shallow Copy）
浅拷贝是创建一个新对象，其内容是原始对象中对象的引用的拷贝。这意味着：
- 浅拷贝会创建一个新对象，但是它不会递归地复制对象内部的元素。
- 如果原始对象包含对其他对象的引用（如列表、字典、类实例等），浅拷贝只会复制这些引用，而不是引用的对象本身。
深拷贝（Deep Copy）
深拷贝是对对象以及对象的所有子对象进行拷贝，创建完全独立的副本。这意味着：
- 深拷贝会递归地复制对象及其所有子对象，创建全新的对象。
- 原始对象和拷贝对象之间没有引用上的关联。
import copy original = [1, 2, [3, 4], 5] shallow_copied = copy.copy(original) deep_copied = copy.deepcopy(original) # 修改原始列表中的嵌套列表 original[2].append(6) print(original) # 输出: [1, 2, [3, 4, 6], 5] print(deep_copied) # 输出: [1, 2, [3, 4], 5] print(original) # 输出: [1, 2, [3, 4, 6], 5] print(shallow_copied) # 输出: [1, 2, [3, 4, 6], 5]使用场景：
- 浅拷贝：当你需要快速复制对象，并且对象内部的引用不需要独立副本时，可以使用浅拷贝。
- 深拷贝：当你需要完全独立的副本，包括对象内部的所有子对象时，应该使用深拷贝。
注意事项：
- 深拷贝比浅拷贝更消耗资源，因为它需要创建更多的对象。
- 在某些情况下，深拷贝可能不会拷贝某些特殊对象，如文件句柄、线程锁等。
11、Python中如何使用正则表达式？
首先，需要导入Python的
re模块。编写一个符合需求的正则表达式字符串。例如，要匹配一个电子邮件地址，可以使用以下正则表达式：
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'使用
re模块的方法对字符串进行匹配。
re.match()：
- 从字符串的开始位置匹配正则表达式。
- 如果开始位置不匹配，返回
None。
re.search()：
- 扫描整个字符串，返回第一个成功的匹配。
- 如果没有找到匹配项，返回
None。使用
re.findall()找到字符串中所有匹配的项。使用
re.sub()替换字符串中的匹配项。使用
re.split()根据正则表达式拆分字符串。
12、请解释Python中的垃圾回收机制。
Python中的垃圾回收机制是一种自动内存管理功能，用于回收不再使用的对象所占用的内存。Python主要使用以下两种方法来实现垃圾回收：
引用计数（Reference Counting）：
- 每个对象都有一个引用计数，用于跟踪有多少个引用指向该对象。
- 当一个对象被创建时，其引用计数初始化为1（对于内置函数和模块等全局对象，初始值可能大于1）。
- 当一个对象的引用被删除或被赋予新的对象时，其引用计数减1。
- 当对象的引用计数降至0时，意味着没有任何引用指向该对象，该对象可以被垃圾回收器回收。
标记-清除（Mark-and-Sweep）：
- 为了解决循环引用的问题，Python使用标记-清除机制。
- 垃圾回收器定期运行，从根对象（如全局变量和调用栈中的局部变量）开始，递归地遍历所有可达的对象。
- 在遍历过程中，所有可达的对象都会被标记为“活跃”。
- 遍历结束后，未被标记的对象被认为是“垃圾”，可以被回收。
垃圾回收的过程：
识别垃圾：
- 垃圾回收器首先识别出所有可达的对象，这些对象不会被回收。
- 然后，识别出所有不可达的对象，这些对象是潜在的垃圾。
回收内存：
- 对于不可达的对象，垃圾回收器会释放它们占用的内存。
- 对于包含复杂数据结构（如列表、字典等）的对象，垃圾回收器还会递归地释放其内部元素占用的内存。
内存整理：
- 在某些情况下，垃圾回收器还会整理内存，减少内存碎片。
特殊情况：
循环引用：
- 如果两个或多个对象相互引用，它们的引用计数永远不会降到0，但它们又不可达，这种情况下就需要标记-清除机制来识别和回收。
**
__del__方法**：
- 对象的
__del__方法会在对象被销毁时调用，可以用于执行清理操作，如关闭文件、释放资源等。垃圾回收的触发：
- 垃圾回收器并不是在每次对象被删除时立即运行，而是在特定条件下触发，如内存不足或达到一定的垃圾数量。
垃圾回收的优点：
- 自动管理内存：开发者不需要手动管理内存，减少了内存泄漏的风险。
- 提高开发效率：开发者可以更专注于业务逻辑，而不是内存管理。
- 资源利用率：通过回收不再使用的对象，可以更有效地利用内存资源。
注意事项：
- 过度依赖垃圾回收：虽然垃圾回收可以自动管理内存，但过度依赖它可能会导致性能问题，如内存泄漏和频繁的垃圾回收。
- 理解垃圾回收机制：了解垃圾回收的工作原理有助于编写更高效的代码，避免潜在的性能问题。
13、Python中有哪些内置函数？
Python有很多内置函数，以下是一些常用的内置函数：
abs(x): 返回数字的绝对值。all(iterable): 如果迭代器中的所有元素都为真（True），返回True，否则返回False。any(iterable): 如果迭代器中的任何元素为真（True），返回True，否则返回False。bin(x): 将整数转换为二进制字符串。bool([x]): 将参数转换为布尔值，如果参数是假（False），返回False，否则返回True。chr(i): 返回Unicode字符的字符串表示。dir([object]): 返回一个包含对象属性和方法名称的列表。enumerate(iterable[, start]): 返回一个枚举对象，包含迭代器的索引和值。eval(expression[, globals[, locals]]): 计算Python表达式，并返回结果。exec(object[, globals[, locals]]): 执行Python代码，并返回最后表达式的值。filter(function, iterable): 返回一个迭代器，包含迭代器中所有满足函数要求的元素。getattr(object, name[, default]): 获取对象的属性值。globals(): 返回一个字典，包含当前作用域的所有全局变量。hasattr(object, name): 检查对象是否具有属性。input([prompt]): 读取用户输入的字符串。int(value=0[, base=10]): 将参数转换为整数。isinstance(object, classinfo): 检查对象是否属于特定类型。iter(iterable[, sentinel]): 返回迭代器的迭代器。len(object): 返回对象的长度。list(iterable): 将迭代器转换为列表。locals(): 返回一个字典，包含当前作用域的所有局部变量。map(function, iterable, ...): 对迭代器中的元素应用函数，并返回一个映射对象。max(iterable[, key[, default]]): 返回迭代器中的最大元素。min(iterable[, key[, default]]): 返回迭代器中的最小元素。open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None): 打开文件。ord(c): 返回字符的Unicode码。print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False): 打印对象。property([fget[, fset[, fdel[, doc]]]]): 创建新的属性。range(stop): 创建一个等差数列。range(start, stop[, step]): 创建一个等差数列。repr(object): 返回对象的字符串表示。sorted(iterable[, key[, reverse]]): 对迭代器进行排序。str(object=''): 将对象转换为字符串。sum(iterable[, start]): 计算迭代器中的所有元素之和。type(object): 返回对象的类型。这只是Python中内置函数的一部分，Python还有很多其他内置函数。
14、请解释Python中的虚拟环境。
Python中的虚拟环境是一种工具，用于创建隔离的Python环境。每个虚拟环境都有自己的Python二进制文件（解释器）和一套独立的Python库。使用虚拟环境可以：
- 隔离项目依赖：不同的项目可能需要不同版本的库，虚拟环境可以避免这些依赖之间的冲突。
- 避免全局安装：不需要将所有库安装到全局环境中，从而保持系统环境的整洁。
- 提高安全性：每个环境都是独立的，一个环境的问题不会影响其他环境。
- 便于部署：可以确保在不同环境中部署的应用程序具有一致的依赖关系。
15、如何在Python中实现单元测试？
在Python中实现单元测试通常使用
unittest模块，它是Python标准库的一部分，专门用于编写和运行单元测试。以下是使用unittest进行单元测试的基本步骤：1. 编写测试用例
创建一个继承自
unittest.TestCase的类，并在其中编写测试方法。测试方法必须以test开头。import unittest class TestMyModule(unittest.TestCase): def test_addition(self): result = 1 + 1 self.assertEqual(result, 2) def test_subtraction(self): result = 2 - 1 self.assertEqual(result, 1)2. 使用断言
unittest提供了多种断言方法来验证测试结果是否符合预期，例如：
assertEqual(a, b)：检查a和b是否相等。assertTrue(x)：检查x是否为True。assertFalse(x)：检查x是否为False。assertIsNone(x)：检查x是否为None。- 等等。
3. 组织测试
将相关的测试用例组织在同一个测试类中或不同的测试类中。
4. 运行测试
有几种方式可以运行
unittest测试：
直接运行测试脚本： 如果你的测试用例在一个Python脚本文件中，例如
test_my_module.py，你可以直接运行这个文件。Python会自动识别并执行所有以test开头的方法。bashpython test_my_module.py使用unittest命令： 在命令行中使用
-m unittest参数运行测试。bashpython -m unittest test_my_module如果你的测试用例分布在多个文件中，可以使用
discover方法发现并运行它们：bashpython -m unittest discover -s <test_cases_directory> -p 'test_*.py'在IDE中运行测试： 大多数集成开发环境（IDE）都有内置的
unittest测试运行器，允许你直接在IDE中运行测试。5. 测试套件（Test Suites）
你可以使用
unittest.TestSuite和unittest.defaultTestLoader来组织多个测试用例为一个测试套件，并一起运行。pythonsuite = unittest.TestLoader().loadTestsFromTestCase(TestMyModule) unittest.TextTestRunner().run(suite)6. 测试 Fixtures
使用
setUp和tearDown方法来准备测试环境和清理测试环境。注意事项：
- 测试用例应该是独立的，不应该依赖于其他测试用例的状态。
- 测试用例应该具有清晰的名称，以便于理解和维护。
- 使用断言来验证测试结果，确保测试的可读性和准确性。
通过使用
unittest框架，你可以系统地编写和执行单元测试，确保代码的质量和可靠性。
16、请解释Python中的上下文管理器。
Python中的上下文管理器是一种能够自动管理资源的协议，它允许你在一个代码块的执行期间，确保资源被正确地获取和释放。这种协议是通过定义在特殊方法
__enter__和__exit__中来实现的，这两个方法使得对象可以被用来创建上下文环境。上下文管理器的关键特点：
- 资源管理：确保在代码块执行前后对资源进行获取和释放。
- 异常安全：即使在代码块中发生异常，也能确保资源被正确地清理。
- 可重用性：上下文管理器可以被重复使用，用于管理同一类型的资源。
标准库中的上下文管理器：
Python的标准库中有许多内置的上下文管理器，例如：
- 文件操作：使用
with open('file.txt', 'r') as f:可以自动关闭文件。- 线程锁：使用
threading.Lock作为上下文管理器，可以自动获取和释放锁。- 数据库连接：许多数据库API使用上下文管理器来管理数据库连接的生命周期。
17、请解释Python中的异步编程。
Python中的异步编程是一种并发编程范式，它允许你编写单线程的并发代码。异步编程通过非阻塞I/O操作和协程（coroutines）来实现，使得程序可以在等待I/O操作完成时释放执行权，从而执行其他任务。
使用
async def定义异步函数，这些函数被称为协程。使用
asyncio.run()或loop.run_until_complete()来运行协程。import asyncio async def fetch_data(): print("开始获取数据...") await asyncio.sleep(2) # 模拟异步I/O操作 print("数据获取完成") return {'data': 1} async def main(): task = asyncio.create_task(fetch_data()) # 创建Task对象 data = await task # 等待协程完成 print(data) # 运行事件循环 asyncio.run(main())
18、Python中如何实现网络编程？
在Python中实现网络编程主要涉及使用内置的
socket模块，该模块提供了访问底层网络接口的方法。#服务器端 import socket def server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind(('localhost', 12345)) s.listen() print("服务器在等待连接...") conn, addr = s.accept() with conn: print(f"连接来自 {addr}") while True: data = conn.recv(1024) if not data: break conn.sendall(data) # 回显数据 server()#客户端 import socket def client(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect(('localhost', 12345)) message = 'Hello, World!' s.sendall(message.encode()) data = s.recv(1024) print(f"收到回显: {data.decode()}") client()
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
