Programación UTFSM¶

Algoritmos¶

La informática se trata de computadores tanto como la astronomía se trata de telescopios. — Edsger Dijkstra.

Al diseñar un programa, el desafío principal es crear y describir un procedimiento que esté completamente bien definido, que no tenga ambigüedades, y que efectivamente resuelva el problema.

Así es como la programación no es tanto sobre computadores, sino sobre resolver problemas de manera estructurada. El objeto de estudio de la programación no son los programas, sino los algoritmos.

Un algoritmo es un procedimiento bien definido para resolver un problema.

Todo el mundo conoce y utiliza algoritmos a diario, incluso sin darse cuenta:

• Una receta de cocina es un algoritmo; si bien podríamos cuestionar que algunos pasos son ambiguos (¿cuánto es «una pizca de sal»? ¿qué significa «agregar a gusto»?), en general las instrucciones están lo suficientemente bien definidas para que uno las pueda seguir sin problemas.

  La entrada de una receta son los ingredientes y algunos datos como: ¿para cuántas personas se cocinará? El proceso es la serie de pasos para manipular los ingredientes. La salida es el plato terminado.

  En principio, si una receta está suficientemente bien explicada, podría permitir preparar un plato a alguien que no sepa nada de cocina.

• El método para multiplicar números a mano que aprendimos en el colegio es un algoritmo. Dado cualquier par de números enteros, si seguimos paso a paso el procedimiento siempre obtendremos el producto:

  

  La entrada del algoritmo de multiplicación son los dos factores. El proceso es la secuencia de pasos en que los dígitos van siendo multiplicados las reservas van siendo sumadas, y los productos intermedios son finalmente sumados. La salida del algoritmo es el producto obtenido.

Un algoritmo debe poder ser usado mecánicamente, sin necesidad de usar inteligencia, intuición ni habilidad.

A lo largo de esta asignatura, haremos un recorrido por los conceptos elementales de la programación, con énfasis en el aspecto práctico de la disciplina.

Al final del semestre, usted tendrá la capacidad de identificar problemas que pueden ser resueltos por el computador, y de diseñar y escribir programas sencillos. Además, entenderá qué es lo que ocurre dentro del computador los programas que usted usa.

Los computadores son inútiles: sólo pueden darte respuestas. — Pablo Picasso.

Componentes de un algoritmo¶

Conceptualmente, un algoritmo tiene tres componentes:

1. la entrada: son los datos sobre los que el algoritmo opera;
2. el proceso: son los pasos que hay que seguir, utilizando la entrada;
3. la salida: es el resultado que entrega el algoritmo.

El proceso es una secuencia de sentencias, que debe ser realizada en orden. El proceso también puede tener ciclos (grupos de sentencias que son ejecutadas varias veces) y condicionales (grupos de sentencias que sólo son ejecutadas bajo ciertas condiciones).

Cómo describir un algoritmo¶

Consideremos un ejemplo sencillo: un algoritmo para resolver ecuaciones cuadráticas.

Una ecuación cuadrática es una ecuación de la forma \(ax^2 + bx + c = 0\), donde \(a\), \(b\) y \(c\) son datos dados, con \(a\ne 0\), y \(x\) es la incógnita cuyo valor que se desea determinar.

Por ejemplo, \(2x^2 - 5x + 2 = 0\) es una ecuación cuadrática con \(a = 2\), \(b = -5\) y \(c = 2\). Sus soluciones son \(x_1 = 1/2\) y \(x_2 = 2\), como se puede comprobar fácilmente al reemplazar estos valores en la ecuación. El problema es cómo obtener estos valores en primer lugar.

El problema computacional de resolver una ecuación cuadrática puede ser planteado así:

Dados \(a\), \(b\) y \(c\), entontrar los valores reales de \(x\) que satisfacen \(ax^2 + bx + c = 0\).

La entrada del algoritmo, pues, son los valores \(a\), \(b\) y \(c\), y la salida son las raíces reales \(x\) (que pueden ser cero, una o dos) de la ecuación. En un programa computacional, los valores de \(a\), \(b\) y \(c\) deberían ser ingresados usando el teclado, y las soluciones \(x\) deberían ser mostradas a continuación en la pantalla.

Al estudiar álgebra aprendemos un algoritmo para resolver este problema. Es lo suficientemente detallado para que pueda usarlo cualquier persona, incluso sin saber qué es una ecuación cuadrática, o para que lo pueda hacer un computador. A continuación veremos algunas maneras de describir el procedimiento.

Diagrama de flujo¶

Un diagrama de flujo es una representación gráfica de un algoritmo. Los pasos son representados por varios tipos de bloques, y el flujo de ejecución es indicado por flechas que conectan los bloques:

El inicio y el final del algoritmo son representados con bloques circulares. El algoritmo siempre debe ser capaz llegar desde uno hasta el otro, sin importar por qué camino lo hace. Un algoritmo no puede «quedarse pegado» en la mitad.

La entrada y la salida de datos son representadas con romboides, que en la figura de arriba están pintados de verde.

Los diamantes representan condiciones en las que el algoritmo sigue uno de dos caminos. que están etiquetados con sí o no, dependiendo si la condición es verdadera o falsa.

También puede haber ciclos, representados por flechas que regresan a bloques anteriores. En este ejemplo, no hay ciclos.

Otras sentencias van dentro de rectángulos, que en la figura están pintados de azul. En este ejemplo, las sentencias son asignaciones, representadas en la forma nombre = valor.

Los diagramas de flujo no son usados en la práctica para programar, pero son útiles para ilustrar cómo funcionan algoritmos sencillos.

leer a
leer b
leer c

discriminante = b² - 4ac

si discriminante < 0:
    escribir 'La ecuación no tiene soluciones reales'

o si no, si discriminante = 0:
    x = -b / 2a
    escribir 'La solución única es', x

o si no:
    x1 = (-b - √discriminante) / 2a
    x2 = (-b + √discriminante) / 2a
    escribir 'Las dos soluciones reales son:'
    escribir x1
    escribir x2

a = float(raw_input('Ingrese a: '))
b = float(raw_input('Ingrese b: '))
c = float(raw_input('Ingrese c: '))

discriminante = b ** 2 - 4 * a * c
if discriminante < 0:
    print 'La ecuacion no tiene soluciones reales'
elif discriminante == 0:
    x = -b / (2 * a)
    print 'La solucion unica es x =', x
else:
    x1 = (-b - (discriminante ** 0.5)) / (2 * a)
    x2 = (-b + (discriminante ** 0.5)) / (2 * a)
    print 'Las dos soluciones reales son:'
    print 'x1 =', x1
    print 'x2 =', x2

raw_input()

Edición de programas¶

Un programa es un archivo de texto. Por lo tanto, puede ser creado y editado usando cualquier editor de texto, como el Bloc de Notas.

Lo que no se puede usar es un procesador de texto, como Microsoft Word.

Haga la prueba: abra el programa cuadratica.py con el Bloc de Notas (u otro editor) y verá su contenido.

Otros editores de texto (mucho mejores que el Bloc de Notas) que usted puede instalar son:

• en Windows: Notepad++, Textpad;
• en Mac: TextWrangler, TextMate;
• en Linux: Gedit, Kate.

Instalación del intérprete de Python¶

Una cosa es editar el programa, y otra es ejecutarlo. Para poder ejecutar un programa en Python hay que instalar el intérprete.

En la página de descargas de Python está la lista de instaladores. Debe descargar el indicado para su computador y su sistema operativo.

La versión que debe instalar es la 2.7.3, no la 3.2.3.

No use los instaladores que dicen x86-64 a no ser que esté seguro que su computador tiene una arquitectura de 64 bits (lo más probable es que no sea así).

Ejecución de un programa¶

Una vez escrito el programa e instalado el intérprete, es posible ejecutar los programas. Para hacerlo, haga doble clic en el ícono del programa.

Uso de la consola¶

La ejecución de programas no es la única manera de ejecutar el intérprete. Si uno ejecuta Python sin pasarle ningún programa, se abre la consola (o intérprete interactivo).

La consola permite ingresar un programa línea por línea. Además, sirve para evaluar expresiones y ver su resultado inmediatamente. Esto permite usarla como si fuera una calculadora.

La consola interactiva siempre muestra el símbolo >>>, para indicar que ahí se puede ingresar código. En todos los libros sobre Python, y a lo largo de este apunte, cada vez que aparezca un ejemplo en el que aparezca este símbolo, significa que debe ejecutarse en la consola, y no en un programa. Por ejemplo:

>>> a = 5
>>> a > 10
False
>>> a ** 2
25

En este ejemplo, al ingresar las expresiones a > 10 y a ** 2, el intérprete interactivo entrega los resultados False y 25.

No hay ningún motivo para tipear el símbolo >>> ni en un programa ni en un certamen, pues no es parte de la sintaxis del lenguaje.

Entornos de desarollo¶

En general, usar un simple editor de texto para escribir programas no es la manera más eficiente de trabajar.

Los entornos de desarrollo (también llamados IDE, por sus siglas en inglés) son aplicaciones que hacen más fácil la tarea de escribir programas.

Python viene con su propio entorno de desarrollo llamado IDLE. IDLE viene con una consola y un editor de texto.

Además, hay otros buenos entornos de desarrollo más avanzados para Python:

• PyScripter,
• WingIDE 101

Usted puede probar éstos y usar el que más le acomode durante el semestre.

El siguiente video muestra cómo usar IDLE para desarrollar un programa y para usar la consola interactiva:

