El gran libro de Python E-Book

Marco Buttu

• Herausgeber: Marcombo
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Spanisch
• Veröffentlichungsjahr: 2020

Seitenzahl: 551

Beschreibung

Python es un lenguaje de programacion multiplataforma, consistente y maduro, en el cual confian con exito las Empresas y organizaciones mundiales mas prestigiosas: Google, la NASA, YouTube, Intel y Yahoo! Su exito esta vinculado tanto al hecho de que favorece la productividad, haciendo mas sencillo el desarrollo de sistemas de software sin tener en cuenta su complejidad, como al hecho de que tiene multiples entornos de uso: aplicaciones web, juegos y multimedia, interficies graficas, networking, aplicaciones cientificas, inteligencia artificial y programacion de sistemas, entre muchos otros. El gran libro de Python es el mas completo, moderno y detallado de entre los volumenes dedicados a Python que pueden encontrarse actualmente en el mercado. Actualizado a la version 3.4 del lenguaje, lanzada en enero de 2014. Su composicion es muy detallada y sigue un curso gradual elaborado en torno a una amplia serie de ejemplos y ejercicios: parte de las bases del lenguaje, sin dar nada por sabido, hasta llegar a los argumentos considerados mas dificiles, incluso por los programadores mas experimentados. Soporte al libro disponible online: code.google.com/p/the]phytonic]way/ Aspectos destacados: - Introduccion al lenguaje Python, a su sintaxis, a sus construcciones fundamentales y a la libreria estandar. - Funciones y modos de emparejamiento de argumentos, generadores, corrutinas, archivos, comodines y expresiones regulares. - Modulos y paquetes, entornos y espacios de nombres, ambientes virtuales, instalacion y distribucion de aplicaciones. - Prueba de validacion de cadenas de documentacion y desarrollo guiado por pruebas. - Programacion orientada a objetos en Python: clases, herencia, gestion de las excepciones, patron y antipatron, propiedades y decoradores. - Modelo a objetos de Python, atributos magicos, descriptores y metaclases. Marco Buttu: ingeniero electronico. Tras haber trabajado en el campo del Network on Chip y de las nuevas arquitecturas para la elaboracion paralela, aterrizo en el Istituto Nazionale di Astrofisica, en el cual se ocupa del desarrollo del software de control del Sardinia Radio Telescope, el radiotelescopio europeo mas moderno y uno de los mas grandes del mundo. En 2004 tuvo su primer encuentro con Python y desde entonces no ha podido separarse de el.

Leseprobe

El Gran libro de Python

Marco Buttu

Título original de la obra:

Programmare con Phyton – Guida completa

Marco Buttu

© 2014 Edizioni LSWR

Título de la versión en español de la obra:

El Gran libro de Phyton

Traducción: Sònia Llena

Diseño de la cubierta: ENEDENÚ ESTUDI DISSENY GRÀFIC

Primera edición, 2016

© 2016 MARCOMBO, S.A.

www.marcombo.com

Esta edición de El Gran libro de Phyton ha sido publicada en colaboración con Edizioni LSWR.

This edition of Programmare con Phyton – Guida completa by Marco Buttu is published by arrange-ment with Edizioni LSWR.

«Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra sólo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley.»

Sumario

INTRODUCCIÓN

1. LOS FUNDAMENTOS DEL LENGUAJE

Introducción a Python

Introducción al lenguaje

Los elementos del código Python

Arquitectura de un programa Python

La Python Virtual Machine

Etiquetas y objetos

Tipos de errores

Objetos iterables, iteradores y contexto de iteración

Ejercicio final

2. EL CORAZÓN DEL LENGUAJE

Números

Operaciones y funciones integradas utilizables con objetos iterables

Los conjuntos matemáticos

Diccionarios

Las secuencias

Ejercicio final

3. FUNCIONES, GENERADORES Y ARCHIVOS

Definición y llamada de una función

Funciones anónimas

Introspección de funciones

Generadores

Archivos

Ejercicio final

4. MÓDULOS, PAQUETES, ENTORNOS VIRTUALES Y APLICACIONES

Módulos

Espacio de nombres, ámbito y resolución de nombres

Instalación de paquetes

Entornos virtuales

Ejercicio final

5. CLASES Y PROGRAMACIÓN ORIENTADA A OBJETOS

Clases e instancias

Un primer vistazo a la sobrecarga

La composición

La herencia

La decoradores

Los métodos y las propiedades

Introducción a los patrones de diseño

Las excepciones

La instrucción with y los gestores de contexto

Ejercicio final

6. ATRIBUTOS MÁGICOS, METACLASES Y DESARROLLO GUIADO POR PRUEBAS

El modelo a objetos de Python

Los atributos mágicos

Metaclases

Desarrollo guiado por pruebas

Ejemplo práctico de uso del desarrollo guiado por pruebas

Las enumeraciones

Ejercicio final

APÉNDICE A - DESCRIPCIÓN DE LOS COMANDOS UNIX-LIKE UTILIZADOS EN EL LIBRO

cat

chmod

cut

diff

echo

find

grep

head

ln

ls

mkdir

more

mv

pwd

rm

sed

source

tail

tar

time

touch

tree

wc

wget

which

zip

Los metacaracteres

Variables de entorno

APÉNDICE B - PRINCIPALES PUNTOS DE ROTURA ENTRE PYTHON 2 Y PYTHON 3

Incompatibilidades entre las dos versiones

Migración automática de Python 2 a Python 3

APÉNDICE C - EL BUFFERING DE LOS ARCHIVOS

Introducción

Python es un lenguaje de programación multiplataforma, consistente y maduro, en el cual confían con éxito las empresas y organizaciones más prestigiosas a nivel mundial, como Google, YouTube, Intel, Yahoo! y la NASA. Son múltiples los campos en los que se utiliza: aplicaciones web, juegos y multimedia, interficies gráficas, networking, aplicaciones científicas, inteligencia artificial, programación de sistemas, entre muchos otros.

El objetivo de este libro es enseñar a programar con Python en el modo correcto (The Pythonic Way). El tema central es, por tanto, el lenguaje, en todos sus aspectos, que se aborda detalladamente tanto desde el punto de vista teórico como práctico.

El libro está actualizado a la versión 3.4 de Python, lanzada en el año 2014.

A quién va dirigido

El libro va dirigido tanto a aquellos que quieren empezar a programar con Python como a los que ya conocen el lenguaje y desean profundizar en los argumentos más avanzados, como los decoradores, las metaclases y los descriptores.

La lectura será probablemente más entretenida para aquellos que tienen experiencia en programación, pero el libro es accesible a todos, puesto que nada se da por sabido. De hecho, se parte del estudio de las bases del lenguaje hasta llegar, siguiendo un recorrido gradual elaborado en torno a una amplia serie de ejemplos y ejercicios, a los argumentos más avanzados.

Este libro no es solo una guía de Python, sino también un manual de programación, puesto que se tratan numerosos temas de carácter general, como la aritmética del ordenador y las problemáticas relacionadas con ella, el estándar Unicode y el desarrollo guiado por pruebas.

Contenido del libro

El libro está formado por seis capítulos y tres apéndices. El primero es un resumen de todo el libro, puesto que presenta, de forma gradual, múltiples temas, como los objetos integrados, los módulos, los archivos, las funciones, las clases y las librerías estándar. Al final de este capítulo, el lector ya debería ser productivo y ser capaz de desarrollar programas Python importantes y con sentido.

Del segundo al quinto capítulo se profundiza y se integran todos los argumentos estudiados en el primero: el segundo capítulo se centra en el core data-type; el tercero, en las funciones, los generadores y los archivos; el cuarto, en los módulos, la instalación y la distribución de las aplicaciones, y el quinto, en la programación orientada a objetos.

