Copia e vista degli array NumPy

Una copia è una copia completa dei dati, se la modificiamo, non influenzerà i dati originali, i dati non sono nella stessa posizione di memoria.
Una vista è un altro nome o riferimento ai dati, attraverso del quale si può accedere e operare sui dati originali, ma i dati originali non vengono copiati. Se modifichiamo la vista, ciò influenzerà i dati originali, nella stessa posizione di memoria.

La differenza tra copie e viste

La principale differenza tra copie e viste degli array è che la copia è un nuovo array, mentre la vista è solo una vista dell'array originale.Le copie possiedono dati, qualsiasi modifica fatta alla copia non influenzerà l'array originale, e qualsiasi modifica fatta all'array originale non influenzerà la copia.Le viste non possiedono dati, qualsiasi modifica fatta alla vista influenzerà l'array originale, e qualsiasi modifica fatta all'array originale influenzerà la vista.

1. Le operazioni di taglio di numpy restituiscono una vista dei dati originali.2. La chiamata alla funzione view() dell'ndarray produce una vista.

Operazioni di taglio delle sequenze Python, chiamata deepCopy() funzione.La chiamata alla funzione copy() dell'ndarray produce una copia.

Senza copia

Le assegnazioni semplici non creano copie degli oggetti array. Al contrario, utilizzano lo stesso id() dell'array originale per accedervi. L'id() restituisce l'identificatore universale degli oggetti Python, simile ai puntatori in C. Inoltre, qualsiasi modifica a un array si riflette sull'altro. Ad esempio, una modifica alla forma di un array cambia anche la forma dell'altro array.

>>> import numpy as np
>>> a = np.arange(6)
>>> print('Il nostro array è:',a)
Il nostro array è: [0 1 2 3 4 5]
>>> print('Chiamata alla funzione id():',id(a))
Chiamata alla funzione id(): 4553321728
>>> b = a
>>> print(b)
[0 1 2 3 4 5]
>>> print('b ha lo stesso id():',id(b))
b ha lo stesso id(): 4553321728
>>> b.shape = 3,2
>>> print(b)
[[0 1]
　[2 3]
　[4 5]]
>>> print(a)
[[0 1]
　[2 3]
　[4 5]]
>>>

Vista o copia superficiale

Il metodo ndarray.view() creerà un nuovo oggetto array, le modifiche alle dimensioni del nuovo array non influenzeranno le dimensioni dei dati originali.

import　numpy　as　np　
　
　# Inizialmente a è un array 3x2
a = np.arange(6).reshape(3,2)　
print　('Array　a：')
print　(a)
print('Creazione di una vista di a:')
b = a.view()　
print　(b)
print('Gli id() di due array sono diversi:')
print('Id di a():')
print(id(a))
print('Id di b():')
print(id(b))
　# Modificare la forma di b non influenzerà a
b.shape = 2,3
print('Forma di b:')
print　(b)
print('Forma di a:')
print　(a)

Il risultato dell'output è：

Array　a：
[[0 1]
　[2 3]
　[4 5]]
Creazione di una vista di a:
[[0 1]
　[2 3]
　[4 5]]
Gli id() di due array sono diversi:
Id di a():
4314786992
Id di b():
4315171296
Forma di b:
[[0 1 2]
　[3 4 5]
Forma di a:
[[0 1]
　[2 3]
　[4 5]]

L'uso delle slice per creare viste e modificare i dati influenzerà l'array originale:

import　numpy　as　np　
arr = np.arange(12)
print('Il nostro array:')
print(arr)
print('Creazione di una slice:')
a=arr[2:]
b=arr[2:]
a[1]=123456
b[2]=23445
print(arr)
print(id(a),id(b),id(arr[3:]))

Il risultato dell'output è：

Il nostro array:
[ 0 1 2 3 4 5 6 7 8 9 10 11]
Creazione di una slice:
[ 0 1 2 123456 23445 5 6 7 8 9
　　　　　10 11]
4669930672 4444330304 4670012352
Processo completato con codice di uscita 0

Le variabili a e b sono parte di una vista dell'array, le modifiche alla vista si rifletteranno direttamente sui dati originali. Ma osservando l'id di a e b, sono diversi, il che significa che sebbene le viste puntino ai dati originali, hanno comunque delle differenze rispetto agli riferimenti di assegnazione.

Copia o copia profonda

La funzione ndarray.copy() crea una copia. Le modifiche apportate alla copia non influenzano i dati originali, essi non si trovano nella stessa posizione di memoria.

import　numpy　as　np　
　
a　=　np.array([[10,10],　[2,3],　[4,5]])　
print　('Array　a：')
print　(a)
print　('Crea una copia profonda di　a：')
b　=　a.copy()　
print　('Array　b：')
print　(b)
　#　b　e　a　non condividono alcun contenuto　
print　('Possiamo scrivere　b　per scrivere　a？')
print　(b　is　a)
print　('Modifica il contenuto di　b：')
b[0,0]　=　100　
print　('Array modificato　b：')
print　(b)
print　('a　mantieni invariato：')
print　(a)

Il risultato dell'output è：

Array　a：
[[10　10]
　[　2　3]
　[　4　5]]
Crea una copia profonda di　a：
Array　b：
[[10　10]
　[　2　3]
　[　4　5]]
Possiamo scrivere　b　per scrivere　a？
False
Modifica il contenuto di　b：
Array modificato　b：
[[100　10]
　[　2　3]
　[　4　5]]
a　mantieni invariato：
[[10　10]
　[　2　3]
　[　4　5]]