Si desea trabajar con PyScripter en vez de IDLE, puede ver este otro video con una demostración de cómo usarlo.

Números enteros¶

El tipo int (del inglés integer, que significa «entero») permite representar números enteros.

Los valores que puede tomar un int son todos los números enteros: ... -3, -2, -1, 0, 1, 2, 3, ...

Los números enteros literales se escriben con un signo opcional seguido por una secuencia de dígitos:

1570
+4591
-12

Números reales¶

El tipo float permite representar números reales.

El nombre float viene del término punto flotante, que es la manera en que el computador representa internamente los números reales.

Hay que tener mucho cuidado, porque los números reales no se pueden representar de manera exacta en un computador. Por ejemplo, el número decimal 0.7 es representado internamente por el computador mediante la aproximación 0.69999999999999996. Todas las operaciones entre valores float son aproximaciones. Esto puede conducir a resultados algo sorpresivos:

>>> 1/7 + 1/7 + 1/7 + 1/7 + 1/7 + 1/7 + 1/7
0.9999999999999998

Los números reales literales se escriben separando la parte entera de la decimal con un punto. Las partes entera y decimal pueden ser omitidas si alguna de ellas es cero:

>>> 881.9843000
881.9843
>>> -3.14159
-3.14159
>>> 1024.
1024.0
>>> .22
0.22

Otra representación es la notación científica, en la que se escribe un factor y una potencia de diez separados por una letra e. Por ejemplo:

>>> -2.45E4
-24500.0
>>> 7e-2
0.07
>>> 6.02e23
6.02e+23
>>> 9.1094E-31
9.1094e-31

Los dos últimos valores del ejemplo son iguales, respectivamente, a \(6.02\times 10^{23}\) (la constante de Avogadro) y \(9.1094\times 10^{-31}\) (la masa del electrón).

Números complejos¶

El tipo complex permite representar números complejos.

Los números complejos tienen una parte real y una imaginaria. La parte imaginaria es denotada agregando una j inmediatamente después de su valor:

3 + 9j
-1.4 + 2.7j

Valores lógicos¶

Los valores lógicos True y False (verdadero y falso) son de tipo bool, que representa valores lógicos.

El nombre bool viene del matemático George Boole, quien creó un sistema algebraico para la lógica binaria. Por lo mismo, a True y False también se les llama valores booleanos. El nombre no es muy intuitivo, pero es el que se usa en informática, así que hay que conocerlo.

Texto¶

A los valores que representan texto se les llama strings, y tienen el tipo str.

Los strings literales pueden ser representados con texto entre comillas simples o comillas dobles:

"ejemplo 1"
'ejemplo 2'

La ventaja de tener dos tipos de comillas es que se puede usar uno de ellos cuando el otro aparece como parte del texto:

"Let's go!"
'Ella dijo "hola"'

Es importante entender que los strings no son lo mismo que los valores que en él pueden estar representados:

>>> 5 == '5'
False
>>> True == 'True'
False

Los strings que difieren en mayúsculas y minúsculas, o en espacios también son distintos:

>>> 'mesa' == 'Mesa'
False
>>> ' mesa' == 'mesa '
False

Nulo¶

Existe un valor llamado None (en inglés, «ninguno») que es utilizado para representar casos en que ningún valor es válido, o para indicar que una variable todavía no tiene un valor que tenga sentido.

El valor None tiene su propio tipo, llamado NoneType, que es diferente al de todos los demás valores.

Expresiones y variables¶

Una expresión es una combinación de valores y operaciones que son evaluados durante la ejecución del algoritmo para obtener un resultado.

Por ejemplo, 2 + 3 es una expresión aritmética que, al ser evaluada, siempre entrega el valor 5 como resultado. En esta expresión, 2 y 3 son valores literales y + es el operador de adición.

En el programa de conversión de temperaturas aparece la expresión (f - 32.0) * (5.0 / 9.0), cuyo resultado depende de cuál es el valor de f al momento de la evaluación. A diferencia de los valores literales, \(f\) es una variable que tiene un valor específico que puede ser distinto cada vez que la expresión es evaluada.

En esta expresión, * es el operador de multiplicación y / el de división.

Una expresión puede ser usada como una sentencia de un programa por sí sola, pero la mayoría de las veces esto no tiene ningún efecto. El programa evaluará la expresión, pero no hará nada con el resultado obtenido.

Asignaciones¶

Una asignación es una sentencia que asocia un nombre al resultado de una expresión. El nombre asociado al valor se llama variable.

La sintaxis de una asignación es la siguiente:

variable = expresión

Por ejemplo, el programa de conversión de temperaturas tiene la siguiente asignación:

c = (f - 32.0) * (5.0 / 9.0)

Cuando aparece una asignación en un programa, es interpretada de la siguiente manera:

1. primero la expresión a la derecha del signo = es evaluada, utilizando los valores que tienen en ese momento las variables que aparecen en ella;
2. una vez obtenido el resultado, el valor de la variable a la izquierda del signo = es reemplazado por ese resultado.

Bajo esta interpretación, es perfectamente posible una asignación como ésta:

i = i + 1

Primero la expresión i + 1 es evaluada, entregando como resultado el sucesor del valor actual de i. A continuación, la variable i toma el nuevo valor. Por ejemplo, si i tiene el valor 15, después de la asignación tendrá el valor 16.

Esto no significa que \(15 = 16\). Una asignación no es una igualdad matemática ni una ecuación.

Por ejemplo, las siguientes asignaciones son correctas, suponiendo que las variables que aparecen en ellas ya fueron asignadas previamente:

nombre = 'Perico Los Palotes'
discriminante = b ** 2 - 4 * a * c
pi = 3.14159
r = 5.0
perimetro = 2 * pi * r
sucesor = n + 1
a = a
es_menor = x < 4
x0 = x1 + x2
r = 2 * abs(x - x0)
nombre = raw_input('Ingrese su nombre')

Las siguientes no son asignaciones válidas, pues no respetan la sintaxis nombre = expresión (tarea: identifique los errores):

n + 1 = 5
7 = a
2_pi_r = 2 * pi * r
area del circulo = pi * r ** 2
x ** 2 = x * x

Entrada¶

La entrada es la parte del programa en que el usuario ingresa datos.

La manera más simple de ingresar datos es hacerlo a través del teclado. La función raw_input(mensaje) pide al usuario ingresar un valor, que puede ser asignado a una variable para ser usado por el programa. El mensaje es lo que se mostrará al usuario antes de que él ingrese el valor.

El valor ingresado por el usuario siempre es interpretado como texto, por lo que es de tipo str. Si es necesario usarlo como si fuera de otro tipo, hay que convertirlo explícitamente.

Por ejemplo, en el programa de conversión de temperaturas, la entrada es realizada por la sentencia:

f = float(raw_input('Ingrese temperatura en Fahrenheit: '))

Cuando el programa llega a esta línea, el mensaje Ingrese temperatura en Fahrenheit: es mostrado al usuario, que entonces debe ingresar un valor, que es convertido a un número real y asociado al nombre f.

Desde esa línea en adelante, la variable f puede ser usada en el programa para referirse al valor ingresado.

Salida¶

La salida es la parte del programa en que los resultados son entregados al usuario.

La manera más simple de entregar la salida es mostrando texto en la pantalla. En Python, la salida del programa es realizada por la sentencia print (imprimir en inglés).

Si se desea imprimir un texto tal cual, la sintaxis es la siguente:

print valor_a_imprimir

Si los valores a imprimir son varios, deben ser puestos separados por comas. Por ejemplo, el programa de conversión de temperaturas tiene la siguiente sentencia de salida:

print 'El equivalente en Celsius es:', c

En este caso, se está imprimiendo el mensaje El equivalente en Celsius es: y a continuación, en la misma línea, el valor de la variable c.

Las comillas sólo sirven para representar un string en el código, y no forman parte del string. Al imprimir el string usando print las comillas no aparecen:

>>> 'Hola'
'Hola'
>>> print 'Hola'
Hola

Comentarios¶

Un comentario es una sección del código que es ignorada por el intérprete. Un comentario puede ser utilizado por el programador para dejar un mensaje en el código que puede ser útil para alguien que tenga que leerlo en el futuro.

En Python, cualquier texto que aparezca a la derecha de un signo # es un comentario:

>>> 2 + 3  # Esto es una suma
5
>>> # Esto es ignorado
>>>

La excepción son los signos # que aparecen en un string:

>>> "123 # 456" # 789
'123 # 456'

Evitar que se cierre el programa¶

La ejecución de programas en Windows presenta un inconveniente práctico: cuando el programa termina, la ventana de ejecución se cierra inmediatamente, por lo que no es posible alcanzar a leer la salida del programa.

Por ejemplo, al ejecutar el programa temperatura.py tal como está arriba, el usuario verá el mensaje Ingrese temperatura... y a continuación ingresará el valor. Una vez que el programa entrega como resultado el equivalente en grados Celcius, no quedan más sentencias para ejecutar, por lo que el programa se cierra.

Existen otras maneras de ejecutar programas con las que este problema no ocurre. Por ejemplo, al ejecutar un programa desde una IDE, generalmente la salida aparece en una ventana que no se cierra.

Una solución para evitar que la ventana se cierre es agregar un raw_input() al final del código. De este modo, el programa quedará esperando que el usuario ingrese cualquier cosa (un enter basta) antes de cerrarse.

