Python - notas de estudio de la biblioteca Numpy

ndarray

• Nadrray es un objeto de matriz N-dimensional, un contenedor rápido y flexible para grandes conjuntos de datos
• Puede usar esta matriz (ndarray) para realizar operaciones matemáticas en todo el bloque de datos

Importar el código de la biblioteca Nump

import numpy as np

Genera algunos datos aleatorios

data = np.random.randn(2, 3)

–Numpy.random.randn ()

• La función randn devuelve una muestra o un conjunto de muestras con una distribución normal estándar
• La distribución normal estándar también se llama distribución u. Es una distribución normal con 0 como media y 1 como desviación estándar, denotada como N (0, 1)

--Dn significa cada dimensión, randn (2, 3) significa devolver una matriz con 2 filas y 3 columnas

Las matrices pueden realizar operaciones matemáticas

• Multiplica todos los elementos de la matriz por 10

data * 10

• Agregue dos matrices, cada elemento en la matriz se agrega correspondientemente

data + data

Numpy es un contenedor multidimensional universal de datos isomórficos, en el que todos los elementos deben ser del mismo tipo.
Cada matriz tiene

• forma (una tupla que representa el tamaño de cada dimensión)
• dtype (un objeto utilizado para describir el tipo de datos de una matriz)

Eche un vistazo a la forma y el tipo de la matriz de datos

data.shape

Se puede ver que los datos son una matriz con 2 filas y 3 columnas.

data.dtype

Se puede ver que el tipo de datos de la matriz de datos es 'flotador 64'

Crear ndarray

La función de matriz se puede utilizar para crear una matriz ndarray. Acepta todos los objetos en serie (incluidas otras matrices).
Tome la conversión de una lista como ejemplo:

data1 = [6, 7.5, 8, 0, 1]
arr1 = np.array(data1)
arr1

Puede ver que la lista data1 se convierte en la matriz arr1

Si la lista está compuesta por un conjunto de listas de igual longitud, la función de matriz la convertirá en una matriz multidimensional

data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)
arr2

Se puede ver que la lista que consta de dos listas se convierte en una matriz bidimensional.

Podemos usar los atributos ndim y shape para verificar

arr2.ndim

-ndim devuelve la dimensión de la matriz, solo se devuelve un número, que representa la dimensión de la matriz

arr2.shape

-Si no hay instrucciones especiales, np.array seleccionará el tipo de datos más coincidente para los datos que se crearán
-como arr1, arr2 en el ejemplo anterior, podemos ver el tipo de datos creado

, si hay decimales en la lista, el arreglo creado por arreglo El tipo de datos es de punto flotante ->
si la lista de 'flotador64' es todos enteros, entonces el tipo de datos de la matriz creada por matriz es entero -> 'int32'

El método --np.zeros () puede crear una matriz de todos los 0 con una longitud o forma específica.
Si se pasa un número 10, se creará una matriz unidimensional de 10 '0 de forma predeterminada

np.zeros(10)

El tipo de datos de la matriz creada es punto flotante

np.zeros(10).dtype

Pase una tupla que represente la forma, puede crear una matriz multidimensional,
como crear una matriz bidimensional de todos los '0's con 3 filas y 6 columnas

np.zeros((3, 6))

--Np.empty () método especifica una matriz no inicializada de longitud o forma, o puede pasar una tupla para crear una matriz multidimensional,
como crear una matriz tridimensional no inicializada (2 * 3 filas y 2 columnas)

np.empty((2, 3, 2))

Nota: la idea de que np.empty devuelva una matriz de todos 0 no es segura. En muchos casos, devuelve algunos valores basura no inicializados.

np.arange ()

--El arange en numpy es la versión de matriz de la función incorporada de Python'range '. El
parámetro N se pasa, lo que significa generar una matriz de enteros de 0 a (N-1)

Por ejemplo, cree una matriz de enteros de 0 a 14

np.arange(15)

np.arange(15).dtype

Nota: Numpy se centra en cálculos numéricos. Si no se especifica, los tipos de datos son básicamente "flotador 64" (números de coma flotante)

Las siguientes son algunas funciones de creación de matrices de uso común, que se usan con frecuencia

• Matriz: convierta los datos a ndarray (matriz multidimensional), si no se especifica dtype, coincidirá con el tipo de datos más adecuado para los datos de origen de forma predeterminada
• asarry: convierte datos a ndarray (matriz multidimensional). La diferencia entre esta y la matriz es -> Cuando los datos de origen son ndarray, la matriz
  copiará una copia de ndarray, pero asarray no
