Los condicionales, permiten tomar decisiones o elegir las acciones como resultado de una operación lógica,
a>b a=b
a<b a>=b
a<=b ; etc....
De la situación propuesta escrita en Python:
if (vkmh>50):
sancion=1
else:
sancion=0
Con lo que el algoritmo de velocidad media se convierte en:
Multa por velocidad limite
# FCNM-ESPOL. Física con python# cálculo de multa por velocidad límite# valores conocidos d y t# sancion si exede los 50km/h
tf=int(input('¿cuantos segundos?: '))
d=float(input('¿distancia recorrida?: '))
v=d/tf
vkmh=(v/1000)*60*60
if (vkmh>50):
sancion=1
else:
sancion=0
print('Velocidad Media(Km/h)')
print(vkmh)
if (sancion==1):
print('Tiene sancion por exceso de velocidad sobre 50 Km/h')
Ejercicio propuesto
Ampliar el uso del tema propuesto, solicitando la variable de velocidad “limite” para decidir si aplica una sanción
Zona escolar: 20 Km/h
Zona urbana: 50 Km/h
Via rápida urbana: 60 Km/h
Carretera: 90 Km/h
Velocidad Media
# FCNM-ESPOL. Física con python# cálculo de velocidad# valores conocidos d y t
tf = int(input('¿cuantos segundos?: '))
d = float(input('¿distancia recorrida?: '))
v = d/tf
vkmh = (v/1000)*60*60
print('Velocidad Media(Km/h)')
print(vkmh)
Para plantear el movimiento en línea recta se consideran el punto de partida, llegada y tiempo de recorrido. En Python son variables que pueden obtener diferente valor para cada prueba.
Puede usar Python como calculadora y como programa.
Para que el computador realice los trabajos de cálculo, se deben describir las instrucciones de forma ordenada, simple y muy clara. (Algoritmo)
Una forma de describir un Algoritmo es mediante gráficas conocidas como “Diagramas de Flujo”.
El “Programa” consiste en escribir las instrucciones del algoritmo en un lenguaje para computadora
Generalmente las instrucciones se escriben en inglés, siguiendo un formato (sintaxis) establecido por el lenguaje de programación. Estructuras de Control en programación
Para éste curso, el lenguaje utilizado será Python
En las líneas de inicio, se comienza describiendo la razón por la que escribimos el “algoritmo” escrito en forma de “programa”
# FCNM-ESPOL. Física con python# cálculo de velocidad# valores conocidos d y t
En el bloque de INGRESO, se Seleccionan datos conocidos al inicio,se determinan los tipos de datos, sean Variables simples: enteros o reales.
En el algoritmo o programa no se usarán inicialmente las unidades, se supondrá que son predeterminadas
tf = int(input('¿cuantos segundos?: '))
d = float(input('¿distancia recorrida?: '))
En el bloque de procedimiento, para calcular la velocidad en el tramo se escribe la formula, incluso se puede cambiar de mts/seg a Km/h
v = d/tf
vkmh = (v/1000)*60*60
En los bloques de salida y Fin, Se muestran los resultados encontrados y como fin del algoritmo en python de establece cuando no se encuentran líneas de instrucción
print('Velocidad Media(Km/h)')
print(vkmh)
Velocidad Media
# FCNM-ESPOL. Física con python# cálculo de velocidad# valores conocidos d y t
tf = int(input('¿cuantos segundos?: '))
d = float(input('¿distancia recorrida?: '))
v = d/tf
vkmh = (v/1000)*60*60
print('Velocidad Media(Km/h)')
print(vkmh)
En el caso de estar tomando el curso de Física-Cinemática, los siguientes temas te serán de ayuda como introducción a Python. Los temas de programación se desarrollan usando los ejemplos del libro Sears-Zemansky Capítulo 2, Edición 12.
El concepto se amplía con el uso de simulaciones en computadora
Otro enfoque:
"Computers are incredibly fast, accurate, and stupid;
humans are incredibly slow, inaccurate, and brilliant;
together they are powerful beyond imagination". Albert Einstein
Existen otras librerías para el procesamiento de imagen, sin embargo para describir el concepto se usará la forma más simple.
La imagen normalmente tiene el formato RGB (Red, Green, Blue) o RGBA (incluye transparencia).
El tamaño de la imagen en alto y ancho corresponde a las dos primeras dimensiones de la matriz, la tercera dimensión corresponde al color en formato RGB.
Ejemplo: Matriz[fila, columna, RGBA]
# Abrir imagen desde in archivoimport numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
# INGRESO# narchivo = input('nombre del archivo: ')
narchivo='pinky&brain.gif'
unaimagen=mpimg.imread(narchivo)
# PROCEDIMIENTO
tamano=np.shape(unaimagen)
rojo=unaimagen[:,:,0]
verde=unaimagen[:,:,1]
azul=unaimagen[:,:,2]
transparente=unaimagen[:,: 3]
# SALIDAprint('El tama o de la imagen: ', tamano)
print(unaimagen)
plt.subplot(221)
plt.imshow(rojo, cmap='Reds')
plt.subplot(222)
plt.imshow(verde, cmap='Greens')
plt.subplot(223)
plt.imshow(azul, cmap='Blues')
plt.subplot(224)
plt.imshow(unaimagen)
plt.show()
El tamaño de la imagen: (277, 370, 4)
[[[ 0 43 102 255]
[ 0 43 51 255]
[ 0 43 102 255]
...,
Los conceptos de arreglos como vectores y matrices son suficientes para manejar archivos.wav. con la librería Scipy-Python.
1. Leer o Abrir archivo.wav de audio
Para procesar un archivo de audio en formato .wav, la instrucción waves.read(archivo) usa el archivo con 'nombre.wav' y obtiene dos variables que representan:
- muestreo: frecuencia de muestreo del sonido en PCM y
- sonido: que es un arreglo con las muestras del sonido.
El archivo de audio debe encontrarse en el mismo directorio que el archivo.py de instrucciones, por ejemplo, dado el archivo 'Alarm01.wav' , se puede procesar con las instrucciones mostradas:
En el ejemplo, la frecuencia de muestreo es de 22050 Hz. El sonido es estéreo al tener dos columnas que corresponden a los canales izquierdo y derecho.
Para usar un solo canal, se copian los datos a un nuevo arreglo. Para separar el canal izquierdo por ejemplo, se usan las instrucciones:
la librería de funciones scipy(scientific python), dispone de funciones para el tratamiento de señales, estadísticas, audio, entre otras.
El orden de las instrucciones es el que aparece en los post del blog.
instrucciones
import scipy.io.wavfile as waves
librerias de audio en formato wav para lectura y escritura de archivos.
muestreo, sonido = waves.read(archivo)
lectura de datos de un archivo de audio en formato wav. Se obtiene la frecuencia de muestreo y los datos en sonido
import scipy.integrate as integrate
importar metodos de integración de scipy
integrate.simps(valrores, ejex)
integral de muestras de señal usando el método de Simpson.
.
.
.
.
2. Extraer una Porción del audio y guardar archivo.wav
Para extraer una porción de un archivo de audio se requiere: abrir el archivo, seleccionar la porción de interés y guardar el resultado un archivo de salida.
La porción puede ser indicada en unidades de tiempo que luego deben ser convertidas a índices de muestras para extraer la porción requerida.
El procesamiento del archivo simplificado en Python es:
# Extrae porción de un archivo de audio .wavimport numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves
# INGRESO # archivo = input('archivo de sonido:' )
archivo = 'muestra_Invernal01.wav'
archivosalida = 'muestra_Invernal02.wav'# tiempo en segundos
desde = 7.5
hasta = 10.2
muestreo, sonido = waves.read(archivo)
# PROCEDIMIENTO# indices de muestras
idesde = int(desde*muestreo)
ihasta = int(hasta*muestreo)
porcion = sonido[idesde:ihasta,:]
duracion = len(porcion)/muestreo
# SALIDA
waves.write(archivosalida, muestreo, porcion)
print('archivo creado: ', archivosalida)
2.1 Guardar un archivo de audio .wav
Luego de procesar los datos de audio, y guardar el resultado en un archivo con 'nombre.wav' se usa la instruccion waves.write() de la libreria scipy, que requiere:
- archivo: el nombre del archivo resultante, con extension.wav
- fsonido: la frecuencia de muestreo del sonido (entero)
- sonido: el arreglo de la señal de audio como entero de 16 bits (dtype='int16').
Recuerde haber realizado el llamado a las librerias numpy y scipy que se presentan como referencia en el script.
# PROCEDIMIENTO# Arreglos para datos con k muestras
sonidofinal = np.zeros(k, dtype='int16')
# SALIDA
archivo = 'audiofinal.wav'
waves.write(archivo, int(fsonido),sonidofinal)
El archivo de audio resultante se escucharà usando un programa como "windows media player"
Notas:
Se puede añadir al nombre la ruta de ubicación del archivo en el disco duro. Ejemplo para windows: 'C:\Users\mis documentos\archivo.wav'
3. Gráfica de un canal de audio
Para mostrar en un gráfico un canal de audio se usa la libreria matplotlib. Para muestra, usando los datos del ejemplo anterior:
Para almacenar estos datos se realiza la conversión del diccionario a DataFrame con el objetivo de usar la instrucción de Pandas para guardar archivos.json.
tabla.to_json(unarchivo)
Instrucciones en Python
import pandas as pd
# INGRESO#archivos de salida T: Transpuesta
unarchivo = 'ejemplonotas01.json'
unarchivoT = 'ejemplonotasT01.json'# datos como diccionario de datos
tabla = {'Maria': {'primera': 55,
'segunda': 70,
'tercera': 0,
'final': '62,5'},
'Pedro': {'primera': 30,
'segunda': 60,
'tercera': 70,
'final': '65'},
'Juan': {'primera': 80,
'segunda': 65,
'tercera': 65,
'final': '72,5'}
}
# PROCEDIMIENTO# conversión a DataFrame de pandas
tabla = pd.DataFrame(tabla)
tablaT = tabla.transpose()
# SALIDAprint(tabla)
print('transponer: ')
print(tablaT)
# almacena en archivo.json
tabla.to_json(unarchivo)
tablaT.to_json(unarchivoT)
a. Realice la lectura de los datos desde el archivo.csv en una tabla de Pandas, muestre los nombres de las columnas
b. Añada una columna de fecha-hora con tipo de dato datetime unificando las columnas "Date" y "Time"
c. Realice la gráfica de los datos obtenidos para la variable temperatura "TEMP" vs "fecha".
Referencia: Basic Time Series Plotting. Unidata. https://unidata.github.io/python-training/workshop/Time_Series/basic-time-series-plotting/
1.1 Solución propuesta
literal a
Para leer o cargar el archivo.csv con pandas y realizar la gráfica se usarán las librerías "pandas" y "matplotlib". La lectura del archivo usa los parámetros de separador de datos ';' y separador decimal ','. El nombre del archivo es parte del bloque de ingreso.
tabla = pd.read_csv(narchivo, sep=';',decimal=',')
literal b
Para manejar las fechas, se concatenan los valores de las columnas 'Date' y 'Time' conformando una cadena de caracteres en cada casilla de la columna 'fecha'.
Para manejar los datos y operaciones con fechas se usan el tipo de datos datetime. El formato de lectura se indica como"%d/%m/%Y %H:%M:%S" dado por una cadena de caracteres
La gráfica se realiza usando los datos de las columnas de fecha y temperatura.
Instrucciones Python
# lecturas archivo.csv de estación meteorológicaimport pandas as pd
import matplotlib.pyplot as plt
# INGRESO
narchivo = "2021_10_EstMeteorologica.csv"# PROCEDIMIENTO
tabla = pd.read_csv(narchivo, sep=';',decimal=',')
n = len(tabla)
# fechas concatenando columnas de texto
tabla['fecha'] = tabla['Date']+' '+tabla['Time']
# convierte a datetime
fechaformato = "%d/%m/%Y %H:%M:%S"
tabla['fecha'] = pd.to_datetime(tabla['fecha'],
format=fechaformato)
# SALIDAprint('columnas: ', list(tabla.keys()))
# grafica
x_horas = tabla['fecha']
y_temp = tabla['TEMP']
plt.plot(x_horas,y_temp,'*')
plt.title('Temperatura')
plt.grid()
plt.show()
2. Separar datos por días y graficar
d. Para realizar un análisis por día y comparar entre varios días, se requiere encontrar los intervalos de inicio y fin de día.
e. Realizar la gráfica comparativa de los días.
2.1 Solución propuesta
literal d
Los intervalos se pueden entregar como una lista de los índices de las filas donde cambia el día.
literal d
Para que las gráficas se superpongan en las mismas horas, sin cambiar de día, se realiza una operación de desplazamiento pd.Timedelta(days=j) a las fechas antes de hacer cada línea de gráfica.
Las etiquetas en el eje x se cambia al formato '%H:%M' mediante la librería matplotlib.dates y la instrucción DateFormatter.
La gráfica para 7 días se presenta muchos datos, por lo que para análisis es preferible algo más simplificado, como comparar dos días para simplificar visualmente.
Instrucciones Python
# lecturas archivo.csv de estación meteorológicaimport pandas as pd
import matplotlib.pyplot as plt
from matplotlib.dates import DateFormatter, DayLocator
# INGRESO
narchivo = "2021OctubreEstMetorologica.csv"# PROCEDIMIENTO
tabla = pd.read_csv(narchivo, sep=';',decimal=',')
n = len(tabla)
# fechas concatenando columnas de texto
tabla['fecha'] = tabla['Date']+' '+tabla['Time']
# convierte a datetime
fechaformato = "%d/%m/%Y %H:%M:%S"
tabla['fecha'] = pd.to_datetime(tabla['fecha'],
format=fechaformato)
# serie por días
diaIndice = [0] # indice inicialfor i inrange(1,n-1,1):
i0_fecha = tabla['fecha'][i-1]
i1_fecha = tabla['fecha'][i]
if i0_fecha.day != i1_fecha.day:
diaIndice.append(i)
diaIndice.append(len(tabla)-1) # indice final
m = len(diaIndice)
# SALIDAprint('columnas: ', list(tabla.keys()))
print('SerieDia: ',diaIndice)
print('días en serie: ', len(diaIndice))
# grafica
figura, grafica = plt.subplots()
marcador = ['.','o','v','^','<','>','1']
for j inrange(0,7,1):
i0 = diaIndice[j]
i1 = diaIndice[j+1]
x_horas = tabla['fecha'][i0:i1]-pd.Timedelta(days=j)
y_temp = tabla['TEMP'][i0:i1]
etiqueta = str(tabla['fecha'][i0].month)+'-'
etiqueta = etiqueta + str(tabla['fecha'][i0].day)
grafica.scatter(x_horas,y_temp,
marker = marcador[j%7],
label=etiqueta)
# formato de eje
grafica.xaxis.set_major_formatter(DateFormatter('%H:%M'))
plt.legend()
plt.title('Temperatura')
plt.grid()
plt.show()
1. Gráficas 3D en Python. Sistema de ecuaciones y Planos
El ejercicio se presenta desde la perspectiva que la solución es un punto de intersección de los planos en el espacio dados por cada ecuación. Ejercicio de métodos numéricos.
xi = [x0, x1, x2]
yi = [y0, y1, y2]
zi = [z0, z1, z2]
con lo que se crea la gráfica de puntos (scatter) en 3d:
las instrucciones en Python son:
# Puntos en el espacio, Dispersión-Scatter# cada fila representa un punto [xi,yi,zi]import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# INGRESO# unpunto = [x,y,z]
puntos = np.array([[0, 0, 0],
[1, 2, 3],
[2, 4,-1]])
# SALIDA# grafica
figura = plt.figure()
grafica = figura.add_subplot(111,projection = '3d')
# xi = [:,0] ; yi = [:,1], zi = [:,2]# selecciona columnas, use la transpuesta de puntos
[xi, yi , zi] = np.transpose(puntos)
grafica.scatter(xi,yi,zi,
c = 'blue',
marker='o',
label = 'puntos[i]')
grafica.set_title('puntos, dispersión-scatter')
grafica.set_xlabel('eje x')
grafica.set_ylabel('eje y')
grafica.set_zlabel('eje z')
grafica.legend()
plt.show()
siguiendo el esquema, se pueden añadir los puntos que sean necesarios.
Realizar la gráfica de la función f(x) dentro del intervalo en el eje x de [0.5, 2]
f(x) = 5 \cos(2x) - 2x \sin(2x)
Algoritmo en Python para gráfica 2D
El bloque de inicio contiene la referencia del problema y carga las librerías numpy y matplotlib.
La función f(x) se puede escribir en la forma "def-return" o también en la forma simplificada lambda.
fx = lambda x: 5*np.cos(2*x)-2*x*np.sin(2*x)
El bloque de ingreso se usa para definir la función matemática fx en formato lambda y los valores que determinan el intervalo [a,b]. Se requiere establecer el número de muestras necesarias para una buena precisión o "suavidad" de la curva.
En el bloque de procedimiento, se calculan los vectores que contienen los puntos xi, fi. Para calcular el vector xi se usa la instrucción np.linspace(a,b,muestras) que permite generar las muestras xi en el intervalo [a,b] del eje x , cuyos valores luego son usados para evaluar f(xi)
# Grafica 2D con lineaimport numpy as np
import matplotlib.pyplot as plt
# INGRESO
fx = lambda x: 5*np.cos(2*x)-2*x*np.sin(2*x)
a = 0.5
b = 2
muestras = 21
# PROCEDIMIENTO
xi = np.linspace(a,b,muestras)
fi = fx(xi)
# SALIDA# GRAFICA
plt.plot(xi,fi)
# Etiquetas de ejes
plt.title('funcion(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
El bloque de salida se enfoca en la gráfica. Las instrucciones necesarias para la gráfica son básicamente dos:
la que dibuja la línea plt.plot(xi,fi)
la que muestra el gráfico en pantalla plt.show()
A la gráfica se puede añadir otros detalles con instrucciones adicionales antes de plt.show(). Por ejemplo, se añaden las etiquetas de los ejes con plt.xlabel(), plt.ylabel(), y los títulos de los gráficos con plt.title().
Cuando se termina de añadir los elementos del gráfico, se usa la instrucción plt.show() para mostrar la gráfica.
dibuja en el rango un área entre 0 y los valores, al color descrito: 'green', 'ligthgreen', 'red', 'magenta', 'blue', 'yellow', etc
plt.margins(0.1)
crea un margen en la gráfica de valor 0.1 expandiendo los bordes sobre los máximos y mínimos. Se usa para ver claramente las variaciones en los extremos o cuando los valores máximos son constantes en un periodo.
Las gráficas son un recurso muy versátil en el área de la matemática e ingeniería. En el curso de Métodos Numéricos se presenta una introducción de gráficas en 2D y se usan y desarrollan en todas las unidades como parte del análisis de los problemas.
En el curso de Señales y Sistemas, se las usa ampliamente desde la unidad 1 Señales, para mostrar los diferentes tipos y formas, y luego en el análisis de las respuestas de los sistemas ante las señales. Como tema de introducción, revise algunas de las definiciones básicas de señales para observar la aplicación de gráficas.
Las instrucciones para las gráficas se realizan en el bloque de salida usando un solo bloque de instrucciones, para finalmente mostrar el resultado plt.show().