Los programas presentados en este apunte no tendrán el raw_input() al final, pero usted puede agregarlo por su cuenta si así lo desea. En controles y certámenes, no será necesario hacerlo.

Operadores¶

Un operador es un símbolo en una expresión que representa una operación aplicada a los valores sobre los que actúa.

Los valores sobre los que actúa un operador se llaman operandos. Un operador binario es el que tiene dos operandos, mientras que un operador unario es el que tiene sólo uno.

Por ejemplo, en la expresión 2.0 + x el operador + es un operador binario que en este contexto representa la operación de adición. Sus operandos son 2.0 y x.

Las operaciones más comunes se pueden clasificar en: aritméticas, relacionales, lógicas y de texto.

>>> 8 - 5
3
>>> 8 - 5.0
3.0
>>> 8.0 - 5
3.0
>>> 8.0 - 5.0
3.0

>>> 5 / 2
2
>>> 5 / -2
-3

>>> 3 + 4
7
>>> 3 + (4+0j)
(7+0j)

>>> 7 % 3
1

>>> 17 % 5   # 17 no es divisible por 5
2
>>> 20 % 5   # 20 si es divisible por 5
0

(a / b) * b + (a % b) == a

>>> n = -4
>>> +n
-4
>>> -n
4

>>> a = 5
>>> b = 9
>>> c = 14
>>> a < b
True
>>> a + b != c
False
>>> 2.0 == 2
True
>>> 'amarillo' < 'negro'
True

>>> x = 4
>>> 0 < x <= 10
True
>>> 5 <= x <= 20
False

>>> True and False
False
>>> not True
False

>>> 'perro' + 'gato'
'perrogato'

>>> 'waka' * 2
'wakawaka'

Precedencia¶

La precedencia de operadores es un conjunto de reglas que especifica en qué orden deben ser evaluadas las operaciones de una expresión.

La precedencia está dada por la siguiente lista, en que los operadores han sido listados en orden de menor a mayor precedencia:

• or
• and
• not
• <, <=, >, >=, !=, ==
• +, - (suma y resta)
• *, /, %
• +, - (positivo y negativo)
• **

Esto significa, por ejemplo, que las multiplicaciones se evalúan antes que las sumas, y que las comparaciones se evalúan antes que las operaciones lógicas:

>>> 2 + 3 * 4
14
>>> 1 < 2 and 3 < 4
True

Operaciones dentro de un mismo nivel son evaluadas en el orden en que aparecen en la expresión, de izquierda a derecha:

>>> 15 * 12 % 7    # es igual a (15 * 12) % 7
5

La única excepción a la regla anterior son las potencias, que son evaluadas de derecha a izquierda:

>>> 2 ** 3 ** 2    # es igual a 2 ** (3 ** 2)
512

Para forzar un orden de evaluación distinto a la regla de precedencia, debe usarse paréntesis:

>>> (2 + 3) * 4
20
>>> 15 * (12 % 7)
75
>>> (2 ** 3) ** 2
64

Otra manera de forzar el orden es ir guardando los resultados intermedios en variables:

>>> n = 12 % 7
>>> 15 * n
75

Como ejemplo, consideremos la siguiente expresión:

15 + 59 * 75 / 9 < 2 ** 3 ** 2 and (15 + 59) * 75 % n == 1

y supongamos que la variable n tiene el valor 2. Aquí podemos ver cómo la expresión es evaluada hasta llegar al resultado final, que es False:

15 + 59 * 75 / 9 < 2 ** 3 ** 2 and (15 + 59) * 75 % n == 1
#                         ↓
15 + 59 * 75 / 9 < 2 **   9    and (15 + 59) * 75 % n == 1
#                    ↓
15 + 59 * 75 / 9 < 512         and (15 + 59) * 75 % n == 1
#       ↓
15 +  4425   / 9 < 512         and (15 + 59) * 75 % n == 1
#            ↓
15 +        491  < 512         and (15 + 59) * 75 % n == 1
#                                      ↓
15 +        491  < 512         and    74     * 75 % n == 1
#                                            ↓
15 +        491  < 512         and          5550  % n == 1
#                                                   ↓
15 +        491  < 512         and          5550  % 2 == 1
#                                                 ↓
15 +        491  < 512         and                0   == 1
#  ↓
  506            < 512         and                0   == 1
#                ↓
                True           and                0   == 1
#                                                     ↓
                True           and                  False
#                               ↓
                              False

La operación entre paréntesis (15 + 59) debe ser evaluada antes de la multiplicación por 75, ya que es necesario conocer su resultado para poder calcular el producto. El momento preciso en que ello ocurre no es importante.

Lo mismo ocurre con la evaluación de la variable n: sólo importa que sea evaluada antes de ser usada por el operador de módulo.

En el ejemplo, ambos casos fueron evaluados inmediatamente antes de que su valor sea necesario.

Las reglas completas de precedencia, incluyendo otros operadores que aún no hemos visto, pueden ser consultados en la sección sobre expresiones de la documentación oficial de Python.

Llamadas a función¶

Los operadores forman un conjunto bastante reducido de operaciones. Más comúnmente, las operaciones más generales son representadas como funciones.

Al igual que en matemáticas, las funciones tienen un nombre, y reciben parámetros (o argumentos) que van entre paréntesis después del nombre. La operación de usar la función para obtener un resultado se llama llamar la función.

Ya conocemos la función raw_input(), que entrega como resultado el texto ingresado por el usuario mediante el teclado.

La función abs entrega el valor absoluto de su argumento:

>>> abs(4 - 5)
1
>>> abs(5 - 4)
1

La función len recibe un string y entrega su largo. (más adelante veremos otros usos de la función len):

>>> len('hola mundo')
10
>>> len('hola' * 10)
40

Los nombres de los tipos también sirven como funciones, que entregan el equivalente de su parámetro en el tipo correspondiente:

>>> int(3.8)
3
>>> float('1.5')
1.5
>>> str(5 + 6)
'11'
>>> int('5' + '6')
56

Las funciones min y max entregan el mínimo y el máximo de sus argumentos:

>>> min(6, 1, 8)
1
>>> min(6.0, 1.0, 8.0)
1.0
>>> max(6, 1, 4, 8)
8

La función round redondea un número real al entero más cercano:

>>> round(4.4)
4.0
>>> round(4.6)
5.0

Algunas funciones matemáticas como la exponencial, el logaritmo y las trigonométricas pueden ser usadas, pero deben ser importadas primero usando la sentencia import, que veremos en detalle más adelante:

>>> from math import exp
>>> exp(2)
7.3890560989306504
>>> from math import sin, cos
>>> cos(3.14)
-0.9999987317275395
>>> sin(3.14)
0.0015926529164868282

La lista completa de funciones matemáticas que pueden ser importadas está en la descripción del módulo math en la documentación de Python.

Más adelante también aprenderemos a crear nuestras propias funciones. Por ahora, sólo necesitamos saber cómo llamarlas.

Por supuesto, siempre es necesario que los argumentos de una llamada tengan el tipo apropiado:

>>> round('perro')
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: a float is required
>>> len(8)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: object of type 'int' has no len()
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: object of type 'int' has no len()

Error de sintaxis¶

Un error de sintaxis ocurre cuando el programa no cumple las reglas del lenguaje. Cuando ocurre este error, significa que el programa está mal escrito. El nombre del error es SyntaxError.

Los errores de sintaxis siempre ocurren antes de que el programa sea ejecutado. Es decir, un programa mal escrito no logra ejecutar ninguna instrucción. Por lo mismo, el error de sintaxis no es una excepción.

A continuación veremos algunos ejemplos de errores de sintaxis

>>> 2 * (3 + 4))
  File "<stdin>", line 1
    2 * (3 + 4))
               ^
SyntaxError: invalid syntax
  File "<stdin>", line 1
    2 * (3 + 4))
               ^
SyntaxError: invalid syntax

>>> n + 2 = 7
  File "<stdin>", line 1
SyntaxError: can't assign to operator
  File "<stdin>", line 1
SyntaxError: can't assign to operator

>>> True = 1000
  File "<stdin>", line 1
SyntaxError: assignment to keyword
  File "<stdin>", line 1
SyntaxError: assignment to keyword

Error de nombre¶

Un error de nombre ocurre al usar una variable que no ha sido creada con anterioridad.

El nombre de la excepción es NameError:

>>> x = 20
>>> 5 * x
100
>>> 5 * y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined

Para solucionar este error, es necesario asignar un valor a la variable antes de usarla.

Error de tipo¶

En general, todas las operaciones en un programa pueden ser aplicadas sobre valores de tipos bien específicos. Un error de tipo ocurre al aplicar una operación sobre operandos de tipo incorrecto.

El nombre de la excepción es TypeError.

Por ejemplo, no se puede multiplicar dos strings:

>>> 'seis' * 'ocho'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'

Tampoco se puede obtener el largo de un número:

>>> len(68)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

Cuando ocurre un error de tipo, generalmente el programa está mal diseñado. Hay que revisarlo, idealmente hacer un ruteo para entender el error, y finalmente corregirlo.

Error de valor¶

El error de valor ocurre cuando los operandos son del tipo correcto, pero la operación no tiene sentido para ese valor.

El nombre de la excepción es ValueError.

Por ejemplo, la función int puede convertir un string a un entero, pero el string debe ser la representación de un número entero. Cualquier otro valor lanza un error de valor:

>>> int('41')
41
>>> int('perro')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'perro'
>>> int('cuarenta y uno')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'cuarenta y uno'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'cuarenta y uno'

