Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

Ficha 15
Arreglos de Registros
1.] Arreglos correspondientes (o "paralelos").

En muchas ocasiones ser necesario almacenar informacin en varios arreglos

unidimensionales a la vez, pero de tal forma que haya correspondencia entre los valores
almacenados en la casillas con el mismo ndice (llamadas casillas homlogas). Por ejemplo,
podra ocurrir que se pida guardar en un arreglo los nombres de ciertas personas, y en otro
arreglo el importe del sueldo que perciben:
Figura 1: Dos arreglos correspondientes o paralelos.
nombres
sueldos

Juan
1100
0

Ana

Alejandro

Mara

Pedro

2100

1300

750

800

Como se est pidiendo almacenar los datos en dos arreglos, slo se debe cuidar que el
nombre y el importe del sueldo de una misma persona aparezcan en ambos arreglos en
casillas homlogas. As, en nuestro ejemplo, la persona representada por la casilla 0 del
arreglo Nombres (o sea, nombres[0]) se llama "Juan", y el sueldo que percibe aparece en el
arreglo sueldos tambin en la casilla con ndice 0 (o sea, sueldos[0] ) y es el valor 1100.
Cuando dos o ms arreglos se usan de esta forma, se los suele designar como arreglos
correspondientes o paralelos [1].
El manejo de ambos arreglos es simple: slo debe recordar el programador que hay que usar
el mismo ndice en ambos arreglos para entrar a la informacin de una misma persona. El
siguiente esquema, muestra por pantalla el nombre y el sueldo de la persona en la casilla 2:
print('Nombre:', nombres[2])
print('Sueldo:', sueldos[2])

# Alejandro
# 1300

El siguiente problema servir para aclarar la forma general de manejar arreglos paralelos:
Problema 37.) Desarrollar un programa que permita cargar tres arreglos con n nombres de
personas, sus edades y los sueldos que ganan. Luego de realizar la carga de todos los datos,
mostrar los nombres de las personas mayores de 18 aos que ganan menos de 10000 pesos,
pero de forma que el listado salga ordenado en forma alfabtica.
Discusin y solucin: El programa usar una funcin read() cuyo objetivo es cargar por
teclado los tres arreglos. Cuando se trabaja con arreglos paralelos, en los que la componente
en la casilla i de cada arreglo contiene informacin relacionada al mismo objeto o entidad
del problema, es conveniente que la carga por teclado se haga de forma de barrer los tres
arreglos al mismo tiempo: se carga primero la componente 0 de todos los arreglos, luego la
componente 1 de todos ellos, y as sucesivamente. De esta forma, quien hace la carga de
datos ve facilitada su tarea pues carga los datos de una persona de una sola vez, sin tener

Ing. Valerio Frittelli - 317

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

que volver atrs luego de cargar los nombres o las edades para cargar los sueldos (lo que
sera realmente incmodo). La funcin read() de nuestro programa sera la siguiente:
def read(nombres, edades, sueldos):
n = len(nombres)
for i in range(n):
nombres[i] = input('Nombre[' + str(i) + ']: ')
edades[i] = int(input('Edad: '))
sueldos[i] = int(input('Sueldo: '))
print()

El proceso de ordenamiento ser realizado por la funcin sort() mediante nuestro ya

conocido algoritmo de ordenamiento por Seleccin Directa. El arreglo de nombres debe ser
ordenado en forma alfabtica o lexicogrfica: como sabemos, la idea intuitiva es que las
palabras que en un diccionario apareceran primero se consideran "menores"
(alfabticamente hablando) que las palabras que en el diccionario apareceran despus. As,
el nombre "Ana" es lexicogrficamente menor que el nombre "Luis", pues "Ana" aparecera
primero en un diccionario que "Luis". En Python, La comparacin de cadenas es simple y
directa: como sabemos, dos cadenas pueden ser comparadas directamente mediante los
operadores relacionales tpicos, y Python har el trabajo correcto [2] [3].
Note, no obstante, que la funcin sort() no slo debe ordenar el arreglo de nombres, sino
que debe cuidar que al ordenar ese arreglo se mantenga la correspondencia entre los
elementos de ese arreglo y los elementos de los otros dos que contienen las edades y los
sueldos. El principio es simple: si se realiza un cambio en el arreglo de nombres, el mismo
cambio debe reflejarse en los otros dos, por lo cual se realizan tres operaciones de
intercambio (una para el arreglo de nombres, otra para el arreglo de edades y otra para el de
sueldos). La funcin que hace el ordenamiento sera la que sigue:
def sort(nombres, edades, sueldos):
n = len(nombres)
for i in range(n-1):
for j in range(i+1, n):
if nombres[i] > nombres[j]:
nombres[i], nombres[j] = nombres[j], nombres[i]
edades[i], edades[j] = edades[j], edades[i]
sueldos[i], sueldos[j] = sueldos[j], sueldos[i]

