Tipos de datos

Para crear un array con un rango de datos podemos usar el método arange

np.arange(0,10)

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Tipos de datos

Los arrays de NumPy solo pueden contener un tipo de dato, ya que esto es lo que le confiere las ventajas de la optimización de memoria.

Podemos conocer el tipo de datos del array consultando la propiedad .dtype.

arr = np.array([1, 2, 3, 4])
arr.dtype
	---> dtype('int64')

Si queremos usar otro tipo de dato lo podemos definir en la declaración del array.

arr = np.array([1, 2, 3, 4], dtype = 'float64')
arr.dtype
	---> dtype('float64')

Ahora vemos que los valores están con punto decimal.

arr
	---> array([1., 2., 3., 4.])

Si ya se tiene el array definido se usa el método .astype() para convertir el tipo de dato.

arr = np.array([1, 2, 3, 4])
arr = arr.astype(np.float64)
arr
	---> array([1., 2., 3., 4.])

También se puede cambiar a tipo booleano recordando que los números diferentes de 0 se convierten en True.

arr = np.array([0, 1, 2, 3, 4])
arr = arr.astype(np.bool_)
arr
	---> array([False,  True,  True,  True,  True])

También podemos convertir los datos en tipo string.

arr = np.array([0, 1, 2, 3, 4])
arr = arr.astype(np.string_)
arr
	---> array([b'0', b'1', b'2', b'3', b'4'], dtype='|S21')

De igual forma se puede pasar de string a numero.

arr = np.array(['0', '1', '2', '3', '4'])
arr = arr.astype(np.int8)
arr
	---> array([0, 1, 2, 3, 4], dtype=int8)

Si un elemento no es de tipo número el método falla.

arr = np.array(['hola','0', '1', '2', '3', '4'])
arr = arr.astype(np.int8)
arr
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-30-b9bb95861c7b> in <module>()
      1 # DSi un elemento no es de tipo número el método falla.
      2 arr = np.array(['hola','0', '1', '2', '3', '4'])
----> 3 arr = arr.astype(np.int8)
      4 arr

ValueError: invalid literal for int() with base 10: 'hola'

• np.float16 ahorra espacio en memoria (precisión media, exponente de 5 bits)
• np.float_ hace lo mismo que float64 (precisión doble, exponente de 11 bits)
  
  

Hola,esto es util, linspace y arange, parecen iguales pero no lo son. En linspace en el tercer valor indicamos la cantidad de valores que iran en el intervalo , ademas nótese que linspace SI incluye el segundo valor que se coloca (10 en este ejemplo). En arange en el tercer valor indicamos de cuanto en cuanto irán saltanto, aquí NO toma el ultimo valor ( segundo valor que se da, 10 en este caso).

Carlos en un momento obtuvo un dato INT64 y luego metió un INT64. Para que entiendan (ya que Carlos dio por hecho que nosotros lo sabemos), existen INT8, INT16, INT32 e INT64, en donde cada número a la derecha define la cantidad de bits en memoria ocupados, y por ende, define el rango de cantidad de números disponibles en cada array. Por ejemplo, un INT62 puede almacenar números dentro del rango de -9223372036854775808 a 9223372036854775807.

El array de numpy solo puede tener un único tipo de datos en el cual va a trabajar. No puedo tener la mitad del array en int y la otra mitad en bool.

Los arrays en NumPy contienen valores de un solo tipo, por lo que es importante tener conocimiento de esos tipos y sus limitaciones. En NumPy, los elementos de un Array por defectos son float de 64 bits (float64), es decir, cada float ocupa 8 bytes en memoria.

n = np.zeros((1,3))
n.size
print(n, n.size, n.itemsize)
print("Tipo de dato almacenado en un elemento del array: ", type(n[0]))
print("Bytes almacenados en el array: %d bytes " % (n.size * n.itemsize))

[[0. 0. 0.]] 3 8
Tipo de dato almacenado en un elemento del array:  <class 'numpy.ndarray'>
Bytes almacenados en el array: 24 bytes 

Link a código en Deepnote

Los alias de tipos de datos de numpy se encuentran deprecated, ejemplo:

np.int

Aqui en la documentacion explican el motivo principal.
aqui

La nueva forma de hacer uso de esta funcionalidad es en algunos casos colocar un _ al final del tipo de dato

