Python

Introducción

En menos de 5 minutos*

* (a.k.a. descarado resumen de Wikipedia)

Python:

• En vigencia desde los 90's
• Tipado dinámico
• Garbage Collector
• Multi-paradigma (!!!)
• Multi-plataforma (¡con pocos o ningún™ cambio!)
• Sintaxis y filosofía del desarrollo 'estrictas' (no difíciles)
• Extendible con C(++)
• Por lo dicho anteriormente, perfecto para todo tipo de personas (tú incluido)

Guido Van Rossum, creador de Python, circa 2006 (ahora está
más viejo y gordo, además de trabajar en Dropbox)

Usan Python

Entre otros...

Bootstrap

La serpiente y tú

Bootstrap

https://python.org/downloads

Actualmente, se mantienen dos versiones mayores del lenguaje: Py2 y Py3K.

Y, aunque no son (muy) compatibles entre sí, la versión 2 tiene el suelo más amplio y será la que usaremos para este curso.

Bootstrap

Los scripts de Python son ejecutados a través de un intérprete.

$ python miscript.py

También podemos ordenar directamente al intérprete a través de un REPL.

$ python

ASpectos Básicos

Aprendiendo a tomar a la serpiente.

Tipos de Datos Básicos

Numéricos

# Enteros (int):
entero = 123

# Largos (long):
largo = 1234567890L

# Flotantes (float):
flotante = 12.34
flotante_cientifico = 0.1e-3

# ¡Complejos! (complex):
complejo = 1 + 2.34j

# Dato: Puedes representar números en octal empezándolos en 0:
veintitres = 027

# O en hexadecimal con el prefijo 0x
quince = 0xf

Tipos de Datos Básicos

Operadores Numéricos

Aritméticos

Nivel de Bits

Tipos de Datos Básicos

Cadenas

# Normales
cadena_normal = 'holita'

# Unicode
cadena_unicode = u'Hólítá óöøµ©'

# Raw
cadena_raw = r'\a %b \n'

# Comillas triples
cadena_comillas = u"""Puedo tener
varias líneas sin ningún
problema"""

El uso de comillas dobles o simples responde a gusto de quien escribe, aunque por convención, se prefieren las simples (salvo para las triples).

Tipos de Datos Básicos

Operaciones con Cadenas

cadena = 'holita'

# Concatenación
cadena + ' mundo'  # -> 'holita mundo'

# Multitplicación (!!!)
cadena * 3  # -> 'holitaholitaholita'

# Formateo (formato de printf de C)
'%s mundo' % cadena  # -> 'holita mundo'

Tipos de Datos Básicos

Booleanos

# Los únicos valores booleanos son:
verdadero = True
falso = False

Operadores Lógicos

Tipos de Datos Básicos

Iterables

# Listas (list)
lista = [1, 'dos', [3.14, 4 + 5j], True]

# Tuplas (tuple)
tupla = (1, 'dos', [3.14, 4 + 5j], True)

# Conjuntos (set)
conjunto = {1, 'dos', True}

lista = [1, 2, 3, 4, 5, 6, 7, 8]
tupla = (1, 2, 3)

# Concatenación
lista + [9, 10]  # -> [1, 2, ..., 9, 10]

# Adición
lista.append(9)  # -> [1, 2, ..., 9]

#Acceso
lista[4]  # -> 5
lista[-2]  # -> 7

# Partición
lista[3:5]  # -> [4, 5]
lista[2:]  # -> [3, 4, ...]
lista[:5]  # -> [1, 2, 3, 4, 5]
lista[1:6:2] # -> [2, 4, 6]

# Eliminación
del lista[0]  # -> [2, 3, ...]

# Tuplas y listas pueden hacer lo mismo
# ¿La diferencia? ¡Las tuplas son inmutables!
del tupla[0] # -> TypeError

Tipos de Datos Básicos

Operaciones con Iterables

Tipos de Datos Básicos

Operaciones con Iterables

Protip:

¡Las cadenas también son iterables!

Tipos de Datos Básicos

Diccionarios

# Pares de clave/valor (dict):
diccionario = {
    'uno': 1,
    'dos': [2, 2.0],
    'tres': 'three'
}

# Acceso
diccionario['tres']  # -> 'three'
diccionario.get('tres')  # -> 'three'

# Añadir elementos
diccionario['cuatro'] = 4

# Quitar elementos
del diccionario['uno']

Control De Flujo

Control de Flujo

Condicional

# Condicional clásica
if verdadero:
    pass  # No hacer nada
else:
    pass  # Tampoco hacer nada

# Anidada
if falso:
    # Hacer algo...
elif verdadero:
    # Hacer otra cosa...
else:
    # Si todo lo demás falla...

# Inline (!!)
paridad = 'par' if numero % 2 == 0 else 'impar'

Control de Flujo

Iterativo

# While clásico
contador = 0
while contador < 10:
    contador += 1
    if contador == 7:
        break