Para corregir el error, hay que preocuparse de siempre usar valores adecuados.

Error de división por cero¶

El error de division por cero ocurre al intentar dividir por cero.

El nombre de la excepción es ZeroDivisionError:

>>> 1/0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Error de desborde¶

El error de desborde ocurre cuando el resultado de una operación es tan grande que el computador no puede representarlo internamente.

El nombre de la excepción es OverflowError:

>>> 20.0 ** 20.0 ** 20.0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: (34, 'Numerical result out of range')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: (34, 'Numerical result out of range')

Para los interesados en saber más sobre excepciones, pueden revisar la sección sobre excepciones en la documentación oficial de Python.

Condicional if¶

La sentencia if («si») ejecuta las instrucciones sólo si se cumple una condición. Si la condición es falsa, no se hace nada:

La sintaxis es la siguiente:

if condición:
    sentencias

Por ejemplo, el siguente programa felicita a alguien que aprobó la asignatura:

nota = int(raw_input('Ingrese su nota: '))
if nota >= 55:
    print 'Felicitaciones'

Ejecute este programa, probando varias veces con valores diferentes.

Condicional if-else¶

La sentencia if-else («si-o-si-no») decide qué instrucciones ejecutar dependiendo si una condición es verdadera o falsa:

La sintaxis es la siguiente:

if condición:
    qué hacer cuando la condición es verdadera
else
    qué hacer cuando la condición es falsa

Por ejemplo, el siguiente programa indica a alguien si es mayor de edad:

edad = int(raw_input('Cual es su edad? '))
if edad < 18:
    print 'Usted es menor de edad'
else:
    print 'Usted es adulto'

El siguiente programa realiza acciones distintas dependiendo de si el número de entrada es par o impar:

n = int(raw_input('Ingrese un numero: '))
if n % 2 == 0:
    print 'El numero es par'
    print 'La mitad del numero es', n / 2
else:
    print 'El numero es impar'
    print 'El sucesor del numero es', n + 1
print 'Listo'

La última sentencia no está indentada, por lo que no es parte del condicional, y será ejecutada siempre.

Condicional if-elif-else¶

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

La sintaxis es la siguiente:

if condición1:
    qué hacer si condición1 es verdadera
elif condición2:
    qué hacer si condición2 es verdadera
...
else:
    qué hacer cuando ninguna de las
    condiciones anteriores es verdadera

El último else es opcional.

Por ejemplo, la tasa de impuesto a pagar por una persona según su sueldo puede estar dada por la siguiente tabla:

Entonces, el programa que calcula el impuesto a pagar es el siguiente:

sueldo = int(raw_input('Ingrese su sueldo: '))
if sueldo < 1000:
    tasa = 0.00
elif sueldo < 2000:
    tasa = 0.05
elif sueldo < 4000:
    tasa = 0.10
else:
    tasa = 0.12
print 'Usted debe pagar', tasa * sueldo, 'de impuesto'

Siempre sólo una de las alternativas será ejecutada. Apenas una de las condiciones es verdadera, el resto de ellas no siguen siendo evaluadas.

Otra manera de escribir el mismo programa usando sólo sentencias if es la siguiente:

sueldo = int(raw_input('Ingrese su sueldo: '))
if sueldo < 1000:
    tasa = 0.00
if 1000 <= sueldo < 2000:
    tasa = 0.05
if 2000 <= sueldo < 4000:
    tasa = 0.10
if 4000 < sueldo:
    tasa = 0.12
print 'Usted debe pagar', tasa * sueldo, 'de impuesto'

Esta manera es menos clara, porque no es evidente a primera vista que sólo una de las condiciones será verdadera.

Ciclo while¶

El ciclo while («mientras») ejecuta una secuencia de instrucciones mientras una condición sea verdadera:

Cada una de las veces que el cuerpo del ciclo es ejecutado se llama iteración.

La condición es evaluada antes de cada iteración. Si la condición es inicialmente falsa, el ciclo no se ejecutará ninguna vez.

La sintaxis es la siguiente:

while condición:
    sentencias

Por ejemplo, el siguiente programa multiplica dos números enteros sin usar el operador *:

m = int(raw_input())
n = int(raw_input())
p = 0
while m > 0:
    m = m - 1
    p = p + n
print 'El producto de m y n es', p

Para ver cómo funciona este programa, hagamos un ruteo con la entrada m = 4 y n = 7:

p	m	n
	4
		7
0
	3
7
	2
14
	1
21
	0
28

En cada iteración, el valor de m decrece en 1. Cuando llega a 0, la condición del while deja de ser verdadera por lo que el ciclo termina. De este modo, se consigue que el resultado sea sumar m veces el valor de n.

Note que el ciclo no termina apenas el valor de m pasa a ser cero. La condición es evaluada una vez que la iteración completa ha terminado.

En general, el ciclo while se utiliza cuando no es posible saber de antemano cuántas veces será ejecutado el ciclo, pero sí qué es lo que tiene que ocurrir para que se termine.

Ciclo for con rango¶

El ciclo for con rango ejecuta una secuencia de sentencias una cantidad fija de veces.

Para llevar la cuenta, utiliza una variable de control que toma valores distintos en cada iteración.

Una de las sintaxis para usar un for con rango es la siguiente:

for variable in range(fin):
    qué hacer para cada valor de la variable de control

En la primera iteración, la variable de control toma el valor 0. Al final de cada iteración, el valor de la variable aumenta automáticamente. El ciclo termina justo antes que la variable tome el valor fin.

Por ejemplo, el siguiente programa muestra los cubos de los números del 0 al 20:

for i in range(21):
    print i, i ** 3

Un rango es una sucesión de números enteros equiespaciados. Incluyendo la presentada más arriba, hay tres maneras de definir un rango:

range(final)
range(inicial, final)
range(inicial, final, incremento)

El valor inicial siempre es parte del rango. El valor final nunca es parte del rango. El incremento indica la diferencia entre dos valores consecutivos del rango.

Si el valor inicial es omitido, se supone que es 0. Si el incremento es omitido, se supone que es 1.

Con algunos ejemplos quedará más claro:

Usando un incremento negativo, es posible hacer ciclos que van hacia atrás:

for i in range(10, 0, -1):
    print i
print 'Feliz anno nuevo!'

En general, el ciclo for con rango se usa cuando el número de iteraciones es conocido antes de entrar al ciclo.

Salir de un ciclo¶

Además de las condiciones de término propias de los ciclos while y for, siempre es posible salir de un ciclo en medio de una iteración usando la sentencia break. Lo lógico es que sea usada dentro de un if, para evitar que el ciclo termine prematuramente en la primera iteración:

Por ejemplo, en el programa para determinar si un número es primo o no, la búsqueda de divisores puede ser terminada prematuramente apenas se encuentra el primero de ellos:

es_primo = True
for d in range(2, n):
    if n % d == 0:
        es_primo = False
        break

Saltar a la siguiente iteración¶

La sentencia continue se usa para saltar a la iteración siguiente sin llegar al final de la que está en curso.

Por ejemplo, el siguiente programa muestra el seno, el coseno y la tangente de los números del 1 al 30, pero omitiendo los que terminan en 7:

from math import sin, cos, tan
for i in range(1, 31):
    if i % 10 == 7:
        continue
    print i, sin(i), cos(i), tan(i)

Sumar y multiplicar cosas¶

La suma y la multiplicación son operaciones binarias: operan sobre dos valores.

Para sumar y multiplicar más valores, generalmente dentro de un ciclo que los vaya generando, hay que usar una variable para ir guardando el resultado parcial de la operación. Esta variable se llama acumulador.

En el caso de la suma, el acumulador debe partir con el valor cero. Para la multiplicación, con el valor uno. En general, el acumulador debe ser inicializado con el elemento neutro de la operación que será aplicada.

Por ejemplo, el siguiente programa entrega el producto de los mil primeros números naturales:

producto = 1
for i in range(1, 1001):
    producto = producto * i

print producto

El siguiente programa entrega la suma de los cubos de los números naturales cuyo cuadrado es menor que mil:

i = 1
suma = 0
while i ** 2 < 1000:
    valor = i ** 3
    i = i + 1
    suma = suma + valor

print suma

En todos los casos, el patrón a seguir es algo como esto:

acumulador = valor_inicial
ciclo:
    valor = ...
    ...
    acumulador = acumulador operación valor

El cómo adaptar esta plantilla a cada situación de modo que entregue el resultado correcto es responsabilidad del programador.

Contar cosas¶

Para contar cuántas veces ocurre algo, hay que usar un acumulador, al que se le suele llamar contador.

Tal como en el caso de la suma, debe ser inicializado en cero, y cada vez que aparezca lo que queremos contar, hay que incrementarlo en uno.

Por ejemplo, el siguiente programa cuenta cuántos de los números naturales menores que mil tienen un cubo terminado en siete:

c = 0
for i in range(1000):
    ultimo_digito = (i ** 3) % 10
    if ultimo_digito == 7:
        c = c + 1

print c

Encontrar el mínimo y el máximo¶

Para encontrar el máximo de una secuencia de valores, hay que usar un acumulador para recordar cuál es el mayor valor visto hasta el momento. En cada iteración, hay que examinar cuál es el valor actual, y si es mayor que el máximo, actualizar el acumulador.

El acumulador debe ser inicializado con un valor que sea menor a todos los valores que vayan a ser examinados.