arr = arr.astype(np.int_)

Para cambiar los tipos de datos de manera sencilla o consultarlos:
• .dtype: Para poder saber cuál es el tipo de dato está usando el array
• .astype: Para poder cambiar el tipo de dato qué está usando el array

Me causo curiosidad ver lo de int8, int64, etc y esto fue lo que encontre:
En NumPy, los tipos de datos numéricos tienen diferentes representaciones de tamaño y rango. Las diferencias principales entre ellos radican en la cantidad de memoria que ocupan y el rango de valores que pueden almacenar. Aquí tienes una breve descripción de algunos de los tipos de datos numéricos más comunes en NumPy:

int8: Entero de 8 bits con signo. Puede representar valores en el rango de -128 a 127.

int16: Entero de 16 bits con signo. Puede representar valores en el rango de -32,768 a 32,767.

int32: Entero de 32 bits con signo. Puede representar valores en el rango de -2,147,483,648 a 2,147,483,647.

int64: Entero de 64 bits con signo. Puede representar valores en el rango de -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807.

uint8: Entero de 8 bits sin signo. Puede representar valores en el rango de 0 a 255.

uint16: Entero de 16 bits sin signo. Puede representar valores en el rango de 0 a 65,535.

uint32: Entero de 32 bits sin signo. Puede representar valores en el rango de 0 a 4,294,967,295.

uint64: Entero de 64 bits sin signo. Puede representar valores en el rango de 0 a 18,446,744,073,709,551,615.

La elección del tipo de datos adecuado dependerá de los requisitos específicos de tu aplicación. Si necesitas almacenar grandes cantidades de datos y estás seguro de que los valores se encuentran dentro de un rango limitado, es posible que desees utilizar tipos de datos más pequeños para ahorrar memoria. Por otro lado, si necesitas representar números más grandes o negativos, puedes optar por tipos de datos con mayor rango.

Es importante tener en cuenta que el uso de tipos de datos con mayor rango implica un mayor consumo de memoria, por lo que es recomendable utilizar el tipo de datos más adecuado según las necesidades de tu proyecto. En general, NumPy proporciona una amplia gama de tipos de datos numéricos para satisfacer diversas necesidades de cálculo y manipulación de datos.

Desde el principio se puede declarar el tipo de dato que se va a usar:

arr = [0,1,2,3,4]
w = np.float_(arr)
x = np.int_(arr)
y = np.bool_(arr)
z= np.string_(arr)

w, x, y, z

(array([0., 1., 2., 3., 4.]),
 array([0, 1, 2, 3, 4]),
 array([False,  True,  True,  True,  True]),
 b'\x00\x01\x02\x03\x04')

Información resumida de esta clase
#EstudiantesDePlatzi

• Numpy me permite trabajar con muchos tipos de datos

• Con la propiedad dtype puedo ver qué tipo de dato estoy usando

• Los tipos de datos decimales se entienden mejor con las máquinas y son de mayor uso con las redes neuronales

• Con la propiedad astype puedo cambiar el tipo de dato a cualquiera que yo desee

• El tipo de dato lo defino desde la librería

• El array de numpy solo puede tener un único tipo de dato a la vez con el cual voy a trabajar

Tipos de datos en Numpy, en numpy los tipos de datos se expresan con una sola letra, pero tambien puedes referirte a ellos mediante su nombre completo: (int, str, bool etc)

• i - enteros

• b - booleanos

• u - entero sin signo

• f - flotante

• c - flotantes compejos

• m - timedelta

• M - fecha y hora

• O - objeto

• S - cadena de texto

• U - cadena unicode

• V - ragmento fijo de memoria para otro tipo (vacío)

Siento que acabo de adquirir un nuevo superpoder. Es maravilloso este curso.

******Tipos de matrices y conversiones entre tipos ******

• NumPy admite una variedad mucho mayor de tipos numéricos que Python. Esta sección muestra cuáles están disponibles y cómo modificar el tipo de datos de una matriz.
  dtype

Tipos de datos

• NumPy maneja gran cantidad de tipos de datos. A diferencia de los tipos de datos numéricos en Python que no establecen un tamaño de bytes de almacenamiento, aquí sí hay una diferencia clara.

