Instalación de Material

Los proyectos de esta clase utilizan Python 3. Este tutorial cubre:

• Instrucciones sobre cómo configurar Python
• Un tutorial de Python mini

Instalación de Python

Necesitan una distribución de Python (3.9 - 3.11) y ya sea pip o conda.

Para verificar si cumplen con nuestros requisitos, deben abrir la terminal y ejecutar python -V y ver que la versión sea al menos 3.9. Luego, ejecuten pip -V o conda -V y vean que al menos uno de estos funcione e imprima alguna versión de la herramienta. En algunos sistemas que también tienen Python 2, es posible que deban usar python3 y pip3 en lugar de los mencionados anteriormente.

Hay dos formas de instalar Python para este curso, la primera es descargarlo directamente desde el sitio web oficial. La segunda, que recomendamos encarecidamente, es configurar un entorno conda.

Configurando un entorno Conda (Recomendado)

Para evitar tener dependencias conflictivas entre esta clase y cualquier otro proyecto en el que trabaje, recomendamos configurar un entorno virtual para este curso. Esto facilita la instalación de dependencias y evita la mayoría de los problemas comunes de instalación.

1. Instalar Miniconda: Miniconda es una herramienta ligera que le permite crear entornos virtuales, así como le da acceso a pip y algunos paquetes esenciales de Python.
2. Corran conda create -n [nombre de su entorno] python=3.11 en su terminal/Anaconda Prompt
3. Activen el entorno con conda activate [nombre de su entorno]. Ahora que están en el entorno, cualquier dependencia que instalen solo será accesible dentro de su entorno virtual.

Ahora que tienen un entorno virtual configurado, asegúrense de activarlo antes de instalar cualquier dependencia o ejecutar su proyecto. Si alguna vez olvidan el nombre de su entorno, ejecuten conda env list para obtener una lista completa de los entornos que han creado.

Descargando Python directamente

Nota: Este método es más probable que cause problemas de dependencia, y también es más difícil resolver esos problemas cuando surgen.

1. Instalar Python 3.11:
   • Para Windows y MacOS, recomendamos usar un instalador gráfico oficial: descarguen e instalen Python 3.11.
   • Para Linux, usen un administrador de paquetes para instalar Python 3.11.
2. Instalar Pip:
   • Para Windows y MacOS, ejecuten python -m ensurepip --upgrade.
   • Para Linux, usen un administrador de paquetes para instalar Pip para Python 3.

Instalación de Dependencias

Algunos proyectos tienen dependencias adicionales. Es importante instalarlas ahora para que si hay un problema con la instalación de Python, no tengamos que volver o volver a hacer la instalación más tarde.

Las libreriras que necesitarán para este curso son:

• numpy: Una librería de Python que proporciona soporte para arreglos y matrices multidimensionales, junto con una colección de funciones matemáticas de alto nivel para operar en estos arreglos.
• matplotlib: Una librería de Python para trazar gráficos 2D.

Para instalar estas dependencias, ejecuten:

pip install numpy
pip install matplotlib

Para comprobar que todo está funcionando, ingresen al intérprete de Python:

python

y ejecuten:

import numpy as np
import matplotlib.pyplot as plt

Solución de Problemas

Algunas instalaciones tendrán python3 y pip3 refiriéndose a lo que queremos usar. Además, puede haber múltiples instalaciones de python que pueden complicar qué comandos instalan dónde.

Pueden verificar la instalación de Python y pip con los siguientes comandos:

python -V # version de python
pip -V # version de pip y para que version de python esta instalando
which python # ubicacion de python

Si hay un error de importación de tkinter, es probable que Python sea atípico y provenga de homebrew. Desinstalen eso e instalen Python desde homebrew con soporte para tkinter, o usen el instalador gráfico recomendado.

Si necesitan ayuda con la depuración, intenten configurar un entorno conda antes de comunicarse a través de Slack, ya que hacer esto soluciona la mayoría de los errores de instalación.

Tutorial de Python

El objetivo de este tutorial es que ustedes puedan aprender sobre lo básico de Python 3, no esperamos que se vuelvan expertos con esta introducción. En este curso no es fundamental que dominen al 100% este lenguaje de programación y realmente solo necesitan conocer lo básico para poder completar satisfactoriamente los proyectos.

Introducción

Python es un lenguaje de programación multiparadigma y con tipos dinámicos. El código escrito en Python se dice que es similar al pseudocódigo, ya que permite expresar ideas bastante poderosas en muy pocas líneas de código y al mismo tiempo ser bastante leíble. Como ejemplo, aquí hay una implementación del clásico algoritmo quicksort escrito en Python:

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))

Tipos de datos básicos

