UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
UNIVERSIDAD CENTRAL DEL ECUADOR
SEGUNDO SEMESTRE
FACULTAD DE INGENIERIA EN GEOLOGÍA,
MINAS, PETRÓLEOS Y AMBIENTAL
Integrantes: Steven Abril
Carla Castillo
Fernanda Zambrano
Asignatura: Programación y Base de Datos
Semestre: 2do
Fecha:18/12/2024
Numero de tarea: 1
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA EN GEOLOGÍA, MINAS, PETRÓLEOS Y AMBIENTAL
CARRERA DE INGENIERÍA PETRÓLEOS – 2er SEMESTRE
PROGRAMACIÓN Y BASE DE DATOS
NOMBRES: Steven Abril
DEBER Nro.: 1
Carla Castillo
Fernanda Zambrano
FECHA: 18/12/2024
TEMA: Funciones, condicionales y diccionarios
Objetivo:
Este ejercicio busca que los estudiantes apliquen condicionales y funciones para
resolver un problema realista del ámbito de las ciencias de la tierra, fomentando el
pensamiento lógico y la programación estructurada.
1.- Enunciado:
Diseña un programa en Python que permita a un geólogo analizar y clasificar el tipo
de suelo de un área determinada en función de su contenido de humedad y densidad.
El programa debe incluir:
1.- Entrada de datos:
Solicita al usuario ingresar los valores de humedad (%), densidad (g/cm^3) y el
nombre del área a analizar.
2.- Clasificación del suelo:
Crea una función llamada clasificar_suelo{humedad,densidad} que determine
el tipo de suelo según las siguientes condiciones:
Si la humedad es mayor al 40% y la densidad mayor a 2.5g/cm^3
califica el suelo como “ARCILLOSO COMPACTO”.
Si la humedad está entre el 20% y el 40% y la densidad es entre 1.5 y
2.5 g/cm^3 clasifica el suelo como “LIMOSO”.
Si la humedad es menor al 20% y la densidad menor a 1.5g/cm^3 califica el suelo
como “ARENOSO”.
Si no cumple con ninguna de estas condiciones, clasifica el suelo como “OTRO
TIPO DE SUELO”.
3.- Salida de resultados
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
El programa debe mostrar el nombre del área, los valores ingresados y el tipo de
suelo clasificado.
4.- Validaciones
Asegúrate de que los valores de humedad estén entre 0 y 100% y que la densidad
sea positiva si los datos no son válidos, muestra un mensaje de error y permite que
el usuario los ingrese nuevamente.
2.- Enunciado:
Diseña un programa de Python que permita a un ingeniero de petróleos analizar y
clasificar el tipo de fluido en un pozo según sus propiedades físicas. El programa
debe incluir:
1.- Entrada de datos
Solicita al usuario ingresar los valores de presión del pozo (en psi), gravedad API
del fluido y el factor de compresibilidad.
2.- Clasificación del fluido:
Crea una función llamada clasificar_fluido(presión,api,z) que determine el tipo de
fluido de acuerdo con las siguientes condiciones:
Si la gravedad API es mayor a 31.1, clasifica el fluido como “crudo ligero”.
Si la gravedad API está entre 22.3 y 31.1, clasifica el fluido como “crudo
mediano”.
Si la gravedad API es menor a 22.3y la presión es mayor a 2000 psi, clasifica el
fluido como “crudo pesado”.
Si el factor de compresibilidad (Z) es menor a 0.8 y la presión es mayor a 1000
psi, clasifica como “gas húmedo”
Si no cumple con ninguna de las condiciones anteriores, clasifica el fluido como
“otro tipo de fluido”.
3.- Salida de resultados:
El programa debe mostrar los valores ingresados y el tipo de fluido clasificado.
4.- Validaciones:
Asegúrate de que los valores ingresados sean positivos y razonables:
La presión debe ser mayor a 0 psi.
La gravedad API debe estar entre 0 y 100.
El factor de compresibilidad (Z) debe estar entre 0 y 1
Si los datos no son válidos, muestra un mensaje de error y permite que el usuario
los ingrese nuevamente
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
Interfaz:
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
Pruebas de funcionamiento:
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
CODIGO DE LA INTERFAZ:
def ingresar_humedad() -> float:
humedad = float(input("Ingrese la humedad del suelo:"))
if humedad < 0 or humedad >100:
print("Error: La humedad del suelo debe estar entre 0 y 100. Intente nuevamente.")
return ingresar_humedad()
return humedad
def ingresar_densidad() -> float:
densidad = float(input("Ingrese la densidad del suelo:"))
if densidad < 0:
print("Error: La densidad del suelo debe estar entre 0 y 100. Intente nuevamente.")
return ingresar_densidad()
return densidad
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
def Datos_suelo() ->dict():
suelo={}
suelo["Muestra"]= str(input("Ingrese la muestra del suelo:"))
suelo["Área"] = str(input("Ingrese el area del suelo:"))
suelo["Humedad"] = ingresar_humedad()
suelo["Densidad"] = ingresar_densidad()
return suelo
def suelo(suelo1:dict,suelo2:dict,suelo3:dict,muestra:str)->dict:
if suelo1["Muestra"]==muestra:
respuesta=suelo1
elif suelo2["Muestra"]==muestra:
respuesta=suelo2
elif suelo3["Muestra"]==muestra:
respuesta=suelo3
else:
respuesta= None
return respuesta
def clasificar_suelo(suelo:dict)->str:
if suelo["Humedad"]>40 and suelo["Densidad"]>2.5:
return "Arcilloso compacto"
elif 20<=suelo["Humedad"]<=40 and 1.5<=suelo["Densidad"]<=2.5:
return "Limoso"
elif suelo["Humedad"]<20 and suelo["Densidad"]<1.5:
return "Arenoso"
else:
return "Otro tipo de suelo"
def promedio_humedad(suelo1:dict,suelo2:dict,suelo3:dict) -> dict:
promedio_humedad={}
promedio_humedad = (suelo1["Humedad"]+suelo2["Humedad"]+suelo3["Humedad"])/ 3
return promedio_humedad
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
def ingresar_presion() -> float:
presion = float(input("Ingrese la presión del pozo:"))
if presion < 0:
print("Error: La presión del pozo debe ser mayor a cero. Intente nuevamente.")
return ingresar_presion()
return presion
def ingresar_gravedad_api() -> float:
gravedad = float(input("Ingrese la gravedad API del pozo:"))
if gravedad < 0 or gravedad > 100:
print("Error: La gravedad API del pozo debe estar entre 0 y 100. Intente nuevamente.")
return ingresar_gravedad_api()
return gravedad
def ingresar_factor_z() -> float:
factor_z = float(input("Ingrese el factor de comprensibilidad (Z) del pozo:"))
if factor_z < 0 or factor_z > 1:
print("Error: El factor Z del pozo debe estar entre 0 y 1. Intente nuevamente.")
return ingresar_factor_z()
return factor_z
def Datos_pozo()->dict:
pozo={}
pozo["Muestra"]= str(input("Ingrese la muestra del pozo:"))
pozo["Presión"] = ingresar_presion()
pozo["Gravedad API"] = ingresar_gravedad_api()
pozo["Factor Z"] = ingresar_factor_z()
return pozo
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
def pozo(pozo1:dict,pozo2:dict,pozo3:dict,muestra:str)->dict:
if pozo1["Muestra"]==muestra:
respuesta=pozo1
elif pozo2["Muestra"]==muestra:
respuesta=pozo2
elif pozo3["Muestra"]==muestra:
respuesta=pozo3
else:
respuesta= None
return respuesta
def clasificar_fluido(pozo:dict)->str:
if pozo["Gravedad API"]>31.1 :
return "Crudo ligero"
elif pozo["Gravedad API"]>=22.3 and pozo["Gravedad API"]<=31.1:
return "Crudo mediano"
elif pozo["Gravedad API"]<22.3 and pozo["Presión"]>2000:
return "Crudo pesado"
elif pozo["Factor Z"]<0.8 and pozo["Presión"]>1000:
return "Clasificación fluido:Gas Húmedo"
else:
return "Otro tipo de fluido"
def promedio_presion(pozo1:dict,pozo2:dict,pozo3:dict) -> dict:
promedio_presion={}
promedio_presion = (pozo1["Presión"]+pozo2["Presión"]+pozo3["Presión"])/ 3
return promedio_presion
import libreria_tarea1_grupo as l
def programa_principal():
print("Escoja el menú:")
print("[Link]ón suelo")
print("[Link]ón fluido")
opcion = int(input ("Ingrese la alternativa que desea considerar:"))
if opcion==1:
suelo1=l.Datos_suelo()
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
print("-------------------------------------")
suelo2=l.Datos_suelo()
print("-------------------------------------")
suelo3=l.Datos_suelo()
print("-------------------------------------")
print("VALORES INGRESADOS")
print("Muestra suelo",suelo1["Muestra"])
print("Área:",suelo1["Área"])
print("Humedad:",suelo1["Humedad"],"%")
print("Densidad:",suelo1["Densidad"],"g/cm³")
print("Clasificación del suelo 1:", l.clasificar_suelo(suelo1))
print("-------------------------------------")
print("Muestra suelo",suelo2["Muestra"])
print("Área:",suelo2["Área"])
print("Humedad:",suelo2["Humedad"],"%")
print("Densidad:",suelo2["Densidad"],"g/cm³")
print("Clasificación del suelo 2:", l.clasificar_suelo(suelo2))
print("-------------------------------------")
print("Datos suelo:")
print("Muestra suelo",suelo3["Muestra"])
print("Área:",suelo3["Área"])
print("Humedad:",suelo3["Humedad"],"%")
print("Densidad:",suelo3["Densidad"],"g/cm³")
print("Clasificación del suelo 3:", l.clasificar_suelo(suelo3))
print("El promedio de las humedades es:",("{:.2f}".format(l.promedio_humedad(suelo1, suelo2,
suelo3))),"%")
elif opcion==2:
pozo1=l.Datos_pozo()
print("-------------------------------------")
pozo2=l.Datos_pozo()
print("-------------------------------------")
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
pozo3=l.Datos_pozo()
print("-------------------------------------")
print("VALORES INGRESADOS:")
print("Muestra pozo",pozo1["Muestra"])
print("Presión:",pozo1["Presión"],"psi")
print("Gravedad API:",pozo1["Gravedad API"])
print("Factor Z:",pozo1["Factor Z"])
print("Clasificación del Pozo 1:", l.clasificar_fluido(pozo1))
print("-------------------------------------")
print("Muestra pozo",pozo2["Muestra"])
print("Presión:",pozo2["Presión"],"psi")
print("Gravedad API:",pozo2["Gravedad API"])
print("Factor Z:",pozo2["Factor Z"])
print("Clasificación del Pozo 2:", l.clasificar_fluido(pozo2))
print("-------------------------------------")
print("Muestra pozo",pozo3["Muestra"])
print("Presión:",pozo3["Presión"],"psi")
print("Gravedad API:",pozo3["Gravedad API"])
print("Factor Z:",pozo3["Factor Z"])
print("Clasificación del Pozo 3:", l.clasificar_fluido(pozo3))
print("El promedio de las presiones es:",("{:.2f}".format(l.promedio_presion(pozo1, pozo2,
pozo3))),"psi")
else:
print("Alternativa no valida")
programa_principal()
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA PETRÓLEOS
Conclusiones:
Las funciones y los condicionales son herramientas esenciales en programación, cada una con
sus beneficios y desafíos. Las funciones permiten dividir el código en módulos, reutilizarlo,
hacerlo más legible y simplificar la depuración, además de mejorar la escalabilidad; no obstante,
su uso puede implicar una sobrecarga inicial, mayor consumo de memoria y complejidad si se
emplean de forma excesiva. Por su parte, los condicionales ofrecen la posibilidad de tomar
decisiones dinámicas, aportan flexibilidad, optimizan la ejecución y facilitan el mantenimiento
del código, aunque un diseño demasiado complejo puede dificultar la lectura, reducir el
rendimiento o provocar errores lógicos. Aprovechar estas herramientas de manera adecuada
contribuye a desarrollar programas más claros, eficientes y fáciles de gestionar.