Dominar Python para Bioinformática

Prefacio

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

La programación es un multiplicador de fuerza. Podemos escribir programas informáticos para liberarnos de tediosas tareas manuales y para acelerar la investigación. Programar en cualquier lenguaje mejorará probablemente tu productividad, pero cada lenguaje tiene diferentes curvas de aprendizaje y herramientas que mejoran o dificultan el proceso de codificación.

Hay un adagio en los negocios que dice que tienes tres opciones:

1. Rápido

2. Bien

3. Barato

Elige dos.

En lo que respecta a los lenguajes de programación, Python se encuentra en un punto dulce, ya que es rápido porque es bastante fácil de aprender y de escribir un prototipo funcional de una idea: prácticamente siempre es el primer lenguaje que utilizo para escribir cualquier programa. Creo que Python es barato porque mis programas suelen ejecutarse lo suficientemente bien en hardware básico como mi portátil o una pequeña instancia de AWS. Sin embargo, yo diría que no es necesariamente fácil hacer buenos programas con Python porque el lenguaje en sí es bastante laxo. Por ejemplo, permite mezclar caracteres y números en operaciones que bloquearán el programa.

Este libro se ha escrito para el aspirante a programador bioinformático que desee conocer las buenas prácticas y herramientas de Python, como las siguientes:

• Desde Python 3.6, puedes añadir sugerencias de tipo para indicar, por ejemplo, que una variable debe ser de un tipo como un número o una lista, y puedes utilizar la herramienta mypy para asegurarte de que los tipos se utilizan correctamente.

• Los marcos de pruebas como pytest pueden ejercitar tu código con datos buenos y malos para asegurarse de que reacciona de alguna manera predecible.

• Herramientas como pylint y flake8 pueden encontrar posibles errores y problemas estilísticos que dificultarían la comprensión de tus programas.

• El módulo argparse puede documentar y validar los argumentos de tusprogramas.

• El ecosistema Python te permite aprovechar cientos de módulos existentes, como Biopython, para acortar los programas y hacerlos más fiables.

Utilizar estas herramientas de forma individual mejorará tus programas, pero combinarlas todas mejorará tu código de forma combinada. Este libro no es un libro de texto sobre bioinformática en sí. Se centra en lo que ofrece Python que lo hace adecuado para escribir programas científicos que sean reproducibles. Es decir, te mostraré cómo diseñar y probar programas que siempre produzcan los mismos resultados con las mismas entradas. La bioinformática está saturada de programas mal escritos y sin documentación, y mi objetivo es invertir esta tendencia, programa a programa.

Los criterios de reproducibilidad del programa incluyen:

Parámetros

Todos los parámetros del programa pueden establecerse como argumentos en tiempo de ejecución. Esto significa que no hay valores codificados que requieran modificar el código fuente para cambiar el comportamiento del programa.

Documentación

Un programa debe responder a un argumento --help imprimiendo los parámetros y el uso.

Prueba

Deberías poder ejecutar un conjunto de pruebas que demuestre que el código cumple algunasespecificaciones

Podrías esperar que esto condujera lógicamente a programas que tal vez sean correctos, pero, por desgracia, como dijo Edsger Dijkstra: "¡Las pruebas de programas se pueden utilizar para mostrar la presencia de errores, pero nunca para mostrar su ausencia!".

La mayoría de los bioinformáticos son científicos que han aprendido programación o programadores que han aprendido biología (o gente como yo, que tuvo que aprender ambas cosas). Independientemente de cómo hayas llegado al campo de la bioinformática, quiero mostrarte técnicas prácticas de programación que te ayudarán a escribir programas correctos rápidamente. Empezaré por cómo escribir programas que documenten y validen sus argumentos. Luego mostraré cómo escribir y ejecutar pruebas para garantizar que los programas hacen lo que pretenden.

Por ejemplo, el primer capítulo muestra cómo informar de la frecuencia de tetranucleótidos de una cadena de ADN. Suena bastante sencillo, ¿verdad? Es una idea trivial, pero dedicaré unas 40 páginas a mostrar cómo estructurar, documentar y probar este programa. Dedicaré mucho tiempo a cómo escribir y probar varias versiones diferentes del programa, de modo que pueda explorar muchos aspectos de las estructuras de datos, la sintaxis, los módulos y las herramientas de Python.

