Ejercicio: 3Eva_IIT2017_T1 Mantenimiento vehículos

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IIT2017_T1 Mantenimiento vehículos
# Tarea: Analizar el número de días

def mantenimientos(strPlaca, dictHistorial, dictMantenimiento):
    resultado = []
    
    # Estado del vehículo analizado
    estado = dictHistorial[strPlaca]['registro']
    n = len(estado)

    # grupos por tipo mantenimiento
    preven = []
    repara = []
    nada = []
    prev = dictMantenimiento['preventivo']
    corr = dictMantenimiento['correctivo']
    m = len(prev)
    q = len(corr)

    # Analiza cada parte del vehículo    
    for i in range(0,n,1):
        parte = estado[i][0]
        dias  = estado[i][1]
        usoKm = estado[i][2]

        # Analiza correctivos
        for j in range(0,q,1):
            c_parte = corr[j][0]
            c_dias  = corr[j][1]
            c_usoKm = corr[j][2]
            if (parte == c_parte):
                if (usoKm >= c_usoKm):
                    repara.append(parte)

        # Analiza preventivos
        for k in range(0,m,1):
            p_parte = prev[k][0]
            p_dias  = prev[k][1]
            p_usoKm = prev[k][2]
            if (parte == p_parte):
                if (usoKm >= p_usoKm and not(parte in repara)):
                    preven.append(parte)

        # Revisa si lo añade a "nada"
        if not(parte in repara) and not(parte in preven):
            nada.append(parte)

    # Convierte a tuplas como se requiere
    m = len(preven)
    q = len(repara)
    p = len(nada)
    for k in range(0,m,1):
        resultado.append((preven[k],'preventivo'))
    for j in range(0,q,1):
        resultado.append((repara[j],'correctivo'))
    for j in range(0,p,1):
        resultado.append((nada[j],'nada'))
    return(resultado)

def semaforo(strPlaca, dictHistorial, dictMantenimiento):
    resultado = {'amarillo':[],
                 'rojo':[],
                 'verde':[]}
    
    diagnostico = mantenimientos(strPlaca,
                                 dictHistorial,
                                 dictMantenimiento)
    n = len(diagnostico)
    
    for i in range(0,n,1):
        if (diagnostico[i][1]== 'preventivo'):
            resultado['amarillo'].append(diagnostico[i][0])
        if (diagnostico[i][1]== 'correctivo'):
            resultado['rojo'].append(diagnostico[i][0])
        if (diagnostico[i][1]== 'nada'):
            resultado['verde'].append(diagnostico[i][0])
    return(resultado)

def recomendar(strparte, strtipoMantenimiento, dictHistorial, dictMantenimiento):
    darservicio = []
    for cliente in dictHistorial:
        colores = semaforo(cliente,
                           dictHistorial,
                           dictMantenimiento)
        if (strtipoMantenimiento=='preventivo'):
            partes = colores['amarillo']
            if (strparte in partes):
                darservicio.append(cliente)
        if (strtipoMantenimiento=='correctivo'):
            partes = colores['rojo']
            if (strparte in partes):
                darservicio.append(cliente)
    return(darservicio)

# INGRESO
dictMantenimiento = {
    'preventivo': [('llantas',  60,  4500),
                   ('bujias',   45,  3000)],
    'correctivo': [('llantas',  90,  6000),
                   ('zapatas', 120, 10000)]
    }

dictHistorial = {
    'GEC-2411': {
        'propietario': 'Eduardo Cueva',
        'registro': [('llantas',  12, 32500),
                     ('zapatas', 180, 500)]
        },
    'GAA-0321': {
        'propietario': 'Andrea Martinez',
        'registro': [('bujias',   40, 500),
                     ('zapatas', 120, 100)]
        }
    }
strPlaca = 'GEC-2411'
strparte = 'llantas'
strtipoMantenimiento = 'correctivo'

# PROCESAMIENTO
diagnostico = mantenimientos(strPlaca,
                             dictHistorial,
                             dictMantenimiento)

colores = semaforo(strPlaca, dictHistorial,
                   dictMantenimiento)

darservicio = recomendar(strparte,
                         strtipoMantenimiento,
                         dictHistorial,
                         dictMantenimiento)