Por ejemplo, el siguiente programa pide al usuario que ingrese diez números enteros positivos, e indica cuál es el mayor de ellos:

print 'Ingrese diez numeros positivos'

mayor = -1
for i in range(10):
    n = int(raw_input())
    if n > mayor:
        mayor = n

print 'El mayor es', mayor

Otra manera de hacerlo es reemplazando esta parte:

if n > mayor:
    mayor = n

por ésta:

mayor = max(mayor, n)

En este caso, como todos los números ingresados son positivos, inicializamos el acumulador en -1, que es menor que todos los valores posibles, por lo que el que sea el mayor eventualmente lo reemplazará.

¿Qué hacer cuando no exista un valor inicial que sea menor a todas las entradas posibles? Una solución es poner un número «muy negativo», y rezar para que el usuario no ingrese uno menor que él. Esta no es la mejor solución, ya que no cubre todos los casos posibles:

mayor = -999999999
for i in range(10):
    n = int(raw_input())
    mayor = max(mayor, n)

Una opción más robusta es usar el primero de los valores por examinar:

mayor = int(raw_input())   # preguntar el primer valor
for i in range(9):         # preguntar los nueve siguientes
    n = int(raw_input())
    mayor = max(mayor, n)

La otra buena solución es usar explícitamente el valor \(-\infty\), que en Python puede representarse usando el tipo float de la siguiente manera:

mayor = -float('inf')     # asi se dice "infinito" en Python
for i in range(10):
    n = int(raw_input())
    mayor = max(mayor, n)

Si sabemos de antemano que todos los números por revisar son positivos, podemos simplemente inicializar el acumulador en -1.

Por supuesto, para obtener el menor valor se hace de la misma manera, pero inicializando el acumulador con un número muy grande, y actualizándolo al encontrar un valor menor.

Generar pares¶

Para generar pares de cosas en un programa, es necesario usar dos ciclos anidados (es decir, uno dentro del otro).

Ambos ciclos, el exterior y el interior, van asignando valores a sus variables de control, y ambas son accesibles desde dentro del doble ciclo.

Por ejemplo, todas las casillas de un tablero de ajedrez pueden ser identificadas mediante un par (fila, columna). Para recorrer todas las casillas del tablero, se puede hacer de la siguiente manera:

for i in range(1, 9):
    for i in range(1, 9):
        print 'Casilla', i, j

Cuando los pares son desordenados (es decir, el par \((a, b)\) es el mismo que el par \((b, a)\)), el ciclo interior no debe partir desde cero, sino desde el valor que tiene la variable de control del ciclo interior.

Por ejemplo, el siguiente programa muestra todas las piezas de un juego de dominó:

for i in range(7):
    for j in range(i, 7):
        print i, j

Además, otros tipos de restricciones pueden ser necesarias. Por ejemplo, en un campeonato de fútbol, todos los equipos deben jugar entre ellos dos veces, una como local y una como visita. Por supuesto, no pueden jugar consigo mismos, por lo que es necesario excluir los pares compuestos por dos valores iguales. El siguiente programa muestra todos los partidos que se deben jugar en un campeonato con 6 equipos, suponiendo que los equipos están numerados del 0 al 5:

for i in range(6):
    for j in range(6):
        if i != j:
            print i, j

Otra manera de escribir el mismo código es:

for i in range(6):
    for j in range(6):
        if i == j:
            continue
        print i, j

Funciones¶

En programación, una función es una sección de un programa que calcula un valor de manera independiente al resto del programa.

Una función tiene tres componentes importantes:

• los parámetros, que son los valores que recibe la función como entrada;
• el código de la función, que son las operaciones que hace la función; y
• el resultado (o valor de retorno), que es el valor final que entrega la función.

En esencia, una función es un mini programa. Sus tres componentes son análogos a la entrada, el proceso y la salida de un programa.

En el ejemplo del factorial, el parámetro es el entero al que queremos calcularle el factorial, el código es el ciclo que hace las multiplicaciones, y el resultado es el valor calculado.

def nombre(parámetros):
    # código de la función

def factorial(n):
    f = 1
    for i in range(1, n + 1):
        f *= i
    return f

>>> factorial(0)
1
>>> factorial(12) + factorial(10)
482630400
>>> factorial(factorial(3))
720
>>> n = 3
>>> factorial(n ** 2)
362880

>>> factorial(5)
120
>>> f
Traceback (most recent call last):
  File "<console>", line 1, in <module>
NameError: name 'f' is not defined
Traceback (most recent call last):
  File "<console>", line 1, in <module>
NameError: name 'f' is not defined

def comb(m, n):
    fact_m = factorial(m)
    fact_n = factorial(n)
    fact_m_n = factorial(m - n)
    c = fact_m / (fact_n * fact_m_n)
    return c

def comb(m, n):
    return factorial(m) / (factorial(n) * factorial(m - n))

def factorial(n):
    p = 1
    for i in range(1, n + 1):
        p *= i
    return p


def comb(m, n):
    return factorial(m) / (factorial(n) * factorial(m - n))


m = int(raw_input('Ingrese m: '))
n = int(raw_input('Ingrese n: '))
c = comb(m, n)
print '(m n) =', c

Múltiples valores de retorno¶

En Python, una función puede retornar más de un valor.

Por ejemplo, la siguiente función recibe una cantidad de segundos, y retorna el equivalente en horas, minutos y segundos:

def convertir_segundos(segundos):
    horas = segundos / (60 * 60)
    minutos = (segundos / 60) % 60
    segundos = segundos % 60
    return horas, minutos, segundos

Al llamar la función, se puede asignar un nombre a cada uno de los valores retornados:

>>> h, m, s = convertir_segundos(9814)
>>> h
2
>>> m
43
>>> s
34

Técnicamente, la función está retornando una tupla de valores, un tipo de datos que veremos más adelante:

>>> convertir_segundos(9814)
(2, 43, 34)

Funciones que no retornan nada¶

Una función puede realizar acciones sin entregar necesariamente un resultado.

Por ejemplo, si un programa necesita imprimir cierta información muchas veces, conviene encapsular esta acción en una función que haga los print

def imprimir_datos(nombre, apellido, rol, dia, mes, anno):
    print 'Nombre completo:', nombre, apellido
    print 'Rol:', rol
    print 'Fecha de nacimiento:', dia, '/', mes, '/', anno

imprimir_datos('Perico', 'Los Palotes', '201101001-1',  3, 1, 1993)
imprimir_datos('Yayita', 'Vinagre',     '201101002-2', 10, 9, 1992)
imprimir_datos('Fulano', 'De Tal',      '201101003-3', 14, 5, 1990)

En este caso, cada llamada a la función imprimir_datos muestra los datos en la pantalla, pero no entrega un resultado. Este tipo de funciones son conocidas en programación como procedimientos o subrutinas, pero en Python son funciones como cualquier otra.

Técnicamente, todas las funciones retornan valores. En el caso de las funciones que no tienen una sentencia return, el valor de retorno siempre es None. Pero como la llamada a la función no aparece en una asignación, el valor se pierde, y no tiene ningún efecto en el programa.

Módulos presentes en Python¶

Éstos son algunos de los módulos estándares de Python, que pueden ser usado desde cualquier programa.

El módulo math contiene funciones y constantes matemáticas:

>>> from math import floor, radians
>>> floor(-5.9)
-6.0
>>> radians(180)
3.1415926535897931

El módulo random contiene funciones para producir números aleatorios (es decir, al azar):

>>> from random import choice, randrange,
>>> choice(['cara', 'sello'])
'cara'
>>> choice(['cara', 'sello'])
'sello'
>>> choice(['cara', 'sello'])
'sello'
>>> randrange(10)
7
>>> randrange(10)
2
>>> randrange(10)
5
>>> r = range(5)
>>> r
[0, 1, 2, 3, 4]
>>> shuffle(r)
>>> r
[4, 2, 0, 3, 1]

El módulo datetime provee tipos de datos para manipular fechas y horas:

>>> from datetime import date
>>> hoy = date(2011, 5, 31)
>>> fin_del_mundo = date(2012, 12, 21)
>>> (fin_del_mundo - hoy).days
570

El módulo fractions provee un tipo de datos para representar números racionales:

>>> from fractions import Fraction
>>> a = Fraction(5, 12)
>>> b = Fraction(9, 7)
>>> a + b
Fraction(143, 84)

El módulo turtle permite manejar una tortuga (¡haga la prueba!):

>>> from turtle import Turtle
>>> t = Turtle()
>>> t.forward(10)
>>> t.left(45)
>>> t.forward(20)
>>> t.left(45)
>>> t.forward(30)
>>> for i in range(10):
... t.right(30)
... t.forward(10 * i)
...
>>>

La lista completa de módulos de Python puede ser encontrada en la documentación de la biblioteca estándar.

Importación de nombres¶

La sentencia import importa objetos desde un módulo para poder ser usados en el programa actual.

Una manera de usar import es importar sólo los nombres específicos que uno desea utilizar en el programa:

from math import sin, cos
print sin(10)
print cos(20)

En este caso, las funciones sin y cos no fueron creadas por nosotros, sino importadas del módulo de matemáticas, donde están definidas.

La otra manera de usar import es importando el módulo completo, y accediendo a sus objetos mediante un punto:

import math
print math.sin(10)
print math.cos(10)

Las dos formas son equivalentes. Como siempre, hay que optar por la que hace que el programa sea más fácil de entender.

Creación de módulos¶

