Listas

La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores.

Las listas pueden contener cualquier tipo de dato: números, cadenas, booleanos, … y también listas.

Crear una lista es tan sencillo como indicar entre corchetes, y separados por comas, los valores que queremos incluir en la lista:

l = [22, True, "una lista", [1, 2]]

Podemos acceder a cada uno de los elementos de la lista escribiendo el nombre de la lista e indicando el índice del elemento entre corchetes. Ten en cuenta sin embargo que el índice del primer elemento de la lista es 0, y no 1:

mi_var = l[0] # mi_var vale 22

Si queremos acceder a un elemento de una lista incluida dentro de otra lista tendremos que utilizar dos veces este operador, primero para indicar a qué posición de la lista exterior queremos acceder, y el segundo para seleccionar el elemento de la lista interior:

mi_var = l[3][0] # mi_var vale 1

También podemos utilizar este operador para modificar un elemento de la lista si lo colocamos en la parte izquierda de una asignación:

l[0] = 99 # l vale [99, True, "una lista", [1, 2]]

El uso de los corchetes para acceder y modificar los elementos de una lista es común en muchos lenguajes, pero Python nos depara varias sorpresas muy agradables.

Una curiosidad sobre el operador [] de Python es que podemos utilizar también números negativos. Si se utiliza un número negativo como índice, esto se traduce en que el índice empieza a contar desde el final, hacia la izquierda; es decir, con [-1] accederíamos al último elemento de la lista, con [-2] al penúltimo, con [-3], al antepenúltimo, y así sucesivamente.

Otra cosa inusual es lo que en Python se conoce como slicing o particionado, y que consiste en ampliar este mecanismo para permitir seleccionar porciones de la lista. Si en lugar de un número escribimos dos números inicio y fin separados por dos puntos (inicio:fin) Python interpretará que queremos una lista que vaya desde la posición inicio a la posición fin, sin incluir este último. Si escribimos tres números (inicio:fin:salto) en lugar de dos, el tercero se utiliza para determinar cada cuantas posiciones añadir un elemento a la lista.

mi_var = l[0:2]   # mi_var vale [99, True]
mi_var = l[0:4:2] # mi_var vale [99, "una lista"]

Los números negativos también se pueden utilizar, con el mismo comportamiento que se comentó anteriormente.

Hay que mencionar así mismo que no es necesario indicar el principio y el final del slicing, sino que, si estos se omiten, se usarán por defecto las posiciones de inicio y final de la lista respectivamente:

mi_var = l[1:]  # mi_var vale [True, "una lista", [1, 2]]
mi_var = l[:2]  # mi_var vale [99, True]
mi_var = l[:]   # mi_var vale [99, True, "una lista", [1, 2]]
mi_var = l[::2] # mi_var vale [99, "una lista"]

También podemos utilizar este mecanismo para modificar la lista:

l[0:2] = [0, 1] # l vale [0, 1, "una lista", [1, 2]]

pudiendo incluso modificar el tamaño de la lista si la lista de la parte derecha de la asignación tiene un tamaño menor o mayor que el de la selección de la parte izquierda de la asignación:

l[0:2] = [False] # l vale [False, "una lista", [1, 2]]

En todo caso las listas ofrecen mecanismos más cómodos para ser modificadas a través de las funciones de la clase correspondiente, aunque no veremos estos mecanismos hasta más adelante, después de explicar lo que son las clases, los objetos y las funciones.

Tuplas

Todo lo que hemos explicado sobre las listas se aplica también a las tuplas, a excepción de la forma de definirla, en la que se utiliza paréntesis en lugar de corchetes.

t = (1, 2, True, "python")

En realidad el constructor de la tupla es la coma, no el paréntesis, pero el intérprete muestra los paréntesis, y nosotros deberíamos utilizarlos, por claridad.

>>> t = 1, 2, 3
>>> type(t)
type “tuple”

Además hay que tener en cuenta que es necesario añadir una coma para tuplas de un solo elemento, para diferenciarlo de un elemento entre paréntesis.

>>> t = (1)
>>> type(t)
type “int”
>>> t = (1,)
>>> type(t)
type “tuple”

Para referirnos a elementos de una tupla, como en una lista, se usa el operador []:

mi_var = t[0] # mi_var es 1
mi_var = t[0:2] # mi_var es (1, 2)

