transparencias: añadido ejemplos clausuras
[spanish-workshop-intro-python:mainline.git] / beamer / main.tex
1 %; whizzy -pdf
2 \documentclass{beamer}
3
4 %% based on an original file from Till Tantau (thanks!)
5 \mode<presentation>
6 {
7   \usetheme{Boadilla}
8   \setbeamercovered{transparent}
9 }
10
11 \usepackage[spanish]{babel}
12 \usepackage[T1]{fontenc}
13 \usepackage[utf8x]{inputenc}
14 \input{pygment_preamble}
15
16 \newcommand*{\fichero}[1]{\texttt{#1}}
17 \newcommand*{\variable}[1]{\textit{\texttt{#1}}}
18 \newcommand{\inputDocstring}[1]{\input{../codigo/programas/#1.py.0.tex}}
19 \newcommand{\inputPrograma}[1]{\input{../codigo/programas/#1.py.tex}}
20 \newcommand{\inputProgramaND}[1]{\input{../codigo/programas/#1.py.nodoc.tex}}
21 \newcommand{\inputProgramaYD}[1]{
22   \small
23   \inputProgramaND{#1}
24   \inputDocstring{#1}
25 }
26
27 \title[Introducción a Python]{Introducción al lenguaje de programación Python}
28 \date{\today}
29 \author{Antonio García Domínguez}
30 \institute[OSLUCA]{Oficina de Software Libre\\Universidad de Cádiz}
31
32 \AtBeginSubsection[]
33 {
34   \begin{frame}<beamer>{Tabla de contenidos}
35     \tableofcontents[currentsection,currentsubsection]
36   \end{frame}
37 }
38
39 \begin{document}
40
41 \frame[plain]{\titlepage}
42
43 \begin{frame}
44 \frametitle{Tabla de contenidos}
45 \tableofcontents
46 \end{frame}
47
48 \section{Introducción}
49 %-------------------------------------------------------------------
50
51 \begin{frame}[fragile]
52   \frametitle{Características generales}
53
54   \begin{block}{Lenguaje en sí (ver \emph{import this})}
55     \begin{itemize}
56     \item Muy alto nivel
57     \item Sintaxis uniforme y sencilla
58     \item Completamente orientado a objetos
59     \item Multiparadigma
60     \item Énfasis está en la eficiencia de desarrollo
61     \end{itemize}
62   \end{block}
63
64   \input{../codigo/programas/zen.py.0.tex}
65 \end{frame}
66
67 \begin{frame}
68   \frametitle{Origen del nombre}
69   \framesubtitle{Monty Python and the Flying Circus}
70
71   \begin{center}
72     \includegraphics[width=.4\textwidth]{MontySpam}
73   \end{center}
74
75   Man:  Well, what've you got?
76
77   Waitress:     Well, there's egg and bacon; egg sausage and bacon; egg and spam; egg bacon and spam; egg bacon sausage and spam; spam bacon sausage and spam; spam egg spam spam bacon and spam; spam sausage spam spam bacon spam tomato and spam;
78
79   Vikings:      Spam spam spam spam...
80
81   Waitress:     ...spam spam spam egg and spam; spam spam spam spam spam spam baked beans spam spam spam...
82
83 \end{frame}
84
85 \begin{frame}
86   \frametitle{Implementaciones, herramientas y bibliotecas}
87
88   \begin{block}{Extensa biblioteca estándar}
89     \begin{itemize}
90     \item Analizadores XML DOM/SAX
91     \item Varios entornos de pruebas
92     \item Servidor Web
93     \item Y si necesitamos más, podemos integrar bibliotecas de otros
94       lenguajes con sus \emph{bindings} (PyGame, PyQt, PyGTK...)
95     \item También hay entornos y bibliotecas enteras en Python (Django)
96     \end{itemize}
97   \end{block}
98
99   \pause
100   
101   \begin{block}{Implementaciones}
102     \begin{description}
103     \item[CPython] la original, escrita en C
104     \item[Jython]  se ejecuta sobre la Java Virtual Machine
105     \item[IronPython] utiliza el .NET Common Language Runtime
106     \item[PyS60]  para móviles con Symbian serie 60
107     \item[PyPy] intérprete modular de Python escrito en Python
108     \end{description}
109   \end{block}
110
111 \end{frame}
112
113 \begin{frame}
114   \frametitle{Historia}
115
116   \begin{columns}
117     \column{.8\textwidth}
118     \begin{block}{Python 1.X}
119       \begin{itemize}
120       \item \structure{1991}: Guido van Rossum publica la 0.9.0
121       \item \structure{1994}: Versión 1.0, y se toman conceptos de
122         Lisp
123       \item \structure{2000}: Versión 1.6 genera polémica con su
124         licencia
125       \end{itemize}
126     \end{block}
127
128     \column{.2\textwidth}
129     \begin{center}
130       \includegraphics[width=.9\textwidth]{PythonProgLogo}
131     \end{center}
132
133   \end{columns}
134   \pause
135
136   \begin{columns}
137     \column{.2\textwidth}
138     \begin{center}
139       \includegraphics[width=.9\textwidth]{current-python-logo}
140     \end{center}
141
142     \column{.8\textwidth}
143     \begin{block}{Python 2.X}
144       \begin{itemize}
145       \item \structure{2000}: Versión 2.0 toma de Haskell y
146         recolecta ciclos
147       \item 2.1: código pasa a la \emph{Python Software Foundation}
148       \item Versión 2.2 equipara tipos básicos con clases normales
149       \item Versiones 2.3 y 2.4 (entre otras) toman de Java
150       \end{itemize}
151     \end{block}
152   \end{columns}
153   \pause
154
155   \begin{block}{Python 3.X (ahora en \emph{alpha})}
156     \begin{itemize}
157     \item Romperá compatibilidad hacia atrás y retirará bagaje inútil
158     \item ``There should be one-- and preferably only one --obvious way to do it.''
159     \end{itemize}
160   \end{block}
161   
162   
163 \end{frame}
164
165 \begin{frame}
166   \frametitle{Comparación con Java}
167
168   \begin{itemize}
169   \item También se compila a un \emph{bytecode} intermedio
170     \begin{itemize}
171     \item pero de forma implícita (estilo Perl)
172     \end{itemize}
173
174   \item Todo hereda de \texttt{object}
175     \begin{itemize}
176     \item pero todo, todo: no se escapan ni las constantes numéricas
177     \end{itemize}
178
179   \item Semántica de referencias a objetos
180     \begin{itemize}
181     \item Vamos pasando, asignando y devolviendo sólo \emph{referencias}
182     \end{itemize}
183
184   \item Recolección automática de basura
185
186   \item Introspección, serialización, multihilo, biblioteca estándar enorme...
187   \end{itemize}
188   
189 \end{frame}
190
191 \begin{frame}
192   \frametitle{Comparación con C++}
193   
194   \begin{itemize}
195   \item Multiparadigma: no obliga a hacer OO
196     \begin{itemize}
197     \item Procedural
198     \item Orientado a objetos
199     \item Genérico (mediante \emph{duck typing})
200     \item Algo de funcional
201     \end{itemize}
202
203   \item Herencia múltiple
204   \item Sobrecarga de operadores (menos asignación)
205   \item Libertad de elección de herramientas
206   \end{itemize}
207 \end{frame}
208
209 \begin{frame}{Preparación del entorno}{Necesitaremos algunas herramientas}
210
211   \begin{itemize}
212   \item Por lo pronto instalaremos Python, claro
213   \item A ser posible también \structure{ipython}
214   \item Usaremos su \emph{shell} interactivo por lo pronto
215
216   \item Después trabajaremos en nuestro editor:
217     \begin{itemize}
218     \item Debería tener autoindentado por espacios
219     \item Emacs/Vim en GNU/Linux, Windows, MacOS X
220     \item TextMate en MacOS X también muy popular
221     \end{itemize}
222   \end{itemize}
223 \end{frame}
224
225 %-------------------------------------------------------------------
226 \section{Tipos de datos}
227
228 \subsection{Simples}
229 %-------------------------------------------------------------------
230 \begin{frame}[fragile]{Operaciones aritméticas}
231   \small
232   \inputDocstring{ops_aritmeticos}
233 \end{frame}
234
235 \begin{frame}[fragile]{Operaciones con bits}
236   \small
237   \inputDocstring{ops_bits}
238 \end{frame}
239
240 \begin{frame}[fragile]{Comparaciones}
241   \small
242   \inputDocstring{comparaciones}
243 \end{frame}
244
245 \begin{frame}[fragile]{Números complejos}
246   \small
247   \inputDocstring{num_complejos}
248 \end{frame}
249
250 \begin{frame}[fragile]{Cadenas}
251   \small
252   \inputDocstring{cadenas}
253 \end{frame}
254 %-------------------------------------------------------------------
255 \begin{frame}[fragile]{Booleanos}
256   \small
257   \inputDocstring{booleanos}
258 \end{frame}
259 %-------------------------------------------------------------------
260 \begin{frame}[fragile]{Todo esto es un objeto}
261
262   \begin{itemize}
263   \item Los objetos tienen métodos, y éstos tienen documentación
264   \item La documentación se puede consultar en momento de ejecución
265   \item ¿Qué cosas puedo hacer con una cadena?
266   \end{itemize}
267
268   \small
269   \inputDocstring{ayuda_enlinea}
270 \end{frame}
271 %-------------------------------------------------------------------
272 \subsection{Estructurados}
273 %-------------------------------------------------------------------
274 \begin{frame}[fragile,allowframebreaks]{Listas}
275   \inputDocstring{listas}
276 \end{frame}
277
278 \begin{frame}[fragile]{Tuplas}
279   \inputDocstring{tuplas}
280 \end{frame}
281
282 \begin{frame}[fragile]{Diccionarios}
283   \inputDocstring{diccionarios}
284 \end{frame}
285
286 \begin{frame}[fragile]{Conjuntos}
287   \inputDocstring{conjuntos}
288 \end{frame}
289 %-------------------------------------------------------------------
290 \section{Control de flujo}
291 %-------------------------------------------------------------------
292 \subsection*{Inciso}
293
294 \begin{frame}[fragile]{Cambio a editor}
295
296   \begin{block}{Creación de un \emph{shell script} en Python}
297     \begin{enumerate}
298     \item Añadir una primera línea con el intérprete a usar:
299 \begin{verbatim}
300 #!/usr/bin/env python
301 \end{verbatim}
302     \item Declaración de codificación (por si escribimos acentos):
303 \begin{verbatim}
304 # -*- encoding: utf-8 -*-
305 \end{verbatim}
306     \item Marcamos el fichero (extensión \fichero{.py}) como ejecutable:
307 \begin{verbatim}
308 chmod +x fichero.py
309 \end{verbatim}
310     \end{enumerate}
311   \end{block}
312
313   \pause
314
315   \begin{block}{Ejecución}
316     \begin{itemize}
317     \item Podemos ejecutar simplemente con:
318 \begin{verbatim}
319 ./fichero.py
320 \end{verbatim}
321     \item Si algo falla, se puede ejecutar con el depurador usando:
322 \begin{verbatim}
323 python -m pdb fichero.py
324 \end{verbatim}
325     \end{itemize}
326   \end{block}
327 \end{frame}
328 %-------------------------------------------------------------------
329 \subsection{Condicionales}
330
331 \begin{frame}[fragile]{Condicional: if}{Python nos obliga a indentar debidamente el código}
332   \inputDocstring{if}
333 \end{frame}
334
335 \subsection{Bucles sobre listas}
336
337 \begin{frame}[fragile]{Bucle sobre iterable: for}{El estilo de C es peligroso: mejor el foreach de Perl y Java 5}
338   \inputDocstring{for}
339 \end{frame}
340
341 \begin{frame}[fragile]{Iterando sobre secuencias, diccionarios y conjuntos}{for es más flexible de lo que parece a simple vista}
342   \inputDocstring{for_avanzado}
343 \end{frame}
344
345 \begin{frame}[fragile]{Operando sobre listas completas}{Listas de comprensión de Haskell y reducciones de Lisp evitan errores y bucles engorrosos}
346   \inputDocstring{comprension_listas}
347 \end{frame}
348
349 \subsection{Bucles sobre condiciones}
350
351 \begin{frame}[fragile]{Bucle sobre condición: while}{Nada fuera de lo normal, excepto por el else}
352   \inputDocstring{while}
353 \end{frame}
354
355 %-------------------------------------------------------------------
356 \section{Elementos de nivel superior}
357 %-------------------------------------------------------------------
358 \subsection{Módulos y paquetes}
359
360 \begin{frame}{Conceptos de módulo y paquete}
361
362   \begin{block}{Árbol de directorios de ejemplo}
363     \begin{itemize}
364     \item<1,2> \fichero{settings.py} \only<2->{$\rightarrow$ \alert{settings}}
365     \item<1,3-> \fichero{blog/}
366       \begin{itemize}
367       \item<1,3> \fichero{\_\_init\_\_.py} \only<3->{$\rightarrow$ \alert{blog}}
368       \item<1,4> \fichero{views.py}  \only<4->{$\rightarrow$ \alert{blog.views}}
369       \item<1,4> \fichero{models.py} \only<4->{$\rightarrow$ \alert{blog.models}}
370       \item<1,4> \fichero{forms.py}  \only<4->{$\rightarrow$ \alert{blog.forms}}
371       \end{itemize}
372     \end{itemize}
373   \end{block}
374
375   \pause
376
377   \begin{block}{Método seguido por Python}
378     \begin{enumerate}
379     \item Cada \fichero{.py} es un módulo con su nombre menos la extensión
380       \pause
381     \item Cada directorio pasa a ser un \emph{paquete} si tiene el
382       fichero marcador \fichero{\_\_init\_\_.py} (puede estar vacío o
383       no)
384       \pause
385     \item El submódulo \emph{y} de un paquete \emph{x} (que pueden ser
386       paquetes a su vez) se llama \emph{x.y}, como en Java
387     \end{enumerate}
388   \end{block}
389
390 \end{frame}
391
392 \begin{frame}{Acceso a los miembros de un módulo}
393   \begin{itemize}
394   \item Los módulos deben de estar en nuestro \variable{PYTHONPATH} (\texttt{sys.path})
395   \item Ubuntu: ficheros \fichero{.pth} en \fichero{/usr/lib/python2.5/site-packages}
396   \item Al cargarse, normalmente se precompilan a un \fichero{.pyc}
397   \end{itemize}
398
399   \inputDocstring{modulos}
400 \end{frame}
401
402 %-------------------------------------------------------------------
403 \subsection{Funciones}
404
405 \begin{frame}{Función sin argumentos y sin cuerpo}{Dejamos lo mínimo necesario, excepto por el docstring}
406   \inputPrograma{funciones_basico}
407 \end{frame}
408
409 \begin{frame}{Función resta de dos argumentos}{Pasando argumentos por nombre o por orden}
410   \inputPrograma{funciones_resta}
411 \end{frame}
412
413 \begin{frame}{Valores por defecto}
414   \inputPrograma{funciones_pordefecto}
415 \end{frame}
416
417 \begin{frame}{Listas de argumentos variables}
418   \begin{itemize}
419   \item \texttt{*p} como argumento formal captura los posicionales extra
420   \item \texttt{**p} hace lo mismo para los argumentos nombrados
421   \end{itemize}
422
423   \inputPrograma{funciones_varargs}
424 \end{frame}
425
426 \begin{frame}{Expansión de argumentos}
427   \inputDocstring{funciones_expansion}
428 \end{frame}
429
430 \begin{frame}{Combinándolo todo}{Da algo de miedo, pero es útil, creedme}
431   \inputPrograma{funciones_todo}
432 \end{frame}
433
434 \subsection{Clausuras y otros aspectos funcionales}
435
436 \begin{frame}{Clausuras}{Bloque de código con un contexto asociado}
437
438   \begin{block}{Funciones como valores de primera clase en Python}
439     \begin{itemize}
440     \item Lo usual en lenguajes funcionales (Haskell, Lisp)
441     \item Se tratan como cualquier otra cosa (ej.: una constante
442       numérica)
443     \item De hecho, son objetos en Python
444     \end{itemize}
445   \end{block}
446
447   \begin{block}{Construcción de funciones}
448     \begin{itemize}
449     \item Las funciones se pueden anidar:
450       \begin{itemize}
451       \item La función interior puede referenciar variables de la
452         exterior
453       \item Al revés \alert{no} se puede
454       \end{itemize}
455
456     \item Si la función interior es devuelta por la superior:
457
458       \begin{itemize}
459       \item Las referencias a las variables de la exterior se
460         devuelven junto con ella
461       \item Lo que se devuelve es por tanto una \emph{clausura}
462       \end{itemize}
463     \end{itemize}
464   \end{block}
465
466   ¿Y esto para qué sirve?
467 \end{frame}
468
469 \begin{frame}{Clausuras: constructores de funciones}{Funciones de segundo orden: funciones que crean funciones}
470   \inputProgramaYD{funciones_2orden}
471 \end{frame}
472
473 \begin{frame}{Clausuras: decoradores}
474   \begin{columns}
475     \column{.7\textwidth}
476     \begin{itemize}
477     \item \texttt{def} realmente lo que hace es:
478       \begin{enumerate}
479       \item compila el cuerpo a bytecode
480       \item lo asigna al espacio de nombres actual
481       \end{enumerate}
482     \item ¿Por qué no reasignarlo nosotros mismos?
483     \end{itemize}
484
485     \column{.3\textwidth}
486     \includegraphics[width=\textwidth]{Spanish_Inquisition}
487   \end{columns}
488
489   \inputProgramaYD{funciones_deco}
490 \end{frame}
491
492 \begin{frame}{Clausuras: decoradores (sintaxis alternativa)}{La sintaxis estilo Java es más visible y cómoda de utilizar}
493   \inputProgramaYD{funciones_deco2}
494 \end{frame}
495 %-------------------------------------------------------------------
496 \begin{frame}
497 \frametitle{Generadores}
498
499 \end{frame}
500
501 \subsection{Clases}
502
503 \begin{frame}
504 \frametitle{Clases y objetos}
505
506 \begin{itemize}
507 \item Definición de clases
508 \item Herencia
509 \item Propiedades
510 \item Módulos y paquetes
511 \item Manejo de excepciones
512 \item Duck typing
513 \end{itemize}
514 \end{frame}
515
516 %-------------------------------------------------------------------
517 \section{Marcos de pruebas}
518 %-------------------------------------------------------------------
519 \begin{frame}
520 \frametitle{Marcos de pruebas}
521
522 \begin{itemize}
523 \item doctests
524 \item unittest
525 \end{itemize}
526 \end{frame}
527 %-------------------------------------------------------------------
528
529 \end{document}
530