You are on page 1of 16

ESTRUCTURAS DE CONTROL Y ARREGLOS

ESTRUCTURAS SECUENCIALES
Son problemas en los que, para su solución se emplea una serie de acciones ejecutadas
invariablemente en un orden secuencial.
Las tareas suceden de tal modo que la salida de una es la entrada de la siguiente y así
sucesivamente hasta el fin del proceso.
Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicialización de variables,
operaciones de asignación, cálculo, sumarización, etc.
Este tipo de estructura se basa en las 5 fases de que consta todo algoritmo o programa:
Definición de variables (Declaración)
Inicialización de variables.
Lectura de datos
Cálculos
Salida
REPRESENTACIÓN GRÁFICA.

ESTRUCTURAS SELECTIVAS
Una decisión es la estructura según la cual se puede escoger uno de entre dos caminos
lógicos dependiendo de una condición que al ser evaluada nos brinda la oportunidad de
saber cuál de los dos caminos escoger. La evaluación de dicha condición siempre va a
originar una respuesta VERDADERA (cuando la condición se cumple) o FALSA (cuando
dicha condición no se cumple) y con ello se podrá saber cuál es el conjunto de instrucciones
a resolver. La representación de una estructura selectiva se hace con palabras en
pseudocódigo (if – then – else o en español si – entonces - sino) y en flujograma con una
figura geométrica en forma de rombo.
La condición, en algoritmos técnicos, se podrá expresar en términos de dos tipos de
operadores: los operadores relacionales y los operadores booleanos. Recordemos que los
operadores relacionales son aquellos que nos originan una respuesta Verdadera o Falsa y
que corresponden a los símbolos mayor que, menor que, mayor o igual, menor o igual, igual
(de comparación) y diferente de. Los operadores booleanos son aquellos que nos permiten
establecer conexiones entre expresiones en donde aparezcan los operadores booleanos y
corresponden a los operadores:
AND: Genera Verdadero si todas las expresiones relacionales conectadas son Verdaderas
OR: Genera Verdadero si al menos una de las expresiones conectadas es Verdadera
NOT que invierte el sentido lógico de la expresión

Con estos elementos podemos recordar que la utilización de las decisiones como estructura
básica de programación no tiene ninguna restricción y que pueden considerarse como
válidos los siguientes casos:
Una decisión dentro de otra
Una decisión a continuación de otra
Muchas decisiones dentro de otras
Muchas decisiones a continuación de otras
Los lenguajes de programación normalmente cuentan con una forma de seleccionar uno de
entre varios caminos lógicos que correspondería a una pequeña modificación de la
estructura de DECISIÓN pero que en últimas partes del mismo supuesto.
ESTRRUCTURAS SELECTIVAS SIMPLES
Se identifican porque están compuestos únicamente de una condición.
La estructura si – entonces evalúa la condición y en tal caso:
Si la condición es verdadera, entonces ejecuta la acción Si (o acciones si son varias).
Si la condición es falsa, entonces no se hace nada.

Representación gráfica:
DONDE:
Condición: Expresa la condición o conjunto de condiciones a evaluar
Acción: Expresa la operación o conjunto de operaciones que se van a realizar si la condición
resulta verdadera.

ESTRUCTURAS SELECTIVAS DOBLES


Son estructuras lógicas que permiten controlar la ejecución de varias acciones y se utilizan
cuando se tienen dos opciones de acción, por la naturaleza de estas se debe ejecutar una
o la otra, pero no ambas a la vez, es decir, son mutuamente excluyentes.

REPRESENTACIÓN GRÁFICA:

