En esta sección se encuentra plasmado mis conocimientos adquiridos en un curso dictado por la Universidad Federico Santa María sobre los fundamentos de programación en Python.

Lo que veremos a continuación serán los siguientes temas:

• Estructuras condicionales
• Estructura de repetición WHILE
• Funciones
• Definicion de funciones avanzadas
• String y Ciclos
• Listas y ciclos FOR
• Listas Bi-dimensionales
• Tuplas
• Diccionarios
• Procesamiento de texto
• Archivos de texto

Estructuras condicionales

Operadores relacionales

Comparan valores. Operandos pueden ser cualquier expresión que pueda ser comparada. El resultado siempre es un valor lógico.

• igual a (==)
• distinto a (!=)
• mayor que (>)
• menor que (<)
• mayor o igual que (>=)
• menor o igual que (<=)

5 == 3

False

«casa» == ‘casa’

True

Operadores lógicos

Tienen operandos y resultado de tipo lógico.

• conjunción lógica and
• disyunción lógica or
• negación lógica not

3 == 5 and False

False

((3 + 4) < 2) or ((2**4) >= 4)

True

Sentencias Condicionales

Condicional if

La sentencia if ejecuta las instrucciones sólo si se cumple una condición. Si la condición es falsa no se hace nada

Sintaxis:

if condición:

    sentencias

La Tabulación/Sangría después de la instrucción if indica que cosas se realizarán si se cumple la condición. Esto se llama Indentación.

Ejemplo:

nota = int(input(«Ingrese su nota: «))

if nota >= 4:

    print(«Felicitaciones!!!»)

Condicional if-else

La sentencia if-else decide que instrucciones ejecutar, dependiendo si una condición es verdadera o falsa.

Sintaxis:

if condicion:

    sentencias cuando la condicion es verdadera

else:

    sentencias cuando la condicion es falsa

Ejemplo

edad = int(input(«Cual es su edad? «))

if edad < 18:

    print(«Usted es menor de edad»)

else:

    print(«Usted es adulto»)

Condicional if-elif-else

La sentencia if-elif-else depende de dos o más condiciones, que son evaluadas en orden. La primera que sea verdadera determina qué instrucciones son ejecutadas.

Sintaxis:

if cond1:

    sentencias a ejecutar si cond1 es verdadera

elif cond2:

    sentencias a ejecutar si cond2 es verdadera

elif cond3:

    sentencias a ejecutar si cond3 es verdadera

…

else:

    sentencias cuando ninguna condicion anterior es verdadera

La Indentación después de cada instrucción elif indica que cosas se realizarán si se cumple su respectiva condición (consecuentemente, si no se cumplen las condiciones anteriores)

Ejemplo

nota = int(input(«Ingrese su nota: «))

if nota >= 80:

    print(«Usted es un alumno destacado.»)

elif nota >= 65:

    print(«Usted ha aprobado.»)

elif nota >= 55:

    print(«Usted aprobó con algunas dificultades.»)

elif nota >= 45:

    print(«Con un poco mas de empeño hubiese aprobado.»)

else:

    print(«Nos vemos el próximo semestre.»)

Conclusión

• Las estructuras condicionales nos permiten realizar labores diferentes dependiendo si se cumple alguna condición.
• La tabulación/sangría indica qué elementos se realizan al cumplir una condición. Este proceso se llama Indentación.
• Una estructura condicional tiene al if como instrucción obligatoria.
• Las instrucciones elif y else son opcionales. Si son utilizadas, siempre irán en compañía de un if.

Estructuras de repetición WHILE

Sentencias Cíclicas

Permiten realizar un conjunto de instrucciones reiterativamente. Esta reiteración puede:

• Ser una cantidad determinada de veces.
• Hasta que una condición se cumpla.

OJO: Nótese que una cantidad finita de veces puede ser representada como condición.

Ciclo while

El ciclo while ejecuta una secuencia de instrucciones mientras una condición sea verdadera.

Sintaxis:

while cond:

    sentencias mientras la cond sea verdadera

La Indentación después de la instrucción while indica que cosas se realizarán reiterativamente si se cumple la condición.

Conceptos y detalles importantes

• Iteración: es una ejecución del cuerpo del ciclo. Cada vez que se ejecutan las sentencias del ciclo se habla de iteración.
• La condición es evaluada antes de cada iteración.
• Si la condición es inicialmente falsa, el ciclo no se ejecutará.

Ejemplo

m = int(input(«m: «))

n = int(input(«n: «))

k = 0

while m > 0:

    m = m – 1

    k = k + n

print(«El producto de m y n es:»,k)

Patrones Comunes

Patrón: Solución aplicable a un problema que ocurre a menudo.

1. Sumar cosas
2. Multiplicar cosas
3. Contar cosas
4. Encontrar el máximo
5. Encontrar el mínimo

Sintaxis sumar cosas:

suma = 0

ciclo:

    n = calcular()

    suma = suma + n

Sintaxis multiplicar cosas:

producto = 1

ciclo:

    n = calcular()

    producto = producto * n

Sintaxis contar cosas:

cuenta = 0

ciclo:

    if condicion:

        cuenta = cuenta + 1

Sintaxis encontrar el máximo:

mayor = numero_muy_chico

ciclo:

    n = calcular()

    if n > mayor:

        mayor = n

Sintaxis encontrar el mínimo:

menor = numero_muy_grande

ciclo:

    n = calcular()

    if n < menor:

        menor = n

Ejercicio

Escriba un programa que determine si un número es primo o compuesto.

n=int(input(«n: «))

es_primo = True

d = 2

while d<n and es_primo:

    if n%d == 0:

        es_primo = False

    d = d+1

if es_primo:

    print(«Es primo»)

else:

    print(«Es compuesto»)

Conclusiones

• Depende. A veces hay operaciones que se deben hacer muchas veces.
• Un ciclo es recomendado cuando una misma operación se debe repetir, pero cambiando algo ligeramente.
• Los ciclos son útiles, pero peligrosos si no se tiene cuidado de la condición

Funciones

Hasta el momento se ha visto que existen funciones ya definidas que pueden ser utilizadas. Ejemplo de estas funciones son:

• abs()
• print()
• float()
• etc.

Sin embargo, en ocasiones necesitamos crear funciones para realizar ciertas tareas específicas. Para realizar esto, se deben tener presente 2 aspectos:

• La definición de la función.
• El adecuado llamado de la función previamente definida.

Definición de una función

Para definir una función se debe utilizar la palabra reservada def, seguida de la siguiente sintaxis:

def nombre_funcion(parametro1, parametro2, …):

Toda función definida debe tener un nombre luego de la palabra def. Este nombre cumple las mismas restricciones de nombres de variables.

Los parámetros de entradas entre paréntesis redondos ( ). Estos parámetros deben ir separados por comas y pueden ser una cantidad variable. Se termina al final con el carácter dos puntos :.