Finalmente, la funcin display() usa un ciclo for para analizar cada componente del arreglo
de edades y del arreglo de sueldos. Si se encuentra que la edad en la posicin i es mayor a 18
y al mismo tiempo el sueldo es menor a 10000, se muestran los tres datos que corresponden
a esa persona, que se encuentra en cada arreglo en la misma posicin i. La funcin podra ser
la siguiente:
def display(nombres, edades, sueldos):
n = len(nombres)
print('ayores de 18 que ganan menos de 10000 pesos:')
for i in range(n):
if edades[i] > 18 and sueldos[i] < 10000:
print('Nombre:', nombres[i], 'Edad:', edades[i], 'Sueldo:', sueldos[i])

El programa completo que se muestra a continuacin. est incluido en el modelo tes01.py

que forma parte del proyecto [F15] Arreglos de Registros que acompaa a esta Ficha.
__author__ = 'Ctedra de AED'
def validate(inf):
n = inf

Ing. Valerio Frittelli - 318

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

while n <= inf:

n = int(input('Cantidad de elementos (> a ' + str(inf) + ' por favor): '))
if n <= inf:
print('Error: se pidio mayor a', inf, '... cargue de nuevo...')
return n
def read(nombres, edades, sueldos):
n = len(nombres)
for i in range(n):
nombres[i] = input('Nombre[' + str(i) + ']: ')
edades[i] = int(input('Edad: '))
sueldos[i] = int(input('Sueldo: '))
print()
def sort(nombres, edades, sueldos):
n = len(nombres)
for i in range(n-1):
for j in range(i+1, n):
if nombres[i] > nombres[j]:
nombres[i], nombres[j] = nombres[j], nombres[i]
edades[i], edades[j] = edades[j], edades[i]
sueldos[i], sueldos[j] = sueldos[j], sueldos[i]
def display(nombres, edades, sueldos):
n = len(nombres)
print('Personas mayores de 18 que ganan menos de 10000 pesos:')
for i in range(n):
if edades[i] > 18 and sueldos[i] < 10000:
print('Nombre:', nombres[i], 'Edad:', edades[i], 'Sueldo:', sueldos[i])
def test():
# cargar cantidad de personas...
n = validate(0)
# crear los tres arreglos de n elementos...
nombres = n * [' ']
edades = n * [0]
sueldos = n * [0]
# cargar los tres arreglos por teclado...
print('\nCargue los datos de las personas:')
read(nombres, edades, sueldos)
# ordenar alfabticamente el sistema...
sort(nombres, edades, sueldos)
# avisar por pantalla el resultado de la bsqueda...
display(nombres, edades, sueldos)
# script principal...
if __name__ == '__main__':
test()

2.] Arreglos de registros en Python.

En muchas aplicaciones ser ms til almacenar registros completos en cada casillero de un

arreglo, en lugar de usar arreglos paralelos como mostramos en la seccin anterior. Esto es
perfectamente vlido en Python: un arreglo en Python puede contener elementos de
cualquier tipo incluyendo elementos que sean referencias a registros. Esta tcnica es
efectivamente ms cmoda que la de los arreglos paralelos, ya que en lugar de definir varios
arreglos separados para almacenar en cada uno una parte de los valores que se necesitan, se
Ing. Valerio Frittelli - 319

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

define un nico arreglo que contiene a todos los datos y con eso no slo se simplifica el
cdigo fuente sino que se ahorra esfuerzo cuando se tiene que enviar ese conjunto de datos
como parmetro a una funcin, ya que en lugar de varios arreglos, se pasa slo uno [1].
Supongamos que se tiene definido un registro Estudiante y que se desea almacenar varios
registros de ese tipo en un arreglo. Suponga que se cuenta con el tipo Estudiante ya definido
y con una funcin constructora __init()__ para crear y asignar los campos a cada registro de
ese tipo:
class Estudiante:
def __init__(self, leg=0, nom='', pro=0):
self.legajo = leg
self.nombre = nom
self.promedio = pro

