Taller de Introducción a Python

El objetivo de este taller es ofrecer una pequeña introducción práctica a todos aquellos que no conozcan Python y quieran iniciarse en este lenguaje de programación.

Forma de trabajar

• Se realizarán grupos de 3 personas siempre que sea posible, intentando que aquellos que tengan más conocimientos se junten con los que tengan poco o ninguno.
• El trabajo se dividirá en iteraciones, donde en cada una de ellas el grupo tratara de resolver un pequeño poblema, que será más complejo conforme avancen las iteraciones.

Iteración #0: Instalación de Python 3

Desde el código fuente

$ wget https://www.python.org/ftp/python/3.5.2/Python-3.5.2.tgz
$ tar xf Python-3.5.2.tgz
$ cd Python-3.5.2
$ ./configure
$ make
$ sudo make install

macOS

Usando Homebrew

$ brew install python3

Comprobar que funciona correctamente:

$ python
Python 3.5.2 (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>

Iteración #1: Hello world

Desde el propio intérprete:

>>> print("Hello world!")

Desde un fichero, por ejemplo hello.py, con el siguiente contenido:

print("Hello world!")

Lo ejecutamos:

$ python hello.py
Hello world!

Iteración #2: Creación de un virtualenv

Usando el módulo venv de Python 3:

$ python -m venv myvenv

Usando el paquete virtualenvwrapper:

$ sudo pip install virtualenv virtualenvwrapper

Para que funcione correctamente hay que añadir lo siguiente al fichero .bashrc:

export WORKON_HOME=$HOME/.virtualenvs
source /usr/bin/virtualenvwrapper.sh

Y lo recargamos .bashrc:

$ source ~/.bashrc

Ahora podemos usar el comando mkvirtualenv para crear el viertualenv

$ mkvirtualenv myvenv
(myvenv) $

Iteración #4: Números

Aprendamos a usar Python como si de una calculadora se tratara.

• + suma
• - resta
• / división
• * multiplicación
• % módulo
• < menor que
• > mayor que
• <= menor o igual que
• >= mayor o igual que

Iteración #5: Variables

Guardemos nuestros cálculos, números y lo que queramos en un lugar donde no se pierdan.

>>> cars = 100
>>> space_in_a_car = 4.0
>>> drivers = 30
>>> passengers = 90
>>> cars_not_driven = cars - drivers
>>> cars_driven = drivers
>>> carpool_capacity = cars_driven * space_in_a_car
>>> average_passengers_per_car = passengers / cars_driven

Iteración #6: Cadenas de texto

No sólo se pueden guardar números, también cadenas de texto, y de varias formas distintas.

>>> text = "¡Bienvendio a Python!"
>>> other_text = 'Con comillas simples y comillas dobles funciona igual'
>>> long_text = '''Usando tres comillas simples se pueden
hacer cadenas de más de una línea.'''

>>> name = "Antonio"
>>> text = "Hola %s!" % name
>>> other_text = "¿Qué te trae por aquí, {}?".format(name)
>>> more_options = "Con esto puedes " + "concatenar cadenas"

Iteración #7: Hacer preguntas al usuario

Vamos a obtener datos del usuario:

.. code-block:: python

print("¿Cómo te llamas?") name = input() answer = input("¿Cuál es el sentido de la vida, el universo y todo lo demás?")

Iteración #8: Listas, tuplas y diccionarios

Las listas, tuplas y diccionarios son las estructuras de datos más útiles y usadas en Python.

Listas

Similares a los vectores y arrays en otros lenguaes, son mutables y pueden contener elementos de cualquier tipo.

>>> some_list = []
>>> some_list = list()
>>> list_1 = [1, 2, 3]
>>> list_2 = ["a", "b", "c"]
>>> list_3 = ["a", 1, "b", 2]
>>> nested = [list_1, list_2, list_3]

A los elementos de una lista se puden acceder usando las [], además, se pueden trocear usando los ::

>>> list_1[1]
2
>>> list_2[-1]
"c"
>>> list_2[:2]
["a", "b"]
>>> list_2[1:]
["b", "c"]
>>> list_2[1:2]
["b"]

Tuplas

Similar a las listas, pero son inmutables.

>>> some_tuple = (1, 2, 3)
>>> some_tuple = tuple()
>>> some_tuple = tuple([1, 2, 3])

Se puede acceder a los elementos de una tupla de la misma forma que la lista.

Diccionarios

Los diccionarios son tablas hash, que están indexados por cualquier tipo inmutable, como cadenas de texto o números.

>>> some_dict = {}
>>> some_dict = dict()
>>> other_dict = {"one": 1, "two": 2,  "three": 3}

>>> "one" in other_dict
True
>>> other_dict["two"]
2
>>> other_dict["five"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'five'
>>> "five" in other_dict
False

Iteración #9: Condiciones

cats = input("¿Cuantos gatos tienes?")
if cats < 2:
    print("Igual está muy solo")
elif cats == 2:
    print("¡Es el número perfecto!")
elif 2 < cats <= 5:
    print("¿Seguro que puedes cuidarlos a todos bien?")
else:
    print("No te diré yo que son demasiados... pero...")

Operadores booleanos

• or
• and
• not

La evaluación de [], (), "" y None siempre resulta en False.

Iteración #10: Bucles

Bucle for

>>> for number in range(5):
        print(number)
0
1
2
3
4
5
>>> a_dict = {"one":1, "two":2, "three":3}
>>> for key in a_dict:
        print(key)
"three"
"two"
"one"

Bucle while

>>> i = 0
>>> while i < 10:
        print(i)
        i += 1
0
1
2
3
4
5
6
7
8
9

Iteración #11: Compresiones

Copresión de listas

>>> x = ['1', '2', '3', '4', '5']
>>> y = [int(i) for i in x]
>>> y
[1, 2, 3, 4, 5]
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Copresión de diccionarios

>>> d = {i: str(i) for i in range(5)}
>>> print(d)
{0: '0', 1: '1', 2: '2', 3: '3', 4: '4'}

Iteración #12: Manejando excepciones

other_dict = {"one": 1, "two": 2,  "three": 3}
key = "five"
try:
    other_dict[key]
except KeyError:
    print("La calve %s no existe en el diccionario" % key)
else:
    print("La calve %s se ha encontrado en el diccionario" % key)
finally:
    print("¡Y seguimos ejecutando!")

Excepciones comunes

• Exception
• AttributeError
• IOError
• ImportError
• IndexError
• KeyError
• KeyboardInterrupt
• NameError
• OSError
• SyntaxError
• TypeError
• ValueError
• ZeroDivisionError

Iteración #13: Trabajando con ficheros

with open("test.txt") as file_handler:
    for line in file_handler:
        print(line)

Iteración #14: Módulos y paquetes

• Cada fichero .py es un módulo
• Una carpeta con un fichero llamado __init__.py es un paquete

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

>>> import math
>>> math.sqrt(4)
2.0

>>> from math import sqrt
>>> sqrt(16)
4.0

Iteración #15: Funciones

La forma más sencilla de una función:

>>> def cool_function():
        print("!He hecho una función!")
>>> cool_function()
!He hecho una función!

Una función devuelve un valor:

>>> def cool_function():
        return 40 + 2
>>> cool_function()
42

Puede tener argumentos:

>>> def cool_function(a, b):
        return a + b
>>> cool_function(40, 2)
42
>>> cool_function(b=2, a=40)
42

Y puede tener argumentos variables:

>>> def cool_function(*args, **kwargs):
        print(args)
        print(kwargs)
>>> cool_function(1, 2, c=3, d=4)
(1, 2)
{"c": 3, "d": 4}

Iteración #16: Clases

Todo en Python es un objeto, es decir, todo en Python tiene atributos y métodos.

class Vehicle:

    def __init__(self, color):
        self.color = color

    def brake(self):
        return "¡Frenando!"

>>> car = Vehicle(color="red")
>>> car.brake()
¡Frenando!

• Las "funciones" __init__ y brake no son realmente functiones, son métodos de la clase.
• En self.color se está guardando el color como atributo.
• En car = Vehicle(color="red") se está creando una instancia de la clase.
• El método __init__ es el inicializador de la clase, se llama siempre que se crea una nueva instancia.
• El atributo self hace referencia siempre a una instancia de la clase.

Subclases

Las subclases son especializaciones de otras clases, que añade y/o sobreescribe métodos.

class Car(Vehicle):

    def brake(self):
        return "¡Frenando más despacio!"

>>> car = Car(color="red")
>>> car.brake()
¡Frenando más despacio!