Definición de una función

Después de escribir la primera línea de código de la función, se deben escribir todas las instrucciones. Estas instrucciones deben estar indentadas de tal manera que todas estén dentro de la función

En la mayoría de los casos, las funciones tienen una instrucción especial representada por la palabra reservada return. Esta instrucción especial nos indica el momento en que nos salimos de la función, retornando algún valor de interés.

Un ejemplo:

def discriminante(a,b,c):

    resultado = b**2-4*a*c

    return resultado

Llamado de la función

Una vez la función es creada, como en el ejemplo anterior, podemos utilizarla. A este proceso comúnmente se le llama: llamar la función.

Para llamar a una función, se debe saber el nombre de esta y los parámetros que recibe. Es importante respetar el número de parámetros.

Siguiendo el ejemplo anterior, llamar a una función en Python consiste en lo siguiente:

var_resultado = discriminante(1,4,2)

Con lo anterior, guardamos el dato que calcula la función (variable resultado) en la variable var_resultado. Veamos que nos entrega:

var_resultado

8

Recuerde utilizar una variable para guardar lo que entrega la función.

Si quisiéramos hacer un programa que nos pudiera resolver las ecuaciones de segundo grado, nuestro código podría ser:

def discriminante(a,b,c):

    resultado = b**2-4*a*c

    return resultado

p1 = float(input(‘Ingrese el valor a:’))

p2 = float(input(‘Ingrese el valor b:’))

p3 = float(input(‘Ingrese el valor c:’))

var_resultado = discriminante(p1,p2,p3)

if var_resultado < 0:

    print(‘La ecuacion no tiene solucion real’)

elif var_resultado == 0:

    sol = –p2 / (2*p1)

    print(‘La solucion es unica y es sol=’, sol)

else:

    sol = (–p2 – (var_resultado**0.5))/(2*p1)

    sol2 = (–p2 + (var_resultado**0.5))/(2*p1)

    print(‘Las soluciones son:’)

    print(‘sol=’, sol)

    print(‘sol2=’, sol2)

Diferencia entre print() y return

print() y return pueden tener un comportamiento muy parecido, pero no se les debe confundir, ya que son instrucciones completamente diferentes.

• return es el resultado de una función, por lo tanto solo debe ir dentro de una función.
• print() es una salida de un programa, puede ir tanto en una función (aunque no es tan común) como en el código de un programa principal (el main).
• return se comporta muy parecido al print() cuando a la función se le llama de la consola (shell).
• Lo anterior cambia cuando el código se ejecuta desde el archivo.

Recordemos la función, la cual estará guardada en un archivo llamado prueba.py:

def discriminante(a,b,c):

    resultado = b**2-4*a*c

    return resultado

Al ejecutar el archivo prueba.py no nos mostrará ningún resultado por pantalla, ya que el return no se comporta como un print() cuando se ejecuta desde un archivo.

Para obtener resultado por pantalla, se debe llamar la función:

discriminante(1,2,4)

-12

Si queremos que al ejecutar el archivo prueba.py muestre inmediatamente el resultado de la función, debemos llamar a la función incluyendo un print().

Nuestro archivo prueba.py entonces quedaria como:

def discriminante(a,b,c):

    resultado = b**2-4*a*c

    return resultado

print(discriminante(1,2,4))

Debemos ejecutar la función desde la consola para que nos entregue el resultado. Y al llamarla, debemos entregarle los valores de los parámetros. NO OLVIDAR!!

Lo que hace python es cargar la función en memoria y luego mostrar por pantalla (gracias al print()) el resultado de llamarla.

Definiciones de funciones avanzadas

Descomposición en Funciones

Como dice el refrán: Divide y Vencerás… Es posible resolver un problema difícil, dividiéndolo en subproblemas más simples (en la medida de lo posible). La idea es resolver el problema principal, utilizando las soluciones de los subproblemas.

En el mundo de la informática, es muy frecuente que se resuelvan los problemas de esta forma, siendo uno de los paradigmas más importantes en el diseño de algoritmos. Un pequeño esquema podría ser:

Problema:

    Subproblema 1

    Subproblema 2

    …

    Subproblema N

Subproblema a Función

Recordando los contenidos vistos en clases anteriores, podríamos relacionar cada subproblema a una función. De esta forma el esquema anterior quedaría más o menos así:

# Inicio de mi algoritmo (problema):

def funcion1(…):

    Instrucciones

def funcion2(…):

    Instrucciones

….

Instrucciones

funcion1(…)

Instrucciones

funcion2(…)

…

En resumen, buscamos descomponer nuestro algoritmo en funciones, integrar estas funciones y finalmente obtener nuestra solución.

Ahora el problema está en la capacidad de encontrar los subproblemas… Pero generalmente son bastante simples de identificar.

Variables Globales y Locales

Si bien hay una definición mucho más completa de los tipos de variables Globales y Locales, para nosotros bastará diferenciarlas de la siguiente manera:

• Variable local: es una variable que sólo se usa dentro del código de una función.
• Variable global: es una variable que se puede utilizar en cualquier parte del programa, inclusive al interior de una función.

A continuación un pequeño ejemplo.

Opción 1, utilizando G como variable global.

G = 6.67428e-11 # Variable global. Puede ser utilizada en cualquier parte del código

def cgu(masa1, masa2, radio):

    # La variable fuerza se comporta como variable local, 

    # solo se conoce dentro de la función cgu

    fuerza = G * masa1 * masa2 / (radio ** 2)

    return fuerza

m1 = float(input(‘m1: ‘))

m2 = float(input(‘m2: ‘))

r = float(input(‘Distancia: ‘))

print(‘La fuerza de atraccion es’, cgu(m1, m2, r))

Opción 2, utilizando G como variable local.

def cgu(masa1, masa2, radio):

    # Tanto fuerza como G son variables locales que solo se conocen en cgu.

    G = 6.67428e-11

    fuerza = G * masa1 * masa2 / (radio ** 2)

    return fuerza

m1 = float(input(‘m1: ‘))

m2 = float(input(‘m2: ‘))

r = float(input(‘Distancia: ‘))

print(‘La fuerza de atraccion es’, cgu(m1, m2, r))

Ciclos Anidados

Como su nombre lo dice, hay problemas en los cuales es necesario utilizar una estructura repetitiva dentro de otra estructura repetitiva. Sintaxis general:

ciclo:

    ciclo:

        ciclo:

            …

Y en Python:

while condicion:

    while condicion:

        while condicion:

            instrucciones

Ejemplo

un programa que muestre todas las combinaciones de dos dados que entreguen un puntaje mayor que siete.

dado_1 = 1

while dado_1 <= 6:

    dado_2 = 1

    while dado_2 <= 6:

        if dado_1 + dado_2 > 7:

            print(dado_1, dado_2)

        dado_2 += 1

    dado_1 += 1

