1. Introducción

NumPy tiene un objeto de matriz multidimensional llamado ndarray. Está formado por dos partes:

  • Los datos que manejamos
  • Algunos metadatos que describen los datos

La mayoría de las operaciones de matriz dejan intactos los datos sin procesar. El único aspecto que cambia son los metadatos.

La matriz NumPy es en general homogénea (hay un tipo de matriz especial que es heterogénea): los elementos de la matriz deben ser del mismo tipo. La ventaja es que, si sabemos que los elementos de la matriz son del mismo tipo, es fácil determinar el tamaño de almacenamiento requerido para la matriz (???).

Las matrices NumPy se indexan como en Python, comenzando desde 0. Los tipos de datos se representan por objetos especiales.

2. Trabajando con arrays

Imagina que queremos sumar dos vectores llamados a y b. Aquí se utiliza un vector en el sentido matemático, lo que significa una matriz unidimensional.

El vector a contiene los cuadrados de los números enteros de 0 a n, por ejemplo. Si n es igual a 3, entonces a contiene 0 , 1 y 4 . El vector b contiene los cubos de los números enteros 0 a n , por lo que si n es igual a 3 , entonces el vector b es igual a 0, 1 y 8 . como lo harias eso usando Python simple? Después de encontrar una solución, la compararemos con el equivalente NumPy.

Usando Python puro:

src/01.py

#!/usr/bin/env python3

def pythonsum(n):
    a = [*range(n)]    
    b = [*range(n)]
    c = []
    for i in range(len(a)):
        a[i] = i ** 2
        b[i] = i ** 3
        c.append(a[i] + b[i])        
    return c

print(pythonsum(3)) # [0, 2, 12]

El operador “*” del código sirve como operador desempaquetar argumentos, puedes estudiarlo en estos enlaces:

La siguiente es una función que logra lo mismo con NumPy:

src/02.py

#!/usr/bin/env python3

import numpy

def numpysum(n):
    a = numpy.arange(n) ** 2
    b = numpy.arange(n) ** 3
    c = a + b
    return c

print(numpysum(3)) # [ 0  2 12]

Tenga en cuenta que numpysum() no necesita un bucle for. Además, usamos la función arange de NumPy, que crea una matriz NumPy para nosotros con números enteros de 0 a n. la arange se importó; es por eso que tiene el prefijo numpy.

In [1]: import numpy as np

In [2]: a=np.arange(3)

In [3]: a.dtype
Out[3]: dtype('int64')

In [4]: print(a)
[0 1 2]

El atributo shape de la matriz es una tupla (de tipo immutable para prevenir cambios por accidente), en este caso una tupla de 1 elemento, que contiene la longitud en cada dimensión.

In [7]: a
Out[7]: array([0, 1, 2])

In [8]: a.shape
Out[8]: (3,)

Enlaces:

Imprimir la forma de un array 2D:

import numpy as np

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

print(arr.shape)

El ejemplo anterior devuelve una tupla con (2, 4), lo que significa que la matriz tiene 2 dimensiones, donde la primera dimensión tiene 2 elementos y la segunda tiene 4.

Ejemplo:

Cree una matriz con 5 dimensiones usando ndmin usando un vector con valores 1,2,3,4 y verifique que la última dimensión tenga valor 4:

import numpy as np

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

print(arr)
print('shape of array :', arr.shape)

¿Qué representa la tupla de forma?

Los números enteros en cada índice informan sobre la cantidad de elementos que tiene la dimensión correspondiente.

3. Creando vectores

Use NumPy para crear una matriz unidimensional:

src/03.py

#!/usr/bin/env python3

# Cargar librería
import numpy as np

# Crear un vector como fila
vector_row = np.array([1, 2, 3])
print(vector_row) # [1 2 3]
print(vector_row.shape) # (3,)

# Crear un vector como columna
vector_column = np.array([[1],
                          [2],
                          [3]])
print(vector_column) 
# [[1]
# [2]
# [3]]
print(vector_column.shape) # (3, 1)

La estructura de datos principal de NumPy es la matriz multidimensional. Para crear un vector, simplemente cree una matriz unidimensional. Al igual que los vectores, estas matrices se pueden representar horizontalmente (es decir, filas) o verticalmente (es decir, columnas).