¿Quién debería leer esto?

Deberías leer este libro si te importa el oficio de programar y si quieres aprender a escribir programas que produzcan documentación, validen sus parámetros, fallen con elegancia y funcionen de forma fiable. Las pruebas son una habilidad clave tanto para comprender tu código como para verificar su corrección. Te mostraré cómo utilizar las pruebas que he escrito y cómo escribir pruebas para tus programas.

Para sacar el máximo partido a este libro, ya debes tener unos conocimientos sólidos de Python. Me basaré en las habilidades que enseñé en Tiny Python Projects (Manning, 2020), donde muestro cómo utilizar estructuras de datos de Python como cadenas, listas, tuplas, diccionarios, conjuntos y tuplas con nombre. No es necesario que seas un experto en Python, pero definitivamente te empujaré a comprender algunos conceptos avanzados que introduzco en ese libro, como tipos, expresiones regulares e ideas sobre funciones de orden superior, junto con pruebas y cómo utilizar herramientas como pylint, flake8, yapf, y pytest para comprobar el estilo, la sintaxis y la corrección. Una diferencia notable es que utilizaré sistemáticamente anotaciones de tipo para todo el código de este libro y utilizaré la herramienta mypy para garantizar el uso correcto de los tipos.

Estilo de programación: Por qué evito la programación orientada a objetos y las excepciones

Tiendo a evitar la programación orientada a objetos (POO). Si no sabes lo que significa POO, no pasa nada. El propio Python es un lenguaje POO, y casi todos los elementos, desde una cadena a un conjunto, son técnicamente un objeto con estado interno y métodos. Te encontrarás con suficientes objetos como para hacerte una idea de lo que significa POO, pero los programas que presento evitarán en su mayor parte utilizar objetos para representar ideas.

Dicho esto, el Capítulo 1 muestra cómo utilizar un class para representar una estructura de datos compleja.El class me permite definir una estructura de datos con anotaciones de tipo para que pueda verificar que estoy utilizando los tipos de datos correctamente. Esto ayuda a comprender un poco la POO. Por ejemplo, las clases definen los atributos de un objeto, y las clases pueden heredar atributos de las clases padre, pero esto describe esencialmente los límites de cómo y por qué utilizo la POO en Python. Si ahora mismo no lo entiendes del todo, no te preocupes, lo entenderás en cuanto lo veas.

En lugar de código orientado a objetos, muestro programas compuestos casi totalmente por funciones.Estas funciones también son puras, en el sentido de que sólo actuarán sobre los valores que se les den.Es decir, las funciones puras nunca dependen de algún estado oculto y mutable como las variables globales, y siempre devolverán los mismos valores dados los mismos argumentos. Además, cada función tendrá una prueba asociada que puedo ejecutar para verificar que se comporta de forma predecible. En mi opinión, esto da lugar a programas más cortos, más transparentes y más fáciles de probar que las soluciones escritas con programación orientada a objetos. Puedes no estar de acuerdo y, por supuesto, puedes escribir tus soluciones con el estilo de programación que prefieras, siempre que superen las pruebas. La documentación del CÓMO de Programación Funcional de Python explica muy bien por qué Python es adecuado para la programación funcional (PF).

Por último, los programas de este libro también evitan el uso de excepciones, lo que me parece apropiado para programas cortos que escribas para uso personal.Gestionar las excepciones de modo que no interrumpan el flujo de un programa añade otro nivel de complejidad que, en mi opinión, resta capacidad para entender un programa. En general, no me gusta cómo se escriben en Python las funciones que devuelven errores. Mucha gente lanzaría una excepción y dejaría que un bloque try/catch se encargara de los errores. Si considero que una excepción está justificada, a menudo optaré por no atraparla, dejando en su lugar que el programa se bloquee. En este sentido, sigo una idea de Joe Armstrong, el creador del lenguaje Erlang, que dijo: "La manera Erlang es escribir el camino feliz, y no escribir pasadizos retorcidos llenos de código corrector de errores".

Si decides escribir programas y módulos para su publicación, tendrás que aprender mucho más sobre excepciones y manejo de errores, pero eso está fuera del alcance de este libro.

Estructura