Podemos utilizar el operador [] debido a que las tuplas, al igual que las listas, forman parte de un tipo de objetos llamados secuencias. Permitirme un pequeño inciso para indicaros que las cadenas de texto también son secuencias, por lo que no os extrañará que podamos hacer cosas como estas:

c = "hola mundo"
c[0]   # h
c[5:]  # mundo
c[::3] # hauo

Volviendo al tema de las tuplas, su diferencia con las listas estriba en que las tuplas no poseen estos mecanismos de modificación tan útiles de los que hablábamos al final de la anterior sección. También son inmutables, es decir, sus valores no se pueden modificar una vez creada; y de tamaño fijo. A cambio las tuplas son más “ligeras” que las listas, por lo que si el uso que le vas a dar a tu colección es muy básico, puedes utilizar tuplas en lugar de listas y ahorrar memoria.

Diccionarios

Los diccionarios, también llamados matrices asociativas, deben su nombre a que son colecciones que relacionan una clave y un valor. Por ejemplo, veamos un diccionario de películas y directores:

d = {"Love Actually ": "Richard Curtis",
     "Kill Bill": "Tarantino",
     "Amélie": "Jean-Pierre Jeunet"}

El primer valor se trata de la clave y el segundo del valor asociado a la clave. Como clave podemos utilizar cualquier valor inmutable: podríamos usar números, cadenas, booleanos, tuplas, … pero no listas o diccionarios, dado que son mutables. Esto es así porque los diccionarios se implementan como tablas hash, y a la hora de introducir un nuevo par clave-valor en el diccionario se calcula el hash de la clave para después poder encontrar la entrada correspondiente rápidamente. Si se modificara el objeto clave después de haber sido introducido en el diccionario, evidentemente, su hash también cambiaría y no podría ser encontrado.

La diferencia principal entre los diccionarios y las listas o las tuplas es que a los valores almacenados en un diccionario se les accede no por su índice, porque de hecho no tienen orden, sino por su clave, utilizando de nuevo el operador [].

d["Love Actually "] # devuelve "Richard Curtis"

Al igual que en listas y tuplas también se puede utilizar este operador para reasignar valores.

d["Kill Bill"] = "Quentin Tarantino"

Sin embargo en este caso no se puede utilizar slicing, entre otras cosas porque los diccionarios no son secuencias, si no mappings (mapeados, asociaciones).

Vamos a crear un par de variables a modo de ejemplo. Una de tipo cadena y una de tipo entero:

# esto es una cadena
c = "Hola Mundo"

# y esto es un entero
e = 23

# podemos comprobarlo con la función type
type(c)
type(e)

Como veis en Python, a diferencia de muchos otros lenguajes, no se declara el tipo de la variable al crearla. En Java, por ejemplo, escribiríamos:

String c = "Hola Mundo";
int e = 23;

También nos ha servido nuestro pequeño ejemplo para presentaros los comentarios inline en Python: cadenas de texto que comienzan con el carácter ‘#’ y que Python ignora totalmente. Hay más tipos de comentarios, de los que hablaremos más adelante.

Números

Como decíamos, en Python se pueden representar números enteros, reales y complejos.

Enteros

Los números enteros son aquellos que no tienen decimales, tanto positivos como negativos (además del cero). En Python se pueden representar mediante el tipo int (de integer, entero) o el tipo long (largo). La única diferencia es que el tipo long permite almacenar números más grandes. Es aconsejable no utilizar el tipo long a menos que sea necesario, para no malgastar memoria.

El tipo int de Python se implementa a bajo nivel mediante un tipo long de C. Y dado que Python utiliza C por debajo, como C, y a diferencia de Java, el rango de los valores que puede representar depende de la plataforma. En la mayor parte de las máquinas el long de C se almacena utilizando 32 bits, es decir, mediante el uso de una variable de tipo int de Python podemos almacenar números de -2³¹ a 2³¹ – 1, o lo que es lo mismo, de -2.147.483.648 a 2.147.483.647. En plataformas de 64 bits, el rango es de -9.223.372.036.854.775.808 hasta 9.223.372.036.854.775.807.

El tipo long de Python permite almacenar números de cualquier precisión, limitado por la memoria disponible en la máquina.

Al asignar un número a una variable esta pasará a tener tipo int, a menos que el número sea tan grande como para requerir el uso del tipo long.

# type(entero) daría int
entero = 23

También podemos indicar a Python que un número se almacene usando long añadiendo una L al final:

# type(entero) daría long
entero = 23L