String y ciclos

Strings

Son el tipo de dato usado para representar texto en Python.

Usando strings para entradas y salidas

Anteriormente, los strings se utilizaban en entradas y salidas de datos.

nombre = input(«Ingrese su nombre: «)

print(«Mi nombre es»,nombre)

Strings vacíos

Los valores literales » y «» representan strings vacíos, es decir, un texto que no contiene caracteres.

print(«»)

«»

»

Estructura de un String

Un string (que no es el string vacío) se compone de varios elementos, llamados caracteres.

Índice de un string

Es posible enumerar los caracteres de un string, desde cero para el primer carácter y aumentando la enumeración en sentido izquierda-derecha.

Acceder al carácter de un string mediante indexación

Cuando una variable es de tipo string, es posible acceder al carácter que se encuentra en el índice i-ésimo usando corchetes.

a = «hola mundo!»

#obtiene el caracter que esta en el indice 5 y lo muestra por pantalla

print(a[5])

ambién es posible enumerar los caracteres de un string usando índices negativos:

a = «hola mundo!»

#obtiene el ultimo caracter y lo muestra por pantalla

print(a[-1])

Substrings

Utilizando los corchetes es posible obtener una parte de un string (substring), es decir, algunos de sus caracteres.

s[inicio:fin] entrega un string con todos los caracteres desde el índice inicio, hasta el índice fin-1.

Por ejemplo, a[3:7], donde a = «hola mundo!» corresponde al substring ‘a mu’

a = «hola mundo!»

b = a[3:7]

print(b)

Omitiendo inicio, se asume que el substring parte desde el inicio del string original.

Ejemplo, a[:6], donde a = «hola mundo!» corresponde al substring ‘hola m’.

a = «hola mundo!»

b = a[:6]

print(b)

Omitiendo fin, se asume que el substring termina cuando termina el string original.

Ejemplo, a[2:], donde a = «hola mundo!» corresponde al substring ‘la mundo!’.

a = «hola mundo!»

b = a[2:]

print(b)

Operaciones elementales sobre Strings

Algunos operadores definidos anteriormente para números, pueden utilizarse sobre strings.

• Concatenación de strings (+)
• Repetición de strings (*)

«hola» +  «mundo»

x = 4

c = 4**2

mensaje = str(4)+«al cuadrado es»+str(c)

print(mensaje)

Otras operaciones para strings

1. La instrucción in permite saber si un substring está contenido dentro de un string. Es similar a un operador de comparación, por lo que entrega valores True o False. Se puede negar con el operador lógico not.

«pollo» in «repollos»

True

2. La función len(s) entrega como resultado la cantidad de caracteres del string s pasado como parámetro.

len(«hola mundo!»)

11

Comparaciones de strings

Los operadores de comparación se pueden utilizar sobre strings.

«a» > «z»

False

«Casa» < «casa»

True

El código ASCII

El código ASCII asocia con un número decimal a los caracteres imprimibles (letras, números y símbolos) y se utilizan para decidir el ordenamiento.

Los strings tienen su propio ordenamiento, que considera el siguiente orden creciente:

• Dígitos escritos como strings
• Algunos caracteres especiales
• Letras mayúsculas
• Letras minúsculas

Mayúsculas y Minúsculas

Los métodos s.upper() y s.lower() permiten cambiar el string s a mayúsculas y minúsculas, respectivamente.

Un método es una función que opera directamente sobre una variable que es de cierto tipo de dato.

pal = «Progra»

pal.lower()

‘progra’

pal.upper()

‘PROGRA’

s.upper() y s.lower() generan un nuevo string a partir del valor de s. NO MODIFICAN A s.

print(pal)

Progra

Ciclo For

• Repite sentencias una cantidad fija de veces.
• Funciona sobre tipos de datos iterables

¿Qué significa iterable?

Un tipo de dato que se puede iterar es aquel que se puede recorrer sobre cada uno de sus «elementos» constituyentes en un ciclo.

Ejemplo: un string está compuesto por caracteres. Luego con un ciclo for se puede recorrer cada carácter de este string.

a = «hola mundo!»

for s in a:

    print(«s = «+str(s))

s = h

s = o

s = l

s = a

s =

s = m

s = u

s = n

s = d

s = o

s = !

Sintaxis genérica de un Ciclo For

for variable in secuencia:

    #codigo

    a = operacion(variable)

• Cada vez que se utiliza un ciclo for, se define una variable que va a tomar cada uno de los valores de secuencia.
• La secuencia debe ser un tipo de dato iterable.

Listas ciclos y for

Listas

• Colección o secuencia de valores
• Pueden contener básicamente cualquier cosa

Creación de Listas

• Usando corchetes []
• Usando la función list()

Lista vacía

a = []

b = list()

print(a)

print(b)

[]

[]

Lista con elementos

a = [1,2,3,4]

palabra = «hola»

b = list([palabra,2,[1,2],‘3’])

print(a)

print(b)

[1, 2, 3, 4]

[‘hola’, 2, [1, 2], ‘3’]

c = list(«abc»)

print(c)

[‘a’, ‘b’, ‘c’]

Rangos

La función range genera una secuencia de números ordenados.

• Existen varias formas de usar esta función.
• Se pueden crear listas a partir de las secuencias de range.

range(fin) genera una secuencia de fin números ordenados desde 0 hasta fin-1.

#rango de 3 numeros

a = range(3)

print(a)

range(0, 3)

range(inicio,fin) genera una secuencia de números ordenados, iniciada en inicio y terminada en fin-1.

#rango de numeros desde el 2 al 7

c = range(2,7)

print(c)

range(2, 7)

range(inicio, fin, salto) genera una secuencia de números ordenados, iniciada en inicio, hasta antes de llegar a fin, con saltos entre cada número de la secuencia de salto.

#rango de numeros desde el 2 hasta el 10 con saltos de 3

range(2,10,3)

range(2, 10, 3)

Indexación en listas

Las listas tienen índices para enumerar sus elementos, de manera similar que con strings.

a = [1,2,3,4]

print(a[1])

2

A diferencia de los strings, las listas son tipos de datos mutables. El índice puede ser usado para modificar un elemento de la lista

colores = [«azul», «rojo», «verde», «amarillo»]

print(«Lista antes de modificar un elemento por el indice»)

print(colores)

colores[0] = «fucsia»

print(«Lista despues de modificar un elemento por el indice»)

print(colores)

Lista antes de modificar un elemento por el indice

[‘azul’, ‘rojo’, ‘verde’, ‘amarillo’]

Lista despues de modificar un elemento por el indice

[‘fucsia’, ‘rojo’, ‘verde’, ‘amarillo’]

Las listas también poseen índices negativos.

a = [1,2,3,4]

#imprime por pantalla el penultimo elemento de la lista

print(a[-2])

3

