s2Eva_IIT2015_T4 biciespol, prestamos de bicicletas

Ejercicio: 2Eva_IIT2015_T4 biciespol, prestamos de bicicletas

Desarrollo del algoritmo en Python:

# ICM00794-Fundamentos de Computación - FCNM-ESPOL
# 2Eva_IIT2015_T4 biciespol, prestamos de bicicletas
# Tarea: validar matricula de estudiante

opcion = -1 # aun no es escoge una opcion
while not(opcion==6):
    # Presenta el menú
    print('Menú:')
    print('1. Formulario de Préstamos')
    print('2. Registro de bicicletas')
    print('3. Préstamo')
    print('4. Devolución')
    print('5. Inventario de estado')
    print('6. Salir')
    
    opcion = int(input('cual es su opcion:'))
    
    if opcion==1:
        # Ingresa un estudiante
        mat  = input('matricula: ')
        nom  = input('nombre: ')
        carr = input('carrera: ')
        unestudiante = [mat,nom,carr]
        formulario.append(unestudiante)

    if opcion==2:    
        # Bicicletas
        m =  int(input('cuantas bicicletas:'))
        bicicletas =[]
        j = 0
        while not(j>=m):
            cod = input('codigo: ')
            est = 0 # iniciar con cero
            ubi = int(input('ubicacion:'))
            # crea un registro
            unabici = [cod,est,ubi]
            # Añade a la tabla
            bicicletas.append(unabici)
            j = j+1

    if opcion==3:
        
        est = input('matricula')
        cod = input('codigo: ')
        ubi = int(input('ubicacion'))

        # Tarea: validar matricula de estudiante

        # busca la bicicleta
        m = len(bicicletas)
        j = 0
        while not(j>=m):
            if bicicletas[j][0]==cod:
                donde = j
            j = j + 1
        
        # prestamo
        if (bicicletas[donde][1] == '0' and bicicletas[donde][2]==ubi):
            bicicletas[donde][1] = est
            bicicletas[donde][2] = 0
            
    # Opciones 4 y 5 continuan en el siguiente laboratorio
    
    if opcion==6:
        print('gracias por usar el software...')
        print('@espol.edu.ec')

s2Eva_IIT2018_T4 Hielo y especies en Ártico-programa

Ejercicio: 2Eva_IIT2018_T4 Hielo y especies en Ártico-programa

Finalmente, se crea el programa que usa las funciones anteriores:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T4 Hielo y especies en Ártico-programa

# ----- NUMERAL 1 y 6----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# ----- NUMERAL 7-----
especies19 = np.unique(manimales19)
k = len(especies19)
comunes = []
for i in range(0,k,1):
    animal = especies19[i]
    Q = cuadrantes(manimales09)
    animal124 = np.concatenate([Q[0],Q[1],Q[3]]) 
    if (animal in animal124) and not(animal in Q[2]):
        comunes.append(animal)
        
# ----- NUMERAL 8-----
migra3 = migracionEspecie(manimales09, manimales19,3)
migro3 = 0
if (migra3[0]!=migra3[1]):
    migro3 =1
# ----- NUMERAL 9-----
# TAREA

# SALIDA
print(' ----- NUMERAL 1 y 6 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

print(' ----- NUMERAL 7 ----- ')
print('animales comunes: ')
print(comunes)

print(' ----- NUMERAL 8 ----- ')
print('migracion de 3:')
print(migra3)
print('migracion: ',migro3)

print(' ----- NUMERAL 9 ----- ')
print('Tarea...')

s2Eva_IIT2018_T3 Hielo y especies en Ártico-Diccionario

Ejercicio2Eva_IIT2018_T3 Hielo y especies en Ártico-Diccionario

}continuación de los temas anteriores:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T3 Hielo y especies en Ártico-Diccionario

# ----- NUMERAL 5 -----
def crearDiccionario(mHielo, mAnimales, dicEspecies):
    densidad = densidadHielo(mHielo)
    k = len(densidad)
    tablad = {}
    for i in range(0,k,1):
        indice = 'Q'+str(i+1)
        tablad[indice] = densidad[i]

    especies = list(dicEspecies.keys())
    ke = len(especies)
    tablae = {}
    for j in range(0,ke,1):
        animal = especies[j]
        conteo = poblacionEspecie(mAnimales, animal)
        tablae[animal] = np.sum(conteo)
    
    tabla={}
    tabla['densidad hielo'] = tablad
    tabla['Especies'] = tablae
    return(tabla)

para probar con el computador, se usa el diccionario y los resultados anteriores:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T3 Hielo y especies en Ártico-Diccionario

