 |
 |
 |
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 éste. 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
Se usa el signo de igualdad "=" para asignar un valor a una variable. Tras la asignación, no se presenta nada antes de presentar el siguiente indicador:
>>> 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
>>> 3 * 3.75 / 1.5 7.5 >>> 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 o 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=3.0+4.0j >>> float(a) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: can't convert complex to float; use e.g. abs(z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0 >>>
_. Esto significa que, cuando se usa Python como calculadora,
se facilita continuar los cálculos, por ejemplo:
>>> iva = 12.5 / 100 >>> precio = 100.50 >>> precio * iva 12.5625 >>> precio + _ 113.0625 >>> round(_, 2) 113.06 >>>
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 usando una barra invertida al final de cada línea parcial:
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."
print hola
observa que los saltos de línea se han de incrustar en la cadena con
\n, pues el salto de línea físico se desecha. El ejemplo
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.
Sin embargo, si hacemos de la cadena una cadena ``en bruto'', las secuencias
\n no se convierten en saltos de línea, sino que se incluyen tanto
la barra invertida y el carácter de salto de línea del código fuente en la
cadena como datos. Así, el ejemplo:
hola = r"Ésta es una cadena bastante larga que contiene\n\ varias líneas de texto de manera parecida a como se haría en C." print hola
mostraría:
Ésta es una cadena bastante larga que contiene\n\ varias líneas de texto de manera parecida a como se haría en C.
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; se incluyen 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 marcados 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'
>>> 'cad'.strip() + 'ena' # <- Esto vale
'cadena'
>>> 'cad'.strip() 'ena' # <- Esto no vale
File "<stdin>", line 1, in ?
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 'udaZ'
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'
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 (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesn't support item assignment >>> palabra[:1] = 'Choof' Traceback (most recent call 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[4] 'ChoofZ'
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 (most recent call last): File "<stdin>", line 1, in ? 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
Ver tambié:
%.
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 (consultar 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 caracteres + "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. Si se tienen cadenas en la codificación estándar Latin-1 utilizada en muchos países occidentales3.1, resulta bastante práctico que los primeros 256 caracteres de Unicode sean los mismos que los de Latin-1.
Para los expertos, existe también un modo en bruto, como para las cadenas
normales. Se debe prefijar la cadena con 'ur'
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 suele resultar necesario 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 codes (codificadores/descodificadores) Unicode registrados. Algunas de las codificaciones más conocidas a las que pueden convertir estos codes son Latin-1, ASCII, UTF-8 y UTF-16. Los últimos dos son codificaciones de longitud variable que almacenan cada carácter Unicode como uno o más bytes. La codificación predeterminada suele ser ASCII, que admite los caracteres del 0 al 127 y rechaza el resto de los caracteres. Cuando se presenta una cadena, se escribe en un fichero o se convierte con str(), se lleva a cabo la conversión con esta codificación predeterminada.
\begin{verbatim}
>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
Para convertir una cadena Unicode a una cadena de caracteres de 8 bit usando una codificación específica, los objetos Unicode proporcionan un método encode() que toma un argumento, el nombre de la codificación. Son preferibles los nombres en minúsculas.
>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'
Si dispones de datos en una codificación concreta y quieres obtener su cadena Unicode correspondiente, usa la función unicode() con el nombre de la codificación como segundo argumento.
>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'
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] + ['panceta', 2*2] ['fiambre', 'huevos', 'panceta', 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 distinto de cero
es verdadero y 0 es falso.
La condición también puede ser una lista o cualquier secuencia, cualquier cosa
con longitud distinta de 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 != (distinto 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 | |
|
|