• arange: similar al rango de la función incorporada de Python, pero arange devuelve un ndarry y el rango incorporado devuelve una lista
• ones: crea una matriz de todos los '1 de acuerdo con la forma y el tipo de d especificados, el valor predeterminado es el punto flotante' flotador 64 '
• ones_like: tome otra matriz como parámetro (obtenga la forma de la matriz) y cree una matriz de todos los '1 según la forma del parámetro
• zeros, zeros_like: similar a unos y ones_like, pero crea una matriz de todos los '0's
• empty, empty_like: similar a ones y ones_like, pero solo asigna espacio de memoria, pero no llena ningún valor (se crean todos los valores de basura no inicializados)
• full: use todos los valores en el valor de relleno para crear una matriz basada en la forma y el tipo d especificados (simule un conjunto de fill_value aquí)
• full_like: crea una matriz de la misma forma con la forma de otra matriz, el valor de la matriz es fill_value
• ojo: ingrese el parámetro N, cree una matriz de identidad cuadrada N * N (la diagonal es 1, el resto es 0), el tipo de matriz es punto flotante
• identidad: Igual que np.eye ()

dtype

-Dtype contiene la información necesaria para interpretar una parte de la memoria de ndarry como un tipo de datos específico

Tipos de datos comunes de Numpy

• int8: escriba el código: i1 -> entero con signo de 8 bits (1 byte)
• uint8: Código de tipo: u1 -> entero de 8 bits (1 byte) sin signo
• int16: código de tipo: i2 -> entero de 16 bits (2 bytes) con signo
• uint16: Código de tipo: u2 -> entero de 16 bits (2 bytes) sin signo
• int32: Código de tipo: i4 -> entero de 32 bits (4 bytes) con signo
• uint32: Código de tipo: u4 -> entero de 32 bits (4 bytes) sin signo
• int64: Código de tipo: i8 -> entero de 64 bits (8 bytes) con signo
• uint64: Código de tipo: u8 -> entero de 64 bits (8 bytes) sin signo
• float16: Código de tipo: f2 -> número de coma flotante de precisión media
• float32: Código de tipo: f4 of -> número de coma flotante de precisión simple estándar (compatible con C float)
• float64: código de tipo: f8 od -> número de punto flotante de precisión doble estándar (compatible con objetos flotantes C double y Python)
• float128: Código de tipo: f16 og -> número de coma flotante de precisión extendida
• complex64: Código de tipo: c8 -> un número complejo representado por dos números de coma flotante de 32 bits
• complex128: Código de tipo: c16 -> un número complejo representado por dos números de coma flotante de 64 bits
• complex256: Código de tipo: c32 -> un número complejo representado por dos números de coma flotante de 128 bits
• bool: Código de tipo :? -> Tipo booleano que almacena Verdadero y Falso
• objeto: Código de tipo: O -> Tipo de objeto Python
• string_: Código de tipo: S -> tipo de cadena de longitud fija (1 byte por carácter), por ejemplo, para crear una cadena de longitud 10, debe usar S10
• unicode_: Código de tipo: U -> tipo Unicode de longitud fija (el número de bytes lo determina la plataforma)

- Puede convertir explícitamente una matriz de un dtype a otro dtype utilizando el método astype de ndarray.
Suponga que hay una matriz entera arr

arr = np.array([1, 2, 3, 4, 5])

Convertir arr a punto flotante

float_arr = arr.astype(np.float64)

Si convierte un número de punto flotante en un entero, la parte fraccionaria se truncará y eliminará.
Por ejemplo, hay una matriz de punto flotante arr2

arr2 = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])

Convertir a entero

int_arr2 = arr2.astype(np.int32)

Puede ver que la nueva matriz int_arr2 intercepta y elimina la parte decimal de la matriz original

También puede utilizar un tipo para convertir una matriz de cadenas en una forma numérica.
Suponga que hay una matriz de cadenas numeric_strings

numeric_strings = np.array(['1.25', '-9.6', '42'], dtype = np.string_)

