PDF de programación - Tutorial del lenguaje Python

Tutorial del lenguaje

Python

Alan Ignacio Sepulveda Rodriguez

[email protected]

Índice de contenido

"Hello World!"......................................................................................................................................3
Entrada de Usuario. raw_input()...........................................................................................................3
Operadores.............................................................................................................................................3
Variables................................................................................................................................................4
Números................................................................................................................................................4
Secuencias (strings, listas y tuplas).......................................................................................................4
Strings...............................................................................................................................................6
Listas y Tuplas..................................................................................................................................6
Diccionarios...........................................................................................................................................7
Bloques de código.................................................................................................................................8
Sentencia if............................................................................................................................................8
Bucle while............................................................................................................................................9
Bucle for................................................................................................................................................9
Definición de funciones.......................................................................................................................10
Módulos...............................................................................................................................................10
Ficheros...............................................................................................................................................10
Errores y excepciones..........................................................................................................................12

"Hello World!"
El primer programa al que se enfrentará el desarrollador más avanzado cuando empieza con un nuevo
lenguaje, será sin ninguna duda el famoso ¡ Hola Mundo !
>>> print 'Hello World!'
Hello World!

La sentencia print se utiliza en python para mostrar la salida por la pantalla. Aquellos que estén
familiarizados con C, deben saber que funciona de forma parecida a la sentencia printf().

Un apunte final, la sentencia print junto con el operador de formateo de cadenas (%) se comporta
exactamente igual a la sentencia printf() de C.
>>> print "%s es el número %d!" % ("Python", 1)
Python es el número 1!

Entrada de Usuario. raw_input()
La forma más fácil de obtener la entrada de datos de un usuario por pantalla, es utilizando la sentencia
raw_input().
>>> user = raw_input('Introduce tu login: ')
Introduce tu login: root
>>> print 'Tu login es:', user
Tu login es: root

El ejemplo anterior espera que la entrada sea una cadena, pero si queremos introducir un valor
numérico y que sea tratado como tal, habrá que convertirlo previamente.
>>> num = raw_input('Introduce un número: ')
Introduce un número: 1024
>>> print 'El doble del número es: %d' % (int(num) * 2)
El doble del número es: 2048

La función int() convierte la variable de tipo string en un entero.
Operadores

 Operadores matemáticos: + - * / % **
 Operadores de comparación: < <= > >= == != <>

 Operadores lógicos: and or not

Variables
Las reglas que rigen el comportamiento de las variables en Python son muy parecidas a las de otros
lenguajes. Las variables son simples identificadores que deben empezar siembre por un carácter
alfabético, en mayúsculas o minúsculas o el símbolo _ (guión bajo), seguidos de cualquier carácter
alfanumérico.

Hay que recalcar que Python distingue entre mayúsculas y minúsculas.

Python es un lenguaje de tipos dinámicos, lo cual significa que no hay necesidad de declarar el tipo de
una variable. El tipo se definirá en el momento de la asignación de la variable.
>>> contador = 0
>>> millas = 1000.0
>>> nombre = 'Fernando'
>>> contador = contador + 1
>>> kms = 1.609 * millas
>>> print '%f millas es lo mismo que %f km' % (millas, kms)
1000.000000 millas es lo mismo que 1609.000000 km

Números
Python soporta cuatro tipos numéricos:

1. Enteros con signo (int).
2. Enteros largos (long) que pueden ser representados también en octal o hexadecimal.

3. Reales en coma flotante (float)

4. Números complejos (complex)

Los tipos realmente interesantes en Python por las particularidades que comportan son el tipo long y el
tipo complex.

El tipo long es superior al archiconocido long de C, ya que en Python no tiene límite de capacidad,
solamente el que le imponga la memoria virtual del sistema. Sería más parecido a los números
definidos en Java con la clase BigInteger.

En cuanto al soporte de números complejos, Python es el único lenguaje que nativamente soporta este
tipo de datos.
Secuencias (strings, listas y tuplas)
Las secuencias son un tipo de datos cuyos elementos están ordenados y pueden ser accedidos vía un
índice.