# ----- NUMERAL 5 -----
dicEspecies = {0:'No hay animal',
               1:'Lobo ártico',
               2:'Oso Polar',
               3:'Reno',
               4:'Foca',
               5:'...',
               7:'a7',
               9:'a9',
               22:'a22'}
datosdic = crearDiccionario(mhielo09,
                            manimales09,
                            dicEspecies)

#------------------------------------
print(' ----- NUMERAL 5 ----- ')
print('diccionario para año 2009')
print(datosdic)

con lo que los resultados son:

 ----- NUMERAL 5 ----- 
diccionario para año 2009
{'densidad hielo': {'Q1': 0.5,
                    'Q2': 0.6666666666666666,
                    'Q3': 0.8333333333333334,
                    'Q4': 0.5},
 'Especies': {0: 1,
              1: 7,
              2: 3,
              3: 2,
              4: 6,
              5: 2,
              7: 1,
              9: 1,
              22: 1}
 }

s2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar

Ejercicio2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar

Se añade las instrucciones al tema anterior,

Se incluyen las funciones que se asume como existentes para prueba de programa. En caso de problemas o dudas con el conteo, elaborar una función contar.

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 2 ----- 
# Funciones que suponen que existen:
def cuadrantes(matriz):
    tamano = np.shape(matriz)
    n = tamano[0]
    m = tamano[1]
    mitadfila = n//2
    mitadcolumna = m//2
    Q1 = matriz[0:mitadfila,0:mitadcolumna]
    Q2 = matriz[0:mitadfila,mitadcolumna:]
    Q3 = matriz[mitadfila:,0:mitadcolumna]
    Q4 = matriz[mitadfila:,mitadcolumna:]
    Q = np.array([Q1,Q2,Q3,Q4])
    return(Q)

def poblacionEspecie(mAnimales, especie):
    Q = cuadrantes(mAnimales)
    # pQ1 = np.count_nonzero(Q[0],especie)
    # np.count_nonzero no hay en funciones referencia
    # no en cheatsheet “Cheat Sheet”
    # se procede con algoritmo básico
    k = len(Q)
    poblacion = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        for f in range(0,n,1):
            for c in range(0,m,1):
                if (unaQ[f,c] == especie):
                    poblacion[i] = poblacion[i] +1
    return(poblacion)

# otra forma es usar una funcion contar en arreglo
def contarenarreglo(arreglo,cual):
    tamano = np.shape(arreglo)
    n = tamano[0]
    m = tamano[1]
    contar = 0
    for f in range(0,n,1):
        for c in range(0,m,1):
            if (arreglo[f,c] == cual):
                contar = contar+1
    return(contar)



Desarrollo del numeral 2:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# funcion numeral 2
def densidadHielo(mHielo):
    Q = cuadrantes(mHielo)
    k = len(Q)
    densidad = np.zeros(k,dtype=float)
    for i in range(0,k,1):
        unaQ = Q[i]
        tamano = np.shape(unaQ)
        n = tamano[0]
        m = tamano[1]
        densidad[i]=np.sum(unaQ)/(n*m)
    return(densidad)

desarrollo del numeral 3:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 3 -----
def especieDominante(mAnimales):
    especies = np.unique(mAnimales)
    ke = len(especies)
    
    Q = cuadrantes(mAnimales)
    k = len(Q)
    dominante = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos = np.zeros(ke,dtype=int)
        for j in range(0,ke,1):
            # solución semejante al NUMERAL 2
            # para poblacionEspecie
            animal = especies[j]
            cuantos[j] = contarenarreglo(unaQ,animal)
        mayoria = np.argmax(cuantos)
        dominante[i]= especies[mayoria]
    return(dominante)

desarrollo del numeral 4

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# ----- NUMERAL 4 -----
def migracionEspecie(mAnimales2009, mAnimales2019, especie):
    Q = cuadrantes(mAnimales2009)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria09 = np.argmax(cuantos)

    Q = cuadrantes(mAnimales2019)
    k = len(Q)
    cuantos = np.zeros(k,dtype=int)
    for i in range(0,k,1):
        unaQ = Q[i]
        cuantos[i] = contarenarreglo(unaQ,especie)
    mayoria19 = np.argmax(cuantos)
    
    # considere numeración desde 0
    a = 'Q'+str(mayoria09+1)
    b = 'Q'+str(mayoria19+1)
    migraron =[a,b]
    return(migraron)


Programa de prueba, incluye las partes del tema anterior

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T2 Hielo y especies en Ártico-Procesar
import numpy as np

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'
especie = 4

# PROCEDIMIENTO

# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# ----- NUMERAL 2 ----- 
Q = cuadrantes(manimales09)
poblacion = poblacionEspecie(manimales09, especie)
densidad = densidadHielo(mhielo09)

# ----- NUMERAL 3 -----
dominante = especieDominante(manimales09)

# ----- NUMERAL 4 -----
migraron = migracionEspecie(manimales09, manimales19, especie)


# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

print(' ----- NUMERAL 2 ----- ')
print('cuadrantes de manimales09')
print(Q)
print('población por cuadrantes de manimales09')
print('para especie = 4')
print(poblacion)
print('densidad de hielo para mhielo09')
print(densidad)

print(' ----- NUMERAL 3 ----- ')
print('dominantes en manimales09')
print(dominante)
print(' ----- NUMERAL 4 ----- ')
print('migraron de la especie: ',especie)
print(migraron)

Los resultados obtenidos son:

animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]

 ----- NUMERAL 2 ----- 
cuadrantes de manimales09
[[[ 1  2]
  [ 2  5]
  [ 1  3]]

 [[ 4  4]
  [ 5  3]
  [ 9  1]]

 [[ 1  1]
  [ 4 22]
  [ 1  1]]

 [[ 4  2]
  [ 4  7]
  [ 4  0]]]
población por cuadrantes de manimales09
para especie = 4
[0 2 1 3]
densidad de hielo para mhielo09
[0.5        0.66666667 0.83333333 0.5       ]
 ----- NUMERAL 3 ----- 
dominantes en manimales09
[1 4 1 4]
 ----- NUMERAL 4 ----- 
migraron de la especie:  4
['Q4', 'Q2']

s2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

Ejercicio: 2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

Usando el archivo proporcionado en el ejemplo: ‘artico2009-2019.txt

se crea la función y programa de prueba con las instrucciones más básicas y simples:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IIT2018_T1 Hielo y especies en Ártico-Archivo

# ----- NUMERAL 1 ----- 
def crearMatriz(narchivo):
    archivo = open(narchivo,'r')
    
    # dimensiones de matriz
    linea = archivo.readline()
    n = int(linea.strip('\n'))
    linea = archivo.readline()
    m = int(linea.strip('\n'))
    # se crean las matrices
    mhielo09 = np.zeros(shape=(n,m),dtype=int)
    mhielo19 = np.zeros(shape=(n,m),dtype=int)
    manimales09 = np.zeros(shape=(n,m),dtype=int)
    manimales19 = np.zeros(shape=(n,m),dtype=int)
    
    # linea encabezados, No procesada
    linea = archivo.readline()
    
    # linea datos
    linea = archivo.readline()
    while not(linea==''):
        linea = linea.strip('\n')
        partes = linea.split(',')
        anio    =  partes[0]
        fila    = int(partes[1])
        columna = int(partes[2])
        hielo   = int(partes[3])
        animal  = int(partes[4])
        if (anio =='2009'):
            mhielo09[fila,columna] = hielo
            manimales09[fila,columna] = animal
        if (anio =='2019'):
            mhielo19[fila,columna] = hielo
            manimales19[fila,columna] = animal
        linea = archivo.readline()
    archivo.close()
    matrices = [mhielo09,
                mhielo19,
                manimales09,
                manimales19]
    return(matrices)

# PROGRAMA DE PRUEBA
# INGRESO
narchivo = 'artico2009-2019.txt'

# PROCEDIMIENTO
# ----- NUMERAL 1 ----- 
matrices = crearMatriz(narchivo)
mhielo09 = matrices[0]
mhielo19 = matrices[1]
manimales09 = matrices[2]
manimales19 = matrices[3]

# SALIDA
print(' ----- NUMERAL 1 ----- ')
print('hielo 2009')
print(mhielo09)
print('hielo 2019')
print(mhielo19)
print('animales 2009')
print(manimales09)
print('animales 2019')
print(manimales19)

para obtener:

 ----- NUMERAL 1 ----- 
hielo 2009
[[1 0 0 1]
 [0 1 1 1]
 [1 0 1 0]
 [1 1 1 0]
 [0 1 0 1]
 [1 1 1 0]]
hielo 2019
[[1 0 0 1]
 [0 1 0 1]
 [1 0 1 0]
 [1 0 1 0]
 [0 1 0 1]
 [0 0 1 0]]
animales 2009
[[ 1  2  4  4]
 [ 2  5  5  3]
 [ 1  3  9  1]
 [ 1  1  4  2]
 [ 4 22  4  7]
 [ 1  1  4  0]]
animales 2019
[[ 3  2  4  1]
 [ 0 11  3  5]
 [ 1  0 67  1]
 [ 2 22  3  2]
 [13 13  2  3]
 [ 3  0  1  0]]