• Nota: Cuando use np.string_ type, preste atención a la longitud de la cadena, porque el tamaño de los datos de la cadena de numpy es fijo y no se informará ningún error cuando se produzca la intercepción.
• Si durante el proceso de conversión, la conversión de la cadena -> valor numérico falla (como "uno" no se puede convertir al valor numérico 1, se generará un ValueError

-También podemos pasar el dtype de una matriz como parámetro al método astype.
Supongamos que hay una matriz entera int_array y una matriz de coma flotante calibres

int_array = np.arange(10)
calibers = np.array([.22, .270, .357, .380, .44, .50], dtype = np.float64)

Si desea convertir int_array en la misma matriz de punto flotante que calibres, puede pasar el tipo d de calibres al parámetro del método astype

int_float = int_array.astype(calibers.dtype)
int_float.dtype

-También puede utilizar el código de tipo del tipo de datos para representar dtype

empty_unit32 = np.empty(8, dtype = 'u4')

Operaciones de matriz Numpy

• Cualquier operación aritmética entre matrices de igual tamaño aplicará la operación al nivel del elemento

Cree un arreglo de matriz bidimensional con 2 filas y 3 columnas

arr = np.array([[1., 2., 3.], [4., 5., 6.]])
arr.shape

Multiplique entre matrices de igual tamaño, y los elementos se multiplicarán correspondientemente

arr * arr

Reste entre matrices de igual tamaño, y los elementos se restan correspondientemente

arr - arr

Las operaciones aritméticas entre matrices y escalares propagarán operaciones de valor escalar a cada elemento

1 / arr

La comparación entre matrices del mismo tamaño producirá una matriz booleana.
Creemos una matriz bidimensional arr con el mismo tamaño que arr

arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])

- Comparar arr y arr2

arr2 > arr

Puede ver que se genera una matriz booleana del mismo tamaño, y cada elemento de la matriz es una comparación de arr y arr2.

Indexación y segmentación básica

Rebanada de matriz unidimensional

• En la superficie, el corte de matriz unidimensional es similar a la función de corte de lista de Python

Cree un arreglo de matriz de enteros 0-9

arr = np.arange(10)

• Toma el sexto elemento en arr

arr[5]

• Tome los elementos 6 a 8 en arr, cierre antes de cortar y luego abra

arr[5: 8]

• Puede asignar un valor a la parte cortada y la matriz de origen se modifica en su lugar.
  Si asigno el número 6 al 8 de arr con '12'

arr[5: 8] = 12

Como puede ver, la matriz de arr se modifica in situ
, por lo que la diferencia más importante entre el segmento de matriz y el segmento de lista de Python es: el segmento de matriz es una vista de los datos originales, lo que significa que los datos no se copiarán y cualquier modificación en la vista reflejará directamente En la matriz de origen

Por ejemplo, cree una porción de arr_slice

arr_slice = arr[5: 8]

• Nota: Si modificamos el valor de arr_slice, el cambio se reflejará en el arreglo original arr

Por ejemplo, asigne el segundo número de arr_slice a '12345'

arr_slice[1] = 12345

Como puede ver, los datos de la matriz de origen también se modifican

- Slice [:] significa cortar todos los valores de la matriz. Por
ejemplo, asignamos un valor de '64' a cada tupla en arr_slice

arr_slice[:] = 64

Se puede ver que a cada elemento en arr_slice se le asigna un valor de '64'

• La razón por la que la operación anterior es diferente de la división nativa de Python es que Numpy está diseñado para manejar big data. Si los datos se copian y copian, ejercerá mucha presión sobre el rendimiento y la memoria.
• Por supuesto, si desea obtener una copia de corte del ndarray (matriz) en lugar de la vista, puede agregar un método copy () después del corte

Por ejemplo, queremos obtener una copia de segmento de los elementos 6 al 8 de arr y asignarlo con '6'

arr3 = arr[5: 8].copy()
arr3[:] = 6

Como puede ver, operar en la copia del segmento de matriz no afecta la matriz de origen

Matriz bidimensional

-En una matriz bidimensional, los elementos en cada posición de índice ya no son escalares como matrices unidimensionales, sino matrices unidimensionales

Por ejemplo, cree una matriz bidimensional arr2d

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

Toma el tercer elemento de arr2d

arr2d[2]

El resultado es una matriz unidimensional

- Si desea obtener un solo elemento escalar, puede acceder de forma recursiva a los elementos de alta dimensión. Por
ejemplo, quiero obtener el tercer escalar de la primera matriz unidimensional de una matriz bidimensional

arr2d[0, 2]

La idea de recursividad jerárquica se utiliza aquí.

Matrices multidimensionales

- El principio de las matrices multidimensionales es similar al de las matrices bidimensionales

Creamos una matriz tridimensional 2 * 2 * 3 arr3d

