Mini-Apunte Control 3 Introduccion a la Programacion

Bernardo Subercaseaux
25 de Noviembre 2015

1.

Temario

El primer paso en la preparaci

on del control corresponde a tener claridad sobre los contenidos a
evaluar, y la capacidad de describir brevemente cada uno de ellos. Esto no solo es un requisito para saber
que estudiar y que no, sino sobre todo una fuente de confianza y seguridad.
Los principales contenidos a evaluar son:
1. Estructuras indexadas
2. Estructuras de control
3. Diccionarios
4. Clases y objetos

2.

Estructuras indexadas

Como el nombre lo indica, las estructuras indexadas se tratan de estructuras, esto es, formas determinadas de almacenar datos con el objetivo de hacer mas facil o eficiente su manipulacion.
Como el nombre lo indica, las estructuras indexadas son indexadas, es decir, los datos que contienen
tienen un orden de modo que cada dato ocupa una posicion. Al n
umero de esa posicion se le llama ndice,
y se cuenta desde 0.
Ok, ya entend que son las estructuras indexadas, pero.. Cuales debera conocer para el control?
Respuesta:
1. strings
2. arreglos o listas de Python

2.1.

Strings

Sobre strings, debe saber lo siguiente:

Son inmutables:
1
2
3
4
5
6
7
8

>>> palabra = "video"

>>> palabra[0]
v
>>> palabra[0] = b
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
palabra[0] = b
TypeError: str object does not support item assignment
Que acaba de pasar? En primer lugar creamos un string, la palabra video, luego, mostramos como
se puede acceder a la letra de indice 0, es decir, la primera letra. Finalmente tratamos de cambiar la
primera letra por otra, pero obtuvimos un error, el error es que los strings son inmutables por lo que
no podemos cambiar una letra por otra. Una forma intuitiva de entender esto es que la palabra video.es
as, cambiarle una letra sera definir una palabra totalmente nueva...
Si queremos cambiar la letra de indice i de un string, podemos hacer lo siguiente, recordando que la
operaci
on + concatena strings (los pone uno al lado del otro).

1
2
3
4

>>>
>>>
>>>
mi

palabra = mi letra favorita es la A por que es bonita

palabra = palabra[0:24] + U + palabra[25:]
palabra
letra favorita es la U por que es bonita

Note como palabra[0:24] obtiene la parte de la palabra desde el indice 0 al 23 ( NO al 24, siempre
se excluye el u
ltimo). Luego pegamos la letra deseada, y luego el resto de la palabra. La notacion [25:]
indica desde el 25 hasta el final.
Otras funciones interesantes sobre strings son:

1
2
3
4
5
6
7
8
9
10
11

>>> palabra = "murcielago"

>>> u in palabra
True
>>> b in palabra
False
>>> palabra.index(u)
1
>>> len(palabra)
10
>>> palabra[-1] # ultimo caracter
y
Como puede notar, in nos dice si un caracter esta dentro de una palabra, e index nos indica el indice de
la primera aparici
on de un caracter, y len nos retorna el largo. (tambien puede hacerse ola in holanda,
y retornar
a True).

2.2.

Arreglos

Un arreglo es como una de esas listas recursivas y tediosas que hemos visto a lo largo del curso, solo
que no son recursivas ni tediosas.
Note como se crea un arreglo y se buscan elementos en el.
1
2
3
4
5

>>>
>>>
8
>>>
[5,

arreglo = [2,4,5,8,2,4]
arreglo[3]
arreglo[2:5]
8, 2]

Los arreglos son mutables

A diferencia de sus compa
neros los strings, los arreglos son mutables, es decir, sus elementos pueden
cambiar directamente.
1
2
3
4
5
6

>>> arreglo = [2,4,5,8,2,4]

>>> arreglo[3]
8
>>> arreglo[3] = "cualquier cosa menos 8"
>>> arreglo
[2,4,5,cualquier cosa menos 8,2,4]
Hay una serie de funciones que Python provee para trabajar con estas listas o arreglos. No debe
importar nada para usarlas, y son muy sencillas, como mostramos a continuacion.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