# SALIDA
print('El diagnóstico de la placa : ', strPlaca)
print(diagnostico)
print('El equivalente en semaforo : ', strPlaca)
print(colores)
print('clientes por dar servicio '+ strtipoMantenimiento + ' de ' + strparte)
print(darservicio)

Ejercicio: 2Eva_IIT2017_T1 Citas San Valentín

Propuesta de solución en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2da Evaluación II Término 2017
# Tema 1. Citas San Valentin

def hayEmparejamiento(codigoP1, codigoP2, dicPersonas, aceptacion):
    tanimoto = 0
    aceptado = False
    gen1 = dicPersonas[codigoP1]['genero']
    gen2 = dicPersonas[codigoP2]['genero']
    caract1 = dicPersonas[codigoP1]['caracteristicas']
    caract2 = dicPersonas[codigoP2]['caracteristicas']
    tanimoto = len(caract1&caract2)/len(caract1|caract2)
    citaf = dicPersonas[codigoP1]['citas']['fallidas']
    citae = dicPersonas[codigoP1]['citas']['exitosas']

    if (gen1!=gen2 and
        tanimoto>=aceptacion and 
        not(codigoP2 in citaf) and
        not(codigoP2 in citae)):
        
        aceptado = True
        
    respuesta = (tanimoto,aceptado)
    return(respuesta)

def imprimirResultados(codigoPersona, dicPersonas,
                       aceptacionMinimo, aceptacionMaximo):
    narchivo = codigoPersona + '.txt'
    archivo  = open(narchivo,'w')
    quienes  = dicPersonas.keys()
    gen1 = dicPersonas[codigoPersona]['genero']
    for otra in quienes:
        gen2 = dicPersonas[otra]['genero']
        
        if (gen1 != gen2 and
            otra != codigoPersona):
            
            nombre = dicPersonas[otra]['nombre']
            linea = otra + '$' + nombre
            caract = dicPersonas[otra]['caracteristicas']
            cadena = ''
            
            for unacaract in caract:
                cadena = cadena + unacaract + ','
                
            cadena = cadena.strip(',')
            linea = linea + '$' + cadena
            tupla = hayEmparejamiento(codigoPersona,
                                      otra,dicPersonas,
                                      aceptacionMinimo)
            tanimoto = tupla[0]
            aceptado = tupla[1]
            linea = linea + '$' + str(tanimoto)
            responde = 'aceptar'
            if aceptado != False:
                responde = 'rechazar'
            linea = linea + '$' + responde + '\n'
            archivo.write(linea)
    archivo.close()
    respuesta = 'Archivos creados'
    return(respuesta)

def compatibles(codigoPersona, dicPersonas, aceptacion=0.43):
    respuesta={}
    quienes = dicPersonas.keys()
    gen1 = dicPersonas[codigoPersona]['genero']
    for otra in quienes:
        gen2 = dicPersonas[otra]['genero']
        if (gen1!= gen2 and otra != codigoPersona):
            tupla = hayEmparejamiento(codigoPersona, otra,
                                      dicPersonas, aceptacion)
            tanimoto=tupla[0]
            if tanimoto>=aceptacion:
                nombre2 = dicPersonas[otra]['nombre']
                caract2 = dicPersonas[codigoP2]['caracteristicas']
                citasf2 = len(dicPersonas[codigoP2]['citas']['fallidas'])
                respuesta[otra] = {'nombre':nombre2,
                                   'caracteristicas':caract2,
                                   'indice': tanimoto,
                                   'fallidas': citasf2
                                   }
    return(respuesta)

# PROGRAMA PRUEBA
# INGRESO datos de prueba
dicPersonas = {
    'p1021': {'nombre': 'Carlos S.',
              'genero': 'm',
              'caracteristicas': {'alegre',
                                  'fumador',
                                  'hacker',
                                  'deportista'},
              'citas': {'fallidas': ['P1902',
                                     'P2893',
                                     'P2310'],
                        'exitosas': ['P4025',
                                     'P1001']}
              },
    'p1001': {'nombre': 'Andrea V.',
              'genero': 'f',
              'caracteristicas': {'farrero',
                                  'programador',
                                  'fabuloso',
                                  'deportista'},
              'citas': {'fallidas': ['P1802'],
                        'exitosas': ['P1021',
                                     'P1002']}
              }
    }