arr3d = np.array([[[1, 2, 3], [4, 5, 6]],
                 [[7, 8, 9], [10, 11, 12]]])

• Si corta arr3d y pasa un parámetro escalar, lo que se devuelve es una matriz bidimensional reducida en una dimensión

Por ejemplo, quiero obtener la primera matriz bidimensional de arr3d

arr3d[0]

Como puede ver, lo que se devuelve es una matriz bidimensional de 2 * 3.
A medida que aumenta el parámetro de corte, la dimensión de la matriz devuelta disminuye, hasta que se devuelve un valor escalar.

- Se pueden asignar tanto valores escalares como matrices a arr3d [0]

Antes de mostrar la asignación, primero creamos una copia de arr3d [0] old_values ​​para restaurar la matriz de origen

old_values = arr3d[0].copy()

Luego, asignamos la primera matriz bidimensional de arr3d a esta matriz tridimensional a 42

arr3d[0] = 42

Como puede ver, a cada elemento de la primera matriz bidimensional obtenida mediante el corte se le asigna un valor de 42

Usamos la copia original para restaurar la matriz de origen

arr3d[0] = old_values

• Tenga en cuenta que si no hay un tratamiento especial, el segmento devuelve una vista de la matriz de origen y la modificación del segmento afectará el valor de la matriz de origen.

Índice de corte

- La sintaxis de corte de ndarray es similar
a la de los objetos unidimensionales como las listas de Python. Mire el arreglo unidimensional anterior arr, tomamos del segundo al sexto elementos de arr

arr[1:6]

Para una matriz bidimensional de 3 * 3 arr2d, el sector selecciona elementos a lo largo de un eje, el eje 0 es la fila y el primer eje es la columna.
Seleccionamos las dos primeras filas de la matriz bidimensional

arr2d[:2]

Se puede ver aquí que arr2d [: 2] es una forma simple de escribir arr2d [0: 2], lo que significa que se seleccionan las dos primeras líneas de arr2d (frente cerrado y luego abierto)

-También es posible pasar varios segmentos a la vez. Por ejemplo, necesitamos seleccionar todos los datos después de la segunda columna en las dos primeras filas de la matriz arr2d

arr2d[ :2, 1: ]

• Al mezclar índices enteros y sectores, puede obtener sectores de dimensiones reducidas.
  Por ejemplo, quiero seleccionar las dos primeras columnas de la segunda fila.

arr2d[1,  :2]

Obtenemos una matriz unidimensional de dimensiones inferiores.

• Nota: Un solo punto indica que se ha seleccionado todo el eje.

• Por supuesto, la operación de asignación del sector también se extenderá a toda la selección, porque el sector es la vista después de que se procesa la matriz de origen, y la matriz de origen se verá afectada por el cambio de la sección.

Índice booleano

- Supongamos que tenemos una matriz de datos para almacenar datos y una matriz de nombres para almacenar nombres (que contienen duplicados)

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])

Usamos la función randn en numpy.random para generar una distribución normal estándar con 7 filas y 4 columnas de datos de matriz aleatoria

data = np.random.randn(7, 4)

• Supongamos que cada nombre en la matriz de nombres corresponde a cada fila en el valor de datos.
  Queremos seleccionar todas las filas correspondientes al nombre de 'Bob'

- Echemos un vistazo a qué nombres en los nombres son 'Bob'

names == 'Bob'

• Aquí, debe usar el signo '==' en lugar del signo '=', de lo contrario, asignará 'Bob' a cada elemento en los nombres
• Se puede ver que se genera una matriz booleana unidimensional, y el elemento con el elemento 'Bob' devuelve Verdadero, de lo contrario es Falso

-A continuación, pasamos la matriz booleana devuelta como un índice a los datos

data[names == 'Bob']

No es difícil encontrar que las filas correspondientes a 'Bob' en los datos han sido seleccionadas

• Nota: La longitud de la matriz booleana debe ser la misma que la longitud del eje indexado. Si la longitud es inconsistente, se producirá un error.

-Por supuesto, también puede indexar más ejes, como agregar un índice de columna, quiero obtener los datos después de la segunda columna de la fila correspondiente a 'Bob' en los datos

data[names == 'Bob', 2: ]

- Si desea seleccionar un valor que no sea 'Bob', puede usar el signo de desigualdad '! =' O '~' para negar

data[names != 'Bob']

Como resultado, se seleccionan las filas restantes excepto la fila correspondiente a Bob

