2.1: Hola, Mundo

Última actualización
Guardar como PDF

Page ID: 55133

$ \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } $ $ \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} $$\newcommand{\id}{\mathrm{id}}$ $ \newcommand{\Span}{\mathrm{span}}$ $ \newcommand{\kernel}{\mathrm{null}\,}$ $ \newcommand{\range}{\mathrm{range}\,}$ $ \newcommand{\RealPart}{\mathrm{Re}}$ $ \newcommand{\ImaginaryPart}{\mathrm{Im}}$ $ \newcommand{\Argument}{\mathrm{Arg}}$ $ \newcommand{\norm}[1]{\| #1 \|}$ $ \newcommand{\inner}[2]{\langle #1, #2 \rangle}$ $ \newcommand{\Span}{\mathrm{span}}$ $\newcommand{\id}{\mathrm{id}}$ $ \newcommand{\Span}{\mathrm{span}}$ $ \newcommand{\kernel}{\mathrm{null}\,}$ $ \newcommand{\range}{\mathrm{range}\,}$ $ \newcommand{\RealPart}{\mathrm{Re}}$ $ \newcommand{\ImaginaryPart}{\mathrm{Im}}$ $ \newcommand{\Argument}{\mathrm{Arg}}$ $ \newcommand{\norm}[1]{\| #1 \|}$ $ \newcommand{\inner}[2]{\langle #1, #2 \rangle}$ $ \newcommand{\Span}{\mathrm{span}}$$\newcommand{\AA}{\unicode[.8,0]{x212B}}$

Antes de comenzar con la programación en Python, es útil considerar cómo encaja el lenguaje en el paisaje y la historia de lenguajes similares. Inicialmente, la programación informática no estaba muy alejada del hardware en el que se estaba codificando. Esto significaba escribir “bytecode” —o su equivalente legible por humanos, código ensamblado—que hacía referencia explícita a ubicaciones de memoria (RAM) y copiaba datos hacia y desde el número relativamente pequeño de registros de CPU (las unidades de almacenamiento directamente accesibles por la CPU). Desafortunadamente, esto significó que el código tuvo que ser reescrito para cada uno de los muchos tipos de CPU. Posteriormente, se desarrollaron lenguajes más portátiles como el C. Estos lenguajes aún funcionan cerca del hardware de muchas maneras; en particular, el programador debe decirle a la computadora cómo debe asignar y desasignar la memoria de la RAM. Por otro lado, alguna abstracción proporciona construcciones de codificación de nivel superior que no son específicas del tipo de CPU. Este código es luego compilado en bytecode por un programa de compilación para cada CPU específica (como se discutió en capítulos anteriores, tuvimos que compilar algún software desde la fuente para instalarlo). El resultado es un programa rápido y a menudo optimizado que libera al programador de tener que preocuparse por la gran variedad de tipos de CPU.

Posteriormente, algunos programadores decidieron que no querían tener que preocuparse por especificar cómo debía asignarse y desasignarse el espacio RAM. También querían más funciones integradas en sus idiomas para ayudarlos a diseñar rápidamente programas complicados. Uno de los lenguajes destinados a lograr estos objetivos es Python, un proyecto iniciado en 1988 por el matemático, informático y fan de Monty Python Guido van Rossum. ^[1] Los lenguajes de “alto nivel” como Python y R (cubiertos en capítulos posteriores) proporcionan muchas características incorporadas al programador, y son incluso más abstractos que lenguajes como C.

Desafortunadamente, debido a las abstracciones agregadas, lenguajes como Python no se pueden compilar fácilmente (como C puede) para ejecutarse directamente en la CPU. ^[2] De hecho, estos lenguajes no se ejecutan de la misma manera que los programas compilados o ensamblados son: son interpretados por otro programa que está escrito en un lenguaje compilado como C y se ejecuta en la CPU. Entonces, un “programa” de Python es solo un archivo de texto de comandos que son interpretados por otro programa que en realidad está interactuando con la CPU y la RAM.

La facilidad y flexibilidad adicionales de los lenguajes interpretados generalmente tiene un costo: debido a la capa de ejecución adicional, tienden a ser de 2 a 100 veces más lentos y usan de 2 a 20 veces más memoria que los programas C cuidadosamente construidos, dependiendo de lo que se esté calculando. Sin embargo, estos lenguajes son significativamente más fáciles de usar y podemos introducir nuestras ideas en el código mucho más rápidamente.

El trabajo en el lenguaje Python y los intérpretes para él ha progresado de manera constante desde la década de 1990, enfatizando un enfoque de “una mejor manera”. En lugar de proporcionar múltiples versiones de comandos básicos que hacen lo mismo, Python proporciona la menor cantidad de comandos posible mientras intenta no limitar al programador. Python también enfatiza la legibilidad del código: la mayor parte de la sintaxis se compone de palabras similares al inglés, los atajos y los caracteres de puntuación se mantienen al mínimo, y la estructura visual de los “bloques” de código se aplica con sangría.

Por estas razones, el uso de Python ha crecido significativamente en los últimos años, especialmente para la bioinformática y la biología computacional. El énfasis en la legibilidad y “una mejor manera” facilita el aprendizaje, particularmente para aquellos que son nuevos en la programación. ^[3] Lo más importante es que Python nos permite enfocarnos en los conceptos de programación sin luchar a través de una abundancia de opciones y sintaxis confusa, y los nuevos programadores pueden leer y comprender con frecuencia el código escrito por otros. Finalmente, Python incorpora una serie de paradigmas de programación modernos que lo hacen apropiado tanto para tareas pequeñas como para proyectos de ingeniería de software más grandes: es un lenguaje oficial en Google (junto con C++ y Java), y se enseña en cursos introductorios en la Universidad Johns Hopkins, la Universidad de Nueva York, la Instituto Tecnológico de Massachusetts, y muchos otros.

Todo esto no quiere decir que cualquier lenguaje de programación esté desprovisto de peculiaridades y dificultades. Solo cubriremos algo de lo que ofrece Python, las partes que son más básicas y que probablemente se encuentren en muchos idiomas. Temas que son altamente “pitónicos” serán resaltados a medida que avancemos.

Versiones Python

En este libro estaremos trabajando con Python versión 2.7; es decir, vamos a suponer que el ejecutable de Python que se encuentra en tu variable $PATH es la versión 2.7 (quizás 2.7.10, que es la última de la serie 2.7 a partir de 2015). Puede verificar esto ejecutando python —version en la línea de comandos. Si bien las versiones más nuevas están disponibles (hasta 3.4 y superiores), aún no se usan universalmente. Estas versiones más recientes cambian algo de sintaxis de 2.7. Para muchos de los conceptos introducidos en este libro, si te quedas con la sintaxis que se muestra, tu código también debería ser compatible con estas versiones más nuevas, pero posiblemente no compatible con versiones anteriores como 2.5 o 2.6. Este es un artefacto desafortunado de la filosofía “one best way” de Python: ¡en ocasiones, los diseñadores de Python cambian de opinión sobre cuál es la mejor manera!

Para dar un ejemplo, la función print print (“hello there”) funciona en Python versiones 2.6, 2.7, 3.0, 3.1, y así sucesivamente, mientras que la palabra clave version print “hello there” (note la falta de paréntesis) solo funcionaría en las versiones 2.6 y 2.7. En algunos casos donde se producirían diferencias de comportamiento en versiones posteriores, las anotaremos en notas al pie de página.

Hola, Mundo

Debido a que estamos trabajando en un lenguaje interpretado, para poder escribir un programa, necesitaremos crear un archivo de código Python, y luego suministrarlo como entrada al programa de interpretación. Hay algunas formas de hacerlo: (1) usar un entorno gráfico interactivo como el cuaderno Jupyter; (2) ejecutar el intérprete nosotros mismos en la línea de comandos, dando el nombre del archivo que contiene nuestro código como argumento; o (3) haciendo del archivo de código un script ejecutable en el entorno de línea de comandos usando #! sintaxis.

Cuaderno Jupyter

Para aquellos que deseen programar Python sin trabajar en la línea de comandos, hay una variedad de entornos gráficos disponibles. Una instalación típica de Python de http://python.org incluye el editor de código “Idle”. Una de las mejores alternativas a este default se conoce como Jupyter, que se ejecuta en un navegador web permite al programador intercalar secciones de código y documentación.

La instalación de Jupyter requiere que Python ya esté instalado (desde http://python.org), y luego requiere usar el terminal de línea de comandos en Linux, OS X o Windows; consulte http://jupyter.org/install para obtener más detalles. Una vez instalado, se puede iniciar desde la línea de comandos ejecutando jupyter notebook:

imagen

La interfaz de Jupyter se abrirá en el navegador web de escritorio predeterminado, mostrando la lista de carpetas y archivos en cualquier directorio desde el que se ejecutó el comando.

imagen

Al hacer clic en el botón “Nuevo”, seguido de “Python Notebook” se creará un nuevo documento de cuaderno compuesto por “celdas”. Las celdas de un cuaderno pueden contener texto legible por humanos (como documentación) o líneas de código Python. Si el texto de la celda se interpreta como código o texto depende de la elección que se haga en el menú “Celda”.

Cada celda puede ser “ejecutada” haciendo clic en el botón “Reproducir”; al hacerlo, las celdas de texto cambian a una salida muy bien formateada y ejecuta líneas de código para celdas de código. Pero cuidado: la salida de una celda dada a menudo depende de qué otras celdas se hayan ejecutado y en qué orden (vea la celda “La salida de celda depende del orden de ejecución” en la figura siguiente).

imagen

Por esta razón, recomiendo encarecidamente hacer la suposición de que todas las celdas de código se ejecutarán en orden de arriba a abajo, lo que se puede lograr seleccionando “Ejecutar todo” en el menú “Celda” cada vez que desee ejecutar cualquier código. Al hacerlo, todas las celdas se vuelven a ejecutar cada vez que se ejecuta, pero tiene la ventaja de garantizar la corrección del cuaderno general a medida que se realizan cambios en las celdas a lo largo del tiempo.

Intérprete especificado

Tan conveniente como es el cuaderno IPython, debido a que la parte anterior de este libro se centró en la línea de comandos, y Python interactúa bastante bien con ella, los ejemplos aquí serán del entorno de línea de comandos. Debido a que los programas Python son scripts interpretados, podemos especificar manualmente el intérprete en la línea de comandos cada vez que ejecutamos dicho script.

Para este método, primero tenemos que editar un archivo de código que llamaremos helloworld.py (.py es la extensión tradicional para programas Python). En la línea de comandos, editaremos archivos de código con nuestro editor de texto nano, pasando algunos parámetros adicionales:

El -w le dice a nano que no envuelva automáticamente las líneas largas (estamos escribiendo código después de todo, no un ensayo), -i dice que sanje automáticamente las nuevas líneas al nivel de sangría actual, -T 4 dice que las tab-stops deben tener cuatro espacios de ancho, y -E dice que las pestañas deben convertirse en espacios (cuatro de ellas). Este uso de cuatro espacios por nivel de sangría es ampliamente acordado por la comunidad Python como fácil a la vista. (“Una mejor manera”, ¿recuerdas?) Pondremos una simple llamada a la función print () en el archivo:

Como de costumbre, Control-o guarda el archivo (presione Enter si se le solicita sobre el nombre del archivo) y Control-X sale nano. A continuación, para ejecutarlo, todo lo que necesitamos hacer es llamar al intérprete de Python en el archivo:

¡Éxito! ¡Hemos escrito nuestro primer programa Python!

Hacer que el archivo sea ejecutable

Un método alternativo es hacer que el archivo de código sea un script ejecutable. Primero, tenemos que editar el archivo de código para incluir una primera línea especial:

Para que este método funcione, los dos primeros caracteres del archivo deben ser #! (de hecho, toda la línea necesita ser replicada exactamente); aunque nano está mostrando lo que parece ser una línea en blanco por encima de nuestro #! línea, realmente no hay una ahí.

En el capítulo 5, “Permisos y Ejecutables”, discutimos el #! línea como que contiene la ruta absoluta al intérprete, como en #! /usr/bin/bash para scripts bash. En este caso, estamos especificando algo ligeramente diferente: ¡#! /usr/bin/env python. El programa env, entre otras cosas, busca la ubicación instalada del argumento dado y lo ejecuta. A #! como esta provocará que un programa Python se ejecute con éxito, incluso si está instalado en una ubicación no estándar. (Uno puede preguntar si env alguna vez se instala en una ubicación no estándar. Afortunadamente, es raro encontrar env ubicado en otro lugar que no sea en /usr/bin.)

A continuación, necesitamos salir nano y hacer que el archivo sea ejecutable usando la utilidad chmod, y finalmente podemos ejecutarlo con. /helloworld.py. Esto especifica que se debe ejecutar el programa helloworld.py y que existe en el directorio actual (. /).

Configuración y uso de nano

Generalmente, no querrás escribir nano -w -i -E -T 4... cada vez que quieras editar un archivo de código Python. Afortunadamente, nano se puede configurar para usar automáticamente estas opciones si se especifican correctamente en un archivo llamado .nanorc en su directorio home. Pero esta puede no ser la mejor opción, ya sea: al editar archivos que no son código Python, es probable que no quiera convertir todas sus entradas de tabulación en espacios. En su lugar, es posible que desee definir un alias de shell llamado nanopy específicamente para editar código Python. Para tener este alias de shell preservado para cada sesión de inicio de sesión, el código relevante tendría que ser agregado a su .bashrc (asumiendo que su shell es bash):

Si vas a realizar lo anterior, vuelve a verificar que el comando sea exactamente como está escrito. Después de cerrar sesión y volver a ingresar, puede editar un archivo de código Python con el alias usando nanopy helloworld.py.

Como se desprende de la muestra de código anterior, nano también puede proporcionar resaltado de sintaxis (coloración del código para legibilidad) si su $HOME/.nanorc y archivos relacionados están configurados correctamente, aunque no es necesario para la programación.

No olvides que muchas veces es útil tener múltiples ventanas de terminales abiertas simultáneamente. Puedes usar uno para editar, uno para ejecutar tu programa y probar, y tal vez un tercer running top, mostrando cuánta CPU y RAM está usando tu programa.

Aunque no es tan potente como los editores de texto más sofisticados como emacs o vim, nano es fácil de usar e incluye una serie de características como editar múltiples archivos, cortar y pegar dentro y entre archivos, búsqueda y búsqueda/reemplazo basada en expresiones regulares, deletrear check, y más. Durante la edición, nano también puede llevarte directamente a un número de línea (Control — -), que te será útil cuando necesites ir directamente a una línea que causó un error.

Sea cual sea el editor que elijas usar, leer alguna documentación te ayudará a ser mucho más productivo. Para el resto de nuestras muestras de código, mostraremos capturas de pantalla desde dentro de vim, principalmente porque proporciona un resaltado de sintaxis más bonito.

Ejercicios

Crear un archivo de código Python en la línea de comandos que contenga una impresión simple (“¡Hola!”) declaración. Ejecútelo especificando el intérprete. Si está ejecutando iPython notebook, intente crear un cuaderno similarmente simple y ejecute la celda.
Cree un archivo de código Python, conviértalo en un script ejecutable y ejecútelo. ¿Eso funciona? ¿Por qué o por qué no?
Determine qué versión de Python está ejecutando (tal vez ejecutando python —version). Prueba para ver qué versiones de impresión funcionan para ti: print (“¡Hola!” ) o imprimir “¡Hola! ". (El primero es muy preferido.)

La historia de la computación está llena de giros, giros y reinvención de ruedas. LISP, por ejemplo, es un lenguaje que incorpora muchas de las mismas características de alto nivel que Python, ¡pero se desarrolló por primera vez en 1958!
Por otro lado, programadores ambiciosos están trabajando actualmente en proyectos como Cython para hacer exactamente esto.
Muchos creen que la mejor manera de aprender programación es de una manera orientada al hardware con ensamble o un lenguaje como C. Esta es una filosofía legítima, pero para el público objetivo de este libro, nos quedaremos con los lenguajes de nivel superior Python y R.