codigoP1 = 'p1021'
codigoP2 = 'p1001'
aceptacionMin = 0.1
aceptacionMax = 0.8

# PROCEDIMIENTO
pareja = hayEmparejamiento(codigoP1,codigoP2,
                           dicPersonas,
                           aceptacionMin)
resultado = imprimirResultados(codigoP1,
                               dicPersonas,
                               aceptacionMin,
                               aceptacionMax)
posibles = compatibles(codigoP1, dicPersonas,
                       aceptacionMin)

# Salida
print('emparejamiento de: ', codigoP1),
print(pareja)
print(resultado)
print('las parejas posibles: ')
print(posibles)

Ejercicio: 2Eva_IIT2017_T2 Reporte comercio internacional

Propuesta de solución en Python:

archivos usados: Flores.txt,  Maderas.txt
para obtener respuestas: categoriasconsolidado.txt, totalFlores, totalMaderas

totales de:  Flores
{('Estados Unidos', 'Ecuador', 'rosas'): 118568,
 ('Holanda', 'Japon', 'tulipanes'): 2384,
 ('Estados Unidos', 'Ecuador', 'girasoles'): 38284}
*** Consolidando productos:  Archivos consolidados guardados
resultados de funcion crearMatriz(): 
(array([[ 38284, 118568,      0,  69284,  69284,  48284],
       [     0,      0,   2384,      0,   3384,      0]]),
       ['Ecuador', 'Japon'],
       ['girasoles', 'rosas', 'tulipanes', 'abeto', 'cereso', 'teca'],
       {'Flores': ['girasoles', 'rosas', 'tulipanes'], 
'Maderas': ['abeto', 'cereso', 'teca']})
*** Ventas por categoria son:  Archivos venta por categoria guardados
>>> 

Instrucciones en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2017_T2 reporte comercio internacional
import numpy as np