Si se conoce de antemano la cantidad n de registros a almacenar, una forma de crear el

arreglo pedido consiste en declarar primero la referencia a ese arreglo, reservando n
casilleros que pueden comenzar valiendo cualquier valor (por ejemplo, None): lo importante
no es qu valor comience asignado en cada casillero (puesto que este valor puede cambiarse
ms tarde incluso por uno de otro tipo), sino que se tengan efectivamente n casilleros [2]:
n = 6
v = n * [None]

La instruccin anterior crea un arreglo de n = 6 componentes con valor inicial None. La idea
es que en cada uno se almacene luego una referencia a un registro de tipo Estudiante,
aunque todava no se han creado esos registros. El aspecto que tendra este arreglo en este
momento en memoria sera como el que se muestra a continuacin:
Figura 2: Un arreglo con n = 6 casilleros con valor inicial None.

v
None

None

None None

None None

A diferencia de un arreglo que contenga valores de tipo simple, un arreglo de referencias

todava no contiene elementos listos para usar (a menos que el programador quiera
efectivamente usar los valores None...): deben crearse los registros que sern apuntados
desde cada casilla del arreglo, y recin entonces comenzar a usar esos objetos. Por ejemplo,
en este caso, podra hacerse algo como:
for i in range(n):
v[i] = Estudiante()

lo cual hara que cada casilla del arreglo contenga ahora una referencia a un registro de tipo
Estudiante, pero con todos sus campos valiendo los valores default que asigna la funcin
constructora (ya que al invocarla en el momento de crear cada registro, no le hemos
enviando ningn valor como parmetro formal). Los valores None ya no estn en cada
casillero, y fueron reemplazados por las direcciones de cada uno de los registros. Una mejor
forma de proceder, podra ser que no slo se creen los registros vacos, sino que tambin se
proceda a cargar por teclado los datos a almacenar en cada uno, y luego se creen los
registros con sus campos inicializados de forma definitiva. La secuencia que sigue muestra la
forma de hacerlo:
for i in range(n):
leg = int(input('Legajo[' + str(i) + ']: '))

Ing. Valerio Frittelli - 320

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

nom = input('Nombre: ')

pro = float(input('Promedio: '))
print()
v[i] = Estudiante(leg, nom, pro)

Est claro que puede lograrse el mismo resultado dejando los valores default de la funcin
constructora __init()__, y luego creando y asignando directamente los campos en cada
casillero. Lo anterior es equivalente a:
for i in range(n):
v[i] = Estudiante()
v[i].legajo = int(input('Legajo[' + str(i) + ']: '))
v[i].nombre = input('Nombre: ')
v[i].promedio = float(input('Promedio: '))
print()

Como cada casillero v[i] del arreglo es un registro de tipo Estudiante, entonces el acceso a
cada campo de v[i] se hace con el operador punto combinado con el propio identificador
v[i]: v[i].legajo permite acceder al campo legajo del registro ubicado en v[i], y en forma
similar ocurre para el resto de los campos.
Las dos secuencias anteriores crean diferentes registros y los asignan en distintas casillas del
arreglo, que podra verse ahora como sigue (suponga que los datos cargados por teclado
fueron efectivamente los que se ven en la figura):
Figura 3: Un arreglo con n = 6 referencias a registros ya creados de tipo Estudiante.

legajo: 76

legajo: 57

legajo: 10

legajo: 21

legajo: 45

legajo: 33

nombre: Luis
promedio: 8

nombre: Juan

nombre: Ana

nombre: Ale

nombre: Maria

nombre: Pedro

promedio: 5

promedio: 7

promedio: 4

promedio: 10

promedio: 8