El libro se divide en dos partes principales. La primera parte aborda 14 de los retos de programación que se encuentran en el sitio web Rosalind.info.¹ La segunda parte muestra programas más complicados que demuestran otros patrones o conceptos que considero importantes en bioinformática. Cada capítulo del libro describe un reto de codificación para que lo escribas y proporciona un conjunto de pruebas para que determines cuándo has escrito un programa que funciona.

Aunque el "Zen de Python " dice que "Debería haber una -y preferiblemente sólo una- forma obvia de hacerlo", creo que se puede aprender bastante probando muchos enfoques diferentes de un problema.Perl fue mi puerta de entrada a la bioinformática, y el espíritu de la comunidad Perl de "Hay más de una forma de hacerlo" (TMTOWTDI) aún resuena en mí. En general, sigo un enfoque de temas y variaciones en cada capítulo, mostrando muchas soluciones para explorar diferentes aspectos de la sintaxis y las estructuras de datos de Python.

Desarrollo basado en pruebas

Más que el acto de probar, el acto de diseñar pruebas es uno de los mejores preventivos de errores que se conocen. La reflexión que hay que hacer para crear una prueba útil puede descubrir y eliminar errores antes de que se codifiquen; de hecho, la reflexión sobre el diseño de las pruebas puede descubrir y eliminar errores en cada fase de la creación del software, desde la concepción a la especificación, pasando por el diseño, la codificación y el resto.

Boris Beizer, Técnicas de comprobación de software (Thompson Computer Press)

Detrás de toda mi experimentación habrá conjuntos de pruebas que ejecutaré constantemente para asegurarme de que los programas siguen funcionando correctamente. Siempre que tengo la oportunidad, intento enseñar el desarrollo dirigido por pruebas (TDD), una idea explicada en un libro con ese título escrito por Kent Beck (Addison-Wesley, 2002). El TDD aboga por escribir pruebas para el código antes de escribir el código. El ciclo típico implica lo siguiente:

1. Añade una prueba.

2. Ejecuta todas las pruebas y comprueba si la nueva prueba falla.

3. Escribe el código.

4. Realiza pruebas.

5. Refactoriza el código.

6. Repite.

En el repositorio GitHub del libro encontrarás las pruebas de cada programa que escribas.Te explicaré cómo ejecutar y escribir pruebas, y espero que al final del material creas en el sentido común y la decencia básica de utilizar TDD. Espero que pensar primero en las pruebas empiece a cambiar tu forma de entender y explorar la codificación.

Utilizar la línea de comandos e instalar Python

Mi experiencia en bioinformática siempre se ha centrado en la línea de comandos de Unix. Gran parte de mi trabajo diario se ha realizado en algún tipo de servidor Linux, uniendo programas existentes de línea de comandos mediante secuencias de comandos de shell, Perl y Python. Aunque puede que escriba y depure un programa o una canalización en mi portátil, a menudo despliego mis herramientas en un clúster de computación de alto rendimiento (HPC) donde un programador ejecutará mis programas de forma asíncrona, a menudo en mitad de la noche o durante un fin de semana y sin ninguna supervisión o intervención por mi parte. Además, todo mi trabajo de creación de bases de datos y sitios web y de administración de servidores se realiza completamente desde la línea de comandos, por lo que creo firmemente que necesitas dominar este entorno para tener éxito en la bioinformática.

He utilizado un Macintosh para escribir y probar todo el material de este libro, y macOS dispone de la aplicación Terminal que puedes utilizar como línea de comandos.También he probado todos los programas utilizando varias distribuciones de Linux, y el repositorio de GitHub incluye instrucciones sobre cómo utilizar una máquina virtual Linux con Docker. Además, he probado todos los programas en Windows 10 utilizando la distribución de Ubuntu Windows Subsystem for Linux (WSL) versión 1.Recomiendo encarecidamente WSL para que los usuarios de Windows tengan una verdadera línea de comandos Unix, pero los shells de Windows como cmd.exe, PowerShell y Git Bash a veces pueden funcionar suficientemente bien para algunos programas.

Te animo a que explores entornos de desarrollo integrados (IDE) como VS Code, PyCharm o Spyder para ayudarte a escribir, ejecutar y probar tus programas.Estas herramientas integran editores de texto, documentación de ayuda y terminales. Aunque escribí todos los programas, pruebas e incluso este libro utilizando el editor vim en un terminal, la mayoría de la gente probablemente preferiría utilizar al menos un editor de texto más moderno como Sublime, TextMate o Notepad++.