• Algunos de los tipos de datos numéricos en NumPy se presentan en la siguiente tabla:
  

  

EJERCICIO: Parto de una matriz 3D numpy array y voy cambiando el tipo de dato. Usando la función de NUMPY NBYTES veo cómo varía el tamaño en bytes de la matriz cuando le cambio el tipo de dato.

• Genero matriz 3D 3x3x3. Tipo de dato INT 64.

import numpy as np
npint64 = np.array([[[1,2,3], [4,5,6], [7,8,9]],[[11,12,13], [14,15,16],[17,18,19]],[[21,22,23], [24,25,26],[27,28,29]]])
npint64.dtype, npint64.nbytes

(dtype(‘int64’), 216)

• Matriz con tipo de dato FLOAT 16 (Half precision float: sign bit, 5 bits exponent, 10 bits mantissa)

npfloat16 = npint64.astype(np.float16) 
npfloat16.dtype, npfloat16.nbytes  

(dtype(‘float16’), 54)

• Matriz con tipo de dato FLOAT / SINGLE (Platform-defined single precision float: typically sign bit, 8 bits exponent, 23 bits mantissa)

npsingle = npint64.astype(np.single)  
npsingle.dtype, npsingle.nbytes  

(dtype(‘float32’), 108)

• Matriz con tipo de dato DOUBLE (Platform-defined doubleprecisionfloat: typically sign bit, 11 bits exponent, 52 bits mantissa.)

npdouble = npint64.astype(np.double)  
npdouble.dtype, npdouble.nbytes 

(dtype(‘float64’), 216)