Un módulo sencillo es simplemente un archivo con código en Python. El nombre del archivo indica cuál es el nombre del módulo.

Por ejemplo, podemos crear un archivo llamado pares.py que tenga funciones relacionadas con los números pares:

def es_par(n):
    return n % 2 == 0

def es_impar(n):
    return not es_par(n)

def pares_hasta(n):
    return range(0, n, 2)

En este caso, el nombre del módulo es pares. Para poder usar estas funciones desde otro programa, el archivo pares.py debe estar en la misma carpeta que el programa.

Por ejemplo, el programa mostrar_pares.py puede ser escrito así:

from pares import pares_hasta

n = int(raw_input('Ingrese un entero: '))
print 'Los numeros pares hasta', n, 'son:'
for i in pares_hasta(n):
    print i

Y el programa ver_si_es_par.py puede ser escrito así:

import pares

n = int(raw_input('Ingrese un entero: '))
if pares.es_par(n):
    print n, 'es par'
else:
    print n, 'no es par'

Como se puede ver, ambos programas pueden usar los objetos definidos en el módulo simplemente importándolos.

Usar módulos como programas¶

Un archivo con extensión .py puede ser un módulo o un programa. Si es un módulo, contiene definiciones que pueden ser importadas desde un programa o desde otro módulo. Si es un programa, contiene código para ser ejecutado.

A veces, un programa también contiene definiciones (por ejemplo, funciones y variables) que también pueden ser útiles desde otro programa. Sin embargo, no pueden ser importadas, ya que al usar la sentencia import el programa completo sería ejecutado. Lo que ocurriría en este caso es que, al ejecutar el segundo programa, también se ejecutaría el primero.

Existe un truco para evitar este problema: siempre que hay código siendo ejecutado, existe una variable llamada __name__. Cuando se trata de un programa, el valor de esta variable es '__main__', mientras que en un módulo, es el nombre del módulo.

Por lo tanto, se puede usar el valor de esta variable para marcar la parte del programa que debe ser ejecutada al ejecutar el archivo, pero no al importarlo.

Por ejemplo, el siguiente programa convierte unidades de medidas de longitud:

km_por_milla = 1.609344
cm_por_pulgada = 2.54

def millas_a_km(mi):
    return mi * km_por_milla

def km_a_millas(km):
    return km / km_por_milla

def pulgadas_a_cm(p):
    return p * cm_por_pulgada

def cm_a_pulgadas(cm):
    return cm / cm_por_pulgada

if __name__ == '__main__':
    print 'Que conversion desea hacer?'
    print '1) millas a kilometros'
    print '2) kilometros a millas'
    print '3) pulgadas a centimetros'
    print '4) centimetros a pulgadas'
    opcion = int(raw_input('> '))

    if opcion == 1:
        x = float(raw_input('Ingrese millas: '))
        print x, 'millas =', millas_a_km(x), 'km'
    elif opcion == 2:
        x = float(raw_input('Ingrese kilometros: '))
        print x, 'km =', km_a_millas(x), 'millas'
    elif opcion == 3:
        x = float(raw_input('Ingrese pulgadas: '))
        print x, 'in =', pulgadas_a_cm(x), 'cm'
    elif opcion == 4:
        x = float(raw_input('Ingrese centimetros: '))
        print x, 'cm =', cm_a_pulgadas(x), 'in'
    else:
        print 'Opcion incorrecta'

Este programa es útil por sí solo, pero además sus cuatro funciones y las constantes km_por_milla y cm_por_pulgada podrían ser útiles para ser usadas en otro programa.

Al poner el cuerpo del programa dentro del if __name__ == '__main__', el archivo puede ser usado como un módulo. Si no hiciéramos esto, cada vez que otro programa importe una función se ejecutaría el programa completo.

Haga la prueba: descargue el programa y ejecútelo. Luego, escriba otro programa que importe alguna de las funciones. A continuación, haga lo mismo, pero eliminando el if.

Cómo crear listas¶

Las dos maneras principales de crear una lista son:

• usar una lista literal, con los valores entre corchetes:

  >>> primos = [2, 3, 5, 7, 11]
  >>> primos
  [2, 3, 5, 7, 11]
  >>> []
  []
  >>> [1.0 + 2.0, 3.0 + 4.0 + 5.0]
  [3.0, 12.0]
  >>> ['hola ' + 'mundo', 24 * 7, True or False]
  ['hola mundo', 168, True]
  

• usar la función list aplicada sobre un iterable:

  >>> list('hola')
  ['h', 'o', 'l', 'a']
  >>> list(range(10))
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> list()
  []
  

Operaciones sobre listas¶

len(l) entrega el largo de la lista; es decir, cuántos elementos tiene:

>>> colores = ['azul', 'rojo', 'verde', 'amarillo']
>>> len(colores)
4
>>> len([True, True, True])
3
>>> len([])
0

l[i] entrega el i-ésimo valor de la lista. El valor i se llama índice del valor. Al igual que para los strings, los índices parten de cero:

>>> colores = ['azul', 'rojo', 'verde', 'amarillo']
>>> colores[0]
'azul'
>>> colores[3]
'amarillo'

Además, es posible modificar el valor del i-ésimo elemento:

>>> colores[1] = 'negro'
>>> colores
['azul', 'negro', 'verde', 'amarillo']

Si el índice i indica un elemento que no está en la lista, ocurre un error de índice:

>>> colores[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Si el índice es negativo, los elementos se cuentan desde el final hacia atrás:

>>> colores[-1]
'amarillo'
>>> colores[-4]
'azul'

l.append(x) agrega el elemento x al final de la lista:

>>> primos = [2, 3, 5, 7, 11]
>>> primos.append(13)
>>> primos.append(17)
>>> primos
[2, 3, 5, 7, 11, 13, 17]

Un comentario al margen: append es un método. Los métodos son funciones que están dentro de un objeto. Cada lista tiene su propia función append. Es importante tener esta distinción clara, ya que hay operaciones que están implementadas como funciones y otras como métodos.

sum(x) entrega la suma de los valores de la lista:

>>> sum([1, 2, 1, -1, -2])
1
>>> sum([])
0

l1 + l2 concatena las listas l1 y l2:

>>> list('perro') + [2, 3, 4]
['p', 'e', 'r', 'r', 'o', 2, 3, 4]

l * n repite n veces la lista l:

>>> [3.14, 6.28, 9.42] * 2
[3.14, 6.28, 9.42, 3.14, 6.28, 9.42]
>>> [3.14, 6.28, 9.42] * 0
[]

Para saber si un elemento x está en la lista l, se usa x in l. La versión negativa de in es not in:

>>> r = range(0, 20, 2)
>>> r
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> 12 in r
True
>>> 15 in r
False
>>> 15 not in r
True

l[i:j] es el operador de rebanado, que entrega una nueva lista que tiene desde el i-ésimo hasta justo antes del j-ésimo elemento de la lista l:

>>> x = [1.5, 3.3, 8.4, 3.1, 2.9]
>>> x[2:4]
[8.4, 3.1]

l.count(x) cuenta cuántas veces está el elemento x en la lista:

>>> letras = list('paralelepipedo')
>>> letras.count('p')
3

l.index(x) entrega cuál es el índice del valor x:

>>> colores = ['azul', 'rojo', 'verde', 'amarillo']
>>> colores.index('verde')
2
>>> colores.index('fucsia')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'fucsia' is not in list
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'fucsia' is not in list

l.remove(x) elimina el elemento x de la lista:

>>> l = [7, 0, 3, 9, 8, 2, 4]
>>> l.remove(2)
>>> l
[7, 0, 3, 9, 8, 4]

del l[i] elimina el i-ésimo elemento de la lista:

>>> l = [7, 0, 3, 9, 8, 2, 4]
>>> del l[2]
>>> l
[7, 0, 9, 8, 2, 4]

l.reverse() invierte la lista:

>>> l = [7, 0, 3, 9, 8, 2, 4]
>>> l.reverse()
>>> l
[4, 2, 8, 9, 3, 0, 7]

l.sort() ordena la lista:

>>> l = [7, 0, 3, 9, 8, 2, 4]
>>> l.sort()
>>> l
[0, 2, 3, 4, 7, 8, 9]

Para todas estas operaciones, siempre hay que tener muy claro si la lista es modificada o no. Por ejemplo, el rebanado no modifica la lista, sino que crea una nueva:

>>> ramos = ['Progra', 'Mate', 'Fisica', 'Ed.Fisica']
>>> ramos[:2]
['Progra', 'Mate']
>>> len(ramos)    # la lista sigue teniendo cuatro elementos
4

Iteración sobre una lista¶

Una lista es un objeto iterable. Esto significa que sus valores se pueden recorrer usando un ciclo for:

valores = [6, 1, 7, 8, 9]
for i in valores:
    print i ** 2

En cada iteración del for, la variable i toma uno de los valores de la lista, por lo que este programa imprime los siguientes valores:

36
1
49
64
81

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 (en inglés: unpack):

>>> nombre, apellido = persona
>>> nombre
'Perico'

Si se intenta desempaquetar una cantidad incorrecta de valores, ocurre un error de valor:

>>> a, b, c = persona
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack

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

>>> persona[1]
'Los Palotes'

A diferencia de las listas, los elementos no se pueden modificar:

>>> persona[1] = 'Smith'
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

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
>>> (6, 1) == (6, 1, 0)
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 compació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.

Este método de comparación es el mismo que se utiliza para poner palabras en orden alfabético (por ejemplo, en guías telefónicas y diccionarios):

>>> 'auto' < 'auxilio'
True
>>> 'auto' < 'autos'
True
>>> 'mes' < 'mesa' < 'mesadas' < 'mesas' < 'meses' < 'mi'
True

Usos típicos de las tuplas¶

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. Por ejemplo, un partido de fútbol se puede representar como una tupla de los equipos que lo juegan:

partido1 = ('Milan', 'Bayern')

Para representar puntos en el plano, se puede usar tuplas de dos elementos (x, y). Por ejemplo, podemos crear una función distancia que recibe dos puntos y entrega la distancia entre ellos:

def distancia(p1, p2):
    x1, y1 = p1
    x2, y2 = p2
    dx = x2 - x1
    dy = y2 - y1
    return (dx ** 2 + dy ** 2) ** 0.5

Al llamar a la función, se le debe pasar dos tuplas:

>>> a = (2, 3)
>>> b = (7, 15)
>>> distancia(a, b)
13.0

Las fechas generalmente se representan como tuplas agrupando el año, el mes y el día. La ventaja de hacerlo en este orden (el año primero) es que las operaciones relacionales permiten saber en qué orden ocurrieron las fechas:

>>> hoy = (2011, 4, 19)
>>> ayer = (2011, 4, 18)
>>> navidad = (2011, 12, 25)
>>> anno_nuevo = (2012, 1, 1)
>>> hoy < ayer
False
>>> hoy < navidad < anno_nuevo
True

Una tupla puede contener otras tuplas. Por ejemplo, una persona puede ser descrita por su nombre, su rut y su fecha de nacimiento:

persona = ('Perico Los Palotes', '12345678-9', (1980, 5, 14))

En este caso, los datos se pueden desempaquetar así:

>>> nombre, rut, (a, m, d) = persona
>>> m
5

A veces a uno le interesa sólo uno de los valores de la tupla. Para evitar crear variables innecesarias, se suele asignar estos valores a la variable _. Por ejemplo, si sólo nos interesa el mes en que nació la persona, podemos obtenerlo así:

>>> _, _, (_, mes, _) = persona
>>> mes
5

Una tabla de datos generalmente se representa como una lista de tuplas. Por ejemplo, la información de los alumnos que están tomando un ramo puede ser representada así:

alumnos = [
    ('Perico', 'Los Palotes', '201199001-5', 'Civil'),
    ('Fulano', 'De Tal',      '201199002-6', 'Electrica'),
    ('Fulano', 'De Tal',      '201199003-7', 'Mecanica'),
]

En este caso, se puede desempaquetar los valores automáticamente al recorrer la lista en un ciclo for:

for nombre, apellido, rol, carrera in alumnos:
    print nombre, 'estudia', carrera

O, ya que el apellido y el rol no son usados:

for nombre, _, _, carrera in alumnos:
    print nombre, 'estudia', carrera

Es posible crear tuplas de largo uno dejando una coma a continuación del único valor:

>>> t = (12,)
>>> len(t)
1

En otros lenguajes, las tuplas reciben el nombre de registros. Este nombre es común, por lo que conviene conocerlo.

Iteración sobre tuplas¶

Al igual que las listas, las tuplas son iterables:

for valor in (6, 1):
    print valor ** 2

Además, se puede convertir una tupla en una lista usando la función list, y una lista en una tupla usando la función tuple:

>>> a = (1, 2, 3)
>>> b = [4, 5, 6]
>>> list(a)
[1, 2, 3]
>>> tuple(b)
(4, 5, 6)

Cómo crear diccionarios¶

Los diccionarios literales se crean usando llaves ({ y }). La llave y el valor van separados por dos puntos:

>>> telefonos = {'Pepito': 5552437, 'Jaimito': 5551428, 'Yayita': 5550012}

En este ejemplo, las llaves son 'Pepito', 'Jaimito' y 'Yayita', y los valores asociados a ellas son, respectivamente, 5552437, 5551428 y 5550012.

Un diccionario vacío puede ser creado usando {} o con la función dict():

>>> d = {}
>>> d = dict()

Cómo usar un diccionario¶

El valor asociado a la llave k en el diccionario d se puede obtener mediante d[k]:

>>> telefonos['Pepito']
5552437
>>> telefonos['Jaimito']
5551428

A diferencia de los índices de las listas, las llaves de los diccionarios no necesitan ser números enteros.

Si la llave no está presente en el diccionario, ocurre un error de llave (KeyError):

>>> telefonos['Fulanito']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Fulanito'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Fulanito'

Se puede agregar una llave nueva simplemente asignándole un valor:

>>> telefonos['Susanita'] = 4448139
>>> telefonos
{'Pepito': 5552437, 'Susanita': 4448139, 'Jaimito': 5551428, 'Yayita': 5550012}

Note que el orden en que quedan las llaves en el diccionario no es necesariamente el mismo orden en que fueron agregadas.

Si se asigna un valor a una llave que ya estaba en el diccionario, el valor anterior se sobreescribe. Recuerde que un diccionario no puede tener llaves repetidas:

>>> telefonos
{'Pepito': 5552437, 'Susanita': 4448139, 'Jaimito': 5551428, 'Yayita': 5550012}
>>> telefonos['Jaimito'] = 4448139
>>> telefonos
{'Pepito': 5552437, 'Susanita': 4448139, 'Jaimito': 4448139, 'Yayita': 5550012}

Los valores sí pueden estar repetidos. En el ejemplo anterior, Jaimito y Susanita tienen el mismo número.

Para borrar una llave, se puede usar la sentencia del:

>>> del telefonos['Yayita']
>>> telefonos
{'Pepito': 5552437, 'Susanita': 4448139, 'Jaimito': 4448139}

Los diccionarios son iterables. Al iterar sobre un diccionario en un ciclo for, se obtiene las llaves:

>>> for k in telefonos:
...     print k
...
Pepito
Susanita
Jaimito

Para iterar sobre las llaves, se usa d.values():

>>> for v in telefonos.values():
...     print v
...
5552437
4448139
4448139

Para iterar sobre las llaves y los valores simultáneamente, se usa el método d.items():

>>> for k, v in telefonos.items():
...     print 'El telefono de', k, 'es', v
...
El telefono de Pepito es 5552437
El telefono de Susanita es 4448139
El telefono de Jaimito es 4448139

También es posible crear listas de llaves o valores:

>>> list(telefonos)
['Pepito', 'Susanita', 'Jaimito']
>>> list(telefonos.values())
[5552437, 4448139, 4448139]

len(d) entrega cuántos pares llave-valor hay en el diccionario:

>>> numeros = {15: 'quince', 24: 'veinticuatro'}
>>> len(numeros)
2
>>> len({})
0

k in d permite saber si la llave k está en el diccionario d:

>>> patas = {'gato': 4, 'humano': 2, 'pulpo': 8, 'perro': 4, 'ciempies': 100}
>>> 'perro' in patas
True
>>> 'gusano' in patas
False

Para saber si una llave no está en el diccionario, se usa el operador not in:

>>> 'gusano' not in patas
True

Restricciones sobre las llaves¶

No se puede usar cualquier objeto como llave de un diccionario. Las llaves deben ser de un tipo de datos inmutable. Por ejemplo, no se puede usar listas:

>>> d = {[1, 2, 3]: 'hola'}
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: unhashable type: 'list'
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: unhashable type: 'list'

Típicamente, se usa números, tuplas y strings como llaves de los diccionarios.

Cómo crear conjuntos¶

Las dos maneras principales de crear un conjunto son:

• usar un conjunto literal, entre llaves:

  >>> colores = {'azul', 'rojo', 'blanco', 'blanco'}
  >>> colores
  {'rojo', 'azul', 'blanco'}
  

  Note que el conjunto no incluye elementos repetidos, y que los elementos no quedan en el mismo orden en que fueron agregados.

• usar la función set aplicada sobre un iterable:

  >>> set('abracadabra')
  {'a', 'r', 'b', 'c', 'd'}
  >>> set(range(50, 2000, 400))
  {1250, 50, 1650, 850, 450}
  >>> set([(1, 2, 3), (4, 5), (6, 7, 8, 9)])
  {(4, 5), (6, 7, 8, 9), (1, 2, 3)}
  

  El conjunto vacío debe ser creado usando set(), ya que {} representa el diccionario vacío.

Los elementos de un conjunto deben ser inmutables. Por ejemplo, no es posible crear un conjunto de listas, pero sí un conjunto de tuplas:

>>> s = {[2, 4], [6, 1]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> s = {(2, 4), (6, 1)}
>>>
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Como un conjunto no es ordenado, no tiene sentido intentar obtener un elemento usando un índice:

>>> s = {'a', 'b', 'c'}
>>> s[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

Sin embargo, sí es posible iterar sobre un conjunto usando un ciclo for:

>>> for i in {'a', 'b', 'c'}:
...     print i
...
a
c
b

Operaciones sobre conjuntos¶

len(s) entrega el número de elementos del conjunto s:

>>> len({'azul', 'verde', 'rojo'})
3
>>> len(set('abracadabra'))
5
>>> len(set())
0

x in s permite saber si el elemento x está en el conjunto s:

>>> 3 in {2, 3, 4}
True
>>> 5 in {2, 3, 4}
False

x not in s permite saber si x no está en s:

>>> 10 not in {2, 3, 4}
True

s.add(x) agrega el elemento x al conjunto s:

>>> s = {6, 1, 5, 4, 3}
>>> s.add(-37)
>>> s
{1, 3, 4, 5, 6, -37}
>>> s.add(4)
>>> s
{1, 3, 4, 5, 6, -37}

s.remove(x) elimina el elemento x del conjunto s:

>>> s = {6, 1, 5, 4, 3}
>>> s.remove(1)
>>> s
{3, 4, 5, 6}

Si el elemento x no está en el conjunto, ocurre un error de llave:

>>> s.remove(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 10

& y | son, respectivamente, los operadores de intersección y unión:

>>> a = {1, 2, 3, 4}
>>> b = {2, 4, 6, 8}
>>> a & b
{2, 4}
>>> a | b
{1, 2, 3, 4, 6, 8}

s - t entrega la diferencia entre s y t; es decir, los elementos de s que no están en t:

>>> a - b
{1, 3}

s ^ t entrega la diferencia simétrica entre s y t; es decir, los elementos que están en s o en t, pero no en ambos:

>>> a ^ b
{1, 3, 6, 8}

El operador < aplicado sobre conjuntos significa «es subconjunto de»:

>>> {1, 2} < {1, 2, 3}
True
>>> {1, 4} < {1, 2, 3}
False

s <= t también indica si s es subconjunto de t. La distinción ocurre cuando los conjuntos son iguales:

>>> {1, 2, 3} < {1, 2, 3}
False
>>> {1, 2, 3} <= {1, 2, 3}
True

Saltos de línea¶

Un string puede contener caracteres de salto de línea, que tienen el efecto equivalente al de presionar la tecla Enter. El caracter de salto de línea se representa con \n:

>>> a = 'piano\nviolin\noboe'
>>> print a
piano
violin
oboe

Los saltos de línea sólo son visibles al imprimir el string mediante la sentencia print. Si uno quiere ver el valor del string en la consola, el salto de línea aparecerá representado como \n:

>>> a
'piano\nviolin\noboe'
>>> print a
piano
violin
oboe

Aunque dentro del string se representa como una secuencia de dos símbolos, el salto de línea es un único caracter:

>>> len('a\nb')
3

En general, hay varios caracteres especiales que se representan comenzando con una barra invertida (\) seguida de una letra. Experimente, y determine qué significan los caracteres especiales \t y \b:

print 'abcde\tefg\thi\tjklm'
print 'abcde\befg\bhi\bjklm'

Para incluir una barra invertida dentro de un string, hay que hacerlo con \\:

>>> print 'c:\\>'
c:\>
>>> print '\\o/  o\n |  /|\\\n/ \\ / \\'
\o/  o
 |  /|\
/ \ / \

Reemplazar secciones del string¶

El método s.replace(antes, despues) busca en el string s todas las apariciones del texto antes y las reemplaza por despues:

>>> 'La mar astaba sarana'.replace('a', 'e')
'Le mer estebe serene'
>>> 'La mar astaba sarana'.replace('a', 'i')
'Li mir istibi sirini'
>>> 'La mar astaba sarana'.replace('a', 'o')
'Lo mor ostobo sorono'

Hay que tener siempre muy claro que esta operación no modifica el string, sino que retorna uno nuevo:

>>> orden = 'Quiero arroz con pollo'
>>> orden.replace('arroz', 'pure').replace('pollo', 'huevo')
'Quiero pure con huevo'
>>> orden
'Quiero arroz con pollo'

Separar y juntar strings¶

s.split() separa el strings en varios strings, usando los espacios en blanco como separador. El valor retornado es una lista de strings:

>>> oracion = 'El veloz murcielago hindu  comia feliz  cardillo y kiwi'
>>> oracion.split()
['El', 'veloz', 'murcielago', 'hindu', 'comia', 'feliz', 'cardillo', 'y', 'kiwi']

Además, es posible pasar un parámetro al método split que indica cuál será el separador a usar (en vez de los espacios en blanco):

>>> s = 'Ana lavaba las sabanas'
>>> s.split()
['Ana', 'lavaba', 'las', 'sabanas']
>>> s.split('a')
['An', ' l', 'v', 'b', ' l', 's s', 'b', 'n', 's']
>>> s.split('l')
['Ana ', 'avaba ', 'as sabanas']
>>> s.split('aba')
['Ana lav', ' las s', 'nas']

Esto es muy útil para pedir al usuario que ingrese datos en un programa de una manera más conveniente, y no uno por uno. Por ejemplo, antes hacíamos programas que funcionaban así:

Ingrese a: `2.3`
Ingrese b: `1.9`
Ingrese c: `2.3`
El triangulo es isoceles.

Ahora podemos hacerlos así:

Ingrese lados del triangulo: `2.3 1.9 2.3`
El triangulo es isoceles.

En este caso, el código del programa podría ser:

entrada = raw_input('Ingrese lados del triangulo: ')
lados = entrada.split()
a = int(lados[0])
b = int(lados[1])
c = int(lados[2])
print 'El triangulo es', tipo_triangulo(a, b, c)

O usando la función map, más simplemente:

entrada = raw_input('Ingrese lados del triangulo: ')
a, b, c = map(int, entrada.split())
print 'El triangulo es', tipo_triangulo(a, b, c)

s.join(lista_de_strings) une todos los strings de la lista, usando al string s como «pegamento»:

>>> valores = map(str, range(10))
>>> pegamento = ' '
>>> pegamento.join(valores)
'0 1 2 3 4 5 6 7 8 9'
>>> ''.join(valores)
'0123456789'
>>> ','.join(valores)
'0,1,2,3,4,5,6,7,8,9'
>>> ' --> '.join(valores)
'0 --> 1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> 8 --> 9'

Mayúsculas y minúsculas¶

s.isupper() y s.islower() indican si el string está, respectivamente, en mayúsculas o minúsculas:

>>> s = 'hola'
>>> t = 'Hola'
>>> u = 'HOLA'
>>> s.isupper(), s.islower()
(False, True)
>>> t.isupper(), t.islower()
(False, False)
>>> u.isupper(), u.islower()
(True, False)

s.upper() y s.lower() entregan el string s convertido, respectivamente, a mayúsculas y minúsculas:

>>> t
'Hola'
>>> t.upper()
'HOLA'
>>> t.lower()
'hola'

s.swapcase() cambia las minúsculas a mayúsculas, respectivamente, a mayúsculas y minúsculas:

>>> t.swapcase()
'hOLA'

Lamentablemente, ninguno de estos métodos funcionan con acentos y eñes:

>>> print 'ñandú'.upper()
ñANDú

Revisar contenidos del string¶

s.startswith(t) y s.endswith(t) indican si el string s comienza y termina, respectivamente, con el string t:

>>> objeto = 'paraguas'
>>> objeto.startswith('para')
True
>>> objeto.endswith('aguas')
True
>>> objeto.endswith('x')
False
>>> objeto.endswith('guaguas')
False

Nuestro conocido operador in indica si un string está contenido dentro de otro:

>>> 'pollo' in 'repollos'
True
>>> 'pollo' in 'gallinero'
False

Alineación de strings¶

Los métodos s.ljust(n), s.rjust(n) y s.center(n) rellenan el string con espacios para que su largo sea igual a n, de modo que el contenido quede alineado, respectivamente, a la izquierda, a la derecha y al centro:

>>> contenido.ljust(20)
'hola                '
>>> contenido.center(20)
'        hola        '
>>> contenido.rjust(20)
'                hola'

Estos métodos son útiles para imprimir tablas bien alineadas:

datos = [
    ('Pepito', (1991, 12, 5), 'Osorno', '***'),
    ('Yayita', (1990, 1, 31), 'Arica', '*'),
    ('Fulanito', (1992, 10, 29), 'Porvenir', '****'),
]

for n, (a, m, d), c, e in datos:
    print n.ljust(10),
    print str(a).rjust(4), str(m).rjust(2), str(d).rjust(2),
    print c.ljust(10), e.center(5)

Este programa imprime lo siguiente:

Pepito     1991 12  5 Osorno      ***
Yayita     1990  1 31 Arica        *
Fulanito   1992 10 29 Porvenir    ****

Interpolación de strings¶

El método format permite usar un string como una plantilla que se puede completar con distintos valores dependiendo de la situación.

Las posiciones en que se deben rellenar los valores se indican dentro del string usando un número entre paréntesis de llaves:

>>> s = 'Soy {0} y vivo en {1}'

Estas posiciones se llaman campos. En el ejemplo, el string s tiene dos campos, numerados del cero al uno.

Para llenar los campos, hay que llamar al método format pasándole los valores como parámetros:

>>> s.format('Perico', 'Valparaiso')
'Soy Perico y vivo en Valparaiso'
>>> s.format('Erika', 'Berlin')
'Soy Erika y vivo en Berlin'
>>> s.format('Wang Dawei', 'Beijing')
'Soy Wang Dawei y vivo en Beijing'

El número indica en qué posición va el parámetro que está asociado al campo:

>>> '{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'

Otra opción es referirse a los campos con un nombre. En este caso, hay que llamar al método format diciendo explícitamente el nombre del parámetro para asociarlo al valor:

>>> s = '{nombre} estudia en la {universidad}'
>>> s.format(nombre='Perico', universidad='UTFSM')
'Perico estudia en la UTFSM'
>>> s.format(nombre='Fulana', universidad='PUCV')
'Fulana estudia en la PUCV'
>>> s.format(universidad='UPLA', nombre='Yayita')
'Yayita estudia en la UPLA'

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.close()

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()