El sexto capítulo está dedicado a los argumentos más avanzados: modelo a objetos de Python, metaclases, atributos mágicos, descriptores y desarrollo guiado por pruebas. Estos temas se tratarán de forma gradual y, al mismo tiempo, de manera detallada. En este libro no existe ningún capítulo dedicado exclusivamente a las librerías estándar, puesto que este tema es tan amplio que sería necesario otro libro para tratarlo de manera completa. Hemos preferido seguir un enfoque práctico, tratando distintos módulos de interés en cada momento, cuando se presenta la ocasión. Esto permite tanto realizar prácticas con los módulos más utilizados como familiarizarse con la documentación online.

Al final de cada capítulo se incluye un ejercicio final, con el objetivo no solo de analizar programas completos, sino también y sobre todo de hacer frente a otras temáticas importantes y explorar la librería estándar. De hecho, en estos ejercicios se podrá ver cómo realizar el análisis de argumentos desde la línea de comandos, crear programas portables que puedan funcionar igual en todos los sistemas operativos, trabajar con fechas, utilizar los comodines y las expresiones regulares y realizar el desarrollo guiado por pruebas, entre otras aplicaciones.

Cada ejercicio empieza mostrando el código -que tras una primera lectura seguramente parecerá del todo incomprensible- y continúa con la explicación del significado de cada línea, de manera que, al finalizar, todos los puntos estén claros para el lector. La parte final del libro está formada por tres apéndices. El apéndice A describe los comandos Unix-like utilizados en el libro; el apéndice B, los principales puntos de rotura entre Python 2 y Python 3, y el apéndice C, el proceso de buffering de los archivos.

Material y contactos

El código fuente de los ejercicios finales y las soluciones están disponibles en internet, en la dirección:

http://code.google.com/p/the-pythonic-way/

Para cualquier aclaración, o simplemente, para intercambiar opiniones, pueden ponerse en contacto con el autor mediante un e-mail a su dirección de correo electrónico:

[email protected]

indicando en el asunto el texto Python - Guida completa.

Agradecimientos

El autor dedica este libro a Micky, su irremplazable otra mitad, y le agradece la paciencia y la comprensión. Sin su ayuda no habría sido posible escribir este libro.

Muchas gracias también a todas aquellas personas que han pasado su tiempo inter-cambiando opiniones con el autor acerca de Python, particularmente a Steven D’Aprano, por su participación en el grupo de discusión comp.lang.python y en la mailing list python-ideas.

El autor quiere dar las gracias también a Andrea Saba, Franco Buffa y Marco Bartolini por todos los consejos útiles.

1

Los fundamentos del lenguaje

En este capítulo construiremos sólidosfundamentospráctico-teóricos que nos permitirán serrápidamente productivos. Presentaremos paso a paso distintos temas: objetosintegrados, módulos, archivos, funciones, clasesylibrerías estándar. El objetivo es ambicioso: proporcionar las bases a quien quiereaprender a programarcorrectamente con Python y, al mismo tiempo, ofrecer ideas interesantes a losprogramadores de Python más experimentados.

Introducción a Python

Python nace en diciembre de 1989 de manos del informático holandés Guido van Rossum.

Tras haber estado trabajando durante cuatro años (de 1982 a 1986) en el desarrollo del lenguaje de programación ABC, en el Centrum voor Wiskunde & Informatica (CWI) de Amsterdam, en 1986 Guido empieza a colaborar en el desarrollo de Amoeba, un sistema operativo distribuido nacido también en Amsterdam (1981), en la Vrije Universiteit. A finales de los ochenta, el equipo se da cuenta de que Amoeba necesita un lenguaje de scripting, por lo que Guido, mientras pasa las vacaciones de Navidad de 1989 en su casa, tanto por hobby como por contribuir en el desarrollo de Amoeba, decide poner en marcha un proyecto personal.

Intenta utilizar todo cuanto ha aprendido durante el tiempo de trabajo con ABC y, aunque aquella experiencia fue más bien frustrante, algunas de las carácterísticas de ABC le gustan y decide utilizarlas como fundamentos para su nuevo lenguaje:

• la sangría para indicar los bloques de instrucciones anidadas;

• alguna instrucción de variables;

• cadenas de caracteres y listas de longitud arbitraria.

Sobre estas bases empieza a escribir en C un intérprete para su futuro lenguaje de programación, que bautiza con el nombre de Python en honor a su serie de televisión favorita: Monty Python’s Flying Circus.

En 1990, Guido finaliza la primera implementación del intérprete, que implanta en la CWI para uso interno. En febrero de 1991, hace público el código en alt.sources, indicando como versión la 0.9.0. En 1994 se crea comp.lang.python, el primer grupo de discusión sobre Python, y el año siguiente nace el sitio web oficial: www.python.org.

Desarrollo de Python

Python es desarrollado, mantenido e implantado por un grupo de personas coordinado por Guido van Rossum, quien tiene la última palabra en las decisiones relacionadas tanto con el lenguaje como con las librerías estándar. Por este motivo, en 1995, se otorgó a Guido el título de Benevolent Dictator For Life (BDFL). El 6 de marzo de 2001 se funda la Python Software Foundation (PSF), una organización sin ánimo de lucro que tiene los derechos de autor sobre Python y promueve su difusión. La PSF está presidida por Guido van Rossum y cuenta entre sus miembros con el núcleo de los desarrolladores de Python, entre muchas otras personalidades denominadas en virtud de su notable contribución en el lenguaje.

Las major version (las versiones principales, aquellas que se distinguen por el primer número de la versión, denominado major number) se van lanzando con distintos años de separación unas de otras. Así, la 1.0 sale en 1994, la 2.0, en el año 2000 y la 3.0, en 2008. En cambio, las minor version (las versiones menores, aquellas que tienen el mismo major number y se diferencian por el primer número después del punto) aparecen cada uno o dos años.

Las funcionalidades que se añaden a las minor version son retrocompatibles, lo que significa que todo el código escrito para una versiones menores funcionará del mismo modo también en las sucesivas. Por tanto, el código escrito para la versión 3.x funcionará de manera idéntica en todas las versiones 3.y, siendo y mayor que x.

Sin embargo, en las versiones principales no se garantiza la retrocompatibilidad. Si el código de una versión principal x no se puede ejecutar con una y, x < y, o bien sí se puede pero el resultado es distinto, se dice que es incompatible con la versión y.

NOTA

Este libro ha sido actualizado a Python 3.4. El código ha sido ejecutado tanto en Python 3.3 como en Python 3.4 (evidentemente, las funcionalidades presentadas en la 3.4 solo han sido probadas en dicha versión). Para conocer las principales incompatibilidades entre Python 2 y Python 3 consulte el Apéndice B, titulado Principales puntos de rotura entre Python 2 y Python 3.

Para indicar las versiones en las cuales se resuelven ciertos errores presentes en la versión menor, se utiliza un tercer número, denominado micro number, o patch number. Por ejemplo, en la versión x.y.1 de Python el número 1 indica el micro número. Por tanto, la 3.4.1 es la primera bug-fix release (o versión con errores corregidos) de Python 3.4. Por último, es posible ver un código detrás del número de versión, por ejemplo, 3.4.1a3, 3.4.1b2, 3.4.1c4. Este código se utiliza para indicar las sub-release. Los códigos a1, a2, … aN indican las alpha release, que pueden añadir nuevas funcionalidades (por ejemplo, la 3.4.1a2 podría presentar funcionalidades que no se incluyen en la 3.4.1a1). Los códigos b1, b2, … bN indican las beta release, que pueden resolver los bug pero no pueden añadir nuevas funcionalidades. Los códigos c1, c2, … cN indican las versiones candidate, en las cuales el desarrollo del núcleo comprueba escrupulosamente la corrección de errores. La herramienta utilizada para proponer los cambios en el lenguaje es la Python Enhancement Proposal, que se indica con el acrónimo PEP. Las PEP son documentos públicos revisados por los desarrolladores y la comunidad, con la finalidad de ser aprobados o descartados por Guido. Las PEP tratan distintos aspectos del lenguaje y se identifican por un código único (por ejemplo, PEP-0008). El archivo de todas las PEP se encuentra en la página http://www.python.org/dev/peps/. Para acceder a la página de una determinada PEP, es preciso añadir el texto /pep-code/ a la dirección del archivo; por ejemplo, la página de la PEP-0008 es accesible desde la URL http:// www.python.org/dev/peps/pep-0008/. Tengamos todo esto presente, puesto que nos referiremos a las PEP durante todo el libro.