Escribí y probé todos los ejemplos utilizando las versiones 3.8.6 y 3.9.1 de Python.Algunos ejemplos utilizan sintaxis de Python que no estaba presente en la versión 3.6, por lo que te recomiendo que no utilices esa versión. La versión 2.x de Python ya no está soportada y no debería utilizarse. Suelo obtener la última versión de Python 3 de la página de descargas de Python, pero también he tenido éxito utilizando la distribución de Python Anaconda. Puede que tengas un gestor de paquetes como apt en Ubuntu o brew en Mac que pueda instalar una versión reciente, o puede que elijas compilar desde el código fuente. Sea cual sea tu plataforma y método de instalación, te recomiendo que intentes utilizar la versión más reciente, ya que el lenguaje sigue cambiando, sobre todo para mejor.

Ten en cuenta que he optado por presentar los programas como programas de línea de comandos y no como Cuadernos Jupyter por varias razones. Me gustan los Cuadernos para la exploración de datos, pero el código fuente de los Cuadernos se almacena en Notación de Objetos JavaScript (JSON) y no como texto orientado a líneas. Esto hace que sea muy difícil utilizar herramientas como diff para encontrar las diferencias entre dos Cuadernos. Además, los Cuadernos no se pueden parametrizar, lo que significa que no puedo pasar argumentos desde fuera del programa para cambiar el comportamiento, sino que tengo que cambiar el propio código fuente. Esto hace que los programas sean inflexibles y que sea imposible realizar pruebas automatizadas. Aunque te animo a explorar los Cuadernos, especialmente como forma interactiva de ejecutar Python, me centraré en cómo escribir programas de línea de comandos.

Obtener el código y las pruebas

Todo el código y las pruebas están disponibles en el repositorio GitHub del libro. Puedes utilizar el programa Git (que puede que necesites instalar) para copiar el código a tu ordenador con el siguiente comando.Esto creará un nuevo directorio llamado biofx_python en tu ordenador con el contenido del repositorio:

$ git clone https://github.com/kyclark/biofx_python

Si te gusta utilizar un IDE, puede ser posible clonar el repositorio a través de esa interfaz, como se muestra en la Figura P-1.Muchos IDE pueden ayudarte a gestionar proyectos y escribir código, pero todos funcionan de forma diferente. Para simplificar las cosas, mostraré cómo utilizar la línea de comandos para realizar la mayoría de las tareas.

Figura P-1. La herramienta PyCharm puede clonar directamente el repositorio de GitHub por ti

Algunas herramientas, como PyCharm, pueden intentar crear automáticamente un entorno virtual dentro del directorio del proyecto. Es una forma de aislar la versión de Python y los módulos de otros proyectos de tu ordenador. Utilizar o no entornos virtuales es una preferencia personal. No es un requisito utilizarlos.

Puede que prefieras hacer una copia del código en tu propia cuenta para poder seguir tus cambios y compartir tus soluciones con los demás. Esto se llama bifurcar porque te estás separando de mi código y añadiendo tus programas al repositorio.

Para bifurcar mi repositorio de GitHub, haz lo siguiente:

1. Crea una cuenta en GitHub.com.

2. Visita https://github.com/kyclark/biofx_python.

3. Pulsa el botón Bifurcar en la esquina superior derecha (ver Figura P-2) para hacer una copia del repositorio en tu cuenta.

Figura P-2. El botón Fork en mi repositorio de GitHub hará una copia del código en tu cuenta

Ahora que tienes una copia de todo mi código en tu repositorio, puedes utilizar Git para copiar ese código a tu ordenador. Asegúrate de sustituir YOUR_GITHUB_ID por tu ID real de GitHub:

$ git clone https://github.com/YOUR_GITHUB_ID/biofx_python

Puede que actualice el repositorio después de que hagas tu copia. Si quieres poder obtener esas actualizaciones, tendrás que configurar Git para establecer mi repositorio como fuente upstream. Para ello, después de clonar el repositorio en tu ordenador, entra en tu directorio biofx_python:

$ cd biofx_python

A continuación, ejecuta este comando:

$ git remote add upstream https://github.com/kyclark/biofx_python.git

Siempre que quieras actualizar tu repositorio desde el mío, puedes ejecutar este comando:

$ git pull upstream main

Instalar módulos