DONDE:
Condición: Expresa la condición o conjunto de condiciones a evaluar
Acción 1: Expresa la operación o conjunto de operaciones que se van a realizar
si la condición resulta verdadera.
Acción 2: Expresa la operación o conjunto de operaciones que se van a realizar
si la condición resulta falsa
REPRESENTACIÓN PSEUDOCODIFICADA.
Español Inglés
Si <condición> entonces If <condición> then
<acción S1> <acción S1>
sino else
<acción S2> <acción S2>
Fin_Si End_if
En este caso se constituye en una selección de dos posibilidades. Si la condición es
verdadera se ejecuta la acción 1, y si es falsa, se ejecuta la acción 2. En el Flujograma es
recomendable que el camino verdadero deba colocarse a la derecha y lo falso a la izquierda.
En el diagrama N-S no se puede cambiar el orden del Si y No.
ESTRUCTURAS SELECTIVAS MULTIPLES
Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema
se podría resolver por estructuras selectivas simples o dobles, anidadas o en cascada, pero
si el número de alternativas es grande puede plantear serios problemas de escritura y de
legibilidad.
Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n
valores distintos, 1, 2 , 3, ...., n y según que elija uno de estos valores en la condición, se
realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un
determinado camino entre los n posibles.
Esta estructura se representa por un selector el cual si toma el valor 1 ejecutará la acción
1, si toma el valor 2 ejecutará la acción 2, si toma el valor N realizará la acción N.
Así, si el selector toma el valor 1 se ejecutará la acción 1, si toma el valor 2 se ejecutará la
acción 2, si toma el valor N, se realizará la acción N. De otra forma, si no es ningún caso
de los anteriores, significa que no se cumplió ninguna de las anteriores, entonces se
realizará la acción X.
Deberá reemplazar Selector por variables, propiedad o expresión que vaya a ser el valor
clave.
Estructuras de Control Iterativas repetir mientras, hasta, desde.
En la vida diaria existen situaciones que frecuentemente se resuelven realizando una
determinada secuencia de pasos que puede repetirse muchas veces, ejemplo:
El proceso que seguimos para comer, mientras no se termine la comida.
El proceso de insertar monedas, hasta que se abone la cantidad necesaria.
Las operaciones que realizamos para llamar por teléfono, mientras no se logre la
comunicación.
Como se puede observar estos son algoritmos que se hacen cotidianamente, pero tienen
la particularidad de que la ejecución de alguno de sus pasos puede repetirse muchas veces,
mientras no se logre la meta trazada. A este tipo de algoritmo se le conoce como algoritmos
iterativos o repetitivos. En C#, las instrucciones while, do/while, y for, permiten ejecutar
iteraciones, bucles o ciclos. En cada caso se ejecuta un bloque de instrucciones mientras
la condición que se evalúa tome valor verdadero. Se resalta que cualquiera de las 3
instrucciones cumple con el mismo objetivo que es el de ejecutar una secuencia de pasos,
más de una vez.
La instrucción while
La instrucción while tiene la siguiente sintaxis:
La semántica de la instrucción es la siguiente:
<condición>. Está representada por una expresión booleana y mientras se cumpla se
ejecutará el ciclo.
[Bloque de Instrucciones] El bloque de instrucciones puede estar formado por una o varias
instrucciones y es el conjunto de pasos que se van ejecutar en cada iteración del ciclo.
Para una mayor comprensión se muestra su representación en un diagrama de actividad.

Esta estructura de control permite repetir o iterar el [Bloque de Instrucciones] mientras la


