9.

Números aleatorios y simulaciones

NumPy ofrece el submódulo [Link] , con el que podemos generar números aleatorios
simples, arrays completos y muestras de distribuciones estadísticas muy utilizadas.

9.1 Generación de números aleatorios ( [Link] )

Existen múltiples formas de generar números aleatorios:

a) Un número aleatorio entre 0 y 1 ( [Link] )

import numpy as np

print("Número aleatorio [0,1):", [Link]())

b) Array de números aleatorios ( rand )

print("Array 1D:", [Link](5)) # 5 números aleatorios

print("Matriz 2D:\n", [Link](2, 3)) # Matriz 2x3

c) Enteros aleatorios ( randint )

print("Enteros aleatorios:", [Link](1, 10, size=5))

# 5 números entre 1 y 9

9.2 Distribuciones comunes

NumPy permite simular distribuciones estadísticas.

a) Distribución uniforme ( [Link] )

Genera valores entre un rango [a, b) con probabilidad uniforme.

arr = [Link](0, 10, size=5)

print("Distribución uniforme [0,10):", arr)

b) Distribución normal o gaussiana ( [Link] )

Muy utilizada en estadística y machine learning.

arr = [Link](loc=0, scale=1, size=10)

print("Distribución normal (media=0, std=1):", arr)
👉 loc es la media; scale , la desviación estándar.
c) Distribución binomial ( [Link] )

Se usa para experimentos “sí/no” (Bernoulli).

# Simulación: 10 experimentos, probabilidad de éxito 0.5, repetido 5 veces

arr = [Link](n=10, p=0.5, size=5)
print("Distribución binomial:", arr)

👉 Ejemplo típico: lanzar una moneda 10 veces y contar cuántas veces salió cara.
9.3 Fijar semillas ( [Link] )
Sin semilla, cada ejecución produce valores distintos. Para reproducir resultados, fijamos una
semilla.

[Link](42)

print("Con semilla fija:", [Link](1, 100, 5))

Salida (repetible):

Con semilla fija: [52 93 15 72 61]

👉 Es clave para experimentar y comparar modelos de forma justa.

Resumen
[Link]() : números aleatorios en [0,1) .

[Link](a, b, size) : enteros aleatorios.

[Link](a, b, size) : distribución uniforme.

[Link](media, std, size) : distribución normal.

[Link](n, p, size) : distribución binomial.

[Link](valor) : fija la semilla para reproducibilidad.

Nota: Estas herramientas permiten crear simulaciones, experimentos y pruebas controladas en

proyectos de ciencia de datos.
10. Integración con otras librerías

NumPy es la base de la mayoría de las librerías de ciencia de datos y machine

learning en Python. Aquí vemos cómo se integra con Pandas y Matplotlib, y cómo
convertir arrays en listas y viceversa.

10.1 Uso de arrays de NumPy en Pandas

Pandas se apoya en NumPy para manejar Series y DataFrames.

a) Crear una Serie a partir de un array

import numpy as np
import pandas as pd

arr = [Link]([10, 20, 30, 40, 50])

serie = [Link](arr, index=["a", "b", "c", "d", "e"])

print("Serie de Pandas:\n", serie)

Salida:

Serie de Pandas:
a 10
b 20
c 30
d 40
e 50
dtype: int32

b) Crear un DataFrame a partir de un array

mat = [Link]([[1, 2, 3],

[4, 5, 6],
[7, 8, 9]])

df = [Link](mat, columns=["Col1", "Col2", "Col3"])

print("DataFrame de Pandas:\n", df)

Salida:
DataFrame de Pandas:
Col1 Col2 Col3
0 1 2 3
1 4 5 6
2 7 8 9

👉 Gracias a NumPy, Pandas manipula grandes volúmenes de datos con

eficiencia.

10.2 Uso de arrays de NumPy en Matplotlib

Matplotlib utiliza arrays de NumPy para construir gráficos.

a) Graficar una función matemática

import [Link] as plt

# Generamos datos con NumPy

x = [Link](0, 10, 100)
y = [Link](x)

# Gráfico
[Link](x, y, label="sin(x)", color="blue")
[Link]("Ejemplo con NumPy + Matplotlib")
[Link]("x")
[Link]("y")
[Link]()
[Link]()