Slo cuando cada registro haya sido creado se puede recorrer el arreglo y aplicar a cada uno
alguna tarea o proceso. Recuerde que v[i] es la referencia que apunta al registro en la casilla
i, y por lo tanto algo como v[i].legajo accede al nmero de legajo almacenado en el registro
v[i]. Pero esto slo es vlido si v[i] es efectivamente un registro de tipo Estudiante: si se
intenta acceder a un campo desde una referencia que no apunta a un registro de ese tipo, el
programa se interrumpir lanzando un mensaje de error por campo inexistente.
Finamente, el arreglo se usa como se usara a cualquier arreglo: si se sabe qu clase de
registros se almacenaron dentro de l, se podr cargarlos por teclado, visualizarlos,
ordenarlos, efectuar bsquedas, etc. Analice el siguiente ejercicio que completa el ejemplo
que hemos venido utilizando:
Problema 38.) Se desea almacenar en un arreglo la informacin de los n estudiantes que se
registraron para participar de un curso de programacin. Por cada estudiante se tiene su
nmero de legajo, su nombre y su promedio en la carrera que cursa. Participarn del curso

Ing. Valerio Frittelli - 321

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

los estudiantes cuyo promedio sea mayor o igual a x, siendo x un valor cargado por teclado.
Muestre los datos de los estudiantes que participarn del curso, pero ordenados de menor a
mayor por nmero de legajo.
Discusin y solucin: El programa que resuelve este problema es el modelo test02.py
(incluido en el proyecto [F15] Arreglos Registros Ordenamiento que viene con esta Ficha),
y es el siguiente:
__author__ = 'Ctedra de AED'
class Estudiante:
def __init__(self, leg, nom, pro):
self.legajo = leg
self.nombre = nom
self.promedio = pro
def write(est):
print('Legajo:', est.legajo, end=' ')
print('- Nombre:', est.nombre, end=' ')
print('- Promedio:', est.promedio)
def validate(inf):
n = inf
while n <= inf:
n = int(input('Cantidad de elementos (mayor a ' + str(inf) + '): '))
if n <= inf:
print('Error: se pidio mayor a', inf, '... cargue de nuevo...')
return n
def read(estudiantes):
n = len(estudiantes)
for i in range(n):
leg = int(input('Legajo[' + str(i) + ']: '))
nom = input('Nombre: ')
pro = float(input('Promedio: '))
print()
estudiantes[i] = Estudiante(leg, nom, pro)
def sort(estudiantes):
n = len(estudiantes)
for i in range(n-1):
for j in range(i+1, n):
if estudiantes[i].legajo > estudiantes[j].legajo:
estudiantes[i], estudiantes[j] = estudiantes[j], estudiantes[i]
def display(estudiantes, x):
n = len(estudiantes)
print('Estudiantes que harn el curso (tienen promedio >=', x, '):')
for i in range(n):
if estudiantes[i].promedio >= x:
write(estudiantes[i])
def test():
# cargar cantidad de estudiantes...
n = validate(0)
# crear un arreglo con n casilleros de valor indefinido...

Ing. Valerio Frittelli - 322

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

# ... se usar para almacenar luego las referencias a los Estudiantes...

estudiantes = n * [None]
# cargar el arreglo por teclado...
print('\nCargue los datos de los estudiantes:')
read(estudiantes)
print()
x = float(input('Promedio mnimos para poder hacer el curso: '))
print()
# ordenar alfabticamente el arreglo...
sort(estudiantes)
# mostrar por pantalla el listado...
display(estudiantes, x)
# script principal...
if __name__ == '__main__':
test()