condición sea verdadera o dicho de otra manera, estas iteraciones terminarán cuando la
condición sea falsa y entonces se podrá ejecutar la siguiente instrucción después del while.
Es válido señalar que en esta instrucción la condición se evalúa al inicio del ciclo por lo que
si la primera vez que se evalúa la condición esta es falsa, el ciclo no llegará a realizarse.
La instrucción do/while
La estructura de control do/while es otra sentencia de iteración en la que la condición se
evalúa por primera vez una vez que se haya ejecutado el [Bloque de Instrucciones] y tienen
la siguiente sintaxis:
Su semántica es la misma que la de la instrucción while y su representación en un diagrama
de actividad es la siguiente:
En esta estructura repetitiva el bloque de instrucciones siempre se ejecuta al menos una
vez pues la condición se evalúa al final. Una vez realizada la evaluación si el resultado es
true, se vuelve a ejecutar el [Bloque de Instrucciones], en caso contrario se ejecutan las
instrucciones que sigan a continuación saliendo del ciclo. La funcionalidad de este método
será la misma que en el ejemplo con while. La única diferencia es la forma en que se
controla el bucle. En la práctica, verá que la instrucción while se utiliza más a menudo que
la instrucción do – while. El elegir una instrucción en lugar de la otra es una elección
personal. Un aspecto muy importante a tener presente en los ciclos condicionales es la
necesidad de contemplar dentro del bloque de instrucciones al menos una, que de alguna
manera, altere –en algún momento- el resultado de la expresión booleana. La explicación
sencillamente está dada por el hecho que de no existir esta instrucción una vez entrada al
ciclo este nunca terminaría por lo que se caería en un ciclo infinito.
La estructura de control for
Los procesos iterativos que se han visto hasta ahora terminan por una condición. En
muchas situaciones las iteraciones se realizan un número determinado de veces, muchos
autores les llaman ciclos por conteo pues se conoce de antemano cuántas veces se hará
el proceso que se repite. En este tipo de iteración, siempre se necesita una variable que
lleve el control de las veces que se repite el proceso por esto se les conoce también como
ciclos con variable de control. Uno de los ciclos más conocidos y usados en la mayoría de
los lenguajes de programación es el de la instrucción for que suele estar controlado por un
contador o variable de control y tiene la siguiente sintaxis:

La semántica de la instrucción es la siguiente:


<instrucciones 1>. Se ejecutará una sola vez al inicio del ciclo, generalmente se realizan
inicializaciones y declaraciones de variables puesto que como se dijo con anterioridad, esta
solo se ejecuta una vez. En caso de que se quiera realizar o ejecutar más de una instrucción
en este momento, dichas instrucciones se deben separar por comas (“,”).
<expresión>. Es evaluada en cada iteración y en dependencia del valor que devuelva,
dependerá que el ciclo continúe ejecutándose (valor de la expresión true) o no (false).
Destacar que de no colocarse nada en esta parte, el ciclo tomará como true el valor de la
expresión por lo que en principio, el ciclo puede estar repitiéndose infinitamente.
<instrucciones 2>. Es ejecutado siempre en cada ciclo al terminar de ejecutar todas las
instrucciones que pertenecen al bucle for en cuestión. Por lo general puede contener alguna
actualización para las variables de control. Análogamente a <instrucciones 1> en caso de
querer ejecutar en este momento más de una instrucción se deben separar por comas.
Observe que es obligatorio para separar cada término que compone la instrucción for utilizar
un punto y coma (;) de lo contrario el compilador mostrará un error de tipo semántico.
Reiterar que la <instrucción 1> se ejecuta una sola vez al comienzo, que la <instrucción 2>
es la que generalmente se utiliza para modificar la variable de control aunque en el ciclo
esta puede modificarse también, y que <expresión>, es la que garantiza la finitud del ciclo,
el for se estará ejecutando siempre y cuando <expresión> sea evaluada y tome valor true.
Caso de Estudio
Para mejor entendimiento de lo expuesto anteriormente, se presenta el siguiente caso de
estudio en que se trabajará con cada una de las estructuras repetitivas.