👉 Los arrays de NumPy permiten calcular los valores que luego se visualizan.
b) Graficar datos aleatorios

[Link](0)
data = [Link](0, 1, 1000)

[Link](data, bins=30, color="orange", edgecolor="black")

[Link]("Histograma de distribución normal")
[Link]()

👉 NumPy genera los datos y Matplotlib los representa.

10.3 Conversión entre arrays y listas
Es común convertir entre arrays de NumPy y listas nativas.

a) De array a lista ( .tolist() )

 arr = [Link]([1, 2, 3, 4, 5])
lista = [Link]()

print("Array:", arr)
print("Convertido a lista:", lista)

Salida:

Array: [1 2 3 4 5]
Convertido a lista: [1, 2, 3, 4, 5]

b) De lista a array ( [Link] )

lista = [10, 20, 30, 40]

arr = [Link](lista)

print("Lista:", lista)
print("Convertida a array:", arr)

Salida:

Lista: [10, 20, 30, 40]

Convertida a array: [10 20 30 40]

👉 Esta conversión es clave cuando importamos datos externos (JSON, CSV) que
llegan como listas.

Resumen
Pandas: los arrays de NumPy son la base de Series y DataFrames.

Matplotlib: usa arrays de NumPy para graficar funciones y distribuciones.

Conversión: .tolist() (array → lista) y [Link](lista) (lista → array).

Nota: Integrar NumPy con estas librerías es fundamental para flujos de ciencia de
datos profesionales.
11. Buenas prácticas y optimización

NumPy está pensado para eficiencia y velocidad. Aprovecha implementaciones en C y Fortran para operar con arrays
multidimensionales de manera óptima. Veamos cómo sacarle el máximo provecho.

11.1 Ventajas de los arrays sobre listas en eficiencia

Las listas de Python son flexibles, pero no están optimizadas para cálculos matemáticos masivos.

a) Ejemplo con listas

# Sumar 2 a cada elemento de una lista

lista = [i for i in range(1_000_000)]
nueva_lista = [x + 2 for x in lista]

👉 Python itera elemento por elemento: lento con millones de datos.

b) Ejemplo con arrays

import numpy as np

arr = [Link](1_000_000)
nuevo_arr = arr + 2

👉 Con NumPy no usamos bucles explícitos, la operación se ejecuta en código compilado y los arrays homogéneos
usan menos memoria. Resultado: decenas o cientos de veces más rápido.

11.2 Vectorización y evitar bucles

La vectorización aplica operaciones sobre arrays completos, reemplazando bucles en Python.

a) Con bucle (ineficiente)

valores = [1, 2, 3, 4, 5]
cuadrados = []
for v in valores:
[Link](v ** 2)
print(cuadrados) # [1, 4, 9, 16, 25]

b) Vectorizado con NumPy (eficiente)

arr = [Link]([1, 2, 3, 4, 5])

print(arr ** 2) # [ 1 4 9 16 25]

👉 El array entero se eleva al cuadrado en una sola operación.

c) Ejemplo: normalizar datos

# Lista en Python
lista = [10, 20, 30, 40, 50]
media = sum(lista) / len(lista)
desvio = (sum((x - media) ** 2 for x in lista) / len(lista)) ** 0.5
normalizada = [(x - media) / desvio for x in lista]
print(normalizada)
Con NumPy:

arr = [Link]([10, 20, 30, 40, 50])

normalizada = (arr - [Link]()) / [Link]()
print(normalizada)

👉 Más simple, legible y rápido.

11.3 Uso de funciones universales (ufuncs)
Las ufuncs son funciones optimizadas que operan elemento a
elemento: [Link] , [Link] , [Link] , [Link] , [Link] , [Link] , [Link] , entre otras.

a) Ejemplo con suma y multiplicación

a = [Link]([1, 2, 3])
b = [Link]([4, 5, 6])

print([Link](a, b)) # [5 7 9]
print([Link](a, b)) # [ 4 10 18]

b) Funciones matemáticas

arr = [Link]([1, 2, 3, 4])

print("Raíz cuadrada:", [Link](arr)) # [1. 1.41421356 1.73205081 2. ]

print("Exponencial:", [Link](arr)) # [ 2.71828183 7.3890561 20.08553692 54.59815003]
print("Logaritmo:", [Link](arr)) # [0. 0.69314718 1.09861229 1.38629436]