NOTA

La nomenclatura y la gestión del lanzamiento de las versiones de Python se trata en la PEP-0101, titulada Doing Python Releases 101, mientras que las micro-release y las sub-release se tratan en la PEP-0102.

El estado del arte

Python es un lenguaje consistente y maduro, utilizado en diversos ámbitos: web, desarrollo de interficies gráficas, programación de sistemas, networking, bases de datos, cálculo numérico y aplicaciones científicas, programación de juegos y multimedia, gráficos e inteligencia artificial, entre muchos otros.

Se trata de un lenguaje multiplataforma, es decir, disponible para los principales sistemas operativos, y se incluye automáticamente en las distribuciones Linux y en los ordenadores Macintosh. Además, proporciona todas las herramientas para escribir de manera sencilla programas portables, es decir, que se comportan del mismo modo si se ejecutan sobre distintas plataformas. Podremos ver un ejemplo elocuente de código portable en el ejercicio final de este capítulo.

Se utiliza con éxito a nivel mundial en las empresas y organizaciones más variadas, entre las cuales se encuentran Google, la NASA, YouTube, Intel, Yahoo! Groups, reddit, Spotify Ltd, OpenStack y Dropbox Inc. Esta última merece una mención aparte, puesto que su historia nos permite evidenciar distintos puntos fuertes de Python.

Dropbox es un software multiplataforma que ofrece un servicio de alojamiento y sincronización automática de archivos a través de la web. Su primera versión fue lanzada en septiembre de 2008 y en muy poco tiempo tuvo un éxito sorprendente, llegando a los 50 millones de usuarios en octubre de 2011 y a los 100 millones el año siguiente, como anunció el 12 de noviembre de 2012 Drew Houston, uno de los dos fundadores de Dropbox Inc.

Casi un mes después del anuncio de este increíble resultado, el 7 de diciembre de 2012, Drew nos sorprendió a todos con otra clamorosa noticia. Guido van Rossum, tras haber sido partícipe durante siete años de la buena suerte de Google, se unía al equipo de Dropbox:

Nos complace dar la bienvenida, de forma insólita, a un nuevo miembro de la familia Dropbox. Aunque su incorporación es muy reciente, sus aportaciones a Dropbox han sido evidentes desde el primer día, desde la primera línea de código.

Son muy pocas las personas que no necesitan presentación, y el BDFL (“el dictador benevolente de por vida”) es una de ellas. Dropbox está orgulloso de dar la bienvenida a Guido, el creador del lenguaje de programación Python, y amigo nuestro desde hace mucho tiempo. Han pasado cinco años desde que nuestro primer prototipo fue guardado como dropbox.py, y Guido y la comunidad de Python han sido cruciales en ayudarnos a resolver retos que han concernido a cientos de millones de personas.

Por todo ello, acogemos a Guido con admiración y gratitud. Guido nos ha inspirado a todos, ha desarrollado un papel fundamental en el modo en que Dropbox une los productos, los dispositivos y los servicios en nuestra vida. Estamos muy contentos de tenerlo en nuestro equipo.

En ese mismo anuncio, Drew rindió homenaje a Python, su lenguaje de programación favorito, elogiándolo por su portabilidad, simplicidad y flexibilidad:

Desde el principio, estaba claro que Dropbox tenía que funcionar en todos los sistemas operativos. Históricamente, este aspecto representaba un reto importante para los desarrolladores: cada plataforma precisaba distintas herramientas de desarrollo, distintos lenguajes de programación, y los desarrolladores debían escribir el mismo código múltiples veces.

No teníamos tiempo de hacerlo y, afortunadamente, Python llegó para socorrernos. Unos años atrás, Python se había convertido en mi lenguaje de programación favorito porque presentaba un equilibrio entre simplicidad, flexibilidad y elegancia. Estas cualidades de Python, y el trabajo de la comunidad para soportar cada una de las plataformas más importantes, nos permitió escribir el código una sola vez y ejecutarlo en cualquier lugar. Python y la comunidad han sido una influencia para la filosofía más importante que está detrás de Dropbox: realizar un producto simple que reúna toda nuestra vida.

Aquellos que conocen Python pueden confirmar que cuanto dice Drew Houston es cierto. Todo el mundo sabe que programar con Python es un placer, gracias a su sintaxis clara y comprensible, que lo hace simple y fácil de aprender, pero también porque solo con los tipos integrados y con la librería estándar puede hacerse casi todo, y únicamente ante exigencias muy especializadas es preciso recurrir a librerías de terceros. A todo esto debemos añadir otro importante mérito: Python es un lenguaje multiparadigma, es decir, que permite utilizar diferentes paradigmas de programación: meta-programación, procedural, funcional, a objetos y scripting.

NOTA

Por honestidad intelectual, tengo el deber de informaros acerca de una importante contraindicación de uso de Python: crea dependencia. Cuando hayáis aprendido a programar con Python, os será muy difícil prescindir de él.

Dicho esto, Drew ha sacado partido de sus decisiones y, tras menos de un año de la llegada de Guido y del anuncio del logro de los 100 millones de usuarios, en noviembre de 2013 Dropbox había doblado esta cifra, llegando a los 200 millones.

Acabamos esta sección con una sugerencia: la lectura del Python Advocacy HOWTO, que puede consultarse en la siguiente página de su sitio oficial: http://docs.python.org/3/howto/advocacy.html.

La comunidad italiana de Python

Italia desempeña un papel relevante en cuanto al desarrollo de Python se refiere. Desde 2011 y hasta 2013, la Conferencia Europea de Python (EuroPython, www.europython.eu) se ha celebrado en Florencia y ha sido organizada de forma impecable por la Associazione di Promozione Sociale Python Italia.

La comunidad italiana es extensa e, igual que la internacional, siempre está dispuesta a compartir sus propias experiencias, a ayudar a los demás y a organizar de forma conjunta eventos y encuentros.

Formar parte de esta comunidad es muy sencillo: basta con inscribirse en la mailing list, siguiendo las instrucciones de la página http://www.python.it/comunita/mailing-list/.

Implementaciones de Python

Debemos realizar una importante precisión con respecto al término Python. De hecho, este término se utiliza para indicar dos cosas estrechamente vinculadas, aunque distintas: el lenguaje Python y el intérprete Python.

El lenguaje Python, como se puede intuir, es el equivalente a una lengua, como puede ser el italiano o el inglés, compuesto por tanto de un conjunto de palabras, reglas de sintaxis y semántica. El código resultante de la combinación de estos elementos se dice que está escrito en lenguaje Python. Este código, por sí mismo, no tiene ninguna utilidad. Solo resulta útil en el momento en que se tiene una herramienta que lo analiza, lo entiende y lo ejecuta. Y esta herramienta es el intérprete Python.

Por lo tanto, cuando instalamos Python o utilizamos el comando python, estamos instalando o utilizando el intérprete, es decir, la herramienta que nos permite ejecutar el código escrito en el lenguaje de programación Python. El intérprete Python está escrito también en un lenguaje de programación. En realidad, existe más de un intérprete Python, cada uno de los cuales se implementa de forma distinta respecto a los otros:

•CPython: el intérprete clásico, implementado en C (www.python.org);

•PyPy: intérprete en RPython (Restricted Python) y compilador Just-in-Time (www.pypy.org);

•IronPython: implementado sobre la plataforma .NET (www.ironpython.net);

•Jython: implementado sobre la plataforma Java (www.jython.org);

•Stackless Python: rama de CPython que soporta microthreads (www.stackless.com).

