Guía de aprendizaje de Python

En los siguientes ejemplos, la entrada y la salida se distinguen por la presencia o ausencia de indicadores (‘>>> ’ y ‘... ’). Para repetir el ejemplo debe teclear todo lo que sigue al indicador, cuando aparezca el indicador. Las líneas que no empiezan por un indicador son la salida del intérprete. Observa que un indicador secundario solo en una línea indica que debe teclear una línea en blanco. Esto se utiliza para finalizar una orden multi-línea.

Muchos de los ejemplos de este manual, incluidos los que se escriben interactivamente, incluyen comentarios. Los comentarios en Python empiezan por el carácter almohadilla, ‘#’, y se extienden hasta el final de la línea física. Se puede iniciar un comentario al principio de una línea o tras espacio en blanco o código, pero no dentro de una constante literal. Una almohadilla dentro de una cadena es, simplemente, una almohadilla.

Ejemplos:

# éste es el primer comentario
fiambre = 1 # y éste
# ... ¡y un tercero!
cadena = "# Esto no es un comentario."

. Python como calculadora

Vamos a probar algunas órdenes simples de Python. Arranca el intérprete y espera a que aparezca el indicador principal, ‘>>>’ (no debería tardar mucho).

. Números

El intérprete funciona como una simple calculadora: Tú tecleas una expresión y él muestra el resultado. La sintaxis de las expresiones es bastante intuitiva: Los operadores +, -, * y / funcionan como en otros lenguajes (p. ej. Pascal o C). Se puede usar paréntesis para agrupar operaciones. Por ejemplo:

>>> 2+2
4
>>> # Esto es un comentario
... 2+2
4
>>> 2+2 # un comentario junto al código
4
>>> (50-5*6)/4
5
>>> # La división entera redondea hacia abajo:
... 7/3
2
>>> 7/-3
-3

Al igual que en C, se usa el signo de igualdad ‘=’ para asignar un valor a una variable. El valor de una asignación no se escribe:

>>> ancho = 20
>>> alto = 5*9
>>> ancho * alto
900

Se puede asignar un valor simultáneamente a varias variables:

>>> x = y = z = 0 # Poner a cero ’x’, ’y’ y ’z’
>>> x
0
>>> y
0
>>> z
0

La coma flotante funciona de la manera esperada. Los operadores con tipos mixtos convierten el operando entero a coma flotante:

>>> 4 * 2.5 / 3.3
3.0303030303
>>> 7.0 / 2
3.5

También funcionan de la manera esperada los números complejos: Los números imaginarios se escriben con el sufijo ‘j’ o ‘J’. Los números complejos con una parte real distinta de cero se escriben ‘(real+imagj)’, y se pueden crear con la función ‘complex(real, imag)’.

>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

Los números complejos siempre se representan como dos números de coma flotante, la parte real y la imaginaria. Para extraer una de las partes de un número complejo z, usa z.real y z.imag.

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

Las funciones de conversión a coma flotante y a entero (float(), int() y long()) no funcionan con números complejos, pues no hay un modo único y correcto de convertir un complejo a real. Usa abs(z) para sacar su módulo (como flotante) o z.real para sacar su parte real.

>>> a=1.5+0.5j
>>> float(a)
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: can’t convert complex to float; use e.g. abs(z)
>>> a.real
1.5
>>> abs(a)
1.58113883008

En modo interactivo, la última expresión impresa se asigna a la variable _. Esto significa que, cuando se usa Python como calculadora, se facilita continuar los cálculos, por ejemplo:

>>> iva = 17.5 / 100
>>> precio = 3.50
>>> precio * iva
0.61249999999999993
>>> precio + _
4.1124999999999998
>>> round(_, 2)
4.1100000000000003

Sólo debe leer esta variable. No le asignes un valor explícitamente, ya que crearías una variable local del mismo nombre y enmascararías la variable interna que proporciona la funcionalidad especial.

. Cadenas

Además de los números, Python también sabe manipular cadenas, que se pueden expresar de diversas maneras. Se pueden encerrar entre comillas simples o dobles:

>>> ’fiambre huevos’
’fiambre huevos’
>>> ’L\’Hospitalet’
"L’Hospitalet"
>>> "L’Hospitalet"
"L’Hospitalet"
>>> ’"Sí," dijo.’
’"Sí," dijo.’
>>> "\"Sí,\" dijo."
’"Sí," dijo.’
>>> ’"En L\’Hospitalet," dijo.’
’"En L\’Hospitalet," dijo.’

Las cadenas pueden ocupar varias líneas de diferentes maneras. Se puede impedir que el final de línea física se interprete como final de línea lógica mediante usando una barra invertida, por ejemplo:

hola = "Esto es un texto bastante largo que contiene\n\
varias líneas de texto, como si fuera C.\n\
    Observa que el espacio en blanco al principio de la línea es\
  significativo.\n"
print hola

mostraría lo siguiente:

Esto es un texto bastante largo que contiene
varias líneas de texto, como si fuera C.
    Observa que el espacio en blanco al principio de la línea es significativo.

O se pueden encerrar las cadenas entre comillas triples emparejadas: """ o ’’’. No es necesario poner barra invertida en los avances de línea cuando se utilizan comillas triples; serán incluidos en la cadena.

print """
Uso: cosilla [OPCIONES]
    -h                  Mostrar este mensaje de uso
    -H NombreServidor   Nombre del servidor al que conectarse
"""

presenta:

Uso: cosilla [OPCIONES]
    -h                  Mostrar este mensaje de uso
    -H NombreServidor   Nombre del servidor al que conectarse

El intérprete muestra los resultados de las operaciones con cadenas como se escriben a la entrada: Entre comillas y con las comillas y otros caracteres raros escapados por barras invertidas, para mostrar el valor exacto. La cadena se encierra entre comillas dobles si contiene una comilla simple y no contiene comillas dobles, si no, se encierra entre comillas simples (se puede utilizar print para escribir cadenas sin comillas ni secuencias de escape).

Se puede concatenar cadenas (pegarlas) con el operador + y repetirlas con *:

>>> palabra = ’Ayuda’ + ’Z’
>>> palabra
’AyudaZ’
>>> ’<’ + palabra*5 + ’>’
’<AyudaZAyudaZAyudaZAyudaZAyudaZ>’

Dos literales juntos se concatenan automáticamente. La primera línea de arriba se podría haber escrito ‘palabra = ’Ayuda’ ’Z’’. Esto sólo funciona con literales, no con expresiones de cadena arbitrarias.

>>> import string
>>> ’cad’ ’ena’ # <- Esto vale
’cadena’
>>> string.strip(’cad’) + ’ena’ # <- Esto vale
’cadena’
>>> string.strip(’cad’) ’ena’ # <- Esto no vale
File "<stdin>", line 1
string.strip(’cad’) ’ena’
^
SyntaxError: invalid syntax

Se puede indexar una cadena. Como en C, el primer carácter de una cadena tiene el índice 0. No hay un tipo carácter diferente; un carácter es una cadena de longitud uno. Como en Icon, las subcadenas se especifican mediante la notación de corte: dos índices separados por dos puntos.

>>> palabra[4]
’a’
>>> palabra[0:2]
’Ay’
>>> palabra[2:4]
’ud’

A diferencia de las cadenas en C, las cadenas de Python no se pueden cambiar. Si se intenta asignar a una posicion indexada dentro de la cadena se produce un error:

>>> palabra[0] = ’x’
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesn’t support item assignment
>>> palabra[:-1] = ’Choof’
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesn’t support slice assignment

Sin embargo crear una nueva cadena con el contenido combinado es fácil y eficaz:

>>> ’x’ + palabra[1:]
’xyudaZ’
>>> ’Choof’ + word[-1:]
’ChoofZ’

Los índices de corte tienen valores por omisión muy prácticos; si se omite el primer índice se supone cero y si se omite el segundo se supone el tamaño de la cadena sometida al corte.

>>> palabra[:2] # Los primeros dos caracteres
’Ay’
>>> palabra[2:] # Todos menos los primeros dos caracteres
’daZ’

He aquí un comportamiento útil en las operaciones de corte: s[:i] + s[i:] equivale a s.

>>> palabra[:2] + palabra[2:]
’AyudaZ’
>>> palabra[:3] + palabra[3:]
’AyudaZ’

Los índices degenerados se tratan con elegancia: un índice demasiado grande se reemplaza por el tamaño de la cadena, un índice superior menor que el inferior devuelve una cadena vacía.

>>> palabra[1:100]
’yudaZ’
>>> palabra[10:]
’’
>>> palabra[2:1]
’’

Los índices pueden ser negativos, para hacer que la cuenta comience por el final. Por ejemplo:

>>> palabra[-1] # El último carácter
’Z’
>>> palabra[-2] # El penúltimo carácter
’a’
>>> palabra[-2:] # Los dos últimos caracteres
’aZ’
>>> palabra[:-2] # Todos menos los dos últimos
’Ayud’

Pero date cuenta de que -0 es 0, así que ¡no cuenta desde el final!

>>> palabra[-0] # (porque -0 es igual a 0)
’A’

Los índices de corte negativos fuera de rango se truncan, pero no ocurre así con los índices simples (los que no son de corte):

>>> palabra[-100:]
’AyudaZ’
>>> palabra[-10] # error
Traceback (innermost last):
File "<stdin>", line 1
IndexError: string index out of range

El mejor modo de recordar cómo funcionan los índices es pensar que apuntan al espacio entre los caracteres, estando el borde izquierdo del primer carácter numerado 0. El borde derecho del último carácter de una cadena de n caracteres tiene el índice n, por ejemplo:

Ejemplo de índices

La primera fila de números da la posición de los índices 0..5 de la cadena; la segunda da los índices negativos correspondientes.

El corte desde i hasta j consta de todos los caracteres entre los bordes etiquetados i y j, respectivamente.

Para los índices no negativos, la longitud del corte es la diferencia entre los índices, si los dos están entre límites. Por ejemplo, la longitud de palabra[1:3] es 2.

La función interna len() devuelve la longitud de una cadena:

>>> s = ’supercalifragilisticoexpialidoso’
>>> len(s)
32

. Cadenas Unicode

A partir de Python 2.0, el programador dispone de un nuevo tipo de datos para almacenar datos de texto: el objeto Unicode. Se puede usar para almacenar y manipular datos Unicode (consulte http://www.unicode.org) y se integra bien con los objetos de cadena existentes, proporcionando conversiones automáticas si se da el caso.

La codificación Unicode tiene la ventaja de proporcionar un ordinal para cada sistema de escritura utilizado en textos antiguos y modernos. Anteriormente, había sólo 256 ordinales para los caracteres escritos y se solía asociar los textos a una página de códigos, que hacía corresponder los ordinales con los caracteres escritos. Esto llevaba a una gran confusión, especialmente en lo relativo a la internacionalización (comúnmente escrito ‘i18n’ — ‘i’ + 18 characters + ‘n’) del software. Unicode resuelve estos problemas definiendo una página de códigos única para todos los sistemas de escritura.

Crear cadenas Unicode en Python es tan simple como crear cadenas normales:

>>> u’Muy buenas’
u’Muy buenas’

La ‘u’ minúscula frente a la comilla indica que se ha de crear una cadena Unicode. Si deseas incluir caracteres especiales dentro de la cadena, lo puedes hacer mediante la codificación Unicode-Escape de Python. El siguiente ejemplo muestra cómo:

>>> u’Muy\\u0020buenas’
u’Muy buenas’

La secuencia de escape u0020 indica que se ha de insertar el carácter Unicode con ordinal hexadecimal 0x0020 (el espacio) en la posición indicada.

El resto de los caracteres se interpretan utilizando sus ordinales respectivos directamente como ordinales Unicode. Como ocurre que los primeros 256 ordinales de Unicode coinciden con la codificación estándar Latin-1 utilizada en muchos países occidentales 1 , el proceso de introducir Unicode se ve muy simplificado.

Para los expertos, existe también un modo en bruto, como para las cadenas normales. Se debe preceder la cadena con una ‘r’ minúscula para que Python utilice la codificación En bruto-Unicode-Escape. Sólo aplicará la conversión citada >uXXXX si hay un número impar de barras invertidas frente a la ‘u’.

>>> ur’Muy\u0020buenas’
u’Muy buenas’
>>> ur’Muy\\u0020buenas’
u’Muy\\\\u0020buenas’

El modo en bruto es útil cuando hay que meter gran cantidad de barras invertidas, como en las expresiones regulares.

Además de estas codificaciones estándar, Python proporciona un conjunto completo de modos de crear cadenas Unicode basándose en una codificación conocida.

La función interna unicode() proporciona acceso a todos los codecs (codificadores/descodificadores) Unicode registrados. Algunas de las codificaciones más conocidas a las que pueden convertir estos codecs son Latin-1, ASCII, UTF-8 y UTF-16. Los últimos dos son codificaciones de longitud variable que permiten almacenar caracteres Unicode de 8 o 16 bits. Python usa UTF-8 como codificación por defecto. Ésto se hace patente cuando se presentan cadenas Unicode o se escriben en ficheros.

>>> u"äöü"
u’\344\366\374’
>>> str(u"äöü")
’\303\244\303\266\303\274’

Si tienes datos en una codificación específica y quieres obtener la correspondiente cadena Unicode a partir de ellos, puedes usar la función interna unicode() con el nombre de la codificación como segunod argumento.

>>> unicode(’\303\244\303\266\303\274’,’UTF-8’)
u’\344\366\374’

Para reconvertir la cadena Unicode a una cadena con la codificación original, los objetos proporcionan un método encode().

>>> u"äöü".encode(’UTF-8’)
’\303\244\303\266\303\274’

. Listas

Python utiliza varios tipos de datos compuestos, que se utilizan para agrupar otros valores. El más versátil es la lista, que se puede escribir como una lista de valores (elementos) separada por comas entre corchetes. Los elementos de una lista no tienen que ser todos del mismo tipo.

>>> a = [’fiambre’, ’huevos’, 100, 1234]
>>> a
[’fiambre’, ’huevos’, 100, 1234]

Como los índices de las cadenas, los índices de una lista empiezan en cero. Las listas también se pueden cortar, concatenar, etc.:

>>> a[0]
’fiambre’
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
[’huevos’, 100]
>>> a[:2] + [’bacon’, 2*2]
[’fiambre’, ’huevos’, ’bacon’, 4]
>>> 3*a[:3] + [’¡Hey!’]
[’fiambre’, ’huevos’, 100, ’fiambre’, ’huevos’, 100, ’fiambre’, ’huevos’, 100, ’¡Hey!’]

A diferencia de las cadenas, que son inmutables, es posible cambiar los elementos de una lista:

>>> a
[’fiambre’, ’huevos’, 100, 1234]
>>> a[2] = a[2] + 23
>>> a
[’fiambre’, ’huevos’, 123, 1234]

Se puede asignar a un corte, lo que puede hasta cambiar el tamaño de la lista:

>>> # Reemplazar elementos:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Quitar elementos:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Insertar cosas:
... a[1:1] = [’puaj’, ’xyzzy’]
>>> a
[123, ’puaj’, ’xyzzy’, 1234]
>>> a[:0] = a # Insertarse (una copia) al principio de ella misma
>>> a
[123, ’puaj’, ’xyzzy’, 1234, 123, ’puaj’, ’xyzzy’, 1234]

La función interna len() se aplica también a las listas:

>>> len(a)
8

Es posible anidar listas (crear listas que contienen otras listas), por ejemplo:

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append(’xtra’) # Consulte la sección 5.1
>>> p
[1, [2, 3, ’xtra’], 4]
>>> q
[2, 3, ’xtra’]

Observa que, en el último ejemplo, ¡p[1] y q se refieren en realidad al mismo objeto! Volveremos al tema de la semántica de objetos más tarde.

. Primeros pasos programando

Por supuesto, se puede usar Python para tareas más complejas que sumar dos y dos. Por ejemplo, podemos escribir una secuencia parcial de la serie de Fibonacci 2 de este modo:

>>> # Serie de Fibonacci:
... # La suma de dos elementos nos da el siguiente
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
...
1
1
2
3
5
8

Este ejemplo introduce varias características nuevas.

  1. La primera línea contiene una asignación múltiple: a las variables a y b se les asignan a la vez los nuevos valores 0 y 1. En la última línea se utiliza esto de nuevo, demostrando que las expresiones del lado derecho se evalúan antes que la primera de las asignaciones. Las expresiones del lado derecho se evalúan de izquierda a derecha.
  2. El bucle while se ejecuta mientras la condición (en este caso: b < 10) sea cierta. En Python, como en C, cualquier valor entero no cero es verdadero y 0 es falso. La condición también puede ser una lista o cualquier secuencia, cualquier cosa con longitud no cero es verdadero, las secuencias vacías son falso. La comprobación en este caso es simple. Los operadores de comparación estándar se escriben igual que en C: < (menor que), > (mayor que), == (igual a), <= (menor o igual a), >= (mayor o igual a) y != (diferente de).
  3. El cuerpo del bucle está sangrado (o indentado): Éste es el modo en que Python agrupa las sentencias. Python (todavía) no ofrece un servicio de edición de líneas sangradas, así que hay que teclear a mano un tabulador o espacio(s) para cada línea sangrada. En la práctica, los programas más complejos se realizan con un editor de texto y la mayoría ofrece un servicio de sangrado automático. Cuando se introduce una sentencia compuesta interactivamente, se debe dejar una línea en blanco para indicar el final (porque el analizador de sintaxis no puede adivinar cuándo has acabado) Observa que cada línea de un bloque básico debe estar sangrada al mismo nivel exactamente.
  4. La sentencia print escribe el valor de la expresión o expresiones dadas. Se diferencia de escribir simplemente la expresión (como hemos hecho antes en los ejemplos de la calculadora) en el modo en que gestiona las expresiones múltiples y las cadenas. Las cadenas se imprimen sin comillas y se inserta un espacio entre los elementos para queden las cosas colocadas:
>>> i = 256*256
>>> print ’El valor de i es’, i
El valor de i es 65536

Si se pone una coma al final se evita el retorno de carro tras la salida:

>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Observa que el intérprete inserta una nueva línea antes de presentar el indicador si la última línea quedó incompleta.

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
¡SÉ EL PRIMERO EN COMENTAR!
Conéctate o Regístrate para dejar tu comentario.