def calculaTotales(categoria):
    totales = {}

    narchivo = categoria + '.txt'
    archivo  = open(narchivo,'r')

    # Linea de encabezado
    linea = archivo.readline()
    # Primera linea de datos
    linea = archivo.readline() 
    while not(linea ==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        indice = (partes[0],partes[1],partes[2])
        cantidad = int(partes[3])
        valor = float(partes[4])

        if indice in totales:
            totales[indice] = totales[indice] + cantidad
        else:
            totales[indice] = cantidad
        linea = archivo.readline()
    archivo.close()

    return(totales)

def consolidado(nomArchivo,categorias):
    archivo = open(nomArchivo, 'w')
    for unacat in categorias:
        total = calculaTotales(unacat)

        # totales.update(total)
        for indice in total:
            comp = indice[0] 
            vend = indice[1]
            cate = unacat
            prod = indice[2]
            cant = total[indice]
            linea = comp + ',' + vend + ','
            linea = linea + cate + ',' + prod
            linea = linea + ',' + str(cant) + '\n'
            archivo.write(linea)
            
    archivo.close()

    respuesta = 'Archivos consolidados guardados'
    return(respuesta)

def ventasCategorias(nomArchivo, dicCat):
    # Por simplicidad, supone que el orden
    # en dicCat es el mismo que en
    # lista productos
    # Tarea: seleccionar los 5 vendedores mas bajos

    paisproducto = crearMatriz(nomArchivo)
    matriz     = paisproducto[0]
    vendedores = paisproducto[1]
    productos  = paisproducto[2]
    categorias = dicCat.keys()

    a = 0
    for categ in categorias:
        incluye = dicCat[categ]
        k = len(incluye)
        b = a + k
        seccion = matriz[:,a:b]
        suma = np.sum(seccion, axis=1)
        a = a + k
        
        unifica = []
        for f in range(0,len(vendedores),1):
            unifica.append([vendedores[f],suma[f]])

        narchivo = 'total'+categ+'.txt'
        archivo = open(narchivo,'w')
        for f in range(0,len(unifica),1):
            linea = unifica[f][0]+','+str(unifica[f][1])+'\n'
            archivo.write(linea)
        archivo.close()

    respuesta = 'Archivos venta por categoria guardados'
    return(respuesta)

# El examen supone que esta función ya existe.
# adicionalmete crea dicCat para hacer funcional el problema
def crearMatriz(nomArchivo):
    # Obtiene los indices para la matriz
    vendedores = []
    categoria = {}
    lista = []

    archivo = open(nomArchivo,'r')
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes =  linea.split(',')
        unvendedor = partes[1]
        unacategoria = partes[2]
        unproducto = partes[3]
        cant = int(partes[4])

        if not(unvendedor in vendedores):
            vendedores.append(unvendedor)
        if not(unacategoria in categoria):
            categoria[unacategoria] = [unproducto]
        else:
            if not(unproducto in categoria[unacategoria]):
                categoria[unacategoria].append(unproducto)
        lista.append([unvendedor,unproducto,cant])
        linea = archivo.readline()
    archivo.close()

    # Ordena los productos alfabeticamente
    productos = []
    for unacategoria in categoria:
        prod = categoria[unacategoria]
        prod.sort()
        categoria[unacategoria] = prod
        productos = productos + prod

    # Crea la matriz
    n = len(vendedores)
    m = len(productos)
    matriz = np.zeros(shape=(n,m),dtype=int)
    k = len(lista)
    for i in range(0,k,1):
        fila = vendedores.index(lista[i][0])
        columna = productos.index(lista[i][1])
        matriz[fila,columna] = matriz[fila,columna] + lista[i][2]
    respuesta = (matriz, vendedores, productos,categoria)
    return(respuesta)

# PROGRAMA
# INGRESO datos prueba
categoria = 'Flores'
categorias = ['Flores','Maderas']
nomArchivo = 'categoriasconsolidado.txt'

# PROCEDIMIENTO
totales = calculaTotales(categoria)
consolidaprod = consolidado(nomArchivo, categorias)
paisproducto = crearMatriz(nomArchivo)
dicCat = paisproducto[3]
ventacat = ventasCategorias(nomArchivo, dicCat)

# SALIDA
print('totales de: ', categoria)
print(totales)
print('*** Consolidando productos: ', consolidaprod)
print('resultados de funcion crearMatriz(): ')
print(paisproducto)
print('*** Ventas por categoria son: ', ventacat)

Ejercicio: 3Eva_IT2016_T1 Costo de mensaje

Propuesta de solución en Python:

se requiere los archivos y su contenido: costos.txt

10
0.2
0.5
0.3

mensaje01.txt

El cuerpo humano es el carruaje;
el yo, el hombre que lo conduce;
el pensamiento son las riendas,
y los sentimientos, los caballos.

Algoritmo en Python

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2016_T1 Costo de mensaje
# Tarea: revisar si es necesario el uso de
#  mayúsculas/minúsculas

# literal a)
def cargarDatos(nombreArchivo):
    
    archivo  = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    
    unalinea = unalinea.strip('\n')
    m = int(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    corta    = float(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    larga    = float(unalinea)
    unalinea = archivo.readline()
    unalinea = unalinea.strip('\n')
    infinitivo = float(unalinea) 

    archivo.close()

    tarifas = {'m':m,
               'corta':corta,
               'larga':larga,
               'infinitivo':infinitivo}
    return(tarifas)


def cargarDatos2(nombreArchivo):
    lista = []
    
    archivo  = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    while not(unalinea==''):
        unalinea = unalinea.strip('\n')
        lista.append(unalinea)
        unalinea = archivo.readline()
    archivo.close()

    tarifas = {'m':int(lista[0]),
               'corta':float(lista[1]),
               'larga':float(lista[2]),
               'infinitivo':float(lista[3])}
    return(tarifas)

def calcularCostos(tarifas, nombreArchivo):
    costo = 0
    # Carga en una lista
    lista = []
    archivo  = open(nombreArchivo, 'r')
    unalinea = archivo.readline()
    while not(unalinea==''):
        unalinea = unalinea.strip('\n')
        lista.append(unalinea)
        unalinea = archivo.readline()
    archivo.close()
    #Procesar las lineas
    n = len(lista)
    i = 0
    while not(i>=n):
        linea = lista[i]
        palabras = linea.split(' ')
        m = len(palabras)

        j = 0
        while not(j>=m):
            palabras[j] = palabras[j].strip(',')
            palabras[j] = palabras[j].strip(';')
            palabras[j] = palabras[j].strip('.')
            tamano = len(palabras[j])

            valor  = 0
            if (tamano  tarifas['m']):
                valor = tarifas['larga']
            k = len(palabras[j])
            ultimas = palabras[j][k-2]+palabras[j][k-1]

            if (ultimas == 'ar' or ultimas=='er' or ultimas=='ir'):
                valor = tarifas['infinitivo']
            costo = costo + valor
            j = j + 1
            
        i = i + 1
    return(costo)

# PROGRAMA DE PRUEBA
tarifas = cargarDatos('costos.txt')
costo = calcularCostos(tarifas, 'mensaje01.txt')
print(costo)

Ejercicio: 1Eva_IIT2017_T3 Venta combustibles

Propuesta de solución en Python:

Se usan datos de prueba para probar la ejecución del algoritmo por cada literal. En el bloque de ingreso se pide solo un tipo de combustible (literal a) y una ciudad (literal b).

Se usa vector.index(dato) para ubicar la posición de un dato en el vector.

# literal a
cual     = tipoGasolina.index(untipo)
cantidad = venta[cual,:]
prom_anual =  np.sum(cantidad)/m
menosprom  = []
for c in range(0,m,1):
    if (cantidad<prom_anual):
        menosprom.append(gasolinera)

Como algunas respuestas tienen un número indeterminado de elementos se usan listas, al inicio vacías. Revise el uso de np.concatenate() para hacerlo con arreglos.

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T3 Venta combustibles
import numpy as np

# INGRESO
venta = np.array([
    [ 239034,  678493,  896321,   32438,  554213],
    [4568321, 6745634, 9754008, 3242342, 3456123],
    [ 234773,   56743,  123678,    4783,   90874],
    [  45672,   45212,   90781,    3904,   90431]])

tipoGasolina = np.array(['Regular',
                         'Extra',
                         'Super',
                         'Premium'])

gasolinera  = np.array(['Primax Alborada',
                        'PS Los Ríos',
                        'Móbil Cumbayá',
                        'Lutexa Cia Ltda',
                        'PS Remigio Crespo'])

distrito = np.array(['distrito1',
                     'distrito2',
                     'distrito1',
                     'distrito2',
                     'distrito4'])

ciudad =  np.array(['Guayaquil',
                    'Babahoyo',
                    'Quito',
                    'Guayaquil',
                    'Cuenca'])

meta = 5000000

untipo    = input('un tipo de gasolina: ')
unaciudad = input('una ciudad: ')

# PROCEDIMIENTO
tipoGasolina = list(tipoGasolina)
gasolinera   = list(gasolinera)
distrito = list(distrito)
ciudad   = list(ciudad)

tamano = np.shape(venta)
n = tamano[0]
m = tamano[1]

# literal a
cual     = tipoGasolina.index(untipo)
cantidad = venta[cual,:]
prom_anual =  np.sum(cantidad)/m
menosprom  = []
for c in range(0,m,1):
    if (cantidad<prom_anual):
        menosprom.append(gasolinera)

# literal b
cual  = ciudad.index(unaciudad)
anual = np.sum(venta, axis=0)
menosciudad = []
for c in range(0,m,1):
    if (ciudad == unaciudad  and anual<meta):
        menosciudad.append(gasolinera)
cuantas = len(menosciudad)

# literal c
cual = tipoGasolina.index('Premium')
cantidad = venta[cual,:]
nombres = []
valores = []
for c in range(0,m,1):
    if (distrito == 'distrito2'):
        nombres.append(ciudad)
        valores.append(cantidad)

k = len(nombres)
mayor = np.argmax(np.array(valores))
mejorendistrito = nombres[mayor]

# SALIDA
print('literal a')
print('con menos ventas anuales que promedio: ')
print(menosprom)

print('literal b')
print('cantidad de estaciones de ' + unaciudad + ': ')
print(cuantas)

print('literal c')
print(nombres)
print(valores)
print(mejorendistrito)

Resultado del algoritmo

un tipo de gasolina: Regular
una ciudad: Guayaquil
literal a
con menos ventas anuales que promedio: 
['Primax Alborada', 'Lutexa Cia Ltda']
literal b
cantidad de estaciones de Guayaquil: 
1
literal c
['Babahoyo', 'Guayaquil']
[45212, 3904]
Babahoyo
>>> 

Ejercicio: 1Eva_IIT2017_T1 Taller de juguetes en polo norte

Propuesta de solución en Python:

Los tiempos para finalizar las tareas se obtienen como la suma de los tiempos de inicio mas los tiempos de duración.

Para realizar la mayor cantidad de tareas, se usan los tiempos para finalizarlas, buscando la posición en la lista de la mayor. Al encontrarla se puede establecer el orden.

El proceso se repite para el resto de tareas. Para que no se utilice la primera encontrada se elimina de la lista asignando el tiempo final con cero.

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T1 Taller de juguetes en polo norte
import numpy as np

# INGRESO
tareas = ['pintar soldados',
          'hornear galletas',
          'armar muñecos',
          'cortar papel de regalo']
inicio   = [ 678, 200, 240, 423]
duracion = [ 300, 800, 456, 112]

# PROCEDIMIENTO
n = len(tareas)

# tiempo finaliza tarea
final = np.zeros(n,dtype=int)
i = 0
while not(i>=n):
    final[i] = inicio[i] + duracion[i]
    i = i + 1

# Determina el orden
finaliza = np.copy(final)
orden = np.zeros(n,dtype = int)
j = 0
while not(j>=n):
    
    mayor = 0
    i = 1
    while not(i>=n):
        if (final[i]>final[mayor]):
            mayor = i
        i = i + 1
    
    orden[j] = mayor
    final[mayor] = 0
    j = j + 1
    
# dias de trabajo
dia  = np.zeros(n,dtype = int)
cual = 1
suma = 0
j = 0
while not(j>=n):
    suma = suma + finaliza[j]
    if (suma>=1440):
        cual = cual + 1
        suma = finaliza[j]
    dia[j] = cual
    j = j + 1
   
# SALIDA
print('finaliza')
print(finaliza)

print('Tareas del dia')
s = 0
i = 0
while not(i>=n):
    cual = orden[i]
    s = s + finaliza[cual]
    print(i, cual, tareas[cual], s, dia[i])
    i = i + 1

Resultado del algoritmo

finaliza
[ 978 1000  696  535]
Tareas del dia
0 1 hornear galletas 1000 1
1 0 pintar soldados 1978 2
2 2 armar muñecos 2674 3
3 3 cortar papel de regalo 3209 3
>>> 

Ejercicio: 1Eva_IIT2017_T2 Texto de Examen de sangre

Propuesta de solución en Python:

Para simplificar el ejercicio, se supondrá que el resultado corresponde al texto del ejemplo en el enunciado:

resultado = "Resultado de Laboratorio 'Su Salud' Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo"

El texto se analiza separando las partes usando los espacios '  '.

>>> partes = resultado.split(' ')
>>> partes
['Resultado', 'de', 'Laboratorio', "'Su", "Salud'",
 'Nombre', 'del', 'paciente:', 'José', 'Aimas',
...
]
>>> 

Se analiza cada una de las partes, considerando que los "indicadores buscados" tienen todas las letras en mayúsculas a diferencia del resto de partes o palabras. Por lo que se compara la conversión de la parte en mayúsculas y su forma original o sinconvertir, si son iguales se encontró un indicador.
Considere que si la parte es numérica, no se afecta al convertir en mayúscula.

>>> i=0
>>> mayusculas = partes[i].upper()
>>> sinconvertir = partes[i]
>>> mayusculas
'RESULTADO'
>>> sinconvertir
'Resultado'
>>> mayusculas == sinconvertir
False
>>> 

Al encontrar un indicador, se lo separa en otra lista de solo indicadores.

Algoritmo en Python

# CCPG1001 Fundamentos de Programación FIEC-ESPOL
# 1Eva_IIT2017_T2 Examen de sangre
# Tarea: Encontrar nombre del médico

# INGRESO
resultado = "Resultado de Laboratorio 'Su Salud' Nombre del paciente: José Aimas E-mail del paciente: jose.aimas@gmail.com Resultados del laboratorio: INR 1.25 segundos BGT 180.12 mmol/dL HGB 13 g/dL ESR 3.2 mm/hora RBC 4000024.2 cel/ul TA 1.5 ng/dL WBC 123233.23 cel/uL. Los valores de éste informe no representan un diagnóstico. Firma médico responsable: Dr. Juan Pozo"

# PROCEDIMIENTO
partes = resultado.split(' ')
n = len(partes)

# Encontrar indicadores
numero = '0123456789'
indicador = []
i = 0
while not(i>=n):
    mayusculas   = partes[i].upper()
    sinconvertir = partes[i]
    unapalabra   = partes[i]
    unaletra     = unapalabra[0]
    if (mayusculas==sinconvertir and not(unaletra in numero)):
        indicador.append(partes[i])
    i = i + 1
m = len(indicador)

# Busca por indicadores
valor  = []
unidad = []
k = 0
while not(k>=m):
    i = 0
    while not(i>=n):
        if (partes[i]==indicador[k]):
            valor.append(partes[i+1])
            unidad.append(partes[i+2])
        i = i + 1
    k = k + 1

# SALIDA
print('INFORME DE LABORATORIO')
print('**********************')
i = 0
while not(i>=m):
    print(indicador[i],valor[i],unidad[i])
    i = i + 1

Resultado del algoritmo

INFORME DE LABORATORIO
**********************
INR 1.25 segundos
BGT 180.12 mmol/dL
HGB 13 g/dL
ESR 3.2 mm/hora
RBC 4000024.2 cel/ul
TA 1.5 ng/dL
WBC 123233.23 cel/uL.
>>> 

Ejercicio: 3Eva_IT2017_T1 Archivos de notas por semestre

Propuesta de solución en Python:

Para la prueba del algoritmo, se requiere los archivos:

notas-2015-I.csv

notas-2013-II.csv

Algoritmo en Python

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2017_T1 Archivos de notas por semestre
# Tarea: una vez comprendido los pasos, 
#        simplificar de ser posible
import numpy as np

def academico(narchivos):
    notas = {}
    n = len(narchivos)
    for i in range(0,n,1):
        archivo = open(narchivos[i],'r')

        # semestre en el nombre
        nombre = narchivos[i]
        partes = nombre.split('.')
        semestre = partes[0][6:]

        # Datos del archivo
        linea = archivo.readline()
        while not(linea==''):
            linea   = linea.strip('\n')
            partes  = linea.split(',')
            quien   = int(partes[0])
            materia = partes[1]
            nota1   = int(partes[2])
            nota2   = int(partes[3])
            nota3   = int(partes[4])
            estado  = partes[5]
            califica = (materia,nota1,nota2,
                        nota3,estado)

            # Revisar estudiante creado
            estudiantes = notas.keys()
            if not(quien in estudiantes):
                notas[quien] = {semestre:[califica]}
            else:
                cuando = notas[quien].keys()
                if (semestre in cuando):
                    notas[quien][semestre].append(califica)
                else:
                    notas[quien][semestre] = [califica]

            linea = archivo.readline()
        archivo.close()
    return(notas)

def semestres(notas,matricula):
    estudiantes = notas.keys()
    cuando = ()
    if (matricula in estudiantes):
        cuando = notas[matricula].keys()
    cuando = tuple(cuando)
    return(cuando)

def nota_academico(notas,matricula,materia):
    califica = []
    estudiantes = notas.keys()
    # Desarrollar tarea
        
    return(nota_final)

def mas_aprobados(notas,semestre):
    # Separa dictadas y aprobadas en el semestre
    dictadas = []
    estudiantes = notas.keys()
    for quien in estudiantes:
        cuando = notas[quien].keys()
        if (semestre in cuando):
            registradas = notas[quien][semestre]
            n = len(registradas)
            for i in range(0,n,1):
                if (registradas[i][4] == 'AP'):
                    dictadas.append(registradas[i][0])

    # Cuenta las repetidas
    m = len(dictadas)
    lista = list(set(dictadas))
    conteo = {}
    for j in range(0,m,1):
        una = dictadas[j]
        if (una in conteo):
            conteo[una] = conteo[una]+1
        else:
            conteo[una] = 1

    # busca la mas aprobada
    mejor = ''
    if (len(conteo)>0):
        llaves  = list(conteo.keys())
        valores = np.array(conteo.values())
        mejor   = llaves[np.argmax(valores)]
    return(mejor)

# PROGRAMA
# INGRESO /siguiendo ejemplo de examen
narchivos = ['notas-2015-I.csv',
           'notas-2013-II.csv']
matricula = 201321454
materia   = 'Fundamentos de Programación'
semestre  = '2015-I'

# PROCEDIMIENTO
notas = academico(narchivos)
semestres  = semestres(notas, matricula)
nota_final = nota_academico(notas, matricula, materia)
alto_AP = mas_aprobados(notas, semestre)

# SALIDA
print('las notas son: ')
print(notas)
print('--- para '+str(matricula) + ': ')
print('semestres que estudió: ',semestres)
print('notas final para '+materia+': ',nota_final)
print('--- En el semestre '+semestre + ': ' )
print('la materia con alto indice de aprobación es: ',
      alto_AP)

Ejercicio: 3Eva_IT2017_T2 Huracanes en Atlantico Norte

Propuesta de solución en Python:

# CCPG1001-Fundamentos de Programación - FIEC-ESPOL
# 3Eva_IT2017_T2 Huracanes en Atlantico Norte
# Supone que el numero de columnas de M
# Es igual al numero de nombres en huracanes

import numpy as np

def categoriza(M):
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]
    categoria = np.ones(m, dtype=int)
    for j in range(0,m,1):
        vv = M[2,j]
        if (vv>=100 and vv=150 and vv=200 and vv250):
            categoria[j]=5
    return(categoria)

def total_marejada(M,cat):
    categoria = categoriza(M)
    
    tamano = np.shape(M)
    n = tamano[0]
    m = tamano[1]

    marejadas = np.zeros(6,dtype=float)
    for j in range(0,m,1):
        k = categoria[j]
        marejadas[k] = marejadas[k]+M[4,j]
    totaluna = marejadas[cat]
    return(totaluna)

def indices_anio(huracanes,anio):
    # Supone que cantidad de huracanes
    # es igual a columnas de matriz
    cuales  = huracanes.keys()
    indices = {}
    a = 0
    b = -1
    for cada in cuales:
        m = len(huracanes[cada])
        a = b + 1
        b = a + m-1
        indices[cada] = [a,b]
    return(indices[anio])

def velocidad_superior(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    promedio = np.mean(vector)
    cuantos = 0
    for valor in vector:
        if (valor>promedio):
            cuantos = cuantos + 1
    return(cuantos)

def ACE(M,huracanes,anio):
    cual   = indices_anio(huracanes,anio)
    desde  = cual[0]
    hasta  = cual[1]
    vector = M[0,desde:hasta+1]
    liberada = 0
    for valor in vector:
        liberada = liberada + valor**2
    liberada = liberada*(10**(-4))
    return(liberada)

def lluvia(M, huracanes, nombre_huracan,anio):
    nombres = huracanes[anio]
    nombres = list(nombres)
    donde   = nombres.index(nombre_huracan)
    cual  = indices_anio(huracanes,anio)
    desde = cual[0]
    hasta = cual[1]
    cantidad = M[3,desde+donde]
    return(cantidad)

# PROGRAMA ------------------------
import numpy as np

M = np.array([[20, 30, 19, 15, 18],
              [89,195,120,150,240],
              [65,165,100,110,200],
              [30, 49, 35, 89, 67],
              [ 5, 18,  1,  2,  5]]
             )
# 2015:('Ana','Kate'), # No usado para el ejemplo (CONFUSO)
huracanes = {2016:('Alex', 'Otto'),
             2017:('Ariene', 'Harvey','Irma'),
             }
cat = 2
anio = 2017
nombre_huracan = 'Harvey'

# PROCEDIMIENTO
categoria = categoriza(M)
marejadas = total_marejada(M,cat)
indices   = indices_anio(huracanes,anio)
vel_superior = velocidad_superior(M,huracanes,anio)
energia = ACE(M,huracanes,anio)
llovio  = lluvia(M, huracanes, nombre_huracan,anio)

# SALIDA
print(M)
print(huracanes)
print('---')
print('categorias: ', categoria)
print('Marejadas cat['+str(cat)+']: ', marejadas)
print('indices: ', indices)
print('velocidad superior: ', vel_superior)
print('Energia liberada: ',energia)
print('lluvia en mm: ', llovio)