La notación l[inicio:fin] también es válida para listas, solo que obtiene una lista con los elementos desde el índice inicio hasta el índice fin-1.

a = list(range(2,20))

print(a[4:15])

[6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

Operaciones sobre listas

Algunas operaciones de listas son análogas a las operaciones de strings:

• Concatenación de lista (+)
• Repetición de listas (*)
• Verificar si un elemento está en en la lista
• Eliminar el elemento i-ésimo de una lista

Concatenación de listas

El operador suma (+) permite juntar dos listas

[1,2] + [2,6]

[1, 2, 2, 6]

Repetición de listas

El operador multiplicación (*) permite repetir una lista

a = [1,4,6]

c = a*3

print(c)

[1, 4, 6, 1, 4, 6, 1, 4, 6]

Verificar si elemento se encuentra en la lista

La instrucción in permite verificar si un elemento está contenido en la lista.

a = [1,2,3,4]

6 in a

False

Eliminar un elemento de la lista

• Utilizando la instrucción del, es posible eliminar un elemento de la lista.
• Se debe indicar el índice de la lista a eliminar.

a = [1,2,3,4,2]

print(«lista antes de eliminar el elemento a[-3]»)

print(a)

del a[-3]

print(«lista despues de eliminar a[-3]»)

print(a)

lista antes de eliminar el elemento a[-3]

[1, 2, 3, 4, 2]

lista despues de eliminar a[-3]

[1, 2, 4, 2]

Funciones que aceptan listas como parámetros

Longitud de una lista

La función len(lista) entrega la cantidad de elementos de la lista ingresada como parámetro.

a = [1,2,3,4]

c = len(a)

print(«La cantidad de elementos de la lista es»,c)

La cantidad de elementos de la lista es 4

Suma de los valores de una lista

Usando la función sum(lista), se puede determinar la suma de los elementos de una lista.

sum([1,5,3])

9

Mínimo en una lista de elementos

La función min(lista) entrega el valor mínimo en la lista ingresada como parámetro.

m = min([1,6,2,-1])

print(m)

-1

Máximo en una lista de elementos

La función max(lista) entrega el valor máximo en la lista ingresada como parámetro.

m = max([1,6,2,-1])

print(m)

6

Métodos para listas

• Agregar un elemento x: l.append(x)
• Agregar un elemento x en una posición pos: l.insert(pos,x)
• Contar la aparición de un elemento x: l.count(x)
• Obtener el índice de un elemento x: l.index(x)
• Eliminar un elemento x: l.remove(x)
• Invertir una lista: l.reverse()
• Ordenar una lista: l.sort()

Importante: recordar que los métodos operan sobre una variable que es de cierto tipo. En este caso l es una lista.

Agregar un elemento

• Usando append, se agrega un elemento al final de la lista.

a = [1,2,3,4]

print(«lista antes de agregar un elemento»)

print(a)

#agregar un 4 al final de la lista

a.append(4)

print(«lista despues de agregar un elemento»)

print(a)

lista antes de agregar un elemento

[1, 2, 3, 4]

lista despues de agregar un elemento

[1, 2, 3, 4, 4]

Agregar un elemento en una posición

Usando el método insert se puede agregar un elemento en la lista en la posición i-ésima ingresada como parámetro.

a = [1,2,3,4]

print(«lista antes de agregar un elemento»)

print(a)

#agregar un 10 en a[2]

a.insert(2,10)

print(«lista despues de agregar un elemento»)

print(a)

lista antes de agregar un elemento

[1, 2, 3, 4]

lista despues de agregar un elemento

[1, 2, 10, 3, 4]

Contar la aparición de un elemento en una lista

El método count cuenta cuántas veces aparece un elemento en la lista.

a = list(«paralelepipedo»)

b = a.count(«p»)

print(b)

3

Índice de un elemento

• El método index entrega la posición de un elemento en la lista
• Si hay más de un elemento en la lista, entrega la posición del primer elemento (sentido izquierda – derecha).
• El elemento debe existir.

a = [1,2,3,4,3]

a.index(3)

2

Eliminar un elemento de una lista

• El método remove elimina el elemento ingresado como parámetro
• Si hay más de un elemento en la lista, elimina el primer elemento (sentido izquierda – derecha).
• El elemento debe existir en la lista

a = [1,2,3,5,3]

print(«lista antes de eliminar el elemento 3»)

print(a)

#eliminar el elemento 3 de la lista

a.remove(3)

print(«lista despues de eliminar»)

print(a)

lista antes de eliminar el elemento 3

[1, 2, 3, 5, 3]

lista despues de eliminar

[1, 2, 5, 3]

Invertir una lista

El método reverse invierte el orden de los elementos de una lista.

a = [4,1,10,5]

print(«lista antes de invertir»)

print(a)

a.reverse()

print(«lista despues de invertir»)

print(a)

lista antes de invertir

[4, 1, 10, 5]

lista despues de invertir

[5, 10, 1, 4]

Ordenar una lista

El método sort ordena los elementos de una lista en orden creciente.

a = [4,1,10,6]

print(«lista antes de ordenar»)

print(a)

a.sort()

print(«lista despues de ordenar»)

print(a)

Ciclo for en listas

• Un ciclo for puede ser usado para iterar sobre listas.

lista = [1,4,«s»,[1,5]]

for elem in lista:

    print(«elem =»,elem)

elem = 1

elem = 4

elem = s

elem = [1, 5]

Utilizando range en un ciclo for

suma = 0

for k in range(3,6):

    suma += k**2

print(suma)

50

Iterables (hasta el momento):

• Strings
• Listas
• range

Listas Bi-dimensionales

Las listas bi-dimensionales se caracterizan por que al menos un elemento de la lista es, a su vez, otra lista.También se les llama: listas de listas o listas anidadas.

Las listas de listas tienen las mismas características que una lista normal (o uni-dimensional). Es decir:

• Se les puede aplicar los métodos ya vistos: .append(), .sort(), .remove(), etc.
• Estas listas pueden tener cualquier tamaño, incluso pueden crearse como listas vacías.
• Pueden contener cualquier tipo de dato.

Ejemplo de listas de listas pueden ser:

L1 = [1,2,3, [4,5,6,7,8], 9]

L2 = [True, 234, [1988, 4, 12], ‘lista de listas’, [False, ‘789’]]

L3 = [[],[]]

print(‘Lista L1:’, L1)

print(‘Lista L2:’, L2)

print(‘Lista L3:’, L3)

Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]

Lista L2: [True, 234, [1988, 4, 12], ‘lista de listas’, [False, ‘789’]]

Lista L3: [[], []]

Se debe tener conciencia que en estos casos, los elementos de las listas pueden ser elementos que pueden contener a su vez otros elementos.

Listas Bi-dimensionales: manejo de índices

El manejo de índices en listas de listas aumenta un poco su complejidad, pero es importante entenderlo ya que es posible obtener cualquier valor y esto facilita mucho el trabajo.

