1.

¿Qué librerías en Python se utilizan comúnmente para

generar gráficos de línea 2D?

Las librerías comunes en Python para generar gráficos de línea 2D son

Matplotlib, Seaborn y Plotly.

2. ¿Cómo se crea una figura y un eje en Matplotlib para dibujar

un gráfico de línea?

Para crear una figura y un eje en Matplotlib, se utilizan los métodos

plt.figure() para crear la figura y plt.gca() para obtener el eje actual.
Ejemplo:

python
Copiar código
import matplotlib.pyplot as plt
fig, ax = plt.subplots()

3. ¿Cuál es la diferencia entre plt.plot() y plt.show() en

Matplotlib?

plt.plot() se utiliza para crear y trazar un gráfico de línea en el eje

actual, mientras que plt.show() se utiliza para mostrar el gráfico en una
ventana emergente. plt.show() debe llamarse después de plt.plot()
para visualizar el gráfico.

4. Explica cómo puedes añadir un título y etiquetas a los ejes

en un gráfico de línea utilizando Matplotlib.

Para añadir un título y etiquetas a los ejes en Matplotlib, se utilizan los

métodos set_title(), set_xlabel(), y set_ylabel() del objeto de los
ejes. Ejemplo:

python
Copiar código
ax.set_title('Título del gráfico')
ax.set_xlabel('Etiqueta del eje x')
ax.set_ylabel('Etiqueta del eje y')

5. ¿Qué método se utiliza para agregar una leyenda a un

gráfico de línea en Matplotlib?
Se utiliza el método legend() para agregar una leyenda a un gráfico de
línea en Matplotlib. Puedes pasar una lista de etiquetas a legend() para
identificar las distintas líneas.

6. Describe el uso de plt.grid(True) en un gráfico de línea.

El método plt.grid(True) se utiliza para añadir una cuadrícula al fondo

del gráfico, lo que facilita la visualización y la comparación de los datos. Al
establecerlo en True, se activa la visualización de la cuadrícula.

7. ¿Cómo puedes cambiar el estilo de las líneas (por ejemplo,

guiones, puntos) en un gráfico de línea? Proporciona un
ejemplo.

Puedes cambiar el estilo de las líneas usando el parámetro linestyle en

plt.plot(). Ejemplo:

python
Copiar código
plt.plot(x, y, linestyle='--') # Línea discontinua
plt.plot(x, y, linestyle=':') # Línea de puntos

8. ¿Cómo se puede modificar el color de las líneas en un gráfico

2D? Menciona dos maneras de hacerlo.

Puedes modificar el color de las líneas utilizando el parámetro color en

plt.plot(). Dos maneras de hacerlo son:

python
Copiar código
plt.plot(x, y, color='red') # Usando un nombre de color
plt.plot(x, y, color='#FF0000') # Usando un código
hexadecimal

9. Explica cómo se puede agregar un marcador a los puntos en

un gráfico de línea.

Puedes agregar un marcador a los puntos en un gráfico de línea utilizando

el parámetro marker en plt.plot(). Ejemplo:

python
Copiar código
plt.plot(x, y, marker='o') # Marcadores en forma de círculo
 10. ¿Qué función en Matplotlib permite guardar un gráfico
de línea como un archivo de imagen? ¿Cuáles son los
formatos soportados?

La función savefig() permite guardar un gráfico de línea como un

archivo de imagen. Los formatos soportados incluyen PNG, PDF, SVG y
EPS. Ejemplo:

python
Copiar código
plt.savefig('grafico.png')

11. ¿Cómo puedes crear múltiples gráficos de línea en la

misma figura? Explica con un ejemplo.

Puedes crear múltiples gráficos de línea en la misma figura utilizando

plt.plot() varias veces antes de llamar a plt.show(). Ejemplo:

python
Copiar código
plt.plot(x1, y1, label='Línea 1')
plt.plot(x2, y2, label='Línea 2')
plt.legend()
plt.show()

12. ¿Qué es un gráfico de líneas con múltiples ejes y cómo

se puede crear en Matplotlib?

Un gráfico de líneas con múltiples ejes muestra datos en diferentes ejes Y