La funcin test() define un arreglo referenciado por la variable estudiantes, que contendr
referencias a registros de tipo Estudiante (tipo que fue definido al inicio del mdulo). Este
arreglo se usar para almacenar los datos de todos los estudiantes que se hayan inscripto
para hacer el curso. La misma funcin test() carga por teclado la cantidad total de alumnos n,
y en base a ese valor crea el arreglo con n casilleros valiendo None. Recuerde que no se
debera comenzar a usar el arreglo hasta crear o asignar registros de tipo Estudiante en cada
componente (cosa que se hace en este caso la funcin read().
La funcin sort() ordena el arreglo de acuerdo a los legajos de los estudiantes, de menor a
mayor. Lo ms relevante de esta funcin es la condicin para determinar si debe hacerse un
intercambio o no:
if estudiantes[i].legajo > estudiantes[i].legajo:
estudiantes[i], estudiantes[j] = estudiantes[j], estudiantes[i]

Puede verse que en la condicin se accede al campo legajo de cada registro, y se comparan
sus valores: ahora cada casillero contiene un registro y no un valor int, por lo que comparar
directamente estudiantes[i] con estudiantes[j] carece de sentido (y provocara un error!).
Adems, si la condicin es verdadera puede verse que se procede a intercambiar
directamente las referencias a los registros, sin tener que hacer ese intercambio campo por
campo.
Finalmente, la funcin display() recorre el contenido del arreglo mostrando por consola los
datos de los alumnos cuyo promedio sea mayor o igual al valor x que se tom como
parmetro. Como el arreglo est ordenado por legajo, los datos de los estudiantes que se
muestren saldrn a su vez ordenados por legajo.

Anexo: Temas Avanzados

En general, cada Ficha de Estudios podr incluir a modo de anexo un captulo de Temas Avanzados,
en el cual se tratarn temas nombrados en las secciones de la Ficha, pero que requeriran mucho
tiempo para ser desarrollados en el tiempo regular de clase. El captulo de Temas Avanzados podra
incluir profundizaciones de elementos referidos a la programacin en particular o a las ciencias de la
computacin en general, como as tambin explicaciones y demostraciones de fundamentos

Ing. Valerio Frittelli - 323

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

matemticos. En general, se espera que el alumno sea capaz de leer, estudiar, dominar y aplicar
estos temas aun cuando los mismos no sean especficamente tratados en clase.
a.) Conteo y/o acumulacin por acceso directo (vectores de conteo y/o acumulacin).

Los arreglos son estructuras de datos especialmente tiles, puesto que brindan la
posibilidad del acceso directo a cada componente. Es decir: si se necesita acceder
directamente a un elemento, slo se requiere conocer el ndice del mismo y no es necesario
pasar en forma secuencial por todos los elementos anteriores. Existen situaciones (el caso de
la bsqueda binaria es una de ellas) en las cuales esta propiedad permite resolver problemas
en forma notablemente sencilla y rpida. Por ejemplo, considrese el siguiente problema:
Problema 39.) Cargar por teclado un conjunto de valores tales que todos ellos estn
comprendidos entre 0 y 99 (incluidos ambos). Se indica el fin de datos con el nmero -1.
Determinar cuntas veces apareci cada nmero.
Discusin y solucin: A primera vista, el problema parece de solucin obvia: se usa un ciclo
para cargar de a un valor (num) por vez, de forma que el ciclo slo se detenga cuando sea
num == -1. Como se pide determinar cuntas veces apareci cada valor posible de num, se
usa un contador distinto por cada valor diferente que num pueda asumir. As, para contar
cuntas veces apareci el 1, se puede usar el contador c1, para el 2 se podr usar c2, y as
sucesivamente. En cada repeticin del ciclo se usa un if encadenado para determinar qu
nmero se carg en esa vuelta, y en funcin del nmero se elige el contador
correspondiente. Al finalizar el ciclo, se muestran todos los contadores, y asunto
terminado...
Sin embargo, esa solucin dista mucho de ser buena y sobre todo en casos como ste, en
que la variable num puede asumir valores en un rango muy amplio (0 a 99). El programador
debera declarar y poner en cero cien contadores, y luego, dentro del ciclo, usar cien
condiciones anidadas! para determinar qu contador debera usar de acuerdo al nmero
ingresado. Adems del gran esfuerzo de codificacin que el programador deber realizar, se
tendr el problema de la enorme redundancia de instrucciones semejantes, y por si esto
fuera poco, el programa resultante ser muy poco flexible en la prctica: si luego de
plantearlo nos cambian las condiciones supuestas (por ejemplo: si los valores que puede
asumir num pasaran a ser entre 0 y 150) entonces el programa original ya no servira de
nada...
La solucin correcta es usar un arreglo unidimensional c de cien componentes, de forma que
cada componente se use como uno de los contadores que se estn necesitando [1]. Se pone
inicialmente en cero cada componente del vector (dado que esos componentes sern
contadores). Luego comienza el ciclo para cargar los valores num. La idea central, es que si
num vale 0, entonces debe usarse c[0] para contarlo. Si num vale 1, se usa c[1], y as
sucesivamente. En general, para cada valor de la variable num tal que 0 <= num <= 99, debe
usarse c[num] para contarlo... En otras palabras: dentro del ciclo no es necesario usar
condiciones anidadas para determinar qu casillero del arreglo usar para contar cada
nmero: se accede directamente al casillero cuyo ndice es num y se incrementa el mismo en
uno... Al cortar el ciclo, se muestra el contenido del arreglo, y ahora s el problema queda
resuelto de manera convincente.