La implementación clásica, aquella que encontramos ya instalada en las distribuciones Linux y en los ordenadores Mac, y presente en el sitio web oficial, es la CPython. Esta es la implementación de referencia y se denomina habitualmente Python. Por este motivo, de ahora en adelante en este libro, si no se indica de otra forma, cuando hablemos del intérprete Python, de su instalación y de su funcionamiento, así como cuando nos refiramos a su implementación, estaremos hablando de CPython.

Modos de ejecución del código Python

Como ya hemos dicho, la teoría que estudiaremos en este libro está actualizada para Python 3.4, por lo que se aconseja probar los ejemplos del libro utilizando esta versión.

En cualquier caso, debemos tener en cuenta que el código que funciona con la versión 3.x funciona también con cualquier versión 3.y, siendo y mayor que x.

El intérprete Python en los sistemas Unix-like se encuentra habitualmente en /usr/bin/ python o /usr/local/bin/python:

mientras que en las máquinas Windows normalmente se encuentra en C:\Python.

NOTA

En todo este libro utilizaremos muchas veces comandos Unix y los acompañaremos de notas para explicar su significado. Además, todo el Apéndice A está dedicado a los comandos Unix utilizados en el libro. Acabamos de ver el comando which. Este toma como argumento el nombre de un archivo ejecutable que se encuentra en la ruta de búsqueda y devuelve la ruta completa. En otras palabras, nos dice dónde se encuentra el programa:

Podemos arrancar el intérprete mediante el comando python del terminal:

El intérprete puede arrancar con distintas opciones, que podemos consultar ejecutando Python con la opción -h:

Como podremos ver, el intérprete se comporta igual que una shell Unix: cuando es llamado con la entrada estándar conectado a un terminal, lee y ejecuta los comandos de manera interactiva, y cuando es llamado pasando el nombre de un archivo como argumento, o se redirecciona la entrada estándar de un archivo, lee y ejecuta los comandos incluidos en el archivo. Además, cuando se utiliza la opción -c, ejecuta las instrucciones que se le han pasado en forma de cadena. Veamos en detalle estos tres modos de ejecución.

Modo interactivo

Cuando los comandos se leen desde un terminal, se dice que el intérprete se ejecuta en modo interactivo. Para utilizar este modo se ejecuta python desde la línea de comandos sin argumentos:

El intérprete muestra un mensaje de bienvenida, que empieza con el número de la versión de Python que se está ejecutando, seguido del prompt principal, normalmente marcado con tres signos mayor que. Cuando una instrucción o un bloque de instrucciones ocupa más de una línea, se muestra el prompt secundario, marcado con tres puntos:

Desde el prompt principal y desde el secundario, es posible cancelar la entrada y volver al prompt principal tecleando el carácter de interrupción, normalmente Control-CoDEL:

Podemos salir del modo interactivo (con el estado de salida 0) mediante el comando quit() en el prompt principal, o bien tecleando un carácter de EOF (Control-D en los sistemas Unix-like, Control-Z en Windows).

Como el modo interactivo es muy útil tanto para probar el código rápidamente como para efectuar introspecciones de objetos, es preferible utilizar un entorno más cómodo que el simple modo interactivo integrado. Existen distintas opciones, entre las cuales destacan IPython, bpython, DreamPie o el entorno de desarrollo IDLE (Integrated Development Environment), incluido en las distribuciones Python estándar. Estas soportan funciones avanzadas, como la implementación del tabulador con introspección de objetos, la coloración de la sintaxis, la ejecución de los comandos de shell y el historial de comandos.

NOTA

En los sistemas Unix-like, la librería GNU readline permite tener el historial y la implementación del tabulador también en el modo interactivo integrado.

Para la implementación del tabulador, debemos importar los módulos rlcompleter y readline y llamar a readline.parse_and_bind('tab: complete'):

Aquí (con un doble TAB) tenemos la implementación del tabulador:

Indudablemente, ejecutar estas tres instrucciones cada vez que se trabaja con el modo interactivo es un fastidio. Por ello, es conveniente automatizar el procedimiento creando un archivo con las tres instrucciones y asignándolo a la variable de entorno PYTHONSTARTUP. De esta manera, siempre que trabajemos con el modo interactivo, Python ejecutará en primer lugar las instrucciones contenidas en el archivo. Veamos cómo realizar lo que acabamos de describir en un sistema Unix-like con shell bash. Creamos en nuestra home un archivo de inicio, llamado, por ejemplo, .pyrc, con las tres instrucciones Python:

Añadimos la siguiente línea en el archivo .bashrc de la home (si este archivo no existe, lo creamos):

Hecho. Ahora solo tenemos que abrir un terminal (o escribir el comando source ~/.pyrc en el terminal que ya está abierto) y arrancar el intérprete interactivo.

Los archivos que contienen código Python se denominan módulos Python. Hablaremos de los módulos en la sección Los módulos como contenedores de instrucciones de este capítulo, y de forma más profunda en una sección del Capítulo 4. Como veremos, los módulos realizan distintas tareas. Por ejemplo, un módulo puede ser utilizado como contenedor lógico en el cual se definen clases y funciones, o bien como script, para ser ejecutado con el fin de obtener un resultado o de realizar ciertas acciones.

Un programa Python está compuesto por uno o más módulos, y por tanto su arquitectura puede ubicar desde un simple script hasta un complejo programa estructurado en cientos de módulos. Los módulos Python tienen normalmente el sufijo .py, y tanto en Windows como en los sistemas Unix-like pueden ejecutarse con el prompt de los comandos, pasando el nombre del archivo como argumento. Por ejemplo, el archivo myfile.py:

puede ser ejecutado desde un terminal Unix, como se muestra a continuación:

NOTA

El comando cat de los sistemas Unix muestra el contenido de uno o más archivos de texto (o de la entrada estándar) sobre un terminal textual y produce sobre la salida estándar la concatenación de su contenido.

Puesto que en Windows los archivos .py se asocian directamente al ejecutable python.exe, es posible ejecutarlos simplemente mediante un doble clic sobre ellos. En cambio, en los sistemas Unix-like, como en los script de shell, los módulos pueden ser directamente ejecutados escribiendo el shebang en la primera línea del archivo:

y convirtiéndolos después en ejecutables:

NOTA

El comando chmod de los sistemas Unix modifica los permisos de archivos y directorios. Por ejemplo, si queremos que el propietario del archivo tenga los permisos de ejecución, pasamos +x como argumento de chmod:

En este punto, el archivo puede ser ejecutado directamente desde la línea de comandos. Dado que como primera línea del archivo se encuentra el shebang #! /usr/bin/env python, el archivo se ejecutará con Python:

Para más información acerca del comando chmod y sobre la escritura ./ utilizada en el ejemplo anterior, podemos consultar el Apéndice A.

Por defecto, en Python 3 el intérprete utiliza la codificación UTF-8 para descodificar el contenido de los módulos. Pero, si queremos escribir el código utilizando una codificación diferente, también podemos hacerlo, siempre y cuando el intérprete sea informado de ello. Podemos especificar la codificación utilizada insertando en el módulo un comentario especial debajo del shebang, que contenga coding:nome o coding=nome:

NOTA

Normalmente, este comentario especial que acabamos de mostrar en el ejemplo contiene los tres caracteres -*- antes o después de la indicación del código. Esta sintaxis se inspira en la escritura que se utiliza con Emacs para definir las variables locales en un archivo. Pero para Python estos símbolos no significan nada, puesto que el programa comprobará que en el comentario aparece la indicación coding:nome o coding=nome, sin prestar atención al resto.

Ejecución de cadenas pasadas desde la línea de comandos

Cuando el intérprete es llamado mediante la opción -c, este acepta como argumento una cadena que contiene instrucciones Python y las ejecuta:

Utilizaremos a menudo esta modalidad de ejecución durante todo el libro.

Introducción al lenguaje

En esta sección hablaremos de aspectos carácterísticos de Python, de los principales tipos integrados, de la definición de funciones y clases, de los archivos, de la librería estándar y de los módulos. Esta pretende ser solo una breve introducción al lenguaje, puesto que hablaremos con más profundidad de estos aspectos en el resto del libro.