>>> arreglo = [7,3,1,2,2,4,9,1]

>>> len(arreglo) #cantidad de elementos
8
>>> max(arreglo) #mayor elemento
9
>>> min(arreglo) #menor elemento
1
>>> sum(arreglo) #suma de elementos
29
>>> arreglo.append(4) # agrega un 4 al final del arreglo
>>> arreglo
[7,3,1,2,2,4,9,1,4]
>>> arreglo.insert(2,19) # inserta 19 en la posicion de indice 2
>>> arreglo
[7,3,19,1,2,2,4,9,1,4]
>>> arreglo.pop() # remueve y retorna el ultimo elemento
4
>>> arreglo
[7,3,19,1,2,2,4,9,1]
>>> arreglo.sort() # ordena.
>>> arreglo
[1,1,2,2,3,4,7,9,17]
>>> arreglo.count(2) # cuenta cuantas veces aparece un elemento, en este caso el 2 esta 2 veces.
2
>>> arreglo.remove(1) # remueve la primera aparicion de un valor
>>> arreglo
3

27
28
29
30
31
32
33
34

[1,2,2,3,4,7,9,17]
>>> arreglo.index(2) ## retorna el indice de la primera aparicion de un elemento
1
>>> arreglo.reverse() # invierte el orden del arreglo
>>> arreglo
[17,9,7,4,3,2,2,1]
>>> arreglo + arrego # se suman como strings, quedan uno al lado del otro
[17,9,7,4,3,2,2,1,17,9,7,4,3,2,2,1]
Note que los elementos del arreglo no tienen por que ser enteros, pueden ser decimales, palabras o
cualquier cosa, incluso arreglos. De hecho, un arreglo de arreglos es conocido como una matriz. Observe
como se ven.

1
2
3
4
5

>>> M = [[2,3],[5,7]]
>>> M[0]
[2,3]
>>> M[0][1]
3
Menci
on especial requiere la funci
on range, que crea una lista de forma muy sencilla. Veamos ejemplos.

1
2
3
4
5
6
7
8
9
10

>>> range(7) ## crea lista desde 0 hasta N-1 (6)

[0,1,2,3,4,5,6]
>>> range(2,7) ## crea lista desde 2 (primer parametro) hasta 6 ( 7 - 1)
[2,3,4,5,6]
>>> range(2,7,2) ## igual que la anterior, pero va de dos en dos
[2,4,6]
>>> range(1,7,2) ## note que esta vez llega a 5 y no a 6
[1,3,5]
>>> range(4,1,-1) ## ejemplo destacado, notar que no llega a 1 sino a 2.
[4,3,2]
Una funci
on interesante que mezcla strings y arreglos se muestra en el siguiente ejemplo.

1
2
3

>>> palabra = "me gusta escuchar a Debussy"

>>> palabra.split(" ") ## separar la palabra por cada espacio
[me, gusta, escuchar, a, Debussy]

3.

Estructuras de Control

Hemos visto hasta ahora como almacenar informacion en palabras y arreglos, pero Para que hacemos
eso? La respuesta es sencilla, hacemos eso para trabajar con esa informacion de una forma mas sencilla.
Ser capacez de trabajar con informaci
on es uno de los principales objetivos de la computacion, tanto as
que algunas veces se le llama por eso Inform
atica. A continuacion empezaremos a trabajar con ello.
Una estructura de control es una forma de controlar un proceso, definiendo cuando (en que casos)
queremos que se ejecute, y cuando no. Ademas, permiten definir cuantas veces queremos que se ejecuten,
o hasta cuando queremos que se ejecuten. Lo primero nos llevara al estudio del if, lo segundo al estudio
del for y lo tercero a estudiar while.

3.1.

IF

Es la estructura de control m
as sencilla, basicamente dice que queremos que una accion (o grupo de
acciones) se ejecute si y solo si se cumple una cierta condicion. Dado que para estas alturas debera
entenderse bien, veamos ejemplos.