Necesitarás instalar varios módulos y herramientas de Python. He incluido un archivo requirements.txt en el nivel superior del repositorio. Este archivo enumera todos los módulos necesarios para ejecutar los programas del libro. Algunos IDE pueden detectar este archivo y ofrecerse a instalarlos por ti, o puedes utilizar el siguiente comando:

$ python3 -m pip install -r requirements.txt

O utiliza la herramienta pip3:

$ pip3 install -r requirements.txt

A veces, pylint puede quejarse de algunos de los nombres de variables de los programas, y mypy planteará algunos problemas cuando importes módulos que no tengan anotaciones de tipo. Para silenciar estos errores, puedes crear archivos de inicialización en tu directorio personal que estos programas utilizarán para personalizar su comportamiento. En la raíz del repositorio de fuentes, hay archivos llamados pylintrc y mypy.ini que debes copiar en tu directorio personal de la siguiente manera:

$ cp pylintrc ~/.pylintrc
$ cp mypy.ini ~/.mypy.ini

Alternativamente, puedes generar un nuevo pylintrc con el siguiente comando:

$ cd ~
$ pylint --generate-rcfile > .pylintrc

Siéntete libre de personalizar estos archivos para adaptarlos a tus gustos.

Instalar el programa new.py

Escribí un programa Python llamado new.py que crea programas Python. Tan meta, lo sé. Lo escribí para mí y luego se lo di a mis alumnos porque creo que es bastante difícil empezar a escribir un programa desde una pantalla vacía. El programa new.py creará un nuevo programa Python bien estructurado que utiliza el módulo argparse para interpretar los argumentos de la línea de comandos. Debería haberse instalado en la sección anterior con las dependencias del módulo. Si no, puedes utilizar el módulo pip para instalarlo, así:

$ python3 -m pip install new-py

Ahora deberías poder ejecutar new.py y ver algo como esto

$ new.py
usage: new.py [-h] [-n NAME] [-e EMAIL] [-p PURPOSE] [-t] [-f] [--version]
              program
new.py: error: the following arguments are required: program

En cada ejercicio se te sugerirá que utilices new.py para empezar a escribir tus nuevos programas. Por ejemplo, en el capítulo 1 crearás un programa llamado dna.py en el directorio 01_dna, de la siguiente manera:

$ cd 01_dna/
$ new.py dna.py
Done, see new script "dna.py".

Si a continuación ejecutas ./dna.py --helpverás que genera documentación de ayuda sobre cómo utilizar el programa. Debes abrir el programa dna.py en tu editor, modificar los argumentos y añadir tu código para satisfacer los requisitos del programa y de las pruebas.

Ten en cuenta que nunca es un requisito que utilices new.py. Sólo te lo ofrezco como ayuda para empezar. Así es como yo empiezo cada uno de mis programas, pero, aunque yo lo encuentro útil, puede que tú prefieras ir por otro camino. Mientras tus programas pasen los conjuntos de pruebas, puedes escribirlos como te plazca.

¿Por qué escribí este libro?

Richard Hamming pasó décadas como matemático e investigador en los Laboratorios Bell.Era conocido por buscar a gente que no conocía y preguntarles sobre sus investigaciones. Luego les preguntaba cuáles eran, en su opinión, las preguntas más importantes y acuciantes sin respuesta en su campo. Si sus respuestas para ambas no coincidían, les preguntaba: "¿Y por qué no estáis trabajando en eso?".

Creo que uno de los problemas más acuciantes de la bioinformática es que gran parte del software está mal escrito y carece de documentación y pruebas adecuadas, si es que las tiene. Quiero mostrarte que es menos difícil utilizar tipos y pruebas y linters y formateadores, porque con el tiempo resultará más fácil añadir nuevas funciones y publicar más y mejor software. Tendrás la confianza de saber con certeza cuándo tu programa es correcto, al menos en cierta medida.

Para ello, mostraré las buenas prácticas en el desarrollo de software. Aunque estoy utilizando Python como medio, los principios se aplican a cualquier lenguaje, desde C a R o JavaScript. Lo más importante que puedes aprender de este libro es el arte de desarrollar, probar, documentar, liberar y dar soporte al software, para que todos juntos podamos hacer avanzar la informática de la investigación científica.