3.1. Crear un arreglo inicializado a 0 o 1

src/26.py

zeros = np.zeros(6)
print(zeros) # [0. 0. 0. 0. 0. 0.]

ones_array = np.ones(6, dtype = int)
print(ones_array) # [1 1 1 1 1 1]

4. Creando una matriz (array multidimensional)

src/04.py

#!/usr/bin/env python3

# Cargar librería
import numpy as np

# Crear una matriz
matrix = np.array([[1, 2],
                   [1, 2],
                   [1, 2]])

Para crear una matriz, podemos usar una matriz bidimensional NumPy. En nuestra solución, el matriz contiene tres filas y dos columnas (una columna de 1 y una columna de 2).

Usando arange

Con la terminal de IPython:

In [1]: import numpy as np

In [2]: m = np.array([np.arange(2),np.arange(2)])

In [3]: m
Out[3]: 
array([[0, 1],
       [0, 1]])

In [4]: m.shape
Out[4]: (2, 2)

src/05.py

#!/usr/bin/env python3

# Cargar librería
import numpy as np

m = np.array([np.arange(2), np.arange(2)])
print(m)
# [[0 1]
#  [0 1]]
print(m.shape) # (2, 2)

La función de array crea una matriz a partir de un objeto que le das. El objeto necesita ser como una matriz, por ejemplo, una lista de Python. En el ejemplo anterior, pasamos una lista de arrays. El objeto es el único argumento requerido de la función de array.

Obtener ayuda en el propio interprete:

In [6]: help(np.array)


In [7]: np.array?

5. Comparación entre la matriz Numpy y la lista de Python

Ver Python Lists VS Numpy Arrays.

5.1. Efecto de las operaciones en la matriz Numpy y las listas de Python

En este ejemplo se demuestra la incapacidad de la lista de Python para realizar una operación básica. Se declarará una lista de Python y una matriz Numpy con los mismos elementos y se agregará un número entero para incrementar cada elemento del contenedor por ese valor entero sin declaraciones en bucle. Se analizará el efecto de esta operación en la matriz Numpy y la lista de Python.

src/17.py

# declaring a list
ls =[1, 2, 3]

# converting the list into a Numpy array
arr = np.array(ls)

try:
	# adding 4 to each element of list
	ls = ls + 4
	
except(TypeError):
	print("Lists don't support list + int")

# now on array
try:
	# adding 4 to each element of Numpy array
	arr = arr + 4

	# printing the Numpy array
	print("Modified Numpy array: ",arr)
	
except(TypeError):
	print("Numpy arrays don't support list + int")

6. Seleccionando elementos

De vez en cuando, querremos seleccionar un elemento particular de una matriz. echaremos un vistazo en cómo hacer esto, pero, primero, cree una matriz de dos por dos nuevamente:

In [9]: a = np.array([[1,2],[3,4]])

In [10]: a
Out[10]: 
array([[1, 2],
       [3, 4]])

La matriz se creó esta vez pasando a la función de matriz una lista de listas. ahora lo haremos seleccione cada elemento de la matriz uno por uno. Recuerde, los índices están numerados comenzando desde 0.

In [11]: a[0,0]
Out[11]: 1

In [12]: a[0,1]
Out[12]: 2

In [13]: a[1,0]
Out[13]: 3

In [14]: a[1,1]
Out[14]: 4

Como puede ver, seleccionar elementos de la matriz es bastante simple. Para la matriz a , solo usamos la notación a[m,n] , donde m y n son los índices del elemento en la matriz como se muestra en la siguiente diagrama:

Ejemplo src/06.py:

#!/usr/bin/env python3

# Cargar librería
import numpy as np

# Crear un vector como fila
vector = np.array([1, 2, 3, 4, 5, 6])
# Crear una matriz
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
# Seleccionar 3º elemento del vector
print(vector[2]) # 3
# Segunda fila, segunda columna
print(matrix[1,1]) # 5

NumPy ofrece una amplia variedad de métodos para seleccionar (por ejemplo por indexación o slicing) elementos o grupos de elementos en matrices:

Ejemplo src/07.py:

# Seleccionar todos los elementos del vector
print(vector[:]) # array([1, 2, 3, 4, 5, 6])
# Seleccionar hasta el 3º elemento incluido
print(vector[:3])  # array([1, 2, 3])
# Todo despues del 3º elemento
print(vector[3:]) # array([4, 5, 6])
# Último elemento
print(vector[-1]) # 6
# Primeras dos filas y todas las columnas 
print(matrix[:2,:]) #array([[1, 2, 3], [4, 5, 6]])

Otro ejemplo:

# Initial Array
arr = np.array([[-1, 2, 0, 4],
                [4, -0.5, 6, 0],
                [2.6, 0, 7, 8],
                [3, -7, 4, 2.0]])
print("Initial Array: ")
print(arr)
 
# Printing a range of Array
# with the use of slicing method
sliced_arr = arr[:2, ::2]
print ("Array with first 2 rows and"
    " alternate columns(0 and 2):\n", sliced_arr)
 
# Printing elements at
# specific Indices
Index_arr = arr[[1, 1, 0, 3], 
                [3, 2, 1, 0]]
print ("\nElements at indices (1, 3), "
    "(1, 2), (0, 1), (3, 0):\n", Index_arr)

Salida:

[[-1.   2.   0.   4. ]
 [ 4.  -0.5  6.   0. ]
 [ 2.6  0.   7.   8. ]
 [ 3.  -7.   4.   2. ]]
Array with first 2 rows and alternate columns(0 and 2):
 [[-1.  0.]
 [ 4.  6.]]

Elements at indices (1, 3), (1, 2), (0, 1), (3, 0):
 [0. 6. 2. 3.]

Ver:

7. Operaciones avanzadas con matrices

7.1. Apilar

Varias matrices se pueden apilar juntas a lo largo de diferentes ejes.

  • np.vstack: Para apilar arreglos a lo largo del eje vertical.
  • np.hstack: Para apilar arreglos a lo largo del eje horizontal.
  • np.column_stack: Para apilar arreglos 1-D como columnas en arreglos 2-D.
  • np.concatenate: Para apilar matrices a lo largo del eje especificado (el eje se pasa como argumento).

src/23.py

#!/usr/bin/env python3

import numpy as np

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

b = np.array([[5, 6],
			[7, 8]])

# vertical stacking
print("Vertical stacking:\n", np.vstack((a, b)))

# horizontal stacking
print("\nHorizontal stacking:\n", np.hstack((a, b)))

c = [5, 6]

# stacking columns
print("\nColumn stacking:\n", np.column_stack((a, c)))

# concatenation method
print("\nConcatenating to 2nd axis:\n", np.concatenate((a, b), 1))

Salida:

Vertical stacking:
 [[1 2]
 [3 4]
 [5 6]
 [7 8]]

Horizontal stacking:
 [[1 2 5 6]
 [3 4 7 8]]

Column stacking:
 [[1 2 5]
 [3 4 6]]

Concatenating to 2nd axis:
 [[1 2 5 6]
 [3 4 7 8]]

7.2. Splitting

  • np.hsplit: Dividir matriz a lo largo del eje horizontal.
  • np.vsplit: Dividir matriz a lo largo del eje vertical.
  • np.array_split: Dividir matriz a lo largo del eje especificado.

src/24.py

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

# horizontal splitting
print("Splitting along horizontal axis into 2 parts:\n", np.hsplit(a, 2))

# vertical splitting
print("\nSplitting along vertical axis into 2 parts:\n", np.vsplit(a, 2))

Salida:

Splitting along horizontal axis into 2 parts:
 [array([[1, 3, 5],
       [2, 4, 6]]), array([[ 7,  9, 11],
       [ 8, 10, 12]])]

Splitting along vertical axis into 2 parts:
 [array([[ 1,  3,  5,  7,  9, 11]]), array([[ 2,  4,  6,  8, 10, 12]])]

7.3. Broadcasting

El término transmisión (broadcasting) describe cómo NumPy trata las matrices con diferentes formas durante las operaciones aritméticas.

@@@TODO

Ver:

8. Inspeccionando una matriz

Desea describir la forma, el tamaño y las dimensiones de la matriz.

src/08.py