El literal que se asigna a la variable también se puede expresar como un octal, anteponiendo un cero:

# 027 octal = 23 en base 10
entero = 027

o bien en hexadecimal, anteponiendo un 0x:

# 0x17 hexadecimal = 23 en base 10
entero = 0x17

Reales

Los números reales son los que tienen decimales. En Python se expresan mediante el tipo float. En otros lenguajes de programación, como C, tenemos también el tipo double, similar a float pero de mayor precisión (double = doble precisión). Python, sin embargo, implementa su tipo float a bajo nivel mediante una variable de tipo double de C, es decir, utilizando 64 bits, luego en Python siempre se utiliza doble precisión, y en concreto se sigue el estándar IEEE 754: 1 bit para el signo, 11 para el exponente, y 52 para la mantisa. Esto significa que los valores que podemos representar van desde ±2,2250738585072020 x 10^-308 hasta ±1,7976931348623157×10³⁰⁸.

La mayor parte de los lenguajes de programación siguen el mismo esquema para la representación interna. Pero como muchos sabréis esta tiene sus limitaciones, impuestas por el hardware. Por eso desde Python 2.4 contamos también con un nuevo tipo Decimal, para el caso de que se necesite representar fracciones de forma más precisa. Sin embargo este tipo está fuera del alcance de este tutorial, y sólo es necesario para el ámbito de la programación científica y otros relacionados. Para aplicaciones normales podeis utilizar el tipo float sin miedo, como ha venido haciéndose desde hace años, aunque teniendo en cuenta que los números en coma flotante no son precisos (ni en este ni en otros lenguajes de programación).

Para representar un número real en Python se escribe primero la parte entera, seguido de un punto y por último la parte decimal.

real = 0.2703

También se puede utilizar notación científica, y añadir una e (de exponente) para indicar un exponente en base 10. Por ejemplo:

real = 0.1e-3

sería equivalente a 0.1 x 10^-3 = 0.1 x 0.001 = 0.0001

Complejos

Los números complejos son aquellos que tienen parte imaginaria. Si no conocías de su existencia, es más que probable que nunca lo vayas a necesitar, por lo que puedes saltarte este apartado tranquilamente. De hecho la mayor parte de lenguajes de programación carecen de este tipo, aunque sea muy utilizado por ingenieros y científicos en general.

En el caso de que necesitéis utilizar números complejos, o simplemente tengáis curiosidad, os diré que este tipo, llamado complex en Python, también se almacena usando coma flotante, debido a que estos números son una extensión de los números reales. En concreto se almacena en una estructura de C, compuesta por dos variables de tipo double, sirviendo una de ellas para almacenar la parte real y la otra para la parte imaginaria.

Los números complejos en Python se representan de la siguiente forma:

complejo = 2.1 + 7.8j

Operadores

Veamos qué podemos hacer con nuestros números usando los operadores por defecto. Para operaciones más complejas podemos recurrir al módulo math.

Operadores aritméticos

Puede que tengáis dudas sobre cómo funciona el operador de módulo, y cuál es la diferencia entre división y división entera.

El operador de módulo no hace otra cosa que devolvernos el resto de la división entre los dos operandos. En el ejemplo, 7 / 2 sería 3, con 1 de resto, luego el módulo es 1.

La diferencia entre división y división entera no es otra que la que indica su nombre. En la división el resultado que se devuelve es un número real, mientras que en la división entera el resultado que se devuelve es solo la parte entera.

No obstante hay que tener en cuenta que si utilizamos dos operandos enteros, Python determinará que queremos que la variable resultado también sea un entero, por lo que el resultado de, por ejemplo, 3 / 2 y 3 // 2 sería el mismo: 1.

Si quisiéramos obtener los decimales necesitaríamos que al menos uno de los operandos fuera un número real, bien indicando los decimales

r = 3.0 / 2

o bien utilizando la función float (no es necesario que sepais lo que significa el término función, ni que recordeis esta forma, lo veremos un poco más adelante):

r = float(3) / 2

Esto es así porque cuando se mezclan tipos de números, Python convierte todos los operandos al tipo más complejo de entre los tipos de los operandos.

Operadores a nivel de bit

Si no conocéis estos operadores es poco probable que vayáis a necesitarlos, por lo que podéis obviar esta parte. Si aún así tenéis curiosidad os diré que estos son operadores que actúan sobre las representaciones en binario de los operandos.

