Vamos a hacer una pequeña introducción al lenguaje de programación Python. Para ello, me voy a apoyar principalmente en dos excelentes recursos para aprender Python online que siempre recomiendo:
Esto es un cuaderno de Jupyter compuesto de una serie de celdas de distintos tipos. Esta primera celda contiene texto formateado. Para ver el código (y editarlo, si es necesario), haz doble clic sobre ella y verás el código Markdown.
La siguiente celda, por el contrario, contiene código en Python. Para ejecutarla y ver cómo funciona, selecciónala y pulsa ctrl-ENTER:
In [1]:
print('Esto es un mensaje')
En los lenguajes de programación, una variable es un tipo de identificador que almacena o al que se le asigna un determinado valor. Este valor puede ser de distinto tipo, como veremos más adelante. Para asignar valores a variables, utilizamos el signo = con la siguiente sintaxis:
nombre_de_variable = valor
Veamos un ejemplo: vamos a declarar distintas variables, asignándoles valores:
In [2]:
# NOTA: en Python, las líneas que comienzan con # son comentarios
# El intérprete no las lee. Los humanos sí deberíamos leerlas :-)
mivariable = 34
edad = 25
year = 1992
En Python podemos utilizar como nombre de variable cualquier secuencia de caracteres alfanuméricos, siempre que comience por una letra del alfabeto y no sea una palabra reservada por el propio lenguaje (típicamente, nombres de funciones y palabras clave).
Una vez que hemos asignado valores a nombres de variables, podemos utilizar o recuperar esos valores siempre que lo necesitemos.
Para hacer una pequeña prueba, vamos a imprimir por pantalla el valor de las variables declaradas anteriormente. Para imprimir por pantalla, usamos la función print.
In [3]:
print(mivariable)
print(year)
print('mivariable')
print('year')
print('El niño come manzanas.')
print(255666)
In [4]:
# esta celda dará error, al menos mientras no declaremos la variable llamada otraVariable
print(otraVariable)
En el ejemplo anterior, hemos declarado tres variables diferentes. Sin embargo, el tipo de dato que estábamos almacenando era el mismo: simples números enteros.
Como hemos mencionado antes, las variables pueden almacenar distintos tipos de datos. Los principales que vamos a utilizar nosotros son:
True, FalseVeamos cómo funcionan.
In [5]:
# números enteros (integer)
hijos = 3
# números reales (float), siempre indicando los decimales con punto
precio = 350.25
longitud = 1.5
# cadenas de texto (string), siempre entre comillas simples o dobles
nombre = "Pedro"
apellidos = 'Sanz Hernández'
# valores booleanos (bool): solo pueden ser True o False, escritos tal cual sin comillas
animal = True
mineral = False
In [6]:
# imprimimos algunos de ellos por pantalla
print(hijos)
print("Me llamo", nombre, apellidos) # fíjate cómo puedo imprimir más de una cosa con la función print
print(precio)
print(mineral)
Los valores que contienen las variabes pueden ser reasignados en cualquier momento. Eso sí, solo almacenan el último valor que hayamos asignado.
Si reasignamos algunas de las variables declaradas anteriormente e imprimimos sus valores por pantalla, comprobamos que éstos han cambiado:
In [7]:
nombre = 'Ana'
apellidos = 'Serrano de la Oca'
print(nombre, apellidos)
Podemos utilizar el intérprete de Python como una calculadora. Basta con introducir operaciones aritméticas como operadores que seguramente ya conoces: suma (+), resta (-), multiplicación (*), división (/), potencias (**) y módulo (%). Vamos a imprimir por pantalla el resultado de algunas operaciones.
In [8]:
#suma
print(5+6)
# resta
print(10-3)
# multiplicación
print(25*6)
# división
print(2558/800000)
# potencias
print(2**3)
# módulo hace referencia al resto de la división 10/2.
print(10%2)
print(6+5+12*2)
print((6+5+12)*2)
print(6+5+(12*2))
Si retomamos lo aprendido anteriormente acerca de las variables, veremos que podemos declarar variables a partir de operaciones matemáticas, por ejemplo:
In [9]:
# una suma sencilla
suma = 9+5
print(suma)
In [10]:
# calculamos el área de un cuadrado
lado = 1.5
area = lado**2 # es equivalente a lado*lado
print(area)
In [11]:
# vamos a calcular el precio final de un producto cuyo valor es 19,95€
iva = 21
precio = 19.95
precio_final = precio + (precio * iva)/100
print(precio_final)
In [12]:
# calculamos la edad actual de una persona
ahora = 2016
fechaNacimiento = 1985
edad = ahora - fechaNacimiento
print(edad)
Si nuestro objetivo es aprende a programar en Python para procesar texto, las cadenas de caracteres van a ser el principal tipo de dato que vamos a manejar. Como hemos visto antes, las cadenas se identifican en Python porque se declaran entre comillas dobles ("cadena") o simples ('cadena') o, si las cadenas son muy largas y ocupan más de una línea, entre triples pares de comillas.
Algunos ejemplos de cadenas:
In [13]:
nombre = "Godofredo de Orléans"
oracion = 'GREEN COLORLESS IDEAS SLEEP FURIOUSLY'
parrafo = '''En un lugar de la Mancha, de cuyo nombre no quiero acordarme,
no ha mucho tiempo que vivía un "hidalgo" de los de lanza en astillero,
adarga antigua, rocín flaco y galgo corredor. Una olla de algo más vaca
que carnero, salpicón las más noches, duelos y quebrantos los sábados,
lentejas los viernes, algún palomino de añadidura los domingos, consumían
las tres partes de su hacienda.'''
¡OJO! Podemos definir como valores de variables cadenas formadas por secuencias de números, siempre que se declaren entre comillas. Es muy importante entender la diferencia entre:
In [14]:
numero1 = 45852236
numero2 = '45852236'
# podemos realizar operaciones aritméticas entre números
print(numero1 + 1)
# pero no entre cadenas y números: esto da un error
print(numero2 + 1)
In [15]:
# sin embargo, sí puedo utilizar el operador '+' para concatenar varias cadenas
print(numero2 + '1')
print('¡Hola' + ' ' + 'amigo!')
print("otra", "vez " * 3)
print("otra" + "vez" * 3)
In [16]:
# guardamos en numero1 un entero
numero1 = 45852236
# en numero2, guardamos el valor de numero1 convertido a cadena de texto con la función str()
numero2 = str(numero1)
# con la función type() imprimimos por pantalla el tipo de dato que guarda una variable
print(type(numero1)) # es un entero: int
print(type(numero2)) # es una cadena: str
print("\nOtros tipos de datos son:")
print(type(2.3))
print(type(True))
print(type(""))
Para hacer el paso contrario, es decir, transformar cadenas en enteros, podemos utilizar la función int().
In [17]:
# guardamos en numero1 una cadena
numero1 = '45852236'
# en numero2, guardamos el valor de numero1 convertido a entero con la función int()
numero2 = int(numero1)
# con la función type() imprimimos por pantalla el tipo de dato que guarda una variable
print(type(numero1)) # es una cadena: str
print(type(numero2)) # es un entero: int
# esto no va a funcionar :-/ no podemos convertir cadenas a enteros
otracosa = "hola amigo"
print(int(otracosa))
Recuerda, cualquier secuencia alfanumérica encerrada entre comillas será tratada como una cadena de caracteres (string) aunque esté formada únicamente por dígitos.
Existe una serie de funciones y metodos que podemos ejecutar sobre cadenas de texto y que nos van a permitir realizar operaciones y transformar dichas cadenas de distintas maneras, p. ej.:
len()) .upper()) o minúsculas (.lower())Para más info, consulta los métodos que podemos aplicar a las cadenas.
In [18]:
print(len(nombre))
print(len(oracion))
print(len(parrafo))
In [19]:
print(len(nombre)) # devuelve la longitud (en número de caracteres) de una cadena
print(oracion.lower()) # transforma una cadena a minúsculas (lowercas)
print(oracion)
print(parrafo.upper()) # transforma una cadena a mayúsculas (uppercas)
print(parrafo) #
print('AbCdEfGhIjKlMnÑoPqRsTuVwXyZ'.swapcase()) # transforma mayúsculas a minúsculas y viceversa
# incluso funciona con las letras con diacríticos
print("áéíóúüûÁÉÍÓÚÛÜ".swapcase())
Las listas de Python son una estructura de datos que almacenan una colección de diferentes tipos de información en forma de secuencia ordenada, bajo un solo nombre de variable. Las listas pueden guardar valores de cualquiera de los tipos que hemos visto anteriormente (cadenas, números y booleanos) e incluso las listas pueden incluir otras listas de manera anidada.
Las listas se declaran especificando la colección de elementos entre corchetes y separando los elementos con comas:
In [20]:
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
dias = ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"]
misCosas = [23.4, True, oracion.lower(), len(nombre)]
listaVacia = []
# los imprimimos por pantalla
print(numeros)
print(dias)
print(misCosas)
print(listaVacia)
print(type(numeros))
print(len(numeros))
print(len(misCosas))
Las listas son estructuras de datos ordenadas, lo que implica que podemos acceder a los elementos individuales a través de un índice (la posición que ocupa en la secuencia). El índice se especifica indicando el nombre de la lista y un entero entre corchetes: nombre_de_lista[índice].
¡OJO! Los índices de las listas comienzan con 0, no con 1: el primer elemento es nombre_de_lista[0].
In [21]:
print('el primer día de la semana es', dias[0])
print('el tercer día de la semana es ' + dias[2])
print('y el último es', dias[-1])
print('el tercer día de la semana es ' + dias[2] + ' y el sexto día es ' + dias[-2])
print('el tercer día de la semana es', dias[2], 'y el sexto día es', dias[-2])
# podemos utilizar los índices también para reasignar valores a los elementos de una lista
# p. ej., cambiamos el primer valor de la lista misCosas
misCosas[0] = 44
print(misCosas)
# ¡OJO! si intentamos acceder a un índice que no existe, el intérprete nos dará error
print(misCosas[8])
Podemos acceder a porciones de una lista usando una notación especial en los corchetes del índice. nombre_de_lista[n:m] devuelve la secuencia de elementos de la lista que va desde el índice n hasta el m.
In [22]:
# imprime los tres primeros elementos de la variable dias
print(dias[:3])
# imprime elementos del 3º al 6ª de la variable números
print(numeros[2:6])
# imprime los tres últimos números de la variable números
print(numeros[-3:-1])
print(dias[3:5])
Las cadenas, al igual que las listas, son estructuras ordenadas. No lo hemos mencionado antes, pero podemos utilizar esta misma notación de índices para acceder a elementos y a porciones de una cadena.
In [23]:
cadena = 'perrogatorana'
print(cadena[:5])
print(cadena[5:9])
print(cadena[-4:])
# practica los índices en listas y en cadenas, es muy importante tener solutura
In [24]:
pal1 = 'perro'
pal2 = 'soles'
pal3 = 'azul'
pal4 = 'amigos'
pal5 = 'cafés'
pal6 = 'hola'
print(pal1[-1] == 's')
print(pal2[-1] == 's')
print(pal3[-1] == 's')
print(pal4[-1] == 's')
print(pal5[-1] == 's')
print(pal6[-1] == 's')
print("---------------------")
print(pal1.endswith('s'))
print(pal2.endswith('s'))
print(pal3.endswith('s'))
print(pal4.endswith('s'))
print(pal5.endswith('s'))
print(pal6.endswith('s'))
Como con las cadenas, en las listas existen una serie de funciones y métodos que podemos ejecutar y que nos van a permitir realizar operaciones y transformar dichas listas de distintas maneras, p. ej.:
len()..index(). .append()..insert()..remove() y .pop()..extend().Para más info, consulta los métodos que podemos aplicar a las listas.
In [25]:
# creamos una lista vacía
miLista = []
# ¿está realmente vacía?
print(len(miLista))
In [26]:
# ¿qué posición ocupa "jueves" o "domingo" en la lista días
print(dias.index('jueves'))
print(dias.index('domingo'))
# esto, sin embargo, dará error
print(dias.index('DOMINGO'))
In [27]:
miLista = []
# añadimos varios elementos nuevos y vemos cómo va aumentando la lista
miLista.append(2)
print(miLista)
miLista.append('palabra')
print(miLista)
miLista.append(25**3)
print(miLista)
In [28]:
# añadimos como cuarto elemento otra lista de elementos: fíjate en la estructura del resultado
miLista.append(numeros)
print(miLista)
print(len(miLista))
In [29]:
# ¿cuántos elementos tiene miLista?
# estas dos líneas son equivalentes, pero tienen sutiles diferencias.
# aquí, concatenamos con el símbolo + tres cadenas dentro de una misma intrucción print
# uno de los elementos es originariamente un número entero, por eso hay que transformarlo antes con str
print('la lista miLista tiene ' + str(len(miLista)) + ' elementos')
# aquí, imprimimos tres elementos diferentes en una misma instrucción print
print('la lista miLista tiene', len(miLista), 'elementos')
In [30]:
print(miLista)
# insertamos como segundo elemento otro nuevo valor
miLista.insert(1, 'segundo elemento')
print(miLista)
miLista[1] = "second element"
print(miLista)
In [31]:
# más ejemplos con los métodos insert y append
l = []
print(l)
l.append('hola')
print(l)
l.append('adiós')
print(l)
l.insert(1, 'segundo elemento')
print(l)
l.insert(2, 'otra cosa')
print(l)
In [32]:
dias = ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"]
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(dias)
# eliminarmos el elemento 2 y el elemento "palabra" de miLista
dias.pop(2)
print(dias)
In [33]:
dias.remove('sábado')
print(dias)
In [34]:
letras = ['a', 'b', 'c', 'a']
print(letras.count('aaaaa'))
letras.remove('a')
print(letras)
print(letras.count('a'))
In [35]:
# también puedo eliminar el último elemento de la lista
miLista.pop(-1)
print(miLista)
In [36]:
# más pruebas concatenando listas
dias = ["lunes", "martes", "miércoles", "jueves", "viernes", "sábado", "domingo"]
dias.extend(numeros)
print(dias)
# fíjate en que la lista numeros crece de manera indefinida
numeros.extend(dias)
print(numeros)
Las tuplas de Python son una estructura de datos que almacenan una colección de diferentes tipos de información en forma de secuencia ordenada. Estas tuplas pueden guardar valores de cualquiera de los tipos que hemos visto anteriormente (cadenas, números y booleanos) e incluso otras listas o tuplas de manera anidada. La principal diferencia con las listas es que las tuplas son inmutables: no podemos modificarlas, ni añadiendo o eliminando elementos, ni reordenado, etc.
Las tuplas se declaran especificando la colección de elementos entre paréntesis y separando los elementos con comas.
In [37]:
# creo tres tripletas, cada una almacenando el nombre, apellido y sexo de unas personas ficticias
tripleta1 = ("Carlos", "Pujol", "H")
tripleta2 = ("Montse", "Santos", "M")
tripleta3 = ("Ana", "Ruiz", "M")
# creo una lista de personas y añado las tripletas por orden
personas = []
personas.append(tripleta1)
personas.append(tripleta2)
personas.append(tripleta3)
print(personas)
# las tuplas son secuencias ordenadas, y como tales podemos acceder a sus elementos
# a través de índices numéricos
print(len(personas[0]))
print(personas[1][1])
Los diccionarios de Python son una estructura de datos que almacena una colección de pares clave:valor. La clave es siempre una cadena, y el valor puede contener cualquiera de los tipos que hemos visto anteriormente (cadenas, números y booleanos) e incluso otras listas, tuplas o diccionarios de manera anidada. Al contrario que las listas y las tuplas, los diccionarios no son estructuras ordenadas. Por lo tanto, nos interesará utilizar diccionarios cuando necesitamos almacenar y acceder directamente a información cuyo nombre conozcamos.
Podemos definir diccionarios de varias maneras:
In [38]:
# entre llaves, separando claves y valores con dos puntos, y separando pares con comas
victor = {"nombre": "Victor", "apellido": "Peinado", "sexo": "H", "edad": 38}
print(victor)
# declarando el diccionario como una estructura vacía y añadiendo los pares clave:valor después
antonio = {}
antonio["nombre"] = "Antonio"
antonio["apellido"] = "Santos"
antonio["sexo"] = "H"
antonio["edad"] = 26
print(antonio)
# creo una lista de diccionarios: OJO, la lista sí está ordenada
personas = [victor, antonio]
print(personas)
print(type(personas))
print(type(personas[-1]))
print(type(personas[-1]["edad"]))
Podemos acceder a los elementos del diccionaro a través del nombre de la clave:
In [39]:
print(victor['nombre'])
print(antonio['apellido'])
print(personas[1]['nombre'])
Como con otras estructuras de datos, los diccionarios proporcionan una serie de funciones y métodos que podemos ejecutar y que nos van a permitir manipular y acceder a dichos diccionarios de distintas maneras, p. ej.:
len()..keys()..values()..pop().Para más info, consulta los métodos que podemos aplicar a los diccionarios.
In [40]:
# ¿cuántos pares clave:valor tiene el diccionario antonio?
print(len(antonio))
# dame las claves
print(antonio.keys())
# dame los valores
print(antonio.values())
In [41]:
# recuerda que para crear nuevos pares clave:valor, basta con asignarles un valor
antonio['altura'] = 1.79
# podemos comprobar si el diccionario tiene determinadas claves
print('email' in antonio)
print('altura' in antonio)
print(antonio)
In [42]:
# eliminamos la clave altura de antonio
antonio.pop('altura')
print('altura' in antonio) # y esto ahora devuelve False
print(antonio)
Los diccionarios pueden contener otros diccionarios anidados, lo que conlleva que podemos manejar estructuras bastante complejas. A modo de ejemplo:
In [43]:
# creo un diccionario de la familia Pig, en principio vacío
familiaPig = {}
# creo varios diccionarios por cada miembro de la familia
peppa = {"nombre": "Peppa", "apellido": "Pig", "email": "peppa@pig.com",}
george = {"nombre": "George", "apellido": "Pig", "email": "george@pig.com",}
daddy = {"nombre": "Daddy", "apellido": "Pig", "email": "daddy@pig.com",}
mommy = {"nombre": "Mommy", "apellido": "Pig", "email": "mommy@pig.com",}
familiaPig['hija'] = peppa
familiaPig['hijo'] = george
familiaPig['padre'] = daddy
familiaPig['madre'] = mommy
print(familiaPig)
In [44]:
# ¿Cuál es el email de la madre?
print(familiaPig["madre"]["email"])
# ¿Y el nombre de la hija?
print(familiaPig["hija"]["nombre"])
# en lugar de un diccionario, puedo crear también una lista con los miembros de la familia ordenados por edad
familia = [daddy, mommy, peppa, george]
# ahora solo puedo acceder por índices, así que ¿cuál es el email del primer miembro de la familia?
print(familia[0]["email"])
# ¿Y el nombre del miembro más joven?
print(familia[-1]["nombre"])
In [45]:
# esta celda no hace nada, salvo insertar una imagen externa
from IPython.core.display import Image
Image('http://peppapigjuegos.com/img/wallpapers/2pag/peppa_pig_family.jpg')
Out[45]:
In [46]:
pelicula = {}
pelicula['titulo'] = "The Arrival"
pelicula['ano'] = 2016
pelicula['reparto'] = ["Amy Adams", "Jeremy Renner", "Forest Whitaker",]
pelicula['esBuena'] = True
print(pelicula)
print("----------------------------")
# imprime el título
print("La película se titula", pelicula['titulo'], ".")
# y más datos asociados a la peli
print("La película tiene" + str(len(pelicula["reparto"])) + "actores" + ".")
# normalmente no necesitaremos esto, pero aquí hay un ejemplo de cómo formatear
# cadenas complejas con print
print("La película se titula {} y tiene {} actores.".format(pelicula["titulo"], len(pelicula["reparto"])))
# creamos una ficha para una serie
serie = {"titulo": "Narcos", "ano":2015, "reparto":["Uno", "Otro"]}
print(serie)
print(serie["titulo"])
# añadimos más datos
serie["esBuena"] = True
print(serie)
Para simular una colección de películas y series vistas en orden cronológico, creo un lista de Pyhton en la que voy incluyendo las fichas de películas a medida que las voy viendo.
In [47]:
coleccion = []
coleccion.append(serie)
print(coleccion)
coleccion.append(pelicula)
print(coleccion)
# añado una tercera serie, y la meto en la colección
serie = {"titulo": "The Expanse", "ano":2015, "reparto":["Fulano", "Mengano"]}
coleccion.append(serie)
print(coleccion)