1
2
3
4

>> if 2 < 3: print "hola" #la condicion es cierta, por lo tanto se realizara.
hola
>> if 3 < 2: print "hola" #en este caso no
>>
En este momento, podra usted preguntarse que utilidad tiene esto, y la respuesta es que en la vida
real modelamos muchas cosas de este modo, por ejemplo, un cajero automatico le da plata a una persona
si y solo si la tiene en su cuenta, o el navegador se abre si y solo si se presiona sobre el.
Un ejemplo m
as interesante sera hacer la suposicion (incorrecta, pero razonable) de que los nombres
de mujer terminan en a, y por lo tanto hacer el siguiente programa con que un extra-terreste de la
especie Boov saluda.

1
2
3
4
5
6
7
8
9

def Saludar():
nombre = raw_input("ingrese su nombre") ## se solicita al usuario ingresar su nombre
if nombre[-1] == a: ## si el ultimo caracter es a
print "Saludos mujer terricola" + nombre
elif nombre == "Boov":# los extrarrestres de la especie Boov se llaman Boov
#note que el uso de elif garantiza que esto solo se hara si es que no se hizo lo anterior
print "Saludos Boov"
else: ## si es que no se cumpla ninguna condicion anterior
print "Saludos hombre terricola"

3.2.

FOR

La instrucci
on for es una de las instrucciones mas u
tiles. En espa
nol quiere decir para, y es una
herencia del lenguaje matem
atico. En el lenguaje matematico, se suelen decir cosas como x X, f (x) =
0. Esto quiere decir que para todo valor en un conjunto, se tiene una propiedad. En programaci
on
utilizaremos la misma idea para hacer que para todo valor en un conjunto, se ejecute una accion. A
continuaci
on un ejemplo b
asico:

1
2
3
4
5
6

>>> for i in range(4): print i ## para todo valor en range(4) , que sabemos es [0,1,2,3], imprimir.
...
0
1
2
3
Veamos ahora un ejemplo interesante. Supongamos que tenemos un arreglo y queremos contar cuantos
elementos tiene que sean mayores a un cierto valor K. Pienselo unos segundos y luego observe la soluci
on
a continuaci
on.

1
2
3
4

##
##
##
def

5
6
7
8
9

Funcion que cuente la cantidad de elementos mayores a un valor

arreglo, int -> int
ejemplo: contarMayores([2,4,5],2) -> 2
contarMayores(lista,K):
mayores = 0 # en principio hay 0 elementos mayores
for elemento in lista: # para cada elemento en la lista
if elemento > K: # si es mayor
mayores += 1 # aumentamos en 1 la cuenta
return mayores # luego de recorrer todos (fuera del for) retornamos.

10
11

assert contarMayores([2,4,5],2) == 2
Otro ejemplo de interes es encontrar el mnimo valor de una lista.

1
2
3
4
5
6
7
8
9

##
##
##
def

Funcion que encuentra el menor elemento de una lista

arreglo -> any (int o string en general)
ejemplo: menor([2,4,5,1]) -> 1
menor(lista):
menor = lista[0] # al principio asumiremos que el menor es el primero
for elemento in lista: # revisamos cada elemento de la lista
if elemento < menor: # si el elemento es menor que el que creiamos que era el menor
menor = elemento # ahora el es el menor
return menor ## finalmente retornamos el que quedo como menor luego de recorrer todo.

10
11

assert menor([2,4,5,1]) == 1
Otra aplicaci
on interesante de for es que si queremos realizar algo un n
umero determinado de veces,
aunque no tenga que ver con ning
un conjunto de valores, podemos usar for para hacerlo. Observe el
siguiente ejemplo:

1
2
3
4
5
6
7

>>> for i in range(5): print "hola"

...
hola
hola
hola
hola
hola

3.3.

WHILE