Mi carrera en bioinformática fue producto de vagabundeos y accidentes felices. Estudié literatura inglesa y música en la universidad, y luego empecé a jugar con bases de datos, HTML y, finalmente, aprendí programación en el trabajo a mediados de los 90. En 2001, me había convertido en un hacker de Perl decente, y conseguí un trabajo como desarrollador web para el Dr. Lincoln Stein, autor de varios módulos y libros de Perl, en el Laboratorio Cold Spring Harbor (CSHL). Él y mi jefa, la Dra. Doreen Ware, me enseñaron pacientemente la biología suficiente para que entendiera los programas que querían que escribiera. Pasé 13 años trabajando en una base de datos genómica comparativa de plantas llamada Gramene.org, aprendiendo una cantidad decente de ciencia mientras seguía explorando los lenguajes de programación y la informática.

A Lincoln le apasionaba compartirlo todo, desde los datos y el código hasta la educación. Inició el curso de Programación para Biología en el CSHL, un curso intensivo de dos semanas para enseñar la línea de comandos de Unix, programación en Perl y habilidades bioinformáticas. El curso se sigue impartiendo, aunque hoy en día se utiliza Python, y yo he tenido varias oportunidades de actuar como ayudante de profesor. Siempre me ha parecido gratificante ayudar a alguien a aprender una habilidad que utilizará para avanzar en su investigación.

Fue durante mi estancia en el CSHL cuando conocí a Bonnie Hurwitz, que finalmente se marchó para realizar su doctorado en la Universidad de Arizona (UA). Cuando puso en marcha su nuevo laboratorio en la UA, yo fui su primera contratación. Bonnie y yo trabajamos juntas durante varios años, y la enseñanza se convirtió en una de mis partes favoritas del trabajo. Al igual que en el curso de Lincoln, introdujimos conocimientos básicos de programación a científicos que querían adentrarse en enfoques más computacionales.

Algunos de los materiales que escribí para estas clases se convirtieron en la base de mi primer libro, Tiny Python Projects, donde intento enseñar los elementos esenciales de la sintaxis del lenguaje Python, así como la forma de utilizar pruebas para garantizar que los programas son correctos y reproducibles, elementos cruciales para la programación científica. Este libro parte de ahí y se centra en los elementos de Python que te ayudarán a escribir programas para biología.

Convenciones utilizadas en este libro

En este libro se utilizan las siguientes convenciones tipográficas:

Cursiva

Indica nuevos términos, URL, direcciones de correo electrónico, nombres y extensiones de archivos, así como codones y bases de ADN.

Constant width

Se utiliza en los listados de programas, así como dentro de los párrafos para referirse a elementos del programa como nombres de variables o funciones, bases de datos, tipos de datos, variables de entorno, sentencias y palabras clave.

Constant width bold

Muestra comandos u otros textos que deben ser tecleados literalmente por el usuario.

Constant width italic

Muestra el texto que debe sustituirse por valores proporcionados por el usuario o por valores determinados por el contexto.

Este elemento significa un consejo o sugerencia.

Este elemento significa una nota general.

Este elemento indica una advertencia o precaución.

Utilizar ejemplos de código

El material complementario (ejemplos de código, ejercicios, etc.) se puede descargar en https://github.com/kyclark/biofx_python.

Si tienes una pregunta técnica o un problema al utilizar los ejemplos de código, envía un correo electrónico a [e-mail].

Este libro está aquí para ayudarte a hacer tu trabajo. En general, si se ofrece código de ejemplo con este libro, puedes utilizarlo en tus programas y documentación. No es necesario que te pongas en contacto con nosotros para pedirnos permiso, a menos que estés reproduciendo una parte importante del código. Por ejemplo, escribir un programa que utilice varios trozos de código de este libro no requiere permiso. Vender o distribuir ejemplos de los libros de O'Reilly sí requiere permiso. Responder a una pregunta citando este libro y el código de ejemplo no requiere permiso. Incorporar una cantidad significativa de código de ejemplo de este libro en la documentación de tu producto sí requiere permiso.

Agradecemos la atribución, pero en general no la exigimos. Una atribución suele incluir el título, el autor, la editorial y el ISBN. Por ejemplo "Dominio de Python para Bioinformática por Ken Youens-Clark (O'Reilly). Copyright 2021 Charles Kenneth Youens-Clark, 978-1-098-10088-9".

