¿Intercambiar columnas en una matriz numpy?

from numpy import * def swap_columns(my_array, col1, col2): temp = my_array[:,col1] my_array[:,col1] = my_array[:,col2] my_array[:,col2] = temp 

Entonces

 swap_columns(data, 0, 1) 

No funciona Sin embargo, llamando directamente al código

 temp = my_array[:,0] my_array[:,0] = my_array[:,1] my_array[:,1] = temp 

Hace. ¿Por qué sucede esto y cómo puedo solucionarlo? El error dice “IndexError: 0-d las matrices solo pueden usar un solo () o una lista de newaxes (y un solo …) como un índice”, lo que implica que los argumentos no son ints? Ya intenté convertir los cols a int pero eso no lo resolvió.

Hay dos problemas aquí. La primera es que los data que pasa a su función aparentemente no son una matriz NumPy bidimensional, al menos esto es lo que dice el mensaje de error.

El segundo problema es que el código no hace lo que esperas:

 my_array = numpy.arange(9).reshape(3, 3) # array([[0, 1, 2], # [3, 4, 5], # [6, 7, 8]]) temp = my_array[:, 0] my_array[:, 0] = my_array[:, 1] my_array[:, 1] = temp # array([[1, 1, 2], # [4, 4, 5], # [7, 7, 8]]) 

El problema es que la división básica de Numpy no crea copias de los datos reales, sino una vista de los mismos datos. Para hacer este trabajo, o bien tienes que copiar explícitamente

 temp = numpy.copy(my_array[:, 0]) my_array[:, 0] = my_array[:, 1] my_array[:, 1] = temp 

o usar rebanado avanzado

 my_array[:,[0, 1]] = my_array[:,[1, 0]] 

Encuentro lo siguiente más rápido:

 my_array[:, 0], my_array[:, 1] = my_array[:, 1], my_array[:, 0].copy() 

Análisis de tiempos de:

 import numpy as np my_array = np.arange(900).reshape(30, 30) 

es como sigue:

 %timeit my_array[:, 0], my_array[:, 1] = my_array[:, 1], my_array[:, 0].copy() The slowest run took 15.05 times longer than the fastest. This could mean that an intermediate result is being cached 1000000 loops, best of 3: 1.72 µs per loop 

Los tiempos de corte avanzados son:

 %timeit my_array[:,[0, 1]] = my_array[:,[1, 0]] The slowest run took 7.38 times longer than the fastest. This could mean that an intermediate result is being cached 100000 loops, best of 3: 6.9 µs per loop 

Construyendo sobre la respuesta de @Sven:

 import numpy as np my_array = np.arange(9).reshape(3, 3) print my_array [[0 1 2] [3 4 5] [6 7 8]] def swap_cols(arr, frm, to): arr[:,[frm, to]] = arr[:,[to, frm]] swap_cols(my_array, 0, 1) print my_array [[1 0 2] [4 3 5] [7 6 8]] def swap_rows(arr, frm, to): arr[[frm, to],:] = arr[[to, frm],:] my_array = np.arange(9).reshape(3, 3) swap_rows(my_array, 0, 2) print my_array [[6 7 8] [3 4 5] [0 1 2]] 

Supongamos que tienes una matriz numpy como esta:

 array([[ 0., -1., 0., 0.], [ 0., 1., 1., 1.], [ 0., 0., -1., 0.], [ 0., 0., 0., -1.]]) 

Esta es una forma muy elegante de intercambiar las columnas:

 col1 = 0 col2 = 1 my_array.T[[col1, col2]] = my_array.T[[col2, col1]] 

Resultado:

 array([[-1., 0., 0., 0.], [ 1., 0., 1., 1.], [ 0., 0., -1., 0.], [ 0., 0., 0., -1.]])