Por ejemplo, si veis una operación como 3 & 2, lo que estais viendo es un and bit a bit entre los números binarios 11 y 10 (las representaciones en binario de 3 y 2). El operador and (&), del inglés “y”, devuelve 1 si el primer bit operando es 1 y el segundo bit operando es 1, luego el resultado de aplicar and bit a bit a 11 y 10 sería 10, o lo que es lo mismo, 2 en decimal (el primer dígito es 1 para ambas cifras, mientras que el segundo es 1 sólo para una de ellas).

El operador or (|), del inglés “o”, devuelve 1 si el primer operando es 1 o el segundo operando es 1

El operador xor u or exclusivo (^) devuelve 1 si uno de los operandos es 1 y el otro no lo es.

El operador not (~), del inglés “no”, sirve para negar uno a uno cada bit; es decir, si el operando es 0, cambia a 1 y si es 1, cambia a 0.

Por último los operadores de desplazamiento (<< y >>) sirven para desplazar los bits n posiciones hacia la izquierda o la derecha.

Cadenas

Las cadenas no son más que texto encerrado entre comillas simples (‘cadena’) o dobles (“cadena”). Dentro de las comillas se pueden añadir caracteres especiales escapándolos con ‘\’, como ‘\n’, el carácter de nueva línea, o ‘\t’, el de tabulación.

Una cadena puede estar precedida por el carácter ‘u’ o el carácter ‘r’, los cuales indican, respectivamente, que se trata de una cadena que utiliza codificación Unicode y una cadena raw (del inglés, cruda). Las cadenas raw se distinguen de las normales en que los caracteres escapados mediante la barra invertida (\) no se sustituyen por sus contrapartidas. Esto es especialmente útil, por ejemplo, para las expresiones regulares.

unicode = u"äóè"
raw = r"\n"

También es posible encerrar una cadena entre triples comillas (simples o dobles). De esta forma podremos escribir el texto en varias líneas, y al imprimir la cadena, se respetarán los saltos de línea que introdujimos sin tener que recurrir al carácter \n, así como las comillas sin tener que escaparlas.

Las cadenas también admiten operadores como la suma (concatenación de cadenas) y la multiplicación.

a = "uno"
b = "dos"

c = a + b # c es "unodos"
c = a * 3 # c es "unounouno"

Booleanos

Como decíamos el tipo booleano sólo puede tener dos valores: True (cierto) y False (falso). Estos valores son especialmente importantes para las expresiones condicionales y los bucles, como veremos más adelante.

En realidad el tipo bool (el tipo de los booleanos) es una subclase del tipo int. Puede que esto no tenga mucho sentido para tí si no conoces los términos de la orientación a objetos, que veremos más adelantes, aunque tampoco es nada importante.

Estos son los distintos tipos de operadores con los que podemos trabajar con valores booleanos, los llamados operadores lógicos o condicionales:

Los valores booleanos son además el resultado de expresiones que utilizan operadores relacionales (comparaciones entre valores):

Además de estos tipos de datos básicos también tenemos matrices, matrices asociativas o hashes, en las que se accede a una posición de la matriz a través de una clave en forma de cadena en lugar de un índice que indique su posición en la matriz; funciones y objetos, que funcionan como una especie de matrices asociativas.

En JavaScript, al igual que ocurre en otros lenguajes como Lisp, la definición de los tipos de los datos se hace de forma dinámica, es decir, una variable no está limitada a contener el tipo de dato que se indicó al declarar la variable, sino que puede contener primero un número, y mas tarde pasar a contener una cadena de texto, por ejemplo. De hecho en JavaScript al declarar las variables (con la palabra clave var) no se define un tipo para esa variable.

En Java o C++, por ejemplo, para declarar e inicializar variables haríamos algo parecido a esto:

int miNumero=7;
String miCadena="Hola Mundo";

es decir, indicamos el tipo de la variable, el nombre y su valor. Sin embargo en JavaScript se usaría:

var miVariable=7;
miVariable="Hola Mundo";

indicando simplemente el nombre y el valor de inicio, sin necesidad de especificar el tipo de la variable.

Podríamos, incluso, prescindir totalmente de declarar la variable, ya que, si al intentar asignar un valor a una variable, JavaScript comprueba que esta no ha sido declarada, este la declarará automáticamente:

miNumero=7;
miCadena="Hola Mundo";

Por último, en Javascript también se pueden declarar constantes como en C++ o Java, mediante la palabra clave const:

const pi = 3.14159;