# Crear la matriz
matrix = np.array([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])
# Ver número de filas y columnas
print(matrix.shape) # (3, 4)
# Ver número de elementos (rows * columns)
print(matrix.size) # 12
# Ver número de dimensiones
print(matrix.ndim) # 2

Esto puede parecer básico (y lo es); sin embargo, una y otra vez será valioso comprobar la forma y el tamaño de una matriz tanto para cálculos posteriores como simplemente como una verificación intuitiva después de alguna operación.

9. Aplicar operaciones a elementos

Desea aplicar alguna función a varios elementos en una matriz.

src/09.py

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

# Función lambda que suma 100 a algo
add_100 = lambda i: i + 100

# Creamos una función vectorizada
vectorized_add_100 = np.vectorize(add_100)
# Aplicamos la función a la matriz
print(vectorized_add_100(matrix)) 
# array([[101, 102, 103],
#       [104, 105, 106],
#       [107, 108, 109]])

La clase vectorize de NumPy convierte una función en una función que se puede aplicar a todos los elementos. mentos en una matriz o segmento de una matriz. Vale la pena señalar que. Por ejemplo, podemos crear una mucho más simple versión de nuestra solución usando transmisión (broadcasting):

In [2]: import numpy as np

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

In [4]: matrix + 100
Out[4]: 
array([[101, 102, 103],
       [104, 105, 106],
       [107, 108, 109]])

10. Encontrar los valores máximo y mínimo

Necesita encontrar el valor máximo o mínimo en una matriz.

src/10.py

matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print(np.max(matrix)) # 9
print(np.min(matrix))  # 1

A menudo queremos saber el valor máximo y mínimo en una matriz o subconjunto. Esto se puede lograr con los métodos max y min. Usando el parámetro axis también podemos aplicar la operación a lo largo de un cierto eje:

Máximo en cada columna:

In [5]: np.max(matrix, axis=0)
Out[5]: array([7, 8, 9])

Máximo en cada fila:

In [6]: np.max(matrix, axis=1)
Out[6]: array([3, 6, 9])

11. Cálculo del promedio, la varianza y la desviación estándar

Promedio:

La media aritmética es un concepto matemático usado en estadística. También llamada promedio o simplemente media, se obtiene con la suma de un conjunto de valores dividida entre el número total de sumandos.

Varianza:

La varianza es una medida de dispersión que representa la variabilidad de una serie de datos respecto a su media. Formalmente se calcula como la suma de los residuos al cuadrado divididos entre el total de observaciones.

Desviación estándar:

En estadística, la desviación típica (también conocida como desviación estándar y desvío típico,es una medida que se utiliza para cuantificar la variación o la dispersión de un conjunto de datos numéricos.

Una desviación estándar baja indica que la mayor parte de los datos de una muestra tienden a estar agrupados cerca de su media (también denominada el valor esperado), mientras que una desviación estándar alta indica que los datos se extienden sobre un rango de valores más amplio.

src/11.py

matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
# media
print(np.mean(matrix)) # 5.0

# varianza
print(np.var(matrix)) # 6.666666666666667

# Desviación estándar
print(np.std(matrix)) # 2.581988897471611

Al igual que con max y min, podemos obtener fácilmente estadísticas descriptivas sobre todo matriz o hacer cálculos a lo largo de un solo eje:

np.mean(matrix, axis=0)

12. Transformación de matrices (reshape)

Quiere cambiar la forma (número de filas y columnas) de una matriz sin cambiar los valores de los elementos:

src/12.py

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

# Reshape matrix into 2x6 matrix
new_matrix=matrix.reshape(2, 6)
print(new_matrix)
# [[ 1  2  3  4  5  6]
# [ 7  8  9 10 11 12]]

remodelar (reshape) nos permite reestructurar una matriz para que mantengamos los mismos datos pero organizados como un número diferente de filas y columnas. El único requisito es que la forma de la matriz original y la nueva contienen el mismo número de elementos (es decir, el mismo tamaño). Podemos ver el tamaño de una matriz usando size:

In [8]: matrix.size
Out[8]: 12

Un argumento útil en reshape es -1 , que efectivamente significa “tantas como sea necesario”. entonces remodelar (-1, 1) significa una fila y tantas columnas como sea necesario:

In [9]: matrix.reshape(1, -1)
Out[9]: array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]])

