Qu'est-ce que copy.copy ()

https://docs.python.jp/3/library/copy.html

Renvoie une copie superficielle de x.

Il n'y a pas de «comment». En d'autres termes, les spécifications ne sont pas vraiment écrites.

Des méthodes spéciales «copy ()» et «deepcopy ()» peuvent être définies pour définir une implémentation de copie spécifique à la classe.

Alors, y a-t-il cette méthode dans la liste?

>>> lst = [1, 2, 3]
>>> lst.__copy__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute '__copy__'

Il n'y en a pas.

Ci-dessous, l'implémentation de copy.copy () en Python 3.6.1.

def copy(x):
    """Shallow copy operation on arbitrary Python objects.

    See the module's __doc__ string for more info.
    """

    cls = type(x)

    copier = _copy_dispatch.get(cls)
    if copier:
        return copier(x)

    try:
        issc = issubclass(cls, type)
    except TypeError: # cls is not a class
        issc = False
    if issc:
        # treat it as a regular class:
        return _copy_immutable(x)

    copier = getattr(cls, "__copy__", None)
    if copier:
        return copier(x)

    reductor = dispatch_table.get(cls)
    if reductor:
        rv = reductor(x)
    else:
        reductor = getattr(x, "__reduce_ex__", None)
        if reductor:
            rv = reductor(4)
        else:
            reductor = getattr(x, "__reduce__", None)
            if reductor:
                rv = reductor()
            else:
                raise Error("un(shallow)copyable object of type %s" % cls)

    if isinstance(rv, str):
        return x
    return _reconstruct(x, None, *rv)


_copy_dispatch = d = {}

def _copy_immutable(x):
    return x
for t in (type(None), int, float, bool, complex, str, tuple,
          bytes, frozenset, type, range, slice,
          types.BuiltinFunctionType, type(Ellipsis), type(NotImplemented),
          types.FunctionType, weakref.ref):
    d[t] = _copy_immutable
t = getattr(types, "CodeType", None)
if t is not None:
    d[t] = _copy_immutable

d[list] = list.copy
d[dict] = dict.copy
d[set] = set.copy
d[bytearray] = bytearray.copy

...

copy.copy () contient une fonction dans le dictionnaire qui réalise une copie superficielle (et une copie profonde) dans chaque type de données intégré, et si elle n'est pas enregistrée dans le dictionnaire, la méthode__copy__ () Chercher.

Après cela, il semble se comporter selon les conventions liées au module pickle, mais il est omis car il dépasse les hypothèses de cet article. Correspond à la partie suivante du document:

Les classes peuvent utiliser la même interface que celle utilisée pour contrôler le pickle pour contrôler la copie. Voir la description du module pickle pour plus d'informations sur ces méthodes. En fait, le module de copie utilise la fonction picle enregistrée par le module copyreg.

En dehors de cela, le code source considère copy.copy (lst) comme équivalent à lst.copy ().

Au fait, il n'y a pas de list.copy () dans la série Python 2, et lst [:] est utilisé à la place. Vous pouvez voir lst [:] relativement souvent dans les documents plus anciens qui ont été migrés de 2 à 3.