Subsecciones


3. Introducción informal a 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."


3.1 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).


3.1.1 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.6125
>>> precio + _
4.1125
>>> round(_, 2)
4.11

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.


3.1.2 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.

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

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:

 +---+---+---+---+---+---+
 | A | y | u | d | a | Z |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

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


3.1.3 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.


3.2 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 Fibonacci3.1 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.



Notas al pie

...Fibonacci3.1
La serie de Fibonacci (matemático italiano del siglo XIII) se caracteriza porque cada elemento es la suma de los dos anteriores, excepto los dos primeros, que son 0 y 1


Envía los comentarios sobre este documento a python-docs@python.org (en inglés). Envía los comentarios sobre la traducción a Marcos.