Ver:

13. Redimensionar de forma permanente

Los métodos numpy.reshape() y numpy.resize() se utilizan para cambiar el tamaño de una matriz NumPy. La diferencia entre ellos es que numpy.reshape() no cambia la matriz original sino que solo devuelve la matriz modificada, mientras que el método numpy.resize() no devuelve nada y cambia directamente la matriz original.

Ver:

src/25.py

# creating an array
gfg = np.array([1, 2, 3, 4, 5, 6])
print("Original array:")
display(gfg)

# using resize()
print("Changed array")
# this will print nothing as None is returned
display(gfg.resize(2, 3))
	
print("Original array:")
display(gfg)

14. Transponer un vector o matriz

Necesita transponer un vector o matriz.

src/13.py

matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
# Transpose matrix
print(matrix.T)
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]

La transposición es una operación común en álgebra lineal donde la columna y la fila se intercambian los índices de cada elemento. Un punto matizado que normalmente se pasa por alto fuera de una clase de álgebra lineal es que, técnicamente, un vector no se puede transponer porque es solo una colección de valores:

In [10]: np.array([1, 2, 3, 4, 5, 6]).T
Out[10]: array([1, 2, 3, 4, 5, 6])

Sin embargo, es común referirse a la transposición de un vector como convertir un vector de fila a un vector de columna (observe el segundo par de corchetes) o viceversa:

In [11]: np.array([[1, 2, 3, 4, 5, 6]]).T
Out[11]: 
array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

15. Aplanando una matriz

Necesitas transformar una matriz en una matriz unidimensional

src/14.py

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

# Flatten matrix
print(matrix.flatten()) # [1 2 3 4 5 6 7 8 9]

flatten es un método simple para transformar una matriz en una matriz unidimensional. Alternativamente, podemos usar reshape para crear un vector de fila:

In [14]: matrix.reshape(1, -1)
Out[14]: array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])

16. Hallar el rango de una matriz

Necesita saber el rango de una matriz.

src/15.py

matrix = np.array([[1, 1, 1], 
                   [1, 1, 10],
                   [1, 1, 15]])

# Return matrix rank
print(np.linalg.matrix_rank(matrix)) # 2

17. Cálculo del determinante

El determinante de una matriz siempre es un número real y únicamente lo podremos calcular para matrices cuadradas. El determinante de una matriz cuadrada —matriz con el mismo número de filas que de columnas— se obtiene de restar la multiplicación de los elementos de la diagonal principal de la matriz y la multiplicación de los elementos de la diagonal secundaria de la misma matriz.

src/16.py

matrix = np.array([[1, 2, 3],
                   [2, 4, 6],
                   [3, 8, 9]])
# Return determinant of matrix
print(np.linalg.det(matrix)) # 0.0

18. Obtener la diagonal de una matriz

src/18.py

matrix = np.array([[1, 2, 3],
                   [2, 4, 6],
                   [3, 8, 9]])
# Retorna los elementos de la diagonal
diag=matrix.diagonal()
print(diag) # [1 4 9]

Tambien es posible obtener una diagonal de la diagonal principal usando el parámetro de offset:

# Return diagonal one above the main diagonal
print(matrix.diagonal(offset=1)) # [2 6]
# Return diagonal one below the main diagonal
print(matrix.diagonal(offset=-1)) # [2 8]

Referencias:

19. Calcular la traza de una matriz

En álgebra lineal, la traza de una matriz cuadrada A de nxn está definida como la suma de los elementos de la diagonal principal.

src/19.py

matrix = np.array([[1, 2, 3],
                   [2, 4, 6],
                   [3, 8, 9]])
print(matrix.trace()) # 14

También podemos devolver la diagonal de una matriz y calcular su suma:

In [5]: matrix = np.array([[1, 2, 3],
   ...:                    [2, 4, 6],
   ...:                    [3, 8, 9]])

In [6]: sum(matrix.diagonal())
Out[6]: 14

20. Suma y resta de matrices

src/20.py

matrix_a = np.array([[1, 1, 1],
                     [1, 1, 1],
                     [1, 1, 2]])