Esta instrucci
on es bastante similar a for, puesto que tambien permite realizar un proceso repetidas
veces, sin embargo, esta vez no realizaremos una operacion seg
un elementos de un conjunto (que como
puede notarse tiene un tama
no definido), sino que lo haremos mientras se cumpla una condicion, o hasta
que se cumpla una condici
on. La palabra while proviene del ingles y quieres decir mientras.
Observe el siguiente ejemplo:
1
2
3
4
5
6

>>> i = 0
>>> while i < 10:
...
i+= 1
...
>>> i
10
Por que luego el valor de i es 10 si al principio era 0? Por que dijimos que mientras su valor fuese
menor que 10, aumentara en 1. Por lo tanto va a dejar de aumentar 1 cuando su valor ya no sea menor
a 10, es decir, cuando sea 10.
Fijese que el c
odigo no depende de que el valor inicial de i haya sido 0, habra dado el mismo resultado
si i hubiese partido con el valor 4, o 6, o cualquiera menor a 10.
Esto nos lleva a plantear la diferencia fundamental entre for y while, esta es, que for realiza un n
umero definido de operaciones (tantas como elementos tenga el conjunto que el for recorre). Por otra parte
while realiza un n
umero textbfindefinido de operaciones (las que sean necesarias para que la condici
on
del while deje ser cierta).
Un ejemplo interesante puede ser, Cuantas veces es necesario dividir en 2 un n
umero para que llegue
a 1?

1
2
3
4
5
6
7
8
9
10

## Funcion que retorna la cantidad de divisiones por 2 necesarias para llevar un numero a 1
## int -> int
## cVeces(8) -> 3
def cVeces(n):
i = 0 # cantidad de divisiones inicial
while n != 1: # mientras no lleguemos a uno
n = n / 2 #dividimos el numero en 2
i += 1 # y aumentamos la cantidad de veces que hemos dividido
return i ## retornamos la cantidad final de divisones.
assert cVEces(8) == 3
Recuerda la funci
on index, que entergaba el indice de la primera aparicion de un elemento en una
lista? Programemosla usando while!

1
2
3
4
5
6
7
8

## Funcion que retorna el indice de primera aparicion de un elemento en una lista

## arreglo, any -> int
## indice([2,4,5],4) -> 1
def indice(lista,elemento):
i = 0 # primer elemento
while lista[i] != elemento: # mientras el elemento i sea distinto del buscado
i+= 1 # miramos el siguiente
return i # si salimos del while significa que lo encontramos.
Puede notarse que si un elemento no se encuentra en la lista y preguntamos su ndice, este programa
arrojar
a un error.
7

4.

Diccionarios

Los Diccionarios son una estructura de datos particularmente u

tiles, puesto que son capaces de realizar b
usquedas muy muy r
apido.
Pero de que est
as hablando? Bueno, primero veamos lo siguiente:
Cuando habl
abamos de estructuras indexadas, hace dos captulos, mostramos como cada posici
on
tena un elemento asociado. Eso quiere decir, que una lista se podra interpretar como una especie de
funci
on que recibe un ndice y entrega el elemento en esa posicion, por ejemplo, si tenemos una lista o
arreglo L = [1,2,3,7,2], se podra decir algo como: f(3) = 7, puesto que el elemento de ndice 3 es 7.
Pero y si queremos que esa funci
on f sea mas interesante? Por ejemplo, si no queremos darle un
ndice, sino algo tan sofisticado como una empresa de comida rapida, y que nos responda que tipo de
comida es... Usaremos diccionarios!
Mire el siguiente ejemplo basado en lo anterior:

1
2
3

>>> LocalesDeComida = {"mcDonalds":"americana", "niusushi":"japonesa","Papa Johns":"italiana" }

