NumPy

1

Fundamentos para Análisis de Datos en NumPy y Pandas

2

Dimensiones en NumPy y Pandas: De Escalares a Tensors

3

Arrays en NumPy

4

Introducción al álgebra lineal con NumPy

5

Indexación y Slicing

6

Broadcasting y Operaciones Lógicas en NumPy

7

Elementos Únicos y sus Conteos: Copias y Vistas

8

Transformación de Arrays: Reshape y Manipulación

9

Caso Práctico de Análisis de Datos

10

Cálculos Matriciales en NumPy

11

Ejercicios en NumPy

Pandas

12

Pandas para Manipulación de Datos

13

Creación de Dataframes en Pandas

14

Estructuras de Datos en Pandas y Funciones

15

Uso de iloc y loc en Pandas

16

Manejo de Datos Faltantes en Pandas

17

Creación y Manipulación de Columnas en Pandas

18

Agrupaciones con groupby

19

Filtrado de datos con condiciones en Pandas

20

Reestructuración de datos: Pivot y Reshape en Pandas

21

Fusión de DataFrames en Pandas

22

Manejo de Series Temporales en Pandas

Matplotlib

23

Introducción a Matplotlib gráfico de líneas y dispersión

24

Personalización de Gráficos en Matplotlib

25

Gráficos de Barras y Diagramas de Pastel

26

Gráficos de Histograma y Boxplot para distribuciones

27

Series de tiempo y manejo de fechas con Matplotlib

28

Subplots y Layouts Avanzados

Proyecto de Análisis de Datos de Retail

29

Caso de Estudio (Parte I). Limpieza de datos

30

Caso de Estudio (Parte II). Creación de columnas

31

Caso de Estudio (Parte III). Graficación y análisis de resultados

32

Proyecto Final: Creación de Portafolio de Análisis de Datos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Arrays en NumPy

3/32
Recursos

Métodos de creación de Arrays de NumPy

NumPy proporciona diversas maneras de crear arrays, facilitando la realización de cálculos numéricos y análisis de datos de manera eficiente en Python.

1. Creación de Arrays a partir de Listas

Podemos crear un array a partir de una lista o una lista de listas:

import numpy as np

# Array unidimensional
array_1d = np.array([1, 2, 3, 4])

# Array bidimensional
array_2d = np.array([[1, 2, 3], [4, 5, 6]])

2. Creación de Arrays con Funciones Predefinidas

NumPy proporciona funciones predefinidas para crear arrays de manera más rápida y conveniente:

  • np.zeros(): Crea un array lleno de ceros.

    
    zeros_array = np.zeros((3, 3))
    
    
  • np.ones(): Crea un array lleno de unos.

    
    ones_array = np.ones((2, 4))
    
    
  • np.arange(): Crea un array con una secuencia de números.

    range_array = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
    
    
  • np.linspace(): Crea un array con números igualmente espaciados.

    linspace_array = np.linspace(0, 1, 5)  # [0., 0.25, 0.5, 0.75, 1.]
    
    

3. Especificando Tipos de Datos (Datatypes)

Al crear un array, podemos especificar el tipo de datos que contendrá utilizando el parámetro dtype. Esta especificación es crucial para la eficiencia y precisión en cálculos numéricos. Aquí se detallan algunos de los tipos de datos más comunes:

  • int32: Entero de 32 bits.
  • float32: Número de punto flotante de 32 bits.
  • float64: Número de punto flotante de 64 bits (por defecto para números flotantes en NumPy).
  • bool: Valores booleanos (True o False).
  • complex64: Número complejo de 64 bits.
  • complex128: Número complejo de 128 bits.
  • str: Cadenas de texto.

Podemos especificar estos tipos de datos al crear el array utilizando el parámetro dtype:

pythonCopiar código
# Array de enteros
int_array = np.array([1, 2, 3], dtype='int32')

# Array de flotantes
float_array = np.array([1.0, 2.0, 3.0], dtype='float32')

# Array de booleanos
bool_array = np.array([True, False, True], dtype='bool')

# Array de números complejos
complex_array = np.array([1+2j, 3+4j], dtype='complex64')

# Array de cadenas de texto
str_array = np.array(['a', 'b', 'c'], dtype='str')

Algunos de estos tipos también pueden ser especificados con abreviaturas en el parámetro dtype. Por ejemplo, 'd' es equivalente a float64, que es el tipo de datos de punto flotante de 64 bits en NumPy:

# Creando un array con dtype 'd' (equivalente a float64)
array_float64 = np.array([1, 2, 3], dtype='d')
print(array_float64)

4. NaN (Not a Number)

NaN es un valor especial utilizado para representar datos que no son números, especialmente en el contexto de operaciones matemáticas que no tienen un resultado definido. Por ejemplo, la división de cero por cero (0/0) o la raíz cuadrada de un número negativo.

nan_array = np.array([1, 2, np.nan, 4])
print(nan_array)

El valor NaN es muy útil para manejar datos faltantes o resultados indefinidos en cálculos numéricos.

Aportes 25

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Diferencias de Listas y Arrays * **Rendimiento**: NumPy es mucho más rápido y eficiente para operaciones matemáticas y científicas. * **Tipos de Datos**: NumPy requiere homogeneidad de tipos, mientras que las listas de Python pueden contener múltiples tipos. * **Funcionalidad**: NumPy proporciona una rica funcionalidad específica para cálculos numéricos. * **Slicing e Indexación**: NumPy ofrece herramientas avanzadas para manipular subconjuntos de datos. **NumPy** es la mejor opción. Para usos más generales y cuando se necesita mayor flexibilidad en los tipos de datos, las **listas de Python** son más adecuadas.
¿Por qué usamos lo arrays en Numpy? Los arrays en NumPy se utilizan porque ofrecen una estructura eficiente y flexible para manejar grandes volúmenes de datos numéricos. Estos son algunos de los motivos: 1. **Eficiencia**: Los arrays de NumPy son más rápidos y utilizan menos memoria que las listas de Python. Esto se debe a que NumPy está implementado en C y realiza operaciones matemáticas de manera muy eficiente. 2. **Operaciones Vectorizadas**: NumPy permite realizar operaciones matemáticas y lógicas sobre arrays enteros sin necesidad de bucles explícitos. Esto se conoce como vectorización y resulta en un código más limpio y rápido. 3. **Funcionalidad Extendida**: NumPy proporciona una amplia gama de funciones matemáticas y estadísticas que se pueden aplicar directamente a los arrays. Además, facilita la manipulación de datos, como la reshaping, slicing, y indexing de arrays. 4. **Compatibilidad**: NumPy es el fundamento de muchos otros paquetes científicos y de análisis de datos en Python, como SciPy, Pandas, y scikit-learn. Utilizar NumPy facilita la integración y el uso de estas bibliotecas.
Utilizamos las listas cuando necesitamos flexibilidad y se manejan varios tipos de datos, por otro lado, usamos arrays al trabajar con grandes cantidades de datos numericos
Muy buena clase. Quiero dar un aporte para los estudian para Data Engineers. Este curso me ha servido mucho para el trabajo. Tengo optimizar la velocidad de código hecho con numpy y pandas en Python migrando a Polars el equivalente hecho en Rust entendí por que polars es mas rápido por esta clase. Python no tiene array numpy los trae arrays de C a CPython y Python perdiendo velocidad, Rust es Zero Cost Abstracción llamar codigo de Rust desde Python no perjudica el performance. Numpy es perfecto para empezar pero cuando ya toca optimizar polars es mejor y sabiendo numpy y pandas aprendes el 80% de lógica de polars por eso este curso me ayudo tanto.
En el análisis de datos, los arrays suelen ser preferidos debido a su eficiencia y optimización para operaciones matemáticas. Los Array de NumPy pueden definirse utilizando secuencias de Python como listas y tuplas. Las listas y tuplas se definen utilizando \[...] y (...), respectivamente. Las listas y tuplas pueden definir la creación de ndarray. NumPy tiene más de 40 funciones incorporadas para crear arrays, como se indica en las rutinas de creación de arrays.
Le pedí a ChatGPT una metáfora entre los Arrays de Numpy y Caperucita Roja y el resultado es fascinante. Me ayudo a entender mejor los conceptos: ### Metáfora de Arrays en NumPy con la Fábula de Caperucita Roja Imagina que el bosque por el que camina Caperucita Roja representa el vasto mundo de datos que necesitamos analizar. En este bosque, cada árbol es un dato individual, y hay millones de ellos. Intentar manejar cada árbol de manera individual sería agotador y poco eficiente, similar a usar listas de Python para grandes conjuntos de datos. Ahora, considera la cesta que lleva Caperucita Roja. Esta cesta es como un array de NumPy. A continuación, se explica la metáfora en detalle: 1. **Cesta Eficiente**: La cesta está perfectamente diseñada para llevar una gran cantidad de elementos (manzanas, bayas, etc.) de manera organizada y eficiente. Al igual que la cesta, un array de NumPy está optimizado para almacenar y manipular datos de forma compacta y rápida. 2. **Operaciones Sencillas**: Caperucita puede realizar operaciones fácilmente con la cesta, como agregar, quitar o contar los elementos sin tener que preocuparse por cada uno de ellos de manera individual. Similarmente, NumPy permite realizar operaciones matemáticas y lógicas sobre todo el array de manera simultánea, sin tener que iterar sobre cada elemento. 3. **Transformaciones Flexibles**: Si Caperucita necesita reorganizar los elementos en la cesta, puede hacerlo fácilmente (por ejemplo, poner todas las bayas en un lado y las manzanas en otro). Esto es como reshaping y slicing en NumPy, donde puedes cambiar la estructura del array según tus necesidades. 4. **Compatibilidad con el Bosque**: La cesta de Caperucita está diseñada para ser compatible con el entorno del bosque, permitiéndole recoger diferentes tipos de frutos sin problemas. Del mismo modo, los arrays de NumPy son compatibles con una amplia gama de bibliotecas y herramientas en Python, facilitando el análisis y procesamiento de datos de manera integral. En resumen, los arrays en NumPy son como la cesta de Caperucita Roja: una herramienta eficiente y flexible que facilita la recolección, organización y manipulación de grandes volúmenes de datos en el vasto bosque de la información.
El término *dtype* o *data type* se refiere a un objeto en Numpy que describe el tipo de los elementos en un array. Este concepto incluye dos aspectos clave: 1. **Tipo de dato**: puede ser entero, flotante, booleano, entre otros. 2. **Tamaño del dato**: puede variar, por ejemplo, 8 bits, 32 bits, 64 bits, etc. Ejemplos de *dtypes* en Numpy: * **Uint8**: Representa un número entero sin signo de 8 bits, que abarca valores entre 0 y 255. * **Float32**: Número de punto flotante de 32 bits, utilizado para representar valores con decimales. * **Float64**: Número de punto flotante de 64 bits con doble precisión. Este es el tipo de dato por defecto en Numpy para números decimales.
la desviacion estandar es por todo el conjunto de datos, no de cada uno de los numeros.
**¿Qué son los Arrays en Numpy?** **Arrays en NumPy** son herramientas versátiles utilizadas para representar imágenes, sonidos y otros tipos de datos científicos. **Arrays en NumPy** son estructuras de datos multidimensionales que permiten: * **Almacenar datos homogéneos** (todos del mismo tipo). * **Tener múltiples dimensiones** (vectores, matrices, etc.). * **Realizar operaciones matemáticas de manera eficiente**. * **Acceder y modificar datos fácilmente** con indexación y slicing.
Diferencias: Las listas son felixbles, pero menos eficientes para calculos completos, mientras que los arrays son muchos mejores para relizar operaciones estadísticas o matemáticas complejas en grandes volúmenes de datos.
También existe el tipo de dato complex64, que es un tipo de dato de 64 bits con números complejos, es un tipo de dato que se utiliza para cálculos con números complejos
La principal diferencia entre arrays y listas son algunos metodos que son diferentes y no son compartidos entre ellos, Pero hay otras diferencias importantes: ### **Listas** * **Flexibilidad:** Las listas pueden contener elementos de diferentes tipos de datos en un solo contenedor. * **Métodos:** Tienen métodos como `append()`, `remove()`, `insert()`, entre otros. * **Uso:** Se utilizan para almacenar colecciones heterogéneas de datos. ### **Arrays** * **Homogeneidad:** Los arrays generalmente contienen elementos del mismo tipo de datos. * **Métodos:** Tienen métodos más específicos a la manipulación numérica, como los ofrecidos por la biblioteca NumPy en Python (`sum()`, `mean()`, `max()`, etc.). * **Uso:** Son más eficientes en términos de espacio y se utilizan para operaciones matemáticas y científicas. Las listas son más versátiles, mientras que los arrays son más eficientes para operaciones específicas y cálculos numéricos.
Los **arrays** son herramientas muy versátiles que se utilizan para representar datos como imágenes, sonidos y otros tipos de información científica. Su uso es común en áreas como: * **Inteligencia Artificial** * **Bioinformática** * **Física** En Python, un **array** de Numpy es una estructura de datos homogénea organizada en una o más dimensiones. Estos son esenciales para realizar cálculos matemáticos de manera eficiente y rápida. #### **Ventajas de los Arrays sobre las Listas en Python** * **Eficiencia:** Las operaciones con arrays consumen menos memoria que las listas. * **Funcionalidad avanzada:** Numpy incluye funciones matemáticas y estadísticas que hacen de los arrays herramientas ideales para el análisis y procesamiento de datos complejos. * **Acceso a atributos:** Los arrays son instancias de una clase, lo que permite acceder a sus atributos. ### **Ejemplo en Código** A continuación, creamos un array en Numpy y exploramos sus atributos básicos: import numpy as np   array = np.array(\[\[1, 2, 3], \[4, 5, 6]])   print(array.ndim)  # Dimensiones del array   print(array.shape)  # Forma (filas, columnas)   print(array.dtype)  # Tipo de dato   **Resultado:** * Dimensiones: 2 * Forma: (2, 3) * Tipo de dato: int64 ### **¿Qué es el Data Type (dtype) en Numpy?** El **Data Type (dtype)** describe el tipo de elementos dentro de un array. Incluye: 1. **El tipo de dato:** Enteros, flotantes, booleanos, etc. 2. **El tamaño del dato:** Por ejemplo, 8 bits, 32 bits o 64 bits. #### **Tipos de datos comunes:** * **uint8:** Entero sin signo de 8 bits (valores entre 0 y 255). Útil para imágenes. * **float32:** Número con decimales de 32 bits, ideal para cálculos que requieren moderada precisión y ahorro de memoria. * **float64:** Número con decimales de 64 bits, que ofrece mayor precisión (valor por defecto en Numpy). ##### **Ejemplo en Código** z = np.array(3, dtype=np.uint8)   print(z)   **Resultado:** 3 double\_array = np.array(\[1, 2, 3], dtype='d')  # d = float64   print(double\_array)   **Resultado:** \[1. 2. 3.] Observa que los números enteros se convierten a flotantes al añadir el punto decimal. #### **Conversión de tipos de datos** Puedes convertir un array a otro tipo de dato con el método .astype(). z = z.astype(np.float64)   print(z)   **Resultado:** 3.0 ### **Estadísticas con Numpy** Los arrays permiten aplicar funciones estadísticas directamente. Por ejemplo: array = np.array(\[\[1, 2, 3], \[4, 5, 6]])   sum = np.sum(array)  # Suma total   print(sum)   **Resultado:** 21 mean = np.mean(array)  # Promedio   print(mean)   **Resultado:** 3.5 std = np.std(array)  # Desviación estándar   print(std)   **Resultado:** 1.707825127659933
La 'd' en `dtype` se utiliza para indicar que el tipo de dato es un número de punto flotante de 64 bits (`float64`). En NumPy, los tipos de datos son fundamentales para optimizar el rendimiento en operaciones matemáticas y estadísticas. Al especificar `dtype='d'`, se asegura que los cálculos se realicen con la mayor precisión posible, lo que es esencial en análisis de datos y procesamiento de información compleja. Utilizar el tipo de dato adecuado puede mejorar la eficiencia y disminuye el uso de memoria.
los arrays tienen ya implementadas operaciones vectoriales como el producto punto la inversion de matrices la trasnpuesta etc, donde las listas no.
Usamos arrays ya que las listas no están optimizadas para operaciones matemáticas, mientras que un array si, un ejemplo es que para aplicar operaciones a una lista debemos recorrerla con un bucle, lo que puede ser mas lento. Usamos listas cuando necesitamos almacenar datos heterogéneos. usamos arrays si tenemos datos numericos homogeneos y queremos aplicar operaciones matematicas
Les recomiendo ampliamente usar VSCode ya que Google Collab no es muy intuitivo como editor de código, incluso la profesora le batalla para encontrar los errores.
La profe dice que "Un **array** en Numpy es una estructura de datos homogénea organizada en una o más dimensiones". **Pregunto**: ¿la dimensión cero (escalar) también hace parte de la definición de un array? Ver el siguiente código... `dim_cero = np.array(5) ` `print (dim_cero.ndim)`
Cuando inicie con phyton lo que mas se me dificulto fue entender cuando se utilizan listas o diccionarios, ahora viendo estos objetos llamados array me parece que son mas sencillos y se facilita mucho el codigo
Diferencias de Listas y Arrays * **Rendimiento**: Los arrays de NumPy consumen menos recursos computacionales haciedo más eficiente operaciones estadísticas y matemáticas avanzadas que las listas de Python. Los arrays de NumPy pueden representar imágenes, sonidos y realizar el análisis y procesamiento de datos complejos. * **Homogeneidad**: NumPy requiere homogeneidad de tipos, en cambio las listas de Python pueden contener múltiples tipos. * **Instancias**: Los arrays al ser instancias que pertenecen a una clase, facilitan el acceso y manejo de sus atributos.
**Listas de Python vs Arrays de Numpy** * Las listas de Python son una estructura de datos orientada a la programación en general. Nos proporcionan la flexibilidad de trabajar con distintos tipos de datos y manipular su estructura añadiendo o quitando elementos. Sin embargo, no son eficientes para operaciones numéricas avanzadas debido a su naturaleza heterogénea y la sobrecarga de operaciones en comparación con estructuras optimizadas. * En cambio, los arrays de NumPy son estructuras menos flexibles, ya que solo permiten un único tipo de dato en ellas. Están diseñados específicamente para el análisis numérico, permitiendo realizar operaciones matemáticas, estadísticas y vectoriales con mucha mayor eficiencia, incluso con grandes volúmenes de datos. Su eficiencia proviene de su implementación optimizada y el soporte para operaciones vectorizadas.
lo de la decisión standard como se obtiene?? porque da 1.70 <https://github.com/iecgerman/python-numpy-pandas>
![]()![](https://static.platzi.com/media/user_upload/image-32fc9716-5650-49ee-b7d8-213709b21a6b.jpg)
CUA CUA CUAAAA, POR MIENTRAS A SEGUIRLE CON PBI QUE LO DEJE A MEDIAS ![](https://static.platzi.com/media/user_upload/image-256e0a12-55d4-4960-8a00-f6af7aa8ed7e.jpg)
De Chapi: En Python, tanto las listas como los arrays se utilizan para almacenar colecciones de datos, pero tienen diferencias clave: \### Listas 1\. \*\*Definición\*\*: \- Las listas se definen usando corchetes `\[]`. \- Ejemplo: `mi\_lista = \[1, 2, 3, 4, 5]`. 2\. \*\*Tipo de Elementos\*\*: \- Pueden contener elementos de diferentes tipos (enteros, cadenas, otros objetos, etc.). \- Ejemplo: `\[1, 'texto', 3.14]`. 3\. \*\*Métodos\*\*: \- Tienen métodos incorporados como `append()`, `remove()`, `extend()`, etc. 4\. \*\*Uso\*\*: \- Son más flexibles y adecuadas para operaciones generales que no requieren manipulación matemática o científica avanzada. 5\. \*\*Implementación\*\*: \- Son parte del lenguaje Python y están implementadas en C. \### Arrays 1\. \*\*Definición\*\*: \- Los arrays en Python se definen a través del módulo `array` o utilizando bibliotecas externas como `numpy`. \- Ejemplo (módulo `array`): `import array; mi\_array = array.array('i', \[1, 2, 3, 4, 5])`. 2\. \*\*Tipo de Elementos\*\*: \- En el módulo `array`, los elementos deben ser del mismo tipo, definido por un código de tipo (como `'i'` para enteros). \- En `numpy`, los arrays también pueden ser multidimensionales y contener tipos de datos específicos. 3\. \*\*Métodos\*\*: \- Ofrecen métodos específicos para operaciones matemáticas y científicas, especialmente en `numpy`. 4\. \*\*Uso\*\*: \- Son más eficientes para operaciones matemáticas y procesamiento de datos científicos, especialmente cuando se manejan grandes volúmenes de datos. 5\. \*\*Implementación\*\*: \- `array` es parte de la biblioteca estándar de Python, mientras que `numpy` es una biblioteca externa que debe ser instalada. \### Ejemplos de Código \- \*\*Lista\*\*: ```python mi\_lista = \[1, 2, 3, 'texto'] mi\_lista.append(4) # Agrega un elemento print(mi\_lista\[0]) # Accede al primer elemento ``` \- \*\*Array con `array`\*\*: ```python import array mi\_array = array.array('i', \[1, 2, 3, 4, 5]) mi\_array.append(6) print(mi\_array\[0]) # Accede al primer elemento ``` \- \*\*Array con `numpy`\*\*: ```python import numpy as np mi\_array\_np = np.array(\[1, 2, 3, 4, 5]) mi\_array\_np = mi\_array\_np \* 2 # Multiplica todos los elementos por 2 print(mi\_array\_np\[0]) # Accede al primer elemento ``` En resumen, elige listas para flexibilidad general y arrays (especialmente con `numpy`) para operaciones matemáticas o científicas más eficientes.