Como en muchos lenguajes, Python tiene un número de tipos de datos básicos incluyendo enteros, floats, booleans y strings. Estos tipos de datos se comportan como lo han visto en otros lenguajes de programación.

Números

Los enteros y los floats funcionan como ustedes han visto que funcionan en otros lenguajes:

x = 3
print(type(x)) # type: sirve para obtener el tipo de un objeto
print(x)
print(x + 1)
print(x - 1)
print(x * 2)
print(x / 2)   # division exacta
print(x // 2)  # division entera
print(x ** 3)  # exponentes
x += 1
print(x)
x *= 2
print(x)
y = 2.5
print(type(y))
print(y)
print(y + 1)
print(y * 2)
print(y / 2)
print(y ** 2)

Noten que Python no tiene los operadores de incremento unario (x++) o decremento (x—). Python también tiene tipos para manejo de números completos, todo esto lo pueden ver en la documentación oficial.

Booleans

Python implementa todos los operadores usuales para hacer lógica booleana, pero usa palabras en Inglés en vez de símbolos (&&, ||, etc.):

t = True
f = False
print(type(t))
print(t and f) # AND lógico
print(t or f)  # OR lógico
print(not t)   # NOT lógico
print(t != f)  # XOR lógico

Strings

Python tiene buen soporte de strings:

hello = 'hello'           # las literales string pueden ser declaradas con apóstofre
world = "world"           # o comillas, no importa la verdad...
print(hello)
print(len(hello))         # con len obtenemos el length del string
hw = hello + ' ' + world  # concatenación, así como en Java
print(hw)
hw12 = '%s %s %d' % (hello, world, 12) # formato de texto al estilo sprintf
print(hw12)

Los objetos de tipo string tienen un montón de métodos útiles; Por ejemplo:

s = 'hello'
# Pone la letra del principio en mayuscula
print(s.capitalize())
# Pasa el string a mayusculas
print(s.upper())
# Justifica un string, rellenando con espacios
print(s.rjust(7))
# Centra un string, rellanando con espacios
print(s.center(7))
# Reemplaza todas las apariciones de un substring por otro
print(s.replace('l', '(ell)'))
# Quita todos los caracteres de whitespace del principio y final
print('  world '.strip())

Pueden encontrar una lista de todos los métodos en la documentación.

Contenedores

Python incluye bastantes tipos de contenedores: listas, diccionarios, sets y tuplas.

Listas

Una lista en Python es equivalente a un arreglo en C o Java, pero es dinámico (puede cambiar su tamaño, es decir no es fijo) y puede tener elementos de diferentes tipos:

# Crea una lista
xs = [3, 1, 2]
print(xs)
# Para acceder a un elemento de la lista, los indices van de 0 a length - 1
print(xs[1])
# Los indices negativos empiezan desde el final de la lista
print(xs[-1])
# Las listas pueden contener elementos de diferentes tipos
xs[2] = 'foo'
print(xs)
# Añade un elemento al final de la lista
xs.append('bar')
print(xs)
# Quita y devuelve el último elemento de la lista
x = xs.pop()
print(x, xs)
# para obtener el length de la lista
print(len(xs))

Puden encontrar más detalles en la documentación de listas.

Slicing

Además de acceder a los elementos de una lista uno a la vez, Python provee una sintaxis para acceder a sublistas, a esto se le conoce como slicing:

# Creamos una nueva lista
nums = [0, 1, 2, 3, 4]
print(nums)
# Agarra una sublista desde el indice 2 hasta el indice 3 es decir [2,4)
print(nums[2:4])
# Agarra una sublista desde el indice 2 hasta el final de la lista, es decir [2,4]
print(nums[2:])
# Agarra una sublista desde el principio de la misma hasta el indice 2 sin incluir, es decir [0,2)
print(nums[:2])
# Agarra toda la lista "[0, 1, 2, 3, 4]"
print(nums[:])
# El slice puede ser negativo, en este caso agarra desde el principio hasta el penultimo elemento, es decir [0,3]
print(nums[:-1])
# Asigna una sublista al slice
nums[2:4] = [8, 9]
print(nums)

Ciclos

Pueden iterar sobre elementos de una lista de la siguiente manera:

animals = ['cat', 'dog', 'monkey']
for animal in animals:
    print(animal)

Si quieren acceder al indice de cada elemento dentro del ciclo, pueden utilizar la funcion “enumerate”:

animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))

Listas por comprensión

Cuando estamos programando, frecuentemente vamos a querer transformar un tipo de dato hacia otro. Como un ejemplo simple, consideren el siguiente código que calcula numeros al cuadrado:

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x ** 2)
print(squares)

Las list comprehension pueden contener condiciones:

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares)

Diccionarios