sobre un mismo eje X. Puedes crearlo usando twinx() o twiny().
Ejemplo:

python
Copiar código
fig, ax1 = plt.subplots()
ax2 = ax1.twinx()
ax1.plot(x, y1, 'g-')
ax2.plot(x, y2, 'b-')

13. Describe cómo utilizar plt.xlim() y plt.ylim() para

ajustar los límites de los ejes en un gráfico de línea.
plt.xlim() y plt.ylim() se utilizan para ajustar los límites de los ejes X
e Y, respectivamente. Ejemplo:

python
Copiar código
plt.xlim(0, 10) # Ajusta el límite del eje X de 0 a 10
plt.ylim(-5, 5) # Ajusta el límite del eje Y de -5 a 5

14. ¿Qué función se utiliza para añadir anotaciones en

puntos específicos de un gráfico de línea?

La función annotate() se utiliza para añadir anotaciones en puntos

específicos del gráfico. Ejemplo:

python
Copiar código
plt.annotate('Anotación', xy=(x, y), xytext=(x + 1, y + 1),
arrowprops=dict(facecolor='black', shrink=0.05))

15. ¿Cómo puedes crear un gráfico de línea suave

utilizando interpolación o splines en Python? Menciona las
librerías necesarias.

Puedes crear un gráfico de línea suave utilizando interpolación o splines

con la librería scipy para interpolación y numpy para manejar los datos.
Ejemplo:

python
Copiar código
from scipy.interpolate import make_interp_spline
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 10, 10)

y = np.sin(x)
xnew = np.linspace(0, 10, 300)
spl = make_interp_spline(x, y, k=3)
ynew = spl(xnew)

plt.plot(xnew, ynew)
plt.show()
PARTE PRACTICA

1-

import numpy as np

def derivada_diferencias_finitas(f, xo, precision=1e-5):

h = 1.0

derivada_estimada = (f(xo + h) - f(xo)) / h

while h > precision:

nueva_h = h / 2

nueva_derivada = (f(xo + nueva_h) - f(xo)) / nueva_h

if abs(nueva_derivada - derivada_estimada) < precision:

break

h = nueva_h

derivada_estimada = nueva_derivada

return derivada_estimada

# Definición del polinomio

coef = [1, -3, 2] # Ejemplo: f(x) = x^2 - 3x + 2

f = np.poly1d(coef)

xo = 1.5

precision = 1e-6

resultado = derivada_diferencias_finitas(f, xo, precision)

print(f"Derivada estimada en x = {xo}: {resultado}")

2-

import numpy as np

def integral_trapecio(f, a, b, n):

h = (b - a) / n

suma = 0.5 * (f(a) + f(b)) # Condicional para sumar extremos

for i in range(1, n):

suma += f(a + i * h)

return h * suma

# Definición del polinomio

coef = [1, -3, 2] # Ejemplo: f(x) = x^2 - 3x + 2

f = np.poly1d(coef)

a, b = 0, 3

n = 1000

resultado = integral_trapecio(f, a, b, n)

print(f"Integral estimada de {a} a {b}: {resultado}")

3-

import numpy as np

def newton_raphson(f, df, xo, tol=1e-6, max_iter=100):

x = xo

for i in range(max_iter):

fx = f(x)

dfx = df(x)

if abs(fx) < tol: # Si la función es suficientemente cercana a cero

return x

x -= fx / dfx # Método de Newton-Raphson

return x

# Definición del polinomio

coef = [1, -3, 2] # f(x) = x^2 - 3x + 2

f = np.poly1d(coef)

df = f.deriv()

xo = 2.5

raiz = newton_raphson(f, df, xo)

print(f"Raíz estimada: {raiz}")

4-

import numpy as np

def biseccion(f, a, b, tol=1e-6, max_iter=100):

if f(a) * f(b) > 0:

raise ValueError("No hay cambio de signo en el intervalo dado")

for _ in range(max_iter):

c = (a + b) / 2

if abs(f(c)) < tol:

return c

if f(a) * f(c) < 0:

b=c

else:

a=c

return c

# Definición del polinomio

coef = [1, -3, 2] # f(x) = x^2 - 3x + 2

f = np.poly1d(coef)

a, b = 0, 3