• Matriz con tipo de dato DOUBLE COMPLEX (Complex number, represented by two double-precision floats (real and imaginary components)

npcdouble = npint64.astype(np.cdouble)  
npcdouble.dtype, npcdouble.nbytes 

(dtype(‘complex128’), 432)

El numero que tiene al final del dtype es el número de bits que se asignaran a cada elemento, así un float64 es una memoria de 64 bits asignada a cada item y que se tratará como un float. Esto es importante para cuestiones de presisión a más bits más información puedes guardar. Aquí un ejemplo de esto que saque de la documentación de Numpy

´´´
np.power(100, 8, dtype=np.int64) # Out: 10000000000000000
np.power(100, 8, dtype=np.int32) # Out: 1874919424
´´´

Es importante tener en cuenta esto porque puede que sea fuente de errores en tus cuentas si definiste que usarías 32 bits pero estás lidiando con datos que ameritarían usar 64 bits…

• Crear un array a partir de un rango asignadole el tipo de dato:

arr = np.arange(5, dtype = np.int8)
arr---> array([0, 1, 2, 3, 4])

• Otra forma de asignar un tipo de dato a un array ya creado es:

np.float(arr)
arr---> array([0., 1., 2., 3., 4.])

Tipo de dato para números complejos:

arr = np.array(['0','1','2','3','4'])
arr = arr.astype(np.csingle)
arr

La salida que genera es la siguiente:

array([0.+0.j, 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j], dtype=complex64)```

Interesante.

arr_string = np.array([1,2,3,4])
arr_string = arr_string.astype(np.str_)
arr_string

salida:

array(['1', '2', '3', '4'], dtype='<U21')

arr = np.array([0,1,2,3,4])
arr = arr.astype(np.clongdouble)
arr
array([0.+0.j, 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j], dtype=complex256)

Me pareció interesante el clongdouble por la gran cantidad de memoria que usa (256).

Creo que en el camino entenderé un poco más porque, no se aún que podría significar “clongdouble”.

Python sequences of numbers to arrays

z = np.arange(10, dtype=np.uint8)
z
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)

Overflow Errors
The fixed size of NumPy numeric types may cause overflow errors when a value requires more memory than available in the data type. For example, numpy.power evaluates 100 ** 8 correctly for 64-bit integers, but gives 1874919424 (incorrect) for a 32-bit integer.

np.power(100, 8, dtype=np.int64)
10000000000000000
np.power(100, 8, dtype=np.int32)
1874919424

Aunque podemos cambiar el array a diferentes tipos de datos. Lo que no se puede es cambiar parcialmente el tipo de dato. Es decir, no podríamos tener la mitad del array con un tipo de dato, y el resto con algún otro.

Me encanto esta clase de numpy. Si que estoy aprendiendo a usar estos tipos de datos basicos porque nos permite mejorar nuestra capacidad de programador. Es lo mejor.

La diferencia que hay entre usar arr = np.array([1,2,3,4], dtype = ‘float64’) y arr.astype(np.float64)1 es la siguiente:

dtype en np.array: Cuando creas un array de NumPy usando np.array(), puedes especificar el tipo de datos usando el argumento dtype. Esto significa que el array se creará con el tipo de datos especificado desde el principio1. Por ejemplo, arr = np.array([1,2,3,4], dtype = ‘float64’) creará un array de números flotantes1.

astype en np.array: El método astype() se usa para hacer un casting de un array a un tipo de datos diferente2. Esto significa que se crea una copia del array original y se cambia el tipo de datos de la copia2. Por ejemplo, si tienes un array arr de enteros y usas arr.astype(np.float64), se creará una copia de arr donde todos los elementos son números flotantes2.

Por lo tanto, la principal diferencia es que dtype en np.array() establece el tipo de datos al crear el array, mientras que astype() cambia el tipo de datos de un array existente creando una copia12. Si la función acepta el parámetro dtype, entonces úsalo. Si no acepta ese parámetro, tendrás que usar astype. El efecto debería ser el mismo (en la mayoría de los casos)1.

✅

El video de la clase se bloquea mucho , es “imposible” hacer la clase

A continuación comparto mi Jupyter Notebook con comentarios, creado en VSC y subido a Google Colab por si lo desean revisar.

Numpy sin lugar a duda es muy potente y los recursos que ofrece para definicr los tipos de datos es muy buena.

Aquí ya vamos viendo las diferencias entre LISTAS Y ARRAYS, pues en una LISTA tú puedes tener elementos de cualquier tipo. En los ARRAYS tienes que tener el mismo tipo de dato para todos los elementos.

Me parece un tema muy interesante, ya que este tipo de conceptos se suele dejar de lado, aunque son muy importantes cuando se trabaja en un proyecto.

I converted aa array of integers in to an array of complex nmumbers.

arr = np.array([‘1’,‘2’,‘3’,‘4’,‘5’])
arr = arr.astype(np.csingle)
arr

run
array([1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j, 5.+0.j], dtype=complex64)

#tarea
m=[[1,2,3],[10,10,4], [4, 5, 6]]
ma = np.array(m)
ma[1:,-2:]

print:
array([[10, 4],
[ 5, 6]])

3. Tipos de datos

• Los array solo pueden trabajar con un único tipo de dato.

import numpy as np

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

arr=np.array([1,2,3,4], dtype='float64')
arr.dtype

arr

arr = np.array([0,1,2,3,4])
arr = arr.astype(np.bool_)
arr

arr = np.array([0,1,2,3,4])
arr = arr.astype(np.string_)
arr

arr = np.array(['hola','0','1','2','3','4'])
arr = arr.astype(np.int8)
arr

NumPy es una biblioteca que proporciona tipos de datos para trabajar con arreglos y matrices multidimensionales de manera eficiente. A continuación, te explico los tipos de datos que ofrece NumPy:

1. integers (enteros): NumPy proporciona tipos de datos enteros con diferentes tamaños, desde 8 bits hasta 64 bits, que se pueden firmar o sin firmar.
2. floats (punto flotante): NumPy proporciona tipos de datos de punto flotante con diferentes tamaños, desde 16 bits hasta 128 bits.
3. complex (números complejos): NumPy proporciona tipos de datos de números complejos con diferentes tamaños de punto flotante.
4. bool (valores booleanos): NumPy proporciona tipos de datos booleanos para representar valores True o False.
5. strings (cadenas de caracteres): NumPy proporciona tipos de datos de cadenas de caracteres con una longitud fija.

Cada tipo de dato en NumPy está representado por un objeto de tipo dtype. El objeto dtype contiene información sobre el tamaño del tipo de dato, su representación en memoria y otras propiedades relevantes.

Para crear un arreglo NumPy con un tipo de datos específico, podemos especificar el tipo de datos en el momento de la creación del arreglo. Por ejemplo:

import numpy as np

# Creamos un arreglo NumPy de enteros sin firmar de 8 bits
arr1 = np.array([1, 2, 3], dtype=np.uint8)
print(arr1)

# Creamos un arreglo NumPy de punto flotante de 64 bits
arr2 = np.array([1.0, 2.0, 3.0], dtype=np.float64)
print(arr2)

# Creamos un arreglo NumPy de números complejos de 64 bits
arr3 = np.array([1+2j, 3+4j, 5+6j], dtype=np.complex64)
print(arr3)

# Creamos un arreglo NumPy de valores booleanos
arr4 = np.array([True, False, True], dtype=np.bool)
print(arr4)

# Creamos un arreglo NumPy de cadenas de caracteres con longitud fija
arr5 = np.array(['foo', 'bar', 'baz'], dtype='S')
print(arr5)

La salida en la consola sería la siguiente:

[1 2 3]
[1. 2. 3.]
[1.+2.j 3.+4.j 5.+6.j]
[ True False  True]
[b'foo' b'bar' b'baz']

También podemos cambiar el tipo de datos de un arreglo NumPy existente utilizando el método astype()
. Por ejemplo:

import numpy as np

# Creamos un arreglo NumPy de enteros de 32 bits
arr = np.array([1, 2, 3], dtype=np.int32)

# Cambiamos el tipo de datos a punto flotante de 64 bits
arr = arr.astype(np.float64)

use
.astype(np.str_)

y obtuve el array sin las b, min 5:35

Es importante tener en cuenta que los tipos de datos en Numpy tienen un impacto en la precisión y el tamaño de los datos. Por ejemplo, float32 es un tipo de punto flotante de precisión simple con 32 bits, mientras que float64 es un tipo de punto flotante de precisión doble con 64 bits. La diferencia entre manejar datos a 32 bits y 64 bits se refiere a la precisión y el tamaño de los datos.

Un número en formato de punto flotante de 32 bits (float32 en Numpy) ocupa 4 bytes de memoria y tiene una precisión de 7 dígitos decimales. Esto significa que el número puede representarse con una precisión limitada en comparación con un número de punto flotante de 64 bits (float64 en Numpy).

Por otro lado, un número en formato de punto flotante de 64 bits (float64 en Numpy) ocupa 8 bytes de memoria y tiene una precisión de 15 dígitos decimales. Esto significa que el número puede representarse con una precisión mucho mayor en comparación con un número de punto flotante de 32 bits.

La elección entre manejar datos a 32 bits o 64 bits depende de la precisión y el tamaño de los datos que se requieren para una determinada tarea. Si se requiere una gran precisión y el tamaño de los datos no es un problema, es recomendable usar float64. Por otro lado, si se requiere una precisión moderada y se desea reducir el tamaño de los datos, es recomendable usar float32.

Es importante tener en cuenta que la precisión y el tamaño de los datos pueden tener un impacto en la velocidad de ejecución y el uso de la memoria, por lo que es importante elegir cuidadosamente el tipo de datos apropiado para cada situación.

Aquí les dejo un ejemplo en código, que muestra la diferencia en precisión entre float32 y float64 en Numpy:

import numpy as np

# Crear un arreglo con datos a 32 bits
num_list_32 = np.array([0.123456789, 1.234567891, 2.345678912], dtype='float32')
print("Arreglo con datos a 32 bits:")
print(num_list_32)
print('')

# Crear un arreglo con datos a 64 bits
num_list_64 = np.array([0.123456789, 1.234567891, 2.345678912], dtype='float64')
print("Arreglo con datos a 64 bits:")
print(num_list_64)
print('')

# Mostrar la diferencia en precisión
print("Diferencia en precisión:")
print(num_list_64 - num_list_32)

El resultado de ejecutar este código es:

Arreglo con datos a 32 bits:
[0.12345679 1.2345679  2.3456788 ]

Arreglo con datos a 64 bits:
[0.12345679 1.23456789 2.34567891]

Diferencia en precisión:
[-2.04328156e-09  1.03695068e-08  1.05695068e-07]

Como podemos notar, la precisión de los números en el arreglo con datos a 32 bits es ligeramente menor que la precisión de los números en el arreglo con datos a 64 bits. La diferencia en precisión es mínima, pero puede tener un impacto importante en algunos casos, especialmente en cálculos científicos y matemáticos.

Muy interesante la opcion de modificar el tipo de dato del array:
arr = arr.astype(np.newtype)

Tipos de datos

Numpy soporta muchos tipos de datos en sus arrays para tus necesidades. Sin embargo, el array de numpy solo debe tener un tipo de dato en su array. Si mezclamos, por ejemplo, entero64 con string, se perdería la eficiencia en memoria.

Archivo de la clase 3 - tipos de datos

fascinante.

array2=np.array([2,3,4,5,6,7],dtype=‘str’)
array2

Lo mas curioso me parecieron la versiones u(tipo de dato) de los números.
ejemplo:

este dato es pequeño así que si este este podría ser útil para utilizar nueceros pequeños

arr= np.array([0,2,3,4,5,6,10])
arr= arr.astype(np.byte)  # este solo esta ene l intervalo enetr 127 y -127

y este duplica su alcance un la muletilla u

arr= np.array([0,2,3,4,5,6,10])
arr= arr.astype(np.ubyte)  # este solo esta ene l intervalo enetr 255 y -255
arr

En mi caso use el cdouble por que se utiliza en caso de un número complejo, representado por dos flotadores de doble precisión ( componentes reales e imaginarios ).

Tipos de datos en NumPy

• Un array puede almacenar un sólo tipo de datos
• Para saber que tipo de datos almacena nuestro array usamos el atributo dtype: my_array.dtype
• En caso queramos cambiar el tipo de datos de nuestro array usamos el método astype() cuyo parámetro principal es el tipo de datos (de preferencia datos de nympy), por ejemplo: my_array.astype(np.float)
• Si casteamos los valores de un array a tipo flotante se reconoceran los 0 y valores nulos como False y el resto de valores como True

Que buena explicación profe!

Mis apuntes #4 (Notion + Notas de Cornell)

Tipos de datos

Los arrays de NumPy solo pueden contener un tipo de dato, ya que esto es lo que le confiere las ventajas de la optimización de memoria.

Podemos conocer el tipo de datos del array consultando la propiedad .dtype.

para ver que tipo de dato estamos usando en nuestro array, basta con usar la propiedad dtype

typeArray = np.array([1,2,3,4])
typeArray.dtype 
# result ---> dtype('int64')

💡 Un Array de Numpy, solo puede tener un unico tipo de dato, pero lo podemos cambiar para todos los datos de nuestro array

Para cambiar el tipo de dato que contiene el array,tiene que usar metodo astype(np.tipodedato)

typeArray = typeArray.astype(np.float64)
typeArray.dtype

# resut --->  float64

Para inizializar el array con el tipo de dato que queremos, podemos usar dtype='typo de dato'

newArray = np.array([1,2,3,4], dtype="float64")
newArray.dtype
# result  --->  float64

Aquí les dejo algunos shortcuts para usar en Colab

PARA EJECUTAR CODIGO:
ctrl + enter
PARA CREAR UNA NUEVA CELDA:
crtl + m +b

Mis ejemplos:

import numpy as np


def main():
    int64 = [0, 1, 2, 3, 4, 5, 6]
    string = ['0', '1', '2', '3', '4', '5', '6', '222']
    array_int64 = np.array(int64)
    array_string = np.array(string)
    arr_int64_as_float64 = np.array(int64, dtype='float64')
    print('See type property python: ', type(array_int64))
    print('See dtype property numpy [int64]: ', array_int64, array_int64.dtype)
    print('See dtype property numpy [int64] but define as [float64]: ',
          arr_int64_as_float64, arr_int64_as_float64.dtype)
    print('Property numpy [int64] but define as [float64] with astype:',
          array_int64.astype(np.float64), array_int64.astype(np.float64).dtype)
    print('Property numpy [int64] but define as [boolean] with astype:',
          array_int64.astype(np.bool_), array_int64.astype(np.bool_).dtype)
    print('Property numpy [int64] but define as [string] with astype:',
          array_int64.astype(np.string_), array_int64.astype(np.string_).dtype)
    print('Property numpy [string] but define as [int8] with astype:',
          array_string.astype(np.int8), array_string.astype(np.int8).dtype)
    print('Property numpy [int64] but define as [byte] with astype:',
          array_string.astype(np.byte), array_string.astype(np.byte).dtype)
    """
    The fixed size of NumPy numeric types may cause overflow errors when a
    value requires more memory than available in the data type. For example,
    numpy.power evaluates 100 ** 8 correctly for 64-bit integers, but gives
    1874919424 (incorrect) for a 32-bit integer.
    """
    print('Property numpy power [int64]', np.power(100, 8, dtype=np.int64))
    print('Property numpy power [int32]', np.power(100, 8, dtype=np.int32))

    """
    The behaviour of NumPy and Python integer types differs significantly for
    integer overflows and may confuse users expecting NumPy integers to behave
    similar to Python’s int. Unlike NumPy, the size of Python’s int is
    flexible. This means Python integers may expand to accommodate any
    integer and will not overflow.

    NumPy provides numpy.iinfo and numpy.finfo to verify the minimum or maximum
    values of NumPy integer and floating point values respectively
    """
    print(np.iinfo(int))  # Bounds of the default integer on this system.
    print(np.iinfo(np.int32))  # Bounds of a 32-bit integer
    print(np.iinfo(np.int64))  # Bounds of a 64-bit integer


if __name__ == '__main__':
    main()

Numpy solo permite un tipo de dato en cada array es super importante, había declaroado una matriz de la siguiente forma [[1,2,3,4,5],[‘Pepe’,‘Juan’,‘Camila’]] y me lanzaba un error.

arr = np.array([0, 1, 2, 3, 4])
arr = arr.astype(np.string_)
arr

Generar un array de cero hasta diez( sin incluirlo) de dos en dos y del tipo float32, todo en una misma línea de código.

<code> b = np.arange(0,10,2, dtype= "float32")

Para conservar los miembros (métodos y atributos) de los elementos de un array de numpy, es recomendable utilizar el tipo de dato np.object_.

Es especialmente útil cuando no queramos reconstruir un objeto constantemente. Al definir el tipo de dato en dtype, numpy hará un casting de los valores dentro de la lista si tienen los métodos necesarios para hacerlo.

Ejemplo

Tenemos la siguiente clase.

class MiEstructura:
    def __init__(self, aaa):
        self.word = aaa
    def ejemplo(self):
        return "bbb"
    def __str__(self):
        return str(self.word)
    def __int__(self):
        return 1

arr1 = np.array(
    [MiEstructura("111"),
    MiEstructura("222"),
    MiEstructura("333"),
    MiEstructura("444")], dtype=np.object_
); arr1

[O] array([<__main__.MiEstructura object at 0x000001794A4FF3A0>,
       <__main__.MiEstructura object at 0x000001794A4FDE70>,
       <__main__.MiEstructura object at 0x0000017948B1D000>,
       <__main__.MiEstructura object at 0x0000017948B1C160>], dtype=object)

arr2 = np.array(
    [MiEstructura("111"),
    MiEstructura("222"),
    MiEstructura("333"),
    MiEstructura("444")], dtype=np.string_
); arr2
[O] array([b'111', b'222', b'333', b'444'], dtype='|S3')
# En este caso, numpy llamo a .__str__() de cada objeto para realizar la conversión

# Al cambiar np.string por np.int_
[O] array([1, 1, 1, 1])
# Se llamo a .__int__() en este caso.

np.object_
Al llamar .ejemplo() en cada caso.

arr1[0].ejemplo()
[O] 'bbb'

np.string_

arr2[0].ejemplo()
[O] AttributeError: 'numpy.bytes_' object has no attribute 'ejemplo'

np.arange

Los array solo pueden tener un único tipo de dato

Array = array.astype(np.float64) -> Cambiar a decimales
Array = array.astype(np.bool_)-> Cambiar a booleano
Array = array.astype(np.string_)-> Cambiar a texto string
Array = array.astype(np.int8_)-> Convierte números en formato texto a formato entero, resultará error de tener elementos con letras

VSC, virtual environment y numpy /

• ImportError.
  -> sol: renombrar tu archivo.

Este curso se pone cada vez más interesante 😎🥇🚀

ty por el notebook

arr = np.array([‘0’,‘1’,‘2’,‘3’,‘4’])
arr = arr.astype(np.double)
arr

Otra alternativa para cambio de tipo de dato:

in: a = np.array([1,2,3,4], dtype='int64')
in: a = a.astype('float')
in: a.dtype
out: dtype('float64')