>>> LocalesDeComida["Papa Johns"]
italiana
Note como construimos el diccionario usando corchetes curvos, pero accedemos a los elementos a partir de corchetes cuadrados, al igual que en las listas o arreglos que vimos antes. Ademas las parejas de
elementos est
an separadas por comas, mientras que dentro de una pareja estan separados por dos puntos.
A los valores del dominiode esa funcion f se le llama llaves, y a los valores del recorridose les llama
simplementente valores. Las parejas en un diccionario siempre se escriben de la forma llave:valor.
Puede notar que los diccionarios sirven entonces para modelar muchsimas situaciones distintas, por
ejemplo, los helados favoritos de cada persona, donde la llave podra ser el nombre de la persona, y el
valor sera el sabor de su helado favorito. Como modelara el sistema de una biblioteca que requiere saber
para cada usuario la lista de libros que tiene arrendados? Respuesta en el siguiente parrafo, permtase
unos segundos para pensar por si mismo.
Podra tenerse un diccionario donde las llaves son n
umeros que identifican a cada usuario, por ejemplo,
en la universidad el c
odigo asociado a cada TUI, y los valores seran arreglos que contienen nombres de
libros. Es solo una opci
on para modelar el problema.
Observe las siguientes funciones sobre diccionarios:

1
2
3
4
5
6
7

>>> Biblio = {juan:[],pedro:[el quijote], maria:[el arte de programar,la biblia]}

>>> Biblio.keys()
[juan, pedro, maria]
>>> Biblio.values()
[[], [el quijote], [el arte de programar, la biblia]]
>>> pedro in Biblio
True

5.

Clases y Objetos

Una clase es un conjunto de cosas con propiedades comunes, por ejemplo, los computadores, y un
objeto es una instancia particular de una clase, por ejemplo, el HP-2580 desde el cual escribo este
documento.
Las propiedades comunes que tienen los objetos de una clase se llaman atributos o variables de instancia, por ejemplo, la marca sera una siguiendo con el ejemplo de los computadores (todos los computadores
tienen una marca, no quiere decir que tengan todos la misma, sino que es una propiedadde cada computador).
As como en introducci
on al
algebra se ve que una estructura se define por un conjunto y operaciones
sobre el, por ejemplo, los enteros y la suma, se puede usar la misma idea aqu. El conjunto es la clase, y
las funciones definidas sobre el se llaman m
etodos.
Ok, consideremos que queremos hacer la clase triangulo, cuyos atributos o variables de instancia seran
los tres vertices que los componen. Sin embargo, los vertices son pares de enteros (una coordenada X y
otra coordenada Y). Por lo que primero construiremos la clase Par, para poder representarlos.
C
omo se construye una clase? Pese a que puede sonar complicado, para crear la clase Par solo hace
falta la lnea:

class Par:
Sin embargo, solo tener la clase no es muy u
til, por lo que nos enfrentamos al primer problema de las
clases, el de construir un OBJETO de esa clase. Para construir un objeto de una clase, hay que indicar
cuales son los par
ametros que reciben. En este caso, un entero X y un entero Y. Ademas, la funcion que
CONSTRUYE un objeto de la clase, tiene que llamarse necesariamente init . Con eso llevaramos lo
siguiente:

1
2

class Par:
def __init__(x,y):
La pregunta clave aqu es, Que tiene que tener entonces el constructor (la funcion init )? Bueno,
la respuesta es que no solo basta decirle al computador que un Par recibe dos enteros x e y, sino que hay
que decirle que representan esos valores x e y en un Par. (Por ejemplo, para hacer una clase Computador,
no solo hara falta escribir HP sino que decir tambien de alguna forma que HP es la MARCA del
Computador). Entonces, quisieramos decirle al computador algo as como x sera la primera componente
del Par, e y ser
a la segunda componente del Par. Podra pensarse en la siguiente idea:

1
2
3
4

class Par:
def __init__(x,y):
Par.primeraComponente = x
Par.segundaComponente = y
Esa idea, si bien es buena, tiene un ligero problema, y es que al hacer Par.primeraComponente
estaramos asumiendo que Par existe, pero justo estamos tratando de construirlo, y por tanto no existe
a
un. Para arreglar esto, le llamaremos de una manera especial a esto que estamos construyendo, que no
es un Par a
un, pero que lo ser
a una vez que le asignemos sus atributos. Esa mnaera especial se llama
self.

1
2
3
4

