# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# python-doc bot, 2025
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-01-03 16:35+0000\n"
"PO-Revision-Date: 2025-09-22 17:54+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/copy.rst:2
msgid ":mod:`copy` --- Shallow and deep copy operations"
msgstr ":mod:`copy` --- 浅层 (shallow) 和深层 (deep) 复制操作"

#: ../../library/copy.rst:7
msgid "**Source code:** :source:`Lib/copy.py`"
msgstr "**源代码:** :source:`Lib/copy.py`"

#: ../../library/copy.rst:11
msgid ""
"Assignment statements in Python do not copy objects, they create bindings "
"between a target and an object. For collections that are mutable or contain "
"mutable items, a copy is sometimes needed so one can change one copy without"
" changing the other. This module provides generic shallow and deep copy "
"operations (explained below)."
msgstr ""
"Python "
"的赋值语句不复制对象，而是创建目标和对象的绑定关系。对于自身可变，或包含可变项的集合，有时要生成副本用于改变操作，而不必改变原始对象。本模块提供了通用的浅层复制和深层复制操作，（如下所述）。"

#: ../../library/copy.rst:18
msgid "Interface summary:"
msgstr "接口摘要："

#: ../../library/copy.rst:22
msgid "Return a shallow copy of *x*."
msgstr "返回 *x* 的浅复制。"

#: ../../library/copy.rst:27
msgid "Return a deep copy of *x*."
msgstr "返回 *x* 的深复制。"

#: ../../library/copy.rst:32
msgid "Raised for module specific errors."
msgstr "针对模块特定错误引发。"

#: ../../library/copy.rst:36
msgid ""
"The difference between shallow and deep copying is only relevant for "
"compound objects (objects that contain other objects, like lists or class "
"instances):"
msgstr "浅层与深层复制的区别仅与复合对象（即包含列表或类的实例等其他对象的对象）相关："

#: ../../library/copy.rst:39
msgid ""
"A *shallow copy* constructs a new compound object and then (to the extent "
"possible) inserts *references* into it to the objects found in the original."
msgstr "*浅层复制* 构造一个新的复合对象，然后（在尽可能的范围内）将原始对象中找到的对象的 *引用* 插入其中。"

#: ../../library/copy.rst:42
msgid ""
"A *deep copy* constructs a new compound object and then, recursively, "
"inserts *copies* into it of the objects found in the original."
msgstr "*深层复制* 构造一个新的复合对象，然后，递归地将在原始对象里找到的对象的 *副本* 插入其中。"

#: ../../library/copy.rst:45
msgid ""
"Two problems often exist with deep copy operations that don't exist with "
"shallow copy operations:"
msgstr "深度复制操作通常存在两个问题, 而浅层复制操作并不存在这些问题："

#: ../../library/copy.rst:48
msgid ""
"Recursive objects (compound objects that, directly or indirectly, contain a "
"reference to themselves) may cause a recursive loop."
msgstr "递归对象 (直接或间接包含对自身引用的复合对象) 可能会导致递归循环。"

#: ../../library/copy.rst:51
msgid ""
"Because deep copy copies everything it may copy too much, such as data which"
" is intended to be shared between copies."
msgstr "由于深层复制会复制所有内容，因此可能会过多复制（例如本应该在副本之间共享的数据）。"

#: ../../library/copy.rst:54
msgid "The :func:`deepcopy` function avoids these problems by:"
msgstr ":func:`deepcopy` 函数用以下方式避免了这些问题："

#: ../../library/copy.rst:56
msgid ""
"keeping a ``memo`` dictionary of objects already copied during the current "
"copying pass; and"
msgstr "保留在当前复制过程中已复制的对象的 \"备忘录\" （``memo``） 字典；以及"

#: ../../library/copy.rst:59
msgid ""
"letting user-defined classes override the copying operation or the set of "
"components copied."
msgstr "允许用户定义的类重写复制操作或复制的组件集合。"

#: ../../library/copy.rst:62
msgid ""
"This module does not copy types like module, method, stack trace, stack "
"frame, file, socket, window, or any similar types.  It does \"copy\" "
"functions and classes (shallow and deeply), by returning the original object"
" unchanged; this is compatible with the way these are treated by the "
":mod:`pickle` module."
msgstr ""
"此模块不会复制模块、方法、栈追踪、栈帧、文件、套接字、窗口以及任何相似的类型。 它会通过不加修改地返回原始对象来（浅层或深层地）“复制”函数和类；这与 "
":mod:`pickle` 模块处理这类问题的方式是兼容的。"

#: ../../library/copy.rst:67
msgid ""
"Shallow copies of dictionaries can be made using :meth:`dict.copy`, and of "
"lists by assigning a slice of the entire list, for example, ``copied_list = "
"original_list[:]``."
msgstr ""
"制作字典的浅层复制可以使用 :meth:`dict.copy` "
"方法，而制作列表的浅层复制可以通过赋值整个列表的切片完成，例如，``copied_list = original_list[:]``。"

#: ../../library/copy.rst:73
msgid ""
"Classes can use the same interfaces to control copying that they use to "
"control pickling.  See the description of module :mod:`pickle` for "
"information on these methods.  In fact, the :mod:`copy` module uses the "
"registered pickle functions from the :mod:`copyreg` module."
msgstr ""
"类可以使用与控制序列化（pickling）操作相同的接口来控制复制操作，关于这些方法的描述信息请参考 :mod:`pickle` "
"模块。实际上，:mod:`copy` 模块使用的正是从 :mod:`copyreg` 模块中注册的 pickle 函数。"

#: ../../library/copy.rst:82
msgid ""
"In order for a class to define its own copy implementation, it can define "
"special methods :meth:`__copy__` and :meth:`__deepcopy__`.  The former is "
"called to implement the shallow copy operation; no additional arguments are "
"passed. The latter is called to implement the deep copy operation; it is "
"passed one argument, the ``memo`` dictionary.  If the :meth:`__deepcopy__` "
"implementation needs to make a deep copy of a component, it should call the "
":func:`deepcopy` function with the component as first argument and the memo "
"dictionary as second argument."
msgstr ""
"想要给一个类定义它自己的拷贝操作实现，可以通过定义特殊方法 :meth:`__copy__` 和 :meth:`__deepcopy__`。 "
"调用前者以实现浅层拷贝操作，该方法不用传入额外参数。 调用后者以实现深层拷贝操作；它应传入一个参数即 ``memo`` 字典。 如果 "
":meth:`__deepcopy__` 实现需要创建一个组件的深层拷贝，它应当调用 :func:`deepcopy` "
"函数并以该组件作为第一个参数，而将 memo 字典作为第二个参数。"

#: ../../library/copy.rst:94
msgid "Module :mod:`pickle`"
msgstr "模块 :mod:`pickle`"

#: ../../library/copy.rst:94
msgid ""
"Discussion of the special methods used to support object state retrieval and"
" restoration."
msgstr "讨论了支持对象状态检索和恢复的特殊方法。"