Hasta ahora sabemos que para obtener el valor de un elemento de una lista es necesario usar los paréntesis cuadrados o corchetes [ ]

Este operador (operador rebanador) nos permite acceder a elementos de un iterable, es decir: lista y string. Entonces, podemos usar tantas veces como queramos el operador rebanador, siempre y cuando tengamos al lado izquierdo una lista o string.

Volvamos al ejemplo anterior, es decir, con las listas L1, L2, y L3

print(‘Lista L1:’, L1)

print(‘Lista L2:’, L2)

print(‘Lista L3:’, L3)

Lista L1: [1, 2, 3, [4, 5, 6, 7, 8], 9]

Lista L2: [True, 234, [1988, 4, 12], ‘lista de listas’, [False, ‘789’]]

Lista L3: [[], []]

Si sabemos que: L1[3] es la lista [4,5,6,7,8], entonces podemos obtener el primer elemento de la siguiente manera:

sub_lista = L1[3]

primer_elem = sub_lista[0]

print(‘El primer elemento de la sublista es:’,primer_elem)

El primer elemento de la sublista es: 4

De una manera abreviada, y más conveniente, podemos escribir lo mismo de la siguiente manera:

primer_elem = L1[3][0]

print(‘El primer elemento de la sublista es:’,primer_elem)

El primer elemento de la sublista es: 4

Los paréntesis corchetes: [ ], permiten acceder a la ubicación que le damos con el valor entero (positivo o negativo), pero además, es posible realizar esto tantas veces como queramos siempre y cuando lo que esté a lado izquierdo sea una lista o un string.

Listas Bi-dimensionales: recorrerlas mediante for

La forma de recorrer las listas mediante for es muy sencilla. Se debe seguir las mismas reglas que para recorrer una lista uni-dimensional.

Se debe poner atención que valores toma ahora la variable que se crea en el for.

Veamos un ejemplo:

print(‘Lista L2:’, L2)

Lista L2: [True, 234, [1988, 4, 12], ‘lista de listas’, [False, ‘789’]]

for elemento in L2:

    print(‘Valor de la variable elemento:’, elemento)

Valor de la variable elemento: True

Valor de la variable elemento: 234

Valor de la variable elemento: [1988, 4, 12]

Valor de la variable elemento: lista de listas

Valor de la variable elemento: [False, ‘789’]

Veamos otro ejemplo:

ramos = [[‘Progra’,‘IWI-131’, 3],

         [‘Mate’, ‘MAT-021’, 5],

         [‘Fisica’, ‘FIS-100’, 3],

         [‘Ed.Fisica’, ‘DEW-100’, 1],

         [‘Inmanente’, ‘HRW-102’, 2],

        ]

for nombre, sigla, c in ramos: # 3 variables en vez de 1

    print(nombre, ‘tiene’, c, ‘creditos’)

Progra tiene 3 creditos

Mate tiene 5 creditos

Fisica tiene 3 creditos

Ed.Fisica tiene 1 creditos

Inmanente tiene 2 creditos

En la línea del for ahora hay 3 variables en vez de 1. Esto es posible ya que sabemos que cada elemento de la lista ramos, siempre, tendrá 3 elementos.

La lista ramos es una lista de listas, donde cada sub-lista siempre tiene 3 elementos.

Cada variable creada en la línea del for, tomará cada valor de las sub-listas. Esto será en orden, es decir: primera variable con el primer elemento de la sub-lista, y así sucesivamente.

Siguiendo el ejemplo anterior, es posible recorrer cada sub-lista para así obtener cada elemento uno por uno sin que falte ninguno. Esto se hace con un for adicional:

ramos = [[‘Progra’,‘IWI-131’, 3],

         [‘Mate’, ‘MAT-021’, 5],

         [‘Fisica’, ‘FIS-100’, 3],

         [‘Ed.Fisica’, ‘DEW-100’, 1],

         [‘Inmanente’, ‘HRW-102’, 2],

        ]

for asignatura in ramos:

    print(‘Valor de la variable asignatura:’, asignatura)

    for dato in asignatura:

        print(‘Valor de la variable dato:’, dato)

Valor de la variable asignatura: [‘Progra’, ‘IWI-131’, 3]

Valor de la variable dato: Progra

Valor de la variable dato: IWI-131

Valor de la variable dato: 3

Valor de la variable asignatura: [‘Mate’, ‘MAT-021’, 5]

Valor de la variable dato: Mate

Valor de la variable dato: MAT-021

Valor de la variable dato: 5

Valor de la variable asignatura: [‘Fisica’, ‘FIS-100’, 3]

Valor de la variable dato: Fisica

Valor de la variable dato: FIS-100

Valor de la variable dato: 3

Valor de la variable asignatura: [‘Ed.Fisica’, ‘DEW-100’, 1]

Valor de la variable dato: Ed.Fisica

Valor de la variable dato: DEW-100

Valor de la variable dato: 1

Valor de la variable asignatura: [‘Inmanente’, ‘HRW-102’, 2]

Valor de la variable dato: Inmanente

Valor de la variable dato: HRW-102

Valor de la variable dato: 2

Listas N-dimensionales o listas de listas de listas de listas … de listas

Como hemos visto, podemos imaginar, y nada nos prohíbe, crear listas n-dimensionales. Esto quiere decir que podemos tener varias «listas anidadas» dentro de una gran lista. Veamos un ejemplo:

L = [[1,2,3,4,[11,22,33]],[5,6,7,[66]],[[88,99],8,9, [88,99,[888,[8888,9999]]]]]

print(L)

[[1, 2, 3, 4, [11, 22, 33]], [5, 6, 7, [66]], [[88, 99], 8, 9, [88, 99, [888, [8888, 9999]]]]]

a1 = L[0]

a2 = L[2][3][0]

a3 = L[1][-1]

a4 = L[-1][-1][-1][1][0]

print(a1)

print(a2)

print(a3)

print(a4)

[1, 2, 3, 4, [11, 22, 33]]

88

[66]

8888

Cada paréntesis corchete nos permite adentrarnos más a la lista. Recordar que esto es posible si el elemento de la lista es un iterable: string o lista

Tuplas 

• Una tupla es una secuencia de valores agrupados.
• Pueden contener básicamente cualquier cosa.
• Una tupla sirve para agrupar, como si fueran un único valor, varios valores que por su naturaleza deben ir juntos.
• Una tupla es inmutable, es decir, no puede ser modificada una vez que ha sido creada.

Creación de Tuplas

• Usando paréntesis ()
• Usando la función tuple()

Tupla Vacía

Aunque no tiene mucha utilidad. 

a = ()

b = tuple()

print(a)

print(b)

()

()

Tupla con elementos

a = (1,2,3,4)

b = tuple([‘a’, 1, True, [1, 2]])

print(a)

print(b)