Ing. Valerio Frittelli - 324

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

Cuando un arreglo unidimensional se usa de esta forma, se lo suele designar como vector de
conteos o simplemente como vector de contadores1. Si el arreglo se usara para acumular
valores (en vez de contarlos como se supuso en el ejemplo), se hablara entonces de un
vector de acumulacin.
Se muestra a continuacin el programa que aplica lo dicho y resuelve el problema (ver
modelo test03.py en el proyecto [F15] Arreglos de Registros): en la funcin test() se define el
vector de conteos c de n = 100 elementos valiendo cada uno de ellos inicialmente 0, que se
usar para contar cuntas veces aparecen los nmeros en el rango [0, n-1]. Luego se cargan
los nmeros mediante un ciclo de doble lectura, y se aplica la tcnica vista para proceder a
contarlos. Al finalizar, se recorre el vector de conteos y se visualizan los resultados, pero de
forma que slo se muestran los conteos de los nmeros que hayan entrado al menos una
vez (lo cual ahorra algo de espacio en la consola de salida):
__author__ = 'Ctedra de AED'
def test():
# crear el vector de conteo...
n = 100
c = n * [0]
# cargar y contar los nmeros...
num = int(input('Ingrese un valor entre 0 y 99 (con 1 corta): '))
while num != -1:
if 0 <= num < n:
c[num] += 1
else:
print('Error... el nmero deba ser >= 0 y <', n)
num = int(input('Ingrese otro valor entre 0 y 99 (con 1 corta): '))
# mostrar los resultados...
print('Resultados:')
for i in range(n):
if c[i] != 0:
print('Nmero', i, '- Frecuencia de aparicin', c[i])
if __name__ == '__main__':
test()

Crditos
El contenido general de esta Ficha de Estudio fue desarrollado por el Ing. Valerio Frittelli para ser
utilizada como material de consulta general en el cursado de la asignatura Algoritmos y Estructuras
de Datos Carrera de Ingeniera en Sistemas de Informacin UTN Crdoba, en el ciclo lectivo 2016.

Una situacin de conteo muy conocida se da en las famosas cuentas regresivas que tienen lugar en distintos
tipos de eventos (lanzamientos de naves espaciales, llegada del Ao Nuevo, etc.) A su vez, es muy comn en el
cine encontrar escenas basadas en cuentas regresivas: Una de esas escenas se dio en la pelcula Independence
Day (o Da de la Independencia), de 1996, dirigida por Roland Emmerich y protagonizada por Will Smith y Jeff
Goldblum. Una avanzada (y hostil) civilizacin extraterrestre llega a la Tierra y posiciona numerosas naves en el
espacio areo de muchas ciudades importantes de todo el mundo, como si estuviesen vigilndolas. Estas naves
emiten una extraa seal mientras se estn posicionando, y pronto alguien descubre que la seal es en
realidad una cuenta regresiva que en cuanto llegue a cero provocar el ataque simultneo de todas esas
naves a todas las ciudades vigiladas, iniciando una invasin.

Ing. Valerio Frittelli - 325

Ctedra de AED [Ciclo 2016]

Ficha 15: Arreglos de Registros

Actuaron como revisores (indicando posibles errores, sugerencias de agregados de contenidos y

ejercicios, sugerencias de cambios de enfoque en alguna explicacin, etc.) en general todos los
profesores de la citada asignatura como miembros de la Ctedra, y en especial las ing. Anala
Guzmn, Cynthia Corso y Karina Ligorria, que realizaron aportes de contenidos, propuestas de
ejercicios y sus soluciones, sugerencias de estilo de programacin, y planteo de enunciados de
problemas y actividades prcticas, entre otros elementos.

Bibliografa
[1] V. Frittelli, Algoritmos y Estructuras de Datos, Crdoba: Universitas, 2001.
[2] Python Software Foundation, "Python Documentation," 2016. [Online].

Available:
https://docs.python.org/3/. [Accessed 24 February 2016].
[3] M. Pilgrim, "Dive Into Python - Python from novice to pro," 2004. [Online]. Available:
http://www.diveintopython.net/toc/index.html. [Accessed 6 March 2016].

Ing. Valerio Frittelli - 326