matrix_b = np.array([[1, 3, 1],
                     [1, 3, 1],
                     [1, 3, 8]])

print(np.add(matrix_a, matrix_b)) 
'''
[[ 2  4  2]
 [ 2  4  2]
 [ 2  4 10]]
'''

print(np.subtract(matrix_a, matrix_b)) 
'''
[[ 0 -2  0]
 [ 0 -2  0]
 [ 0 -2 -6]]
'''

Alternativamente, podemos simplemente usar los operadores + y -:

print(matrix_a + matrix_b)
'''
[[ 2  4  2]
 [ 2  4  2]
 [ 2  4 10]]
'''

21. Multiplicando matrices

Aquí puedes ver como se calcula el producto de dos matrices.

src/21.py

matrix_a = np.array([[1, 1],
                     [1, 2]])

matrix_b = np.array([[1, 3],
                     [1, 2]])

print(np.dot(matrix_a, matrix_b)) 
'''
[[2 5]
 [3 7]]
'''

Es equivalente a:

print(matrix_a @ matrix_b)

Si queremos hacer una multiplicación por elementos:

print(matrix_a * matrix_b) 
'''
[[1 3]
 [1 4]]
'''

Ver:

22. Generación de valores aleatorios

src/22.py

# Set seed
np.random.seed(0)

# Generate three random floats between 0.0 and 1.0
print(np.random.random(3)) # [0.5488135  0.71518937 0.60276338]

Ver:

NumPy ofrece una amplia variedad de medios para generar números aleatorios, también es común para generar enteros:

# Generate three random integers between 1 and 10
print(np.random.randint(0, 11, 3)) # [3 7 9]

23. NumPy tipos numéricos

Python tiene un tipo entero (float), un tipo flotante (float) y un tipo complejo (complex), sin embargo, esto no es suficiente para computación científica y, por esta razón, NumPy tiene muchos más tipos de datos. En la práctica, nosotros necesitan aún más tipos con precisión variable y, por lo tanto, diferente tamaño de memoria. La mayoría de los tipos numéricos NumPy terminan con un número. Este número indica el número de bits asociados con el tipo. La siguiente tabla (adaptada del NumPy guía del usuario) ofrece una descripción de los tipos de NumPy:

Ver Data types

Para cada tipo de datos, existe una función de conversión correspondiente:

In [1]: import numpy as np

In [2]: np.float64(42)
Out[2]: 42.0

In [3]: np.int8(42.0)
Out[3]: 42

Algunas funciones como bool y float están deprecadas (deprecated) en favor de las funciones nativas (bool).

Muchas funciones tienen un argumento de tipo de datos, que suele ser opcional:

In [9]: np.arange(7, dtype=np.uint16)
Out[9]: array([0, 1, 2, 3, 4, 5, 6], dtype=uint16)

24. Objetos de tipo de datos

Los objetos de tipo de datos son instancias de la clase numpy.dtype. Una vez más, las matrices pertenecen a un tipo de datos. Para ser precisos, todos los elementos de una matriz NumPy tienen el mismo tipo de datos. El objeto tipo de datos puede decirle el tamaño de los datos en bytes. El tamaño en bytes viene dado por el tamaño del elemento atributo de la clase dtype:

In [12]:  a = np.array([[1,2],[3,4]])

In [13]: a.dtype.itemsize
Out[13]: 4

25. Códigos de caracteres

Los códigos de caracteres se incluyen para la compatibilidad con versiones anteriores de Numeric, el predecesor de NumPy. No se recomienda su uso, pero los códigos se proporcionan aquí. porque aparecen en varios lugares. En su lugar, debe usar objetos dtype.

In [15]: np.arange(7, dtype='f')
Out[15]: array([0., 1., 2., 3., 4., 5., 6.], dtype=float32)

Referencias:

26. constructores dtype

Tenemos una variedad de formas de crear tipos de datos. Tomemos el caso de los datos de punto flotante:

  • Podemos usar el float general de Python:

    In [17]: np.dtype(float)
Out[17]: dtype('float64')

  • Podemos especificar con un código de carácter:

    In [18]: np.dtype('f')
Out[18]: dtype('float32')

27. Enlaces externos