c) Ventaja frente a funciones estándar

import math

# Con math (lento, bucle explícito)

lista = [1, 2, 3, 4]
raices = [[Link](x) for x in lista]

# Con NumPy (rápido, vectorizado)

arr = [Link]([1, 2, 3, 4])
raices_np = [Link](arr)

👉 La versión con NumPy es mucho más veloz y clara.

Resumen
Los arrays de NumPy son más rápidos y eficientes que las listas de Python.

La vectorización reemplaza bucles con operaciones directas sobre arrays.

Las ufuncs operan elemento a elemento con alto rendimiento.

Nota: Dominar estas prácticas es clave para manejar grandes volúmenes de datos en ciencia de datos y machine
learning.
12. Ejercicios prácticos con NumPy

Estos ejercicios te ayudan a afianzar los conceptos vistos a lo largo del tutorial de NumPy.

12.1 Operaciones básicas con arrays

Ejercicio 1: Crear un array con los números del 1 al 10 y calcular el array al cuadrado, la suma total y la media.

import numpy as np

arr = [Link](1, 11)

print("Array:", arr)

# Array al cuadrado
print("Cuadrados:", arr ** 2)

# Suma total
print("Suma:", [Link]())

# Media
print("Media:", [Link]())

Salida:

Array: [ 1 2 3 4 5 6 7 8 9 10]
Cuadrados: [ 1 4 9 16 25 36 49 64 81 100]
Suma: 55
Media: 5.5

12.2 Creación de matrices y manipulación

Ejercicio 2: Crear una matriz 3x3 con valores del 1 al 9 y realizar:

Transpuesta de la matriz.

Sumas por filas y por columnas.

Extraer la segunda columna.

mat = [Link](1, 10).reshape(3, 3)

print("Matriz:\n", mat)

# Transpuesta
print("Transpuesta:\n", mat.T)

# Suma por filas (axis=1)

print("Suma por filas:", [Link](axis=1))

# Suma por columnas (axis=0)

print("Suma por columnas:", [Link](axis=0))

# Segunda columna
print("Segunda columna:", mat[:, 1])

Salida:

Matriz:
[[1 2 3]
[4 5 6]
[7 8 9]]
Transpuesta:
[[1 4 7]
 [2 5 8]
[3 6 9]]
Suma por filas: [ 6 15 24]
Suma por columnas: [12 15 18]
Segunda columna: [2 5 8]

12.3 Mini proyecto: análisis estadístico

Simula un dataset de calificaciones de 30 estudiantes.

1. Generar puntajes aleatorios (0 a 100).

2. Calcular mínimo, máximo, media, mediana y desviación estándar.
3. Clasificar entre “Aprobado” (≥60) y “Desaprobado” (<60).
4. Contar cuántos aprobaron y cuántos desaprobaron.

[Link](42) # Reproducibilidad
notas = [Link](0, 101, size=30)
print("Notas de los estudiantes:\n", notas)

print("Nota mínima:", [Link]())

print("Nota máxima:", [Link]())
print("Media:", [Link]())
print("Mediana:", [Link](notas))
print("Desviación estándar:", [Link]())

clasificacion = [Link](notas >= 60, "Aprobado", "Desaprobado")

print("Clasificación:\n", clasificacion)

aprobados = [Link](notas >= 60)

desaprobados = [Link](notas < 60)

print("Cantidad de aprobados:", aprobados)

print("Cantidad de desaprobados:", desaprobados)

Ejemplo de salida:

Notas de los estudiantes:

[51 92 14 71 60 20 82 86 74 74 87 99 23 2 21 52 1 87 29 37 1 63 59 20 32 75 57 21 88 48]
Nota mínima: 1
Nota máxima: 99
Media: 53.1
Mediana: 57.5
Desviación estándar: 28.29
Clasificación:
['Desaprobado' 'Aprobado' 'Desaprobado' 'Aprobado' 'Aprobado' ... ]
Cantidad de aprobados: 14
Cantidad de desaprobados: 16

Resumen
Practicaste operaciones básicas (suma, media, potencias).

Manipulaste matrices (transposición, slicing, sumas por ejes).

Implementaste un mini análisis estadístico simulando datos reales.

Nota: Con esto completás el tutorial práctico de NumPy, desde fundamentos hasta aplicaciones reales en ciencia de
datos.