Todos los tipos de secuencias comparten el mismo modelo de acceso a sus elementos. Para acceder a
un elemento en concreto se utiliza la siguiente nomenclatura seq[i]. Dada una variable de tipo
secuencia denominada seq, accedemos al elemento que ocupa la posicion i. El esquema de numeración
utilizado empieza en el 0 y finaliza en el valor que defina la longitud de la secuencia menos 1.

Varios elementos (substrings) pueden ser obtenidos a la vez utilizando el operador slice (trozo). La
sintaxis para obtener un grupo de elementos es la siguiente:
secuencia[indice_inicial : indice_final]

Con esta sintaxis podemos obtener un trozo (slice) empezando en el elemento definido por el
indice_inicial y terminando en el elemento anterior al definido por el indice_final.
>>> cadena='Hola Mundo!'
>>> print cadena[0:4]
Hola

Parece algo confuso pero la mejor forma de recordar como funciona el operador slice es pensar que los
indices apuntan realmente entre los caracteres.
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1

En la siguiente tabla se muestra una lista de operadores que se pueden utilizar con todos los tipos de
secuencias:

Tabla 10.1. Operadores de secuencias

elemento situado en el índice index de la secuencia
elementos desde el índice ind1 hasta el índice ind2
la secuencia se repite n veces

secuencia[index]
secuencia[ind1:ind2]
secuencia * n
secuencia1 + secuencia2 concatena las secuencias secuencia1 y secuencia2
comprueba si objeto es un miembro de secuencia
objeto in secuencia
objeto not in secuencia
comprueba si objeto no es un miembro de secuencia

La siguiente tabla muestra algunas de las funciones predefinidas que se pueden aplicar a las secuencias.

Tabla 10.2. Funciones Pre-Definidas

convierte la secuencia a un tipo lista
convierte el objeto a un tipo string

list (secuencia)
str (objeto)
tuple (secuencia) convierte la secuencia a un tipo tupla
len (secuencia)

devuelve la longitud (numero de elementos) de la secuencia

max (secuencia) devuelve el elemento mas grande de la secuencia
min (secuencia) devuelve el elemento menor de la secuencia

Los diferentes tipos de secuencias se exponen a continuación.

Strings

Para Python, las cadenas (strings) son un conjunto contiguo de caracteres encerrados entre simples o
dobles comillas.
>>> cadena='Hola Mundo!'
>>> print cadena
Hola Mundo!

Los strings son inmutables, no se puede alterar su valor a no ser que sean copiados a otro objeto string.

Los métodos y funciones aplicables al tipo de objeto string se encuentran definidos en el módulo string
>>> import string
>>> cadena.upper()
'HOLA MUNDO!'

La línea import string permite acceder a todos los métodos y atributos disponibles para un tipo de dato
string, siendo la línea cadena.upper() la forma de invocar al método upper sobre el objeto string
denominado cadena. Como resultado obtenemos el string en mayúsculas.

La siguiente tabla muestra algunos de los métodos disponibles en el módulo string:

Tabla 10.3. Métodos del módulo string

find( sub[, start[,
end]])

isalnum()

isdigit()

lower()
split([sep
[,maxsplit]])

Listas y Tuplas

devuelve el índice menor donde se encuentra el substring sub dentro del string

devuelve verdadero si todos los caracteres en el string son alfanuméricos y existe
al menos uno.
devuelve verdadero si todos los caracteres en el string son dígitos y existe al
menos uno.
devuelve una copia del string convertido a minúsculas.

devuelve una lista de elementos del string utilizando como separador sep.

Python posee varios tipos de datos para agrupar de una forma fácil diferentes valores. El tipo de dato
más versátil es la lista. Una lista es una colección de elementos separados por comas y encerrados entre
paréntesis. Los elementos de una lista no tienen porque ser del mismo tipo.
>>> lista = [ 1,'dos',3,'cuatro']

>>> print lista
[1, 'dos', 3, 'cuatro']

Como ocurría con el tipo de datos string, los índices de una lista empiezan en el 0, y pueden ser
troceadas (sliced), concatenadas ...
>>> lista [0]
1
>>> lista [3]
'cuatro'
>>> lista [1:-1]
['dos', 3]
>>> lista + [5,'seis']
[1, 'dos', 3, 'cuatro', 5, 'seis']

A diferencia de los strings, que por definición eran inmutables,