 |
 |
 |
Guía de aprendizaje de Python |  |
 |
|
|
|
|
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."
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).
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
>>> x = y = z = 0 # Poner a cero 'x', 'y' y 'z' >>> x 0 >>> y 0 >>> z 0
>>> 4 * 2.5 / 3.3 3.0303030303 >>> 7.0 / 2 3.5
>>> 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)
z.real y z.imag.
>>> a=1.5+0.5j >>> a.real 1.5 >>> a.imag 0.5
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
_. 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.
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:
+---+---+---+---+---+---+ | 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
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
indica que se ha de insertar
el carácter Unicode con ordinal hexadecimal 0x0020 (el espacio) en la
posición indicada.
u0020
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 occidentales3.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
si hay un número impar
de barras invertidas frente a la "u".
uXXXX
>>> 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'
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.
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.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.
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.
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).
>>> 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.
|
|
|
Guía de aprendizaje de Python | |
|
|