raiz = biseccion(f, a, b)

print(f"Raíz estimada: {raiz}")

5-

import numpy as np

def dft(x):

N = len(x)

X = np.zeros(N, dtype=complex)

for k in range(N):

for n in range(N):

X[k] += x[n] * np.exp(-2j * np.pi * k * n / N)

return X

# Datos de ejemplo (señal)

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

# Aplicar la DFT

resultado_dft = dft(datos)

print(f"Transformada de Fourier Discreta: {resultado_dft}")

6-

import numpy as np

def matrix_product(A, B):

# Verificar si las matrices pueden multiplicarse (n x m) * (m x p)

if A.shape[1] != B.shape[0]:

raise ValueError("Las matrices no tienen dimensiones compatibles

para la multiplicación.")

# Crear matriz de resultado con ceros

result = np.zeros((A.shape[0], B.shape[1]))

# Iterar sobre las matrices y realizar la multiplicación

for i in range(A.shape[0]):

for j in range(B.shape[1]):

for k in range(A.shape[1]):

result[i, j] += A[i, k] * B[k, j]

return result
7-

import numpy as np

def LU_decomposition(A):

n = A.shape[0]

# Inicializar matrices L y U

L = np.eye(n)

U = A.copy()

# Iterar sobre cada columna para la factorización LU

for i in range(n):

if U[i, i] == 0:

raise ValueError("La matriz no puede descomponerse mediante LU

(división por cero).")

for j in range(i+1, n):

factor = U[j, i] / U[i, i]

L[j, i] = factor

U[j] -= factor * U[i]

return L, U

# Ejemplo

A = np.array([[4, 3], [6, 3]])

L, U = LU_decomposition(A)

print("L:\n", L)

print("U:\n", U)
8-

import numpy as np

def gauss_seidel(A, b, tol=1e-10, max_iter=1000):

n = len(b)

x = np.zeros(n)

for it in range(max_iter):

x_new = np.copy(x)

for i in range(n):

sum1 = np.dot(A[i, :i], x_new[:i])

sum2 = np.dot(A[i, i+1:], x[i+1:])

x_new[i] = (b[i] - sum1 - sum2) / A[i, i]

# Verificar la convergencia

if np.linalg.norm(x_new - x, ord=np.inf) < tol:

return x_new

x = x_new

raise ValueError("El método no converge después de {}

iteraciones".format(max_iter))
9-

import numpy as np

def determinant(A):

n = A.shape[0]

# Caso base para matrices 2x2

if n == 2:

return A[0, 0] * A[1, 1] - A[0, 1] * A[1, 0]

det = 0

for c in range(n):

# Submatriz al eliminar la primera fila y la columna c

submatrix = np.delete(np.delete(A, 0, axis=0), c, axis=1)

cofactor = ((-1) ** c) * A[0, c] * determinant(submatrix)

det += cofactor

return det
10-

import numpy as np

def gauss_jordan_inverse(A):

n = A.shape[0]

# Crear la matriz identidad

I = np.eye(n)

# Concatenar A con la identidad

augmented_matrix = np.hstack([A, I])

for i in range(n):

if augmented_matrix[i, i] == 0:

raise ValueError("Matriz singular, no tiene inversa.")

# Normalizar la fila i

augmented_matrix[i] /= augmented_matrix[i, i]

# Eliminar los elementos de las demás filas en la columna i

for j in range(n):

if i != j:

augmented_matrix[j] -= augmented_matrix[j, i] *
augmented_matrix[i]

# La parte derecha de la matriz aumentada es la inversa

inverse = augmented_matrix[:, n:]

return inverse
11-

import numpy as np

def taylor_sine(x, terms=10):

sine = 0

for n in range(terms):

term = ((-1)**n) * (x**(2*n+1)) / np.math.factorial(2*n+1)

sine += term

if abs(term) < 1e-10: # Umbral de precisión

break

return sine

def taylor_cosine(x, terms=10):

cosine = 0

for n in range(terms):

term = ((-1)**n) * (x**(2*n)) / np.math.factorial(2*n)

cosine += term

if abs(term) < 1e-10: # Umbral de precisión

break

return cosine

x = np.pi / 3 # 60 grados

print(f"Seno({x}) usando Taylor: {taylor_sine(x)}")

print(f"Coseno({x}) usando Taylor: {taylor_cosine(x)}")

12-

import numpy as np

def verify_trig_identity(x):

seno = np.sin(x)

cos = np.cos(x)

identity = seno**2 + cos**2

if np.isclose(identity, 1):

print(f"La identidad es válida para x = {x}")

else:

print(f"La identidad no es válida para x = {x}")

x = np.pi / 4 # 45 grados

verify_trig_identity(x)
13-

import numpy as np

import matplotlib.pyplot as plt

def plot_trig_functions(resolution=1000):

x = np.linspace(-2 * np.pi, 2 * np.pi, resolution)

sine = np.sin(x)

cosine = np.cos(x)

plt.plot(x, sine, label='Seno')

plt.plot(x, cosine, label='Coseno')

plt.xlabel('x')

plt.ylabel('y')

plt.title('Funciones Trigonométricas: Seno y Coseno')

plt.axhline(0, color='black',linewidth=0.5)

plt.axvline(0, color='black',linewidth=0.5)

plt.legend()

plt.grid(True)

plt.show()

plot_trig_functions()
14-

import math

def c_p(x, y):

r = math.sqrt(x**2 + y**2)

teta = math.atan2(y, x) # Ángulo en radianes

teta_deg = math.degrees(teta)

return r, teta_deg

def p_to_c(r, teta_deg):

theta = math.radians(theta_deg)

x = r * math.cos(theta)

y = r * math.sin(theta)

return x, y
15-

import math

def leydesenos(a=None, A=None, b=None, B=None, c=None, C=None):

if a and A and B:

b = a * math.sin(math.radians(B)) / math.sin(math.radians(A))

return b

elif a and A and C:

c = a * math.sin(math.radians(C)) / math.sin(math.radians(A))

return c

else:

return None

def leydecosenos(a=None, b=None, c=None, A=None, B=None, C=None):

if a and b and C:

c = math.sqrt(a**2 + b**2 - 2 * a * b * math.cos(math.radians(C)))

return c

elif a and b and c:

C = math.degrees(math.acos((a**2 + b**2 - c**2) / (2 * a * b)))

return C

else:

return None
16-

import numpy as np

import matplotlib.pyplot as plt

def rlc_series_response(R, L, C, f_start, f_stop, steps):

f = np.linspace(f_start, f_stop, steps)

w = 2 * np.pi * f

Z = np.sqrt(R**2 + (w*L - 1/(w*C))**2)

H=1/Z

# Frecuencia resonante

f_resonant = 1 / (2 * np.pi * np.sqrt(L * C))

# Graficar respuesta en frecuencia

plt.plot(f, H)

plt.axvline(f_resonant, color='r', linestyle='--', label=f'Resonante:

{f_resonant:.2f} Hz')

plt.xlabel('Frecuencia (Hz)')

plt.ylabel('Respuesta |H(f)|')

plt.title('Respuesta en frecuencia de un circuito RLC serie')

plt.legend()

plt.grid(True)

plt.show()
17-

def power_calculation(V, I, phi):

# Potencia activa (W)

P = V * I * math.cos(math.radians(phi))

# Potencia reactiva (VAR)

Q = V * I * math.sin(math.radians(phi))

# Potencia aparente (VA)

S=V*I

return {"Potencia Activa": P, "Potencia Reactiva": Q, "Potencia

Aparente": S}
18-

import numpy as np

import matplotlib.pyplot as plt

def moving_average_filter(signal, window_size):

filtered_signal = np.convolve(signal,
np.ones(window_size)/window_size, mode='valid')

return filtered_signal

def adaptive_filter(signal, sampling_rate):

if sampling_rate > 1000:

window_size = 100

else:

window_size = 50

filtered_signal = moving_average_filter(signal, window_size)

return filtered_signal

# Señal de ejemplo

t = np.linspace(0, 1, 500)

signal = np.sin(2 * np.pi * 50 * t) + 0.5 * np.random.randn(500)

# Filtro

filtered_signal = adaptive_filter(signal, 1200)

# Graficar señal original y filtrada

plt.plot(t, signal, label="Original")

plt.plot(t[:len(filtered_signal)], filtered_signal, label="Filtrada")

plt.legend()

plt.show()
19-

import numpy as np

import matplotlib.pyplot as plt

def fourier_transform(signal, sample_rate):

N = len(signal)

T = 1 / sample_rate

yf = np.fft.fft(signal)

xf = np.fft.fftfreq(N, T)[:N//2]

return xf, np.abs(yf[:N//2])

def filter_frequency(signal, sample_rate, cutoff):

xf, yf = fourier_transform(signal, sample_rate)

yf_filtered = np.where(xf > cutoff, 0, yf)

return xf, yf_filtered

# Ejemplo de señal

sample_rate = 1000

t = np.linspace(0.0, 1.0, sample_rate)

signal = np.sin(50.0 * 2.0 * np.pi * t) + 0.5 * np.sin(80.0 * 2.0 * np.pi * t)

xf, yf = filter_frequency(signal, sample_rate, 60)

# Graficar la señal transformada

plt.plot(xf, yf)

plt.grid()

plt.show()
20-

import numpy as np

import matplotlib.pyplot as plt

def lc_oscillator(L, C, initial_charge, initial_current, dt, t_max):

t = np.arange(0, t_max, dt)

charge = np.zeros(len(t))

current = np.zeros(len(t))

charge[0] = initial_charge

current[0] = initial_current

for i in range(1, len(t)):

current[i] = current[i-1] - (dt / L) * charge[i-1]

charge[i] = charge[i-1] + (dt / C) * current[i-1]

return t, charge, current

# Parámetros del oscilador

L = 0.001 # Henrys

C = 0.01 # Farads

initial_charge = 1 # Coulombs

initial_current = 0 # Amperes

dt = 0.001

t_max = 1

# Simulación

t, charge, current = lc_oscillator(L, C, initial_charge, initial_current, dt,

t_max)
# Graficar resultados

plt.plot(t, charge, label="Carga (C)")

plt.plot(t, current, label="Corriente (A)")

plt.legend()

plt.xlabel("Tiempo (s)")

plt.ylabel("Amplitud")

plt.title("Simulación del oscilador LC")

plt.grid(True)

plt.show()
21-

import numpy as np

import matplotlib.pyplot as plt

# Parámetros del proyectil

v0 = 20 # Velocidad inicial (m/s)

theta = np.radians(45) # Ángulo de lanzamiento (grados a radianes)

g = 9.81 # Aceleración debido a la gravedad (m/s^2)

# Componentes de la velocidad inicial

vx0 = v0 * np.cos(theta)

vy0 = v0 * np.sin(theta)

# Tiempo máximo de vuelo

t_max = 2 * vy0 / g

# Tiempo de simulación

t = np.linspace(0, t_max, num=500)

# Trayectoria

x = vx0 * t

y = vy0 * t - 0.5 * g * t**2

# Detección de impacto con el suelo

y = np.maximum(0, y)

# Graficar

plt.plot(x, y)

plt.title('Movimiento Parabólico de un Proyectil')

plt.xlabel('Distancia (m)')

plt.ylabel('Altura (m)')

plt.grid(True)

plt.show()
22-

import math

# Función para calcular energía cinética

def energia_cinetica(masa, velocidad):

return 0.5 * masa * velocidad**2

# Función para calcular energía potencial

def energia_potencial(masa, altura, g=9.81):

return masa * g * altura

# Parámetros del objeto

masa = 5.0 # kg

velocidad = 10.0 # m/s

altura = 20.0 # m

# Cálculo de energías

if velocidad > 0:

Ec = energia_cinetica(masa, velocidad)

print(f"Energía cinética: {Ec} J")

else:

Ec = 0

if altura > 0:

Ep = energia_potencial(masa, altura)

print(f"Energía potencial: {Ep} J")

else:

Ep = 0
23-

import math

# Constante de Coulomb

k = 8.99e9 # Nm²/C²

# Función para calcular la fuerza entre dos cargas

def fuerza_coulomb(q1, q2, r):

return k * abs(q1 * q2) / r**2

# Parámetros de las cargas

q1 = 1e-6 # Carga 1 en C

q2 = -1e-6 # Carga 2 en C

r = 0.05 # Distancia entre las cargas en metros

# Cálculo de la fuerza

if q1 == q2:

print("Las cargas son iguales, la fuerza es repulsiva.")

else:

print("Las cargas son diferentes, la fuerza es atractiva.")

fuerza = fuerza_coulomb(q1, q2, r)

print(f"La fuerza entre las cargas es {fuerza} N")

24-

import numpy as np

import matplotlib.pyplot as plt

# Parámetros del péndulo

g = 9.81 # Gravedad (m/s^2)

longitud = 1.0 # Longitud del péndulo (m)

theta0 = np.radians(20) # Ángulo inicial (grados a radianes)

t_max = 10 # Tiempo de simulación (s)

# Ciclo de simulación

t = np.linspace(0, t_max, num=1000)

theta = theta0 * np.cos(np.sqrt(g / longitud) * t)

# Ajustar la longitud del péndulo según el ángulo

if abs(theta0) > np.radians(30):

longitud *= 1.5 # Aumentar la longitud si el ángulo inicial es mayor a

30°

# Graficar el movimiento angular

plt.plot(t, theta)

plt.title('Movimiento de un Péndulo Simple')

plt.xlabel('Tiempo (s)')

plt.ylabel('Ángulo (radianes)')

plt.grid(True)

plt.show()
25-

import math

# Función para calcular la velocidad de escape

def velocidad_escape(masa_planeta, radio_planeta, G=6.67430e-11):

return math.sqrt(2 * G * masa_planeta / radio_planeta)

# Parámetros del planeta (Tierra)

masa_tierra = 5.972e24 # kg

radio_tierra = 6.371e6 # m

# Calcular velocidad de escape

v_escape = velocidad_escape(masa_tierra, radio_tierra)

print(f"La velocidad de escape es {v_escape} m/s")

# Verificar si es suficiente para escapar de la gravedad

velocidad_inicial = 12000 # m/s

if velocidad_inicial >= v_escape:

print("La velocidad es suficiente para escapar.")

else:

print("La velocidad no es suficiente para escapar.")

26-

# Función para verificar si un número es primo

def es_primo(n):

if n < 2:

return False

for i in range(2, int(n**0.5) + 1):

if n % i == 0:

return False

return True

# Encontrar primos en un rango dado

def primos_en_rango(rango):

return [n for n in rango if es_primo(n)]

# Rango dado

rango = range(10, 50)

primos = primos_en_rango(rango)

print(f"Números primos en el rango: {primos}")

27-

# Función para calcular la serie de Fibonacci

def fibonacci(n):

serie = [0, 1]

while len(serie) < n:

serie.append(serie[-1] + serie[-2])

return serie[:n]

# Generar la serie hasta un número dado

n = #profe aqui coloque el numero que quiera

serie_fib = fibonacci(n)

print(f"Serie de Fibonacci hasta {n}: {serie_fib}")

28-

# Función de ordenamiento por burbuja

def ordenamiento_burbuja(lista):

n = len(lista)

for i in range(n):

ordenado = True

for j in range(n - 1 - i):

if lista[j] > lista[j + 1]:

lista[j], lista[j + 1] = lista[j + 1], lista[j]

ordenado = False

if ordenado:

break

return lista

# Lista desordenada

lista = [64, 34, 25, 12, 22, 11, 90]

lista_ordenada = ordenamiento_burbuja(lista)

print(f"Lista ordenada: {lista_ordenada}")

29-

# Función para descomponer en factores primos

def descomponer_en_factores(n):

factores = []

divisor = 2

while n > 1:

while n % divisor == 0:

factores.append(divisor)

n //= divisor

divisor += 1

return factores

# Descomposición de un número dado

n = 56

factores_primos = descomponer_en_factores(n)

print(f"Factores primos de {n}: {factores_primos}")

30-

# Función para calcular el MCD usando el algoritmo de Euclides

def mcd(a, b):

while b != 0:

a, b = b, a % b

return a

# Cálculo del MCD de dos números

a, b = 48, 18

resultado_mcd = mcd(a, b)

print(f"El MCD de {a} y {b} es {resultado_mcd}")