# For in
suma = 0
iterable = [1, 2, 3, 4, 5]
for numero in iterable:
    suma += numero

Control de Flujo

Excepciones

try:
    num = int('3a')
    print no_existe
except (NameError, ValueError):
    print 'Ocurrio un error'
else:
    print 'Todo bien'
finally:
    print 'Algo se me olvidaba...'

Funciones

# Definición clásica de una función
def sumar(primero, segundo):
    """
    Este es un docstring, todas las funciones 
    deberían de tener uno.
    """
    resultado = primero + segundo
    return resultado

sumar(3, 2)  # -> 5

# Un argumento precedido por un asterisco 
# denota N valores, y se trata como una lista.
def suma_indefinido(*numeros):
    suma = 0
    for numero in numeros:
        suma += numero
    return suma

suma_indefinido(1, 2, 3, 4)  # -> 10

# Un argumento precedido por dos asteriscos
# denota N valores con nombre, y se trata como
# un diccionario.
def suma_nombrado(**kwargs):
    resultado = kwargs['primero'] + kwargs['segundo']
    return resultado

suma_nombrado(primero=3, segundo=2)  # -> 5

Funciones

Bonus: Funciones Útiles

Orientación a Objetos

Orientación a Objetos

Definición

class Carro:
    """Abstraccion de los objetos carro."""
    def __init__(self, gasolina):
        self.gasolina = gasolina
        print 'Tenemos', gasolina, 'litros'

    def arrancar(self):
        if self.gasolina > 0:
            print 'Arranca'
        else:
            print 'No arranca'

    def conducir(self):
        if self.gasolina > 0:
            self.gasolina -= 1
            print 'Quedan', self.gasolina, 'litros'
        else:
            print 'No se mueve'

Orientación a Objetos

Métodos Mágicos

__init__ es un Método Mágico

bmw = Carro(3)  # -> 'Tenemos 3 litros'

Algunos Métodos Mágicos:

Orientación a Objetos

Herencia

class Instrumento:
    def __init__(self, precio):
        self.precio = precio

    def tocar(self):
        print 'Estamos tocando musica'

    def romper(self):
        print 'Eso lo pagas tu'
        print 'Son', self.precio, '$$$'


class Bateria(Instrumento):
    pass


class Guitarra(Instrumento):
    pass

Orientación a Objetos

Herencia Múltiple

class Terrestre:
    def desplazar(self):
        print 'El animal anda'


class Acuatico:
    def desplazar(self):
        print 'El animal nada'


class Cocodrilo(Terrestre, Acuatico):
        pass


c = Cocodrilo()
c.desplazar()  # -> El animal anda

Orientación a Objetos

Polimorfismo

class Bateria(Instrumento):
    def tocar(self):
        print 'badum tss'


class Guitarra(Instrumento):
    def tocar(self):
        print 'waa waa'


bata = Bateria(100)
bata.tocar()  # -> 'badum tss'

fender = Guitarra(50)
fender.tocar()  # -> 'waa waa'

Orientación a Objetos

Encapsulamiento

class Ejemplo:
    def publico(self):
        print 'Publico'

    def __privado(self):
        print 'Privado'


ej = Ejemplo()
ej.publico()  # -> Publico
ej.__privado()  # -> AttributeError (!)

Orientación a Objetos

Bonus Round: Métodos útiles de los tipos básicos

Diccionarios

Orientación a Objetos

Bonus Round: Métodos útiles de los tipos básicos

Cadenas

Orientación a Objetos

Bonus Round: Métodos útiles de los tipos básicos

Listas

Programación Funcional

Programación Funcional

Funciones de orden superior

def saludar(lang):
    def saludar_es():
        print 'Hola'
    
    def saludar_en():
        print 'Hi'
    
    def saludar_fr():
        print 'Salut'
    
    lang_func = {
        'es': saludar_es,
        'en': saludar_en,
        'fr': saludar_fr
    }
    return lang_func[lang]

f = saludar('es')
f()

Programación Funcional

Funciones de orden superior

def cuadrado(n):
    return n ** 2

l = [1, 2, 3]
cuadrados = map(cuadrado, l)


def es_par(n):
    return (n % 2.0 == 0)

l = [1, 2, 3]
pares = filter(es_par, l)

Programación Funcional

Funciones Lambda

l = [1, 2, 3]
pares = filter(lambda n: n % 2.0 == 0, l)
cuadrados = map(lambda x: x ** 2, l)

Programación Funcional

Listas por comprensión y generadores

l = [1, 2, 3]
cuadrados = [n ** 2 for n in l]
cuadrados_gen = (n ** 2 for n in l)

pares = [n for n in l if n % 2.0 == 0]

Programación Funcional

Decoradores

def mi_decorador(funcion):
    def nueva(*args):
        print 'Llamada a la funcion'
        retorno = funcion(*args)
        return retorno
    
    return nueva

@mi_decorador
def imprime(cadena):
    print cadena

imprime('cadena')

To Be Continued