Un diccionario guarda un par (key, value), similar a un Map en java. Pueden utilizarlo así:

# crea un nuevo diccionario con algunos datos
d = {'cat': 'cute', 'dog': 'furry'}
# toma el valor del key 'cat'
print(d['cat'])
# verifica que el key 'cat' este en el diccionario d
print('cat' in d)
# añade un par key, value al diccionario d
d['fish'] = 'wet'
print(d['fish'])
# el key 'monkey' no existe, pero podemos poner un valor por defecto, en este caso N/A
print(d.get('monkey', 'N/A'))
# como fish existe no imprime el valor por defecto
print(d.get('fish', 'N/A'))
# podemos eliminar elementos del diccionario
del d['fish']
# come fish lo quitamos y ya no existe, tiene que devolver el valor por defecto
print(d.get('fish', 'N/A'))

Pueden encontrar todo lo que necesitan saber de diccionarios en la documentación.

Ciclos

Es fácil iterar sobre las keys de un diccionario:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))

Si quieren acceder a las keys y a los valores de un diccionario, pueden utilizar el método “items”:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))

Diccionarios por comprensión

Estos son similares a las list comprehensions, pero ayuda a construir diccionarios fácilmente, por ejemplo:

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)

Sets

Un set es un la colección no ordenada de elementos distintos. Como ejemplo simple, consideren lo siguiente:

animals = {'cat', 'dog'}
# Verifica que un elemento este en el set
print('cat' in animals)
print('fish' in animals)
# Añade un elemento al set
animals.add('fish')
print('fish' in animals)
# Numero de elementos en un set
print(len(animals))
# Añadir un elemento que ya esta en el set, lo permite pero no pasa nada
animals.add('cat')
print(len(animals))
# Remueve un elemento del set
animals.remove('cat')
print(len(animals))

Otra vez, todo lo que quieran saber acerca de los sets lo pueden encontrar en la documentación.

Ciclos

Iterear sobre un set tienen la misma sintaxis que iterar sobre una lista, sin embargo como los sets no tienen orden, no pueden asumir sobre en que orden se van a visitar los elementos del set:

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))

Set comprehensions

Como las listas y los diccionarios, podemos construir sets fácilmente utilizando set comprehensions:

from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums)

Tuplas

Una tupla es una lista ordenada de elementos “fija”. Una tupla es bastante similar a una lista, una de las más importantes diferencias es que las tuplas se pueden utilizar como keys en un diccionario y como elementos de los sets, mientras que las listas no. Aquí hay un ejemplo:

# Crea un diccionario con keys de tuplas
d = {(x, x + 1): x for x in range(10)}
# Crea una tupla
t = (5, 6)
print(type(t))
print(d[t])
print(d[(1, 2)])

La documentación tiene mas información acerca de las tuplas.

Funciones

Las funciones de Python se definen utilizando el keyword def. Por ejemplo:

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))

Vamos a definir funciones que toman argumentos, y opcionalmente argumentos keyword, como esto:

def hello(name, loud=False):
    if loud:
        print('HELLO, %s' % name.upper())
    else:
        print('Hello, %s!' % name)

hello('Bob')
hello('Fred', loud=True)

Hay mucha información acerca de como definir funciones en Python en la documentación.

Funciones Lambda

Python tiene una sintaxis definida para funciones anónimas, lambda functions, están son bastante utiles para pasarlas como argumento a otras funciones:

# importamos la funcion reduce
from functools import reduce
# definimos una funcion anonima y se la asignamos a una variable x
x = lambda l: l ** 2
# podemos usar la funcion anonima como cualquier otra funcion
print(x(2))
# pero lo mas importante es que la podemos pasar como argumento
def foo(f):
    return f(4)
print(foo(lambda x: x + 1))
# aunque esto no implica que con las funciones normales puedan hacer esto...
def bar(x):
    return x ** 2
print(foo(bar))
# por lo general se utilizan con las funciones map, reduce y filter de python que trabajan con listas
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
print(list(filter(lambda x: x > 2, [1, 2, 3, 4, 5])))
print(reduce(lambda a, b: a + b, [1, 2, 3, 4, 5]))

Clases

La sintaxis para definir clases en Python es bastante simple:

class Greeter:

    # Constructor
    def __init__(self, name):
        self.name = name  # Crea un atributo para la clase

    # Un metodo de la clase
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)


# Crea una instancia de la clase
g = Greeter('Fred')
# Llama al metodo de la clase; imprime "Hello, Fred"
g.greet()
# Llama al metodo de la clase; imprime "HELLO, FRED!"
g.greet(loud=True)

Con esto concluimos el tutorial de Python 3, pueden obtener más información en la documentación de Python 3 oficial o incluso seguir el tutorial completo que ellos tienen.