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
[Link]() para crear la figura y [Link]() para obtener el eje actual.
Ejemplo:
python
Copiar código
import [Link] as plt
fig, ax = [Link]()
3. ¿Cuál es la diferencia entre [Link]() y [Link]() en
Matplotlib?
[Link]() se utiliza para crear y trazar un gráfico de línea en el eje
actual, mientras que [Link]() se utiliza para mostrar el gráfico en una
ventana emergente. [Link]() debe llamarse después de [Link]()
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 [Link](True) en un gráfico de línea.
El método [Link](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
[Link](). Ejemplo:
python
Copiar código
[Link](x, y, linestyle='--') # Línea discontinua
[Link](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
[Link](). Dos maneras de hacerlo son:
python
Copiar código
[Link](x, y, color='red') # Usando un nombre de color
[Link](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 [Link](). Ejemplo:
python
Copiar código
[Link](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
[Link]('[Link]')
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
[Link]() varias veces antes de llamar a [Link](). Ejemplo:
python
Copiar código
[Link](x1, y1, label='Línea 1')
[Link](x2, y2, label='Línea 2')
[Link]()
[Link]()
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 = [Link]()
ax2 = [Link]()
[Link](x, y1, 'g-')
[Link](x, y2, 'b-')
13. Describe cómo utilizar [Link]() y [Link]() para
ajustar los límites de los ejes en un gráfico de línea.
[Link]() y [Link]() se utilizan para ajustar los límites de los ejes X
e Y, respectivamente. Ejemplo:
python
Copiar código
[Link](0, 10) # Ajusta el límite del eje X de 0 a 10
[Link](-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
[Link]('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 [Link] import make_interp_spline
import numpy as np
import [Link] as plt
x = [Link](0, 10, 10)
y = [Link](x)
xnew = [Link](0, 10, 300)
spl = make_interp_spline(x, y, k=3)
ynew = spl(xnew)
[Link](xnew, ynew)
[Link]()
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 = [Link]()
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 = [Link](N, dtype=complex)
for k in range(N):
for n in range(N):
X[k] += x[n] * [Link](-2j * [Link] * k * n / N)
return X
# Datos de ejemplo (señal)
datos = [Link]([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 [Link][1] != [Link][0]:
raise ValueError("Las matrices no tienen dimensiones compatibles
para la multiplicación.")
# Crear matriz de resultado con ceros
result = [Link](([Link][0], [Link][1]))
# Iterar sobre las matrices y realizar la multiplicación
for i in range([Link][0]):
for j in range([Link][1]):
for k in range([Link][1]):
result[i, j] += A[i, k] * B[k, j]
return result
7-
import numpy as np
def LU_decomposition(A):
n = [Link][0]
# Inicializar matrices L y U
L = [Link](n)
U = [Link]()
# 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 = [Link]([[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 = [Link](n)
for it in range(max_iter):
x_new = [Link](x)
for i in range(n):
sum1 = [Link](A[i, :i], x_new[:i])
sum2 = [Link](A[i, i+1:], x[i+1:])
x_new[i] = (b[i] - sum1 - sum2) / A[i, i]
# Verificar la convergencia
if [Link](x_new - x, ord=[Link]) < 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 = [Link][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 = [Link]([Link](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 = [Link][0]
# Crear la matriz identidad
I = [Link](n)
# Concatenar A con la identidad
augmented_matrix = [Link]([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)) / [Link](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)) / [Link](2*n)
cosine += term
if abs(term) < 1e-10: # Umbral de precisión
break
return cosine
x = [Link] / 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 = [Link](x)
cos = [Link](x)
identity = seno**2 + cos**2
if [Link](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 = [Link] / 4 # 45 grados
verify_trig_identity(x)
13-
import numpy as np
import [Link] as plt
def plot_trig_functions(resolution=1000):
x = [Link](-2 * [Link], 2 * [Link], resolution)
sine = [Link](x)
cosine = [Link](x)
[Link](x, sine, label='Seno')
[Link](x, cosine, label='Coseno')
[Link]('x')
[Link]('y')
[Link]('Funciones Trigonométricas: Seno y Coseno')
[Link](0, color='black',linewidth=0.5)
[Link](0, color='black',linewidth=0.5)
[Link]()
[Link](True)
[Link]()
plot_trig_functions()
14-
import math
def c_p(x, y):
r = [Link](x**2 + y**2)
teta = math.atan2(y, x) # Ángulo en radianes
teta_deg = [Link](teta)
return r, teta_deg
def p_to_c(r, teta_deg):
theta = [Link](theta_deg)
x = r * [Link](theta)
y = r * [Link](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 * [Link]([Link](B)) / [Link]([Link](A))
return b
elif a and A and C:
c = a * [Link]([Link](C)) / [Link]([Link](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 = [Link](a**2 + b**2 - 2 * a * b * [Link]([Link](C)))
return c
elif a and b and c:
C = [Link]([Link]((a**2 + b**2 - c**2) / (2 * a * b)))
return C
else:
return None
16-
import numpy as np
import [Link] as plt
def rlc_series_response(R, L, C, f_start, f_stop, steps):
f = [Link](f_start, f_stop, steps)
w = 2 * [Link] * f
Z = [Link](R**2 + (w*L - 1/(w*C))**2)
H=1/Z
# Frecuencia resonante
f_resonant = 1 / (2 * [Link] * [Link](L * C))
# Graficar respuesta en frecuencia
[Link](f, H)
[Link](f_resonant, color='r', linestyle='--', label=f'Resonante:
{f_resonant:.2f} Hz')
[Link]('Frecuencia (Hz)')
[Link]('Respuesta |H(f)|')
[Link]('Respuesta en frecuencia de un circuito RLC serie')
[Link]()
[Link](True)
[Link]()
17-
def power_calculation(V, I, phi):
# Potencia activa (W)
P = V * I * [Link]([Link](phi))
# Potencia reactiva (VAR)
Q = V * I * [Link]([Link](phi))
# Potencia aparente (VA)
S=V*I
return {"Potencia Activa": P, "Potencia Reactiva": Q, "Potencia
Aparente": S}
18-
import numpy as np
import [Link] as plt
def moving_average_filter(signal, window_size):
filtered_signal = [Link](signal,
[Link](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 = [Link](0, 1, 500)
signal = [Link](2 * [Link] * 50 * t) + 0.5 * [Link](500)
# Filtro
filtered_signal = adaptive_filter(signal, 1200)
# Graficar señal original y filtrada
[Link](t, signal, label="Original")
[Link](t[:len(filtered_signal)], filtered_signal, label="Filtrada")
[Link]()
[Link]()
19-
import numpy as np
import [Link] as plt
def fourier_transform(signal, sample_rate):
N = len(signal)
T = 1 / sample_rate
yf = [Link](signal)
xf = [Link](N, T)[:N//2]
return xf, [Link](yf[:N//2])
def filter_frequency(signal, sample_rate, cutoff):
xf, yf = fourier_transform(signal, sample_rate)
yf_filtered = [Link](xf > cutoff, 0, yf)
return xf, yf_filtered
# Ejemplo de señal
sample_rate = 1000
t = [Link](0.0, 1.0, sample_rate)
signal = [Link](50.0 * 2.0 * [Link] * t) + 0.5 * [Link](80.0 * 2.0 * [Link] * t)
xf, yf = filter_frequency(signal, sample_rate, 60)
# Graficar la señal transformada
[Link](xf, yf)
[Link]()
[Link]()
20-
import numpy as np
import [Link] as plt
def lc_oscillator(L, C, initial_charge, initial_current, dt, t_max):
t = [Link](0, t_max, dt)
charge = [Link](len(t))
current = [Link](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
[Link](t, charge, label="Carga (C)")
[Link](t, current, label="Corriente (A)")
[Link]()
[Link]("Tiempo (s)")
[Link]("Amplitud")
[Link]("Simulación del oscilador LC")
[Link](True)
[Link]()
21-
import numpy as np
import [Link] as plt
# Parámetros del proyectil
v0 = 20 # Velocidad inicial (m/s)
theta = [Link](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 * [Link](theta)
vy0 = v0 * [Link](theta)
# Tiempo máximo de vuelo
t_max = 2 * vy0 / g
# Tiempo de simulación
t = [Link](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 = [Link](0, y)
# Graficar
[Link](x, y)
[Link]('Movimiento Parabólico de un Proyectil')
[Link]('Distancia (m)')
[Link]('Altura (m)')
[Link](True)
[Link]()
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 [Link] as plt
# Parámetros del péndulo
g = 9.81 # Gravedad (m/s^2)
longitud = 1.0 # Longitud del péndulo (m)
theta0 = [Link](20) # Ángulo inicial (grados a radianes)
t_max = 10 # Tiempo de simulación (s)
# Ciclo de simulación
t = [Link](0, t_max, num=1000)
theta = theta0 * [Link]([Link](g / longitud) * t)
# Ajustar la longitud del péndulo según el ángulo
if abs(theta0) > [Link](30):
longitud *= 1.5 # Aumentar la longitud si el ángulo inicial es mayor a
30°
# Graficar el movimiento angular
[Link](t, theta)
[Link]('Movimiento de un Péndulo Simple')
[Link]('Tiempo (s)')
[Link]('Ángulo (radianes)')
[Link](True)
[Link]()
25-
import math
# Función para calcular la velocidad de escape
def velocidad_escape(masa_planeta, radio_planeta, G=6.67430e-11):
return [Link](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:
[Link](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:
[Link](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}")