(1, 2, 3, 4)

(‘a’, 1, True, [1, 2])

La función tuple(iterable) convierte a tupla el tipo de dato dado por la variable iterable. Cada elemento de iterable es agregado a una tupla.

tup = tuple(«abc»)

print(tup)

(‘a’, ‘b’, ‘c’)

Desempaquetado de Tuplas

Los valores individuales de una tupla pueden ser recuperados asignando la tupla a las variables respectivas. Esto se llama desempaquetar la tupla.

tupla = (1, 2, 3)

a, b, c = tupla

print(tupla)

print(a, b, c)

(1, 2, 3)

1 2 3

Para desempaquetar correctamente debe utilizar tantas variables como elementos posee la tupla.

Además, también es posible extraer los valores usando su índice, al igual que con las listas:

tupla = (1, 2, 3)

print(tupla[1])

2

A diferencia de las listas, los elementos de una tupla no se pueden modificar.

Usos recomendados

Las tuplas se usan siempre que es necesario agrupar valores. Generalmente, conceptos del mundo real son representados como tuplas que agrupan información sobre ellos.

posicion_alfil = (7, 6)

alumno = (‘Fulano’, ‘De Tal’, ‘201199001-1’)

carta = (5, ‘corazones’)

fecha = (2011, 4, 12)

triangulo = ((5, 1), (2, 4), (-2, 0))

personaje = (‘Arturo Prat’, (1848, 4, 3), (1879, 5, 21))

punto = (6.6, -2.4, 3.7)

x, y, z = punto

Comparación de Tuplas

Dos tuplas son iguales cuando tienen el mismo tamaño y cada uno de sus elementos correspondientes tienen el mismo valor:

(1, 2) == (3 // 2, 1 + 1)

True

(6, 1) == (6, 2)

False

Para determinar si una tupla es menor que otra, se utiliza lo que se denomina orden lexicográfico. Si los elementos en la primera posición de ambas tuplas son distintos, ellos determinan el ordenamiento de las tuplas:

(1, 4, 7) < (2, 0, 0, 1)

True

(1, 9, 10) < (0, 5)

False

La primera comparación es True porque 1 < 2. La segunda comparación es False porque 1 > 0. No importa el valor que tengan los siguientes valores, o si una tupla tiene más elementos que la otra.

Si los elementos en la primera posición son iguales, entonces se usa el valor siguiente para hacer la comparación:

(6, 1, 8) < (6, 2, 8)

True

(6, 1, 8) < (6, 0)

False

La primera comparación es True porque 6 == 6 y 1 < 2. La segunda comparación es False porque 6 == 6 y 1 > 0 .

Si los elementos respectivos siguen siendo iguales, entonces se sigue probando con los siguientes uno por uno, hasta encontrar dos distintos. Si a una tupla se le acaban los elementos para comparar antes que a la otra, entonces es considerada menor que la otra:

(1, 2) < (1, 2, 4)

True

(1, 3) < (1, 2, 4)

False

La primera comparación es True porque 1 == 1, 2 == 2, y ahí se acaban los elementos de la primera tupla. La segunda comparación es False porque 1 == 1 y 3 < 2; en este caso sí se alcanza a determinar el resultado antes que se acaben los elementos de la primera tupla.

Algunas operaciones sobre tuplas

Verificar si elemento se encuentra en una tupla

La instrucción in permite verificar si un elemento está contenido en una tupla.

t = (1, 5, 6)

1 in t

True

Funciones que aceptan tuplas como parámetros

Longitud de una tupla

La función len(tupla) entrega la cantidad de elementos de la tupla ingresada como parámetro.

t = (1,2,3,4,8,10)

print(«La cantidad de elementos en la tupla es», len(t))

La cantidad de elementos en la tupla es 6

Suma de los valores de una tupla

Usando la función sum(tupla), se puede determinar la suma de los elementos de una tupla.

sum(t)

28

Mínimo y Máximo en una tupla de elementos

La función min(tupla) y max(tupla) entrega el valor mínimo y máximo de la tupla ingresada como parámetro.

print(min(t), max(t))

1 10

Ciclo for en tuplas

• Un ciclo for puede ser usado para iterar sobre tuplas.

tt = tuple(range(10))

for e in tt:

    print(e)

0

1

2

3

4

5

6

7

8

9

Iterables (hasta el momento):

• Strings
• Listas
• range
• Tuplas

Mezcla de Estructuras: Lista de Tuplas

Algunas veces es necesario integrar varias estructuras para resolver ciertos problemas.

# Opcion 1

ramos = [

    (‘Progra’, ‘IWI-131’, 3),

    (‘Mate’, ‘MAT-021’, 5),

    (‘Física’, ‘FIS-100’, 3),

    (‘Ed.Fisica’, ‘DEW-100’, 1),

    (‘Inmanente’, ‘HRW-102’, 2)

]

# Iterar sobre la lista de tuplas

for ramo in ramos:

    nombre, sigla, c = ramo

    print(nombre, ‘tiene’, c, ‘creditos’)

Progra tiene 3 creditos

Mate tiene 5 creditos

Física tiene 3 creditos

Ed.Fisica tiene 1 creditos

Inmanente tiene 2 creditos

# Opcion 2

ramos = [

    (‘Progra’, ‘IWI-131’, 3),

    (‘Mate’, ‘MAT-021’, 5),

    (‘Física’, ‘FIS-100’, 3),

    (‘Ed.Fisica’, ‘DEW-100’, 1),

    (‘Inmanente’, ‘HRW-102’, 2)

]

# Iterar sobre la lista de tuplas

for nombre, sigla, c in ramos:

    print(nombre, ‘tiene’, c, ‘creditos’)

Progra tiene 3 creditos

Mate tiene 5 creditos

Física tiene 3 creditos

Ed.Fisica tiene 1 creditos

Inmanente tiene 2 creditos

Ordenar una lista de tuplas

star_wars = [

    (4, ‘Una nueva Esperanza’),

    (5, ‘El Imperio Contraataca’),

    (6, ‘El Retorno del Jedi’),

    (1, ‘La Amenaza Fantasma’),

    (2, ‘El Ataque de los Clones’),

    (3, ‘La Venganza de los Siths’),

    (7, ‘El Despertar de la Fuerza’),

    (8, ‘Los Ultimos Jedi’)

]

star_wars

[(4, ‘Una nueva Esperanza’),

 (5, ‘El Imperio Contraataca’),

 (6, ‘El Retorno del Jedi’),

 (1, ‘La Amenaza Fantasma’),

 (2, ‘El Ataque de los Clones’),

 (3, ‘La Venganza de los Siths’),

 (7, ‘El Despertar de la Fuerza’),

 (8, ‘Los Ultimos Jedi’)]

star_wars.sort()

star_wars

[(1, ‘La Amenaza Fantasma’),

 (2, ‘El Ataque de los Clones’),

 (3, ‘La Venganza de los Siths’),

 (4, ‘Una nueva Esperanza’),

 (5, ‘El Imperio Contraataca’),

 (6, ‘El Retorno del Jedi’),

 (7, ‘El Despertar de la Fuerza’),

 (8, ‘Los Ultimos Jedi’)]

Diccionarios

Un diccionario es una colección no ordenada que permite asociar llaves con valores. Utilizando la llave siempre es posible recuperar, de manera eficiente, el valor asociado.

• El funcionamiento de diccionarios es similar a cuando se recupera un elemento de una lista usando su índice: L[i]
• En este caso el índice de la lista es una »llave» y el elemento recuperado es el »valor»

L = [1, 3, 4, 2, 4]

#imprimiendo el elemento del indice 3 de la lista L

print(L[3])

2

• En diccionarios, las llaves pueden ser: números, strings o tuplas.
• Las llaves en un diccionario deben ser únicas.

#diccionario de telefonos

#llaves: nombres de personas (string)

#valores: numeros de telefono asociados a cada nombre (int)

telefonos = {‘Jaimito’:5551428, ‘Yayita’: 5550012, ‘Pepito’:5552437}

#mostrar por pantalla el telefono de Pepito

print(telefonos[‘Pepito’])

5552437

Creación de Diccionarios

Un diccionario vacío puede ser creado por medio de la función dict() y con el paréntesis de llave {}.

dicc1 = {}

dicc2 = dict()

print(dicc1)

print(dicc2)

{}

{}

Un diccionario con elementos, considera que cada uno de ellos tiene una llave y su valor respectivo.

• El diccionario está delimitado por paréntesis de llaves.
• Cada elemento se separa por comas.
• Se utilizan los dos puntos : para separar una llave de un valor en un elemento.

Considerar el siguiente diccionario que relaciona animales (llaves) con la cantidad de patas que tienen (valores).

patas = {‘humano’: 2, ‘pulpo’: 8, ‘perro’: 4, ‘gato’: 4}

Manipulación de Diccionarios

Agregar/Modificar un elemento

Se debe hacer una asignación del diccionario con una llave igual a un valor.

• Si la llave utilizada no existe en el diccionario, se agrega un nuevo elemento.
• Si la llave utilizada existe en el diccionario, el valor asociado es modificado.

patas = {‘humano’: 2, ‘pulpo’: 8, ‘perro’: 5, ‘gato’: 4}

print(«Diccionario antes de agregar un valor»)

print(patas)

patas[‘cienpies’] = 100

print(«Diccionario despues de agregar un valor»)

print(patas)

Diccionario antes de agregar un valor

{‘humano’: 2, ‘pulpo’: 8, ‘perro’: 5, ‘gato’: 4}

Diccionario despues de agregar un valor

{‘humano’: 2, ‘pulpo’: 8, ‘perro’: 5, ‘gato’: 4, ‘cienpies’: 100}

#los perros en realidad tienen cuatro patas, cambiar valor en el diccionario

patas[«perro»] = 4

print(«Diccionario despues de cambiar un valor»)

print(patas)

Diccionario despues de cambiar un valor

{‘humano’: 2, ‘pulpo’: 8, ‘perro’: 4, ‘gato’: 4, ‘cienpies’: 100}

Eliminar un elemento

Usando la instrucción del se puede eliminar un elemento del diccionario. Se debe indicar la llave del elemento que se quiere eliminar.

patas =  {‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘pulpo’: 8, ‘perro’: 4}

print(«Diccionario antes de eliminar un elemento»)

print(patas)

#eliminando el elemento del diccionario

del patas[«pulpo»]

print(«Diccionario despues de eliminar un elemento»)

print(patas)

Diccionario antes de eliminar un elemento

{‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘pulpo’: 8, ‘perro’: 4}

Diccionario despues de eliminar un elemento

{‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘perro’: 4}

Al igual que en listas, al intentar eliminar un elemento que no existe (porque no existe la llave en el diccionario) ocurre un error.

Acceder a elementos de un diccionario

El valor asociado a la llave k del diccionario d se puede obtener como d[k]:

patas =  {‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘pulpo’: 8, ‘perro’: 4}

#accediendo y mostrando por pantalla la cantidad de patas de un gato

print(«El gato tiene»,patas[‘gato’],«patas»)

El gato tiene 4 patas

Funciones sobre Diccionarios

Cantidad de elementos

La función len permite saber la cantidad de elementos del diccionario.

patas =  {‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘pulpo’: 8, ‘perro’: 4}

print(len(patas))

5

Comprobar si una llave está en el diccionario

La instrucción in verifica si una llave está en el diccionario.

patas =  {‘cienpies’: 100, ‘humano’: 2, ‘gato’: 4, ‘pulpo’: 8, ‘perro’: 4}

print(‘pulpo’ in patas)

print(8 in patas)

True

False

Iteración sobre diccionarios

Se pueden utilizar ciclos for para iterar sobre diccionarios.

Considere el diccionario capitales, donde las llaves corresponden a países y los valores son las capitales respectivas de cada país.

capitales = {‘Chile’: ‘Santiago’, ‘Peru’: ‘Lima’, ‘Ecuador’: ‘Quito’}

for pa in capitales:

    #que esta imprimiendo en cada iteracion del ciclo?

    print(«pa =»,pa)

pa = Chile

pa = Peru

pa = Ecuador

capitales = {‘Chile’: ‘Santiago’, ‘Peru’: ‘Lima’, ‘Ecuador’: ‘Quito’}

for pais in capitales:

    #que se esta imprimiendo en cada iteracion del ciclo?

    print(«La capital de»,pais,«es»,capitales[pais])

La capital de Chile es Santiago

La capital de Peru es Lima

La capital de Ecuador es Quito

Sintaxis genérica:

for var in diccio:

    a = funcion(var)

• La variable var está accediendo implícitamente a cada llave del diccionario diccio.
• Recordar que, teniendo la llave, es posible acceder al valor asociado mediante diccio[var].

Iterables (hasta el momento):

• Strings
• Listas
• range
• Tuplas
• Diccionarios

Procesamiento de textos

El procesamiento de texto consiste en manipular strings para:

1. extraer información
2. convertir un texto en otro
3. codificar información

• Servirá más adelante para crear o editar archivos.

Secuencias de escape

Utilizando el carácter backslash (\) se pueden llamar a secuencias de escape que normalmente serían interpretadas como strings.

Salto de línea

• Corresponde al carácter backslash seguido de una n: ‘\n’.
• Es invisible al utilizar print.

a = «piano\nviolin\noboe»

print(a)

piano

violin

oboe

No obstante, la secuencia de escape es parte del string.

a

‘piano\nviolin\noboe’

Tabulación

• Se utiliza con backslash más el carácter t: \t
• Es equivalente a hacer una tabulación.

a = «piano\tviolin\toboe»

print(a)

piano violin oboe

a

‘piano\tviolin\toboe’

• La longitud de un salto de línea y una tabulación es 1.
• Por lo general, el carácter backslash es ignorado para efectos de cualquier string porque permite hacer las secuencias de escape.

len(«\n«)

1

len(«\t«)

1

len(«piano\nviolin\noboe»)

17

Removiendo carácteres especiales

El método s.strip() remueve espacios y caracteres especiales que aparezcan antes y después de algún texto.

s = «hola mundo\n«

print(s)

hola mundo

print(s.strip())

hola mundo

s

‘hola mundo\n’

s.strip()

‘hola mundo’

Importante: El método strip no remueve espacios, ni caracteres especiales que estén en medio de las palabras.

«hola\nmundo\n«.strip()

‘hola\nmundo’

Reemplazar secciones de un string

El método s.replace(antes,después) que reemplaza todas las apariciones del texto antes por el texto después en s.

orden = «Quiero arroz con pollo»

orden.replace(«arroz»,«pure»)

‘Quiero pure con pollo’

print(orden.replace(«arroz»,«pure»))

Quiero pure con pollo

orden = orden.replace(«arroz»,«pure»)

print(orden)

Quiero pure con pollo

El valor del string NO cambia

a = «11111111-5»

# reemplazar el caracter ‘1’ por ‘2’ en la variable a (que es un string)

a.replace(«1»,«2»)

‘22222222-5’

# reemplazar el caracter ‘1’ por ‘2’ en la variable a (que es un string)

# solo se reemplaza 2 veces

a.replace(«1»,«2»,2)

‘22111111-5’

Separar strings

• El método s.split() separa un string en varios substrings usando el espacio en blanco como separador.
• El método s.split(sep) separa un string en varios substrings usando el texto sep como separador.

s = «Ana lavaba las sabanas»

s.split()

[‘Ana’, ‘lavaba’, ‘las’, ‘sabanas’]

s.split(«aba»)

[‘Ana lav’, ‘ las s’, ‘nas’]

print(s)

Ana lavaba las sabanas

Unir strings

El método s.join(iterable) une los strings de la variable iterable utilizando a s como pegamento.

valores = [‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’]

pegamento = » «

pegamento.join(valores)

‘0 1 2 3 4 5’

«,».join(valores)

‘0,1,2,3,4,5’

Interpolación de strings

La interpolación de strings permite generar una plantilla que puede ser rellenada con información dinámica.

s =  «Soy {0} y vivo en {1}«

s.format(«Perico»,«Valparaiso»)

‘Soy Perico y vivo en Valparaiso’

s.format(«Erika»,«Berlin»)

‘Soy Erika y vivo en Berlin’

Soy {0} y vivo en {1}

• {0} y {1} se llaman campos, y el método format va rellenando los campos en orden.

«{1}{0}{2}{0}«.format(«a»,«v»,«c»)

‘vaca’

«{0} y {1}«.format(«carne»,«huevos»)

‘carne y huevos’

«{1} y {0}«.format(«carne»,«huevos»)

‘huevos y carne’

«{0}, {1} {3}«.format(«casa», «azul», «grande», «verde»)

‘casa, azul verde’

• Los campos pueden definirse por identificadores, en lugar de números.

s = «{nombre} estudia en la {universidad}«

s.format(nombre=«Perico», universidad=«UTFSM»)

‘Perico estudia en la UTFSM’

s.format(universidad=«PUC»,nombre=«Yayita»)

‘Yayita estudia en la PUC’

Archivos de textos

Tipo de archivo informático que contiene únicamente texto formado por caracteres que son legibles por humanos, careciendo de cualquier tipo de formato tipográfico.

Ejemplo de archivo: quijote.txt

En un lugar de la Mancha

de cuyo nombre no quiero acordarme

no ha mucho tiempo que vivia un hidalgo

Protocolo de uso

1. Abrir el archivo
2. Recorrer el archivo
3. Cerrar el archivo

Apertura de Archivo

Un archivo puede ser abierto mediante la función open, que acepta como parámetros la dirección donde se encuentra el archivo y el modo de apertura. Los modos de apertura son:

• Lectura ‘r’
• Escritura ‘w’
• Escritura añadiendo al final del archivo ‘a’

# Por omisión los archivos se abren en modo ‘r’

archivo = open(‘quijote.txt’)

Recorrer el archivo

Un archivo puede considerarse un tipo de dato iterable, es decir, podemos recorrerlo con for.

Al momento de iterar el archivo, se incluye la secuencia de escape. Por ejemplo ‘En un lugar de la Mancha\n’. Si queremos «limpiar» la línea leída es necesario utilizar la función strip(), vista en procesamiento de texto.

for linea in archivo:

    # Operaciones sobre linea

    linea = linea.strip()

    print(linea)

En un lugar de la Mancha

de cuyo nombre no quiero acordarme

no ha mucho tiempo que vivia un hidalgo

Cierre de archivo

El último paso es cerrar el archivo luego de leer la información. Para ello se utiliza el método close().

archivo.close()

Creación de archivos

Apertura

Para escribir un archivo, este debe abrirse en modo escritura usando la función open con el parámetro ‘w’.

nuevo_archivo = open(‘prueba.txt’, ‘w’)

Escritura

Se utilizará el método write, que recibe como parámetro un string con el texto que se escribirá en el archivo.

nuevo_archivo.write(‘Informacion\n‘)

12

Cierre

Al igual que en el caso de lectura, luego de escribir la información se debe cerrar el archivo con close().

nuevo_archivo.close()

Agregar información a un archivo existente

Apertura

Para escribir un archivo, este debe abrirse en modo ‘a’ usando la función open.

archivo = open(‘prueba.txt’, ‘a’)

Escritura

Se utilizará el método write, que recibe como parámetro un string con el texto que se agregará en el archivo.

archivo.write(«Nueva informacion\n«)

18

Cierre

Al igual que en el caso de lectura y escritura, luego de escribir la información se debe cerrar el archivo con close().

archivo.close()

Archivos con separador

Considere el archivo alumnos.txt que utiliza un carácter para separar la información. Por ejemplo:

Esteban:Gutierrez:49:18:32

Luisa:Miranda:68:44:99

Jean Paul:Munoz:48:38:81

Gianfranco:Basso:54:54:50

Romina:Smith:100:98:9

Lectura de este tipo de archivos

archivo = open(‘alumnos.txt’)

for linea in archivo:

    valores = linea.strip().split(‘:’)

    nombres = valores[0:2]

    notas = []

    for nota in valores[2:5]:

        notas.append(int(nota))

    print(nombres[0], notas)

archivo.close()

Esteban [49, 18, 32]

Luisa [68, 44, 99]

Jean Paul [48, 38, 81]

Gianfranco [54, 54, 50]

Romina [100, 98, 92]