s2Eva_IT2016_T1 Tendencias en Twitter

Ejercicio: 2Eva_IT2016_T1 Tendencias en Twitter

Propuesta de solución en Python:

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IT2016_T1 Tendencias en Twitter

def reportatendencia(tendencias,fecha1,fecha2):
    etiquetasf1 = tendencias[fecha1]
    n = len(etiquetasf1)
    etiquetasf2 = tendencias[fecha2]
    m = len(etiquetasf2)
    difsimetrica =[]
    i = 0
    while not(i>=n):
        # TAREA

        i = i + 1  
    return(difsimetrica)

def cuentaTopics(tendencias, listaFechas):
    fechaslista = list(listaFechas)
    n = len(fechaslista)
    union = {}
    i = 0
    while not(i>=n):
        etiquetas = tendencias[fechaslista[i]]
        etiquetas = list(etiquetas)
        m = len(etiquetas)
        j = 0
        while not(j>=m):
            if not(etiquetas[j] in union):
                union[etiquetas[j]]=0
            j = j + 1
        i = i + 1
        
    # contadores
    i = 0
    while not(i>=n):
        etiquetas = tendencias[fechaslista[i]]
        etiquetas = list(etiquetas)
        m = len(etiquetas)
        j = 0
        while not(j>=m):
            cual = etiquetas[j]
            union[cual] = union[cual] + 1
            j = j + 1
        i = i + 1

    return(union)

tendencias = {
    '08-22-2016':{'#Rio2016', '#BSC', '#ECU'},
    '08-25-2016':{'#GYE', '#BRA'},
    '08-27-2016':{'#YoSoyEspol', '#GYE', '#BSC'}
    }

listaFechas = ['08-22-2016','08-27-2016']
# PROCEDIMIENTO
cuales = cuentaTopics(tendencias, listaFechas)

print(cuales)

s2Eva_IT2018_T2 Pago nomina mensual

Propuesta de solución en Python:

archivo de prueba: meshoratrabajada.txt

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IT2018_T2 Pago nomina mensual
# Propuesta modo simple pero larga
# Tarea: Proponer simplificaciones a los algoritmos

def calcularHoras(linea):
    linea  = linea.strip('\n')
    partes = linea.split(',')
    fecha  = partes[0]
    dia = int(partes[1])
    esferiado = partes[2]
    ID = partes [3]
    nombre   = partes[4]
    sucursal = partes[5]
    ciudad   = partes[6]
    horas    = int(partes[7])

    trabajado = [ID,ciudad, 0,0,0,0]
    if (esferiado=='Si'):
        trabajado[5] = horas
    else:
        if (dia>=6):
            trabajado[4] = horas
        else:
            if (horas<=8):
                trabajado[2] = horas
            else:
                trabajado[2] = 8
                trabajado[3] = horas-8
    return(trabajado)

def leerData(nomA):
    
    total = {}
    archivo = open(nomA,'r')
    # factores
    linea = archivo.readline()
    linea = linea.strip('\n')
    partes = linea.split(',')
    VH = float(partes[1])
    
    linea = archivo.readline()
    linea = linea.strip('\n')
    partes = linea.split(',')
    
    HR = float(partes[1])
    linea = archivo.readline()
    linea = linea.strip('\n')
    partes = linea.split(',')
    
    HER = float(partes[1])
    linea = archivo.readline()
    linea = linea.strip('\n')
    partes = linea.split(',')
    
    HFDS = float(partes[1])
    linea = archivo.readline()
    linea = linea.strip('\n')
    partes = linea.split(',')
    HF = float(partes[1])
    
    # encabezado
    linea = archivo.readline()
    
    # datos    
    linea = archivo.readline()
    parafecha = linea.split(',')
    parafecha = parafecha[0].split('-')
    mes = parafecha[1]
    anio = parafecha[2]
    
    while not(linea==''):
        trabajado = calcularHoras(linea)
        ID = trabajado[0]
        ciudad = trabajado[1]
        normal = trabajado[2]*VH*HR
        extra = trabajado[3]*VH*HER
        finsem = trabajado[4]*VH*HFDS
        feriado = trabajado[5]*VH*HF
        
        if not(ciudad in total):
            total[ciudad] = {ID:{'HR': normal,
                                'HER': extra,
                                'HFDS': finsem,
                                'HF': feriado}}
        else:
            if not(ID in total[ciudad]):
                total[ciudad][ID] = {'HR': normal,
                                     'HER': extra,
                                     'HFDS': finsem,
                                     'HF': feriado}
            else:
                total[ciudad][ID]['HR'] = total[ciudad][ID]['HR'] + normal
                total[ciudad][ID]['HER'] = total[ciudad][ID]['HER'] + extra
                total[ciudad][ID]['HFDS'] = total[ciudad][ID]['HFDS'] + finsem
                total[ciudad][ID]['HF'] = total[ciudad][ID]['HF'] + feriado
        linea = archivo.readline()     
    
    archivo.close()
    pagonomina = (total,mes,anio)
    return(pagonomina)