MCD()
Para implementar la responsabilidad de la clase de calcular el Máximo Común Divisor MCD
se utilizará el algoritmo de Euclides que consiste en:
P1: Si los números son iguales, tomar el primer número como respuesta y concluir la
ejecución del algoritmo, en otro caso pasar al paso 2.
P2: Determinar cuál de los dos números es mayor.
P3: Sustituir el número mayor por la diferencia entre los números mayor y menor.
P4: Pasar al paso 1.
Obsérvese como se repiten los pasos 1,2 y 3 y el paso 4 consiste precisamente en regresar
al paso 1, esta repetición se conoce normalmente con el nombre de iteración, nótese que
esta no es infinita, precisamente en el primer paso se especifica que los pasos siguientes
(2, 3, 4) han de ejecutarse si no cumple la condición de que los números sean iguales. Esta
condición es una expresión booleana.
Ejecutar el algoritmo para un par de valores (8 y 20 por ejemplo)
Para implementar el método que permita calcular el máximo común divisor utilizaremos la
estructura de control while se evaluará la condición de que los números sean diferentes y
en dependencia del resultado de la misma se ejecutarán o no los pasos que forman parte
del ciclo. El método MCD, quedaría de la siguiente manera:
CantDigitos()
Para determinar la cantidad de dígitos que tiene el número, primeramente se divide el
número entre 10, si el cociente de la división es 0, se toma 1 como respuesta, sino, se toma
dicho cociente y se divide entre 10, este proceso se estará repitiendo mientras el nuevo
cociente sea distinto de 0. Como se observa, al menos se necesita realizar una división, por
lo que la estructura do/while es la indicada para implementar este algoritmo. Para
implementar el método hay que tener en cuenta lo siguiente:
P1: Se realiza la división del número entre 10.
P2: Se almacena el cociente en una variable y se cuenta que número de división es.
P3: Si el resultado del cociente es distinto de 0, se repite el paso 1.
El método quedaría de la siguiente manera:

ARREGLOS:
Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada
de elementos. Los arreglos pueden ser de los siguientes tipos:
De una dimensión.
De dos dimensiones.
De tres o más dimensiones.
Tipos de arreglos
Arreglos unidimensionales.
Arreglos multidimensionales.
Arreglo con múltiple subíndices.
Arreglos unidimensionales
Es un tipo de datos estructurado que está formado de una colección finita y ordenada de
datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.
Están formados por un conjunto de elementos de un mismo tipo de datos que se almacenan
bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del
arreglo de datos. Al declarar un arreglo, se debe inicializar sus elementos antes de
utilizarlos. Para declarar un arreglo tiene que indicar su tipo, un nombre único y la cantidad
de elementos que va a contener.
Arreglos multidimensionales
Es un tipo de dato estructurado, que está compuesto por dimensiones. Para hacer
referencia a cada componente del arreglo es necesario utilizar n índices, uno para cada
dimensión. El término dimensión representa el número de índices utilizados para referirse
a un elemento particular en el arreglo. Los arreglos de más de una dimensión se llaman
arreglos multidimensionales.
Arreglos con múltiple subíndices
Es la representación de tablas de valores, consistiendo de información arreglada en
renglones y columnas. Para identificar un elemento particular de la tabla, deberemos de
especificar dos subíndices; el primero identifica el renglón del elemento y el segundo
identifica la columna del elemento. A los arreglos que requieren dos subíndices para
identificar un elemento en particular se conocen como arreglo de doble subíndice. Note que
los arreglos de múltiples subíndices pueden tener más de dos subíndices. El estándar ANSI
indica que un sistema ANSI C debe soportar por lo menos 12 subíndices de arreglo.
Operaciones con arreglos
Las operaciones en arreglos pueden clasificarse de la siguiente forma:
Lectura: este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno
de sus componentes
Escritura: Consiste en asignarle un valor a cada elemento del arreglo.
Asignación: No es posible asignar directamente un valor a todo el arreglo
Actualización: Dentro de esta operación se encuentran las operaciones de eliminar, insertar
y modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el
arreglo está o no ordenado.
Ordenación.
Búsqueda.
Insertar.
Borrar.
Modificar.
Ordenaciones en Arreglos
La importancia de mantener nuestros arreglos ordenados radica en que es mucho más
rápido tener acceso a un dato en un arreglo ordenado que en uno desordenado.
Existen muchos algoritmos para la ordenación de elementos en arreglos, algunos de ellos
son:
Selección directa
Este método consiste en seleccionar el elemento más pequeño de nuestra lista para
colocarlo al inicio y así excluirlo de la lista. Para ahorrar espacio, siempre que vayamos a
colocar un elemento en su posición correcta lo intercambiaremos por aquel que la esté
ocupando en ese momento.
Ordenación por burbuja
Es el método de ordenación más utilizado por su fácil comprensión y programación, pero
es importante señalar que es el más ineficiente de todos los métodos. Este método consiste
en llevar los elementos menores a la izquierda del arreglo ó los mayores a la derecha del
mismo. La idea básica del algoritmo es comparar pares de elementos adyacentes e
intercambiarlos entre sí hasta que todos se encuentren ordenados.
Ordenación por mezcla
Este algoritmo consiste en partir el arreglo por la mitad, ordenar la mitad izquierda, ordenar
la mitad derecha y mezclar las dos mitades ordenadas en un array ordenado. Este último
paso consiste en ir comparando pares sucesivos de elementos (uno de cada mitad) y
poniendo el valor más pequeño en el siguiente hueco.
Algoritmos de búsqueda que existen
Búsquedas en Arreglos: Una búsqueda es el proceso mediante el cual podemos localizar
un elemento con un valor especifico dentro de un conjunto de datos. Terminamos con éxito
la búsqueda cuando el elemento es encontrado.
Búsqueda secuencial: A este método también se le conoce como búsqueda lineal y consiste
en empezar al inicio del conjunto de elementos , e ir a través de ellos hasta encontrar el
elemento indicado ó hasta llegar al final de arreglo. Este es el método de búsqueda más
lento, pero si nuestro arreglo se encuentra completamente desordenado es el único que
nos podrá ayudar a encontrar el dato que buscamos.
Búsqueda binaria: Las condiciones que debe cumplir el arreglo para poder usar búsqueda
binaria son que el arreglo este ordenado y que se conozca el numero de elementos. Este
método consiste en lo siguiente: comparar el elemento buscado con el elemento situado en
la mitad del arreglo, si tenemos suerte y los dos valores coinciden, en ese momento la
búsqueda termina. Pero como existe un alto porcentaje de que esto no ocurra, repetiremos
los pasos anteriores en la mitad inferior del arreglo si el elemento que buscamos resulto
menor que el de la mitad del arreglo, o en la mitad superior si el elemento buscado fue
mayor. La búsqueda termina cuando encontramos el elemento o cuando el tamaño del
arreglo a examinar sea cero.
Búsqueda por hash: La idea principal de este método consiste en aplicar una función que
traduce el valor del elemento buscado en un rango de direcciones relativas. Una desventaja
importante de este método es que puede ocasionar colisiones