- A menudo usamos el operador '~' para realizar alguna inversión condicional. Por
ejemplo, primero pasamos la matriz booleana de 'Bob' a un objeto cond

cond = names == 'Bob'

Luego use el operador ~ para invertir el objeto en el índice de datos

data[~cond]

Como resultado, las filas restantes excepto la fila correspondiente a Bob también se seleccionan

-Si queremos agregar condiciones de juicio, podemos usar & (y), | (o) y otros operadores aritméticos booleanos (no puede usar las palabras clave y
yo en Python). Por ejemplo, quiero seleccionar 'Bob al mismo tiempo Las filas correspondientes a los dos nombres de 'y' Will 'en los datos

mask = (names == 'Bob') | (names == 'Will')

data[mask]

Como resultado, se seleccionan las filas correspondientes a Bob y Will.

• Nota: la selección de datos en la matriz por índice booleano siempre creará una vista de los datos

- A menudo establecemos valores a través de matrices booleanas. Por
ejemplo, establecemos todos los valores negativos en los datos en 0

data[data < 0] = 0

-También puede establecer el valor de una fila o columna completa a través de una matriz booleana unidimensional

data[names != 'Joe'] = 7

Como puede ver, a los datos correspondientes a los elementos de la fila cuyo nombre es 'Joe' se les asigna el valor 7

Índice de fantasía

• La indexación elegante se refiere a: indexación con matrices de enteros

- Suponga que hay un arreglo de matriz de 8 * 4

arr = np.empty((8, 4))

Esta matriz es solo para crear espacio y contiene valores de basura no inicializados

-Ahora llenamos esta matriz con un bucle for

for i in range(8):
    arr[i] = i

Podemos pasar una lista de enteros en un orden específico o seleccionar un subconjunto de la matriz

arr[[4, 3, 0, 6]]

Transposición de matrices y conversión de ejes

• La transposición es similar a la remodelación de matrices
• Transpose no realiza ninguna operación de copia y devuelve una vista de los datos de origen
• La matriz tiene un atributo especial T para transponer

Cree una matriz bidimensional con 3 filas y 5 columnas

arr = np.arange(15).reshape((3, 5))

Transponer con atributo T

arr.T

• Al realizar cálculos matriciales (como calcular el producto interno de una matriz), a menudo se necesita la transposición
• Para calcular el producto interno de la matriz, podemos usar la función de punto en numpy
• De hecho, dot () devuelve el producto escalar de dos matrices

- Creamos una matriz bidimensional e intentamos calcular el producto interno de la misma y su matriz transpuesta

arr = np.random.randn(6, 3)

Calcular producto interno

np.dot(arr, arr.T)

-En cuanto a la transposición de una matriz de tres dígitos, aquí se debe introducir un concepto: la transposición requiere una tupla que consta de números de eje.
Por ejemplo, cree una matriz tridimensional de 2 * 2 * 4

arr = np.arange(16).reshape((2, 2, 4))

• Numere los tres ejes de la matriz tridimensional: 0, 1, 2 Imagino la longitud (0), el ancho (1) y la altura (2) de un cuboide
• Cuando se transpone, es equivalente a la rotación horizontal del cuboide en 90 grados, y los valores de largo y ancho se entienden subjetivamente como intercambio: el largo original se convierte en ancho y el ancho se convierte en largo, por lo que el largo, ancho y alto del cuboide transpuesto corresponden a Los números de eje del cuboide original son 1 (ancho), 0 (largo), 2 (alto)

arr.transpose((1, 0, 2))

- Hablemos de la función de transposición en numpy. Los parámetros en transposición pueden entenderse como las etiquetas de eje de la matriz

• Para matrices unidimensionales, numpy.transpose () no funciona porque solo hay un eje
• La operación de transposición en la matriz bidimensional es la operación de transposición en la matriz original, y la etiqueta del eje se convierte de (0, 1) a (1, 0)
• Para una matriz tridimensional, la transposición transformará dos de los tres ejes (vea cómo define esta transposición)

-También hay un método swapaxes en ndarray, que puede intercambiar ejes.
Por ejemplo, quiero intercambiar el segundo y tercer eje de una matriz tridimensional

arr.swapaxes(1, 2)

• El método swapaxes es en realidad una forma diferente de transponer, lo cual es muy conveniente
• También debe tenerse en cuenta que el método swapaxes no realiza una operación de copia y devuelve una vista de los datos de origen.