Si crees que el uso que haces de los ejemplos de código no se ajusta al uso legítimo o al permiso concedido anteriormente, no dudes en ponerte en contacto con nosotros en [e-mail].

Aprendizaje en línea O'Reilly

Durante más de 40 años, O'Reilly Media ha proporcionado formación tecnológica y empresarial, conocimientos y perspectivas para ayudar a las empresas a alcanzar el éxito.

Nuestra red única de expertos e innovadores comparten sus conocimientos y experiencia a través de libros, artículos y nuestra plataforma de aprendizaje online. La plataforma de aprendizaje en línea de O'Reilly te ofrece acceso bajo demanda a cursos de formación en directo, rutas de aprendizaje en profundidad, entornos de codificación interactivos y una amplia colección de textos y vídeos de O'Reilly y de más de 200 editoriales. Para más información, visita http://oreilly.com.

Cómo contactar con nosotros

Dirige tus comentarios y preguntas sobre este libro a la editorial:

• O'Reilly Media, Inc.
• 1005 Gravenstein Highway Norte
• Sebastopol, CA 95472
• 800-998-9938 (en Estados Unidos o Canadá)
• 707-829-0515 (internacional o local)
• 707-829-0104 (fax)

Tenemos una página web para este libro, donde se enumeran erratas, ejemplos y cualquier información adicional. Puedes acceder a esta página en https://oreil.ly/mastering-bioinformatics-python.

Envía un correo electrónico a [e-mail] para comentar o hacer preguntas técnicas sobre este libro.

Para obtener noticias e información sobre nuestros libros y cursos, visita http://oreilly.com.

Encuéntranos en Facebook: http://facebook.com/oreilly

Síguenos en Twitter: http://twitter.com/oreillymedia

Míranos en YouTube: http://www.youtube.com/oreillymedia

Agradecimientos

Quiero dar las gracias a las muchas personas que han revisado este libro, incluido mi editor, Corbin Collins; a todo el equipo de producción, pero especialmente a mi editora de producción,Caitlin Ghegan; a mis revisores técnicos, Al Scherer, Brad Fulton, Bill Lubanovic,Rangarajan Janani y Joshua Orvis; y a las muchas otras personas que me proporcionaron comentarios muy apreciados, incluidos Mark Henderson, Marc Bañuls Tornero y el Dr. Scott Cain.

En mi carrera profesional, he tenido la gran suerte de haber tenido muchos jefes, supervisores y colegas maravillosos que me han ayudado a crecer y me han empujado a ser mejor. Eric Thorsen fue la primera persona que vio que tenía potencial para aprender a programar, y me ayudó a aprender varios lenguajes y bases de datos, así como importantes lecciones sobre ventas y soporte. Steve Reppucci fue mi jefe en boston.com, y me proporcionó un conocimiento mucho más profundo de Perl y Unix, y de cómo ser un líder de equipo honesto y considerado. El Dr. Lincoln Stein, del CSHL, se arriesgó a contratar a alguien que no tenía conocimientos de biología para trabajar en su laboratorio, y me empujó a crear programas que no imaginaba que pudiera hacer. Lincoln Stein, del CSHL, se arriesgó a contratar a alguien que no tenía conocimientos de biología para trabajar en su laboratorio, y me empujó a crear programas que no me imaginaba que pudiera hacer. La Dra. Doreen Ware me enseñó pacientemente biología y me empujó a asumir funciones de liderazgo y a publicar. La Dra. Bonnie Hurwitz me apoyó durante muchos años de aprendizaje de informática de alto rendimiento, más lenguajes de programación, tutoría, enseñanza y escritura. En cada puesto, también tuve muchoscolegas que me enseñaron tanto sobre programación como sobre ser humano, y doy las gracias a todos los que me han ayudado en el camino.

En mi vida personal, no estaría en ninguna parte sin mi familia, que me ha querido y apoyado. Mis padres han mostrado un gran apoyo a lo largo de mi vida, y seguramente no sería la persona que soy sin ellos. Lori Kindler y yo llevamos casados 25 años, y no puedo imaginarme una vida sin ella. Juntos hemos engendrado tres vástagos que han sido una increíble fuente de deleite y desafío.

¹ Llamado así por Rosalind Franklin, que debería haber recibido el Premio Nobel por sus contribuciones al descubrimiento de la estructura del ADN.