charla_ddl_python/presentacion.mgp

   1 %% vim: set encoding=utf-8 :
   2 %include "common.mgp"
   3 %%
   4 %page
   5 %nodefault
   6 %center, size 7, font "standard", back "white", fore "black"
   7
   8 Python Básico
   9 %size 4
  10
  11 El lenguaje de la viborita
  12
  13 %bar "gray" 5 10 80
  14
  15 Leandro Lucarella (llucare@fi.uba.ar)
  16
  17 LUGFI - UBA
  18
  19 7 de octubre de 2006
  20
  21
  22 %page
  23
  24 Reseña histórica
  25
  26         Creado en 1990 por Guido van Rossum (BDFL)
  27         Nombrado en honor a los (únicos e inigualables) Monty Python
  28         En 2000 aparece Python 2.0
  29         En 2001 aparece Python 2.1 y la PSF, nueva "dueña" de Python.
  30         Versión actual: 2.5 (recién salido del horno)
  31         Futuro/Evolución -> PEPs -> Python 3000 (ver PEP)
  32         Implementaciones: CPython, Jython, IronPython, PyPy, Nokia (S60)
  33         Hablamos de CPython que es la principal (disponible en más de 35 plataformas)
  34
  35 %page
  36
  37 Características principales
  38
  39         Dinámico
  40         Compila a bytecode (on the fly)
  41         Interpretado, por VM
  42         Fácilmente extensible usando módulos en C
  43         Manejo de memoria automático (GC con detección de ciclos)
  44         Core reducido y después syntactic sugar
  45         Intérprete interactivo
  46         Biblioteca estándar extensa y muchas (MUCHAS) extensiones
  47         Números de precisión arbitraria
  48         Concurrencia real (palo para Ruby =P)
  49         Multiparadigma: OO, estructurado, funcional, genérica, metaprogramación, aspectos
  50         Influenció otros lenguajes, como RUBY!!! y Boo (.NET)
  51
  52 %page
  53
  54 The Zen of Python (import this)
  55
  56         Beautiful is better than ugly.
  57         Explicit is better than implicit.
  58         Simple is better than complex.
  59         Complex is better than complicated.
  60         Flat is better than nested.
  61         Sparse is better than dense.
  62         Readability counts.
  63         Special cases aren't special enough to break the rules.
  64         Although practicality beats purity.
  65
  66 %page
  67
  68 The Zen of Python (continuación)
  69
  70         Errors should never pass silently.
  71         Unless explicitly silenced.
  72         In the face of ambiguity, refuse the temptation to guess.
  73         There should be one-- and preferably only one --obvious way to do it.
  74         Although that way may not be obvious at first unless you're Dutch.
  75         Now is better than never.
  76         Although never is often better than *right* now.
  77         If the implementation is hard to explain, it's a bad idea.
  78         If the implementation is easy to explain, it may be a good idea.
  79         Namespaces are one honking great idea -- let's do more of those!
  80
  81 %page
  82
  83 Tipos
  84
  85         Tipado dinámico pero fuerte, duck typing
  86         Todo es referencia (id), todo es un objeto (TODO)
  87         Las clases son instancias de la clase type (que es instancia de sí mismo)
  88         Los objetos son una identidad con un diccionario de atributos
  89         Por lo tanto puedo modificar una clase dinámicamente
  90         Las funciones son "ciudadanos de 1er orden"
  91         Las funciones son objetos "callables" (que pueden ser atributos)
  92         Los métodos son funciones atributo de una clase que toman el primer parámetro implícito
  93         obj.metodo(a) es sintatic sugar de Clase.metodo(obj, a)
  94
  95 %page
  96
  97 Más sobre tipos
  98
  99         Mutabilidad
 100         Secuencias
 101         Built-in
 102                 CLASE      MUTABILIDAD  EJEMPLO
 103                 bool    -> Inmutable -> a_int = True
 104                 int     -> Inmutable -> a_int = 42
 105                 long    -> Inmutable -> a_long = 12345678901234567890
 106                 float   -> Inmutable -> a_float = 42.25
 107                 complex -> Inmutable -> a_complex = 42 + 25j
 108                 str     -> Immutable -> a_str = 'Wikipedia'
 109                 unicode -> Inmutable -> a_unicode = u'Wikipedia'
 110                 list    -> Mutable   -> a_list = [4.0, 'string', True]
 111                 tuple   -> Immutable -> a_tuple = (4.0, 'string', True)
 112                 set     -> Mutable   -> a_set = set([4.0, 'string', True])
 113                 dict    -> Mutable   -> a_dict = { 'key1' : 1.0, 'key2' : False }
 114
 115 %page
 116
 117 Sintaxis
 118
 119         Hola Mundo!
 120             # coding: utf8
 121             # (más formas de especificar, compatible con VIM/Emacs)
 122             # Comentario
 123             print "Hola mundo!"
 124         Estructuras de control
 125             if i < 10:
 126                 print "%d es chico" % i
 127             elif i > 20:
 128                 print i, "es grande"
 129             else:
 130                 Error de sintaxis
 131         Bloques con identación??? (puaj? NO! Groso!)
 132
 133 %page
 134
 135 Sintaxis (continuación)
 136
 137         Más estructuras de control
 138             while (no hay do-while, pero hay PEP!)
 139                 while i < 10:
 140                     print i
 141                     i += 1
 142             for (sobre secuencias o "iterables")
 143                 l = [1, 2, 3, "hola", "chau"]
 144                 for item in l:
 145                     print item
 146                 for i in xrange(10):
 147                     print i
 148
 149 %page
 150
 151 Sintaxis
 152
 153         Funciones
 154             def (para definir funciones)
 155                 def foo(a, b, *args, **kargs):
 156                     print a, b
 157                     for arg in args:
 158                         print arg
 159                     for (key, val) in kargs.iteritems():
 160                         print key, '=', val
 161                     if a == b:
 162                         return True
 163                     else:
 164                         return False
 165
 166 %page
 167
 168 Sintaxis
 169
 170         Clases
 171             class A1: pass
 172             class A2: pass
 173             class B(A1, A2):
 174                 atributo_de_clase = 1
 175                 def __init__(self, parametro1, *args)
 176                     self.attr1 = parametro1
 177                     self.lista = args
 178                 if atributo_de_clase == 1:
 179                     def hola(self):
 180                         print 1
 181                 else:
 182                     def hola(self)
 183                         print 2
 184                 class C:
 185                     pass
 186
 187 %page
 188
 189 Sintaxis
 190
 191         Instanciación
 192             a = A()
 193             b = B(1)
 194             c = B.C()
 195             c.otro_atributo = lambda x, y: x + y
 196         Private? Protected? Lo qué???
 197
 198 %page
 199
 200 Sintaxis - Excepciones
 201
 202         try-except
 203             try:
 204                 for linea in file("algo.txt"):
 205                     print linea
 206             except Exception, e:
 207                 print e
 208             else:
 209                 print "Todo OK"
 210         try-finally
 211             try:
 212                 for linea in file("algo.txt"):
 213                     print linea
 214             finally:
 215                 print "Listo!"
 216         try-except-finally (PEP, en 2.5?)
 217
 218 %page
 219
 220 Sintaxis
 221
 222         Módulos (built-in)
 223             import modulo
 224             import modulo as mod
 225             from modulo import Clase
 226             from modulo import *
 227             from modulo import Clase as C
 228         Hay más, pero no hay tiempo (seguro ya estoy excedido con la hora)
 229
 230 %page
 231
 232 Preguntas?
 233
 234         Para los que todavía no se fueron a comer...
 235