Compréhension approfondie du module de copie en python (copie superficielle et copie profonde)

Présente principalement le module de copie en python.

Le module de copie comprend des fonctions permettant de créer des copies profondes et superficielles d'objets composés, notamment des listes, des tuples, des dictionnaires et des instances d'objets définis par l'utilisateur.

########

copy(x)

########

Créez un nouvel objet composite et Crée une copie superficielle de x en copiant ses membres par référence. Pour le dire plus profondément,

copie l'objet, mais utilise toujours des références pour les éléments de l'objet.

Pour les types intégrés, cette fonction n'est pas souvent utilisée.

Utilisez plutôt des méthodes d'appel telles que list(x), dict(x), set(x), etc. pour créer une copie superficielle de x. Vous devez savoir que

en utilisant directement. le nom du type est évidemment meilleur que l'utilisation de copy() est beaucoup plus rapide. Mais ils obtiennent le même effet.

Un autre point concerne les objets qui ne peuvent pas être modifiés (chaîne, nombre, tuple), car vous n'avez pas à vous soucier de les modifier. Copier ou non n'a aucun

sens.

Autre point, vous pouvez utiliser l'opérateur is pour déterminer si les objets sont copiés.

a est b -> Vrai a et b font référence au même objet, pas à des copies

- -> Faux a et b sont des copies l'un de l'autre

Par exemple , comme suit Exemple, par exemple :

(1)

>>> a = [1,2,3]

>>> = copier .copy(a)

>>> b

[1, 2, 3]

>>> )

>>>a

[1, 2, 3, 4]

>>> , 2 , 3]

>>> a est b

Faux

(2)

>>> [1 ,2,3]

>>> b = a

>>> >

>>> a.append(4)

>>> a

[1, 2, 3, 4]

>>> b

[1, 2, 3, 4]

>>> > a, b

([1, 2, 3, 4, 6], [1, 2, 3, 4, 6])

(3)

> ;>> a = [1,2,3]

>>> b = liste(a)

>>> [1, 2, 3]

>>> a.append(4)

>>> 2, 3, 4]

>>>b

[1, 2, 3]

>>> (4 )

>>> a = [[1], ['a'], ['A']]

>>> copier( a)

>>> imprimer a, b

[[1], ['a'], ['A']] [[1], [' a' ], ['A']]

>>> b[1].append('b')

>>> 🎜> [[1], ['a', 'b'], ['A']]

>>> a

[[1], ['a ', 'b'], ['A']]

>>> b.append([100,101])

>>> 🎜> [[1], ['a', 'b'], ['A'], [100, 101]]

>>> 1] , ['a', 'b'], ['A']]

Dans l'exemple (3), nous pouvons voir l'objet de copie superficielle b de a. Ce sont des objets différents, donc pour. l'objet Les changements de

ne s'affecteront pas, mais les éléments de ces objets a et b font référence au même, donc si a ou b change les éléments de son objet, cela affectera

La valeur d'un autre.

Si vous souhaitez copier complètement un objet et les valeurs de tous les éléments d'un objet, utilisez uniquement la fonction deepcopy() ci-dessous.

######################

deepcopy(x[, visite])

# # #####################

Crée une copie complète de x en créant un nouvel objet composite et en copiant à plusieurs reprises tous les membres de x.

visit est un dictionnaire facultatif dont le but est de garder une trace des objets visités, détectant et évitant ainsi les cycles répétés dans les structures de données définissant

.

Bien que cela ne soit généralement pas nécessaire, la classe

peut implémenter des méthodes de copie personnalisées en implémentant les méthodes __copy__(self) et __deepcopy__(self, visit). opérations de copie profonde respectivement.

La méthode __deepcopy__() doit utiliser la visite du dictionnaire, qui est utilisée pour suivre les objets précédemment rencontrés pendant le processus de copie. Pour la méthode

__deepcopy__(),

n'a pas besoin d'effectuer d'opérations supplémentaires autres que de transmettre la visite aux autres méthodes deepcopy() incluses dans l'implémentation (le cas échéant).

Si la classe implémente les méthodes __getstate__() et __setstate__() utilisées par le module pickle, alors le module de copie utilisera

ces méthodes pour créer une copie.

, mais en implémentant les méthodes __copy__(self) et __deepcopy__(self, visit), la classe

peut implémenter des méthodes de copie personnalisées. Ces deux méthodes implémentent respectivement des opérations de copie superficielle et de copie profonde. .

La méthode __deepcopy__() doit utiliser la visite du dictionnaire, qui est utilisée pour suivre les objets précédemment rencontrés pendant le processus de copie. Pour la méthode

__deepcopy__(),

n'a pas besoin d'effectuer d'autres opérations en plus de passer la visite aux autres méthodes deepcopy() incluses dans l'implémentation (le cas échéant).

Si la classe implémente les méthodes __getstate__() et __setstate__() utilisées par le module pickle, alors le module de copie utilisera

ces méthodes pour créer une copie. , mais en implémentant les méthodes __copy__(self) et __deepcopy__(self, visit), la classe

peut implémenter une méthode de copie personnalisée. Ces deux méthodes implémentent respectivement des opérations de copie superficielle et de copie profonde.

La méthode __deepcopy__() doit utiliser la visite du dictionnaire, qui est utilisée pour suivre les objets précédemment rencontrés pendant le processus de copie. Pour la méthode

__deepcopy__(),

n'a pas besoin d'effectuer d'autres opérations en plus de passer la visite aux autres méthodes deepcopy() incluses dans l'implémentation (le cas échéant).

Si la classe implémente les méthodes __getstate__() et __setstate__() utilisées par le module pickle, alors le module de copie utilisera

ces méthodes pour créer des copies.

par exemple :

>>> a = [[1], ['a'], ['A']]

>>> ; importer une copie

>>> b = copy.deepcopy(a)

>>> '], ['A']]

>>> c = copy.copy(a)

>>> 1], ['a'], ['A']]

>>> a[1].append('b')

>>> une

[[1], ['a', 'b'], ['A']]

>>> ], ['a'], ['A']]

>>> c

[[1], ['a', 'b'], [' A']]

Il convient de noter que :

(1) Le module de copie est utilisé pour les types simples comme les entiers et les chaînes, mais cela est rarement nécessaire.

(2) Ces fonctions de copie ne peuvent pas fonctionner avec des modules, des objets de classe, des fonctions, des méthodes, des traces, des cadres de pile, des fichiers, des sockets et d'autres types similaires.

Si l'objet ne peut pas être copié, une exception copy.error sera levée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!