Indentación del código

En Python un bloque de código anidado no está delimitado por palabras clave o por llaves sino por el signo de dos puntos y la indentación (sangría) misma del código:

NOTA

Por bloque de código anidado entendemos el código interno a una clase, a una función, a una instrucción o sentencia if, a un bucle for, a un bucle while y demás. Solo los bloques de código anidados van precedidos por una instrucción que termina con el signo de los dos puntos. Más adelante veremos que los bloques anidados son la suite de las instrucciones compuestas o de las relativas cláusulas.

La indentación debe ser la misma para todo el bloque, por lo que el número de espacios en blanco (espacios o tabulaciones) es importante:

En la PEP-0008 se aconseja utilizar cuatro espacios para cada nivel de indentación y no mezclar nunca espacios y tabulaciones.

NOTA

Si utilizamos Vim como editor y queremos que los bloques de código se indenten automáticamente con cuatro espacios, podemos escribir en el archivo de configuración .vimrc las siguientes líneas:

A menudo tendremos que editar archivos escritos por otras personas, los cuales contengan indentaciones con tabulaciones. En estos casos, con Vim, una vez efectuada la configuración indicada, podemos convertir todas las tabulaciones del archivo en espacios mediante el comando retab.

Utilizar a la vez espacios y tabulaciones para indentar instrucciones en el mismo bloque es un error:

NOTA

En Python 3, a diferencia de Python 2, también es un error pasar de espacios a tabulaciones (o viceversa) al cambiar de nivel de indentación, como se muestra en la sección titulada Uso inconsistente de espacios y tabulaciones del Apéndice B.

Por tanto, la indentación es un requisito del lenguaje y no una cuestión de estilo, y esto supone que todos los programas Python tengan el mismo aspecto. Pero quizás un día las cosas cambien, y podremos utilizar también llaves para delimitar los bloques de código:

No, esta posibilidad no existe, por lo que las discusiones acerca de cómo indentar y posicionar los delimitadores de los bloques no tienen razón de ser (consulte la PEP-0666), y todo esto está perfectamente en línea con el Zen de Python, según el cual, como veremos dentro de poco, "debería haber un modo obvio, y preferiblemente uno solo, de hacer las cosas". Este único modo obvio de hacer las cosas se denomina pythonic way. Finalmente, como ya sabemos, no es necesario terminar las instrucciones con un punto y coma, sino que basta con saltar a una nueva línea. En cambio, el punto y coma es necesario para insertar más instrucciones en la misma línea:

Insertar varias instrucciones en la misma línea es de un estilo de programación pésimo, y de hecho está desaconsejado por la PEP-0008. En el resto del libro utilizaremos el punto y coma solo para ejecutar cadenas desde la línea de comandos:

NOTA

Existen distintas herramientas que permiten comprobar si nuestro código respeta la PEP-0008. Podemos realizar un rápido chequeo online con http://pep8online.com/, o bien, como alternativa, podemos utilizar pep8 (https:// pypi.python.org/pypi/pep8) o pyflakes. También están disponibles otros plugins que permiten efectuar la comprobación con Vim.

Los objetos integrados

Cuando un programa es ejecutado, Python, a partir del código, genera estructuras de datos, denominados objetos, sobre las cuales basa después todo el proceso de elaboración. Los objetos se almacenan en la memoria del ordenador, para que puedan ser llamados cuando el programa se refiere a ellos. En el momento en que ya no sirven, un mecanismo singular, denominado garbage collector, libera la memoria que ocupaban. Esta primera descripción de un objeto puede ser demasiado abstracta para que entendamos de qué se trata realmente. No nos preocupemos, puesto que es suficiente para la finalidad de esta sección y veremos otras más formales y concretas en su momento. Los objetos que constituyen el corazón de Python, denominados objetos integrados, se dividen habitualmente en las siguientes categorías: tipos de datos básicos, funciones integradas, clases y tipos de excepciones integradas. Aquí realizaremos solo una breve aproximación a los objetos integrados, puesto que les dedicaremos todo el Capítulo 2.

Tipos de datos básicos

Aquello a lo que llamamos tipos de datos básicos no es más que el conjunto de los principales tipos integrados. Estos pueden ser agrupados en cuatro categorías:

•números: enteros (tipo int), booleanos (bool), complejos (complex), de punto flotante (float);

•conjuntos: representados por el tipo set;

•secuencias: cadenas (str y byte), listas (list) y tuplas (tuple);

•diccionarios: representados por el tipo dict.

Los tipos de datos básicos pertenecen a una categoría de objetos llamados clases, o también tipos. La carácterística de los tipos, como su nombre indica, es la de representar un tipo de dato genérico, a partir del cual podamos crear objetos específicos de dicho tipo, llamados instancias. Por ejemplo, a partir del tipo str podemos crear las instancias "python", "Guido" y"abc"; a partir del tipo int las instancias 22 y 77; a partir del tipo list las instancias [1, 2, 3] y ['a', 'b', 'c', 'd'], y así para el resto de tipos. Por lo tanto, diremos que una cadena de texto es un objeto de tipo str, o, lo que es lo mismo, que es una instancia del tipo str. Del mismo modo, diremos que un entero es un objeto del tipo int, o, lo que es lo mismo, una instancia del tipo int, y así para los números de punto flotante, las listas, etc.

Algunos objetos son fáciles de imaginar debido a que tienen muy en cuenta tanto el concepto de valor como el de tipo, como en el caso de las instancias de los tipos numéricos:

Su tipo, como el de cualquier otro objeto, puede obtenerse a partir de la clase integrada type:

Los objetos están siempre carácterizados por un tipo, mientras que solo a alguno de ellos podemos asociarle de manera intuitiva un valor. Además del tipo, otros elementos carácterísticos de los objetos son la identidad y los atributos.

La identidad está representada por un número que los identifica de manera única, y es devuelta por la función integrada id():

Los atributos son identificadores accesibles mediante el delimitador punto:

En este ejemplo bit_length, as_integer_ratio e imag son atributos, respectivamente, de a, b y c. Los atributos están estrechamente vinculados al tipo de un objeto. Por ejemplo, todos los objetos de tipo str tienen el atributo str.upper(), el cual devuelve una versión de la cadena en mayúsculas:

y todos los objetos de tipo list tienen el atributo list.sort() que reordena los elementos de la lista:

Cuando a un identificador le siguen unos paréntesis (), se dice que el objeto al cual hace referencia es llamable (callable). Al aplicar los paréntesis al identificador, decimos que estamos llamando al objeto. Consideremos, por ejemplo, un número complejo:

Todos los números complejos tienen el siguiente atributo:

y este es llamable. Cuando lo llamamos, nos devuelve el complejo conjugado del número:

Podemos descubrir si un objeto es llamable gracias a la función integrada callable():

Si intentamos llamar a un objeto que no es llamable, obtenemos un error:

Los objetos llamables se distinguen de los que no lo son por el hecho de que permiten ejecutar una serie de operaciones, o bien un bloque de instrucciones. Las funciones, por ejemplo, son objetos llamables. Para aclarar mejor este concepto, consideremos la función integrada sum:

esta es un objeto llamable:

y si la llamamos, ejecuta la suma de los elementos del objeto que pasamos como argumento:

Si en una llamada no debemos pasar ningún argumento, igualmente utilizaremos los paréntesis:

Los parentesis, de hecho, indican que queremos ejecutar las operaciones que pertenecen al objeto llamable.

Sus atributos c.real y c.imag no son métodos y, por tanto, no pueden ser llamados. En cambio, el atributo c.conjugate es un método y al ser llamado ejecuta la operación c.real - c.imag y devuelve el resultado:

NOTA

En este libro, cuando en el texto escribamos el identificador de un método o de una función, utilizaremos los paréntesis. Por ejemplo, escribiremos c.conjugate() e id() y no c.conjugate e id para indicar el método coniugate() de los números complejos y la función integrada id(). En cambio, cuando hablemos de las clases, aunque son objetos llamables, no utilizaremos los paréntesis, por lo que escribiremos, por ejemplo, type y no type(). En el Capítulo 6, cuando hablemos del modelo a objetos de Python y de las meta-clases, entenderemos por qué tiene sentido la distinción entre objetos que son clases y objetos que no lo son.