def generareporte(nomA):
    pagonomina = leerData(nomA)
    total  = pagonomina[0]
    mes    = pagonomina[1]
    anio   = pagonomina[2]
    ciudad = list(total.keys())
    
    for lugar in ciudad:
        narchivo = lugar+mes+'-'+anio+'.txt'
        archivo  = open(narchivo,'w')
        registro = total[lugar]
        # Tarea: Poner encabezado
        
        for empleado in registro:
            linea = empleado +','+str(total[lugar][empleado]['HR'])
            extra = total[lugar][empleado]['HER']+ total[lugar][empleado]['HFDS'] +total[lugar][empleado]['HF']
            linea = linea+','+str(extra)+'\n'
            archivo.write(linea)
            
        archivo.close()
    mensaje = 'archivo guardado'
    return(mensaje)

# PROGRAMA PRUEBA -------------------
# INGRESO
nomA = 'meshoratrabajada.txt'

# PROCEDIMIENTO
mensaje = generareporte(nomA)

# SALIDA
print(mensaje)

s2Eva_IT2018_T1 Niveles seguridad por ciudad

Propuesta de solución en Python:

Como referencia para el algoritmo se usa la tabla:

incidentes
ciudad robo vehículos asalto
Guayaquil 605 6345
Cuenca 123 676

El módulo cargarDatos() desde un archivo se guarda como ecu911.py
La sección no era necesario escribirla en la evaluación, se podría suponer que ya estaba escrita.

# CCPG1001-Fundamentos de programación FIEC-ESPOL
# 2Eva_IT2018_T1 Niveles seguridad por ciudad
import numpy as np
import ecu911 es ecu

def titulostabla(tabla_dic):
    ciudad = tabla_dic.keys()
    ciudad = list(ciudad)
    
    unaciudad = ciudad[0]
    unregistro = tabla_dic[unaciudad]
    
    tipodelito = unregistro.keys()
    tipodelito = list(tipodelito)
    
    titulos = [ciudad,tipodelito]
    return(titulos)

def crearMatriz(tabla_dic,titulos):
    ciudad = titulos[0]
    tipodelito = titulos[1]
    n = len(ciudad)
    m = len(tipodelito)
    
    tabla = np.zeros(shape=(n,m),dtype = int)
    f = 0
    while not(f>=n):
        c = 0
        unaciudad = ciudad[f]
        registro = tabla_dic[unaciudad]
        while not(c>=m):
            untipo = tipodelito[c]
            valor = registro[untipo]
            tabla[f,c] = valor
            c = c+1
        f = f+1
        
    return(tabla)

def ciudadesMenosSeguras(matriz, titulos, untipo, poblacion):
    ciudad = titulos[0]
    tipodelito = titulos[1]
    
    columna = tipodelito.index(untipo)
    incidentes = matriz[:,columna]
    indicador = incidentes/poblacion

    cual = np.argmax(indicador)
    insegura = ciudad[cual]
    # Tarea: encontrar las siguientes menos seguras
    return(insegura)

# PROGRAMA PRUEBA -------------------
# INGRESO

nombrearchivo = 'reporteincidentes.txt'
tabla = ecu.cargardatos(nombrearchivo)

# Usado si no dispone del módulo y archivo.txt
#tabla_dic = {
#    'Guayaquil':{'robo vehiculo':605, 'asalto':6345},
#    'Cuenca':   {'robo vehiculo':123, 'asalto': 676}
#    }
poblacion = np.array([2000, 1000])
untipo = 'asalto'

# PROCEDIMIENTO
titulos = titulostabla(tabla_dic)
matriz = crearMatriz(tabla_dic,titulos)
inseguras = ciudadesMenosSeguras(matriz, titulos, untipo, poblacion)

# SALIDA
print('Los títulos de la tabla son:')
print(titulos)
print('La matriz de datos: ')
print(matriz)
print('La menos segura: ')
print(inseguras)

Usando el módulo es necesario disponer de un archivo reporteincidentes.txt con datos, por facilidad en el mismo directorio de trabajo:

Guayaquil,605,6345
Cuenca,123,676