ARCHIVOS
Todos los datos que un programa utiliza durante su ejecución se encuentran en sus
variables, que están almacenadas en la memoria RAM del computador.
La memoria RAM es un medio de almacenamiento volátil: cuando el programa termina, o
cuando el computador se apaga, todos los datos se pierden para siempre.
Para que un programa pueda guardar datos de manera permanente, es necesario utilizar
un medio de almacenamiento persistente, de los cuales el más importante es el disco duro.
Los datos en el disco duro están organizados en archivos. Un archivo es una secuencia de
datos almacenados en un medio persistente que están disponibles para ser utilizados por
un programa. Todos los archivos tienen un nombre y una ubicación dentro del sistema de
archivos del sistema operativo.
Lectura de archivos
Para leer datos de un archivo, hay que abrirlo de la siguiente manera:
archivo = open(nombre)
nombre es un string que tiene el nombre del archivo. archivo es el archivo lógico a través
del que se manipulará el archivo.
Si el archivo no existe, ocurrirá un error de entrada y salida (IOError).
Es importante recordar que la variable archivo es una representación abstracta del archivo,
y no los contenidos del mismo.
La manera más simple de leer el contenido es hacerlo línea por línea. Para esto, basta con
poner el archivo lógico en un ciclo for:
for linea in archivo:
# hacer algo
Una vez que los datos han sido leídos del archivo, hay que cerrarlo:
archivo. Lose()
Por ejemplo, supongamos que tenemos el archivo himno.txt que tiene el siguiente
contenido:
Puro Chile
es tu cielo azulado
puras brisas
te cruzan también.
El archivo tiene cuatro líneas. Cada línea termina con un salto de línea (\n), que indica que
a continuación comienza una línea nueva.
El siguiente programa imprime la primera letra de cada línea del himno:
archivo = open('himno.txt')
for linea in archivo:
print linea[0]
archivo.close()
El ciclo for es ejecutado cuatro veces, una por cada línea del archivo. La salida del programa
es:
P
e
p
t
Otro ejemplo: el siguiente programa imprime cuántos símbolos hay en cada línea:
archivo = open('himno.txt')
for linea in archivo:
print len(linea)
archivo.close()
La salida es:
11
20
13
19
Note que el salto de línea (el “enter”) es considerado en la cuenta:
+---+---+---+---+---+---+---+---+---+---+---+
| P | u | r | o | | C | h | i | l | e | \n| = 11 símbolos
+---+---+---+---+---+---+---+---+---+---+---+
Para obtener el string sin el salto de línea, se puede usar el método strip, que elimina todos
los símbolos de espaciado al principio y al final del string:
>>> s = ' Hola\n'
>>> s.strip()
'Hola'
Si modificamos el programa para eliminar el salto de línea:
archivo = open('himno.txt')
for linea in archivo:
print len(linea.strip())
archivo.close()
entonces la salida es:
10
19
12
18
Lo importante es comprender que los archivos son leídos línea por línea usando el ciclo for.
Escritura en archivos
Los ejemplos anteriores suponen que el archivo por leer existe, y está listo para ser abierto
y leído. Ahora veremos cómo crear los archivos y cómo escribir datos en ellos, para que
otro programa después pueda abrirlos y leerlos.
Uno puede crear un archivo vacío abriéndolo de la siguiente manera:
archivo = open(nombre, 'w')
El segundo parámetro de la función open indica el uso que se le dará al archivo. 'w' significa
«escribir» (write en inglés).
Si el archivo señalado no existe, entonces será creado. Si ya existe, entonces será
sobreescrito. Hay que tener cuidado entonces, pues esta operación elimina los datos del
archivo que existía previamente.
Una vez abierto el archivo, uno puede escribir datos en él usando el método write:
a = open('prueba.txt', 'w')
a.write('Hola ')
a.write('mundo.')
a.close()
Una vez ejecutado este programa, el archivo prueba.txt será creado (o sobreescrito, si ya
existía). Al abrirlo en el Bloc de Notas, veremos este contenido:
Hola mundo.
Para escribir varias líneas en el archivo, es necesario agregar explícitamente los saltos de
línea en cada string que sea escrito. Por ejemplo, para crear el archivo himno.txt que
usamos más arriba, podemos hacerlo así:
a = open('himno.txt', 'w')
a.write('Puro Chile\n')
a.write('es tu cielo azulado\n')
a.write('puras brisas\n')
a.write('te cruzan también.\n')
a.close()
Además del modo 'w' (write), también existe el modo 'a' (append), que permite escribir
datos al final de un archivo existente. Por ejemplo, el siguiente programa abre el
archivo prueba.txt que creamos más arriba, y agrega más texto al final de él:
a = open('prueba.txt', 'a')
a.write('\n')
a.write('Chao ')
a.write('pescao.')
a.close()
Si abrimos el archivo prueba.txt en el Bloc de Notas, veremos esto:
Hola mundo.