Sustancialmente, los métodos son funciones y, de hecho, son definidos como tales, como veremos en la sección Definir las clases.

Si estos conceptos os parecen demasiado abstractos, no os preocupéis, puesto que los retomaremos más de una vez en este libro y los afrontaremos de manera exhaustiva en el Capítulo 5, cuando presentemos la programación orientada a objetos y veamos en detalle los distintos tipos de método.

La función integrada dir() devuelve una lista de los nombres de los atributos más significativos de un objeto:

Todos los atributos que empiezan y terminan con un doble guion bajo se denominan atributos especiales o también atributos mágicos. Veremos el significado de alguno de ellos en este capítulo y en los dos siguientes, mientras que del resto hablaremos de forma más profunda en el Capítulo 6.

La función integrada hasattr() nos dice si un objeto tiene cierto atributo:

Veamos ahora los tipos de datos básicos. Como ya hemos dicho, esta será solo una breve introducción, puesto que los trataremos con detalle en el Capítulo 2.

Las cadenas de texto

Las cadenas de texto en Python están representadas por una secuencia de caracteres Unicode de longitud arbitraria, encerrados entre comillas simples, comillas, tres comillas simples o tres comillas.

Una cadena de texto es un objeto de tipo str:

y sus elementos están ordenados, lo que significa que a cada uno de ellos se le asocia un número entero llamado índice, que vale 0 para el elemento más a la izquierda y aumenta en una unidad progresivamente para el resto, yendo ordenadamente de izquierda a derecha.

Por este motivo, las cadenas de caracteres pertenecen a la categoría de las secuencias, la cual comprende todos los tipos integrados que representan contenedores ordenados de longitud arbitraria (cadenas, listas y tuplas).

El método str.index() devuelve el índice de la primera aparición del elemento pasado como argumento:

También es posible completar la operación inversa, es decir, obtener un elemento de la cadena de caracteres utilizando como palabra clave el índice.

Esta operación se denomina indexación (indexing) y se lleva a cabo mediante la siguiente sintaxis:

Otra operación que podemos realizar con los índices es la fragmentación (slicing), que permite obtener los elementos de una cadena comprendidos entre dos índices arbitrarios:

Las operaciones de indexación y de fragmentación son habituales en todos los objetos que pertenecen a la categoría de las secuencias. Esta categoría se encuentra dentro de otra más genérica, la de los objetos iterables, de los cuales hablaremos en la sección Objetos iterables, iteradores y contexto de iteración al final de este capítulo. Los objetos iterables soportan una operación denominada de desempaquetado (unpacking), que consiste en asignar los elementos del objeto a etiquetas, del modo siguiente:

Veamos otras operaciones que podemos realizar con las cadenas de caracteres:

Los objetos de tipo str no pueden ser modificados, y por este motivo se dice que son objetos inmutables:

Las listas

Las listas también pertenecen a la categoría de las secuencias, pero, a diferencia de las cadenas, pueden contener objetos de algún tipo. Se representan insertando los elementos entre corchetes, separados por una coma:

Como ya sabemos, las listas pueden ser modificadas. Por este motivo se dice que son objetos mutables.

Las tuplas

Otros tipos de objetos parecidos a las listas son las tuplas. Estas también pertenecen a la categoría de las secuencias y pueden contener objetos de cualquier tipo, pero, a diferencia de las listas, son inmutables, y se representan insertando los elementos entre paréntesis en lugar de entre corchetes:

Los diccionarios

Los diccionarios son contenedores que tienen como elementos parejas clave:valor. Se representan insertando los elementos entre llaves, separados por una coma:

A diferencia de los objetos que pertenecen a la categoría de las secuencias, los diccionarios no son contenedores ordenados, por lo cual su búsqueda se efectúa por clave y no por índice:

Los conjuntos

Los conjuntos son contenedores no ordenados de objetos únicos e inmutables, y tienen las mismas propiedades que los conjuntos matemáticos. Los conjuntos se representan insertando los elementos entre llaves y separándolos con una coma:

Los conjuntos son objetos mutables:

Sin embargo, los elementos de un conjunto deben ser objetos inmutables:

Funciones y clases integradas

Ya hemos visto alguna clase y función integrada, como type y id(). Veamos ahora otros ejemplos en acción para poder ir apreciando la potencia de los objetos integrados de Python:

Un primer vistazo a la librería estándar y al concepto de módulo

Probablemente hemos oído decir que Python tiene las pilas incluídas (batteries included). Esta frase la utilizan los pythonistas para decir que, una vez instalado Python, ya disponemos de todo cuanto necesitamos para ser productivos, puesto que, además de contar con objetos integrados de altísimo nivel, disponemos también de una librería estándar (standard library) que lo abarca prácticamente todo.

La librería estándar de Python está estructurada en módulos, cada uno de los cuales tiene un entorno de uso concreto. Por ejemplo, el módulo math nos permite trabajar con las matemáticas, el módulo datetime, con la fecha y la hora, entre otros. Para importar un módulo se utiliza la palabra clave import, y después, como para todos los otros objetos, podemos acceder a sus atributos mediante el delimitador punto:

Podemos utilizar import en combinación con la palabra clave from para importar desde el módulo solo los atributos que nos interesan, evitando así tener que escribir el nombre del módulo cada vez.

Otros módulos de la librería estándar, que utilizaremos en múltiples ocasiones en este libro, son datetime, sys y os. El módulo datetime, como ya hemos dicho, nos permite trabajar con la fecha y la hora:

El módulo sys se ocupa de los objetos vinculados con el intérprete y la arquitectura de nuestro ordenador:

El módulo os, del cual hablaremos en la sección Ejercicio final de este capítulo, proporciona el soporte para interactuar con el sistema operativo.:

Los entornos de uso de la librería estándar no se detienen aquí. Existen módulos que proporcionan el soporte para acceder a internet y controlar el navegador web:

Otros módulos proporcionan una interfaz para los archivos comodines (wildcard):

entre muchos otros.

Esta ha sido una muy breve introducción a la librería estándar, de la cual hablaremos de nuevo en este libro. Si no podéis esperar, podéis echar un vistazo a la documentación online, que encontraréis en la página web http://docs.python.org/3/library/index.html.

Definir las funciones

Las funciones se definen mediante la instrucción def:

Si no se encuentra la instrucción return, la función devuelve implícitamente el objeto None:

Hablaremos de las funciones de forma detallada en el Capítulo 3.

Definir las clases

Los tipos de datos básicos son objetos increíblemente útiles que nos permiten ser inmediatamente productivos y escribir gran parte del código sin sentir la necesidad de disponer de objetos de otro tipo. Pero cada uno de nosotros tiene sus propias exigencias, y quizás desearía utilizar objetos que le faciliten al máximo el trabajo.

Supongamos, por ejemplo, que queremos escribir una aplicación que solicite al usuario completar una acción de registro insertando sus datos, como nombre y apellido. En este caso, estaría bien tener los objetos con las carácterísticas de una persona, que tengan, por ejemplo, como atributos precisamente un nombre, un apellido y un método que restituyera el tiempo pasado desde el momento del registro. Para hacerlo, el lenguaje dispone de la instrucción class. Esta permite crear un objeto llamado clase o tipo, mediante el cual podemos crear otros objetos denominados instancias de la clase. Si hacemos memoria, recordaremos que ya hemos presentado estos conceptos en la sección Tipos de datos básicos, dedicada precisamente a las instancias de los tipos de datos básicos.

Todas las instancias de una clase tienen los mismos atributos, por lo que, por ejemplo, podemos crear una clase que defina a una persona genérica y utilizar sus instancias para representar a los usuarios que se registran en nuestra aplicación:

Las instancias de una clase MyClass se denominan también objetos de tipoMyClass, por lo que diremos que las instancias p1 y p2 del tipo Person son objetos de tipo Person.

La función integrada isinstance() nos dice si un objeto es una instancia de una clase:

Si no tenéis una base en programación orientada a objetos y no os queda claro todo cuanto hemos dicho acerca del concepto de clase y de su entorno de uso, no os preocupéis: el Capítulo 5 está dedicado por completo a estos argumentos.

Un primer vistazo a los archivos

Los archivos en Python se gestionan mayormente con la función integrada open(). Dicha función permite crear un objeto archivo (file object), es decir, un objeto mediante el cual podemos interactuar con el archivo que reside en el sistema de archivos, que llamaremos archivo subyacente. Los atributos del objeto archivo nos proporcionan información como el nombre del archivo y la codificación que se utiliza para leerlo:

Dichos atributos también nos permiten interactuar con el archivo subyacente, por ejemplo, para leer su contenido:

Podemos obtener el contenido del archivo también como una lista de líneas, mediante el método readline():

Como podemos observar, las líneas son cadenas que terminan con \n. Esta representación no corresponde a la secuencia de los dos caracteres \ y n, sino a un carácter único:

Esto forma parte de un conjunto de caracteres, denominados caracteres de control, los cuales no tienen asociado ningún símbolo gráfico. Hablaremos de ello en profundidad en el próximo capítulo. De momento solo nos interesa saber que \n se utiliza para representar un salto de línea, denominado en inglés newline. Por tanto, al leer el contenido de un archivo, cada salto de línea está representado por \n, y cada \n dentro de una cadena se ve como un salto de línea cuando esta se escribe en un archivo o se muestra en pantalla con print():

Podemos ejecutar operaciones en las líneas de un archivo de manera muy sencilla. De hecho, cuando en un bucle for se repite un archivo, se accede automáticamente a sus líneas, una a una:

Los archivos tienen un modo de apertura, como el de lectura o escritura. Para especificar dicho modo, se pasa a open() como segundo argumento una cadena. La cadena "w" indica escritura (writing mode), mientras que la cadena "r" indica lectura (reading mode). Si no se especifica ningún modo, por defecto el archivo se abre en modo lectura:

Damos por terminada nuestra introducción a los archivos. Hablaremos de nuevo de ellos con mayor profundidad en el Capítulo 3.

La función integrada print()

La forma general de la función integrada print() es la siguiente:

Si no se le pasa ningún objeto, imprime una línea en blanco:

En cambio, si se le pasa uno o más objetos obj_i, los imprime separándolos con la cadena sep, que por defecto es un espacio, y terminando la impresión con la cadena end, que por defecto es un salto de línea:

Básicamente, la función print() solo crea la cadena:

para después pasarla al método write() del objeto asignado al parámetro file. Por tanto, y puesto que por defecto tenemos file=sys.stdout, la siguiente print():

equivale a esta llamada al método sys.stdout.write():

Así, si como archivo no utilizamos la salida estándar sino un archivo físico:

el código equivalente a la print() es el siguiente:

El parámetro flush sirve para forzar el vaciado del buffer inmediatamente después de la impresión. Por defecto, tenemos flush=False, lo que significa que el contenido del buffer no se escribe inmediatamente en el archivo:

En cambio, si escribimos flush=True, el buffer se vacía en cada impresión:

Hablaremos del buffering en la sección Los archivos del Capítulo 3 y en el Apéndice C. Si quisiéramos efectuar un elevado número de impresiones en un archivo en lugar de en pantalla, sería genial poder evitar pasar cada vez el archivo a la print() como argumento. Podemos hacerlo cambiando temporalmente sys.stdout, dado que este se asigna por defecto al parámetro file:

Obtener información sobre los objetos

El término introspección se utiliza para referirse a la capacidad de obtener información sobre los objetos. Python tiene muchísimas herramientas para hacer introspección, muchas de las cuales ya hemos visto, como la clase integrada type y la función integrada id():

las funciones integradas hasattr() y dir():

las funciones integradas isinstance() y callable():

y la palabra clave in:

Más adelante veremos muchos otros, como la palabra clave is, que podemos utilizar para saber si dos objetos son idénticos:

Profundizaremos en el concepto de identidad dentro de poco. Por el momento concentrémonos en dos importantes herramientas para la introspección que se utilizan principalmente en el modo interactivo: las funciones integradas dir() y help().

La función integrada dir()

La función integrada dir(), como ya hemos dicho, devuelve una lista de los nombres de los atributos más significativos de un objeto:

La finalidad de la función integrada dir() no es la de comprobar si un objeto tiene un atributo concreto, pues no todos los atributos del objeto aparecen en la lista devuelta por la función:

Para comprobar si un objeto tiene un atributo indicado debemos utilizar hasattr():

El ámbito principal de uso de dir() es la ayuda al programador durante la fase de escritura del código. Cuando programan, a menudo no recuerdan de memoria todos los atributos de un objeto, y normalmente consultan la documentación para intentar encontrar una lista de los atributos, esperando que a partir del nombre se pueda deducir el significado.

Por ejemplo, estamos escribiendo el código y necesitamos obtener la versión en mayúsculas de una cadena de texto. Sabemos que las cadenas tienen un método que devuelve una copia de la misma en mayúsculas, pero no recordamos el nombre. Es en este momento cuando dir() se convierte en nuestra mejor amiga. Iniciamos el intérprete en modo interactivo y controlamos la lista de los atributos de las cadenas de texto:

¡Premio! Es el atributo str.upper():

Por tanto, debemos utilizar la función integrada dir() como si fuera el índice de nuestra documentación. De forma parecida a un índice, dir() nos proporciona una lista de los nombres, pero no nos da información acerca de su significado.

La función integrada help() y las cadenas de documentación

Para obtener información sobre un atributo, podemos utilizar la función integrada help(). Para entender cuándo y cómo utilizarla, consideremos un ejemplo práctico. Supongamos que debemos escribir el código para poder leer las líneas del archivo siguiente:

y obtener para cada línea la suma de sus elementos (los números separados por un punto y coma). En la sección Un primer vistazo a los archivos, ya hemos podido ver que podemos leer las líneas de un archivo de una en una, como cadenas de texto. Ahora queremos saber si las cadenas tienen un método que permita separarlas según un carácter en concreto (en nuestro caso, el punto y coma). Así, abrimos la shell interactiva y escribimos dir(str). Vemos que las cadenas de texto tienen el método str.split() que parece ser el que buscábamos, por lo que intentaremos saber si se comporta tal y como queremos:

Ya sabemos que str.split() divide la cadena según los espacios. Pero nosotros queremos dividirla según el punto y coma, por lo que nos interesa saber si podemos pasar a str.split() un argumento que indique el carácter de separación. Y es en este punto cuando entra en juego la función help(). Si llamamos a help(str.split) en la shell interactiva, aparece en la pantalla la documentación del método str.split():

La documentación nos dice que str.split() acepta un primer argumento opcional que indica el elemento según el cual debe dividirse la cadena:

Ahora debemos ejecutar la suma de los elementos. En la sección Funciones y clases integradas hemos podido comprobar que la función integrada sum() realiza la suma de los elementos de una secuencia. Para poderlos sumar antes debemos convertirlos en números enteros:

Esta es una sintaxis denominada lista por comprensión (list comprehension), que nos permite hacerlo de un modo más conciso:

Podemos usar esta sintaxis para generar en línea el argumento que se debe pasar a sum():

En realidad, en este caso podemos utilizar una sintaxis todavía más sencilla, denominada expresión generadora (en inglés, generator expression), que veremos en el ejercicio final de este capítulo y de manera más detallada en el Capítulo 3:

Ahora tenemos toda la información que sirve para escribir nuestro programa:

La función integrada help() recaba la mayor parte de la información accediendo a cada una de las cadenas de texto de la documentación, denominadas cadenas de documentación (en inglés, documentation string o, de manera más sencilla, docstring). Las cadenas de documentación se utilizan para documentar los módulos, las clases, los métodos y las funciones, y se ubican en la parte superior del cuerpo de estos elementos. La PEP-0257 sugiere utilizar las triples comillas para delimitar el texto de las cadenas de documentación, incluso si ocupan una sola línea. Consideremos la siguiente función:

La primera línea del cuerpo de doubling() es una cadena de documentación y se asigna al atributo _ _doc_ _:

La función integrada help() obtiene la información del objeto accediendo a este atributo, como muestra el resultado de help(doubling):

NOTA

Observad que hemos llamado a help(doubling) y no a help(doubling()). Cuando pasamos a help() un objeto llamable no debemos utilizar el paréntesis, puesto que si no, llamamos al objeto y, en lugar de pasar a help() la función, le pasamos el objeto que ha devuelto.

Podemos obtener la documentación de los métodos de los tipos de datos básicos calificándolos tanto con la clase como con la instancia:

El Zen de Python

El 3 de junio de 1999, Patrick Phalen envió un mensaje a la python-list, titulado The Python Way. En él básicamente sugería a Guido van Rossum y Tim Peters escribir un documento con 10 o 20 aforismos que pudieran resumir el espíritu del lenguaje, una especie de Zen de Python:

¿Estarían dispuestos Guido e Tim Peters a colaborar en la elaboración de un breve documento -- llamémoslo “The Python Way” en ausencia de un título mejor -- que contenga 10 o 20 líneas para guiar a aquellos que se acercan a Python desde otros lenguajes, y que quieren conocer inmediatamente la manera de utilizarlo de forma correcta en aquellas situaciones más insidiosas (aplicar el cierre, etc.)?

Yo pensaba en un tipo de introducción muy breve, una especie de "Elementos de Estilo" de Strunk & White para Python, que listara las típicas recomendaciones fundamentales para escribir el código según el espíritu del lenguaje. Estoy hablando de una especie de Zen de Python -- algo a lo que acudir y consultar cuando aparecen demasiadas lamentaciones del tipo “fix Python now”.

Mensaje original:

http://mail.python.org/pipermail/python-list/1999-June/014096.html.

Al día siguiente, Tim Peters respondió a Patrick listando 19 aforismos y terminó diciendo:

Aquí están: exactamente 20 tesis pythónicas, contando la que dejo que escriba Guido. Si las respuestas a cualquier problema de diseño con Python no resultan obvias después de haberlas leído, entonces me retiro.

Mensaje original:

http://mail.python.org/pipermail/python-list/1999-June/001951.html.

El número 20 nunca ha llegado, y estos 19 aforismos han sido recogidos en la PEP-0020, The Zen of Python, escrita en 2004 por el mismo Tim Peters.

NOTA

Otro importante documento, que indica las directrices de comportamiento, es el Code of Conduct (Código de conducta), aprobado en abril de 2013 por la PSF. A diferencia del Zen de Python, que se centra en el código, el código de conducta pone su atención en el comportamiento para mantenerse en la comunidad Python; más concretamente, describe a un miembro de la comunidad Python como: abierto (open), considerado con los otros miembros (considerate) y respetuoso (respectful). El documento se encuentra disponible en la página: http://www.python.org/psf/codeofconduct/.

El módulo this de la librería estándar también está dedicado al Zen. En realidad, este módulo es más que un simple reclamo a los 19 aforismos: es un huevo de Pascua. Está escrito de manera que se pueda visualizar el Zen cuando se importa y, al mismo tiempo, que represente un claro ejemplo de aquello que no se debe hacer.

El origen del módulo this se remonta al año 2001, cuando, en ocasión de la décima International Python Conference (todavía no existía la Python Conference – PyCon), se estaba buscando un eslogan para estampar en las camisetas. Había distintas propuestas, pero al final la elección recayó en import this. Una vez elegido el eslogan, solo faltaba implementar un módulo denominado this. Y este fue el resultado:

Dudo que alguien entienda el significado de todo esto. El módulo ha sido escrito especialmente así, como ejemplo para dar a entender la importancia de seguir el Zen de Python:

Y esta es la traducción en español:

Si la validez de estas reglas nos ha convencido, podemos pasar a la siguiente sección; en caso contrario, será mejor que continuemos leyendo:

Python, además, sigue la conocida filosofía de Unix, doing one thing well, según la cual cada programa debe realizar una única cosa, pero bien hecha. Sin embargo, hacer una cosa bien no significa hacerla perfectamente. La perfección en el mundo real no existe, por lo que, según la frase la practicidad vence a la pureza, debemos hacer las cosas bastante bien, como sugiere también Alex Martelli en su charla titulada Good enough is good enough: http://pyvideo.org/video/1738/good-enough-is-good-enough.

Los elementos del código Python

Si miramos un archivo contenedor del código Python, veremos que, como cualquier archivo de texto, está formado por una serie de líneas, que llamaremos líneas físicas. Las líneas físicas no tienen ningún significado para el intérprete Python, sino que sirven sencillamente para organizar visualmente el código de manera legible. Por ejemplo, el archivo myfile.py contiene dos líneas físicas:

El significado obtenido por el intérprete son las líneas lógicas. Una línea lógica corresponde normalmente a una línea física, y es posible subdividir una línea física en más de una línea lógica, separándolas con un punto y coma. Por ejemplo, el siguiente archivo myfile.py contiene tres líneas físicas y seis líneas lógicas:

Probablemente en pocas ocasiones se verán más líneas lógicas en la misma línea física, puesto que es un pésimo estilo de programación, según aconseja de manera apropiada la PEP-0008.

También es posible repartir una línea lógica en varias líneas físicas. Esto puede verse a menudo, y puede hacerse tanto con la barra invertida, como en el ejemplo siguiente:

como mediante paréntesis:

y también separando en varias líneas físicas una lista, una tupla, un conjunto o un diccionario:

El texto contenido en el interior de una línea lógica pertenece a una de estas categorías: comentarios, literales, operadores, palabras clave, etiquetas y delimitadores. Consideremos, por ejemplo, el archivo siguiente:

Se estructura en cuatro líneas lógicas. En la primera, hay dos etiquetas, x e input, un literal de tipo cadena, que empieza y acaba con comillas simples, y tres delimitadores (los dos paréntesis y el signo igual). En la segunda línea hay tres etiquetas (num, int y x), tres delimitadores (los dos paréntesis y el signo igual) y un comentario (el texto que empieza con un símbolo de almohadilla y termina con la línea física). En la tercera hay dos etiquetas (result y num), un operador (/), un literal de tipo entero (10), un delimitador (el signo igual) y tres palabras clave: if, else y None. Por último, en la cuarta línea hay dos etiquetas (print y result) y dos delimitadores (los paréntesis).

El componente del intérprete que se ocupa de efectuar el análisis lexical del código se denomina parser.

Los comentarios

Como hemos visto, los comentarios sirven principalmente para documentar el código con el fin de facilitar su lectura. Se trata de fragmentos de texto que empiezan con el símbolo de almohadilla y terminan con el final de la línea física. Cuando el intérprete encuentra un comentario, no ejecuta ninguna acción:

Sin embargo, en ocasiones los comentarios son analizados por el parser por tener un significado especial, como en el caso del comentario sobre la codificación del código fuente, que hemos visto en la sección Ejecución del código Python a partir de un archivo.

Literales

Las instancias de los tipos de datos básicos se distinguen fácilmente unas de otras, además de por el tipo, también por el valor. Estos objetos son el corazón del lenguaje y representan los elementos clave de todos los programas Python. Para facilitar tanto la lectura como la escritura de los programas, se ha decidido asociar a estas instancias representaciones textuales de inmediata comprensión, que permitan determinar de manera única tanto el tipo como el valor del objeto al cual se refieren. Estas representaciones textuales se denominan literales.

Por ejemplo, un literal de cadena de texto es código delimitado por comillas simples, comillas, triples comillas simples o triples comillas. Cuando el programa se ejecuta, Python crea a partir del literal un objeto de tipo str