class Par:
def __init__(self,x,y):
self.primeraComponente = x
self.segundaComponente = y
Esto ya es un constructor correcto. Luego podemos hacer en la consola lo siguiente:

1
2
3

>>> A = Par(2,3) ## notese que al construir no le damos el self, solo los dos valores necesarios.
>>> A.segundaComponente
3
Nuestra clase Tri
angulo comenzara a verse as:

1
2
3
4
5

class Triangulo:
def __init__(self,P1,P2,P3):
self.vertice1 = P1
self.vertice2 = P2
self.vertice3 = P3
Donde P1, P2 y P3 son objetos de la clase Par.
Hay una peque
na sutileza con las clases, y es que no traen una forma de imprimirse por defecto. Esto
quiere decir que a menos que haga algo especial, se tiene el siguiente problema luego de ejecutar el c
odigo:

1
2
3
4
5
6

>>> P1 = Par(2,3)
>>> P2 = Par(4,5)
>>> P3 = Par(7,7)
>>> T = Triangulo(P1,P2,P3)
>>> print T
<__main__.Triangulo instance at 0x7fedb594cbd8>
Esto quiere decir que a menos que hagamos nuestra propia funcion, la forma natural de imprimir un
objeto es inentendible para un usuario corriente. Por lo tanto... Hagamos nuestra propio metodo para
imprimir un tri
angulo! Dado que ya sabemos de arreglos y estructuras de control, podramos hacer que
un tri
angulo se imprimiera como una matriz, marcando de alguna forma especial los vertices. Observe el
c
odigo a continuaci
on:

1
2
3
4
5
6
7
8

class Par:
def __init__(self,x,y):
self.primeraComponente = x
self.segundaComponente = y
def __eq__(self,other): ## Con este metodo comparamos que dos pares sean iguales
igualX = self.primeraComponente == other.primeraComponente
igualY = self.segundaComponente == other.segundaComponente
return igualX and igualY

9
10
11
12
13
14

class Triangulo:
def __init__(self,P1,P2,P3):
self.vertice1 = P1
self.vertice2 = P2
self.vertice3 = P3
10

def imprimir(self): # Solo requiere el self, puesto que no se necesita ningun parametro extra
#las renombramos por simplicidad}
vertices = [self.vertice1,self.vertice2,self.vertice3]
print vertices
a = self.vertice1.primeraComponente
b = self.vertice1.segundaComponente
c = self.vertice2.primeraComponente
d = self.vertice2.segundaComponente
e = self.vertice3.primeraComponente
f = self.vertice3.segundaComponente
primeras = [a,c,e] # primerasComponentes
segundas = [b,d,f] # segundasComponentes
S = ""
## Que la matriz sea mas grande que todos los vertices
for i in range(2*max(segundas)): ## con esto veremos las filas
for j in range(2*max(primeras)): ## con esto veremos las columnas
if Par(i,j) in vertices: S+=# #vertice
else: S += . # no vertice
S += \n #un salto de linea despues de cada fila
print S

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

P1 = Par(3,1)
P2 = Par(6,7)
P3 = Par(1,6)
T = Triangulo(P1,P2,P3)
T.imprimir()
El resultado de este c
odigo es:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

.
.
.
.
.
.
.
.
.
.
.
.
.

. . . . . . . . . . . .
. . . . . # . . . . .
. . . . . . . . . . .
# . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . # . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .

Puede notarse que si se cambia el nombre del metodo imprimir a str , luego en vez de hacerse
T.imprimir() puede hacerse el natural print T. Esto es porque esos guiones bajos le indican a python
que estamos usando metodos cl
asicos, que tienen formas de llamarse particulares. Esto explica por que
se puede sumar 2 + 3 sin algo as como sumar(2,3). (En particular, para que una funcion luego pueda
llamarse con el signo + debe llamarse add )

11

El conjunto de estos ejemplos debera ser suficiente para que el alumno o la alumna perdida se sienta
en una mejor posici
on. Mucho
animo y suerte! cualquier duda pueden escribir a mi correo: bernardosubercaseaux@gmail.com

12