Chao pescao.
De haber abierto el archivo en modo 'w' en vez de 'a', el contenido anterior (la
frase Hola mundo) se habría borrado.
Archivos de valores con separadores
Una manera usual de almacenar datos con estructura de tabla en un archivo es la siguiente:
cada línea del archivo representa una fila de la tabla, y los datos de una fila se ponen
separados por algún símbolo especial.
Por ejemplo, supongamos que queremos guardar en un archivo los datos de esta tabla:

Nombre Apellido Nota 1 Nota 2 Nota 3 Nota 4

Perico Los Palotes 90 75 38 65

Yayita Vinagre 39 49 58 55

Fulana De Tal 96 100 36 71


Si usamos el símbolo : como separador, el archivo, que llamaremos alumnos.txt, debería
quedar así:
Perico:Los Palotes:90:75:38:65
Yayita:Vinagre:39:49:58:55
Fulanita:De Tal:96:100:36:71
El formato de estos archivos se suele llamar CSV, que en inglés son las siglas de comma-
separated values (significa «valores separados por comas», aunque técnicamente el
separador puede ser cualquier símbolo). A pesar del nombre especial que reciben, los
archivos CSV son archivos de texto como cualquier otro, y se pueden tratar como tales.
Los archivos de valores con separadores son muy fáciles de leer y escribir, y por esto son
muy usados. Como ejemplo práctico, si usted desea hacer un programa que analice los
datos de una hoja de cálculo Excel, puede guardar el archivo con el formato CSV
directamente en el Excel, y luego abrirlo desde su programa escrito en Python.
Para leer los datos de un archivo de valores con separadores, debe hacerlo línea por línea,
eliminar el salto de línea usando el método strip y luego extraer los valores de la línea
usando el método split. Por ejemplo, al leer la primera línea del archivo de más arriba
obtendremos el siguiente string:
'Perico:Los Palotes:90:75:38:65\n'
Para separar los seis valores, lo podemos hacer así:
>>> linea.strip().split(':')
['Perico', 'Los Palotes', '90', '75', '38', '65']
Como se trata de un archivo de texto, todos los valores son strings. Una manera de convertir
los valores a sus tipos apropiados es hacerlo uno por uno:
valores = linea.strip().split(':')
nombre = valores[0]
apellido = valores[1]
nota1 = int(valores[2])
nota2 = int(valores[3])
nota3 = int(valores[4])
nota4 = int(valores[5])
Una manera más breve es usar las rebanadas y la función map:
valores = linea.strip().split(':')
nombre, apellido = valores[0:2]
nota1, nota2, nota3, nota4 = map(int, valores[2:6])
O podríamos dejar las notas en una lista, en vez de usar cuatro variables diferentes:
notas = map(int, valores[2:6])
Por ejemplo, un programa para imprimir el promedio de todos los alumnos se puede escribir
así:
archivo_alumnos = open('alumnos.txt')
for linea in archivo_alumnos:
valores = linea.strip().split(':')
nombre, apellido = valores[0:2]
notas = map(int, valores[2:6])
promedio = sum(notas) / 4.0
print '{0} obtuvo promedio {1}'.format(nombre, promedio)
archivo_alumnos.close()
Para escribir los datos en un archivo, hay que hacer el proceso inverso: convertir todos los
datos al tipo string, pegarlos en un único string, agregar el salto de línea al final y escribir la
línea en el archivo.
Si los datos de la línea ya están en una lista o una tupla, podemos convertirlos a string
usando la función map y pegarlos usando el método join:
alumno = ('Perico', 'Los Palotes', 90, 75, 38, 65)
linea = ':'.join(map(str, alumno)) + '\n'
archivo.write(linea)
Otra manera es armar el string parte por parte:
linea = '{0}:{1}:{2}:{3}:{4}:{5}\n'.format(nombre, apellido,
nota1, nota2, nota3, nota4)
archivo.write(linea)
Como siempre, usted debe preferir la manera que le parezca más simple de entender.