diff --git a/.gitignore b/.gitignore index f24cd99..f978a8d 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,7 @@ pip-log.txt #Mr Developer .mr.developer.cfg + +jb/_build/ +jb/.wrangler/cache/wrangler-account.json +jb/extra_html/cover-source.jpg \ No newline at end of file diff --git a/README.md b/README.md index 39a0d8b..3e1a997 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,108 @@ -# Think Python, 3rd edition +# Think Python, 3.ª edición -Jupyter notebooks and other material for the 3rd edition of *Think Python: How to Think Like a Computer Scientist* +Portada en español de Think Python, 3.ª edición -by Allen B. Downey +Materiales, notebooks de Jupyter y versión web en español de la 3.ª edición de *Think Python: How to Think Like a Computer Scientist*, de Allen B. Downey. -You can order print and electronic versions of *Think Python 3e* from -[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and -[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325). +Traducción al español por [midudev](https://midu.dev) (Miguel Ángel Durán). -The home page for the book is at [Green Tea Press](http://thinkpython.com). +## Enlaces +- Página pública del libro: [libropython.es](https://libropython.es) +- Repositorio del proyecto: [github.com/midudev/ThinkPython](https://github.com/midudev/ThinkPython) +- Página original del libro: [Green Tea Press](http://thinkpython.com) +- Versión impresa y electrónica en inglés: [Bookshop.org](https://bookshop.org/a/98697/9781098155438) y [Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325) + +## Requisitos + +- Python 3 +- `pip` +- Jupyter Notebook o JupyterLab, si quieres abrir los notebooks localmente +- Jupyter Book y Playwright, si quieres construir la versión web y el PDF + +## Instalación + +Desde la raíz del repositorio, instala las herramientas necesarias: + +```bash +python3 -m pip install jupyter notebook jupyterlab jupyter-book playwright +python3 -m playwright install chromium +``` + +Si ya tienes Jupyter instalado, puedes instalar solo lo necesario para construir el libro: + +```bash +python3 -m pip install jupyter-book playwright +python3 -m playwright install chromium +``` + +## Construir el libro + +1. Entra en la carpeta de Jupyter Book: + + ```bash + cd jb + ``` + +2. Ejecuta el script de construcción: + + ```bash + ./build.sh + ``` + +3. Revisa los archivos generados: + + - HTML: `jb/_build/html/index.html` + - PDF: `jb/_build/html/think-python-es.pdf` + - Archivos estáticos para producción: `jb/_build/html/` + - Carpeta lista para desplegar: `dist/` + +## Desplegar en Cloudflare Workers + +El archivo `wrangler.toml` despliega los assets estáticos desde `./dist`. + +1. Construye el libro: + + ```bash + cd jb + ./build.sh + cd .. + ``` + +2. Despliega con Wrangler: + + ```bash + npx wrangler login + npx wrangler deploy + ``` + +3. Para usar `https://libropython.es`, asigna ese dominio al Worker desde Cloudflare Dashboard, en Workers & Pages > tu Worker > Settings > Domains & Routes. + +## Abrir los notebooks + +Desde la raíz del repositorio, puedes abrir los notebooks con Jupyter Notebook: + +```bash +jupyter notebook +``` + +También puedes usar JupyterLab: + +```bash +jupyter lab +``` + +Después, abre desde el navegador el capítulo o notebook que quieras consultar. + +## Estructura del proyecto + +- `chapters/`: notebooks originales por capítulo. +- `jb/`: configuración y fuentes de Jupyter Book. +- `jb/build.sh`: script para generar la versión web y el PDF. +- `jb/_build/html/`: salida generada para publicar el libro. + +## Licencia + +Se conserva la atribución original a Allen B. Downey. La traducción al español fue realizada por [midudev](https://midu.dev) (Miguel Ángel Durán). + +Esta obra está bajo una [Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/). diff --git a/blank/chap00.ipynb b/blank/chap00.ipynb index 55b62c2..c733efe 100644 --- a/blank/chap00.ipynb +++ b/blank/chap00.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -15,7 +15,7 @@ "id": "d9724920", "metadata": {}, "source": [ - "# Preface\n", + "# Prefacio\n", "\n" ] }, @@ -24,21 +24,21 @@ "id": "b76f38c6", "metadata": {}, "source": [ - "## Who Is This Book For?\n", + "## ¿Para quién es este libro?\n", "\n", - "If you want to learn to program, you have come to the right place.\n", - "Python is one of the best programming languages for beginners -- and it is also one of the most in-demand skills.\n", + "Si quieres aprender a programar, has llegado al lugar adecuado.\n", + "Python es uno de los mejores lenguajes de programación para principiantes, y también una de las habilidades más demandadas.\n", "\n", - "You have also come at the right time, because learning to program now is probably easier than ever.\n", - "With virtual assistants like ChatGPT, you don't have to learn alone.\n", - "Throughout this book, I'll suggest ways you can use these tools to accelerate your learning.\n", + "También has llegado en el momento adecuado, porque aprender a programar ahora probablemente sea más fácil que nunca.\n", + "Con asistentes virtuales como ChatGPT, no tienes que aprender en soledad.\n", + "A lo largo de este libro, sugeriré formas de usar estas herramientas para acelerar tu aprendizaje.\n", "\n", - "This book is primarily for people who have never programmed before and people who have some experience in another programming language.\n", - "If you have substantial experience in Python, you might find the first few chapters too slow.\n", + "Este libro es principalmente para personas que nunca han programado y para personas que tienen algo de experiencia en otro lenguaje de programación.\n", + "Si tienes bastante experiencia en Python, quizá los primeros capítulos te parezcan demasiado lentos.\n", "\n", - "One of the challenges of learning to program is that you have to learn *two* languages: one is the programming language itself; the other is the vocabulary we use to talk about programs.\n", - "If you learn only the programming language, you are likely to have problems when you need to interpret an error message, read documentation, talk to another person, or use virtual assistants.\n", - "If you have done some programming, but you have not also learned this second language, I hope you find this book helpful." + "Uno de los retos de aprender a programar es que tienes que aprender *dos* lenguajes: uno es el propio lenguaje de programación; el otro es el vocabulario que usamos para hablar de programas.\n", + "Si solo aprendes el lenguaje de programación, es probable que tengas problemas cuando necesites interpretar un mensaje de error, leer documentación, hablar con otra persona o usar asistentes virtuales.\n", + "Si has programado algo, pero no has aprendido también este segundo lenguaje, espero que este libro te resulte útil." ] }, { @@ -46,21 +46,21 @@ "id": "b4dd57bc", "metadata": {}, "source": [ - "## Goals of the Book\n", + "## Objetivos del libro\n", "\n", - "Writing this book, I tried to be careful with the vocabulary.\n", - "I define each term when it first appears.\n", - "And there is a glossary that the end of each chapter that reviews the terms that were introduced.\n", + "Al escribir este libro, intenté tener cuidado con el vocabulario.\n", + "Defino cada término cuando aparece por primera vez.\n", + "Y al final de cada capítulo hay un glosario que repasa los términos que se han introducido.\n", "\n", - "I also tried to be concise.\n", - "The less mental effort it takes to read the book, the more capacity you will have for programming.\n", + "También intenté ser conciso.\n", + "Cuanto menos esfuerzo mental requiera leer el libro, más capacidad tendrás para programar.\n", "\n", - "But you can't learn to program just by reading a book -- you have to practice.\n", - "For that reason, this book includes exercises at the end of every chapter where you can practice what you have learned.\n", + "Pero no puedes aprender a programar solo leyendo un libro: tienes que practicar.\n", + "Por eso, este libro incluye ejercicios al final de cada capítulo en los que puedes practicar lo que has aprendido.\n", "\n", - "If you read carefully and work on exercises consistently, you will make progress.\n", - "But I'll warn you now -- learning to program is not easy, and even for experienced programmers it can be frustrating.\n", - "As we go, I will suggest strategies to help you write correct programs and fix incorrect ones." + "Si lees con atención y trabajas en los ejercicios de forma constante, avanzarás.\n", + "Pero te aviso desde ahora: aprender a programar no es fácil, e incluso para programadores con experiencia puede ser frustrante.\n", + "A medida que avancemos, sugeriré estrategias para ayudarte a escribir programas correctos y arreglar los incorrectos." ] }, { @@ -68,31 +68,31 @@ "id": "6516d914", "metadata": {}, "source": [ - "## Navigating the Book\n", + "## Cómo navegar por el libro\n", "\n", - "Each chapter in this book builds on the previous ones, so you should read them in order and take time to work on the exercises before you move on.\n", + "Cada capítulo de este libro se basa en los anteriores, así que deberías leerlos en orden y dedicar tiempo a trabajar en los ejercicios antes de seguir adelante.\n", "\n", - "The first six chapters introduce basic elements like arithmetic, conditionals, and loops.\n", - "They also introduce the most important concept in programming, functions, and a powerful way to use them, recursion.\n", + "Los primeros seis capítulos presentan elementos básicos como la aritmética, los condicionales y los bucles.\n", + "También presentan el concepto más importante de la programación, las funciones, y una forma potente de usarlas, la recursión.\n", "\n", - "Chapters 7 and 8 introduce strings -- which can represent letter, words, and sentences -- and algorithms for working with them.\n", + "Los capítulos 7 y 8 presentan strings, que pueden representar letras, palabras y frases, y algoritmos para trabajar con ellas.\n", "\n", - "Chapters 9 through 12 introduce Python's core data structures -- lists, dictionaries, and tuples -- which are powerful tools for writing efficient programs.\n", - "Chapter 12 presents algorithms for analyzing text and randomly generating new text.\n", - "Algorithms like these are at the core of large language models (LLMs), so this chapter will give you an idea of how tools like ChatGPT work.\n", + "Los capítulos 9 a 12 presentan las estructuras de datos principales de Python: listas, diccionarios y tuplas, que son herramientas potentes para escribir programas eficientes.\n", + "El capítulo 12 presenta algoritmos para analizar texto y generar texto nuevo de forma aleatoria.\n", + "Algoritmos como estos están en el núcleo de los modelos de lenguaje grandes (LLMs), así que este capítulo te dará una idea de cómo funcionan herramientas como ChatGPT.\n", "\n", - "Chapter 13 is about ways to store data in long-term storage -- files and databases.\n", - "As an exercise, you can write a program that searches a file system and finds duplicate files.\n", + "El capítulo 13 trata sobre formas de almacenar datos a largo plazo: archivos y bases de datos.\n", + "Como ejercicio, puedes escribir un programa que busque en un sistema de archivos y encuentre archivos duplicados.\n", "\n", - "Chapters 14 through 17 introduce object-oriented programming (OOP), which is a way to organize programs and the data they work with.\n", - "Many Python libraries are written in object-oriented style, so these chapters will help you understand their design -- and define your own objects.\n", + "Los capítulos 14 a 17 presentan la programación orientada a objetos (OOP), que es una forma de organizar programas y los datos con los que trabajan.\n", + "Muchas librerías de Python están escritas con estilo orientado a objetos, así que estos capítulos te ayudarán a entender su diseño y a definir tus propios objetos.\n", "\n", - "The goal of this book is not to cover the entire Python language.\n", - "Rather, I focus on a subset of the language that provides the greatest capability with the fewest concepts.\n", - "Nevertheless, Python has a lot of features you can use to solve common problems efficiently.\n", - "Chapter 18 presents some of these features.\n", + "El objetivo de este libro no es cubrir todo el lenguaje Python.\n", + "En cambio, me centro en un subconjunto del lenguaje que ofrece la mayor capacidad con el menor número de conceptos.\n", + "Aun así, Python tiene muchas características que puedes usar para resolver problemas comunes de forma eficiente.\n", + "El capítulo 18 presenta algunas de estas características.\n", "\n", - "Finally, Chapter 19 presents my parting thoughts and suggestions for continuing your programming journey." + "Por último, el capítulo 19 presenta mis reflexiones finales y sugerencias para continuar tu camino en la programación." ] }, { @@ -100,38 +100,38 @@ "id": "23013838", "metadata": {}, "source": [ - "## What's new in the third edition?\n", + "## ¿Qué hay de nuevo en la tercera edición?\n", "\n", - "The biggest changes in this edition were driven by two new technologies -- Jupyter notebooks and virtual assistants.\n", + "Los cambios más grandes de esta edición fueron impulsados por dos tecnologías nuevas: los Jupyter notebooks y los asistentes virtuales.\n", "\n", - "Each chapter of this book is a Jupyter notebook, which is a document that contains both ordinary text and code.\n", - "For me, that makes it easier to write the code, test it, and keep it consistent with the text.\n", - "For you, it means you can run the code, modify it, and work on the exercises, all in one place.\n", - "Instructions for working with the notebooks are in the first chapter.\n", + "Cada capítulo de este libro es un Jupyter notebook, que es un documento que contiene tanto texto normal como código.\n", + "Para mí, eso facilita escribir el código, probarlo y mantenerlo coherente con el texto.\n", + "Para ti, significa que puedes ejecutar el código, modificarlo y trabajar en los ejercicios, todo en un solo lugar.\n", + "Las instrucciones para trabajar con los notebooks están en el primer capítulo.\n", "\n", - "The other big change is that I've added advice for working with virtual assistants like ChatGPT and using them to accelerate your learning.\n", - "When the previous edition of this book was published in 2016, the predecessors of these tools were far less useful and most people were unaware of them. \n", - "Now they are a standard tool for software engineering, and I think they will be a transformational tool for learning to program -- and learning a lot of other things, too.\n", + "El otro gran cambio es que he añadido consejos para trabajar con asistentes virtuales como ChatGPT y usarlos para acelerar tu aprendizaje.\n", + "Cuando se publicó la edición anterior de este libro en 2016, los predecesores de estas herramientas eran mucho menos útiles y la mayoría de la gente no los conocía. \n", + "Ahora son una herramienta estándar para la ingeniería de software, y creo que serán una herramienta transformadora para aprender a programar, y para aprender muchas otras cosas también.\n", "\n", - "The other changes in the book were motivated by my regrets about the second edition.\n", + "Los demás cambios del libro fueron motivados por mis arrepentimientos sobre la segunda edición.\n", "\n", - "The first is that I did not emphasize software testing.\n", - "That was already a regrettable omission in 2016, but with the advent of virtual assistants, automated testing has become even more important.\n", - "So this edition presents Python's most widely-used testing tools, `doctest` and `unittest`, and includes several exercises where you can practice working with them.\n", + "El primero es que no puse suficiente énfasis en las pruebas de software.\n", + "Eso ya era una omisión lamentable en 2016, pero con la llegada de los asistentes virtuales, las pruebas automatizadas se han vuelto aún más importantes.\n", + "Así que esta edición presenta las herramientas de testing más usadas de Python, `doctest` y `unittest`, e incluye varios ejercicios donde puedes practicar con ellas.\n", "\n", - "My other regret is that the exercises in the second edition were uneven -- some were more interesting than others and some were too hard.\n", - "Moving to Jupyter notebooks helped me develop and test a more engaging and effective sequence of exercises.\n", + "Mi otro arrepentimiento es que los ejercicios de la segunda edición eran desiguales: algunos eran más interesantes que otros y algunos eran demasiado difíciles.\n", + "Pasar a Jupyter notebooks me ayudó a desarrollar y probar una secuencia de ejercicios más atractiva y eficaz.\n", "\n", - "In this revision, the sequence of topics is almost the same, but I rearranged a few of the chapters and compressed two short chapters into one.\n", - "Also, I expanded the coverage of strings to include regular expressions.\n", + "En esta revisión, la secuencia de temas es casi la misma, pero reorganicé algunos capítulos y comprimí dos capítulos cortos en uno.\n", + "Además, amplié la cobertura de strings para incluir expresiones regulares.\n", "\n", - "A few chapters use turtle graphics.\n", - "In previous editions, I used Python's `turtle` module, but unfortunately it doesn't work in Jupyter notebooks.\n", - "So I replaced it with a new turtle module that should be easier to use.\n", + "Algunos capítulos usan turtle graphics.\n", + "En ediciones anteriores usé el módulo `turtle` de Python, pero por desgracia no funciona en Jupyter notebooks.\n", + "Así que lo reemplacé por un nuevo turtle módulo que debería ser más fácil de usar.\n", "\n", - "Finally, I rewrote a substantial fraction of the text, clarifying places that needed it and cutting back in places where I was not as concise as I could be.\n", + "Por último, reescribí una parte considerable del texto, aclarando lugares que lo necesitaban y recortando en lugares donde no fui tan conciso como podía ser.\n", "\n", - "I am very proud of this new edition -- I hope you like it!" + "Estoy muy orgulloso de esta nueva edición. ¡Espero que te guste!" ] }, { @@ -139,27 +139,27 @@ "id": "bfb779bb", "metadata": {}, "source": [ - "## Getting started\n", + "## Primeros pasos\n", "\n", - "For most programming languages, including Python, there are many tools you can use to write and run programs. \n", - "These tools are called integrated development environments (IDEs).\n", - "In general, there are two kinds of IDEs:\n", + "Para la mayoría de los lenguajes de programación, incluido Python, hay muchas herramientas que puedes usar para escribir y ejecutar programas. \n", + "Estas herramientas se llaman entornos de desarrollo integrados (IDEs).\n", + "En general, hay dos tipos de IDEs:\n", "\n", - "* Some work with files that contain code, so they provide tools for editing and running these files.\n", + "* Algunos trabajan con archivos que contienen código, así que proporcionan herramientas para editar y ejecutar esos archivos.\n", "\n", - "* Others work primarily with notebooks, which are documents that contain text and code.\n", + "* Otros trabajan principalmente con notebooks, que son documentos que contienen texto y código.\n", "\n", - "For beginners, I recommend starting with a notebook development environment like Jupyter.\n", + "Para principiantes, recomiendo empezar con un entorno de desarrollo de notebooks como Jupyter.\n", "\n", - "The notebooks for this book are available from an online repository at .\n", + "Los notebooks de este libro están disponibles en un repositorio online en .\n", "\n", - "There are two ways to use them:\n", + "Hay dos formas de usarlos:\n", "\n", - "* You can download the notebooks and run them on your own computer. In that case, you have to install Python and Jupyter, which is not hard, but if you want to learn Python, it can be frustrating to spend a lot of time installing software.\n", + "* Puedes descargar los notebooks y ejecutarlos en tu propio ordenador. En ese caso, tienes que instalar Python y Jupyter, lo cual no es difícil, pero si quieres aprender Python puede ser frustrante pasar mucho tiempo instalando software.\n", "\n", - "* An alternative is to run the notebooks on Colab, which is a Jupyter environment that runs in a web browser, so you don't have to install anything. Colab is operated by Google, and it is free to use.\n", + "* Una alternativa es ejecutar los notebooks en Colab, que es un entorno Jupyter que se ejecuta en un navegador web, así que no tienes que instalar nada. Colab está operado por Google y es gratuito.\n", "\n", - "If you are just getting started, I strongly recommend you start with Colab." + "Si estás empezando, te recomiendo encarecidamente que empieces con Colab." ] }, { @@ -167,17 +167,17 @@ "id": "2ebd2412", "metadata": {}, "source": [ - "## Resources for Teachers\n", + "## Recursos para docentes\n", "\n", - "If you are teaching with this book, here are some resources you might find useful.\n", + "Si enseñas con este libro, aquí tienes algunos recursos que pueden resultarte útiles.\n", "\n", - "* You can find notebooks with solutions to the exercises from , along with links to the additional resources below.\n", + "* Puedes encontrar notebooks con soluciones a los ejercicios en , junto con enlaces a los recursos adicionales de abajo.\n", "\n", - "* Quizzes for each chapter, and a summative quiz for the whole book, are available from [COMING SOON]\n", + "* Los cuestionarios de cada capítulo, y un cuestionario final para todo el libro, están disponibles en [PRÓXIMAMENTE]\n", "\n", - "* *Teaching and Learning with Jupyter* is an online book with suggestions for using Jupyter effectively in the classroom. You can read the book at \n", + "* *Teaching and Learning with Jupyter* es un libro online con sugerencias para usar Jupyter de forma eficaz en el aula. Puedes leer el libro en \n", "\n", - "* One of the best ways to use notebooks is live coding, where an instructor writes code and students follow along in their own notebooks. To learn about live coding -- and get other great advice about teaching programming -- I recommend the instructor training provided by The Carpentries, at " + "* Una de las mejores formas de usar notebooks es programación en vivo (live coding), donde un instructor escribe código y los estudiantes le siguen en sus propios notebooks. Para aprender sobre programación en vivo, y obtener otros grandes consejos sobre enseñanza de programación, recomiendo la formación para instructores ofrecida por The Carpentries, en " ] }, { @@ -185,29 +185,29 @@ "id": "28e7de55", "metadata": {}, "source": [ - "## Acknowledgments\n", + "## Agradecimientos\n", "\n", - "Many thanks to Jeff Elkner, who translated my Java book into Python,\n", - "which got this project started and introduced me to what has turned out\n", - "to be my favorite language.\n", - "Thanks also to Chris Meyers, who contributed several sections to *How to Think Like a Computer Scientist*.\n", + "Muchas gracias a Jeff Elkner, que tradujo mi libro de Java a Python,\n", + "lo que puso en marcha este proyecto y me presentó lo que ha acabado siendo\n", + "mi lenguaje favorito.\n", + "Gracias también a Chris Meyers, que contribuyó con varias secciones a *How to Think Like a Computer Scientist*.\n", "\n", - "Thanks to the Free Software Foundation for developing the GNU Free Documentation License, which helped make my collaboration with Jeff and Chris possible, and thanks to the Creative Commons for the license I am using now.\n", + "Gracias a la Free Software Foundation por desarrollar la GNU Free Documentation License, que ayudó a hacer posible mi colaboración con Jeff y Chris, y gracias a Creative Commons por la licencia que uso ahora.\n", "\n", - "Thanks to the developers and maintainers of the Python language and the libraries I used, including the Turtle graphics module; the tools I used to develop the book, including Jupyter and JupyterBook; and the services I used, including ChatGPT, Copilot, Colab and GitHub.\n", + "Gracias a quienes desarrollan y mantienen el lenguaje Python y las librerías que usé, incluido el módulo de Turtle graphics; las herramientas que usé para desarrollar el libro, incluidos Jupyter y JupyterBook; y los servicios que usé, incluidos ChatGPT, Copilot, Colab y GitHub.\n", "\n", - "Thanks to the editors at Lulu who worked on *How to Think Like a Computer Scientist* and the editors at O'Reilly Media who worked on *Think Python*.\n", + "Gracias a los editores de Lulu que trabajaron en *How to Think Like a Computer Scientist* y a los editores de O'Reilly Media que trabajaron en *Think Python*.\n", "\n", - "Special thanks to the technical reviewers for the second edition, Melissa Lewis and Luciano Ramalho, and for the third edition, Sam Lau and Luciano Ramalho (again!).\n", - "I am also grateful to Luciano for developing the turtle graphics module I use in several chapters, called `jupyturtle`.\n", + "Un agradecimiento especial a los revisores técnicos de la segunda edición, Melissa Lewis y Luciano Ramalho, y de la tercera edición, Sam Lau y Luciano Ramalho (¡otra vez!).\n", + "También agradezco a Luciano haber desarrollado el turtle graphics módulo que uso en varios capítulos, llamado `jupyturtle`.\n", "\n", - "Thanks to all the students who worked with earlier versions of this book and all the contributors who sent in corrections and suggestions.\n", - "More than 100 sharp-eyed and thoughtful readers have sent in suggestions and corrections over the past few years. Their contributions, and enthusiasm for this project, have been a huge help.\n", + "Gracias a todos los estudiantes que trabajaron con versiones anteriores de este libro y a todos los colaboradores que enviaron correcciones y sugerencias.\n", + "Más de 100 lectores atentos y reflexivos han enviado sugerencias y correcciones durante los últimos años. Sus contribuciones, y su entusiasmo por este proyecto, han sido de enorme ayuda.\n", "\n", - "If you have a suggestion or correction, please send email to `feedback@thinkpython.com`.\n", - "If you include at least part of the sentence the error appears in, that\n", - "makes it easy for me to search. Page and section numbers are fine, too,\n", - "but not quite as easy to work with. Thanks!" + "Si tienes una sugerencia o corrección, envía un email a `feedback@thinkpython.com`.\n", + "Si incluyes al menos una parte de la frase en la que aparece el error, eso\n", + "me facilita la búsqueda. Los números de página y sección también sirven,\n", + "pero no son tan fáciles de manejar. ¡Gracias!" ] }, { @@ -225,13 +225,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/blank/chap01.ipynb b/blank/chap01.ipynb index 7b758f0..3ec37ff 100644 --- a/blank/chap01.ipynb +++ b/blank/chap01.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -17,14 +17,14 @@ "tags": [] }, "source": [ - "# Welcome\n", + "# Bienvenida\n", "\n", - "This is the Jupyter notebook for Chapter 1 of [*Think Python*, 3rd edition](https://greenteapress.com/wp/think-python-3rd-edition), by Allen B. Downey.\n", + "Este es el Jupyter notebook del capítulo 1 de [*Think Python*, 3.ª edición](https://greenteapress.com/wp/think-python-3rd-edition), de Allen B. Downey.\n", "\n", - "If you are not familiar with Jupyter notebooks,\n", - "[click here for a short introduction](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb).\n", + "Si no conoces los Jupyter notebooks,\n", + "[haz clic aquí para ver una breve introducción](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb).\n", "\n", - "Then, if you are not already running this notebook on Colab, [click here to run this notebook on Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." + "Luego, si aún no estás ejecutando este notebook en Colab, [haz clic aquí para ejecutar este notebook en Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." ] }, { @@ -34,9 +34,9 @@ "tags": [] }, "source": [ - "The following cell downloads a file and runs some code that is used specifically for this book.\n", - "You don't have to understand this code yet, but you should run it before you do anything else in this notebook.\n", - "Remember that you can run the code by selecting the cell and pressing the play button (a triangle in a circle) or hold down `Shift` and press `Enter`." + "La siguiente celda descarga un archivo y ejecuta algo de código que se usa específicamente para este libro.\n", + "Todavía no tienes que entender este código, pero deberías ejecutarlo antes de hacer cualquier otra cosa en este notebook.\n", + "Recuerda que puedes ejecutar el código seleccionando la celda y pulsando el botón de reproducción (un triángulo dentro de un círculo) o manteniendo pulsada la tecla `Shift` y presionando `Enter`." ] }, { @@ -71,21 +71,21 @@ "tags": [] }, "source": [ - "# Programming as a way of thinking\n", + "# Programar como una forma de pensar\n", "\n", - "The first goal of this book is to teach you how to program in Python.\n", - "But learning to program means learning a new way to think, so the second goal of this book is to help you think like a computer scientist.\n", - "This way of thinking combines some of the best features of mathematics, engineering, and natural science.\n", - "Like mathematicians, computer scientists use formal languages to denote ideas -- specifically computations.\n", - "Like engineers, they design things, assembling components into systems and evaluating trade-offs among alternatives.\n", - "Like scientists, they observe the behavior of complex systems, form hypotheses, and test predictions.\n", + "El primer objetivo de este libro es enseñarte a programar en Python.\n", + "Pero aprender a programar implica aprender una nueva forma de pensar, así que el segundo objetivo de este libro es ayudarte a pensar como un científico de la computación.\n", + "Esta forma de pensar combina algunas de las mejores características de las matemáticas, la ingeniería y las ciencias naturales.\n", + "Como los matemáticos, los científicos de la computación usan lenguajes formales para expresar ideas -- específicamente, cómputos.\n", + "Como los ingenieros, diseñan cosas, ensamblan componentes en sistemas y evalúan las ventajas y desventajas de distintas alternativas.\n", + "Como los científicos, observan el comportamiento de sistemas complejos, formulan hipótesis y prueban predicciones.\n", "\n", - "We will start with the most basic elements of programming and work our way up.\n", - "In this chapter, we'll see how Python represents numbers, letters, and words.\n", - "And you'll learn to perform arithmetic operations.\n", + "Empezaremos con los elementos más básicos de la programación y avanzaremos poco a poco.\n", + "En este capítulo veremos cómo Python representa números, letras y palabras.\n", + "Y aprenderás a realizar operaciones aritméticas.\n", "\n", - "You will also start to learn the vocabulary of programming, including terms like operator, expression, value, and type.\n", - "This vocabulary is important -- you will need it to understand the rest of the book, to communicate with other programmers, and to use and understand virtual assistants." + "También empezarás a aprender el vocabulario de la programación, incluyendo términos como operador, expresión, valor y tipo.\n", + "Este vocabulario es importante -- lo necesitarás para entender el resto del libro, comunicarte con otros programadores y usar y entender asistentes virtuales." ] }, { @@ -93,9 +93,9 @@ "id": "a371aea3", "metadata": {}, "source": [ - "## Arithmetic operators\n", + "## Operadores aritméticos\n", "\n", - "An **arithmetic operator** is a symbol that represents an arithmetic computation. For example, the plus sign, `+`, performs addition." + "Un **operador aritmético** es un símbolo que representa un cálculo aritmético. Por ejemplo, el signo más, `+`, realiza una suma." ] }, { @@ -111,7 +111,7 @@ "id": "fc0e7ce8", "metadata": {}, "source": [ - "The minus sign, `-`, is the operator that performs subtraction." + "El signo menos, `-`, es el operador que realiza una resta." ] }, { @@ -127,7 +127,7 @@ "id": "63e4e780", "metadata": {}, "source": [ - "The asterisk, `*`, performs multiplication." + "El asterisco, `*`, realiza una multiplicación." ] }, { @@ -143,7 +143,7 @@ "id": "a6192d13", "metadata": {}, "source": [ - "And the forward slash, `/`, performs division:" + "Y la barra inclinada, `/`, realiza una división:" ] }, { @@ -159,16 +159,16 @@ "id": "641ad233", "metadata": {}, "source": [ - "Notice that the result of the division is `42.0` rather than `42`. That's because there are two types of numbers in Python: \n", + "Observa que el resultado de la división es `42.0` en lugar de `42`. Eso se debe a que hay dos tipos de números en Python: \n", "\n", - "* **integers**, which represent numbers with no fractional or decimal part, and \n", + "* **enteros**, que representan números sin parte fraccionaria o decimal, y \n", "\n", - "* **floating-point numbers**, which represent integers and numbers with a decimal point.\n", + "* **números de coma flotante**, que representan enteros y números con punto decimal.\n", "\n", - "If you add, subtract, or multiply two integers, the result is an integer.\n", - "But if you divide two integers, the result is a floating-point number.\n", - "Python provides another operator, `//`, that performs **integer division**.\n", - "The result of integer division is always an integer." + "Si sumas, restas o multiplicas dos enteros, el resultado es un entero.\n", + "Pero si divides dos enteros, el resultado es un número de coma flotante.\n", + "Python proporciona otro operador, `//`, que realiza **división entera**.\n", + "El resultado de la división entera siempre es un entero." ] }, { @@ -184,7 +184,7 @@ "id": "b2a620ab", "metadata": {}, "source": [ - "Integer division is also called \"floor division\" because it always rounds down (toward the \"floor\"). " + "La división entera también se llama \"división de piso\" porque siempre redondea hacia abajo (hacia el \"piso\"). " ] }, { @@ -200,8 +200,7 @@ "id": "41e2886a", "metadata": {}, "source": [ - "Finally, the operator `**` performs exponentiation; that is, it raises a\n", - "number to a power:" + "Por último, el operador `**` realiza exponenciación; es decir, eleva un número a una potencia:" ] }, { @@ -217,9 +216,8 @@ "id": "b2502fb6", "metadata": {}, "source": [ - "In some other languages, the caret, `^`, is used for exponentiation, but in Python\n", - "it is a bitwise operator called XOR.\n", - "If you are not familiar with bitwise operators, the result might be unexpected:" + "En algunos otros lenguajes, el acento circunflejo, `^`, se usa para la exponenciación, pero en Python es un operador bit a bit llamado XOR.\n", + "Si no conoces los operadores bit a bit, el resultado puede ser inesperado:" ] }, { @@ -235,8 +233,7 @@ "id": "30078370", "metadata": {}, "source": [ - "I won't cover bitwise operators in this book, but you can read about\n", - "them at ." + "No cubriré los operadores bit a bit en este libro, pero puedes leer sobre ellos en ." ] }, { @@ -244,11 +241,11 @@ "id": "0f5b7e97", "metadata": {}, "source": [ - "## Expressions\n", + "## Expresiones\n", "\n", - "A collection of operators and numbers is called an **expression**.\n", - "An expression can contain any number of operators and numbers.\n", - "For example, here's an expression that contains two operators." + "Un conjunto de operadores y números se llama una **expresión**.\n", + "Una expresión puede contener cualquier cantidad de operadores y números.\n", + "Por ejemplo, aquí hay una expresión que contiene dos operadores." ] }, { @@ -264,10 +261,10 @@ "id": "8e95039c", "metadata": {}, "source": [ - "Notice that exponentiation happens before addition.\n", - "Python follows the order of operations you might have learned in a math class: exponentiation happens before multiplication and division, which happen before addition and subtraction.\n", + "Observa que la exponenciación ocurre antes que la suma.\n", + "Python sigue el orden de operaciones que quizá aprendiste en clase de matemáticas: la exponenciación ocurre antes que la multiplicación y la división, que ocurren antes que la suma y la resta.\n", "\n", - "In the following example, multiplication happens before addition." + "En el siguiente ejemplo, la multiplicación ocurre antes que la suma." ] }, { @@ -283,7 +280,7 @@ "id": "914a60d8", "metadata": {}, "source": [ - "If you want the addition to happen first, you can use parentheses." + "Si quieres que la suma ocurra primero, puedes usar paréntesis." ] }, { @@ -299,8 +296,8 @@ "id": "67ae0ae9", "metadata": {}, "source": [ - "Every expression has a **value**.\n", - "For example, the expression `6 * 7` has the value `42`." + "Toda expresión tiene un **valor**.\n", + "Por ejemplo, la expresión `6 * 7` tiene el valor `42`." ] }, { @@ -308,10 +305,10 @@ "id": "caebaa51", "metadata": {}, "source": [ - "## Arithmetic functions\n", + "## Funciones aritméticas\n", "\n", - "In addition to the arithmetic operators, Python provides a few **functions** that work with numbers.\n", - "For example, the `round` function takes a floating-point number and rounds it off to the nearest integer." + "Además de los operadores aritméticos, Python proporciona algunas **funciones** que trabajan con números.\n", + "Por ejemplo, la función `round` toma un número de coma flotante y lo redondea al entero más cercano." ] }, { @@ -335,8 +332,8 @@ "id": "f5738b4b", "metadata": {}, "source": [ - "The `abs` function computes the absolute value of a number.\n", - "For a positive number, the absolute value is the number itself." + "La función `abs` calcula el valor absoluto de un número.\n", + "Para un número positivo, el valor absoluto es el propio número." ] }, { @@ -352,7 +349,7 @@ "id": "e518494a", "metadata": {}, "source": [ - "For a negative number, the absolute value is positive." + "Para un número negativo, el valor absoluto es positivo." ] }, { @@ -368,11 +365,11 @@ "id": "6969ce45", "metadata": {}, "source": [ - "When we use a function like this, we say we're **calling** the function.\n", - "An expression that calls a function is a **function call**.\n", + "Cuando usamos una función como esta, decimos que estamos **llamando** a la función.\n", + "Una expresión que llama a una función es una **llamada a función**.\n", "\n", - "When you call a function, the parentheses are required.\n", - "If you leave them out, you get an error message." + "Cuando llamas a una función, los paréntesis son obligatorios.\n", + "Si los omites, obtienes un mensaje de error." ] }, { @@ -382,8 +379,8 @@ "tags": [] }, "source": [ - "NOTE: The following cell uses `%%expect`, which is a Jupyter \"magic command\" that means we expect the code in this cell to produce an error. For more on this topic, see the\n", - "[Jupyter notebook introduction](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." + "NOTA: La siguiente celda usa `%%expect`, que es un \"magic command\" de Jupyter que significa que esperamos que el código de esta celda produzca un error. Para más información sobre este tema, consulta la\n", + "[introducción a Jupyter notebook](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." ] }, { @@ -401,13 +398,13 @@ "id": "7d356f1b", "metadata": {}, "source": [ - "You can ignore the first line of this message; it doesn't contain any information we need to understand right now.\n", - "The second line is the code that contains the error, with a caret (`^`) beneath it to indicate where the error was discovered.\n", + "Puedes ignorar la primera línea de este mensaje; no contiene ninguna información que necesitemos entender ahora mismo.\n", + "La segunda línea es el código que contiene el error, con un acento circunflejo (`^`) debajo para indicar dónde se descubrió el error.\n", "\n", - "The last line indicates that this is a **syntax error**, which means that there is something wrong with the structure of the expression.\n", - "In this example, the problem is that a function call requires parentheses.\n", + "La última línea indica que se trata de un **error de sintaxis**, lo que significa que hay algo incorrecto en la estructura de la expresión.\n", + "En este ejemplo, el problema es que una llamada a función requiere paréntesis.\n", "\n", - "Let's see what happens if you leave out the parentheses *and* the value." + "Veamos qué ocurre si omites los paréntesis *y* el valor." ] }, { @@ -423,8 +420,8 @@ "id": "94478885", "metadata": {}, "source": [ - "A function name all by itself is a legal expression that has a value.\n", - "When it's displayed, the value indicates that `abs` is a function, and it includes some additional information I'll explain later." + "Un nombre de función por sí solo es una expresión válida que tiene un valor.\n", + "Cuando se muestra, el valor indica que `abs` es una función e incluye información adicional que explicaré más adelante." ] }, { @@ -434,8 +431,8 @@ "source": [ "## Strings\n", "\n", - "In addition to numbers, Python can also represent sequences of letters, which are called **strings** because the letters are strung together like beads on a necklace.\n", - "To write a string, we can put a sequence of letters inside straight quotation marks." + "Además de números, Python también puede representar secuencias de letras, que se llaman **strings** porque las letras están ensartadas como cuentas en un collar.\n", + "Para escribir un string, podemos poner una secuencia de letras entre comillas rectas." ] }, { @@ -451,7 +448,7 @@ "id": "d20050d8", "metadata": {}, "source": [ - "It is also legal to use double quotation marks." + "También es válido usar comillas dobles." ] }, { @@ -467,7 +464,7 @@ "id": "76f5edb7", "metadata": {}, "source": [ - "Double quotes make it easy to write a string that contains an apostrophe, which is the same symbol as a straight quote." + "Las comillas dobles facilitan escribir un string que contiene un apóstrofo, que es el mismo símbolo que una comilla recta." ] }, { @@ -483,7 +480,7 @@ "id": "d62d4b1c", "metadata": {}, "source": [ - "Strings can also contain spaces, punctuation, and digits." + "Los strings también pueden contener espacios, signos de puntuación y dígitos." ] }, { @@ -499,7 +496,7 @@ "id": "9ad47f7a", "metadata": {}, "source": [ - "The `+` operator works with strings; it joins two strings into a single string, which is called **concatenation**" + "El operador `+` funciona con strings; une dos strings en un solo string, lo que se llama **concatenación**" ] }, { @@ -515,7 +512,7 @@ "id": "0ad969a3", "metadata": {}, "source": [ - "The `*` operator also works with strings; it makes multiple copies of a string and concatenates them." + "El operador `*` también funciona con strings; hace varias copias de un string y las concatena." ] }, { @@ -531,9 +528,9 @@ "id": "dfba16a5", "metadata": {}, "source": [ - "The other arithmetic operators don't work with strings.\n", + "Los otros operadores aritméticos no funcionan con strings.\n", "\n", - "Python provides a function called `len` that computes the length of a string." + "Python proporciona una función llamada `len` que calcula la longitud de un string." ] }, { @@ -549,10 +546,10 @@ "id": "d91e00b3", "metadata": {}, "source": [ - "Notice that `len` counts the letters between the quotes, but not the quotes.\n", + "Observa que `len` cuenta las letras entre las comillas, pero no las comillas.\n", "\n", - "When you create a string, be sure to use straight quotes.\n", - "The back quote, also known as a backtick, causes a syntax error." + "Cuando crees un string, asegúrate de usar comillas rectas.\n", + "La comilla invertida, también conocida como backtick, causa un error de sintaxis." ] }, { @@ -570,7 +567,7 @@ "id": "40d893d1", "metadata": {}, "source": [ - "Smart quotes, also known as curly quotes, are also illegal." + "Las comillas tipográficas, también conocidas como comillas curvas, tampoco son válidas." ] }, { @@ -588,21 +585,21 @@ "id": "5471d4f8", "metadata": {}, "source": [ - "## Values and types\n", + "## Valores y tipos\n", "\n", - "So far we've seen three kinds of values:\n", + "Hasta ahora hemos visto tres clases de valores:\n", "\n", - "* `2` is an integer,\n", + "* `2` es un entero,\n", "\n", - "* `42.0` is a floating-point number, and \n", + "* `42.0` es un número de coma flotante, y \n", "\n", - "* `'Hello'` is a string.\n", + "* `'Hello'` es un string.\n", "\n", - "A kind of value is called a **type**.\n", - "Every value has a type -- or we sometimes say it \"belongs to\" a type.\n", + "Una clase de valor se llama **tipo**.\n", + "Todo valor tiene un tipo -- o a veces decimos que \"pertenece a\" un tipo.\n", "\n", - "Python provides a function called `type` that tells you the type of any value.\n", - "The type of an integer is `int`." + "Python proporciona una función llamada `type` que te dice el tipo de cualquier valor.\n", + "El tipo de un entero es `int`." ] }, { @@ -618,7 +615,7 @@ "id": "b137814c", "metadata": {}, "source": [ - "The type of a floating-point number is `float`." + "El tipo de un número de coma flotante es `float`." ] }, { @@ -634,7 +631,7 @@ "id": "266dea4e", "metadata": {}, "source": [ - "And the type of a string is `str`." + "Y el tipo de un string es `str`." ] }, { @@ -650,8 +647,8 @@ "id": "76d216ed", "metadata": {}, "source": [ - "The types `int`, `float`, and `str` can be used as functions.\n", - "For example, `int` can take a floating-point number and convert it to an integer (always rounding down)." + "Los tipos `int`, `float` y `str` se pueden usar como funciones.\n", + "Por ejemplo, `int` puede tomar un número de coma flotante y convertirlo en un entero (siempre redondeando hacia abajo)." ] }, { @@ -667,7 +664,7 @@ "id": "dcd8d114", "metadata": {}, "source": [ - "And `float` can convert an integer to a floating-point value." + "Y `float` puede convertir un entero en un valor de punto flotante." ] }, { @@ -683,8 +680,8 @@ "id": "eda70b61", "metadata": {}, "source": [ - "Now, here's something that can be confusing.\n", - "What do you get if you put a sequence of digits in quotes?" + "Ahora, aquí hay algo que puede ser confuso.\n", + "¿Qué obtienes si pones una secuencia de dígitos entre comillas?" ] }, { @@ -700,7 +697,7 @@ "id": "fdded653", "metadata": {}, "source": [ - "It looks like a number, but it is actually a string." + "Parece un número, pero en realidad es un string." ] }, { @@ -716,7 +713,7 @@ "id": "2683ac35", "metadata": {}, "source": [ - "If you try to use it like a number, you might get an error." + "Si intentas usarlo como un número, puede que obtengas un error." ] }, { @@ -734,10 +731,10 @@ "id": "32c11cc4", "metadata": {}, "source": [ - "This example generates a `TypeError`, which means that the values in the expression, which are called **operands**, have the wrong type.\n", - "The error message indicates that the `/` operator does not support the types of these values, which are `str` and `int`.\n", + "Este ejemplo genera un `TypeError`, lo que significa que los valores de la expresión, que se llaman **operandos**, tienen el tipo incorrecto.\n", + "El mensaje de error indica que el operador `/` no admite los tipos de estos valores, que son `str` e `int`.\n", "\n", - "If you have a string that contains digits, you can use `int` to convert it to an integer." + "Si tienes un string que contiene dígitos, puedes usar `int` para convertirlo en un entero." ] }, { @@ -753,7 +750,7 @@ "id": "86935d56", "metadata": {}, "source": [ - "If you have a string that contains digits and a decimal point, you can use `float` to convert it to a floating-point number." + "Si tienes un string que contiene dígitos y un punto decimal, puedes usar `float` para convertirlo en un número de coma flotante." ] }, { @@ -769,9 +766,8 @@ "id": "03103ef4", "metadata": {}, "source": [ - "When you write a large integer, you might be tempted to use commas\n", - "between groups of digits, as in `1,000,000`.\n", - "This is a legal expression in Python, but the result is not an integer." + "Cuando escribes un entero grande, puede que te sientas tentado a usar comas entre grupos de dígitos, como en `1,000,000`.\n", + "Esta es una expresión válida en Python, pero el resultado no es un entero." ] }, { @@ -787,10 +783,10 @@ "id": "3d24af71", "metadata": {}, "source": [ - "Python interprets `1,000,000` as a comma-separated sequence of integers.\n", - "We'll learn more about this kind of sequence later.\n", + "Python interpreta `1,000,000` como una secuencia de enteros separados por comas.\n", + "Aprenderemos más sobre este tipo de secuencia más adelante.\n", "\n", - "You can use underscores to make large numbers easier to read." + "Puedes usar guiones bajos para que los números grandes sean más fáciles de leer." ] }, { @@ -806,13 +802,13 @@ "id": "1761cbac", "metadata": {}, "source": [ - "## Formal and natural languages\n", + "## Lenguajes formales y naturales\n", "\n", - "**Natural languages** are the languages people speak, like English, Spanish, and French. They were not designed by people; they evolved naturally.\n", + "Los **lenguajes naturales** son los idiomas que hablan las personas, como inglés, español y francés. No fueron diseñados por personas; evolucionaron de forma natural.\n", "\n", - "**Formal languages** are languages that are designed by people for specific applications. \n", - "For example, the notation that mathematicians use is a formal language that is particularly good at denoting relationships among numbers and symbols.\n", - "Similarly, programming languages are formal languages that have been designed to express computations." + "Los **lenguajes formales** son lenguajes diseñados por personas para aplicaciones específicas. \n", + "Por ejemplo, la notación que usan los matemáticos es un lenguaje formal especialmente bueno para representar relaciones entre números y símbolos.\n", + "De forma similar, los lenguajes de programación son lenguajes formales diseñados para expresar cómputos." ] }, { @@ -820,19 +816,13 @@ "id": "1bf3d2dc", "metadata": {}, "source": [ - "Although formal and natural languages have some features in\n", - "common there are important differences:\n", + "Aunque los lenguajes formales y naturales tienen algunas características en común, hay diferencias importantes:\n", "\n", - "* Ambiguity: Natural languages are full of ambiguity, which people deal with by\n", - " using contextual clues and other information. Formal languages are\n", - " designed to be nearly or completely unambiguous, which means that\n", - " any program has exactly one meaning, regardless of context.\n", + "* Ambigüedad: Los lenguajes naturales están llenos de ambigüedad, que las personas manejan usando pistas contextuales y otra información. Los lenguajes formales están diseñados para ser casi o completamente no ambiguos, lo que significa que cualquier programa tiene exactamente un significado, independientemente del contexto.\n", "\n", - "* Redundancy: In order to make up for ambiguity and reduce misunderstandings,\n", - " natural languages use redundancy. As a result, they are\n", - " often verbose. Formal languages are less redundant and more concise.\n", + "* Redundancia: Para compensar la ambigüedad y reducir malentendidos, los lenguajes naturales usan redundancia. Como resultado, a menudo son verbosos. Los lenguajes formales son menos redundantes y más concisos.\n", "\n", - "* Literalness: Natural languages are full of idiom and metaphor. Formal languages mean exactly what they say." + "* Literalidad: Los lenguajes naturales están llenos de modismos y metáforas. Los lenguajes formales significan exactamente lo que dicen." ] }, { @@ -840,12 +830,10 @@ "id": "78a1cec8", "metadata": {}, "source": [ - "Because we all grow up speaking natural languages, it is sometimes hard to adjust to formal languages.\n", - "Formal languages are more dense than natural languages, so it takes longer to read them.\n", - "Also, the structure is important, so it is not always best to read from top to bottom, left to right.\n", - "Finally, the details matter. Small errors in spelling and\n", - "punctuation, which you can get away with in natural languages, can make\n", - "a big difference in a formal language." + "Como todos crecemos hablando lenguajes naturales, a veces cuesta adaptarse a los lenguajes formales.\n", + "Los lenguajes formales son más densos que los lenguajes naturales, así que lleva más tiempo leerlos.\n", + "Además, la estructura es importante, por lo que no siempre es mejor leer de arriba abajo, de izquierda a derecha.\n", + "Por último, los detalles importan. Pequeños errores de ortografía y puntuación, que puedes tolerar en los lenguajes naturales, pueden marcar una gran diferencia en un lenguaje formal." ] }, { @@ -855,15 +843,15 @@ "source": [ "## Debugging\n", "\n", - "Programmers make mistakes. For whimsical reasons, programming errors are called **bugs** and the process of tracking them down is called **debugging**.\n", + "Los programadores cometen errores. Por razones caprichosas, los errores de programación se llaman **bugs** y el proceso de encontrarlos se llama **debugging**.\n", "\n", - "Programming, and especially debugging, sometimes brings out strong emotions. If you are struggling with a difficult bug, you might feel angry, sad, or embarrassed.\n", + "Programar, y especialmente debugging, a veces provoca emociones intensas. Si estás luchando con un bug difícil, puede que sientas enfado, tristeza o vergüenza.\n", "\n", - "Preparing for these reactions might help you deal with them. One approach is to think of the computer as an employee with certain strengths, like speed and precision, and particular weaknesses, like lack of empathy and inability to grasp the big picture.\n", + "Prepararte para estas reacciones puede ayudarte a manejarlas. Un enfoque es pensar en la computadora como un empleado con ciertas fortalezas, como velocidad y precisión, y debilidades particulares, como falta de empatía e incapacidad para captar el panorama general.\n", "\n", - "Your job is to be a good manager: find ways to take advantage of the strengths and mitigate the weaknesses. And find ways to use your emotions to engage with the problem, without letting your reactions interfere with your ability to work effectively.\n", + "Tu trabajo es ser un buen gerente: encontrar formas de aprovechar las fortalezas y mitigar las debilidades. Y encontrar formas de usar tus emociones para involucrarte con el problema, sin dejar que tus reacciones interfieran con tu capacidad de trabajar eficazmente.\n", "\n", - "Learning to debug can be frustrating, but it is a valuable skill that is useful for many activities beyond programming. At the end of each chapter there is a section, like this one, with my suggestions for debugging. I hope they help!" + "Aprender a debug puede ser frustrante, pero es una habilidad valiosa que resulta útil para muchas actividades más allá de la programación. Al final de cada capítulo hay una sección, como esta, con mis sugerencias para debugging. ¡Espero que te ayuden!" ] }, { @@ -871,62 +859,62 @@ "id": "33b8ad00", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**arithmetic operator:**\n", - "A symbol, like `+` and `*`, that denotes an arithmetic operation like addition or multiplication.\n", + "**operador aritmético:**\n", + "Un símbolo, como `+` y `*`, que denota una operación aritmética como suma o multiplicación.\n", "\n", - "**integer:**\n", - "A type that represents numbers with no fractional or decimal part.\n", + "**entero:**\n", + "Un tipo que representa números sin parte fraccionaria o decimal.\n", "\n", - "**floating-point:**\n", - "A type that represents integers and numbers with decimal parts.\n", + "**número de coma flotante:**\n", + "Un tipo que representa enteros y números con partes decimales.\n", "\n", - "**integer division:**\n", - "An operator, `//`, that divides two numbers and rounds down to an integer.\n", + "**división entera:**\n", + "Un operador, `//`, que divide dos números y redondea hacia abajo a un entero.\n", "\n", - "**expression:**\n", - "A combination of variables, values, and operators.\n", + "**expresión:**\n", + "Una combinación de variables, valores y operadores.\n", "\n", - "**value:**\n", - "An integer, floating-point number, or string -- or one of other kinds of values we will see later.\n", + "**valor:**\n", + "Un entero, número de coma flotante o string -- u otro de los tipos de valores que veremos más adelante.\n", "\n", - "**function:**\n", - "A named sequence of statements that performs some useful operation.\n", - "Functions may or may not take arguments and may or may not produce a result.\n", + "**función:**\n", + "Una secuencia con nombre de sentencias que realiza alguna operación útil.\n", + "Las funciones pueden tomar argumentos o no, y pueden producir un resultado o no.\n", "\n", - "**function call:**\n", - "An expression -- or part of an expression -- that runs a function.\n", - "It consists of the function name followed by an argument list in parentheses.\n", + "**llamada a función:**\n", + "Una expresión -- o parte de una expresión -- que ejecuta una función.\n", + "Consiste en el nombre de la función seguido de una lista de argumentos entre paréntesis.\n", "\n", - "**syntax error:**\n", - "An error in a program that makes it impossible to parse -- and therefore impossible to run.\n", + "**error de sintaxis:**\n", + "Un error en un programa que hace imposible analizarlo -- y por lo tanto imposible ejecutarlo.\n", "\n", "**string:**\n", - " A type that represents sequences of characters.\n", + " Un tipo que representa secuencias de caracteres.\n", "\n", - "**concatenation:**\n", - "Joining two strings end-to-end.\n", + "**concatenación:**\n", + "Unir dos strings extremo con extremo.\n", "\n", - "**type:**\n", - "A category of values.\n", - "The types we have seen so far are integers (type `int`), floating-point numbers (type ` float`), and strings (type `str`).\n", + "**tipo:**\n", + "Una categoría de valores.\n", + "Los tipos que hemos visto hasta ahora son enteros (tipo `int`), números de coma flotante (tipo ` float`) y strings (tipo `str`).\n", "\n", - "**operand:**\n", - "One of the values on which an operator operates.\n", + "**operando:**\n", + "Uno de los valores sobre los que opera un operador.\n", "\n", - "**natural language:**\n", - "Any of the languages that people speak that evolved naturally.\n", + "**lenguaje natural:**\n", + "Cualquiera de los idiomas que hablan las personas y que evolucionaron de forma natural.\n", "\n", - "**formal language:**\n", - "Any of the languages that people have designed for specific purposes, such as representing mathematical ideas or computer programs.\n", - "All programming languages are formal languages.\n", + "**lenguaje formal:**\n", + "Cualquiera de los lenguajes que las personas han diseñado para propósitos específicos, como representar ideas matemáticas o programas de computadora.\n", + "Todos los lenguajes de programación son lenguajes formales.\n", "\n", "**bug:**\n", - "An error in a program.\n", + "Un error en un programa.\n", "\n", "**debugging:**\n", - "The process of finding and correcting errors." + "El proceso de encontrar y corregir errores." ] }, { @@ -934,7 +922,7 @@ "id": "ed4ec01b", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -957,15 +945,15 @@ "id": "23adf208", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregúntale a un asistente virtual\n", "\n", - "As you work through this book, there are several ways you can use a virtual assistant or chatbot to help you learn.\n", + "A medida que avances en este libro, hay varias formas en las que puedes usar un asistente virtual o chatbot para ayudarte a aprender.\n", "\n", - "* If you want to learn more about a topic in the chapter, or anything is unclear, you can ask for an explanation.\n", + "* Si quieres aprender más sobre un tema del capítulo, o algo no está claro, puedes pedir una explicación.\n", "\n", - "* If you are having a hard time with any of the exercises, you can ask for help.\n", + "* Si tienes dificultades con alguno de los ejercicios, puedes pedir ayuda.\n", "\n", - "In each chapter, I'll suggest exercises you can do with a virtual assistant, but I encourage you to try things on your own and see what works for you." + "En cada capítulo sugeriré ejercicios que puedes hacer con un asistente virtual, pero te animo a probar cosas por tu cuenta y ver qué te funciona." ] }, { @@ -973,15 +961,15 @@ "id": "ebf1a451", "metadata": {}, "source": [ - "Here are some topics you could ask a virtual assistant about:\n", + "Aquí tienes algunos temas sobre los que podrías preguntar a un asistente virtual:\n", "\n", - "* Earlier I mentioned bitwise operators but I didn't explain why the value of `7 ^ 2` is 5. Try asking \"What are the bitwise operators in Python?\" or \"What is the value of `7 XOR 2`?\"\n", + "* Antes mencioné los operadores bit a bit, pero no expliqué por qué el valor de `7 ^ 2` es 5. Prueba a preguntar \"¿Cuáles son los operadores bit a bit en Python?\" o \"¿Cuál es el valor de `7 XOR 2`?\"\n", "\n", - "* I also mentioned the order of operations. For more details, ask \"What is the order of operations in Python?\"\n", + "* También mencioné el orden de operaciones. Para más detalles, pregunta \"¿Cuál es el orden de las operaciones en Python?\"\n", "\n", - "* The `round` function, which we used to round a floating-point number to the nearest integer, can take a second argument. Try asking \"What are the arguments of the round function?\" or \"How do I round pi off to three decimal places?\"\n", + "* La función `round`, que usamos para redondear un número de coma flotante al entero más cercano, puede tomar un segundo argumento. Prueba a preguntar \"¿Cuáles son los argumentos de la función round?\" o \"¿Cómo redondeo pi a tres decimales?\"\n", "\n", - "* There's one more arithmetic operator I didn't mention; try asking \"What is the modulus operator in Python?\"" + "* Hay un operador aritmético más que no mencioné; prueba a preguntar \"¿Qué es el operador módulo en Python?\"" ] }, { @@ -989,9 +977,9 @@ "id": "9be3e1c7", "metadata": {}, "source": [ - "Most virtual assistants know about Python, so they answer questions like this pretty reliably.\n", - "But remember that these tools make mistakes.\n", - "If you get code from a chatbot, test it!" + "La mayoría de los asistentes virtuales saben sobre Python, así que responden preguntas como estas de forma bastante fiable.\n", + "Pero recuerda que estas herramientas cometen errores.\n", + "Si obtienes código de un chatbot, ¡pruébalo!" ] }, { @@ -999,11 +987,11 @@ "id": "03c1ef93", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "You might wonder what `round` does if a number ends in `0.5`.\n", - "The answer is that it sometimes rounds up and sometimes rounds down.\n", - "Try these examples and see if you can figure out what rule it follows." + "Quizá te preguntes qué hace `round` si un número termina en `0.5`.\n", + "La respuesta es que a veces redondea hacia arriba y a veces hacia abajo.\n", + "Prueba estos ejemplos y mira si puedes averiguar qué regla sigue." ] }, { @@ -1027,7 +1015,7 @@ "id": "dd2f890e", "metadata": {}, "source": [ - "If you are curious, ask a virtual assistant, \"If a number ends in 0.5, does Python round up or down?\"" + "Si tienes curiosidad, pregunta a un asistente virtual: \"Si un número termina en 0.5, ¿Python redondea hacia arriba o hacia abajo?\"" ] }, { @@ -1035,17 +1023,17 @@ "id": "2cd03bcb", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "When you learn about a new feature, you should try it out and make mistakes on purpose.\n", - "That way, you learn the error messages, and when you see them again, you will know what they mean.\n", - "It is better to make mistakes now and deliberately than later and accidentally.\n", + "Cuando aprendes una característica nueva, deberías probarla y cometer errores a propósito.\n", + "Así aprendes los mensajes de error y, cuando los vuelvas a ver, sabrás qué significan.\n", + "Es mejor cometer errores ahora y deliberadamente que más tarde y accidentalmente.\n", "\n", - "1. You can use a minus sign to make a negative number like `-2`. What happens if you put a plus sign before a number? What about `2++2`?\n", + "1. Puedes usar un signo menos para crear un número negativo como `-2`. ¿Qué ocurre si pones un signo más delante de un número? ¿Y con `2++2`?\n", "\n", - "2. What happens if you have two values with no operator between them, like `4 2`?\n", + "2. ¿Qué ocurre si tienes dos valores sin operador entre ellos, como `4 2`?\n", "\n", - "3. If you call a function like `round(42.5)`, what happens if you leave out one or both parentheses?" + "3. Si llamas a una función como `round(42.5)`, ¿qué ocurre si omites uno o ambos paréntesis?" ] }, { @@ -1053,11 +1041,11 @@ "id": "1fb0adfe", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Recall that every expression has a value, every value has a type, and we can use the `type` function to find the type of any value.\n", + "Recuerda que toda expresión tiene un valor, todo valor tiene un tipo, y podemos usar la función `type` para encontrar el tipo de cualquier valor.\n", "\n", - "What is the type of the value of the following expressions? Make your best guess for each one, and then use `type` to find out.\n", + "¿Cuál es el tipo del valor de las siguientes expresiones? Haz tu mejor conjetura para cada una y luego usa `type` para averiguarlo.\n", "\n", "* `765`\n", "\n", @@ -1081,22 +1069,22 @@ "id": "23762eec", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The following questions give you a chance to practice writing arithmetic expressions.\n", + "Las siguientes preguntas te dan la oportunidad de practicar escribiendo expresiones aritméticas.\n", "\n", - "1. How many seconds are there in 42 minutes 42 seconds?\n", + "1. ¿Cuántos segundos hay en 42 minutos y 42 segundos?\n", "\n", - "2. How many miles are there in 10 kilometers? Hint: there are 1.61 kilometers in a mile.\n", + "2. ¿Cuántas millas hay en 10 kilómetros? Pista: hay 1,61 kilómetros en una milla.\n", "\n", - "3. If you run a 10 kilometer race in 42 minutes 42 seconds, what is your average pace in seconds per mile? \n", + "3. Si corres una carrera de 10 kilómetros en 42 minutos y 42 segundos, ¿cuál es tu ritmo medio en segundos por milla? \n", " \n", - "4. What is your average pace in minutes and seconds per mile?\n", + "4. ¿Cuál es tu ritmo medio en minutos y segundos por milla?\n", "\n", - "5. What is your average speed in miles per hour?\n", + "5. ¿Cuál es tu velocidad media en millas por hora?\n", "\n", - "If you already know about variables, you can use them for this exercise.\n", - "If you don't, you can do the exercise without them -- and then we'll see them in the next chapter." + "Si ya sabes sobre variables, puedes usarlas para este ejercicio.\n", + "Si no, puedes hacer el ejercicio sin ellas -- y luego las veremos en el siguiente capítulo." ] }, { @@ -1170,13 +1158,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap02.ipynb b/blank/chap02.ipynb index 345e793..b988c84 100644 --- a/blank/chap02.ipynb +++ b/blank/chap02.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,12 +41,12 @@ "id": "d0286422", "metadata": {}, "source": [ - "# Variables and Statements\n", + "# Variables y sentencias\n", "\n", - "In the previous chapter, we used operators to write expressions that perform arithmetic computations.\n", + "En el capítulo anterior usamos operadores para escribir expresiones que realizan cálculos aritméticos.\n", "\n", - "In this chapter, you'll learn about variables and statements, the `import` statement, and the `print` function.\n", - "And I'll introduce more of the vocabulary we use to talk about programs, including \"argument\" and \"module\".\n" + "En este capítulo aprenderás sobre variables y sentencias, la sentencia `import` y la función `print`.\n", + "Y presentaré más vocabulario que usamos para hablar de programas, incluyendo \"argumento\" y \"módulo\".\n" ] }, { @@ -56,8 +56,8 @@ "source": [ "## Variables\n", "\n", - "A **variable** is a name that refers to a value.\n", - "To create a variable, we can write a **assignment statement** like this." + "Una **variable** es un nombre que se refiere a un valor.\n", + "Para crear una variable, podemos escribir una **sentencia de asignación** como esta." ] }, { @@ -73,9 +73,9 @@ "id": "52f187f1", "metadata": {}, "source": [ - "An assignment statement has three parts: the name of the variable on the left, the equals operator, `=`, and an expression on the right.\n", - "In this example, the expression is an integer.\n", - "In the following example, the expression is a floating-point number." + "Una sentencia de asignación tiene tres partes: el nombre de la variable a la izquierda, el operador igual, `=`, y una expresión a la derecha.\n", + "En este ejemplo, la expresión es un entero.\n", + "En el siguiente ejemplo, la expresión es un número de punto flotante." ] }, { @@ -91,7 +91,7 @@ "id": "3e27e65c", "metadata": {}, "source": [ - "And in the following example, the expression is a string." + "Y en el siguiente ejemplo, la expresión es un string." ] }, { @@ -107,10 +107,10 @@ "id": "cb5916ea", "metadata": {}, "source": [ - "When you run an assignment statement, there is no output.\n", - "Python creates the variable and gives it a value, but the assignment statement has no visible effect.\n", - "However, after creating a variable, you can use it as an expression.\n", - "So we can display the value of `message` like this:" + "Cuando ejecutas una sentencia de asignación, no hay salida.\n", + "Python crea la variable y le da un valor, pero la sentencia de asignación no tiene ningún efecto visible.\n", + "Sin embargo, después de crear una variable, puedes usarla como una expresión.\n", + "Así que podemos mostrar el valor de `message` así:" ] }, { @@ -126,7 +126,7 @@ "id": "e3fd81de", "metadata": {}, "source": [ - "You can also use a variable as part of an expression with arithmetic operators." + "También puedes usar una variable como parte de una expresión con operadores aritméticos." ] }, { @@ -150,7 +150,7 @@ "id": "97396e7d", "metadata": {}, "source": [ - "And you can use a variable when you call a function." + "Y puedes usar una variable cuando llamas a una función." ] }, { @@ -174,10 +174,9 @@ "id": "397d9da3", "metadata": {}, "source": [ - "## State diagrams\n", + "## Diagramas de estado\n", "\n", - "A common way to represent variables on paper is to write the name with\n", - "an arrow pointing to its value. " + "Una forma común de representar variables en papel es escribir el nombre con una flecha apuntando a su valor. " ] }, { @@ -223,8 +222,8 @@ "id": "6f40da93", "metadata": {}, "source": [ - "This kind of figure is called a **state diagram** because it shows what state each of the variables is in (think of it as the variable's state of mind).\n", - "We'll use state diagrams throughout the book to represent a model of how Python stores variables and their values." + "Este tipo de figura se llama **diagrama de estado** porque muestra en qué estado está cada una de las variables (piensa en ello como el estado mental de la variable).\n", + "Usaremos diagramas de estado a lo largo del libro para representar un modelo de cómo Python almacena variables y sus valores." ] }, { @@ -232,16 +231,15 @@ "id": "ba252c85", "metadata": {}, "source": [ - "## Variable names\n", + "## Nombres de variables\n", "\n", - "Variable names can be as long as you like. They can contain both letters and numbers, but they can't begin with a number. \n", - "It is legal to use uppercase letters, but it is conventional to use only lower case for\n", - "variable names.\n", + "Los nombres de variables pueden ser tan largos como quieras. Pueden contener letras y números, pero no pueden comenzar con un número. \n", + "Es válido usar letras mayúsculas, pero lo convencional es usar solo minúsculas para los nombres de variables.\n", "\n", - "The only punctuation that can appear in a variable name is the underscore character, `_`. It is often used in names with multiple words, such as `your_name` or `airspeed_of_unladen_swallow`.\n", + "El único signo de puntuación que puede aparecer en un nombre de variable es el carácter de guion bajo, `_`. Se usa a menudo en nombres con varias palabras, como `your_name` o `airspeed_of_unladen_swallow`.\n", "\n", - "If you give a variable an illegal name, you get a syntax error.\n", - "The name `million!` is illegal because it contains punctuation." + "Si le das a una variable un nombre no válido, obtienes un error de sintaxis.\n", + "El nombre `million!` no es válido porque contiene puntuación." ] }, { @@ -259,7 +257,7 @@ "id": "a1cefe3e", "metadata": {}, "source": [ - "`76trombones` is illegal because it starts with a number." + "`76trombones` no es válido porque empieza con un número." ] }, { @@ -277,7 +275,7 @@ "id": "94aa7e60", "metadata": {}, "source": [ - "`class` is also illegal, but it might not be obvious why." + "`class` tampoco es válido, pero puede que no sea obvio por qué." ] }, { @@ -295,10 +293,10 @@ "id": "784cfb5c", "metadata": {}, "source": [ - "It turns out that `class` is a **keyword**, which is a special word used to specify the structure of a program.\n", - "Keywords can't be used as variable names.\n", + "Resulta que `class` es una **palabra clave**, que es una palabra especial usada para especificar la estructura de un programa.\n", + "Las palabras clave no se pueden usar como nombres de variables.\n", "\n", - "Here's a complete list of Python's keywords:" + "Aquí tienes una lista completa de las palabras clave de Python:" ] }, { @@ -332,9 +330,7 @@ "id": "6f14d301", "metadata": {}, "source": [ - "You don't have to memorize this list. In most development environments,\n", - "keywords are displayed in a different color; if you try to use one as a\n", - "variable name, you'll know." + "No tienes que memorizar esta lista. En la mayoría de los entornos de desarrollo, las palabras clave se muestran en un color diferente; si intentas usar una como nombre de variable, lo sabrás." ] }, { @@ -342,10 +338,10 @@ "id": "c954a3b0", "metadata": {}, "source": [ - "## The import statement\n", + "## La sentencia import\n", "\n", - "In order to use some Python features, you have to **import** them.\n", - "For example, the following statement imports the `math` module." + "Para usar algunas características de Python, tienes que **importarlas**.\n", + "Por ejemplo, la siguiente sentencia importa el módulo `math`." ] }, { @@ -361,9 +357,9 @@ "id": "ea4f75ec", "metadata": {}, "source": [ - "A **module** is a collection of variables and functions.\n", - "The math module provides a variable called `pi` that contains the value of the mathematical constant denoted $\\pi$.\n", - "We can display its value like this." + "Un **módulo** es una colección de variables y funciones.\n", + "El módulo math proporciona una variable llamada `pi` que contiene el valor de la constante matemática denotada $\\pi$.\n", + "Podemos mostrar su valor así." ] }, { @@ -379,10 +375,10 @@ "id": "c96106e4", "metadata": {}, "source": [ - "To use a variable in a module, you have to use the **dot operator** (`.`) between the name of the module and the name of the variable.\n", + "Para usar una variable de un módulo, tienes que usar el **operador punto** (`.`) entre el nombre del módulo y el nombre de la variable.\n", "\n", - "The math module also contains functions.\n", - "For example, `sqrt` computes square roots." + "El módulo math también contiene funciones.\n", + "Por ejemplo, `sqrt` calcula raíces cuadradas." ] }, { @@ -398,7 +394,7 @@ "id": "185e94a3", "metadata": {}, "source": [ - "And `pow` raises one number to the power of a second number." + "Y `pow` eleva un número a la potencia de un segundo número." ] }, { @@ -414,8 +410,8 @@ "id": "5df25a9a", "metadata": {}, "source": [ - "At this point we've seen two ways to raise a number to a power: we can use the `math.pow` function or the exponentiation operator, `**`.\n", - "Either one is fine, but the operator is used more often than the function." + "En este punto hemos visto dos formas de elevar un número a una potencia: podemos usar la función `math.pow` o el operador de exponenciación, `**`.\n", + "Cualquiera de las dos está bien, pero el operador se usa más a menudo que la función." ] }, { @@ -423,13 +419,13 @@ "id": "6538f22b", "metadata": {}, "source": [ - "## Expressions and statements\n", + "## Expresiones y sentencias\n", "\n", - "So far, we've seen a few kinds of expressions.\n", - "An expression can be a single value, like an integer, floating-point number, or string.\n", - "It can also be a collection of values and operators.\n", - "And it can include variable names and function calls.\n", - "Here's an expression that includes several of these elements." + "Hasta ahora hemos visto algunos tipos de expresiones.\n", + "Una expresión puede ser un solo valor, como un entero, un número de punto flotante o un string.\n", + "También puede ser una colección de valores y operadores.\n", + "Y puede incluir nombres de variables y llamadas a funciones.\n", + "Aquí hay una expresión que incluye varios de estos elementos." ] }, { @@ -445,9 +441,9 @@ "id": "000dd2ba", "metadata": {}, "source": [ - "We have also seen a few kind of statements.\n", - "A **statement** is a unit of code that has an effect, but no value.\n", - "For example, an assignment statement creates a variable and gives it a value, but the statement itself has no value." + "También hemos visto algunos tipos de sentencias.\n", + "Una **sentencia** es una unidad de código que tiene un efecto, pero no un valor.\n", + "Por ejemplo, una sentencia de asignación crea una variable y le da un valor, pero la sentencia en sí no tiene valor." ] }, { @@ -463,7 +459,7 @@ "id": "cff0414b", "metadata": {}, "source": [ - "Similarly, an import statement has an effect -- it imports a module so we can use the variables and functions it contains -- but it has no visible effect." + "De forma similar, una sentencia import tiene un efecto -- importa un módulo para que podamos usar las variables y funciones que contiene -- pero no tiene efecto visible." ] }, { @@ -479,8 +475,8 @@ "id": "2aeb1000", "metadata": {}, "source": [ - "Computing the value of an expression is called **evaluation**.\n", - "Running a statement is called **execution**." + "Calcular el valor de una expresión se llama **evaluación**.\n", + "Ejecutar una sentencia se llama **ejecución**." ] }, { @@ -488,9 +484,9 @@ "id": "f61601e4", "metadata": {}, "source": [ - "## The print function\n", + "## La función print\n", "\n", - "When you evaluate an expression, the result is displayed." + "Cuando evalúas una expresión, se muestra el resultado." ] }, { @@ -506,7 +502,7 @@ "id": "efacf0fa", "metadata": {}, "source": [ - "But if you evaluate more than one expression, only the value of the last one is displayed." + "Pero si evalúas más de una expresión, solo se muestra el valor de la última." ] }, { @@ -522,7 +518,7 @@ "id": "cf2b991d", "metadata": {}, "source": [ - "To display more than one value, you can use the `print` function." + "Para mostrar más de un valor, puedes usar la función `print`." ] }, { @@ -538,7 +534,7 @@ "id": "29af1f89", "metadata": {}, "source": [ - "It also works with floating-point numbers and strings." + "También funciona con números de punto flotante y strings." ] }, { @@ -554,7 +550,7 @@ "id": "8b4d7f4a", "metadata": {}, "source": [ - "You can also use a sequence of expressions separated by commas." + "También puedes usar una secuencia de expresiones separadas por comas." ] }, { @@ -570,7 +566,7 @@ "id": "af447ec4", "metadata": {}, "source": [ - "Notice that the `print` function puts a space between the values." + "Observa que la función `print` coloca un espacio entre los valores." ] }, { @@ -578,12 +574,12 @@ "id": "7c73a2fa", "metadata": {}, "source": [ - "## Arguments\n", + "## Argumentos\n", "\n", - "When you call a function, the expression in parenthesis is called an **argument**.\n", - "Normally I would explain why, but in this case the technical meaning of a term has almost nothing to do with the common meaning of the word, so I won't even try.\n", + "Cuando llamas a una función, la expresión entre paréntesis se llama un **argumento**.\n", + "Normalmente explicaría por qué, pero en este caso el significado técnico de un término no tiene casi nada que ver con el significado común de la palabra, así que ni siquiera lo intentaré.\n", "\n", - "Some of the functions we've seen so far take only one argument, like `int`." + "Algunas de las funciones que hemos visto hasta ahora toman solo un argumento, como `int`." ] }, { @@ -599,7 +595,7 @@ "id": "c4ad4f2c", "metadata": {}, "source": [ - "Some take two, like `math.pow`." + "Algunas toman dos, como `math.pow`." ] }, { @@ -615,8 +611,8 @@ "id": "17293749", "metadata": {}, "source": [ - "Some can take additional arguments that are optional. \n", - "For example, `int` can take a second argument that specifies the base of the number." + "Algunas pueden tomar argumentos adicionales que son opcionales. \n", + "Por ejemplo, `int` puede tomar un segundo argumento que especifica la base del número." ] }, { @@ -632,9 +628,9 @@ "id": "c95589a1", "metadata": {}, "source": [ - "The sequence of digits `101` in base 2 represents the number 5 in base 10.\n", + "La secuencia de dígitos `101` en base 2 representa el número 5 en base 10.\n", "\n", - "`round` also takes an optional second argument, which is the number of decimal places to round off to." + "`round` también toma un segundo argumento opcional, que es el número de posiciones decimales al que redondear." ] }, { @@ -650,7 +646,7 @@ "id": "21e4a448", "metadata": {}, "source": [ - "Some functions can take any number of arguments, like `print`." + "Algunas funciones pueden tomar cualquier número de argumentos, como `print`." ] }, { @@ -666,7 +662,7 @@ "id": "667cff14", "metadata": {}, "source": [ - "If you call a function and provide too many arguments, that's a `TypeError`." + "Si llamas a una función y proporcionas demasiados argumentos, eso es un `TypeError`." ] }, { @@ -684,7 +680,7 @@ "id": "5103368e", "metadata": {}, "source": [ - "If you provide too few arguments, that's also a `TypeError`." + "Si proporcionas muy pocos argumentos, eso también es un `TypeError`." ] }, { @@ -702,7 +698,7 @@ "id": "5333c416", "metadata": {}, "source": [ - "And if you provide an argument with a type the function can't handle, that's a `TypeError`, too." + "Y si proporcionas un argumento con un tipo que la función no puede manejar, eso también es un `TypeError`." ] }, { @@ -720,7 +716,7 @@ "id": "548828af", "metadata": {}, "source": [ - "This kind of checking can be annoying when you are getting started, but it helps you detect and correct errors." + "Este tipo de comprobación puede ser molesto cuando estás empezando, pero te ayuda a detectar y corregir errores." ] }, { @@ -728,13 +724,13 @@ "id": "be2b6a9b", "metadata": {}, "source": [ - "## Comments\n", + "## Comentarios\n", "\n", - "As programs get bigger and more complicated, they get more difficult to read.\n", - "Formal languages are dense, and it is often difficult to look at a piece of code and figure out what it is doing and why.\n", + "A medida que los programas se hacen más grandes y complicados, se vuelven más difíciles de leer.\n", + "Los lenguajes formales son densos, y a menudo es difícil mirar un fragmento de código y averiguar qué hace y por qué.\n", "\n", - "For this reason, it is a good idea to add notes to your programs to explain in natural language what the program is doing. \n", - "These notes are called **comments**, and they start with the `#` symbol." + "Por esta razón, es buena idea añadir notas a tus programas para explicar en lenguaje natural qué está haciendo el programa. \n", + "Estas notas se llaman **comentarios**, y empiezan con el símbolo `#`." ] }, { @@ -750,8 +746,7 @@ "id": "519c83a9", "metadata": {}, "source": [ - "In this case, the comment appears on a line by itself. You can also put\n", - "comments at the end of a line:" + "En este caso, el comentario aparece en una línea por sí solo. También puedes poner comentarios al final de una línea:" ] }, { @@ -767,13 +762,12 @@ "id": "87c8d10c", "metadata": {}, "source": [ - "Everything from the `#` to the end of the line is ignored---it has no\n", - "effect on the execution of the program.\n", + "Todo desde el `#` hasta el final de la línea se ignora---no tiene efecto en la ejecución del programa.\n", "\n", - "Comments are most useful when they document non-obvious features of the code.\n", - "It is reasonable to assume that the reader can figure out *what* the code does; it is more useful to explain *why*.\n", + "Los comentarios son más útiles cuando documentan características no obvias del código.\n", + "Es razonable suponer que el lector puede averiguar *qué* hace el código; es más útil explicar *por qué*.\n", "\n", - "This comment is redundant with the code and useless:" + "Este comentario es redundante con el código y no sirve:" ] }, { @@ -789,7 +783,7 @@ "id": "eb83b14a", "metadata": {}, "source": [ - "This comment contains useful information that is not in the code:" + "Este comentario contiene información útil que no está en el código:" ] }, { @@ -805,8 +799,7 @@ "id": "6cd60d4f", "metadata": {}, "source": [ - "Good variable names can reduce the need for comments, but long names can\n", - "make complex expressions hard to read, so there is a tradeoff." + "Los buenos nombres de variables pueden reducir la necesidad de comentarios, pero los nombres largos pueden hacer que las expresiones complejas sean difíciles de leer, así que hay una compensación." ] }, { @@ -816,14 +809,14 @@ "source": [ "## Debugging\n", "\n", - "Three kinds of errors can occur in a program: syntax errors, runtime errors, and semantic errors.\n", - "It is useful to distinguish between them in order to track them down more quickly.\n", + "En un programa pueden ocurrir tres tipos de errores: errores de sintaxis, errores en tiempo de ejecución y errores semánticos.\n", + "Es útil distinguirlos para localizarlos más rápidamente.\n", "\n", - "* **Syntax error**: \"Syntax\" refers to the structure of a program and the rules about that structure. If there is a syntax error anywhere in your program, Python does not run the program. It displays an error message immediately.\n", + "* **Error de sintaxis**: \"Sintaxis\" se refiere a la estructura de un programa y a las reglas sobre esa estructura. Si hay un error de sintaxis en cualquier parte de tu programa, Python no ejecuta el programa. Muestra un mensaje de error inmediatamente.\n", "\n", - "* **Runtime error**: If there are no syntax errors in your program, it can start running. But if something goes wrong, Python displays an error message and stops. This type of error is called a runtime error. It is also called an **exception** because it indicates that something exceptional has happened.\n", + "* **Error en tiempo de ejecución**: Si no hay errores de sintaxis en tu programa, puede empezar a ejecutarse. Pero si algo sale mal, Python muestra un mensaje de error y se detiene. Este tipo de error se llama error en tiempo de ejecución. También se llama una **excepción** porque indica que ha ocurrido algo excepcional.\n", "\n", - "* **Semantic error**: The third type of error is \"semantic\", which means related to meaning. If there is a semantic error in your program, it runs without generating error messages, but it does not do what you intended. Identifying semantic errors can be tricky because it requires you to work backward by looking at the output of the program and trying to figure out what it is doing." + "* **Error semántico**: El tercer tipo de error es \"semántico\", lo que significa relacionado con el significado. Si hay un error semántico en tu programa, se ejecuta sin generar mensajes de error, pero no hace lo que pretendías. Identificar errores semánticos puede ser complicado porque requiere que trabajes hacia atrás mirando la salida del programa e intentando averiguar qué está haciendo." ] }, { @@ -831,7 +824,7 @@ "id": "6cd52721", "metadata": {}, "source": [ - "As we've seen, an illegal variable name is a syntax error." + "Como hemos visto, un nombre de variable no válido es un error de sintaxis." ] }, { @@ -849,7 +842,7 @@ "id": "b8971d33", "metadata": {}, "source": [ - "If you use an operator with a type it doesn't support, that's a runtime error. " + "Si usas un operador con un tipo que no admite, eso es un error en tiempo de ejecución. " ] }, { @@ -867,8 +860,8 @@ "id": "e51fa6e2", "metadata": {}, "source": [ - "Finally, here's an example of a semantic error.\n", - "Suppose we want to compute the average of `1` and `3`, but we forget about the order of operations and write this:" + "Por último, aquí tienes un ejemplo de error semántico.\n", + "Supongamos que queremos calcular la media de `1` y `3`, pero olvidamos el orden de operaciones y escribimos esto:" ] }, { @@ -884,9 +877,9 @@ "id": "0828afc0", "metadata": {}, "source": [ - "When this expression is evaluated, it does not produce an error message, so there is no syntax error or runtime error.\n", - "But the result is not the average of `1` and `3`, so the program is not correct.\n", - "This is a semantic error because the program runs but it doesn't do what's intended." + "Cuando se evalúa esta expresión, no produce un mensaje de error, así que no hay error de sintaxis ni error en tiempo de ejecución.\n", + "Pero el resultado no es la media de `1` y `3`, así que el programa no es correcto.\n", + "Este es un error semántico porque el programa se ejecuta pero no hace lo que se pretendía." ] }, { @@ -894,52 +887,52 @@ "id": "07396f3d", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", "**variable:**\n", - "A name that refers to a value.\n", + "Un nombre que se refiere a un valor.\n", "\n", - "**assignment statement:**\n", - "A statement that assigns a value to a variable.\n", + "**sentencia de asignación:**\n", + "Una sentencia que asigna un valor a una variable.\n", "\n", - "**state diagram:**\n", - "A graphical representation of a set of variables and the values they refer to.\n", + "**diagrama de estado:**\n", + "Una representación gráfica de un conjunto de variables y los valores a los que se refieren.\n", "\n", - "**keyword:**\n", - "A special word used to specify the structure of a program.\n", + "**palabra clave:**\n", + "Una palabra especial usada para especificar la estructura de un programa.\n", "\n", - "**import statement:**\n", - "A statement that reads a module file so we can use the variables and functions it contains.\n", + "**sentencia de importación:**\n", + "Una sentencia que lee un archivo de módulo para que podamos usar las variables y funciones que contiene.\n", "\n", - "**module:**\n", - "A file that contains Python code, including function definitions and sometimes other statements.\n", + "**módulo:**\n", + "Un archivo que contiene código Python, incluyendo definiciones de funciones y a veces otras sentencias.\n", "\n", - "**dot operator:**\n", - "The operator, `.`, used to access a function in another module by specifying the module name followed by a dot and the function name.\n", + "**operador punto:**\n", + "El operador, `.`, usado para acceder a una función en otro módulo especificando el nombre del módulo seguido de un punto y el nombre de la función.\n", "\n", - "**evaluate:**\n", - "Perform the operations in an expression in order to compute a value.\n", + "**evaluar:**\n", + "Realizar las operaciones de una expresión para calcular un valor.\n", "\n", - "**statement:**\n", - "One or more lines of code that represent a command or action.\n", + "**sentencia:**\n", + "Una o más líneas de código que representan una orden o acción.\n", "\n", - "**execute:**\n", - "Run a statement and do what it says.\n", + "**ejecutar:**\n", + "Ejecutar una sentencia y hacer lo que dice.\n", "\n", - "**argument:**\n", - "A value provided to a function when the function is called.\n", + "**argumento:**\n", + "Un valor proporcionado a una función cuando se llama a la función.\n", "\n", - "**comment:**\n", - "Text included in a program that provides information about the program but has no effect on its execution.\n", + "**comentario:**\n", + "Texto incluido en un programa que proporciona información sobre el programa pero no tiene efecto en su ejecución.\n", "\n", - "**runtime error:**\n", - "An error that causes a program to display an error message and exit.\n", + "**error en tiempo de ejecución:**\n", + "Un error que hace que un programa muestre un mensaje de error y termine.\n", "\n", - "**exception:**\n", - "An error that is detected while the program is running.\n", + "**excepción:**\n", + "Un error que se detecta mientras el programa se está ejecutando.\n", "\n", - "**semantic error:**\n", - "An error that causes a program to do the wrong thing, but not to display an error message." + "**error semántico:**\n", + "Un error que hace que un programa haga algo incorrecto, pero no muestre un mensaje de error." ] }, { @@ -947,7 +940,7 @@ "id": "70ee273d", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -970,20 +963,20 @@ "id": "7256a9b2", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregúntale a un asistente virtual\n", "\n", - "Again, I encourage you to use a virtual assistant to learn more about any of the topics in this chapter.\n", + "De nuevo, te animo a usar un asistente virtual para aprender más sobre cualquiera de los temas de este capítulo.\n", "\n", - "If you are curious about any of keywords I listed, you could ask \"Why is class a keyword?\" or \"Why can't variable names be keywords?\"\n", + "Si tienes curiosidad por alguna de las palabras clave que enumeré, podrías preguntar \"¿Por qué class es una palabra clave?\" o \"¿Por qué los nombres de variables no pueden ser palabras clave?\"\n", "\n", - "You might have noticed that `int`, `float`, and `str` are not Python keywords.\n", - "They are variables that represent types, and they can be used as functions.\n", - "So it is *legal* to have a variable or function with one of those names, but it is strongly discouraged. Ask an assistant \"Why is it bad to use int, float, and str as variable names?\"\n", + "Quizá hayas notado que `int`, `float` y `str` no son palabras clave de Python.\n", + "Son variables que representan tipos, y se pueden usar como funciones.\n", + "Así que es *legal* tener una variable o función con uno de esos nombres, pero se desaconseja firmemente. Pregunta a un asistente: \"¿Por qué es mala idea usar int, float y str como nombres de variables?\"\n", "\n", - "Also ask, \"What are the built-in functions in Python?\"\n", - "If you are curious about any of them, ask for more information.\n", + "Pregunta también: \"¿Cuáles son las funciones incorporadas de Python?\"\n", + "Si tienes curiosidad por alguna de ellas, pide más información.\n", "\n", - "In this chapter we imported the `math` module and used some of the variable and functions it provides. Ask an assistant, \"What variables and functions are in the math module?\" and \"Other than math, what modules are considered core Python?\"" + "En este capítulo importamos el módulo `math` y usamos algunas de las variables y funciones que proporciona. Pregunta a un asistente: \"¿Qué variables y funciones hay en el módulo math?\" y \"Además de math, ¿qué módulos se consideran parte del núcleo de Python?\"" ] }, { @@ -991,20 +984,19 @@ "id": "f92afde0", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Repeating my advice from the previous chapter, whenever you learn a new feature, you should make errors on purpose to see what goes wrong.\n", + "Repitiendo mi consejo del capítulo anterior: siempre que aprendas una característica nueva, deberías cometer errores a propósito para ver qué falla.\n", "\n", - "- We've seen that `n = 17` is legal. What about `17 = n`?\n", + "- Hemos visto que `n = 17` es válido. ¿Qué pasa con `17 = n`?\n", "\n", - "- How about `x = y = 1`?\n", + "- ¿Y con `x = y = 1`?\n", "\n", - "- In some languages every statement ends with a semi-colon (`;`). What\n", - " happens if you put a semi-colon at the end of a Python statement?\n", + "- En algunos lenguajes, cada sentencia termina con punto y coma (`;`). ¿Qué ocurre si pones un punto y coma al final de una sentencia de Python?\n", "\n", - "- What if you put a period at the end of a statement?\n", + "- ¿Qué pasa si pones un punto al final de una sentencia?\n", "\n", - "- What happens if you spell the name of a module wrong and try to import `maath`?" + "- ¿Qué ocurre si escribes mal el nombre de un módulo e intentas importar `maath`?" ] }, { @@ -1012,11 +1004,11 @@ "id": "9d562609", "metadata": {}, "source": [ - "### Exercise\n", - "Practice using the Python interpreter as a calculator:\n", + "### Ejercicio\n", + "Practica usando el intérprete de Python como calculadora:\n", "\n", - "**Part 1.** The volume of a sphere with radius $r$ is $\\frac{4}{3} \\pi r^3$.\n", - "What is the volume of a sphere with radius 5? Start with a variable named `radius` and then assign the result to a variable named `volume`. Display the result. Add comments to indicate that `radius` is in centimeters and `volume` in cubic centimeters." + "**Parte 1.** El volumen de una esfera con radio $r$ es $\\frac{4}{3} \\pi r^3$.\n", + "¿Cuál es el volumen de una esfera con radio 5? Empieza con una variable llamada `radius` y luego asigna el resultado a una variable llamada `volume`. Muestra el resultado. Añade comentarios para indicar que `radius` está en centímetros y `volume` en centímetros cúbicos." ] }, { @@ -1032,12 +1024,12 @@ "id": "6449b12b", "metadata": {}, "source": [ - "**Part 2.** A rule of trigonometry says that for any value of $x$, $(\\cos x)^2 + (\\sin x)^2 = 1$. Let's see if it's true for a specific value of $x$ like 42.\n", + "**Parte 2.** Una regla de trigonometría dice que para cualquier valor de $x$, $(\\cos x)^2 + (\\sin x)^2 = 1$. Veamos si es cierta para un valor específico de $x$, como 42.\n", "\n", - "Create a variable named `x` with this value.\n", - "Then use `math.cos` and `math.sin` to compute the sine and cosine of $x$, and the sum of their squared.\n", + "Crea una variable llamada `x` con este valor.\n", + "Luego usa `math.cos` y `math.sin` para calcular el seno y el coseno de $x$, y la suma de sus cuadrados.\n", "\n", - "The result should be close to 1. It might not be exactly 1 because floating-point arithmetic is not exact---it is only approximately correct." + "El resultado debería estar cerca de 1. Puede que no sea exactamente 1 porque la aritmética de punto flotante no es exacta---solo es aproximadamente correcta." ] }, { @@ -1053,16 +1045,16 @@ "id": "4986801f", "metadata": {}, "source": [ - "**Part 3.** In addition to `pi`, the other variable defined in the `math` module is `e`, which represents the base of the natural logarithm, written in math notation as $e$. If you are not familiar with this value, ask a virtual assistant \"What is `math.e`?\" Now let's compute $e^2$ three ways:\n", + "**Parte 3.** Además de `pi`, la otra variable definida en el módulo `math` es `e`, que representa la base del logaritmo natural, escrita en notación matemática como $e$. Si no conoces este valor, pregunta a un asistente virtual \"¿Qué es `math.e`?\" Ahora calculemos $e^2$ de tres formas:\n", "\n", - "* Use `math.e` and the exponentiation operator (`**`).\n", + "* Usa `math.e` y el operador de exponenciación (`**`).\n", "\n", - "* Use `math.pow` to raise `math.e` to the power `2`.\n", + "* Usa `math.pow` para elevar `math.e` a la potencia `2`.\n", "\n", - "* Use `math.exp`, which takes as an argument a value, $x$, and computes $e^x$.\n", + "* Usa `math.exp`, que toma como argumento un valor, $x$, y calcula $e^x$.\n", "\n", - "You might notice that the last result is slightly different from the other two.\n", - "See if you can find out which is correct." + "Puede que notes que el último resultado es ligeramente diferente de los otros dos.\n", + "Mira si puedes averiguar cuál es correcto." ] }, { @@ -1104,13 +1096,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap03.ipynb b/blank/chap03.ipynb index a2b6766..5dd1607 100644 --- a/blank/chap03.ipynb +++ b/blank/chap03.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,15 +41,15 @@ "id": "6bd858a8", "metadata": {}, "source": [ - "# Functions\n", + "# Funciones\n", "\n", - "In the previous chapter we used several functions provided by Python, like `int` and `float`, and a few provided by the `math` module, like `sqrt` and `pow`.\n", - "In this chapter, you will learn how to create your own functions and run them.\n", - "And we'll see how one function can call another.\n", - "As examples, we'll display lyrics from Monty Python songs.\n", - "These silly examples demonstrate an important feature -- the ability to write your own functions is the foundation of programming.\n", + "En el capítulo anterior usamos varias funciones proporcionadas por Python, como `int` y `float`, y algunas proporcionadas por el módulo `math`, como `sqrt` y `pow`.\n", + "En este capítulo aprenderás a crear tus propias funciones y a ejecutarlas.\n", + "Y veremos cómo una función puede llamar a otra.\n", + "Como ejemplos, mostraremos letras de canciones de Monty Python.\n", + "Estos ejemplos absurdos demuestran una característica importante: la capacidad de escribir tus propias funciones es la base de la programación.\n", "\n", - "This chapter also introduces a new statement, the `for` loop, which is used to repeat a computation." + "Este capítulo también introduce una nueva sentencia, el bucle `for`, que se usa para repetir un cálculo." ] }, { @@ -57,9 +57,9 @@ "id": "b4ea99c5", "metadata": {}, "source": [ - "## Defining new functions\n", + "## Definir nuevas funciones\n", "\n", - "A **function definition** specifies the name of a new function and the sequence of statements that run when the function is called. Here's an example:" + "Una **definición de función** especifica el nombre de una nueva función y la secuencia de sentencias que se ejecutan cuando se llama a la función. Aquí tienes un ejemplo:" ] }, { @@ -75,17 +75,17 @@ "id": "0174fc41", "metadata": {}, "source": [ - "`def` is a keyword that indicates that this is a function definition.\n", - "The name of the function is `print_lyrics`.\n", - "Anything that's a legal variable name is also a legal function name.\n", + "`def` es una palabra clave que indica que esto es una definición de función.\n", + "El nombre de la función es `print_lyrics`.\n", + "Cualquier cosa que sea un nombre de variable válido también es un nombre de función válido.\n", "\n", - "The empty parentheses after the name indicate that this function doesn't take any arguments.\n", + "Los paréntesis vacíos después del nombre indican que esta función no recibe argumentos.\n", "\n", - "The first line of the function definition is called the **header** -- the rest is called the **body**.\n", - "The header has to end with a colon and the body has to be indented. By convention, indentation is always four spaces. \n", - "The body of this function is two print statements; in general, the body of a function can contain any number of statements of any kind.\n", + "La primera línea de la definición de función se llama **encabezado**; el resto se llama **cuerpo**.\n", + "El encabezado tiene que terminar con dos puntos y el cuerpo tiene que estar indentado. Por convención, la indentación es siempre de cuatro espacios. \n", + "El cuerpo de esta función son dos sentencias `print`; en general, el cuerpo de una función puede contener cualquier número de sentencias de cualquier tipo.\n", "\n", - "Defining a function creates a **function object**, which we can display like this." + "Definir una función crea un **objeto función**, que podemos mostrar así." ] }, { @@ -101,10 +101,10 @@ "id": "12bd0879", "metadata": {}, "source": [ - "The output indicates that `print_lyrics` is a function that takes no arguments.\n", - "`__main__` is the name of the module that contains `print_lyrics`.\n", + "La salida indica que `print_lyrics` es una función que no recibe argumentos.\n", + "`__main__` es el nombre del módulo que contiene `print_lyrics`.\n", "\n", - "Now that we've defined a function, we can call it the same way we call built-in functions." + "Ahora que hemos definido una función, podemos llamarla del mismo modo que llamamos a las funciones incorporadas." ] }, { @@ -120,7 +120,7 @@ "id": "8f0fc45d", "metadata": {}, "source": [ - "When the function runs, it executes the statements in the body, which display the first two lines of \"The Lumberjack Song\"." + "Cuando la función se ejecuta, ejecuta las sentencias del cuerpo, que muestran las dos primeras líneas de \"The Lumberjack Song\"." ] }, { @@ -128,12 +128,12 @@ "id": "6d35193e", "metadata": {}, "source": [ - "## Parameters\n", + "## Parámetros\n", "\n", - "Some of the functions we have seen require arguments; for example, when you call `abs` you pass a number as an argument.\n", - "Some functions take more than one argument; for example, `math.pow` takes two, the base and the exponent.\n", + "Algunas de las funciones que hemos visto requieren argumentos; por ejemplo, cuando llamas a `abs` pasas un número como argumento.\n", + "Algunas funciones reciben más de un argumento; por ejemplo, `math.pow` recibe dos: la base y el exponente.\n", "\n", - "Here is a definition for a function that takes an argument." + "Aquí tienes la definición de una función que recibe un argumento." ] }, { @@ -149,9 +149,9 @@ "id": "1716e3dc", "metadata": {}, "source": [ - "The variable name in parentheses is a **parameter**.\n", - "When the function is called, the value of the argument is assigned to the parameter.\n", - "For example, we can call `print_twice` like this." + "El nombre de variable entre paréntesis es un **parámetro**.\n", + "Cuando se llama a la función, el valor del argumento se asigna al parámetro.\n", + "Por ejemplo, podemos llamar a `print_twice` así." ] }, { @@ -167,7 +167,7 @@ "id": "f02be6d2", "metadata": {}, "source": [ - "Running this function has the same effect as assigning the argument to the parameter and then executing the body of the function, like this." + "Ejecutar esta función tiene el mismo efecto que asignar el argumento al parámetro y luego ejecutar el cuerpo de la función, así." ] }, { @@ -183,7 +183,7 @@ "id": "ea8b8b6e", "metadata": {}, "source": [ - "You can also use a variable as an argument." + "También puedes usar una variable como argumento." ] }, { @@ -199,7 +199,7 @@ "id": "5c1884ad", "metadata": {}, "source": [ - "In this example, the value of `line` gets assigned to the parameter `string`." + "En este ejemplo, el valor de `line` se asigna al parámetro `string`." ] }, { @@ -207,10 +207,10 @@ "id": "a3e5a790", "metadata": {}, "source": [ - "## Calling functions\n", + "## Llamar funciones\n", "\n", - "Once you have defined a function, you can use it inside another function.\n", - "To demonstrate, we'll write functions that print the lyrics of \"The Spam Song\" ().\n", + "Una vez que has definido una función, puedes usarla dentro de otra función.\n", + "Para demostrarlo, escribiremos funciones que imprimen la letra de \"The Spam Song\" ().\n", "\n", "> Spam, Spam, Spam, Spam, \n", "> Spam, Spam, Spam, Spam, \n", @@ -218,7 +218,7 @@ "> (Lovely Spam, Wonderful Spam!) \n", "> Spam, Spam,\n", "\n", - "We'll start with the following function, which takes two parameters.\n" + "Empezaremos con la siguiente función, que recibe dos parámetros.\n" ] }, { @@ -234,7 +234,7 @@ "id": "bdd4daa4", "metadata": {}, "source": [ - "We can use this function to print the first line of the song, like this." + "Podemos usar esta función para imprimir la primera línea de la canción, así." ] }, { @@ -250,7 +250,7 @@ "id": "c6f81e09", "metadata": {}, "source": [ - "To display the first two lines, we can define a new function that uses `repeat`." + "Para mostrar las dos primeras líneas, podemos definir una nueva función que use `repeat`." ] }, { @@ -266,7 +266,7 @@ "id": "8058ffe4", "metadata": {}, "source": [ - "And then call it like this." + "Y luego llamarla así." ] }, { @@ -282,7 +282,7 @@ "id": "07ca432a", "metadata": {}, "source": [ - "To display the last three lines, we can define another function, which also uses `repeat`." + "Para mostrar las últimas tres líneas, podemos definir otra función, que también usa `repeat`." ] }, { @@ -306,7 +306,7 @@ "id": "d6456a19", "metadata": {}, "source": [ - "Finally, we can bring it all together with one function that prints the whole verse." + "Por último, podemos unirlo todo con una función que imprime la estrofa completa." ] }, { @@ -330,10 +330,10 @@ "id": "d088fe68", "metadata": {}, "source": [ - "When we run `print_verse`, it calls `first_two_lines`, which calls `repeat`, which calls `print`.\n", - "That's a lot of functions.\n", + "Cuando ejecutamos `print_verse`, llama a `first_two_lines`, que llama a `repeat`, que llama a `print`.\n", + "Son muchas funciones.\n", "\n", - "Of course, we could have done the same thing with fewer functions, but the point of this example is to show how functions can work together." + "Por supuesto, podríamos haber hecho lo mismo con menos funciones, pero el objetivo de este ejemplo es mostrar cómo las funciones pueden trabajar juntas." ] }, { @@ -341,10 +341,10 @@ "id": "c3b16e3f", "metadata": {}, "source": [ - "## Repetition\n", + "## Repetición\n", "\n", - "If we want to display more than one verse, we can use a `for` statement.\n", - "Here's a simple example." + "Si queremos mostrar más de una estrofa, podemos usar una sentencia `for`.\n", + "Aquí tienes un ejemplo sencillo." ] }, { @@ -360,20 +360,20 @@ "id": "bf320549", "metadata": {}, "source": [ - "The first line is a header that ends with a colon.\n", - "The second line is the body, which has to be indented.\n", + "La primera línea es un encabezado que termina con dos puntos.\n", + "La segunda línea es el cuerpo, que tiene que estar indentado.\n", "\n", - "The header starts with the keyword `for`, a new variable named `i`, and another keyword, `in`. \n", - "It uses the `range` function to create a sequence of two values, which are `0` and `1`.\n", - "In Python, when we start counting, we usually start from `0`.\n", + "El encabezado empieza con la palabra clave `for`, una nueva variable llamada `i` y otra palabra clave, `in`. \n", + "Usa la función `range` para crear una secuencia de dos valores, que son `0` y `1`.\n", + "En Python, cuando empezamos a contar, normalmente empezamos desde `0`.\n", "\n", - "When the `for` statement runs, it assigns the first value from `range` to `i` and then runs the `print` function in the body, which displays `0`.\n", + "Cuando la sentencia `for` se ejecuta, asigna el primer valor de `range` a `i` y luego ejecuta la función `print` en el cuerpo, que muestra `0`.\n", "\n", - "When it gets to the end of the body, it loops back around to the header, which is why this statement is called a **loop**.\n", - "The second time through the loop, it assigns the next value from `range` to `i`, and displays it.\n", - "Then, because that's the last value from `range`, the loop ends.\n", + "Cuando llega al final del cuerpo, vuelve al encabezado, por eso esta sentencia se llama **bucle**.\n", + "La segunda vez que recorre el bucle, asigna el siguiente valor de `range` a `i` y lo muestra.\n", + "Entonces, como ese es el último valor de `range`, el bucle termina.\n", "\n", - "Here's how we can use a `for` loop to print two verses of the song." + "Así es como podemos usar un bucle `for` para imprimir dos estrofas de la canción." ] }, { @@ -389,8 +389,8 @@ "id": "88a46733", "metadata": {}, "source": [ - "You can put a `for` loop inside a function.\n", - "For example, `print_n_verses` takes a parameter named `n`, which has to be an integer, and displays the given number of verses. " + "Puedes poner un bucle `for` dentro de una función.\n", + "Por ejemplo, `print_n_verses` recibe un parámetro llamado `n`, que tiene que ser un entero, y muestra el número dado de estrofas. " ] }, { @@ -406,7 +406,7 @@ "id": "ad8060fe", "metadata": {}, "source": [ - "In this example, we don't use `i` in the body of the loop, but there has to be a variable name in the header anyway." + "En este ejemplo, no usamos `i` en el cuerpo del bucle, pero de todos modos tiene que haber un nombre de variable en el encabezado." ] }, { @@ -414,11 +414,11 @@ "id": "b320ec90", "metadata": {}, "source": [ - "## Variables and parameters are local\n", + "## Las variables y los parámetros son locales\n", "\n", - "When you create a variable inside a function, it is **local**, which\n", - "means that it only exists inside the function.\n", - "For example, the following function takes two arguments, concatenates them, and prints the result twice." + "Cuando creas una variable dentro de una función, es **local**, lo que\n", + "significa que solo existe dentro de la función.\n", + "Por ejemplo, la siguiente función recibe dos argumentos, los concatena e imprime el resultado dos veces." ] }, { @@ -434,7 +434,7 @@ "id": "3a35a6d0", "metadata": {}, "source": [ - "Here's an example that uses it:" + "Aquí tienes un ejemplo que la usa:" ] }, { @@ -450,8 +450,8 @@ "id": "4ab4e008", "metadata": {}, "source": [ - "When `cat_twice` runs, it creates a local variable named `cat`, which is destroyed when the function ends.\n", - "If we try to display it, we get a `NameError`:" + "Cuando `cat_twice` se ejecuta, crea una variable local llamada `cat`, que se destruye cuando termina la función.\n", + "Si intentamos mostrarla, obtenemos un `NameError`:" ] }, { @@ -469,10 +469,10 @@ "id": "3ae36c29", "metadata": {}, "source": [ - "Outside of the function, `cat` is not defined. \n", + "Fuera de la función, `cat` no está definida. \n", "\n", - "Parameters are also local.\n", - "For example, outside `cat_twice`, there is no such thing as `part1` or `part2`." + "Los parámetros también son locales.\n", + "Por ejemplo, fuera de `cat_twice`, no existe nada llamado `part1` o `part2`." ] }, { @@ -480,15 +480,15 @@ "id": "eabac8a6", "metadata": {}, "source": [ - "## Stack diagrams\n", + "## Diagramas de pila\n", "\n", - "To keep track of which variables can be used where, it is sometimes useful to draw a **stack diagram**. \n", - "Like state diagrams, stack diagrams show the value of each variable, but they also show the function each variable belongs to.\n", + "Para llevar la cuenta de qué variables se pueden usar en cada lugar, a veces es útil dibujar un **diagrama de pila**. \n", + "Como los diagramas de estado, los diagramas de pila muestran el valor de cada variable, pero también muestran la función a la que pertenece cada variable.\n", "\n", - "Each function is represented by a **frame**.\n", - "A frame is a box with the name of a function on the outside and the parameters and local variables of the function on the inside.\n", + "Cada función se representa mediante un **marco**.\n", + "Un marco es una caja con el nombre de una función por fuera y los parámetros y variables locales de la función por dentro.\n", "\n", - "Here's the stack diagram for the previous example." + "Aquí tienes el diagrama de pila del ejemplo anterior." ] }, { @@ -543,12 +543,12 @@ "id": "854fee12", "metadata": {}, "source": [ - "The frames are arranged in a stack that indicates which function called\n", - "which, and so on. Reading from the bottom, `print` was called by `print_twice`, which was called by `cat_twice`, which was called by `__main__` -- which is a special name for the topmost frame.\n", - "When you create a variable outside of any function, it belongs to `__main__`.\n", + "Los marcos se organizan en un stack que indica qué función llamó a\n", + "cuál, y así sucesivamente. Leyendo desde abajo, `print` fue llamada por `print_twice`, que fue llamada por `cat_twice`, que fue llamada por `__main__`, que es un nombre especial para el marco superior.\n", + "Cuando creas una variable fuera de cualquier función, pertenece a `__main__`.\n", "\n", - "In the frame for `print`, the question mark indicates that we don't know the name of the parameter.\n", - "If you are curious, ask a virtual assistant, \"What are the parameters of the Python print function?\"" + "En el marco de `print`, el signo de interrogación indica que no sabemos el nombre del parámetro.\n", + "Si tienes curiosidad, pregunta a un asistente virtual: \"¿Cuáles son los parámetros de la función `print` de Python?" ] }, { @@ -558,8 +558,8 @@ "source": [ "## Tracebacks\n", "\n", - "When a runtime error occurs in a function, Python displays the name of the function that was running, the name of the function that called it, and so on, up the stack.\n", - "To see an example, I'll define a version of `print_twice` that contains an error -- it tries to print `cat`, which is a local variable in another function." + "Cuando ocurre un error en tiempo de ejecución dentro de una función, Python muestra el nombre de la función que se estaba ejecutando, el nombre de la función que la llamó, y así sucesivamente, subiendo por el stack.\n", + "Para ver un ejemplo, definiré una versión de `print_twice` que contiene un error: intenta imprimir `cat`, que es una variable local de otra función." ] }, { @@ -575,7 +575,7 @@ "id": "d7c0713b", "metadata": {}, "source": [ - "Now here's what happens when we run `cat_twice`." + "Ahora esto es lo que ocurre cuando ejecutamos `cat_twice`." ] }, { @@ -608,11 +608,11 @@ "id": "2f4defcf", "metadata": {}, "source": [ - "The error message includes a **traceback**, which shows the function that was running when the error occurred, the function that called it, and so on.\n", - "In this example, it shows that `cat_twice` called `print_twice`, and the error occurred in a `print_twice`.\n", + "El mensaje de error incluye un **traceback**, que muestra la función que se estaba ejecutando cuando ocurrió el error, la función que la llamó, y así sucesivamente.\n", + "En este ejemplo, muestra que `cat_twice` llamó a `print_twice`, y que el error ocurrió en un `print_twice`.\n", "\n", - "The order of the functions in the traceback is the same as the order of the frames in the stack diagram.\n", - "The function that was running is at the bottom." + "El orden de las funciones en el traceback es el mismo que el orden de los marcos en el diagrama de pila.\n", + "La función que se estaba ejecutando está abajo del todo." ] }, { @@ -620,23 +620,23 @@ "id": "374b4696", "metadata": {}, "source": [ - "## Why functions?\n", + "## ¿Por qué funciones?\n", "\n", - "It may not be clear yet why it is worth the trouble to divide a program into\n", - "functions.\n", - "There are several reasons:\n", + "Puede que todavía no esté claro por qué merece la pena dividir un programa en\n", + "funciones.\n", + "Hay varias razones:\n", "\n", - "- Creating a new function gives you an opportunity to name a group of\n", - " statements, which makes your program easier to read and debug.\n", + "- Crear una nueva función te da la oportunidad de nombrar un grupo de\n", + " sentencias, lo que hace que tu programa sea más fácil de leer y depurar.\n", "\n", - "- Functions can make a program smaller by eliminating repetitive code.\n", - " Later, if you make a change, you only have to make it in one place.\n", + "- Las funciones pueden hacer que un programa sea más pequeño al eliminar código repetitivo.\n", + " Más adelante, si haces un cambio, solo tienes que hacerlo en un lugar.\n", "\n", - "- Dividing a long program into functions allows you to debug the parts\n", - " one at a time and then assemble them into a working whole.\n", + "- Dividir un programa largo en funciones te permite depurar las partes\n", + " de una en una y luego ensamblarlas en un todo que funciona.\n", "\n", - "- Well-designed functions are often useful for many programs. Once you\n", - " write and debug one, you can reuse it." + "- Las funciones bien diseñadas suelen ser útiles para muchos programas. Una vez que\n", + " escribes y depuras una, puedes reutilizarla." ] }, { @@ -644,25 +644,25 @@ "id": "c6dd486e", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Debugging can be frustrating, but it is also challenging, interesting, and sometimes even fun.\n", - "And it is one of the most important skills you can learn.\n", + "Depurar puede ser frustrante, pero también es desafiante, interesante y a veces incluso divertido.\n", + "Y es una de las habilidades más importantes que puedes aprender.\n", "\n", - "In some ways debugging is like detective work.\n", - "You are given clues and you have to infer the events that led to the\n", - "results you see.\n", + "En cierto modo, depurar es como hacer trabajo de detective.\n", + "Se te dan pistas y tienes que inferir los eventos que llevaron a los\n", + "resultados que ves.\n", "\n", - "Debugging is also like experimental science.\n", - "Once you have an idea about what is going wrong, you modify your program and try again.\n", - "If your hypothesis was correct, you can predict the result of the modification, and you take a step closer to a working program.\n", - "If your hypothesis was wrong, you have to come up with a new one.\n", + "Depurar también se parece a la ciencia experimental.\n", + "Una vez que tienes una idea de qué va mal, modificas tu programa y vuelves a intentarlo.\n", + "Si tu hipótesis era correcta, puedes predecir el resultado de la modificación, y das un paso más hacia un programa que funciona.\n", + "Si tu hipótesis era incorrecta, tienes que proponer una nueva.\n", "\n", - "For some people, programming and debugging are the same thing; that is, programming is the process of gradually debugging a program until it does what you want.\n", - "The idea is that you should start with a working program and make small modifications, debugging them as you go.\n", + "Para algunas personas, programar y depurar son lo mismo; es decir, programar es el proceso de depurar gradualmente un programa hasta que hace lo que quieres.\n", + "La idea es que deberías empezar con un programa que funciona y hacer pequeñas modificaciones, depurándolas sobre la marcha.\n", "\n", - "If you find yourself spending a lot of time debugging, that is often a sign that you are writing too much code before you start tests.\n", - "If you take smaller steps, you might find that you can move faster." + "Si te encuentras pasando mucho tiempo depurando, a menudo es una señal de que estás escribiendo demasiado código antes de empezar a hacer pruebas.\n", + "Si das pasos más pequeños, puede que descubras que puedes avanzar más rápido." ] }, { @@ -670,39 +670,39 @@ "id": "d4e95e63", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**function definition:**\n", - "A statement that creates a function.\n", + "**definición de función:**\n", + "Una sentencia que crea una función.\n", "\n", - "**header:**\n", - " The first line of a function definition.\n", + "**encabezado:**\n", + " La primera línea de una definición de función.\n", "\n", - "**body:**\n", - " The sequence of statements inside a function definition.\n", + "**cuerpo:**\n", + " La secuencia de sentencias dentro de una definición de función.\n", "\n", - "**function object:**\n", - "A value created by a function definition.\n", - "The name of the function is a variable that refers to a function object.\n", + "**objeto de función:**\n", + "Un valor creado por una definición de función.\n", + "El nombre de la función es una variable que se refiere a un objeto función.\n", "\n", - "**parameter:**\n", - " A name used inside a function to refer to the value passed as an argument.\n", + "**parámetro:**\n", + " Un nombre usado dentro de una función para referirse al valor pasado como argumento.\n", "\n", - "**loop:**\n", - " A statement that runs one or more statements, often repeatedly.\n", + "**bucle:**\n", + " Una sentencia que ejecuta una o más sentencias, a menudo repetidamente.\n", "\n", - "**local variable:**\n", - "A variable defined inside a function, and which can only be accessed inside the function.\n", + "**variable local:**\n", + "Una variable definida dentro de una función, y a la que solo se puede acceder dentro de la función.\n", "\n", - "**stack diagram:**\n", - "A graphical representation of a stack of functions, their variables, and the values they refer to.\n", + "**diagrama de pila:**\n", + "Una representación gráfica de un stack de funciones, sus variables y los valores a los que se refieren.\n", "\n", - "**frame:**\n", - " A box in a stack diagram that represents a function call.\n", - " It contains the local variables and parameters of the function.\n", + "**marco:**\n", + " Una caja en un diagrama de pila que representa una llamada a función.\n", + " Contiene las variables locales y los parámetros de la función.\n", "\n", "**traceback:**\n", - " A list of the functions that are executing, printed when an exception occurs." + " Una lista de las funciones que se están ejecutando, impresa cuando ocurre una excepción." ] }, { @@ -710,7 +710,7 @@ "id": "eca485f2", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -733,23 +733,23 @@ "id": "82951027", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "The statements in a function or a `for` loop are indented by four spaces, by convention.\n", - "But not everyone agrees with that convention.\n", - "If you are curious about the history of this great debate, ask a virtual assistant to \"tell me about spaces and tabs in Python\".\n", + "Las sentencias dentro de una función o un bucle `for` se indentan con cuatro espacios, por convención.\n", + "Pero no todo el mundo está de acuerdo con esa convención.\n", + "Si tienes curiosidad por la historia de este gran debate, pregunta a un asistente virtual que te hable sobre \"espacios y tabulaciones en Python\".\n", "\n", - "Virtual assistant are pretty good at writing small functions.\n", + "Los asistentes virtuales son bastante buenos escribiendo funciones pequeñas.\n", "\n", - "1. Ask your favorite VA to \"Write a function called repeat that takes a string and an integer and prints the string the given number of times.\" \n", + "1. Pregunta a tu asistente virtual favorito: \"Escribe una función llamada repeat que reciba un string y un entero e imprima el string el número de veces indicado\". \n", "\n", - "2. If the result uses a `for` loop, you could ask, \"Can you do it without a for loop?\"\n", + "2. Si el resultado usa un bucle `for`, podrías preguntar: \"¿Puedes hacerlo sin un bucle for?\"\n", "\n", - "3. Pick any other function in this chapter and ask a VA to write it. The challenge is to describe the function precisely enough to get what you want. Use the vocabulary you have learned so far in this book.\n", + "3. Elige cualquier otra función de este capítulo y pide a un asistente virtual que la escriba. El reto es describir la función con suficiente precisión para obtener lo que quieres. Usa el vocabulario que has aprendido hasta ahora en este libro.\n", "\n", - "Virtual assistants are also pretty good at debugging functions.\n", + "Los asistentes virtuales también son bastante buenos depurando funciones.\n", "\n", - "1. Ask a VA what's wrong with this version of `print_twice`.\n", + "1. Pregunta a un asistente virtual qué está mal en esta versión de `print_twice`.\n", "\n", " ```\n", " def print_twice(string):\n", @@ -757,7 +757,7 @@ " print(cat)\n", " ```\n", " \n", - "And if you get stuck on any of the exercises below, consider asking a VA for help." + "Y si te bloqueas en cualquiera de los ejercicios siguientes, considera pedir ayuda a un asistente virtual." ] }, { @@ -765,9 +765,9 @@ "id": "b7157b09", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function named `print_right` that takes a string named `text` as a parameter and prints the string with enough leading spaces that the last letter of the string is in the 40th column of the display." + "Escribe una función llamada `print_right` que reciba un string llamado `text` como parámetro e imprima el string con suficientes espacios iniciales para que la última letra del string esté en la columna 40 de la pantalla." ] }, { @@ -783,9 +783,9 @@ "id": "428fbee5", "metadata": {}, "source": [ - "Hint: Use the `len` function, the string concatenation operator (`+`) and the string repetition operator (`*`).\n", + "Pista: usa la función `len`, el operador de concatenación de strings (`+`) y el operador de repetición de strings (`*`).\n", "\n", - "Here's an example that shows how it should work." + "Aquí tienes un ejemplo que muestra cómo debería funcionar." ] }, { @@ -807,9 +807,9 @@ "id": "b47467fa", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `triangle` that takes a string and an integer and draws a pyramid with the given height, made up using copies of the string. Here's an example of a pyramid with `5` levels, using the string `'L'`." + "Escribe una función llamada `triangle` que reciba un string y un entero, y dibuje una pirámide con la altura dada, hecha usando copias del string. Aquí tienes un ejemplo de una pirámide con `5` niveles, usando el string `'L'`." ] }, { @@ -838,9 +838,9 @@ "id": "4a28f635", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rectangle` that takes a string and two integers and draws a rectangle with the given width and height, made up using copies of the string. Here's an example of a rectangle with width `5` and height `4`, made up of the string `'H'`." + "Escribe una función llamada `rectangle` que reciba un string y dos enteros, y dibuje un rectángulo con la anchura y altura dadas, hecho usando copias del string. Aquí tienes un ejemplo de un rectángulo con anchura `5` y altura `4`, hecho con el string `'H'`." ] }, { @@ -869,20 +869,20 @@ "id": "44a5de6f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The song \"99 Bottles of Beer\" starts with this verse:\n", + "La canción \"99 Bottles of Beer\" empieza con esta estrofa:\n", "\n", "> 99 bottles of beer on the wall \n", "> 99 bottles of beer \n", "> Take one down, pass it around \n", "> 98 bottles of beer on the wall \n", "\n", - "Then the second verse is the same, except that it starts with 98 bottles and ends with 97. The song continues -- for a very long time -- until there are 0 bottles of beer.\n", + "Luego la segunda estrofa es igual, excepto que empieza con 98 botellas y termina con 97. La canción continúa, durante muchísimo tiempo, hasta que hay 0 botellas de cerveza.\n", "\n", - "Write a function called `bottle_verse` that takes a number as a parameter and displays the verse that starts with the given number of bottles.\n", + "Escribe una función llamada `bottle_verse` que reciba un número como parámetro y muestre la estrofa que empieza con el número dado de botellas.\n", "\n", - "Hint: Consider starting with a function that can print the first, second, or last line of the verse, and then use it to write `bottle_verse`." + "Pista: considera empezar con una función que pueda imprimir la primera, segunda o última línea de la estrofa, y luego úsala para escribir `bottle_verse`." ] }, { @@ -908,7 +908,7 @@ "tags": [] }, "source": [ - "Use this function call to display the first verse." + "Usa esta llamada a función para mostrar la primera estrofa." ] }, { @@ -930,8 +930,8 @@ "tags": [] }, "source": [ - "If you want to print the whole song, you can use this `for` loop, which counts down from `99` to `1`.\n", - "You don't have to completely understand this example---we'll learn more about `for` loops and the `range` function later." + "Si quieres imprimir la canción completa, puedes usar este bucle `for`, que cuenta hacia atrás desde `99` hasta `1`.\n", + "No tienes que entender completamente este ejemplo; aprenderemos más sobre los bucles `for` y la función `range` más adelante." ] }, { @@ -963,13 +963,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap04.ipynb b/blank/chap04.ipynb index 23e5490..14369aa 100644 --- a/blank/chap04.ipynb +++ b/blank/chap04.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -35,10 +35,10 @@ "id": "fbb4d5a2", "metadata": {}, "source": [ - "# Functions and Interfaces\n", + "# Funciones e interfaces\n", "\n", - "This chapter introduces a module called `jupyturtle`, which allows you to create simple drawings by giving instructions to an imaginary turtle.\n", - "We will use this module to write functions that draw squares, polygons, and circles -- and to demonstrate **interface design**, which is a way of designing functions that work together." + "Este capítulo introduce un módulo llamado `jupyturtle`, que te permite crear dibujos sencillos dando instrucciones a una turtle imaginaria.\n", + "Usaremos este módulo para escribir funciones que dibujan cuadrados, polígonos y círculos, y para demostrar el **diseño de interfaces**, que es una forma de diseñar funciones que trabajan juntas." ] }, { @@ -48,9 +48,9 @@ "tags": [] }, "source": [ - "## The jupyturtle module\n", + "## El módulo jupyturtle\n", "\n", - "To use the `jupyturtle` module, we can import it like this." + "Para usar el módulo `jupyturtle`, podemos importarlo así." ] }, { @@ -66,7 +66,7 @@ "id": "8c801121", "metadata": {}, "source": [ - "Now we can use the functions defined in the module, like `make_turtle` and `forward`." + "Ahora podemos usar las funciones definidas en el módulo, como `make_turtle` y `forward`." ] }, { @@ -82,14 +82,14 @@ "id": "77a61cbb", "metadata": {}, "source": [ - "`make_turtle` creates a **canvas**, which is a space on the screen where we can draw, and a turtle, which is represented by a circular shell and a triangular head.\n", - "The circle shows the location of the turtle and the triangle indicates the direction it is facing.\n", + "`make_turtle` crea un **canvas**, que es un espacio en la pantalla donde podemos dibujar, y una turtle, que se representa con un caparazón circular y una cabeza triangular.\n", + "El círculo muestra la ubicación de la turtle y el triángulo indica la dirección hacia la que mira.\n", "\n", - "`forward` moves the turtle a given distance in the direction it's facing, drawing a line segment along the way.\n", - "The distance is in arbitrary units -- the actual size depends on your computer's screen.\n", + "`forward` mueve la turtle una distancia dada en la dirección hacia la que mira, dibujando un segmento de línea por el camino.\n", + "La distancia está en unidades arbitrarias: el tamaño real depende de la pantalla de tu ordenador.\n", "\n", - "We will use functions defined in the `jupyturtle` module many times, so it would be nice if we did not have to write the name of the module every time.\n", - "That's possible if we import the module like this." + "Usaremos muchas veces funciones definidas en el módulo `jupyturtle`, así que estaría bien no tener que escribir el nombre del módulo cada vez.\n", + "Eso es posible si importamos el módulo así." ] }, { @@ -105,7 +105,7 @@ "id": "c1322d31", "metadata": {}, "source": [ - "This version of the import statement imports `make_turtle` and `forward` from the `jupyturtle` module so we can call them like this." + "Esta versión de la sentencia `import` importa `make_turtle` y `forward` desde el módulo `jupyturtle`, de modo que podemos llamarlas así." ] }, { @@ -121,8 +121,8 @@ "id": "bd319754", "metadata": {}, "source": [ - "`jupyturtle` provides two other functions we'll use, called `left` and `right`.\n", - "We'll import them like this." + "`jupyturtle` proporciona otras dos funciones que usaremos, llamadas `left` y `right`.\n", + "Las importaremos así." ] }, { @@ -138,8 +138,8 @@ "id": "0da2a311", "metadata": {}, "source": [ - "`left` causes the turtle to turn left. It takes one argument, which is the angle of the turn in degrees.\n", - "For example, we can make a 90 degree left turn like this." + "`left` hace que la turtle gire a la izquierda. Recibe un argumento, que es el ángulo del giro en grados.\n", + "Por ejemplo, podemos hacer un giro a la izquierda de 90 grados así." ] }, { @@ -155,8 +155,8 @@ "id": "cea2940f", "metadata": {}, "source": [ - "This program moves the turtle east and then north, leaving two line segments behind.\n", - "Before you go on, see if you can modify the previous program to make a square." + "Este programa mueve la turtle hacia el este y luego hacia el norte, dejando dos segmentos de línea detrás.\n", + "Antes de continuar, prueba si puedes modificar el programa anterior para hacer un cuadrado." ] }, { @@ -164,9 +164,9 @@ "id": "e20ea96c", "metadata": {}, "source": [ - "## Making a square\n", + "## Hacer un cuadrado\n", "\n", - "Here's one way to make a square." + "Aquí tienes una forma de hacer un cuadrado." ] }, { @@ -182,7 +182,7 @@ "id": "a7500957", "metadata": {}, "source": [ - "Because this program repeats the same pair of lines four times, we can do the same thing more concisely with a `for` loop." + "Como este programa repite el mismo par de líneas cuatro veces, podemos hacer lo mismo de forma más concisa con un bucle `for`." ] }, { @@ -200,9 +200,9 @@ "tags": [] }, "source": [ - "## Encapsulation and generalization\n", + "## Encapsulación y generalización\n", "\n", - "Let's take the square-drawing code from the previous section and put it in a function called `square`." + "Tomemos el código para dibujar cuadrados de la sección anterior y pongámoslo en una función llamada `square`." ] }, { @@ -218,7 +218,7 @@ "id": "0789b5d9", "metadata": {}, "source": [ - "Now we can call the function like this." + "Ahora podemos llamar a la función así." ] }, { @@ -234,11 +234,11 @@ "id": "da905fc6", "metadata": {}, "source": [ - "Wrapping a piece of code up in a function is called **encapsulation**.\n", - "One of the benefits of encapsulation is that it attaches a name to the code, which serves as a kind of documentation. Another advantage is that if you re-use the code, it is more concise to call a function twice than to copy and paste the body!\n", + "Envolver un fragmento de código en una función se llama **encapsulación**.\n", + "Uno de los beneficios de la encapsulación es que le da un nombre al código, que sirve como una especie de documentación. ¡Otra ventaja es que, si reutilizas el código, es más conciso llamar a una función dos veces que copiar y pegar el cuerpo!\n", "\n", - "In the current version, the size of the square is always `50`.\n", - "If we want to draw squares with different sizes, we can take the length of the sides as a parameter. " + "En la versión actual, el tamaño del cuadrado siempre es `50`.\n", + "Si queremos dibujar cuadrados de distintos tamaños, podemos tomar la longitud de los lados como parámetro. " ] }, { @@ -254,7 +254,7 @@ "id": "397fda4b", "metadata": {}, "source": [ - "Now we can draw squares with different sizes." + "Ahora podemos dibujar cuadrados de distintos tamaños." ] }, { @@ -270,10 +270,10 @@ "id": "5a46bf64", "metadata": {}, "source": [ - "Adding a parameter to a function is called **generalization** because it makes the function more general: with the previous version, the square is always the same size; with this version it can be any size.\n", + "Añadir un parámetro a una función se llama **generalización** porque hace que la función sea más general: con la versión anterior, el cuadrado siempre tiene el mismo tamaño; con esta versión puede tener cualquier tamaño.\n", "\n", - "If we add another parameter, we can make it even more general.\n", - "The following function draws regular polygons with a given number of sides." + "Si añadimos otro parámetro, podemos hacerla aún más general.\n", + "La siguiente función dibuja polígonos regulares con un número dado de lados." ] }, { @@ -289,9 +289,9 @@ "id": "286d3c77", "metadata": {}, "source": [ - "In a regular polygon with `n` sides, the angle between adjacent sides is `360 / n` degrees. \n", + "En un polígono regular con `n` lados, el ángulo entre lados adyacentes es de `360 / n` grados. \n", "\n", - "The following example draws a `7`-sided polygon with side length `30`." + "El siguiente ejemplo dibuja un polígono de `7` lados con longitud de lado `30`." ] }, { @@ -307,8 +307,8 @@ "id": "dc0226db", "metadata": {}, "source": [ - "When a function has more than a few numeric arguments, it is easy to forget what they are, or what order they should be in. \n", - "It can be a good idea to include the names of the parameters in the argument list." + "Cuando una función tiene más de unos pocos argumentos numéricos, es fácil olvidar qué son o en qué orden deberían ir. \n", + "Puede ser una buena idea incluir los nombres de los parámetros en la lista de argumentos." ] }, { @@ -326,10 +326,10 @@ "id": "6aa28eba", "metadata": {}, "source": [ - "These are sometimes called \"named arguments\" because they include the parameter names.\n", - "But in Python they are more often called **keyword arguments** (not to be confused with Python keywords like `for` and `def`).\n", + "A veces se llaman \"argumentos con nombre\" porque incluyen los nombres de los parámetros.\n", + "Pero en Python se llaman más a menudo **argumentos de palabra clave** (no deben confundirse con las palabras clave de Python como `for` y `def`).\n", "\n", - "This use of the assignment operator, `=`, is a reminder about how arguments and parameters work -- when you call a function, the arguments are assigned to the parameters." + "Este uso del operador de asignación, `=`, sirve como recordatorio de cómo funcionan los argumentos y los parámetros: cuando llamas a una función, los argumentos se asignan a los parámetros." ] }, { @@ -337,11 +337,11 @@ "id": "b10184b4", "metadata": {}, "source": [ - "## Approximating a circle\n", + "## Aproximar un círculo\n", "\n", - "Now suppose we want to draw a circle.\n", - "We can do that, approximately, by drawing a polygon with a large number of sides, so each side is small enough that it's hard to see.\n", - "Here is a function that uses `polygon` to draw a `30`-sided polygon that approximates a circle." + "Ahora supongamos que queremos dibujar un círculo.\n", + "Podemos hacerlo, aproximadamente, dibujando un polígono con un gran número de lados, de modo que cada lado sea lo bastante pequeño como para que cueste verlo.\n", + "Aquí tienes una función que usa `polygon` para dibujar un polígono de `30` lados que aproxima un círculo." ] }, { @@ -357,13 +357,13 @@ "id": "39023314", "metadata": {}, "source": [ - "`circle` takes the radius of the the circle as a parameter.\n", - "It computes `circumference`, which is the circumference of a circle with the given radius.\n", - "`n` is the number of sides, so `circumference / n` is the length of each side.\n", + "`circle` recibe el radio del círculo como parámetro.\n", + "Calcula `circumference`, que es la circunferencia de un círculo con el radio dado.\n", + "`n` es el número de lados, así que `circumference / n` es la longitud de cada lado.\n", "\n", - "This function might take a long time to run.\n", - "We can speed it up by calling `make_turtle` with a keyword argument called `delay` that sets the time, in seconds, the turtle waits after each step.\n", - "The default value is `0.2` seconds -- if we set it to `0.02` it runs about 10 times faster." + "Esta función podría tardar mucho en ejecutarse.\n", + "Podemos acelerarla llamando a `make_turtle` con un argumento de palabra clave llamado `delay` que establece el tiempo, en segundos, que la turtle espera después de cada paso.\n", + "El valor predeterminado es `0.2` segundos; si lo establecemos en `0.02`, se ejecuta unas 10 veces más rápido." ] }, { @@ -379,11 +379,11 @@ "id": "701f9cf8", "metadata": {}, "source": [ - "A limitation of this solution is that `n` is a constant, which means\n", - "that for very big circles, the sides are too long, and for small\n", - "circles, we waste time drawing very short sides.\n", - "One option is to generalize the function by taking `n` as a parameter.\n", - "But let's keep it simple for now." + "Una limitación de esta solución es que `n` es una constante, lo que significa\n", + "que para círculos muy grandes los lados son demasiado largos, y para círculos pequeños\n", + "perdemos tiempo dibujando lados muy cortos.\n", + "Una opción es generalizar la función tomando `n` como parámetro.\n", + "Pero mantengámoslo sencillo por ahora." ] }, { @@ -391,15 +391,15 @@ "id": "c48f262c", "metadata": {}, "source": [ - "## Refactoring\n", + "## Refactorización\n", "\n", - "Now let's write a more general version of `circle`, called `arc`, that takes a second parameter, `angle`, and draws an arc of a circle that spans the given angle.\n", - "For example, if `angle` is `360` degrees, it draws a complete circle. If `angle` is `180` degrees, it draws a half circle.\n", + "Ahora escribamos una versión más general de `circle`, llamada `arc`, que recibe un segundo parámetro, `angle`, y dibuja un arco de un círculo que abarca el ángulo dado.\n", + "Por ejemplo, si `angle` es `360` grados, dibuja un círculo completo. Si `angle` es `180` grados, dibuja un semicírculo.\n", "\n", - "To write `circle`, we were able to reuse `polygon`, because a many-sided polygon is a good approximation of a circle.\n", - "But we can't use `polygon` to write `arc`.\n", + "Para escribir `circle`, pudimos reutilizar `polygon`, porque un polígono con muchos lados es una buena aproximación de un círculo.\n", + "Pero no podemos usar `polygon` para escribir `arc`.\n", "\n", - "Instead, we'll create the more general version of `polygon`, called `polyline`." + "En su lugar, crearemos una versión más general de `polygon`, llamada `polyline`." ] }, { @@ -415,9 +415,9 @@ "id": "c2b2503e", "metadata": {}, "source": [ - "`polyline` takes as parameters the number of line segments to draw, `n`, the length of the segments, `length`, and the angle between them, `angle`.\n", + "`polyline` recibe como parámetros el número de segmentos de línea que debe dibujar, `n`, la longitud de los segmentos, `length`, y el ángulo entre ellos, `angle`.\n", "\n", - "Now we can rewrite `polygon` to use `polyline`." + "Ahora podemos reescribir `polygon` para que use `polyline`." ] }, { @@ -433,7 +433,7 @@ "id": "2714a59e", "metadata": {}, "source": [ - "And we can use `polyline` to write `arc`." + "Y podemos usar `polyline` para escribir `arc`." ] }, { @@ -449,9 +449,9 @@ "id": "3c18773c", "metadata": {}, "source": [ - "`arc` is similar to `circle`, except that it computes `arc_length`, which is a fraction of the circumference of a circle.\n", + "`arc` es similar a `circle`, salvo que calcula `arc_length`, que es una fracción de la circunferencia de un círculo.\n", "\n", - "Finally, we can rewrite `circle` to use `arc`." + "Por último, podemos reescribir `circle` para que use `arc`." ] }, { @@ -467,8 +467,8 @@ "id": "313a357c", "metadata": {}, "source": [ - "To check that these functions work as expected, we'll use them to draw something like a snail.\n", - "With `delay=0`, the turtle runs as fast as possible." + "Para comprobar que estas funciones funcionan como esperamos, las usaremos para dibujar algo parecido a un caracol.\n", + "Con `delay=0`, la turtle va lo más rápido posible." ] }, { @@ -484,12 +484,12 @@ "id": "a34da3d8", "metadata": {}, "source": [ - "In this example, we started with working code and reorganized it with different functions.\n", - "Changes like this, which improve the code without changing its behavior, are called **refactoring**.\n", + "En este ejemplo, empezamos con código que funcionaba y lo reorganizamos con funciones diferentes.\n", + "Los cambios como este, que mejoran el código sin cambiar su comportamiento, se llaman **refactorización**.\n", "\n", - "If we had planned ahead, we might have written `polyline` first and avoided refactoring, but often you don't know enough at the beginning of a project to design all the functions.\n", - "Once you start coding, you understand the problem better.\n", - "Sometimes refactoring is a sign that you have learned something." + "Si lo hubiéramos planeado con antelación, quizá habríamos escrito `polyline` primero y evitado la refactorización, pero a menudo no sabes lo suficiente al principio de un proyecto para diseñar todas las funciones.\n", + "Una vez que empiezas a programar, entiendes mejor el problema.\n", + "A veces la refactorización es una señal de que has aprendido algo." ] }, { @@ -497,10 +497,10 @@ "id": "d18c9d16", "metadata": {}, "source": [ - "## Stack diagram\n", + "## Diagrama de pila\n", "\n", - "When we call `circle`, it calls `arc`, which calls `polyline`.\n", - "We can use a stack diagram to show this sequence of function calls and the parameters for each one." + "Cuando llamamos a `circle`, llama a `arc`, que llama a `polyline`.\n", + "Podemos usar un diagrama de pila para mostrar esta secuencia de llamadas a funciones y los parámetros de cada una." ] }, { @@ -528,8 +528,8 @@ "id": "3160bba1", "metadata": {}, "source": [ - "Notice that the value of `angle` in `polyline` is different from the value of `angle` in `arc`.\n", - "Parameters are local, which means you can use the same parameter name in different functions; it's a different variable in each function, and it can refer to a different value. " + "Observa que el valor de `angle` en `polyline` es diferente del valor de `angle` en `arc`.\n", + "Los parámetros son locales, lo que significa que puedes usar el mismo nombre de parámetro en funciones diferentes; es una variable distinta en cada función y puede referirse a un valor diferente. " ] }, { @@ -537,27 +537,27 @@ "id": "c23552d3", "metadata": {}, "source": [ - "## A development plan\n", + "## Un plan de desarrollo\n", "\n", - "A **development plan** is a process for writing programs.\n", - "The process we used in this chapter is \"encapsulation and generalization\".\n", - "The steps of this process are:\n", + "Un **plan de desarrollo** es un proceso para escribir programas.\n", + "El proceso que usamos en este capítulo es \"encapsulación y generalización\".\n", + "Los pasos de este proceso son:\n", "\n", - "1. Start by writing a small program with no function definitions.\n", + "1. Empieza escribiendo un programa pequeño sin definiciones de funciones.\n", "\n", - "2. Once you get the program working, identify a coherent piece of it,\n", - " encapsulate the piece in a function and give it a name.\n", + "2. Una vez que consigas que el programa funcione, identifica una parte coherente,\n", + " encapsula esa parte en una función y dale un nombre.\n", "\n", - "3. Generalize the function by adding appropriate parameters.\n", + "3. Generaliza la función añadiendo los parámetros adecuados.\n", "\n", - "4. Repeat Steps 1 to 3 until you have a set of working functions.\n", + "4. Repite los pasos 1 a 3 hasta que tengas un conjunto de funciones que funcionen.\n", "\n", - "5. Look for opportunities to improve the program by refactoring. For\n", - " example, if you have similar code in several places, consider\n", - " factoring it into an appropriately general function.\n", + "5. Busca oportunidades para mejorar el programa mediante refactorización. Por\n", + " ejemplo, si tienes código similar en varios lugares, considera\n", + " factorizarlo en una función adecuadamente general.\n", "\n", - "This process has some drawbacks -- we will see alternatives later -- but it can be useful if you don't know ahead of time how to divide the program into functions.\n", - "This approach lets you design as you go along." + "Este proceso tiene algunas desventajas (veremos alternativas más adelante), pero puede ser útil si no sabes de antemano cómo dividir el programa en funciones.\n", + "Este enfoque te permite diseñar sobre la marcha." ] }, { @@ -565,13 +565,13 @@ "id": "a3b6b83d", "metadata": {}, "source": [ - "The design of a function has two parts:\n", + "El diseño de una función tiene dos partes:\n", "\n", - "* The **interface** is how the function is used, including its name, the parameters it takes and what the function is supposed to do.\n", + "* La **interfaz** es cómo se usa la función, incluyendo su nombre, los parámetros que recibe y lo que se supone que debe hacer.\n", "\n", - "* The **implementation** is how the function does what it's supposed to do.\n", + "* La **implementación** es cómo la función hace lo que se supone que debe hacer.\n", "\n", - "For example, here's the first version of `circle` we wrote, which uses `polygon`." + "Por ejemplo, aquí tienes la primera versión de `circle` que escribimos, que usa `polygon`." ] }, { @@ -587,7 +587,7 @@ "id": "5d3d2e79", "metadata": {}, "source": [ - "And here's the refactored version that uses `arc`." + "Y aquí tienes la versión refactorizada que usa `arc`." ] }, { @@ -603,7 +603,7 @@ "id": "b726f72c", "metadata": {}, "source": [ - "These two functions have the same interface -- they take the same parameters and do the same thing -- but they have different implementations." + "Estas dos funciones tienen la misma interfaz: reciben los mismos parámetros y hacen lo mismo, pero tienen implementaciones diferentes." ] }, { @@ -615,8 +615,8 @@ "source": [ "## Docstrings\n", "\n", - "A **docstring** is a string at the beginning of a function that explains the interface (\"doc\" is short for \"documentation\").\n", - "Here is an example:" + "Un **docstring** es un string al principio de una función que explica la interfaz (\"doc\" es la abreviatura de \"documentación\").\n", + "Aquí tienes un ejemplo:" ] }, { @@ -632,18 +632,18 @@ "id": "55b60cbc", "metadata": {}, "source": [ - "By convention, docstrings are triple-quoted strings, also known as **multiline strings** because the triple quotes allow the string to span more than one line.\n", + "Por convención, los docstrings son strings entre comillas triples, también conocidos como **strings multilínea** porque las comillas triples permiten que el string ocupe más de una línea.\n", "\n", - "A docstring should:\n", + "Un docstring debería:\n", "\n", - "* Explain concisely what the function does, without getting into the details of how it works,\n", + "* Explicar de forma concisa qué hace la función, sin entrar en los detalles de cómo funciona,\n", "\n", - "* Explain what effect each parameter has on the behavior of the function, and\n", + "* Explicar qué efecto tiene cada parámetro en el comportamiento de la función, e\n", "\n", - "* Indicate what type each parameter should be, if it is not obvious.\n", + "* Indicar qué tipo debería tener cada parámetro, si no es obvio.\n", "\n", - "Writing this kind of documentation is an important part of interface design.\n", - "A well-designed interface should be simple to explain; if you have a hard time explaining one of your functions, maybe the interface could be improved." + "Escribir este tipo de documentación es una parte importante del diseño de interfaces.\n", + "Una interfaz bien diseñada debería ser sencilla de explicar; si te cuesta explicar una de tus funciones, quizá la interfaz podría mejorarse." ] }, { @@ -651,20 +651,20 @@ "id": "f1115940", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "An interface is like a contract between a function and a caller. The\n", - "caller agrees to provide certain arguments and the function agrees to\n", - "do certain work.\n", + "Una interfaz es como un contrato entre una función y quien la llama. Quien\n", + "llama acepta proporcionar ciertos argumentos y la función acepta\n", + "hacer cierto trabajo.\n", "\n", - "For example, `polyline` requires three arguments: `n` has to be an integer; `length` should be a positive number; and `angle` has to be a number, which is understood to be in degrees.\n", + "Por ejemplo, `polyline` requiere tres argumentos: `n` tiene que ser un entero; `length` debería ser un número positivo; y `angle` tiene que ser un número, que se entiende que está en grados.\n", "\n", - "These requirements are called **preconditions** because they are supposed to be true before the function starts executing. Conversely, conditions at the end of the function are **postconditions**.\n", - "Postconditions include the intended effect of the function (like drawing line segments) and any side effects (like moving the turtle or making other changes).\n", + "Estos requisitos se llaman **precondiciones** porque se supone que deben ser verdaderos antes de que la función empiece a ejecutarse. Por el contrario, las condiciones al final de la función son **postcondiciones**.\n", + "Las postcondiciones incluyen el efecto previsto de la función (como dibujar segmentos de línea) y cualquier efecto secundario (como mover la turtle o hacer otros cambios).\n", "\n", - "Preconditions are the responsibility of the caller. If the caller violates a precondition and the function doesn't work correctly, the bug is in the caller, not the function.\n", + "Las precondiciones son responsabilidad de quien llama. Si quien llama viola una precondición y la función no funciona correctamente, el bug está en quien llama, no en la función.\n", "\n", - "If the preconditions are satisfied and the postconditions are not, the bug is in the function. If your pre- and postconditions are clear, they can help with debugging." + "Si las precondiciones se satisfacen y las postcondiciones no, el bug está en la función. Si tus precondiciones y postcondiciones están claras, pueden ayudar con la depuración." ] }, { @@ -672,40 +672,40 @@ "id": "a4d33a70", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**interface design:**\n", - "A process for designing the interface of a function, which includes the parameters it should take.\n", + "**diseño de interfaces:**\n", + "Un proceso para diseñar la interfaz de una función, que incluye los parámetros que debería recibir.\n", "\n", - "**canvas:**\n", - "A window used to display graphical elements including lines, circles, rectangles, and other shapes.\n", + "**lienzo:**\n", + "Una ventana usada para mostrar elementos gráficos, incluyendo líneas, círculos, rectángulos y otras formas.\n", "\n", - "**encapsulation:**\n", - " The process of transforming a sequence of statements into a function definition.\n", + "**encapsulación:**\n", + " El proceso de transformar una secuencia de sentencias en una definición de función.\n", "\n", - "**generalization:**\n", - " The process of replacing something unnecessarily specific (like a number) with something appropriately general (like a variable or parameter).\n", + "**generalización:**\n", + " El proceso de reemplazar algo innecesariamente específico (como un número) por algo adecuadamente general (como una variable o un parámetro).\n", "\n", - "**keyword argument:**\n", - "An argument that includes the name of the parameter.\n", + "**argumento de palabra clave:**\n", + "Un argumento que incluye el nombre del parámetro.\n", "\n", - "**refactoring:**\n", - " The process of modifying a working program to improve function interfaces and other qualities of the code.\n", + "**refactorización:**\n", + " El proceso de modificar un programa que funciona para mejorar las interfaces de las funciones y otras cualidades del código.\n", "\n", - "**development plan:**\n", - "A process for writing programs.\n", + "**plan de desarrollo:**\n", + "Un proceso para escribir programas.\n", "\n", "**docstring:**\n", - " A string that appears at the top of a function definition to document the function's interface.\n", + " Un string que aparece al principio de una definición de función para documentar la interfaz de la función.\n", "\n", - "**multiline string:**\n", - "A string enclosed in triple quotes that can span more than one line of a program.\n", + "**string multilínea:**\n", + "Un string encerrado entre comillas triples que puede ocupar más de una línea de un programa.\n", "\n", - "**precondition:**\n", - " A requirement that should be satisfied by the caller before a function starts.\n", + "**precondición:**\n", + " Un requisito que debería satisfacer quien llama antes de que empiece una función.\n", "\n", - "**postcondition:**\n", - " A requirement that should be satisfied by the function before it ends." + "**postcondición:**\n", + " Un requisito que debería satisfacer la función antes de terminar." ] }, { @@ -713,7 +713,7 @@ "id": "0bfe2e19", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -731,13 +731,13 @@ "id": "50ed5c38", "metadata": {}, "source": [ - "For the exercises below, there are a few more turtle functions you might want to use.\n", + "Para los ejercicios siguientes, hay algunas funciones más de turtle que quizá quieras usar.\n", "\n", - "* `penup` lifts the turtle's imaginary pen so it doesn't leave a trail when it moves.\n", + "* `penup` levanta el lápiz imaginario de la turtle para que no deje rastro cuando se mueve.\n", "\n", - "* `pendown` puts the pen back down.\n", + "* `pendown` vuelve a bajar el lápiz.\n", "\n", - "The following function uses `penup` and `pendown` to move the turtle without leaving a trail." + "La siguiente función usa `penup` y `pendown` para mover la turtle sin dejar rastro." ] }, { @@ -753,10 +753,10 @@ "id": "c78c1e17", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rectangle` that draws a rectangle with given side lengths.\n", - "For example, here's a rectangle that's `80` units wide and `40` units tall." + "Escribe una función llamada `rectangle` que dibuje un rectángulo con longitudes de lado dadas.\n", + "Por ejemplo, aquí tienes un rectángulo de `80` unidades de ancho y `40` unidades de alto." ] }, { @@ -774,7 +774,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your function." + "Puedes usar el siguiente código para probar tu función." ] }, { @@ -792,9 +792,9 @@ "id": "8b8faaf6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rhombus` that draws a rhombus with a given side length and a given interior angle. For example, here's a rhombus with side length `50` and an interior angle of `60` degrees." + "Escribe una función llamada `rhombus` que dibuje un rombo con una longitud de lado dada y un ángulo interior dado. Por ejemplo, aquí tienes un rombo con longitud de lado `50` y un ángulo interior de `60` grados." ] }, { @@ -812,7 +812,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your function." + "Puedes usar el siguiente código para probar tu función." ] }, { @@ -830,9 +830,9 @@ "id": "a9175a90", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now write a more general function called `parallelogram` that draws a quadrilateral with parallel sides. Then rewrite `rectangle` and `rhombus` to use `parallelogram`." + "Ahora escribe una función más general llamada `parallelogram` que dibuje un cuadrilátero con lados paralelos. Luego reescribe `rectangle` y `rhombus` para que usen `parallelogram`." ] }, { @@ -866,7 +866,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions." + "Puedes usar el siguiente código para probar tus funciones." ] }, { @@ -884,13 +884,13 @@ "id": "991ab59d", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an appropriately general set of functions that can draw shapes like this.\n", + "Escribe un conjunto de funciones adecuadamente general que pueda dibujar formas como esta.\n", "\n", "![](https://github.com/AllenDowney/ThinkPython/raw/v3/jupyturtle_pie.png)\n", "\n", - "Hint: Write a function called `triangle` that draws one triangular segment, and then a function called `draw_pie` that uses `triangle`." + "Pista: escribe una función llamada `triangle` que dibuje un segmento triangular, y luego una función llamada `draw_pie` que use `triangle`." ] }, { @@ -916,7 +916,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions." + "Puedes usar el siguiente código para probar tus funciones." ] }, { @@ -944,13 +944,13 @@ "id": "9c78b76f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an appropriately general set of functions that can draw flowers like this.\n", + "Escribe un conjunto de funciones adecuadamente general que pueda dibujar flores como esta.\n", "\n", "![](https://github.com/AllenDowney/ThinkPython/raw/v3/jupyturtle_flower.png)\n", "\n", - "Hint: Use `arc` to write a function called `petal` that draws one flower petal." + "Pista: usa `arc` para escribir una función llamada `petal` que dibuje un pétalo de flor." ] }, { @@ -976,12 +976,12 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions.\n", + "Puedes usar el siguiente código para probar tus funciones.\n", "\n", - "Because the solution draws a lot of small line segments, it tends to slow down as it runs.\n", - "To avoid that, you can add the keyword argument `auto_render=False` to avoid drawing after every step, and then call the `render` function at the end to show the result.\n", + "Como la solución dibuja muchos segmentos de línea pequeños, tiende a ralentizarse mientras se ejecuta.\n", + "Para evitarlo, puedes añadir el argumento de palabra clave `auto_render=False` para evitar dibujar después de cada paso, y luego llamar a la función `render` al final para mostrar el resultado.\n", "\n", - "While you are debugging, you might want to remove `auto_render=False`." + "Mientras estés depurando, quizá quieras quitar `auto_render=False`." ] }, { @@ -1009,12 +1009,12 @@ "id": "9d9f35d1", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are several modules like `jupyturtle` in Python, and the one we used in this chapter has been customized for this book.\n", - "So if you ask a virtual assistant for help, it won't know which module to use.\n", - "But if you give it a few examples to work with, it can probably figure it out.\n", - "For example, try this prompt and see if it can write a function that draws a spiral:\n", + "Hay varios módulos como `jupyturtle` en Python, y el que usamos en este capítulo se ha personalizado para este libro.\n", + "Así que, si pides ayuda a un asistente virtual, no sabrá qué módulo usar.\n", + "Pero si le das algunos ejemplos con los que trabajar, probablemente pueda deducirlo.\n", + "Por ejemplo, prueba este prompt y mira si puede escribir una función que dibuje una espiral:\n", "\n", "```\n", "The following program uses a turtle graphics module to draw a circle:\n", @@ -1046,9 +1046,9 @@ "id": "7beb2afe", "metadata": {}, "source": [ - "Keep in mind that the result might use features we have not seen yet, and it might have errors.\n", - "Copy the code from the VA and see if you can get it working.\n", - "If you didn't get what you wanted, try modifying the prompt.\n" + "Ten en cuenta que el resultado podría usar características que aún no hemos visto, y podría tener errores.\n", + "Copia el código del asistente virtual y comprueba si puedes hacerlo funcionar.\n", + "Si no obtuviste lo que querías, prueba a modificar el prompt.\n" ] }, { @@ -1074,13 +1074,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap05.ipynb b/blank/chap05.ipynb index 9f9ad19..2d480f6 100644 --- a/blank/chap05.ipynb +++ b/blank/chap05.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,12 +25,12 @@ "id": "75b60d6c", "metadata": {}, "source": [ - "# Conditionals and Recursion\n", + "# Condicionales y recursión\n", "\n", - "The main topic of this chapter is the `if` statement, which executes different code depending on the state of the program.\n", - "And with the `if` statement we'll be able to explore one of the most powerful ideas in computing, **recursion**.\n", + "El tema principal de este capítulo es la sentencia `if`, que ejecuta código distinto según el estado del programa.\n", + "Y con la sentencia `if` podremos explorar una de las ideas más potentes de la informática: la **recursión**.\n", "\n", - "But we'll start with three new features: the modulus operator, boolean expressions, and logical operators." + "Pero empezaremos con tres características nuevas: el operador módulo, las expresiones booleanas y los operadores lógicos." ] }, { @@ -38,13 +38,13 @@ "id": "4ab7caf4", "metadata": {}, "source": [ - "## Integer division and modulus\n", + "## División entera y módulo\n", "\n", - "Recall that the integer division operator, `//`, divides two numbers and rounds\n", - "down to an integer.\n", - "For example, suppose the run time of a movie is 105 minutes. \n", - "You might want to know how long that is in hours.\n", - "Conventional division returns a floating-point number:" + "Recuerda que el operador de división entera, `//`, divide dos números y redondea\n", + "hacia abajo hasta un entero.\n", + "Por ejemplo, supón que la duración de una película es de 105 minutos. \n", + "Puede que quieras saber cuánto es eso en horas.\n", + "La división convencional devuelve un número de punto flotante:" ] }, { @@ -60,8 +60,8 @@ "id": "3f224403", "metadata": {}, "source": [ - "But we don't normally write hours with decimal points.\n", - "Integer division returns the integer number of hours, rounding down:" + "Pero normalmente no escribimos las horas con decimales.\n", + "La división entera devuelve el número entero de horas, redondeando hacia abajo:" ] }, { @@ -77,7 +77,7 @@ "id": "bfa9b0cf", "metadata": {}, "source": [ - "To get the remainder, you could subtract off one hour in minutes:" + "Para obtener el resto, podrías restar una hora expresada en minutos:" ] }, { @@ -93,7 +93,7 @@ "id": "05caf27f", "metadata": {}, "source": [ - "Or you could use the **modulus operator**, `%`, which divides two numbers and returns the remainder." + "O podrías usar el **operador módulo**, `%`, que divide dos números y devuelve el resto." ] }, { @@ -109,12 +109,12 @@ "id": "18c1e0d0", "metadata": {}, "source": [ - "The modulus operator is more useful than it might seem.\n", - "For example, it can check whether one number is divisible by another -- if `x % y` is zero, then `x` is divisible by `y`.\n", + "El operador módulo es más útil de lo que podría parecer.\n", + "Por ejemplo, puede comprobar si un número es divisible por otro: si `x % y` es cero, entonces `x` es divisible por `y`.\n", "\n", - "Also, it can extract the right-most digit or digits from a number.\n", - "For example, `x % 10` yields the right-most digit of `x` (in base 10).\n", - "Similarly, `x % 100` yields the last two digits." + "También puede extraer el dígito o los dígitos más a la derecha de un número.\n", + "Por ejemplo, `x % 10` produce el dígito más a la derecha de `x` (en base 10).\n", + "De forma similar, `x % 100` produce los dos últimos dígitos." ] }, { @@ -138,8 +138,8 @@ "id": "f2344fc0", "metadata": {}, "source": [ - "Finally, the modulus operator can do \"clock arithmetic\".\n", - "For example, if an event starts at 11 AM and lasts three hours, we can use the modulus operator to figure out what time it ends." + "Por último, el operador módulo puede hacer «aritmética de reloj».\n", + "Por ejemplo, si un evento empieza a las 11 AM y dura tres horas, podemos usar el operador módulo para averiguar a qué hora termina." ] }, { @@ -155,7 +155,7 @@ "id": "351c30df", "metadata": {}, "source": [ - "The event would end at 2 PM." + "El evento terminaría a las 2 PM." ] }, { @@ -163,10 +163,10 @@ "id": "5ed1b58b", "metadata": {}, "source": [ - "## Boolean Expressions\n", + "## Expresiones booleanas\n", "\n", - "A **boolean expression** is an expression that is either true or false.\n", - "For example, the following expressions use the equals operator, `==`, which compares two values and produces `True` if they are equal and `False` otherwise:" + "Una **expresión booleana** es una expresión que es verdadera o falsa.\n", + "Por ejemplo, las siguientes expresiones usan el operador de igualdad, `==`, que compara dos valores y produce `True` si son iguales y `False` en caso contrario:" ] }, { @@ -190,8 +190,8 @@ "id": "41fbc642", "metadata": {}, "source": [ - "A common error is to use a single equal sign (`=`) instead of a double equal sign (`==`).\n", - "Remember that `=` assigns a value to a variable and `==` compares two values. " + "Un error común es usar un solo signo igual (`=`) en lugar de un doble signo igual (`==`).\n", + "Recuerda que `=` asigna un valor a una variable y `==` compara dos valores. " ] }, { @@ -215,8 +215,8 @@ "id": "d3ec6b48", "metadata": {}, "source": [ - "`True` and `False` are special values that belong to the type `bool`;\n", - "they are not strings:" + "`True` y `False` son valores especiales que pertenecen al tipo `bool`;\n", + "no son cadenas:" ] }, { @@ -240,7 +240,7 @@ "id": "451b2e8d", "metadata": {}, "source": [ - "The `==` operator is one of the **relational operators**; the others are:" + "El operador `==` es uno de los **operadores relacionales**; los otros son:" ] }, { @@ -288,12 +288,12 @@ "id": "db5a9477", "metadata": {}, "source": [ - "## Logical operators\n", + "## Operadores lógicos\n", "\n", - "To combine boolean values into expressions, we can use **logical operators**.\n", - "The most common are `and`, ` or`, and `not`.\n", - "The meaning of these operators is similar to their meaning in English.\n", - "For example, the value of the following expression is `True` only if `x` is greater than `0` *and* less than `10`." + "Para combinar valores booleanos en expresiones, podemos usar **operadores lógicos**.\n", + "Los más comunes son `and`, ` or` y `not`.\n", + "El significado de estos operadores es parecido a su significado en inglés.\n", + "Por ejemplo, el valor de la siguiente expresión es `True` solo si `x` es mayor que `0` *y* menor que `10`." ] }, { @@ -309,7 +309,7 @@ "id": "e8c14026", "metadata": {}, "source": [ - "The following expression is `True` if *either or both* of the conditions is true, that is, if the number is divisible by 2 *or* 3:" + "La siguiente expresión es `True` si *una o ambas* condiciones son verdaderas, es decir, si el número es divisible por 2 *o* por 3:" ] }, { @@ -325,7 +325,7 @@ "id": "3bd0ef52", "metadata": {}, "source": [ - "Finally, the `not` operator negates a boolean expression, so the following expression is `True` if `x > y` is `False`." + "Por último, el operador `not` niega una expresión booleana, de modo que la siguiente expresión es `True` si `x > y` es `False`." ] }, { @@ -341,8 +341,8 @@ "id": "fc6098c2", "metadata": {}, "source": [ - "Strictly speaking, the operands of a logical operator should be boolean expressions, but Python is not very strict.\n", - "Any nonzero number is interpreted as `True`:" + "En sentido estricto, los operandos de un operador lógico deberían ser expresiones booleanas, pero Python no es muy estricto.\n", + "Cualquier número distinto de cero se interpreta como `True`:" ] }, { @@ -358,8 +358,8 @@ "id": "102ceab9", "metadata": {}, "source": [ - "This flexibility can be useful, but there are some subtleties to it that can be confusing.\n", - "You might want to avoid it." + "Esta flexibilidad puede ser útil, pero tiene algunas sutilezas que pueden resultar confusas.\n", + "Quizá prefieras evitarla." ] }, { @@ -367,12 +367,12 @@ "id": "6b0f2dc1", "metadata": {}, "source": [ - "## if statements\n", + "## Sentencias `if`\n", "\n", - "In order to write useful programs, we almost always need the ability to\n", - "check conditions and change the behavior of the program accordingly.\n", - "**Conditional statements** give us this ability. The simplest form is\n", - "the `if` statement:" + "Para escribir programas útiles, casi siempre necesitamos la capacidad de\n", + "comprobar condiciones y cambiar el comportamiento del programa en consecuencia.\n", + "Las **sentencias condicionales** nos dan esta capacidad. La forma más sencilla es\n", + "la sentencia `if`:" ] }, { @@ -388,16 +388,16 @@ "id": "973f705e", "metadata": {}, "source": [ - "`if` is a Python keyword.\n", - "`if` statements have the same structure as function definitions: a\n", - "header followed by an indented statement or sequence of statements called a **block**.\n", + "`if` es una palabra clave de Python.\n", + "Las sentencias `if` tienen la misma estructura que las definiciones de función: una\n", + "cabecera seguida de una sentencia indentada o de una secuencia de sentencias llamada **bloque**.\n", "\n", - "The boolean expression after `if` is called the **condition**.\n", - "If it is true, the statements in the indented block run. If not, they don't.\n", + "La expresión booleana que va después de `if` se llama **condición**.\n", + "Si es verdadera, se ejecutan las sentencias del bloque indentado. Si no, no se ejecutan.\n", "\n", - "There is no limit to the number of statements that can appear in the block, but there has to be at least one.\n", - "Occasionally, it is useful to have a block that does nothing -- usually as a place keeper for code you haven't written yet.\n", - "In that case, you can use the `pass` statement, which does nothing." + "No hay límite para el número de sentencias que pueden aparecer en el bloque, pero tiene que haber al menos una.\n", + "A veces resulta útil tener un bloque que no hace nada, normalmente como marcador de posición para código que todavía no has escrito.\n", + "En ese caso, puedes usar la sentencia `pass`, que no hace nada." ] }, { @@ -413,7 +413,7 @@ "id": "adf3f6c5", "metadata": {}, "source": [ - "The word `TODO` in a comment is a conventional reminder that there's something you need to do later." + "La palabra `TODO` en un comentario es un recordatorio convencional de que hay algo que tienes que hacer más adelante." ] }, { @@ -421,10 +421,10 @@ "id": "eb39bcd9", "metadata": {}, "source": [ - "## The `else` clause\n", + "## La cláusula `else`\n", "\n", - "An `if` statement can have a second part, called an `else` clause.\n", - "The syntax looks like this:" + "Una sentencia `if` puede tener una segunda parte, llamada cláusula `else`.\n", + "La sintaxis tiene este aspecto:" ] }, { @@ -440,14 +440,14 @@ "id": "e7dc8943", "metadata": {}, "source": [ - "If the condition is true, the first indented statement runs; otherwise, the second indented statement runs.\n", + "Si la condición es verdadera, se ejecuta la primera sentencia indentada; si no, se ejecuta la segunda sentencia indentada.\n", "\n", - "In this example, if `x` is even, the remainder when `x` is divided by `2` is `0`, so the condition is true and the program displays `x is even`.\n", - "If `x` is odd, the remainder is `1`, so the condition\n", - "is false, and the program displays `x is odd`.\n", + "En este ejemplo, si `x` es par, el resto al dividir `x` entre `2` es `0`, así que la condición es verdadera y el programa muestra `x is even`.\n", + "Si `x` es impar, el resto es `1`, así que la condición\n", + "es falsa, y el programa muestra `x is odd`.\n", "\n", - "Since the condition must be true or false, exactly one of the alternatives will run. \n", - "The alternatives are called **branches**." + "Como la condición debe ser verdadera o falsa, se ejecutará exactamente una de las alternativas. \n", + "Las alternativas se llaman **ramas**." ] }, { @@ -455,10 +455,10 @@ "id": "20c8adb6", "metadata": {}, "source": [ - "## Chained conditionals\n", + "## Condicionales encadenados\n", "\n", - "Sometimes there are more than two possibilities and we need more than two branches.\n", - "One way to express a computation like that is a **chained conditional**, which includes an `elif` clause." + "A veces hay más de dos posibilidades y necesitamos más de dos ramas.\n", + "Una forma de expresar un cálculo así es un **condicional encadenado**, que incluye una cláusula `elif`." ] }, { @@ -474,15 +474,15 @@ "id": "46916379", "metadata": {}, "source": [ - "`elif` is an abbreviation of \"else if\".\n", - "There is no limit on the number of `elif` clauses.\n", - "If there is an `else` clause, it has to be at the end, but there doesn't have to be\n", - "one.\n", + "`elif` es una abreviatura de «else if».\n", + "No hay límite en el número de cláusulas `elif`.\n", + "Si hay una cláusula `else`, tiene que ir al final, pero no tiene por qué haber\n", + "una.\n", "\n", - "Each condition is checked in order.\n", - "If the first is false, the next is checked, and so on.\n", - "If one of them is true, the corresponding branch runs and the `if` statement ends.\n", - "Even if more than one condition is true, only the first true branch runs." + "Cada condición se comprueba en orden.\n", + "Si la primera es falsa, se comprueba la siguiente, y así sucesivamente.\n", + "Si una de ellas es verdadera, se ejecuta la rama correspondiente y termina la sentencia `if`.\n", + "Aunque más de una condición sea verdadera, solo se ejecuta la primera rama verdadera." ] }, { @@ -490,10 +490,10 @@ "id": "e0c0b9dd", "metadata": {}, "source": [ - "## Nested Conditionals\n", + "## Condicionales anidados\n", "\n", - "One conditional can also be nested within another.\n", - "We could have written the example in the previous section like this:" + "Un condicional también puede estar anidado dentro de otro.\n", + "Podríamos haber escrito el ejemplo de la sección anterior así:" ] }, { @@ -509,15 +509,15 @@ "id": "29f67a0a", "metadata": {}, "source": [ - "The outer `if` statement contains two branches. \n", - "The first branch contains a simple statement. The second branch contains another `if` statement, which has two branches of its own.\n", - "Those two branches are both simple statements, although they could have been conditional statements as well.\n", + "La sentencia `if` exterior contiene dos ramas. \n", + "La primera rama contiene una sentencia sencilla. La segunda rama contiene otra sentencia `if`, que tiene dos ramas propias.\n", + "Esas dos ramas son ambas sentencias sencillas, aunque también podrían haber sido sentencias condicionales.\n", "\n", - "Although the indentation of the statements makes the structure apparent, **nested conditionals** can be difficult to read.\n", - "I suggest you avoid them when you can.\n", + "Aunque la indentación de las sentencias hace visible la estructura, los **condicionales anidados** pueden ser difíciles de leer.\n", + "Te sugiero que los evites cuando puedas.\n", "\n", - "Logical operators often provide a way to simplify nested conditional statements.\n", - "Here's an example with a nested conditional." + "Los operadores lógicos suelen proporcionar una forma de simplificar sentencias condicionales anidadas.\n", + "Aquí tienes un ejemplo con un condicional anidado." ] }, { @@ -533,7 +533,7 @@ "id": "5292eb11", "metadata": {}, "source": [ - "The `print` statement runs only if we make it past both conditionals, so we get the same effect with the `and` operator." + "La sentencia `print` se ejecuta solo si superamos ambos condicionales, así que conseguimos el mismo efecto con el operador `and`." ] }, { @@ -549,7 +549,7 @@ "id": "dd8e808a", "metadata": {}, "source": [ - "For this kind of condition, Python provides a more concise option:" + "Para este tipo de condición, Python ofrece una opción más concisa:" ] }, { @@ -565,11 +565,11 @@ "id": "db583cd9", "metadata": {}, "source": [ - "## Recursion\n", + "## Recursión\n", "\n", - "It is legal for a function to call itself.\n", - "It may not be obvious why that is a good thing, but it turns out to be one of the most magical things a program can do.\n", - "Here's an example." + "Es legal que una función se llame a sí misma.\n", + "Puede que no sea obvio por qué eso es algo bueno, pero resulta ser una de las cosas más mágicas que puede hacer un programa.\n", + "Aquí tienes un ejemplo." ] }, { @@ -585,10 +585,10 @@ "id": "c88e0dc7", "metadata": {}, "source": [ - "If `n` is 0 or negative, `countdown` outputs the word, \"Blastoff!\" Otherwise, it\n", - "outputs `n` and then calls itself, passing `n-1` as an argument.\n", + "Si `n` es 0 o negativo, `countdown` muestra la palabra «Blastoff!». En caso contrario,\n", + "muestra `n` y luego se llama a sí misma, pasando `n-1` como argumento.\n", "\n", - "Here's what happens when we call this function with the argument `3`." + "Esto es lo que ocurre cuando llamamos a esta función con el argumento `3`." ] }, { @@ -604,23 +604,23 @@ "id": "3f3c87ec", "metadata": {}, "source": [ - "The execution of `countdown` begins with `n=3`, and since `n` is greater\n", - "than `0`, it displays `3`, and then calls itself\\...\n", + "La ejecución de `countdown` empieza con `n=3`, y como `n` es mayor\n", + "que `0`, muestra `3` y luego se llama a sí misma\\...\n", "\n", - "> The execution of `countdown` begins with `n=2`, and since `n` is\n", - "> greater than `0`, it displays `2`, and then calls itself\\...\n", + "> La ejecución de `countdown` empieza con `n=2`, y como `n` es\n", + "> mayor que `0`, muestra `2` y luego se llama a sí misma\\...\n", ">\n", - "> > The execution of `countdown` begins with `n=1`, and since `n` is\n", - "> > greater than `0`, it displays `1`, and then calls itself\\...\n", + "> > La ejecución de `countdown` empieza con `n=1`, y como `n` es\n", + "> > mayor que `0`, muestra `1` y luego se llama a sí misma\\...\n", "> >\n", - "> > > The execution of `countdown` begins with `n=0`, and since `n` is\n", - "> > > not greater than `0`, it displays \"Blastoff!\" and returns.\n", + "> > > La ejecución de `countdown` empieza con `n=0`, y como `n` no es\n", + "> > > mayor que `0`, muestra «Blastoff!» y retorna.\n", "> >\n", - "> > The `countdown` that got `n=1` returns.\n", + "> > La `countdown` que recibió `n=1` retorna.\n", ">\n", - "> The `countdown` that got `n=2` returns.\n", + "> La `countdown` que recibió `n=2` retorna.\n", "\n", - "The `countdown` that got `n=3` returns." + "La `countdown` que recibió `n=3` retorna." ] }, { @@ -628,8 +628,8 @@ "id": "782e95bb", "metadata": {}, "source": [ - "A function that calls itself is **recursive**.\n", - "As another example, we can write a function that prints a string `n` times." + "Una función que se llama a sí misma es **recursiva**.\n", + "Como otro ejemplo, podemos escribir una función que imprime una cadena `n` veces." ] }, { @@ -645,11 +645,11 @@ "id": "73d07c17", "metadata": {}, "source": [ - "If `n` is positive, `print_n_times` displays the value of `string` and then calls itself, passing along `string` and `n-1` as arguments.\n", + "Si `n` es positivo, `print_n_times` muestra el valor de `string` y luego se llama a sí misma, pasando `string` y `n-1` como argumentos.\n", "\n", - "If `n` is `0` or negative, the condition is false and `print_n_times` does nothing.\n", + "Si `n` es `0` o negativo, la condición es falsa y `print_n_times` no hace nada.\n", "\n", - "Here's how it works." + "Así es como funciona." ] }, { @@ -665,9 +665,9 @@ "id": "1fb55a78", "metadata": {}, "source": [ - "For simple examples like this, it is probably easier to use a `for`\n", - "loop. But we will see examples later that are hard to write with a `for`\n", - "loop and easy to write with recursion, so it is good to start early." + "Para ejemplos sencillos como este, probablemente sea más fácil usar un bucle `for`.\n", + "Pero más adelante veremos ejemplos que son difíciles de escribir con un bucle `for`\n", + "y fáciles de escribir con recursión, así que conviene empezar pronto." ] }, { @@ -675,9 +675,9 @@ "id": "c652c739", "metadata": {}, "source": [ - "## Stack diagrams for recursive functions\n", + "## Diagramas de stack para funciones recursivas\n", "\n", - "Here's a stack diagram that shows the frames created when we called `countdown` with `n = 3`." + "Aquí tienes un diagrama de stack que muestra los marcos creados cuando llamamos a `countdown` con `n = 3`." ] }, { @@ -705,9 +705,9 @@ "id": "9282331b", "metadata": {}, "source": [ - "The four `countdown` frames have different values for the parameter `n`.\n", - "The bottom of the stack, where `n=0`, is called the **base case**.\n", - "It does not make a recursive call, so there are no more frames." + "Los cuatro marcos de `countdown` tienen valores distintos para el parámetro `n`.\n", + "La parte inferior del stack, donde `n=0`, se llama **caso base**.\n", + "No hace una llamada recursiva, así que no hay más marcos." ] }, { @@ -725,12 +725,12 @@ "id": "37bbc2b8", "metadata": {}, "source": [ - "## Infinite recursion\n", + "## Recursión infinita\n", "\n", - "If a recursion never reaches a base case, it goes on making recursive\n", - "calls forever, and the program never terminates. This is known as\n", - "**infinite recursion**, and it is generally not a good idea.\n", - "Here's a minimal function with an infinite recursion." + "Si una recursión nunca alcanza un caso base, sigue haciendo llamadas\n", + "recursivas para siempre, y el programa nunca termina. Esto se conoce como\n", + "**recursión infinita**, y por lo general no es una buena idea.\n", + "Aquí tienes una función mínima con una recursión infinita." ] }, { @@ -746,9 +746,9 @@ "id": "450a20ac", "metadata": {}, "source": [ - "Every time `recurse` is called, it calls itself, which creates another frame.\n", - "In Python, there is a limit to the number of frames that can be on the stack at the same time.\n", - "If a program exceeds the limit, it causes a runtime error." + "Cada vez que se llama a `recurse`, se llama a sí misma, lo que crea otro marco.\n", + "En Python, hay un límite para el número de marcos que pueden estar en el stack al mismo tiempo.\n", + "Si un programa supera el límite, provoca un error en tiempo de ejecución." ] }, { @@ -776,9 +776,9 @@ "id": "39fc5c31", "metadata": {}, "source": [ - "The traceback indicates that there were almost 3000 frames on the stack when the error occurred.\n", + "El traceback indica que había casi 3000 marcos en el stack cuando ocurrió el error.\n", "\n", - "If you encounter an infinite recursion by accident, review your function to confirm that there is a base case that does not make a recursive call. And if there is a base case, check whether you are guaranteed to reach it." + "Si te encuentras por accidente con una recursión infinita, revisa tu función para confirmar que hay un caso base que no hace una llamada recursiva. Y si hay un caso base, comprueba si tienes garantizado llegar a él." ] }, { @@ -786,15 +786,15 @@ "id": "45299414", "metadata": {}, "source": [ - "## Keyboard input\n", + "## Entrada por teclado\n", "\n", - "The programs we have written so far accept no input from the user. They\n", - "just do the same thing every time.\n", + "Los programas que hemos escrito hasta ahora no aceptan entrada del usuario. Simplemente\n", + "hacen lo mismo cada vez.\n", "\n", - "Python provides a built-in function called `input` that stops the\n", - "program and waits for the user to type something. When the user presses\n", - "*Return* or *Enter*, the program resumes and `input` returns what the user\n", - "typed as a string." + "Python proporciona una función integrada llamada `input` que detiene el\n", + "programa y espera a que el usuario escriba algo. Cuando el usuario pulsa\n", + "*Return* o *Enter*, el programa continúa y `input` devuelve lo que el usuario\n", + "ha escrito como una cadena." ] }, { @@ -820,8 +820,8 @@ "id": "acf9ec53", "metadata": {}, "source": [ - "Before getting input from the user, you might want to display a prompt\n", - "telling the user what to type. `input` can take a prompt as an argument:" + "Antes de obtener entrada del usuario, puede que quieras mostrar un prompt\n", + "que le indique qué debe escribir. `input` puede recibir un prompt como argumento:" ] }, { @@ -847,9 +847,10 @@ "id": "1b754b39", "metadata": {}, "source": [ - "The sequence `\\n` at the end of the prompt represents a **newline**, which is a special character that causes a line break -- that way the user's input appears below the prompt.\n", + "La secuencia `\n", + "` al final del prompt representa una **nueva línea**, que es un carácter especial que provoca un salto de línea; así, la entrada del usuario aparece debajo del prompt.\n", "\n", - "If you expect the user to type an integer, you can use the `int` function to convert the return value to `int`." + "Si esperas que el usuario escriba un entero, puedes usar la función `int` para convertir el valor de retorno a `int`." ] }, { @@ -875,7 +876,7 @@ "id": "0a65f2af", "metadata": {}, "source": [ - "But if they type something that's not an integer, you'll get a runtime error." + "Pero si escribe algo que no es un entero, obtendrás un error en tiempo de ejecución." ] }, { @@ -903,7 +904,7 @@ "id": "a4ce3ed5", "metadata": {}, "source": [ - "We will see how to handle this kind of error later." + "Más adelante veremos cómo manejar este tipo de error." ] }, { @@ -913,17 +914,16 @@ "source": [ "## Debugging\n", "\n", - "When a syntax or runtime error occurs, the error message contains a lot\n", - "of information, but it can be overwhelming. The most useful parts are\n", - "usually:\n", + "Cuando ocurre un error de sintaxis o en tiempo de ejecución, el mensaje de error contiene mucha\n", + "información, pero puede resultar abrumador. Las partes más útiles suelen ser:\n", "\n", - "- What kind of error it was, and\n", + "- Qué tipo de error fue, y\n", "\n", - "- Where it occurred.\n", + "- Dónde ocurrió.\n", "\n", - "Syntax errors are usually easy to find, but there are a few gotchas.\n", - "Errors related to spaces and tabs can be tricky because they are invisible\n", - "and we are used to ignoring them." + "Los errores de sintaxis suelen ser fáciles de encontrar, pero hay algunas trampas.\n", + "Los errores relacionados con espacios y tabulaciones pueden ser complicados porque son invisibles\n", + "y estamos acostumbrados a ignorarlos." ] }, { @@ -941,12 +941,12 @@ "id": "d1d06263", "metadata": {}, "source": [ - "In this example, the problem is that the second line is indented by one space.\n", - "But the error message points to `y`, which is misleading.\n", - "Error messages indicate where the problem was discovered, but the actual error might be earlier in the code.\n", + "En este ejemplo, el problema es que la segunda línea está indentada con un espacio.\n", + "Pero el mensaje de error señala a `y`, lo que resulta engañoso.\n", + "Los mensajes de error indican dónde se descubrió el problema, pero el error real podría estar antes en el código.\n", "\n", - "The same is true of runtime errors. \n", - "For example, suppose you are trying to convert a ratio to decibels, like this:" + "Lo mismo ocurre con los errores en tiempo de ejecución. \n", + "Por ejemplo, supón que intentas convertir una razón a decibelios, así:" ] }, { @@ -974,11 +974,11 @@ "id": "55914374", "metadata": {}, "source": [ - "The error message indicates line 5, but there is nothing wrong with that line.\n", - "The problem is in line 4, which uses integer division instead of floating-point division -- as a result, the value of `ratio` is `0`.\n", - "When we call `math.log10`, we get a `ValueError` with the message `math domain error`, because `0` is not in the \"domain\" of valid arguments for `math.log10`, because the logarithm of `0` is undefined.\n", + "El mensaje de error indica la línea 5, pero no hay nada malo en esa línea.\n", + "El problema está en la línea 4, que usa división entera en lugar de división de punto flotante; como resultado, el valor de `ratio` es `0`.\n", + "Cuando llamamos a `math.log10`, obtenemos un `ValueError` con el mensaje `math domain error`, porque `0` no está en el «dominio» de argumentos válidos para `math.log10`, ya que el logaritmo de `0` no está definido.\n", "\n", - "In general, you should take the time to read error messages carefully, but don't assume that everything they say is correct." + "En general, deberías tomarte el tiempo de leer cuidadosamente los mensajes de error, pero no asumas que todo lo que dicen es correcto." ] }, { @@ -986,53 +986,53 @@ "id": "8ffe690e", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**recursion:**\n", - "The process of calling the function that is currently executing.\n", + "**recursión:**\n", + "El proceso de llamar a la función que se está ejecutando en ese momento.\n", "\n", - "**modulus operator:**\n", - "An operator, `%`, that works on integers and returns the remainder when one number is divided by another.\n", + "**operador módulo:**\n", + "Un operador, `%`, que funciona con enteros y devuelve el resto cuando un número se divide entre otro.\n", "\n", - "**boolean expression:**\n", - "An expression whose value is either `True` or `False`.\n", + "**expresión booleana:**\n", + "Una expresión cuyo valor es `True` o `False`.\n", "\n", - "**relational operator:**\n", - "One of the operators that compares its operands: `==`, `!=`, `>`, `<`, `>=`, and `<=`.\n", + "**operador relacional:**\n", + "Uno de los operadores que compara sus operandos: `==`, `!=`, `>`, `<`, `>=` y `<=`.\n", "\n", - "**logical operator:**\n", - "One of the operators that combines boolean expressions, including `and`, `or`, and `not`.\n", + "**operador lógico:**\n", + "Uno de los operadores que combina expresiones booleanas, incluidos `and`, `or` y `not`.\n", "\n", - "**conditional statement:**\n", - "A statement that controls the flow of execution depending on some condition.\n", + "**sentencia condicional:**\n", + "Una sentencia que controla el flujo de ejecución dependiendo de alguna condición.\n", "\n", - "**condition:**\n", - "The boolean expression in a conditional statement that determines which branch runs.\n", + "**condición:**\n", + "La expresión booleana en una sentencia condicional que determina qué rama se ejecuta.\n", "\n", - "**block:**\n", - "One or more statements indented to indicate they are part of another statement.\n", + "**bloque:**\n", + "Una o más sentencias indentadas para indicar que forman parte de otra sentencia.\n", "\n", - "**branch:**\n", - "One of the alternative sequences of statements in a conditional statement.\n", + "**rama:**\n", + "Una de las secuencias alternativas de sentencias en una sentencia condicional.\n", "\n", - "**chained conditional:**\n", - "A conditional statement with a series of alternative branches.\n", + "**condicional encadenado:**\n", + "Una sentencia condicional con una serie de ramas alternativas.\n", "\n", - "**nested conditional:**\n", - "A conditional statement that appears in one of the branches of another conditional statement.\n", + "**condicional anidado:**\n", + "Una sentencia condicional que aparece en una de las ramas de otra sentencia condicional.\n", "\n", - "**recursive:**\n", - "A function that calls itself is recursive.\n", + "**recursiva:**\n", + "Una función que se llama a sí misma es recursiva.\n", "\n", - "**base case:**\n", - "A conditional branch in a recursive function that does not make a recursive call.\n", + "**caso base:**\n", + "Una rama condicional en una función recursiva que no hace una llamada recursiva.\n", "\n", - "**infinite recursion:**\n", - "A recursion that doesn't have a base case, or never reaches it.\n", - "Eventually, an infinite recursion causes a runtime error.\n", + "**recursión infinita:**\n", + "Una recursión que no tiene caso base o que nunca lo alcanza.\n", + "Con el tiempo, una recursión infinita provoca un error en tiempo de ejecución.\n", "\n", - "**newline:**\n", - "A character that creates a line break between two parts of a string." + "**nueva línea:**\n", + "Un carácter que crea un salto de línea entre dos partes de una cadena." ] }, { @@ -1040,7 +1040,7 @@ "id": "8d783953", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1058,15 +1058,15 @@ "id": "02f9f1d7", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "* Ask a virtual assistant, \"What are some uses of the modulus operator?\"\n", + "* Pregunta a un asistente virtual: «¿Cuáles son algunos usos del operador módulo?»\n", "\n", - "* Python provides operators to compute the logical operations `and`, `or`, and `not`, but it doesn't have an operator that computes the exclusive `or` operation, usually written `xor`. Ask an assistant \"What is the logical xor operation and how do I compute it in Python?\"\n", + "* Python proporciona operadores para calcular las operaciones lógicas `and`, `or` y `not`, pero no tiene un operador que calcule la operación `or` exclusiva, que normalmente se escribe `xor`. Pregunta a un asistente: «¿Qué es la operación lógica xor y cómo la calculo en Python?»\n", "\n", - "In this chapter, we saw two ways to write an `if` statement with three branches, using a chained conditional or a nested conditional.\n", - "You can use a virtual assistant to convert from one to the other.\n", - "For example, ask a VA, \"Convert this statement to a chained conditional.\"" + "En este capítulo, vimos dos formas de escribir una sentencia `if` con tres ramas: usando un condicional encadenado o un condicional anidado.\n", + "Puedes usar un asistente virtual para convertir de una forma a la otra.\n", + "Por ejemplo, pregunta a un asistente virtual: «Convierte esta sentencia en un condicional encadenado»." ] }, { @@ -1092,7 +1092,7 @@ "id": "9c2a8466", "metadata": {}, "source": [ - "Ask a VA, \"Rewrite this statement with a single conditional.\"" + "Pregunta a un asistente virtual: «Reescribe esta sentencia con un único condicional»." ] }, { @@ -1108,7 +1108,7 @@ "id": "e0fbed08", "metadata": {}, "source": [ - "See if a VA can simplify this unnecessary complexity." + "Comprueba si un asistente virtual puede simplificar esta complejidad innecesaria." ] }, { @@ -1124,7 +1124,7 @@ "id": "74ef776d", "metadata": {}, "source": [ - "Here's an attempt at a recursive function that counts down by two." + "Aquí tienes un intento de función recursiva que cuenta hacia atrás de dos en dos." ] }, { @@ -1140,7 +1140,7 @@ "id": "77178e79", "metadata": {}, "source": [ - "It seems to work." + "Parece funcionar." ] }, { @@ -1156,8 +1156,8 @@ "id": "c9d3a8dc", "metadata": {}, "source": [ - "But it has an error. Ask a virtual assistant what's wrong and how to fix it.\n", - "Paste the solution it provides back here and test it." + "Pero tiene un error. Pregunta a un asistente virtual qué está mal y cómo arreglarlo.\n", + "Pega aquí la solución que te proporcione y pruébala." ] }, { @@ -1165,10 +1165,10 @@ "id": "240a3888", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The `time` module provides a function, also called `time`, that returns\n", - "returns the number of seconds since the \"Unix epoch\", which is January 1, 1970, 00:00:00 UTC (Coordinated Universal Time)." + "El módulo `time` proporciona una función, también llamada `time`, que devuelve\n", + "el número de segundos transcurridos desde la «época Unix», que es el 1 de enero de 1970, 00:00:00 UTC (tiempo universal coordinado)." ] }, { @@ -1184,7 +1184,7 @@ "id": "054c3197", "metadata": {}, "source": [ - "Use integer division and the modulus operator to compute the number of days since January 1, 1970 and the current time of day in hours, minutes, and seconds." + "Usa la división entera y el operador módulo para calcular el número de días transcurridos desde el 1 de enero de 1970 y la hora actual del día en horas, minutos y segundos." ] }, { @@ -1194,7 +1194,7 @@ "tags": [] }, "source": [ - "You can read more about the `time` module at ." + "Puedes leer más sobre el módulo `time` en ." ] }, { @@ -1234,23 +1234,22 @@ "id": "6b1fd514", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "If you are given three sticks, you may or may not be able to arrange\n", - "them in a triangle. For example, if one of the sticks is 12 inches long\n", - "and the other two are one inch long, you will not be able to get the\n", - "short sticks to meet in the middle. For any three lengths, there is a\n", - "test to see if it is possible to form a triangle:\n", + "Si te dan tres palos, puede que puedas colocarlos formando un triángulo, o puede que no. Por ejemplo, si uno de los palos mide 12 pulgadas\n", + "y los otros dos miden una pulgada, no podrás hacer que los\n", + "palos cortos se encuentren en el centro. Para tres longitudes cualesquiera, hay una\n", + "prueba para ver si es posible formar un triángulo:\n", "\n", - "> If any of the three lengths is greater than the sum of the other two,\n", - "> then you cannot form a triangle. Otherwise, you can. (If the sum of\n", - "> two lengths equals the third, they form what is called a \"degenerate\"\n", - "> triangle.)\n", + "> Si cualquiera de las tres longitudes es mayor que la suma de las otras dos,\n", + "> entonces no puedes formar un triángulo. En caso contrario, sí puedes. (Si la suma de\n", + "> dos longitudes es igual a la tercera, forman lo que se llama un triángulo\n", + "> «degenerado».)\n", "\n", - "Write a function named `is_triangle` that takes three integers as\n", - "arguments, and that prints either \"Yes\" or \"No\", depending on\n", - "whether you can or cannot form a triangle from sticks with the given\n", - "lengths. Hint: Use a chained conditional.\n", + "Escribe una función llamada `is_triangle` que reciba tres enteros como\n", + "argumentos, y que imprima «Yes» o «No», dependiendo de\n", + "si se puede o no formar un triángulo con palos de las longitudes dadas.\n", + "Pista: usa un condicional encadenado.\n", "\n" ] }, @@ -1271,7 +1270,7 @@ "tags": [] }, "source": [ - "Test your function with the following cases." + "Prueba tu función con los siguientes casos." ] }, { @@ -1319,10 +1318,10 @@ "id": "2ba42106", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "What is the output of the following program? Draw a stack diagram that\n", - "shows the state of the program when it prints the result." + "¿Cuál es la salida del siguiente programa? Dibuja un diagrama de stack que\n", + "muestre el estado del programa cuando imprime el resultado." ] }, { @@ -1356,14 +1355,14 @@ "id": "bca9517d", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The following exercises use the `jupyturtle` module, described in Chapter 4.\n", + "Los siguientes ejercicios usan el módulo `jupyturtle`, descrito en el Capítulo 4.\n", "\n", - "Read the following function and see if you can figure out what it does.\n", - "Then run it and see if you got it right.\n", - "Adjust the values of `length`, `angle` and `factor` and see what effect they have on the result.\n", - "If you are not sure you understand how it works, try asking a virtual assistant." + "Lee la siguiente función y mira si puedes averiguar qué hace.\n", + "Luego ejecútala y comprueba si acertaste.\n", + "Ajusta los valores de `length`, `angle` y `factor`, y observa qué efecto tienen en el resultado.\n", + "Si no tienes claro cómo funciona, prueba a preguntar a un asistente virtual." ] }, { @@ -1387,30 +1386,30 @@ "id": "e525ba59", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Ask a virtual assistant \"What is the Koch curve?\"\n", + "Pregunta a un asistente virtual: «¿Qué es la curva de Koch?»\n", "\n", - "To draw a Koch curve with length `x`, all you\n", - "have to do is\n", + "Para dibujar una curva de Koch con longitud `x`, todo lo que\n", + "tienes que hacer es\n", "\n", - "1. Draw a Koch curve with length `x/3`.\n", + "1. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "2. Turn left 60 degrees.\n", + "2. Girar a la izquierda 60 grados.\n", "\n", - "3. Draw a Koch curve with length `x/3`.\n", + "3. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "4. Turn right 120 degrees.\n", + "4. Girar a la derecha 120 grados.\n", "\n", - "5. Draw a Koch curve with length `x/3`.\n", + "5. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "6. Turn left 60 degrees.\n", + "6. Girar a la izquierda 60 grados.\n", "\n", - "7. Draw a Koch curve with length `x/3`.\n", + "7. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "The exception is if `x` is less than `5` -- in that case, you can just draw a straight line with length `x`.\n", + "La excepción es si `x` es menor que `5`; en ese caso, puedes dibujar simplemente una línea recta con longitud `x`.\n", "\n", - "Write a function called `koch` that takes `x` as an argument and draws a Koch curve with the given length.\n" + "Escribe una función llamada `koch` que reciba `x` como argumento y dibuje una curva de Koch con la longitud dada.\n" ] }, { @@ -1426,7 +1425,7 @@ "id": "2991143a", "metadata": {}, "source": [ - "The result should look like this:" + "El resultado debería verse así:" ] }, { @@ -1444,7 +1443,7 @@ "tags": [] }, "source": [ - "Once you have koch working, you can use this loop to draw three Koch curves in the shape of a snowflake." + "Cuando tengas `koch` funcionando, puedes usar este bucle para dibujar tres curvas de Koch con forma de copo de nieve." ] }, { @@ -1462,17 +1461,17 @@ "id": "4c964239", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Virtual assistants know about the functions in the `jupyturtle` module, but there are many versions of these functions, with different names, so a VA might not know which one you are talking about.\n", + "Los asistentes virtuales conocen las funciones del módulo `jupyturtle`, pero hay muchas versiones de estas funciones, con nombres distintos, así que un asistente virtual podría no saber de cuál estás hablando.\n", "\n", - "To solve this problem, you can provide additional information before you ask a question.\n", - "For example, you could start a prompt with \"Here's a program that uses the `jupyturtle` module,\" and then paste in one of the examples from this chapter.\n", - "After that, the VA should be able to generate code that uses this module.\n", + "Para resolver este problema, puedes proporcionar información adicional antes de hacer una pregunta.\n", + "Por ejemplo, podrías empezar un prompt con «Aquí tienes un programa que usa el módulo `jupyturtle`», y luego pegar uno de los ejemplos de este capítulo.\n", + "Después de eso, el asistente virtual debería poder generar código que use este módulo.\n", "\n", - "As an example, ask a VA for a program that draws a Sierpiński triangle.\n", - "The code you get should be a good starting place, but you might have to do some debugging.\n", - "If the first attempt doesn't work, you can tell the VA what happened and ask for help -- or you can debug it yourself." + "Como ejemplo, pide a un asistente virtual un programa que dibuje un triángulo de Sierpiński.\n", + "El código que obtengas debería ser un buen punto de partida, pero quizá tengas que hacer algo de debugging.\n", + "Si el primer intento no funciona, puedes contarle al asistente virtual qué ocurrió y pedir ayuda, o puedes depurarlo por tu cuenta." ] }, { @@ -1488,7 +1487,7 @@ "id": "6a95097a", "metadata": {}, "source": [ - "Here's what the result might look like, although the version you get might be different." + "Este es un posible aspecto del resultado, aunque la versión que obtengas podría ser diferente." ] }, { @@ -1518,9 +1517,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap06.ipynb b/blank/chap06.ipynb index 7fadc4e..f9d5cce 100644 --- a/blank/chap06.ipynb +++ b/blank/chap06.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,16 +25,16 @@ "id": "88ecc443", "metadata": {}, "source": [ - "# Return Values\n", + "# Valores de retorno\n", "\n", - "In previous chapters, we've used built-in functions -- like `abs` and `round` -- and functions in the math module -- like `sqrt` and `pow`.\n", - "When you call one of these functions, it returns a value you can assign to a variable or use as part of an expression.\n", + "En capítulos anteriores, hemos usado funciones integradas -- como `abs` y `round` -- y funciones del módulo math -- como `sqrt` y `pow`.\n", + "Cuando llamas a una de estas funciones, devuelve un valor que puedes asignar a una variable o usar como parte de una expresión.\n", "\n", - "The functions we have written so far are different.\n", - "Some use the `print` function to display values, and some use turtle functions to draw figures.\n", - "But they don't return values we assign to variables or use in expressions.\n", + "Las funciones que hemos escrito hasta ahora son diferentes.\n", + "Algunas usan la función `print` para mostrar valores, y otras usan funciones de turtle para dibujar figuras.\n", + "Pero no devuelven valores que asignemos a variables o usemos en expresiones.\n", "\n", - "In this chapter, we'll see how to write functions that return values." + "En este capítulo veremos cómo escribir funciones que devuelven valores." ] }, { @@ -42,10 +42,10 @@ "id": "6cf2cf80", "metadata": {}, "source": [ - "## Some functions have return values\n", + "## Algunas funciones tienen valores de retorno\n", "\n", - "When you call a function like `math.sqrt`, the result is called a **return value**.\n", - "If the function call appears at the end of a cell, Jupyter displays the return value immediately." + "Cuando llamas a una función como `math.sqrt`, el resultado se llama **valor de retorno**.\n", + "Si la llamada a la función aparece al final de una celda, Jupyter muestra inmediatamente el valor de retorno." ] }, { @@ -61,7 +61,7 @@ "id": "4b4885c2", "metadata": {}, "source": [ - "If you assign the return value to a variable, it doesn't get displayed." + "Si asignas el valor de retorno a una variable, no se muestra." ] }, { @@ -77,7 +77,7 @@ "id": "196c692b", "metadata": {}, "source": [ - "But you can display it later." + "Pero puedes mostrarlo más tarde." ] }, { @@ -93,7 +93,7 @@ "id": "257b28d5", "metadata": {}, "source": [ - "Or you can use the return value as part of an expression." + "O puedes usar el valor de retorno como parte de una expresión." ] }, { @@ -109,7 +109,7 @@ "id": "23ed47ab", "metadata": {}, "source": [ - "Here's an example of a function that returns a value." + "Aquí tienes un ejemplo de una función que devuelve un valor." ] }, { @@ -125,11 +125,12 @@ "id": "273acabc", "metadata": {}, "source": [ - "`circle_area` takes `radius` as a parameter and computes the area of a circle with that radius.\n", + "`circle_area` toma `radius` como parámetro y calcula el área de un círculo con ese radio.\n", "\n", - "The last line is a `return` statement that returns the value of `area`.\n", + "La última línea es una sentencia `return` que devuelve el valor de `area`.\n", "\n", - "If we call the function like this, Jupyter displays the return value.\n" + "Si llamamos a la función así, Jupyter muestra el valor de retorno.\n", + "\n" ] }, { @@ -145,7 +146,7 @@ "id": "4f28bfd6", "metadata": {}, "source": [ - "We can assign the return value to a variable." + "Podemos asignar el valor de retorno a una variable." ] }, { @@ -161,7 +162,7 @@ "id": "3f82fe70", "metadata": {}, "source": [ - "Or use it as part of an expression." + "O usarlo como parte de una expresión." ] }, { @@ -177,7 +178,7 @@ "id": "15122fd2", "metadata": {}, "source": [ - "Later we can display the value of the variable we assigned the result to." + "Más tarde podemos mostrar el valor de la variable a la que asignamos el resultado." ] }, { @@ -193,7 +194,7 @@ "id": "a3f6dcae", "metadata": {}, "source": [ - "But we can't access `area`." + "Pero no podemos acceder a `area`." ] }, { @@ -211,7 +212,7 @@ "id": "f8ace9ce", "metadata": {}, "source": [ - "`area` is a local variable in a function, so we can't access it from outside the function." + "`area` es una variable local dentro de una función, así que no podemos acceder a ella desde fuera de la función." ] }, { @@ -219,10 +220,10 @@ "id": "41a4f03f", "metadata": {}, "source": [ - "## And some have None\n", + "## Y algunas tienen None\n", "\n", - "If a function doesn't have a `return` statement, it returns `None`, which is a special value like `True` and `False`.\n", - "For example, here's the `repeat` function from Chapter 3." + "Si una función no tiene una sentencia `return`, devuelve `None`, que es un valor especial como `True` y `False`.\n", + "Por ejemplo, aquí está la función `repeat` del Capítulo 3." ] }, { @@ -238,7 +239,7 @@ "id": "6ada19cf", "metadata": {}, "source": [ - "If we call it like this, it displays the first line of the Monty Python song \"Finland\"." + "Si la llamamos así, muestra la primera línea de la canción \"Finland\" de Monty Python." ] }, { @@ -254,8 +255,8 @@ "id": "fe49f5e5", "metadata": {}, "source": [ - "This function uses the `print` function to display a string, but it does not use a `return` statement to return a value.\n", - "If we assign the result to a variable, it displays the string anyway. " + "Esta función usa la función `print` para mostrar una cadena, pero no usa una sentencia `return` para devolver un valor.\n", + "Si asignamos el resultado a una variable, muestra la cadena de todos modos. " ] }, { @@ -271,7 +272,7 @@ "id": "4ecabbdb", "metadata": {}, "source": [ - "And if we display the value of the variable, we get nothing." + "Y si mostramos el valor de la variable, no obtenemos nada." ] }, { @@ -287,8 +288,8 @@ "id": "07033959", "metadata": {}, "source": [ - "`result` actually has a value, but Jupyter doesn't show it.\n", - "However, we can display it like this." + "`result` en realidad tiene un valor, pero Jupyter no lo muestra.\n", + "Sin embargo, podemos mostrarlo así." ] }, { @@ -304,9 +305,9 @@ "id": "379b98c5", "metadata": {}, "source": [ - "The return value from `repeat` is `None`.\n", + "El valor de retorno de `repeat` es `None`.\n", "\n", - "Now here's a function similar to `repeat` except that has a return value." + "Ahora aquí tienes una función parecida a `repeat`, excepto que sí tiene un valor de retorno." ] }, { @@ -322,10 +323,10 @@ "id": "db6ad3d4", "metadata": {}, "source": [ - "Notice that we can use an expression in a `return` statement, not just a variable.\n", + "Observa que podemos usar una expresión en una sentencia `return`, no solo una variable.\n", "\n", - "With this version, we can assign the result to a variable.\n", - "When the function runs, it doesn't display anything." + "Con esta versión, podemos asignar el resultado a una variable.\n", + "Cuando la función se ejecuta, no muestra nada." ] }, { @@ -341,7 +342,7 @@ "id": "1232cd8a", "metadata": {}, "source": [ - "But later we can display the value assigned to `line`." + "Pero más tarde podemos mostrar el valor asignado a `line`." ] }, { @@ -357,7 +358,7 @@ "id": "ae02c7d2", "metadata": {}, "source": [ - "A function like this is called a **pure function** because it doesn't display anything or have any other effect -- other than returning a value." + "Una función como esta se llama **función pura** porque no muestra nada ni tiene ningún otro efecto -- aparte de devolver un valor." ] }, { @@ -365,9 +366,9 @@ "id": "567ae734", "metadata": {}, "source": [ - "## Return values and conditionals\n", + "## Valores de retorno y condicionales\n", "\n", - "If Python did not provide `abs`, we could write it like this." + "Si Python no proporcionara `abs`, podríamos escribirla así." ] }, { @@ -383,12 +384,12 @@ "id": "ffd559b8", "metadata": {}, "source": [ - "If `x` is negative, the first `return` statement returns `-x` and the function ends immediately.\n", - "Otherwise, the second `return` statement returns `x` and the function ends.\n", - "So this function is correct.\n", + "Si `x` es negativo, la primera sentencia `return` devuelve `-x` y la función termina inmediatamente.\n", + "En caso contrario, la segunda sentencia `return` devuelve `x` y la función termina.\n", + "Así que esta función es correcta.\n", "\n", - "However, if you put `return` statements in a conditional, you have to make sure that every possible path through the program hits a `return` statement.\n", - "For example, here's an incorrect version of `absolute_value`." + "Sin embargo, si pones sentencias `return` en un condicional, tienes que asegurarte de que todos los caminos posibles del programa lleguen a una sentencia `return`.\n", + "Por ejemplo, aquí tienes una versión incorrecta de `absolute_value`." ] }, { @@ -404,7 +405,7 @@ "id": "da3280ae", "metadata": {}, "source": [ - "Here's what happens if we call this function with `0` as an argument." + "Esto es lo que ocurre si llamamos a esta función con `0` como argumento." ] }, { @@ -420,9 +421,9 @@ "id": "5733f239", "metadata": {}, "source": [ - "We get nothing! Here's the problem: when `x` is `0`, neither condition is true, and the function ends without hitting a `return` statement, which means that the return value is `None`, so Jupyter displays nothing.\n", + "¡No obtenemos nada! Este es el problema: cuando `x` es `0`, ninguna condición es verdadera, y la función termina sin llegar a una sentencia `return`, lo que significa que el valor de retorno es `None`, así que Jupyter no muestra nada.\n", "\n", - "As another example, here's a version of `absolute_value` with an extra `return` statement at the end." + "Como otro ejemplo, aquí tienes una versión de `absolute_value` con una sentencia `return` adicional al final." ] }, { @@ -438,12 +439,12 @@ "id": "cf5486fd", "metadata": {}, "source": [ - "If `x` is negative, the first `return` statement runs and the function ends.\n", - "Otherwise the second `return` statement runs and the function ends.\n", - "Either way, we never get to the third `return` statement -- so it can never run.\n", + "Si `x` es negativo, se ejecuta la primera sentencia `return` y la función termina.\n", + "En caso contrario, se ejecuta la segunda sentencia `return` y la función termina.\n", + "De cualquier manera, nunca llegamos a la tercera sentencia `return` -- así que nunca puede ejecutarse.\n", "\n", - "Code that can never run is called **dead code**.\n", - "In general, dead code doesn't do any harm, but it often indicates a misunderstanding, and it might be confusing to someone trying to understand the program." + "El código que nunca puede ejecutarse se llama **código muerto**.\n", + "En general, el código muerto no hace daño, pero a menudo indica un malentendido y podría confundir a alguien que intenta entender el programa." ] }, { @@ -453,22 +454,22 @@ "tags": [] }, "source": [ - "## Incremental development\n", + "## Desarrollo incremental\n", "\n", - "As you write larger functions, you might find yourself spending more\n", - "time debugging.\n", - "To deal with increasingly complex programs, you might want to try **incremental development**, which is a way of adding and testing only a small amount of code at a time.\n", + "A medida que escribas funciones más grandes, puede que notes que pasas más\n", + "tiempo depurando.\n", + "Para enfrentarte a programas cada vez más complejos, quizá quieras probar el **desarrollo incremental**, que es una forma de añadir y probar solo una pequeña cantidad de código cada vez.\n", "\n", - "As an example, suppose you want to find the distance between two points represented by the coordinates $(x_1, y_1)$ and $(x_2, y_2)$.\n", - "By the Pythagorean theorem, the distance is:\n", + "Como ejemplo, supón que quieres encontrar la distancia entre dos puntos representados por las coordenadas $(x_1, y_1)$ y $(x_2, y_2)$.\n", + "Por el teorema de Pitágoras, la distancia es:\n", "\n", "$$\\mathrm{distance} = \\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$ \n", "\n", - "The first step is to consider what a `distance` function should look like in Python -- that is, what are the inputs (parameters) and what is the output (return value)?\n", + "El primer paso es considerar cómo debería ser una función `distance` en Python -- es decir, cuáles son las entradas (parámetros) y cuál es la salida (valor de retorno).\n", "\n", - "For this function, the inputs are the coordinates of the points.\n", - "The return value is the distance.\n", - "Immediately you can write an outline of the function:" + "Para esta función, las entradas son las coordenadas de los puntos.\n", + "El valor de retorno es la distancia.\n", + "De inmediato puedes escribir un esquema de la función:" ] }, { @@ -484,10 +485,10 @@ "id": "7b384fcf", "metadata": {}, "source": [ - "This version doesn't compute distances yet -- it always returns zero.\n", - "But it is a complete function with a return value, which means that you can test it before you make it more complicated.\n", + "Esta versión todavía no calcula distancias -- siempre devuelve cero.\n", + "Pero es una función completa con un valor de retorno, lo que significa que puedes probarla antes de hacerla más complicada.\n", "\n", - "To test the new function, we'll call it with sample arguments:" + "Para probar la nueva función, la llamaremos con argumentos de ejemplo:" ] }, { @@ -503,13 +504,13 @@ "id": "13a98096", "metadata": {}, "source": [ - "I chose these values so that the horizontal distance is `3` and the\n", - "vertical distance is `4`.\n", - "That way, the result is `5`, the hypotenuse of a `3-4-5` right triangle. When testing a function, it is useful to know the right answer.\n", + "Elegí estos valores para que la distancia horizontal sea `3` y la\n", + "distancia vertical sea `4`.\n", + "Así, el resultado es `5`, la hipotenusa de un triángulo rectángulo `3-4-5`. Al probar una función, es útil conocer la respuesta correcta.\n", "\n", - "At this point we have confirmed that the function runs and returns a value, and we can start adding code to the body.\n", - "A good next step is to find the differences `x2 - x1` and `y2 - y1`. \n", - "Here's a version that stores those values in temporary variables and displays them." + "En este punto hemos confirmado que la función se ejecuta y devuelve un valor, y podemos empezar a añadir código al cuerpo.\n", + "Un buen siguiente paso es encontrar las diferencias `x2 - x1` e `y2 - y1`. \n", + "Aquí tienes una versión que almacena esos valores en variables temporales y los muestra." ] }, { @@ -525,10 +526,10 @@ "id": "c342a3bd", "metadata": {}, "source": [ - "If the function is working, it should display `dx is 3` and `dy is 4`.\n", - "If so, we know that the function is getting the right arguments and\n", - "performing the first computation correctly. If not, there are only a few\n", - "lines to check." + "Si la función funciona, debería mostrar `dx is 3` y `dy is 4`.\n", + "Si es así, sabemos que la función está recibiendo los argumentos correctos y\n", + "realizando correctamente el primer cálculo. Si no, solo hay unas pocas\n", + "líneas que revisar." ] }, { @@ -544,7 +545,7 @@ "id": "9424eca9", "metadata": {}, "source": [ - "Good so far. Next we compute the sum of squares of `dx` and `dy`:" + "Hasta aquí, bien. A continuación calculamos la suma de los cuadrados de `dx` e `dy`:" ] }, { @@ -560,7 +561,7 @@ "id": "e28262f9", "metadata": {}, "source": [ - "Again, we can run the function and check the output, which should be `25`. " + "De nuevo, podemos ejecutar la función y comprobar la salida, que debería ser `25`. " ] }, { @@ -576,7 +577,7 @@ "id": "c09f0ddc", "metadata": {}, "source": [ - "Finally, we can use `math.sqrt` to compute the distance:" + "Por último, podemos usar `math.sqrt` para calcular la distancia:" ] }, { @@ -592,7 +593,7 @@ "id": "f27902ac", "metadata": {}, "source": [ - "And test it." + "Y probarla." ] }, { @@ -608,9 +609,9 @@ "id": "8ad2e626", "metadata": {}, "source": [ - "The result is correct, but this version of the function displays the result rather than returning it, so the return value is `None`.\n", + "El resultado es correcto, pero esta versión de la función muestra el resultado en lugar de devolverlo, así que el valor de retorno es `None`.\n", "\n", - "We can fix that by replacing the `print` function with a `return` statement." + "Podemos arreglarlo sustituyendo la función `print` por una sentencia `return`." ] }, { @@ -626,8 +627,8 @@ "id": "f3a13a14", "metadata": {}, "source": [ - "This version of `distance` is a pure function.\n", - "If we call it like this, only the result is displayed." + "Esta versión de `distance` es una función pura.\n", + "Si la llamamos así, solo se muestra el resultado." ] }, { @@ -643,7 +644,7 @@ "id": "7db8cf86", "metadata": {}, "source": [ - "And if we assign the result to a variable, nothing is displayed." + "Y si asignamos el resultado a una variable, no se muestra nada." ] }, { @@ -659,20 +660,20 @@ "id": "0c3b8829", "metadata": {}, "source": [ - "The `print` statements we wrote are useful for debugging, but once the function is working, we can remove them. \n", - "Code like that is called **scaffolding** because it is helpful for building the program but is not part of the final product.\n", + "Las sentencias `print` que escribimos son útiles para depurar, pero una vez que la función funciona, podemos eliminarlas. \n", + "El código de ese tipo se llama **andamiaje** porque ayuda a construir el programa, pero no forma parte del producto final.\n", "\n", - "This example demonstrates incremental development.\n", - "The key aspects of this process are:\n", + "Este ejemplo demuestra el desarrollo incremental.\n", + "Los aspectos clave de este proceso son:\n", "\n", - "1. Start with a working program, make small changes, and test after every change.\n", + "1. Empieza con un programa que funcione, haz cambios pequeños y prueba después de cada cambio.\n", "\n", - "2. Use variables to hold intermediate values so you can display and check them.\n", + "2. Usa variables para guardar valores intermedios, de modo que puedas mostrarlos y comprobarlos.\n", "\n", - "3. Once the program is working, remove the scaffolding.\n", + "3. Una vez que el programa funcione, elimina el andamiaje.\n", "\n", - "At any point, if there is an error, you should have a good idea where it is.\n", - "Incremental development can save you a lot of debugging time." + "En cualquier punto, si hay un error, deberías tener una buena idea de dónde está.\n", + "El desarrollo incremental puede ahorrarte mucho tiempo de debugging." ] }, { @@ -680,10 +681,10 @@ "id": "3dd7514f", "metadata": {}, "source": [ - "## Boolean functions\n", + "## Funciones booleanas\n", "\n", - "Functions can return the boolean values `True` and `False`, which is often convenient for encapsulating a complex test in a function.\n", - "For example, `is_divisible` checks whether `x` is divisible by `y` with no remainder." + "Las funciones pueden devolver los valores booleanos `True` y `False`, lo que a menudo resulta conveniente para encapsular una prueba compleja en una función.\n", + "Por ejemplo, `is_divisible` comprueba si `x` es divisible por `y` sin resto." ] }, { @@ -699,7 +700,7 @@ "id": "f3a58afb", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como la usamos." ] }, { @@ -723,8 +724,8 @@ "id": "e9103ece", "metadata": {}, "source": [ - "Inside the function, the result of the `==` operator is a boolean, so we can write the\n", - "function more concisely by returning it directly." + "Dentro de la función, el resultado del operador `==` es un booleano, así que podemos escribir la\n", + "función de forma más concisa devolviéndolo directamente." ] }, { @@ -740,7 +741,7 @@ "id": "4d82dae5", "metadata": {}, "source": [ - "Boolean functions are often used in conditional statements." + "Las funciones booleanas se usan a menudo en sentencias condicionales." ] }, { @@ -756,7 +757,7 @@ "id": "9e232afc", "metadata": {}, "source": [ - "It might be tempting to write something like this:" + "Podría ser tentador escribir algo como esto:" ] }, { @@ -772,7 +773,7 @@ "id": "ff9e5160", "metadata": {}, "source": [ - "But the comparison is unnecessary." + "Pero la comparación es innecesaria." ] }, { @@ -780,27 +781,27 @@ "id": "a932a966", "metadata": {}, "source": [ - "## Recursion with return values\n", + "## Recursión con valores de retorno\n", "\n", - "Now that we can write functions with return values, we can write recursive functions with return values, and with that capability, we have passed an important threshold -- the subset of Python we have is now **Turing complete**, which means that we can perform any computation that can be described by an algorithm.\n", + "Ahora que podemos escribir funciones con valores de retorno, podemos escribir funciones recursivas con valores de retorno, y con esa capacidad hemos cruzado un umbral importante -- el subconjunto de Python que tenemos ahora es **Turing completo**, lo que significa que podemos realizar cualquier cálculo que pueda describirse mediante un algoritmo.\n", "\n", - "To demonstrate recursion with return values, we'll evaluate a few recursively defined mathematical functions.\n", - "A recursive definition is similar to a circular definition, in the sense that the definition refers to the thing being defined. A truly circular definition is not very useful:\n", + "Para demostrar la recursión con valores de retorno, evaluaremos algunas funciones matemáticas definidas de forma recursiva.\n", + "Una definición recursiva se parece a una definición circular, en el sentido de que la definición se refiere a la cosa que se está definiendo. Una definición verdaderamente circular no es muy útil:\n", "\n", - "> vorpal: An adjective used to describe something that is vorpal.\n", + "> vorpal: Un adjetivo usado para describir algo que es vorpal.\n", "\n", - "If you saw that definition in the dictionary, you might be annoyed. \n", - "On the other hand, if you looked up the definition of the factorial function, denoted with the symbol $!$, you might get something like this: \n", + "Si vieras esa definición en el diccionario, quizá te molestaría. \n", + "Por otro lado, si buscaras la definición de la función factorial, denotada con el símbolo $!$, podrías encontrar algo como esto: \n", "\n", - "$$\\begin{aligned}\n", - "0! &= 1 \\\\\n", + "$$\begin{aligned}\n", + "0! &= 1 \\\n", "n! &= n~(n-1)!\n", "\\end{aligned}$$ \n", "\n", - "This definition says that the factorial of $0$ is $1$, and the factorial of any other value, $n$, is $n$ multiplied by the factorial of $n-1$.\n", + "Esta definición dice que el factorial de $0$ es $1$, y que el factorial de cualquier otro valor, $n$, es $n$ multiplicado por el factorial de $n-1$.\n", "\n", - "If you can write a recursive definition of something, you can write a Python program to evaluate it. \n", - "Following an incremental development process, we'll start with a function that take `n` as a parameter and always returns `0`." + "Si puedes escribir una definición recursiva de algo, puedes escribir un programa en Python para evaluarlo. \n", + "Siguiendo un proceso de desarrollo incremental, empezaremos con una función que toma `n` como parámetro y siempre devuelve `0`." ] }, { @@ -816,7 +817,7 @@ "id": "ee1f63b8", "metadata": {}, "source": [ - "Now let's add the first part of the definition -- if the argument happens to be `0`, all we have to do is return `1`:" + "Ahora añadamos la primera parte de la definición -- si resulta que el argumento es `0`, todo lo que tenemos que hacer es devolver `1`:" ] }, { @@ -832,8 +833,8 @@ "id": "4f2fd7c7", "metadata": {}, "source": [ - "Now let's fill in the second part -- if `n` is not `0`, we have to make a recursive\n", - "call to find the factorial of `n-1` and then multiply the result by `n`:" + "Ahora completemos la segunda parte -- si `n` no es `0`, tenemos que hacer una llamada recursiva\n", + "para encontrar el factorial de `n-1` y luego multiplicar el resultado por `n`:" ] }, { @@ -849,32 +850,32 @@ "id": "da3d1595", "metadata": {}, "source": [ - "The flow of execution for this program is similar to the flow of `countdown` in Chapter 5.\n", - "If we call `factorial` with the value `3`:\n", + "El flujo de ejecución de este programa es similar al flujo de `countdown` en el Capítulo 5.\n", + "Si llamamos a `factorial` con el valor `3`:\n", "\n", - "Since `3` is not `0`, we take the second branch and calculate the factorial\n", - "of `n-1`\\...\n", + "Como `3` no es `0`, tomamos la segunda rama y calculamos el factorial\n", + "de `n-1`\\...\n", "\n", - "> Since `2` is not `0`, we take the second branch and calculate the\n", - "> factorial of `n-1`\\...\n", + "> Como `2` no es `0`, tomamos la segunda rama y calculamos el\n", + "> factorial de `n-1`\\...\n", ">\n", - "> > Since `1` is not `0`, we take the second branch and calculate the\n", - "> > factorial of `n-1`\\...\n", + "> > Como `1` no es `0`, tomamos la segunda rama y calculamos el\n", + "> > factorial de `n-1`\\...\n", "> >\n", - "> > > Since `0` equals `0`, we take the first branch and return `1` without\n", - "> > > making any more recursive calls.\n", + "> > > Como `0` es igual a `0`, tomamos la primera rama y devolvemos `1` sin\n", + "> > > hacer más llamadas recursivas.\n", "> >\n", - "> > The return value, `1`, is multiplied by `n`, which is `1`, and the\n", - "> > result is returned.\n", + "> > El valor de retorno, `1`, se multiplica por `n`, que es `1`, y se\n", + "> > devuelve el resultado.\n", ">\n", - "> The return value, `1`, is multiplied by `n`, which is `2`, and the result\n", - "> is returned.\n", + "> El valor de retorno, `1`, se multiplica por `n`, que es `2`, y se devuelve\n", + "> el resultado.\n", "\n", - "The return value `2` is multiplied by `n`, which is `3`, and the result,\n", - "`6`, becomes the return value of the function call that started the whole\n", - "process.\n", + "El valor de retorno `2` se multiplica por `n`, que es `3`, y el resultado,\n", + "`6`, se convierte en el valor de retorno de la llamada a la función que inició todo el\n", + "proceso.\n", "\n", - "The following figure shows the stack diagram for this sequence of function calls." + "La figura siguiente muestra el diagrama de pila para esta secuencia de llamadas a funciones." ] }, { @@ -902,10 +903,10 @@ "id": "f924c539", "metadata": {}, "source": [ - "The return values are shown being passed back up the stack.\n", - "In each frame, the return value is the product of `n` and `recurse`.\n", + "Los valores de retorno se muestran pasando de vuelta hacia arriba por la pila.\n", + "En cada marco, el valor de retorno es el producto de `n` y `recurse`.\n", "\n", - "In the last frame, the local variable `recurse` does not exist because the branch that creates it does not run." + "En el último marco, la variable local `recurse` no existe porque la rama que la crea no se ejecuta." ] }, { @@ -913,20 +914,20 @@ "id": "acea9dc1", "metadata": {}, "source": [ - "## Leap of faith\n", + "## Salto de fe\n", "\n", - "Following the flow of execution is one way to read programs, but it can quickly become overwhelming. An alternative is what I call the \"leap of faith\". When you come to a function call, instead of following the flow of execution, you *assume* that the function works correctly and returns the right result.\n", + "Seguir el flujo de ejecución es una forma de leer programas, pero puede volverse abrumadora rápidamente. Una alternativa es lo que llamo el \"salto de fe\". Cuando llegas a una llamada a una función, en lugar de seguir el flujo de ejecución, *asumes* que la función funciona correctamente y devuelve el resultado adecuado.\n", "\n", - "In fact, you are already practicing this leap of faith when you use built-in functions.\n", - "When you call `abs` or `math.sqrt`, you don't examine the bodies of those functions -- you just assume that they work.\n", + "De hecho, ya estás practicando este salto de fe cuando usas funciones integradas.\n", + "Cuando llamas a `abs` o `math.sqrt`, no examinas los cuerpos de esas funciones -- simplemente asumes que funcionan.\n", "\n", - "The same is true when you call one of your own functions. For example, earlier we wrote a function called `is_divisible` that determines whether one number is divisible by another. Once we convince ourselves that this function is correct, we can use it without looking at the body again.\n", + "Lo mismo ocurre cuando llamas a una de tus propias funciones. Por ejemplo, antes escribimos una función llamada `is_divisible` que determina si un número es divisible por otro. Una vez que nos convencemos de que esta función es correcta, podemos usarla sin volver a mirar el cuerpo.\n", "\n", - "The same is true of recursive programs.\n", - "When you get to the recursive call, instead of following the flow of execution, you should assume that the recursive call works and then ask yourself, \"Assuming that I can compute the factorial of $n-1$, can I compute the factorial of $n$?\"\n", - "The recursive definition of factorial implies that you can, by multiplying by $n$.\n", + "Lo mismo ocurre con los programas recursivos.\n", + "Cuando llegas a la llamada recursiva, en lugar de seguir el flujo de ejecución, deberías asumir que la llamada recursiva funciona y luego preguntarte: \"Suponiendo que puedo calcular el factorial de $n-1$, ¿puedo calcular el factorial de $n$?\"\n", + "La definición recursiva del factorial implica que sí puedes, multiplicando por $n$.\n", "\n", - "Of course, it's a bit strange to assume that the function works correctly when you haven't finished writing it, but that's why it's called a leap of faith!" + "Por supuesto, es un poco extraño asumir que la función funciona correctamente cuando aún no has terminado de escribirla, ¡pero por eso se llama salto de fe!" ] }, { @@ -938,15 +939,15 @@ "source": [ "## Fibonacci\n", "\n", - "After `factorial`, the most common example of a recursive function is `fibonacci`, which has the following definition: \n", + "Después de `factorial`, el ejemplo más común de función recursiva es `fibonacci`, que tiene la siguiente definición: \n", "\n", - "$$\\begin{aligned}\n", - "\\mathrm{fibonacci}(0) &= 0 \\\\\n", - "\\mathrm{fibonacci}(1) &= 1 \\\\\n", + "$$\begin{aligned}\n", + "\\mathrm{fibonacci}(0) &= 0 \\\n", + "\\mathrm{fibonacci}(1) &= 1 \\\n", "\\mathrm{fibonacci}(n) &= \\mathrm{fibonacci}(n-1) + \\mathrm{fibonacci}(n-2)\n", "\\end{aligned}$$ \n", "\n", - "Translated into Python, it looks like this:" + "Traducida a Python, se ve así:" ] }, { @@ -962,11 +963,11 @@ "id": "69d56a0b", "metadata": {}, "source": [ - "If you try to follow the flow of execution here, even for small values of $n$, your head explodes.\n", - "But according to the leap of faith, if you assume that the two recursive calls work correctly, you can be confident that the last `return` statement is correct.\n", + "Si intentas seguir aquí el flujo de ejecución, incluso para valores pequeños de $n$, te explota la cabeza.\n", + "Pero según el salto de fe, si asumes que las dos llamadas recursivas funcionan correctamente, puedes confiar en que la última sentencia `return` es correcta.\n", "\n", - "As an aside, this way of computing Fibonacci numbers is very inefficient.\n", - "In [Chapter 10](section_memos) I'll explain why and suggest a way to improve it." + "Como nota aparte, esta forma de calcular números de Fibonacci es muy ineficiente.\n", + "En el [Capítulo 10](section_memos) explicaré por qué y sugeriré una forma de mejorarla." ] }, { @@ -974,9 +975,9 @@ "id": "26d9706b", "metadata": {}, "source": [ - "## Checking types\n", + "## Comprobación de tipos\n", "\n", - "What happens if we call `factorial` and give it `1.5` as an argument?" + "¿Qué ocurre si llamamos a `factorial` y le damos `1.5` como argumento?" ] }, { @@ -994,17 +995,17 @@ "id": "0bec7ba4", "metadata": {}, "source": [ - "It looks like an infinite recursion. How can that be? The function has a\n", - "base case -- when `n == 0`.\n", - "But if `n` is not an integer, we can *miss* the base case and recurse forever.\n", + "Parece una recursión infinita. ¿Cómo puede ser? La función tiene un\n", + "caso base -- cuando `n == 0`.\n", + "Pero si `n` no es un entero, podemos *saltarnos* el caso base y hacer recursión para siempre.\n", "\n", - "In this example, the initial value of `n` is `1.5`.\n", - "In the first recursive call, the value of `n` is `0.5`.\n", - "In the next, it is `-0.5`. \n", - "From there, it gets smaller (more negative), but it will never be `0`.\n", + "En este ejemplo, el valor inicial de `n` es `1.5`.\n", + "En la primera llamada recursiva, el valor de `n` es `0.5`.\n", + "En la siguiente, es `-0.5`. \n", + "A partir de ahí, se hace más pequeño (más negativo), pero nunca será `0`.\n", "\n", - "To avoid infinite recursion we can use the built-in function `isinstance` to check the type of the argument.\n", - "Here's how we check whether a value is an integer." + "Para evitar la recursión infinita podemos usar la función integrada `isinstance` para comprobar el tipo del argumento.\n", + "Así comprobamos si un valor es un entero." ] }, { @@ -1028,7 +1029,7 @@ "id": "b0017b42", "metadata": {}, "source": [ - "Now here's a version of `factorial` with error-checking." + "Ahora aquí tienes una versión de `factorial` con comprobación de errores." ] }, { @@ -1044,8 +1045,9 @@ "id": "0561e3f5", "metadata": {}, "source": [ - "First it checks whether `n` is an integer.\n", - "If not, it displays an error message and returns `None`.\n", + "Primero comprueba si `n` es un entero.\n", + "Si no lo es, muestra un mensaje de error y devuelve `None`.\n", + "\n", "\n" ] }, @@ -1062,8 +1064,8 @@ "id": "10b00a39", "metadata": {}, "source": [ - "Then it checks whether `n` is negative.\n", - "If so, it displays an error message and returns `None.`" + "Luego comprueba si `n` es negativo.\n", + "Si lo es, muestra un mensaje de error y devuelve `None`." ] }, { @@ -1079,8 +1081,8 @@ "id": "96aa1403", "metadata": {}, "source": [ - "If we get past both checks, we know that `n` is a non-negative integer, so we can be confident the recursion will terminate.\n", - "Checking the parameters of a function to make sure they have the correct types and values is called **input validation**." + "Si superamos ambas comprobaciones, sabemos que `n` es un entero no negativo, así que podemos confiar en que la recursión terminará.\n", + "Comprobar los parámetros de una función para asegurarse de que tienen los tipos y valores correctos se llama **validación de entrada**." ] }, { @@ -1092,25 +1094,25 @@ "source": [ "## Debugging\n", "\n", - "Breaking a large program into smaller functions creates natural checkpoints for debugging.\n", - "If a function is not working, there are three possibilities to consider:\n", + "Dividir un programa grande en funciones más pequeñas crea puntos de control naturales para depurar.\n", + "Si una función no funciona, hay tres posibilidades que considerar:\n", "\n", - "- There is something wrong with the arguments the function is getting -- that is, a precondition is violated.\n", + "- Hay algo mal con los argumentos que recibe la función -- es decir, se viola una precondición.\n", "\n", - "- There is something wrong with the function -- that is, a postcondition is violated.\n", + "- Hay algo mal con la función -- es decir, se viola una postcondición.\n", "\n", - "- The caller is doing something wrong with the return value.\n", + "- Quien llama a la función está haciendo algo mal con el valor de retorno.\n", "\n", - "To rule out the first possibility, you can add a `print` statement at the beginning of the function that displays the values of the parameters (and maybe their types).\n", - "Or you can write code that checks the preconditions explicitly.\n", + "Para descartar la primera posibilidad, puedes añadir una sentencia `print` al principio de la función que muestre los valores de los parámetros (y quizá sus tipos).\n", + "O puedes escribir código que compruebe explícitamente las precondiciones.\n", "\n", - "If the parameters look good, you can add a `print` statement before each `return` statement and display the return value.\n", - "If possible, call the function with arguments that make it easy check the result. \n", + "Si los parámetros parecen correctos, puedes añadir una sentencia `print` antes de cada sentencia `return` y mostrar el valor de retorno.\n", + "Si es posible, llama a la función con argumentos que faciliten comprobar el resultado. \n", "\n", - "If the function seems to be working, look at the function call to make sure the return value is being used correctly -- or used at all!\n", + "Si la función parece funcionar, mira la llamada a la función para asegurarte de que el valor de retorno se está usando correctamente -- ¡o de que se está usando siquiera!\n", "\n", - "Adding `print` statements at the beginning and end of a function can help make the flow of execution more visible.\n", - "For example, here is a version of `factorial` with print statements:" + "Añadir sentencias `print` al principio y al final de una función puede ayudar a hacer más visible el flujo de ejecución.\n", + "Por ejemplo, aquí tienes una versión de `factorial` con sentencias print:" ] }, { @@ -1126,8 +1128,8 @@ "id": "0c044111", "metadata": {}, "source": [ - "`space` is a string of space characters that controls the indentation of\n", - "the output. Here is the result of `factorial(3)` :" + "`space` es una cadena de caracteres de espacio que controla la indentación de\n", + "la salida. Este es el resultado de `factorial(3)` :" ] }, { @@ -1143,8 +1145,8 @@ "id": "43b3e408", "metadata": {}, "source": [ - "If you are confused about the flow of execution, this kind of output can be helpful.\n", - "It takes some time to develop effective scaffolding, but a little bit of scaffolding can save a lot of debugging." + "Si tienes dudas sobre el flujo de ejecución, este tipo de salida puede ser útil.\n", + "Lleva tiempo desarrollar andamiaje eficaz, pero un poco de andamiaje puede ahorrar mucho debugging." ] }, { @@ -1152,29 +1154,29 @@ "id": "b7c3962f", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**return value:**\n", - "The result of a function. If a function call is used as an expression, the return value is the value of the expression.\n", + "**valor de retorno:**\n", + "El resultado de una función. Si una llamada a una función se usa como expresión, el valor de retorno es el valor de la expresión.\n", "\n", - "**pure function:**\n", - "A function that does not display anything or have any other effect, other than returning a return value.\n", + "**función pura:**\n", + "Una función que no muestra nada ni tiene ningún otro efecto, aparte de devolver un valor de retorno.\n", "\n", "\n", - "**dead code:**\n", - "Part of a program that can never run, often because it appears after a `return` statement.\n", + "**código muerto:**\n", + "Parte de un programa que nunca puede ejecutarse, a menudo porque aparece después de una sentencia `return`.\n", "\n", - "**incremental development:**\n", - "A program development plan intended to avoid debugging by adding and testing only a small amount of code at a time.\n", + "**desarrollo incremental:**\n", + "Un plan de desarrollo de programas pensado para evitar la depuración añadiendo y probando solo una pequeña cantidad de código cada vez.\n", "\n", - "**scaffolding:**\n", - " Code that is used during program development but is not part of the final version.\n", + "**andamiaje:**\n", + " Código que se usa durante el desarrollo del programa pero que no forma parte de la versión final.\n", "\n", - "**Turing complete:**\n", - "A language, or subset of a language, is Turing complete if it can perform any computation that can be described by an algorithm.\n", + "**Turing completo:**\n", + "Un lenguaje, o un subconjunto de un lenguaje, es Turing completo si puede realizar cualquier cálculo que pueda describirse mediante un algoritmo.\n", "\n", - "**input validation:**\n", - "Checking the parameters of a function to make sure they have the correct types and values" + "**validación de entrada:**\n", + "Comprobar los parámetros de una función para asegurarse de que tienen los tipos y valores correctos" ] }, { @@ -1182,7 +1184,7 @@ "id": "ff7b1edf", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1200,9 +1202,9 @@ "id": "0da2daaf", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, we saw an incorrect function that can end without returning a value." + "En este capítulo vimos una función incorrecta que puede terminar sin devolver un valor." ] }, { @@ -1218,7 +1220,7 @@ "id": "69563d4b", "metadata": {}, "source": [ - "And a version of the same function that has dead code at the end." + "Y una versión de la misma función que tiene código muerto al final." ] }, { @@ -1234,7 +1236,7 @@ "id": "9fe8ae2e", "metadata": {}, "source": [ - "And we saw the following example, which is correct but not idiomatic." + "Y vimos el siguiente ejemplo, que es correcto pero no idiomático." ] }, { @@ -1250,9 +1252,9 @@ "id": "14f52688", "metadata": {}, "source": [ - "Ask a virtual assistant what's wrong with each of these functions and see if it can spot the errors or improve the style.\n", + "Pregunta a un asistente virtual qué está mal en cada una de estas funciones y comprueba si puede detectar los errores o mejorar el estilo.\n", "\n", - "Then ask \"Write a function that takes coordinates of two points and computes the distance between them.\" See if the result resembles the version of `distance` we wrote in this chapter." + "Luego pregunta: \"Escribe una función que tome las coordenadas de dos puntos y calcule la distancia entre ellos.\" Comprueba si el resultado se parece a la versión de `distance` que escribimos en este capítulo." ] }, { @@ -1260,14 +1262,14 @@ "id": "fd23bb60", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Use incremental development to write a function called `hypot` that returns the length of the hypotenuse of a right triangle given the lengths of the other two legs as arguments.\n", + "Usa desarrollo incremental para escribir una función llamada `hypot` que devuelva la longitud de la hipotenusa de un triángulo rectángulo dadas las longitudes de los otros dos catetos como argumentos.\n", "\n", - "Note: There's a function in the math module called `hypot` that does the same thing, but you should not use it for this exercise!\n", + "Nota: Hay una función en el módulo math llamada `hypot` que hace lo mismo, ¡pero no deberías usarla para este ejercicio!\n", "\n", - "Even if you can write the function correctly on the first try, start with a function that always returns `0` and practice making small changes, testing as you go.\n", - "When you are done, the function should only return a value -- it should not display anything." + "Aunque puedas escribir la función correctamente al primer intento, empieza con una función que siempre devuelva `0` y practica haciendo cambios pequeños, probando a medida que avanzas.\n", + "Cuando termines, la función solo debería devolver un valor -- no debería mostrar nada." ] }, { @@ -1355,10 +1357,10 @@ "id": "0a66d82a", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a boolean function, `is_between(x, y, z)`, that returns `True` if $x < y < z$ or if \n", - "$z < y < x$, and`False` otherwise." + "Escribe una función booleana, `is_between(x, y, z)`, que devuelva `True` si $x < y < z$ o si \n", + "$z < y < x$, y `False` en caso contrario." ] }, { @@ -1376,7 +1378,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1424,20 +1426,20 @@ "id": "57f06466", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The Ackermann function, $A(m, n)$, is defined:\n", + "La función de Ackermann, $A(m, n)$, se define así:\n", "\n", - "$$\\begin{aligned}\n", - "A(m, n) = \\begin{cases} \n", - " n+1 & \\mbox{if } m = 0 \\\\ \n", - " A(m-1, 1) & \\mbox{if } m > 0 \\mbox{ and } n = 0 \\\\ \n", + "$$\begin{aligned}\n", + "A(m, n) = \begin{cases} \n", + " n+1 & \\mbox{if } m = 0 \\ \n", + " A(m-1, 1) & \\mbox{if } m > 0 \\mbox{ and } n = 0 \\ \n", "A(m-1, A(m, n-1)) & \\mbox{if } m > 0 \\mbox{ and } n > 0.\n", "\\end{cases} \n", "\\end{aligned}$$ \n", "\n", - "Write a function named `ackermann` that evaluates the Ackermann function.\n", - "What happens if you call `ackermann(5, 5)`?" + "Escribe una función llamada `ackermann` que evalúe la función de Ackermann.\n", + "¿Qué ocurre si llamas a `ackermann(5, 5)`?" ] }, { @@ -1455,7 +1457,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1495,7 +1497,7 @@ "tags": [] }, "source": [ - "If you call this function with values bigger than 4, you get a `RecursionError`." + "Si llamas a esta función con valores mayores que 4, obtienes un `RecursionError`." ] }, { @@ -1515,7 +1517,7 @@ "tags": [] }, "source": [ - "To see why, add a print statement to the beginning of the function to display the values of the parameters, and then run the examples again." + "Para ver por qué, añade una sentencia print al principio de la función para mostrar los valores de los parámetros, y luego ejecuta los ejemplos de nuevo." ] }, { @@ -1525,12 +1527,12 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A number, $a$, is a power of $b$ if it is divisible by $b$ and $a/b$ is\n", - "a power of $b$. Write a function called `is_power` that takes parameters\n", - "`a` and `b` and returns `True` if `a` is a power of `b`. Note: you will\n", - "have to think about the base case." + "Un número, $a$, es una potencia de $b$ si es divisible por $b$ y $a/b$ es\n", + "una potencia de $b$. Escribe una función llamada `is_power` que tome los parámetros\n", + "`a` y `b`, y devuelva `True` si `a` es una potencia de `b`. Nota: tendrás\n", + "que pensar en el caso base." ] }, { @@ -1548,7 +1550,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1596,17 +1598,17 @@ "id": "a33bbd07", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The greatest common divisor (GCD) of $a$ and $b$ is the largest number\n", - "that divides both of them with no remainder.\n", + "El máximo común divisor (MCD) de $a$ y $b$ es el número más grande\n", + "que divide a ambos sin dejar resto.\n", "\n", - "One way to find the GCD of two numbers is based on the observation that\n", - "if $r$ is the remainder when $a$ is divided by $b$, then $gcd(a,\n", - "b) = gcd(b, r)$. As a base case, we can use $gcd(a, 0) = a$.\n", + "Una forma de encontrar el MCD de dos números se basa en la observación de que\n", + "si $r$ es el resto cuando $a$ se divide por $b$, entonces $gcd(a,\n", + "b) = gcd(b, r)$. Como caso base, podemos usar $gcd(a, 0) = a$.\n", "\n", - "Write a function called `gcd` that takes parameters `a` and `b` and\n", - "returns their greatest common divisor." + "Escribe una función llamada `gcd` que tome los parámetros `a` y `b`, y\n", + "devuelva su máximo común divisor." ] }, { @@ -1624,7 +1626,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1666,9 +1668,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap07.ipynb b/blank/chap07.ipynb index 22ea459..2b473b7 100644 --- a/blank/chap07.ipynb +++ b/blank/chap07.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y libro electrónico de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -27,15 +27,15 @@ "tags": [] }, "source": [ - "# Iteration and Search\n", + "# Iteración y búsqueda\n", "\n", - "In 1939 Ernest Vincent Wright published a 50,000 word novel called *Gadsby* that does not contain the letter \"e\". Since \"e\" is the most common letter in English, writing even a few words without using it is difficult.\n", - "To get a sense of how difficult, in this chapter we'll compute the fraction of English words have at least one \"e\".\n", + "En 1939, Ernest Vincent Wright publicó una novela de 50.000 palabras llamada *Gadsby* que no contiene la letra \"e\". Como \"e\" es la letra más común en inglés, escribir incluso unas pocas palabras sin usarla es difícil.\n", + "Para hacernos una idea de lo difícil que es, en este capítulo calcularemos la fracción de palabras en inglés que tienen al menos una \"e\".\n", "\n", - "For that, we'll use `for` statements to loop through the letters in a string and the words in a file, and we'll update variables in a loop to count the number of words that contain an \"e\".\n", - "We'll use the `in` operator to check whether a letter appears in a word, and you'll learn a programming pattern called a \"linear search\".\n", + "Para ello, usaremos sentencias `for` para recorrer las letras de una cadena y las palabras de un archivo, y actualizaremos variables en un bucle para contar el número de palabras que contienen una \"e\".\n", + "Usaremos el operador `in` para comprobar si una letra aparece en una palabra, y aprenderás un patrón de programación llamado \"búsqueda lineal\".\n", "\n", - "As an exercise, you'll use these tools to solve a word puzzle called \"Spelling Bee\"." + "Como ejercicio, usarás estas herramientas para resolver un juego de palabras llamado \"Spelling Bee\"." ] }, { @@ -43,9 +43,9 @@ "id": "389f5162-0a8c-4cc7-99f1-a261e0b39006", "metadata": {}, "source": [ - "## Loops and strings\n", + "## Bucles y cadenas\n", "\n", - "In Chapter 3 we saw a `for` loop that uses the `range` function to display a sequence of numbers." + "En el capítulo 3 vimos un bucle `for` que usa la función `range` para mostrar una secuencia de números." ] }, { @@ -61,9 +61,9 @@ "id": "937a0af9-5486-4195-8e59-6f819db1cf3f", "metadata": {}, "source": [ - "This version uses the keyword argument `end` so the `print` function puts a space after each number rather than a newline.\n", + "Esta versión usa el argumento de palabra clave `end` para que la función `print` añada un espacio después de cada número en lugar de un salto de línea.\n", "\n", - "We can also use a `for` loop to display the letters in a string." + "También podemos usar un bucle `for` para mostrar las letras de una cadena." ] }, { @@ -79,10 +79,10 @@ "id": "72044436-ed85-407b-8821-9696648ec29c", "metadata": {}, "source": [ - "Notice that I changed the name of the variable from `i` to `letter`, which provides more information about the value it refers to.\n", - "The variable defined in a `for` loop is called the **loop variable**.\n", + "Fíjate en que he cambiado el nombre de la variable de `i` a `letter`, lo que proporciona más información sobre el valor al que se refiere.\n", + "La variable definida en un bucle `for` se llama **variable de bucle**.\n", "\n", - "Now that we can loop through the letters in a word, we can check whether it contains the letter \"e\"." + "Ahora que podemos recorrer las letras de una palabra, podemos comprobar si contiene la letra \"e\"." ] }, { @@ -98,7 +98,7 @@ "id": "644b7df2-4528-48d9-a003-2d21fbefbaab", "metadata": {}, "source": [ - "Before we go on, let's encapsulate that loop in a function." + "Antes de seguir, encapsulemos ese bucle en una función." ] }, { @@ -114,7 +114,7 @@ "id": "31cfacd9-5721-457a-be40-80cf002723b2", "metadata": {}, "source": [ - "And let's make it a pure function that return `True` if the word contains an \"e\" and `False` otherwise." + "Y convirtámosla en una función pura que devuelva `True` si la palabra contiene una \"e\" y `False` en caso contrario." ] }, { @@ -130,7 +130,7 @@ "id": "8f45502e-6db3-4fcc-802c-c97398787dbd", "metadata": {}, "source": [ - "We can generalize it to take the word as a parameter." + "Podemos generalizarla para que tome la palabra como parámetro." ] }, { @@ -146,7 +146,7 @@ "id": "590f4399-16d3-4f1c-93bc-b1fe7ce46633", "metadata": {}, "source": [ - "Now we can test it like this:" + "Ahora podemos probarla así:" ] }, { @@ -170,10 +170,10 @@ "id": "8adf1e92-435e-4b54-837a-bad603ebcafd", "metadata": {}, "source": [ - "## Reading the word list\n", + "## Leer la lista de palabras\n", "\n", - "To see how many words contain an \"e\", we'll need a word list.\n", - "The one we'll use is a list of about 114,000 official crosswords; that is, words that are considered valid in crossword puzzles and other word games. " + "Para ver cuántas palabras contienen una \"e\", necesitaremos una lista de palabras.\n", + "La que usaremos es una lista de unas 114.000 palabras oficiales de crucigramas; es decir, palabras que se consideran válidas en crucigramas y otros juegos de palabras." ] }, { @@ -183,7 +183,7 @@ "tags": [] }, "source": [ - "The following cell downloads the word list, which is a modified version of a list collected and contributed to the public domain by Grady Ward as part of the Moby lexicon project (see )." + "La siguiente celda descarga la lista de palabras, que es una versión modificada de una lista recopilada y aportada al dominio público por Grady Ward como parte del proyecto léxico Moby (consulta )." ] }, { @@ -201,8 +201,8 @@ "id": "5b383a3c-d173-4a66-bf86-23b329032004", "metadata": {}, "source": [ - "The word list is in a file called `words.txt`, which is downloaded in the notebook for this chapter.\n", - "To read it, we'll use the built-in function `open`, which takes the name of the file as a parameter and returns a **file object** we can use to read the file." + "La lista de palabras está en un archivo llamado `words.txt`, que se descarga en el notebook de este capítulo.\n", + "Para leerlo, usaremos la función integrada `open`, que toma el nombre del archivo como parámetro y devuelve un **objeto de archivo** que podemos usar para leer el archivo." ] }, { @@ -218,7 +218,7 @@ "id": "4414d9b1-cb8e-472e-818c-0555e29b1ad5", "metadata": {}, "source": [ - "The file object provides a function called `readline`, which reads characters from the file until it gets to a newline and returns the result as a string:" + "El objeto de archivo proporciona un método llamado `readline`, que lee caracteres del archivo hasta llegar a un salto de línea y devuelve el resultado como una cadena:" ] }, { @@ -234,14 +234,15 @@ "id": "d74e9fe9-117e-436a-ade3-3d08dfda2a00", "metadata": {}, "source": [ - "Notice that the syntax for calling `readline` is different from functions we've seen so far. That's because it is a **method**, which is a function associated with an object.\n", - "In this case `readline` is associated with the file object, so we call it using the name of the object, the dot operator, and the name of the method.\n", + "Fíjate en que la sintaxis para llamar a `readline` es diferente de la de las funciones que hemos visto hasta ahora. Eso se debe a que es un **método**, que es una función asociada a un objeto.\n", + "En este caso `readline` está asociado al objeto de archivo, así que lo llamamos usando el nombre del objeto, el operador punto y el nombre del método.\n", "\n", - "The first word in the list is \"aa\", which is a kind of lava.\n", - "The sequence `\\n` represents the newline character that separates this word from the next.\n", + "La primera palabra de la lista es \"aa\", que es un tipo de lava.\n", + "La secuencia `\n", + "` representa el carácter de salto de línea que separa esta palabra de la siguiente.\n", "\n", - "The file object keeps track of where it is in the file, so if you call\n", - "`readline` again, you get the next word:" + "El objeto de archivo lleva la cuenta de en qué parte del archivo está, así que si llamas a\n", + "`readline` de nuevo, obtienes la siguiente palabra:" ] }, { @@ -257,7 +258,7 @@ "id": "cd466fdb-38ce-4e5b-92c7-05dc23922005", "metadata": {}, "source": [ - "To remove the newline from the end of the word, we can use `strip`, which is a method associated with strings, so we can call it like this." + "Para eliminar el salto de línea del final de la palabra, podemos usar `strip`, que es un método asociado con las cadenas, así que podemos llamarlo así." ] }, { @@ -273,10 +274,10 @@ "id": "6dda6bac-e02e-47ee-9bab-70cef8c27d7a", "metadata": {}, "source": [ - "`strip` removes whitespace characters -- including spaces, tabs, and newlines -- from the beginning and end of the string.\n", + "`strip` elimina caracteres de espacio en blanco -- incluidos espacios, tabulaciones y saltos de línea -- del principio y el final de la cadena.\n", "\n", - "You can also use a file object as part of a `for` loop. \n", - "This program reads `words.txt` and prints each word, one per line:" + "También puedes usar un objeto de archivo como parte de un bucle `for`.\n", + "Este programa lee `words.txt` e imprime cada palabra, una por línea:" ] }, { @@ -294,8 +295,8 @@ "id": "93e320a5-4827-487e-a8ce-216392f398a8", "metadata": {}, "source": [ - "Now that we can read the word list, the next step is to count them.\n", - "For that, we will need the ability to update variables." + "Ahora que podemos leer la lista de palabras, el siguiente paso es contarlas.\n", + "Para eso, necesitaremos la capacidad de actualizar variables." ] }, { @@ -303,13 +304,12 @@ "id": "b63a6877", "metadata": {}, "source": [ - "## Updating variables\n", + "## Actualizar variables\n", "\n", - "As you may have discovered, it is legal to make more than one assignment\n", - "to the same variable.\n", - "A new assignment makes an existing variable refer to a new value (and stop referring to the old value).\n", + "Como quizá hayas descubierto, es legal hacer más de una asignación a la misma variable.\n", + "Una nueva asignación hace que una variable existente se refiera a un valor nuevo (y deje de referirse al valor anterior).\n", "\n", - "For example, here is an initial assignment that creates a variable." + "Por ejemplo, aquí hay una asignación inicial que crea una variable." ] }, { @@ -325,7 +325,7 @@ "id": "c9735982", "metadata": {}, "source": [ - "And here is an assignment that changes the value of a variable." + "Y aquí hay una asignación que cambia el valor de una variable." ] }, { @@ -341,7 +341,7 @@ "id": "fbcd1092-ce06-47fc-9204-fce1c9a100a5", "metadata": {}, "source": [ - "The following figure shows what these assignments looks like in a state diagram." + "La siguiente figura muestra cómo se ven estas asignaciones en un diagrama de estado." ] }, { @@ -369,11 +369,11 @@ "id": "42b7b044-f83b-4483-9a24-64980c688c94", "metadata": {}, "source": [ - "The dotted arrow indicates that `x` no longer refers to `5`.\n", - "The solid arrow indicates that it now refers to `7`.\n", + "La flecha punteada indica que `x` ya no se refiere a `5`.\n", + "La flecha sólida indica que ahora se refiere a `7`.\n", "\n", - "A common kind of assignment is an **update**, where the new value of\n", - "the variable depends on the old." + "Un tipo común de asignación es una **actualización**, donde el nuevo valor de\n", + "la variable depende del anterior." ] }, { @@ -399,9 +399,9 @@ "id": "d3025706", "metadata": {}, "source": [ - "This statement means \"get the current value of `x`, add one, and assign the result back to `x`.\"\n", + "Esta sentencia significa \"obtén el valor actual de `x`, suma uno y asigna el resultado de nuevo a `x`.\"\n", "\n", - "If you try to update a variable that doesn't exist, you get an error, because Python evaluates the expression on the right before it assigns a value to the variable on the left." + "Si intentas actualizar una variable que no existe, obtienes un error, porque Python evalúa la expresión de la derecha antes de asignar un valor a la variable de la izquierda." ] }, { @@ -419,8 +419,8 @@ "id": "03d3959f", "metadata": {}, "source": [ - "Before you can update a variable, you have to **initialize** it, usually\n", - "with a simple assignment:" + "Antes de poder actualizar una variable, tienes que **inicializarla**, normalmente\n", + "con una asignación sencilla:" ] }, { @@ -436,9 +436,9 @@ "id": "374fb3d5", "metadata": {}, "source": [ - "Increasing the value of a variable is called an **increment**; decreasing the value is called a **decrement**.\n", - "Because these operations are so common, Python provides **augmented assignment operators** that update a variable more concisely.\n", - "For example, the `+=` operator increments a variable by the given amount." + "Aumentar el valor de una variable se llama **incremento**; disminuir el valor se llama **decremento**.\n", + "Como estas operaciones son tan comunes, Python proporciona **operadores de asignación aumentada** que actualizan una variable de forma más concisa.\n", + "Por ejemplo, el operador `+=` incrementa una variable en la cantidad dada." ] }, { @@ -454,7 +454,7 @@ "id": "3f4eedf1", "metadata": {}, "source": [ - "There are augmented assignment operators for the other arithmetic operators, including `-=` and `*=`." + "Hay operadores de asignación aumentada para los otros operadores aritméticos, incluidos `-=` y `*=`." ] }, { @@ -462,9 +462,9 @@ "id": "70eeef60-6a34-403a-96bb-aa5c4574a5fe", "metadata": {}, "source": [ - "## Looping and counting\n", + "## Recorrer y contar\n", "\n", - "The following program counts the number of words in the word list." + "El siguiente programa cuenta el número de palabras en la lista de palabras." ] }, { @@ -480,9 +480,9 @@ "id": "9bd83ddd", "metadata": {}, "source": [ - "It starts by initializing `total` to `0`.\n", - "Each time through the loop, it increments `total` by `1`.\n", - "So when the loop exits, `total` refers to the total number of words." + "Empieza inicializando `total` a `0`.\n", + "Cada vez que pasa por el bucle, incrementa `total` en `1`.\n", + "Así que cuando el bucle termina, `total` se refiere al número total de palabras." ] }, { @@ -498,9 +498,9 @@ "id": "54904394", "metadata": {}, "source": [ - "A variable like this, used to count the number of times something happens, is called a **counter**.\n", + "Una variable como esta, usada para contar el número de veces que ocurre algo, se llama **contador**.\n", "\n", - "We can add a second counter to the program to keep track of the number of words that contain an \"e\"." + "Podemos añadir un segundo contador al programa para llevar la cuenta del número de palabras que contienen una \"e\"." ] }, { @@ -516,7 +516,7 @@ "id": "ab73c1e3", "metadata": {}, "source": [ - "Let's see how many words contain an \"e\"." + "Veamos cuántas palabras contienen una \"e\"." ] }, { @@ -532,7 +532,7 @@ "id": "d2262e64", "metadata": {}, "source": [ - "As a percentage of `total`, about two-thirds of the words use the letter \"e\"." + "Como porcentaje de `total`, alrededor de dos tercios de las palabras usan la letra \"e\"." ] }, { @@ -548,7 +548,7 @@ "id": "fe002dde", "metadata": {}, "source": [ - "So you can understand why it's difficult to craft a book without using any such words." + "Así puedes entender por qué es difícil escribir un libro sin usar ninguna de esas palabras." ] }, { @@ -556,10 +556,10 @@ "id": "632a992f", "metadata": {}, "source": [ - "## The in operator\n", + "## El operador in\n", "\n", - "The version of `has_e` we wrote in this chapter is more complicated than it needs to be.\n", - "Python provides an operator, `in`, that checks whether a character appears in a string." + "La versión de `has_e` que escribimos en este capítulo es más complicada de lo necesario.\n", + "Python proporciona un operador, `in`, que comprueba si un carácter aparece en una cadena." ] }, { @@ -575,7 +575,7 @@ "id": "ede36fe9", "metadata": {}, "source": [ - "So we can rewrite `has_e` like this." + "Así que podemos reescribir `has_e` así." ] }, { @@ -591,7 +591,7 @@ "id": "f86f6fc7", "metadata": {}, "source": [ - "And because the conditional of the `if` statement has a boolean value, we can eliminate the `if` statement and return the boolean directly." + "Y como la condición de la sentencia `if` tiene un valor booleano, podemos eliminar la sentencia `if` y devolver el valor booleano directamente." ] }, { @@ -607,8 +607,8 @@ "id": "f2a05319", "metadata": {}, "source": [ - "We can simplify this function even more using the method `lower`, which converts the letters in a string to lowercase.\n", - "Here's an example." + "Podemos simplificar esta función todavía más usando el método `lower`, que convierte las letras de una cadena a minúsculas.\n", + "Aquí tienes un ejemplo." ] }, { @@ -624,7 +624,7 @@ "id": "57aa625a", "metadata": {}, "source": [ - "`lower` makes a new string -- it does not modify the existing string -- so the value of `word` is unchanged. " + "`lower` crea una cadena nueva -- no modifica la cadena existente -- así que el valor de `word` no cambia." ] }, { @@ -640,7 +640,7 @@ "id": "9f0bd075", "metadata": {}, "source": [ - "Here's how we can use `lower` in `has_e`." + "Así es como podemos usar `lower` en `has_e`." ] }, { @@ -672,10 +672,10 @@ "id": "1c39cb6b", "metadata": {}, "source": [ - "## Search\n", + "## Búsqueda\n", "\n", - "Based on this simpler version of `has_e`, let's write a more general function called `uses_any` that takes a second parameter that is a string of letters.\n", - "If returns `True` if the word uses any of the letters and `False` otherwise." + "Basándonos en esta versión más sencilla de `has_e`, escribamos una función más general llamada `uses_any` que recibe un segundo parámetro que es una cadena de letras.\n", + "Devuelve `True` si la palabra usa cualquiera de las letras y `False` en caso contrario." ] }, { @@ -691,7 +691,7 @@ "id": "dc2d6290", "metadata": {}, "source": [ - "Here's an example where the result is `True`." + "Aquí tienes un ejemplo donde el resultado es `True`." ] }, { @@ -707,7 +707,7 @@ "id": "2c3c1553", "metadata": {}, "source": [ - "And another where it is `False`." + "Y otro donde es `False`." ] }, { @@ -723,7 +723,7 @@ "id": "b2acc611", "metadata": {}, "source": [ - "`uses_any` converts `word` and `letters` to lowercase, so it works with any combination of cases. " + "`uses_any` convierte `word` y `letters` a minúsculas, así que funciona con cualquier combinación de mayúsculas y minúsculas." ] }, { @@ -739,13 +739,13 @@ "id": "673786a5", "metadata": {}, "source": [ - "The structure of `uses_any` is similar to `has_e`.\n", - "It loops through the letters in `word` and checks them one at a time.\n", - "If it finds one that appears in `letters`, it returns `True` immediately.\n", - "If it gets all the way through the loop without finding any, it returns `False`.\n", + "La estructura de `uses_any` es similar a la de `has_e`.\n", + "Recorre las letras de `word` y las comprueba una por una.\n", + "Si encuentra una que aparece en `letters`, devuelve `True` inmediatamente.\n", + "Si llega hasta el final del bucle sin encontrar ninguna, devuelve `False`.\n", "\n", - "This pattern is called a **linear search**.\n", - "In the exercises at the end of this chapter, you'll write more functions that use this pattern." + "Este patrón se llama **búsqueda lineal**.\n", + "En los ejercicios al final de este capítulo, escribirás más funciones que usan este patrón." ] }, { @@ -755,9 +755,9 @@ "source": [ "## Doctest\n", "\n", - "In [Chapter 4](section_docstring) we used a docstring to document a function -- that is, to explain what it does.\n", - "It is also possible to use a docstring to *test* a function.\n", - "Here's a version of `uses_any` with a docstring that includes tests." + "En el [capítulo 4](section_docstring) usamos un docstring para documentar una función -- es decir, para explicar qué hace.\n", + "También es posible usar un docstring para *probar* una función.\n", + "Aquí tienes una versión de `uses_any` con un docstring que incluye pruebas." ] }, { @@ -773,15 +773,15 @@ "id": "2871d018", "metadata": {}, "source": [ - "Each test begins with `>>>`, which is used as a prompt in some Python environments to indicate where the user can type code.\n", - "In a doctest, the prompt is followed by an expression, usually a function call.\n", - "The following line indicates the value the expression should have if the function works correctly.\n", + "Cada prueba empieza con `>>>`, que se usa como indicador en algunos entornos de Python para indicar dónde el usuario puede escribir código.\n", + "En un doctest, al indicador le sigue una expresión, normalmente una llamada a función.\n", + "La línea siguiente indica el valor que debería tener la expresión si la función funciona correctamente.\n", "\n", - "In the first example, `'banana'` uses `'a'`, so the result should be `True`.\n", - "In the second example, `'apple'` does not use any of `'xyz'`, so the result should be `False`.\n", + "En el primer ejemplo, `'banana'` usa `'a'`, así que el resultado debería ser `True`.\n", + "En el segundo ejemplo, `'apple'` no usa ninguna de `'xyz'`, así que el resultado debería ser `False`.\n", "\n", - "To run these tests, we have to import the `doctest` module and run a function called `run_docstring_examples`.\n", - "To make this function easier to use, I wrote the following function, which takes a function object as an argument." + "Para ejecutar estas pruebas, tenemos que importar el módulo `doctest` y ejecutar una función llamada `run_docstring_examples`.\n", + "Para que esta función sea más fácil de usar, escribí la siguiente función, que toma un objeto que representa una función como argumento." ] }, { @@ -797,8 +797,8 @@ "id": "79e3de21", "metadata": {}, "source": [ - "We haven't learned about `globals` and `__name__` yet -- you can ignore them.\n", - "Now we can test `uses_any` like this." + "Todavía no hemos aprendido sobre `globals` y `__name__` -- puedes ignorarlos.\n", + "Ahora podemos probar `uses_any` así." ] }, { @@ -814,12 +814,11 @@ "id": "432d8c31", "metadata": {}, "source": [ - "`run_doctests` finds the expressions in the docstring and evaluates them.\n", - "If the result is the expected value, the test **passes**.\n", - "Otherwise it **fails**.\n", - "\n", - "If all tests pass, `run_doctests` displays no output -- in that case, no news is good news.\n", - "To see what happens when a test fails, here's an incorrect version of `uses_any`." + "`run_doctests` encuentra las expresiones en el docstring y las evalúa.\n", + "Si el resultado es el valor esperado, la prueba **pasa**.\n", + "En caso contrario, **falla**.\n", + "Si todas las pruebas pasan, `run_doctests` no muestra ninguna salida -- en ese caso, no tener noticias es buena señal.\n", + "Para ver qué ocurre cuando una prueba falla, aquí tienes una versión incorrecta de `uses_any`." ] }, { @@ -835,7 +834,7 @@ "id": "34b78be4", "metadata": {}, "source": [ - "And here's what happens when we test it." + "Y esto es lo que ocurre cuando la probamos." ] }, { @@ -851,9 +850,9 @@ "id": "473aa6ec", "metadata": {}, "source": [ - "The output includes the example that failed, the value the function was expected to produce, and the value the function actually produced.\n", + "La salida incluye el ejemplo que falló, el valor que se esperaba que devolviera la función y el valor que produjo realmente.\n", "\n", - "If you are not sure why this test failed, you'll have a chance to debug it as an exercise." + "Si no tienes claro por qué falló esta prueba, tendrás la oportunidad de depurarla como ejercicio." ] }, { @@ -861,40 +860,40 @@ "id": "382c134e", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**loop variable:**\n", - "A variable defined in the header of a `for` loop.\n", + "**variable de bucle:**\n", + "Una variable definida en la cabecera de un bucle `for`.\n", "\n", - "**file object:**\n", - "An object that represents an open file and keeps track of which parts of the file have been read or written.\n", + "**objeto de archivo:**\n", + "Un objeto que representa un archivo abierto y lleva la cuenta de qué partes del archivo se han leído o escrito.\n", "\n", - "**method:**\n", - " A function that is associated with an object and called using the dot operator.\n", + "**método:**\n", + " Una función asociada a un objeto que se llama usando el operador punto.\n", "\n", - "**update:**\n", - "An assignment statement that give a new value to a variable that already exists, rather than creating a new variables.\n", + "**actualización:**\n", + "Una sentencia de asignación que da un valor nuevo a una variable que ya existe, en lugar de crear una variable nueva.\n", "\n", - "**initialize:**\n", - "Create a new variable and give it a value.\n", + "**inicializar:**\n", + "Crear una variable nueva y darle un valor.\n", "\n", - "**increment:**\n", - "Increase the value of a variable.\n", + "**incremento:**\n", + "Aumentar el valor de una variable.\n", "\n", - "**decrement:**\n", - "Decrease the value of a variable.\n", + "**decremento:**\n", + "Disminuir el valor de una variable.\n", "\n", - "**counter:**\n", - " A variable used to count something, usually initialized to zero and then incremented.\n", + "**contador:**\n", + " Una variable usada para contar algo, normalmente inicializada a cero y luego incrementada.\n", "\n", - "**linear search:**\n", - "A computational pattern that searches through a sequence of elements and stops what it finds what it is looking for.\n", + "**búsqueda lineal:**\n", + "Un patrón computacional que busca en una secuencia de elementos y se detiene cuando encuentra lo que está buscando.\n", "\n", - "**pass:**\n", - "If a test runs and the result is as expected, the test passes.\n", + "**pasar:**\n", + "Si una prueba se ejecuta y el resultado es el esperado, la prueba pasa.\n", "\n", - "**fail:**\n", - "If a test runs and the result is not as expected, the test fails." + "**fallar:**\n", + "Si una prueba se ejecuta y el resultado no es el esperado, la prueba falla." ] }, { @@ -902,7 +901,7 @@ "id": "0a2b3510-e8d3-439b-a771-a4a58db6ac59", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -920,9 +919,9 @@ "id": "8e8606b8-9a48-4cbd-a0b0-ea848666c77d", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In `uses_any`, you might have noticed that the first `return` statement is inside the loop and the second is outside." + "En `uses_any`, quizá hayas notado que la primera sentencia `return` está dentro del bucle y la segunda está fuera." ] }, { @@ -938,7 +937,7 @@ "id": "e1920737-b485-4823-ac20-c1e35aa93e7f", "metadata": {}, "source": [ - "When people first write functions like this, it is a common error to put both `return` statements inside the loop, like this." + "Cuando la gente escribe por primera vez funciones como esta, es un error común poner ambas sentencias `return` dentro del bucle, así." ] }, { @@ -954,7 +953,7 @@ "id": "d9b46591-6c80-4ff8-9378-e9318ce5e429", "metadata": {}, "source": [ - "Ask a virtual assistant what's wrong with this version." + "Pregunta a un asistente virtual qué está mal en esta versión." ] }, { @@ -962,12 +961,12 @@ "id": "99eff99e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function named `uses_none` that takes a word and a string of forbidden letters, and returns `True` if the word does not use any of the forbidden letters.\n", + "Escribe una función llamada `uses_none` que reciba una palabra y una cadena de letras prohibidas, y devuelva `True` si la palabra no usa ninguna de las letras prohibidas.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1001,12 +1000,12 @@ "id": "9465b09f-0c62-49f6-bbe2-365ecf1717ef", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `uses_only` that takes a word and a string of letters, and that returns `True` if the word contains only letters in the string.\n", + "Escribe una función llamada `uses_only` que reciba una palabra y una cadena de letras, y que devuelva `True` si la palabra contiene solo letras de la cadena.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1040,12 +1039,12 @@ "id": "74259f36", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `uses_all` that takes a word and a string of letters, and that returns `True` if the word contains all of the letters in the string at least once.\n", + "Escribe una función llamada `uses_all` que reciba una palabra y una cadena de letras, y que devuelva `True` si la palabra contiene todas las letras de la cadena al menos una vez.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1079,21 +1078,21 @@ "id": "7210adfa", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "*The New York Times* publishes a daily puzzle called \"Spelling Bee\" that challenges readers to spell as many words as possible using only seven letters, where one of the letters is required.\n", - "The words must have at least four letters.\n", + "*The New York Times* publica un juego diario llamado \"Spelling Bee\" que reta a los lectores a formar tantas palabras como sea posible usando solo siete letras, donde una de las letras es obligatoria.\n", + "Las palabras deben tener al menos cuatro letras.\n", "\n", - "For example, on the day I wrote this, the letters were `ACDLORT`, with `R` as the required letter.\n", - "So \"color\" is an acceptable word, but \"told\" is not, because it does not use `R`, and \"rat\" is not because it has only three letters.\n", - "Letters can be repeated, so \"ratatat\" is acceptable.\n", + "Por ejemplo, el día que escribí esto, las letras eran `ACDLORT`, con `R` como letra obligatoria.\n", + "Así que \"color\" es una palabra aceptable, pero \"told\" no, porque no usa `R`, y \"rat\" tampoco porque solo tiene tres letras.\n", + "Las letras se pueden repetir, así que \"ratatat\" es aceptable.\n", "\n", - "Write a function called `check_word` that checks whether a given word is acceptable.\n", - "It should take as parameters the word to check, a string of seven available letters, and a string containing the single required letter.\n", - "You can use the functions you wrote in previous exercises.\n", + "Escribe una función llamada `check_word` que compruebe si una palabra dada es aceptable.\n", + "Debe recibir como parámetros la palabra que se va a comprobar, una cadena de siete letras disponibles y una cadena que contiene la única letra obligatoria.\n", + "Puedes usar las funciones que escribiste en ejercicios anteriores.\n", "\n", - "Here's an outline of the function that includes doctests.\n", - "Fill in the function and then check that all tests pass." + "Aquí tienes un esquema de la función que incluye doctests.\n", + "Completa la función y luego comprueba que todas las pruebas pasan." ] }, { @@ -1127,18 +1126,18 @@ "id": "0b9589fc", "metadata": {}, "source": [ - "According to the \"Spelling Bee\" rules,\n", + "Según las reglas de \"Spelling Bee\",\n", "\n", - "* Four-letter words are worth 1 point each.\n", + "* Las palabras de cuatro letras valen 1 punto cada una.\n", "\n", - "* Longer words earn 1 point per letter.\n", + "* Las palabras más largas obtienen 1 punto por letra.\n", "\n", - "* Each puzzle includes at least one \"pangram\" which uses every letter. These are worth 7 extra points!\n", + "* Cada juego incluye al menos un \"pangram\" que usa todas las letras. ¡Estos valen 7 puntos extra!\n", "\n", - "Write a function called `score_word` that takes a word and a string of available letters and returns its score.\n", - "You can assume that the word is acceptable.\n", + "Escribe una función llamada `score_word` que reciba una palabra y una cadena de letras disponibles y devuelva su puntuación.\n", + "Puedes asumir que la palabra es aceptable.\n", "\n", - "Again, here's an outline of the function with doctests." + "De nuevo, aquí tienes un esquema de la función con doctests." ] }, { @@ -1174,7 +1173,7 @@ "tags": [] }, "source": [ - "When all of your functions pass their tests, use the following loop to search the word list for acceptable words and add up their scores." + "Cuando todas tus funciones pasen sus pruebas, usa el siguiente bucle para buscar palabras aceptables en la lista de palabras y sumar sus puntuaciones." ] }, { @@ -1194,9 +1193,9 @@ "tags": [] }, "source": [ - "Visit the \"Spelling Bee\" page at and type in the available letters for the day. The letter in the middle is required.\n", + "Visita la página de \"Spelling Bee\" en y escribe las letras disponibles del día. La letra del centro es obligatoria.\n", "\n", - "I found a set of letters that spells words with a total score of 5820. Can you beat that? Finding the best set of letters might be too hard -- you have to be a realist." + "Encontré un conjunto de letras que forma palabras con una puntuación total de 5820. ¿Puedes superarlo? Encontrar el mejor conjunto de letras podría ser demasiado difícil -- hay que ser realista." ] }, { @@ -1204,12 +1203,12 @@ "id": "9ae466ed", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "You might have noticed that the functions you wrote in the previous exercises had a lot in common.\n", - "In fact, they are so similar you can often use one function to write another.\n", + "Quizá hayas notado que las funciones que escribiste en los ejercicios anteriores tenían mucho en común.\n", + "De hecho, son tan parecidas que a menudo puedes usar una función para escribir otra.\n", "\n", - "For example, if a word uses none of a set forbidden letters, that means it doesn't use any. So we can write a version of `uses_none` like this." + "Por ejemplo, si una palabra no usa ninguna letra de un conjunto de letras prohibidas, eso significa que no usa ninguna. Así que podemos escribir una versión de `uses_none` así." ] }, { @@ -1235,8 +1234,8 @@ "id": "32aa2c09", "metadata": {}, "source": [ - "There is also a similarity between `uses_only` and `uses_all` that you can take advantage of.\n", - "If you have a working version of `uses_only`, see if you can write a version of `uses_all` that calls `uses_only`." + "También hay una similitud entre `uses_only` y `uses_all` que puedes aprovechar.\n", + "Si tienes una versión funcional de `uses_only`, mira si puedes escribir una versión de `uses_all` que llame a `uses_only`." ] }, { @@ -1244,11 +1243,11 @@ "id": "fa758462", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "If you got stuck on the previous question, try asking a virtual assistant, \"Given a function, `uses_only`, which takes two strings and checks that the first uses only the letters in the second, use it to write `uses_all`, which takes two strings and checks whether the first uses all the letters in the second, allowing repeats.\"\n", + "Si te atascaste en la pregunta anterior, prueba a preguntar a un asistente virtual: \"Dada una función, `uses_only`, que recibe dos cadenas y comprueba que la primera usa solo las letras del segundo, úsala para escribir `uses_all`, que recibe dos cadenas y comprueba si la primera usa todas las letras del segundo, permitiendo repeticiones.\"\n", "\n", - "Use `run_doctests` to check the answer." + "Usa `run_doctests` para comprobar la respuesta." ] }, { @@ -1274,13 +1273,13 @@ "id": "18f407b3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now let's see if we can write `uses_all` based on `uses_any`.\n", + "Ahora veamos si podemos escribir `uses_all` basándonos en `uses_any`.\n", "\n", - "Ask a virtual assistant, \"Given a function, `uses_any`, which takes two strings and checks whether the first uses any of the letters in the second, can you use it to write `uses_all`, which takes two strings and checks whether the first uses all the letters in the second, allowing repeats.\"\n", + "Pregunta a un asistente virtual: \"Dada una función, `uses_any`, que recibe dos cadenas y comprueba si la primera usa cualquiera de las letras del segundo, ¿puedes usarla para escribir `uses_all`, que recibe dos cadenas y comprueba si la primera usa todas las letras del segundo, permitiendo repeticiones?\"\n", "\n", - "If it says it can, be sure to test the result!" + "Si dice que puede, ¡asegúrate de probar el resultado!" ] }, { @@ -1318,9 +1317,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap08.ipynb b/blank/chap08.ipynb index 00a2a91..317c410 100644 --- a/blank/chap08.ipynb +++ b/blank/chap08.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y libro electrónico de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,14 +25,14 @@ "id": "9d97603b", "metadata": {}, "source": [ - "# Strings and Regular Expressions\n", + "# Cadenas y expresiones regulares\n", "\n", - "Strings are not like integers, floats, and booleans. A string is a **sequence**, which means it contains multiple values in a particular order.\n", - "In this chapter we'll see how to access the values that make up a string, and we'll use functions that process strings.\n", + "Las cadenas no son como los enteros, los flotantes y los booleanos. Una cadena es una **secuencia**, lo que significa que contiene múltiples valores en un orden particular.\n", + "En este capítulo veremos cómo acceder a los valores que componen una cadena, y usaremos funciones que procesan cadenas.\n", "\n", - "We'll also use regular expressions, which are a powerful tool for finding patterns in a string and performing operations like search and replace.\n", + "También usaremos expresiones regulares, que son una herramienta poderosa para encontrar patrones en una cadena y realizar operaciones como búsqueda y reemplazo.\n", "\n", - "As an exercise, you'll have a chance to apply these tools to a word game called Wordle." + "Como ejercicio, tendrás la oportunidad de aplicar estas herramientas a un juego de palabras llamado Wordle." ] }, { @@ -40,13 +40,13 @@ "id": "1280dd83", "metadata": {}, "source": [ - "## A string is a sequence\n", + "## Una cadena es una secuencia\n", "\n", - "A string is a sequence of characters. A **character** can be a letter (in almost any alphabet), a digit, a punctuation mark, or white space.\n", + "Una cadena es una secuencia de caracteres. Un **carácter** puede ser una letra (en casi cualquier alfabeto), un dígito, un signo de puntuación o un espacio en blanco.\n", "\n", - "You can select a character from a string with the bracket operator.\n", - "This example statement selects character number 1 from `fruit` and\n", - "assigns it to `letter`:" + "Puedes seleccionar un carácter de una cadena con el operador de corchetes.\n", + "Esta sentencia de ejemplo selecciona el carácter número 1 de `fruit` y\n", + "lo asigna a `letter`:" ] }, { @@ -62,8 +62,8 @@ "id": "a307e429", "metadata": {}, "source": [ - "The expression in brackets is an **index**, so called because it *indicates* which character in the sequence to select.\n", - "But the result might not be what you expect." + "La expresión entre corchetes es un **índice**, llamado así porque *indica* qué carácter de la secuencia seleccionar.\n", + "Pero el resultado quizá no sea lo que esperas." ] }, { @@ -79,8 +79,8 @@ "id": "57c13319", "metadata": {}, "source": [ - "The letter with index `1` is actually the second letter of the string.\n", - "An index is an offset from the beginning of the string, so the offset of the first letter is `0`." + "La letra con índice `1` es en realidad la segunda letra de la cadena.\n", + "Un índice es un desplazamiento desde el principio de la cadena, así que el desplazamiento de la primera letra es `0`." ] }, { @@ -96,9 +96,9 @@ "id": "57d8e54c", "metadata": {}, "source": [ - "You can think of `'b'` as the 0th letter of `'banana'` -- pronounced \"zero-eth\".\n", + "Puedes pensar en `'b'` como la letra 0 de `'banana'` -- pronunciada \"ceroésima\".\n", "\n", - "The index in brackets can be a variable." + "El índice entre corchetes puede ser una variable." ] }, { @@ -114,7 +114,7 @@ "id": "9630e2e7", "metadata": {}, "source": [ - "Or an expression that contains variables and operators." + "O una expresión que contiene variables y operadores." ] }, { @@ -130,7 +130,7 @@ "id": "939b602d", "metadata": {}, "source": [ - "But the value of the index has to be an integer -- otherwise you get a `TypeError`." + "Pero el valor del índice tiene que ser un entero -- de lo contrario obtienes un `TypeError`." ] }, { @@ -148,7 +148,7 @@ "id": "3f0f7e3a", "metadata": {}, "source": [ - "As we saw in Chapter 1, we can use the built-in function `len` to get the length of a string." + "Como vimos en el capítulo 1, podemos usar la función integrada `len` para obtener la longitud de una cadena." ] }, { @@ -164,7 +164,7 @@ "id": "29013c47", "metadata": {}, "source": [ - "To get the last letter of a string, you might be tempted to write this:" + "Para obtener la última letra de una cadena, podrías sentir la tentación de escribir esto:" ] }, { @@ -182,7 +182,7 @@ "id": "b87e09bd", "metadata": {}, "source": [ - "But that causes an `IndexError` because there is no letter in `'banana'` with the index 6. Because we started counting at `0`, the six letters are numbered `0` to `5`. To get the last character, you have to subtract `1` from `n`:" + "Pero eso causa un `IndexError` porque no hay ninguna letra en `'banana'` con el índice 6. Como empezamos a contar en `0`, las seis letras están numeradas de `0` a `5`. Para obtener el último carácter, tienes que restar `1` a `n`:" ] }, { @@ -198,8 +198,8 @@ "id": "3c79dcec", "metadata": {}, "source": [ - "But there's an easier way.\n", - "To get the last letter in a string, you can use a negative index, which counts backward from the end. " + "Pero hay una forma más sencilla.\n", + "Para obtener la última letra de una cadena, puedes usar un índice negativo, que cuenta hacia atrás desde el final." ] }, { @@ -215,7 +215,7 @@ "id": "5677b727", "metadata": {}, "source": [ - "The index `-1` selects the last letter, `-2` selects the second to last, and so on." + "El índice `-1` selecciona la última letra, `-2` selecciona la penúltima, y así sucesivamente." ] }, { @@ -223,10 +223,10 @@ "id": "8392a12a", "metadata": {}, "source": [ - "## String slices\n", + "## Segmentos de cadenas\n", "\n", - "A segment of a string is called a **slice**.\n", - "Selecting a slice is similar to selecting a character." + "Un segmento de una cadena se llama **segmento**.\n", + "Seleccionar un segmento es similar a seleccionar un carácter." ] }, { @@ -242,9 +242,9 @@ "id": "5cc12531", "metadata": {}, "source": [ - "The operator `[n:m]` returns the part of the string from the `n`th\n", - "character to the `m`th character, including the first but excluding the second.\n", - "This behavior is counterintuitive, but it might help to imagine the indices pointing *between* the characters, as in this figure:" + "El operador `[n:m]` devuelve la parte de la cadena desde el carácter `n`-ésimo\n", + "hasta el carácter `m`-ésimo, incluyendo el primero pero excluyendo el segundo.\n", + "Este comportamiento es contraintuitivo, pero puede ayudar imaginar que los índices apuntan *entre* los caracteres, como en esta figura:" ] }, { @@ -272,10 +272,10 @@ "id": "c391abbf", "metadata": {}, "source": [ - "For example, the slice `[3:6]` selects the letters `ana`, which means that `6` is legal as part of a slice, but not legal as an index.\n", + "Por ejemplo, el segmento `[3:6]` selecciona las letras `ana`, lo que significa que `6` es legal como parte de un segmento, pero no como índice.\n", "\n", "\n", - "If you omit the first index, the slice starts at the beginning of the string." + "Si omites el primer índice, el segmento empieza al principio de la cadena." ] }, { @@ -291,7 +291,7 @@ "id": "1bd7dcb1", "metadata": {}, "source": [ - "If you omit the second index, the slice goes to the end of the string:" + "Si omites el segundo índice, el segmento va hasta el final de la cadena:" ] }, { @@ -307,7 +307,7 @@ "id": "4701123b", "metadata": {}, "source": [ - "If the first index is greater than or equal to the second, the result is an **empty string**, represented by two quotation marks:" + "Si el primer índice es mayor o igual que el segundo, el resultado es una **cadena vacía**, representado por dos comillas:" ] }, { @@ -323,10 +323,10 @@ "id": "d12735ab", "metadata": {}, "source": [ - "An empty string contains no characters and has length 0.\n", + "Una cadena vacío no contiene caracteres y tiene longitud 0.\n", "\n", - "Continuing this example, what do you think `fruit[:]` means? Try it and\n", - "see." + "Continuando con este ejemplo, ¿qué crees que significa `fruit[:]`? Pruébalo y\n", + "mira." ] }, { @@ -344,10 +344,10 @@ "id": "918d3dd0", "metadata": {}, "source": [ - "## Strings are immutable\n", + "## Las cadenas son inmutables\n", "\n", - "It is tempting to use the `[]` operator on the left side of an\n", - "assignment, with the intention of changing a character in a string, like this:" + "Es tentador usar el operador `[]` en el lado izquierdo de una\n", + "asignación, con la intención de cambiar un carácter en una cadena, así:" ] }, { @@ -365,13 +365,13 @@ "id": "df3dd7d1", "metadata": {}, "source": [ - "The result is a `TypeError`.\n", - "In the error message, the \"object\" is the string and the \"item\" is the character\n", - "we tried to assign.\n", - "For now, an **object** is the same thing as a value, but we will refine that definition later.\n", + "El resultado es un `TypeError`.\n", + "En el mensaje de error, el \"objeto\" es la cadena y el \"item\" es el carácter\n", + "que intentamos asignar.\n", + "Por ahora, un **objeto** es lo mismo que un valor, pero refinaremos esa definición más adelante.\n", "\n", - "The reason for this error is that strings are **immutable**, which means you can't change an existing string.\n", - "The best you can do is create a new string that is a variation of the original." + "La razón de este error es que las cadenas son **inmutables**, lo que significa que no puedes cambiar una cadena existente.\n", + "Lo máximo que puedes hacer es crear una cadena nueva que sea una variación del original." ] }, { @@ -387,8 +387,8 @@ "id": "2848546f", "metadata": {}, "source": [ - "This example concatenates a new first letter onto a slice of `greeting`.\n", - "It has no effect on the original string." + "Este ejemplo concatena una nueva primera letra con un segmento de `greeting`.\n", + "No tiene ningún efecto sobre la cadena original." ] }, { @@ -404,10 +404,10 @@ "id": "49e4da57", "metadata": {}, "source": [ - "## String comparison\n", + "## Comparación de cadenas\n", "\n", - "The relational operators work on strings. To see if two strings are\n", - "equal, we can use the `==` operator." + "Los operadores relacionales funcionan con cadenas. Para ver si dos cadenas son\n", + "iguales, podemos usar el operador `==`." ] }, { @@ -423,8 +423,7 @@ "id": "e9be6097", "metadata": {}, "source": [ - "Other relational operations are useful for putting words in alphabetical\n", - "order:" + "Otras operaciones relacionales son útiles para poner palabras en orden alfabético:" ] }, { @@ -448,9 +447,9 @@ "id": "b66f449a", "metadata": {}, "source": [ - "Python does not handle uppercase and lowercase letters the same way\n", - "people do. All the uppercase letters come before all the lowercase\n", - "letters, so:" + "Python no trata las letras mayúsculas y minúsculas de la misma manera que\n", + "lo hacen las personas. Todas las letras mayúsculas van antes que todas las\n", + "minúsculas, así que:" ] }, { @@ -466,8 +465,8 @@ "id": "f9b916c9", "metadata": {}, "source": [ - "To solve this problem, we can convert strings to a standard format, such as all lowercase, before performing the comparison.\n", - "Keep that in mind if you have to defend yourself against a man armed with a Pineapple." + "Para resolver este problema, podemos convertir las cadenas a un formato estándar, como todo en minúsculas, antes de realizar la comparación.\n", + "Tenlo en cuenta si tienes que defenderte de un hombre armado con una piña." ] }, { @@ -475,13 +474,13 @@ "id": "531069f1", "metadata": {}, "source": [ - "## String methods\n", + "## Métodos de cadenas\n", "\n", - "Strings provide methods that perform a variety of useful operations. \n", - "A method is similar to a function -- it takes arguments and returns a value -- but the syntax is different.\n", - "For example, the method `upper` takes a string and returns a new string with all uppercase letters.\n", + "Las cadenas proporcionan métodos que realizan una variedad de operaciones útiles.\n", + "Un método es similar a una función -- recibe argumentos y devuelve un valor -- pero la sintaxis es diferente.\n", + "Por ejemplo, el método `upper` recibe una cadena y devuelve una cadena nueva con todas las letras en mayúsculas.\n", "\n", - "Instead of the function syntax `upper(word)`, it uses the method syntax `word.upper()`." + "En lugar de la sintaxis de función `upper(word)`, usa la sintaxis de método `word.upper()`." ] }, { @@ -497,10 +496,10 @@ "id": "1ac41744", "metadata": {}, "source": [ - "This use of the dot operator specifies the name of the method, `upper`, and the name of the string to apply the method to, `word`.\n", - "The empty parentheses indicate that this method takes no arguments.\n", + "Este uso del operador punto especifica el nombre del método, `upper`, y el nombre de la cadena al que aplicar el método, `word`.\n", + "Los paréntesis vacíos indican que este método no toma argumentos.\n", "\n", - "A method call is called an **invocation**; in this case, we would say that we are invoking `upper` on `word`." + "Una llamada a método se llama **invocación**; en este caso, diríamos que estamos invocando `upper` sobre `word`." ] }, { @@ -510,10 +509,10 @@ "tags": [] }, "source": [ - "## Writing files\n", + "## Escribir archivos\n", "\n", - "String operators and methods are useful for reading and writing text files.\n", - "As an example, we'll work with the text of *Dracula*, a novel by Bram Stoker that is available from Project Gutenberg ()." + "Los operadores y métodos de cadena son útiles para leer y escribir archivos de texto.\n", + "Como ejemplo, trabajaremos con el texto de *Dracula*, una novela de Bram Stoker que está disponible en Project Gutenberg ()." ] }, { @@ -531,7 +530,7 @@ "id": "963dda79", "metadata": {}, "source": [ - "I've downloaded the book in a plain text file called `pg345.txt`, which we can open for reading like this:" + "He descargado el libro en un archivo de texto plano llamado `pg345.txt`, que podemos abrir para lectura así:" ] }, { @@ -547,11 +546,11 @@ "id": "b5d99e8c", "metadata": {}, "source": [ - "In addition to the text of the book, this file contains a section at the beginning with information about the book and a section at the end with information about the license.\n", - "Before we process the text, we can remove this extra material by finding the special lines at the beginning and end that begin with `'***'`.\n", + "Además del texto del libro, este archivo contiene una sección al principio con información sobre el libro y una sección al final con información sobre la licencia.\n", + "Antes de procesar el texto, podemos eliminar este material extra encontrando las líneas especiales al principio y al final que empiezan con `'***'`.\n", "\n", - "The following function takes a line and checks whether it is one of the special lines.\n", - "It uses the `startswith` method, which checks whether a string starts with a given sequence of characters." + "La siguiente función recibe una línea y comprueba si es una de las líneas especiales.\n", + "Usa el método `startswith`, que comprueba si una cadena empieza con una secuencia determinada de caracteres." ] }, { @@ -567,7 +566,7 @@ "id": "2efdfe35", "metadata": {}, "source": [ - "We can use this function to loop through the lines in the file and print only the special lines." + "Podemos usar esta función para recorrer las líneas del archivo e imprimir solo las líneas especiales." ] }, { @@ -583,9 +582,9 @@ "id": "07fb5992", "metadata": {}, "source": [ - "Now let's create a new file, called `pg345_cleaned.txt`, that contains only the text of the book.\n", - "In order to loop through the book again, we have to open it again for reading.\n", - "And, to write a new file, we can open it for writing." + "Ahora creemos un archivo nuevo, llamado `pg345_cleaned.txt`, que contenga solo el texto del libro.\n", + "Para recorrer el libro de nuevo, tenemos que abrirlo otra vez para lectura.\n", + "Y, para escribir un archivo nuevo, podemos abrirlo para escritura." ] }, { @@ -601,10 +600,10 @@ "id": "96d881aa", "metadata": {}, "source": [ - "`open` takes an optional parameters that specifies the \"mode\" -- in this example, `'w'` indicates that we're opening the file for writing.\n", - "If the file doesn't exist, it will be created; if it already exists, the contents will be replaced.\n", + "`open` recibe un parámetro opcional que especifica el \"modo\" -- en este ejemplo, `'w'` indica que estamos abriendo el archivo para escritura.\n", + "Si el archivo no existe, se creará; si ya existe, el contenido será reemplazado.\n", "\n", - "As a first step, we'll loop through the file until we find the first special line." + "Como primer paso, recorreremos el archivo hasta encontrar la primera línea especial." ] }, { @@ -620,9 +619,9 @@ "id": "1989d5a1", "metadata": {}, "source": [ - "The `break` statement \"breaks\" out of the loop -- that is, it causes the loop to end immediately, before we get to the end of the file.\n", + "La sentencia `break` \"rompe\" el bucle -- es decir, hace que el bucle termine inmediatamente, antes de llegar al final del archivo.\n", "\n", - "When the loop exits, `line` contains the special line that made the conditional true." + "Cuando el bucle termina, `line` contiene la línea especial que hizo que la condición fuera verdadera." ] }, { @@ -638,11 +637,11 @@ "id": "9f28c3b4", "metadata": {}, "source": [ - "Because `reader` keeps track of where it is in the file, we can use a second loop to pick up where we left off.\n", + "Como `reader` lleva la cuenta de en qué parte del archivo está, podemos usar un segundo bucle para continuar donde lo dejamos.\n", "\n", - "The following loop reads the rest of the file, one line at a time.\n", - "When it finds the special line that indicates the end of the text, it breaks out of the loop.\n", - "Otherwise, it writes the line to the output file." + "El siguiente bucle lee el resto del archivo, una línea cada vez.\n", + "Cuando encuentra la línea especial que indica el final del texto, rompe el bucle.\n", + "En caso contrario, escribe la línea en el archivo de salida." ] }, { @@ -658,7 +657,7 @@ "id": "c07032a4", "metadata": {}, "source": [ - "When this loop exits, `line` contains the second special line." + "Cuando este bucle termina, `line` contiene la segunda línea especial." ] }, { @@ -674,8 +673,8 @@ "id": "0c30b41c", "metadata": {}, "source": [ - "At this point `reader` and `writer` are still open, which means we could keep reading lines from `reader` or writing lines to `writer`.\n", - "To indicate that we're done, we can close both files by invoking the `close` method." + "En este punto `reader` y `writer` siguen abiertos, lo que significa que podríamos seguir leyendo líneas de `reader` o escribiendo líneas en `writer`.\n", + "Para indicar que hemos terminado, podemos cerrar ambos archivos invocando el método `close`." ] }, { @@ -691,7 +690,7 @@ "id": "d5084cdc", "metadata": {}, "source": [ - "To check whether this process was successful, we can read the first few lines from the new file we just created." + "Para comprobar si este proceso tuvo éxito, podemos leer las primeras líneas del archivo nuevo que acabamos de crear." ] }, { @@ -707,7 +706,7 @@ "id": "34c93df3", "metadata": {}, "source": [ - "The `endswidth` method checks whether a string ends with a given sequence of characters." + "El método `endswith` comprueba si una cadena termina con una secuencia determinada de caracteres." ] }, { @@ -715,12 +714,12 @@ "id": "fcdb4bbf", "metadata": {}, "source": [ - "## Find and replace\n", + "## Buscar y reemplazar\n", "\n", - "In the Icelandic translation of *Dracula* from 1901, the name of one of the characters was changed from \"Jonathan\" to \"Thomas\".\n", - "To make this change in the English version, we can loop through the book, use the `replace` method to replace one name with another, and write the result to a new file.\n", + "En la traducción islandesa de *Dracula* de 1901, el nombre de uno de los personajes se cambió de \"Jonathan\" a \"Thomas\".\n", + "Para hacer este cambio en la versión inglesa, podemos recorrer el libro, usar el método `replace` para reemplazar un nombre por otro y escribir el resultado en un archivo nuevo.\n", "\n", - "We'll start by counting the lines in the cleaned version of the file." + "Empezaremos contando las líneas en la versión limpia del archivo." ] }, { @@ -736,7 +735,7 @@ "id": "8ba9b9ca", "metadata": {}, "source": [ - "To see whether a line contains \"Jonathan\", we can use the `in` operator, which checks whether this sequence of characters appears anywhere in the line." + "Para ver si una línea contiene \"Jonathan\", podemos usar el operador `in`, que comprueba si esta secuencia de caracteres aparece en cualquier parte de la línea." ] }, { @@ -752,8 +751,8 @@ "id": "27805245", "metadata": {}, "source": [ - "There are 199 lines that contain the name, but that's not quite the total number of times it appears, because it can appear more than once in a line.\n", - "To get the total, we can use the `count` method, which returns the number of times a sequence appears in a string." + "Hay 199 líneas que contienen el nombre, pero ese no es exactamente el número total de veces que aparece, porque puede aparecer más de una vez en una línea.\n", + "Para obtener el total, podemos usar el método `count`, que devuelve el número de veces que una secuencia aparece en una cadena." ] }, { @@ -769,7 +768,7 @@ "id": "68026797", "metadata": {}, "source": [ - "Now we can replace `'Jonathan'` with `'Thomas'` like this:" + "Ahora podemos reemplazar `'Jonathan'` por `'Thomas'` así:" ] }, { @@ -785,7 +784,7 @@ "id": "57ba56f3", "metadata": {}, "source": [ - "The result is a new file called `pg345_replaced.txt` that contains a version of *Dracula* where Jonathan Harker is called Thomas." + "El resultado es un archivo nuevo llamado `pg345_replaced.txt` que contiene una versión de *Dracula* donde Jonathan Harker se llama Thomas." ] }, { @@ -803,15 +802,15 @@ "id": "cc9af187", "metadata": {}, "source": [ - "## Regular expressions\n", + "## Expresiones regulares\n", "\n", - "If we know exactly what sequence of characters we're looking for, we can use the `in` operator to find it and the `replace` method to replace it.\n", - "But there is another tool, called a **regular expression** that can also perform these operations -- and a lot more.\n", + "Si sabemos exactamente qué secuencia de caracteres estamos buscando, podemos usar el operador `in` para encontrarla y el método `replace` para reemplazarla.\n", + "Pero hay otra herramienta, llamada **expresión regular**, que también puede realizar estas operaciones -- y muchas más.\n", "\n", - "To demonstrate, I'll start with a simple example and we'll work our way up.\n", - "Suppose, again, that we want to find all lines that contain a particular word.\n", - "For a change, let's look for references to the titular character of the book, Count Dracula.\n", - "Here's a line that mentions him." + "Para demostrarlo, empezaré con un ejemplo sencillo y avanzaremos poco a poco.\n", + "Supongamos, otra vez, que queremos encontrar todas las líneas que contienen una palabra concreta.\n", + "Para variar, busquemos referencias al personaje titular del libro, el conde Dracula.\n", + "Aquí tienes una línea que lo menciona." ] }, { @@ -827,7 +826,7 @@ "id": "d4fd6d11", "metadata": {}, "source": [ - "And here's the **pattern** we'll use to search." + "Y aquí está el **patrón** que usaremos para buscar." ] }, { @@ -843,8 +842,8 @@ "id": "268f647c", "metadata": {}, "source": [ - "A module called `re` provides functions related to regular expressions.\n", - "We can import it like this and use the `search` function to check whether the pattern appears in the text." + "Un módulo llamado `re` proporciona funciones relacionadas con expresiones regulares.\n", + "Podemos importarlo así y usar la función `search` para comprobar si el patrón aparece en el texto." ] }, { @@ -860,8 +859,8 @@ "id": "e17f6731", "metadata": {}, "source": [ - "If the pattern appears in the text, `search` returns a `Match` object that contains the results of the search.\n", - "Among other information, it has a variable named `string` that contains the text that was searched." + "Si el patrón aparece en el texto, `search` devuelve un objeto `Match` que contiene los resultados de la búsqueda.\n", + "Entre otra información, tiene una variable llamada `string` que contiene el texto en el que se buscó." ] }, { @@ -877,7 +876,7 @@ "id": "a8eab0f6", "metadata": {}, "source": [ - "It also provides a method called `group` that returns the part of the text that matched the pattern." + "También proporciona un método llamado `group` que devuelve la parte del texto que coincidió con el patrón." ] }, { @@ -893,7 +892,7 @@ "id": "b6962a7d", "metadata": {}, "source": [ - "And it provides a method called `span` that returns the index in the text where the pattern starts and ends." + "Y proporciona un método llamado `span` que devuelve el índice en el texto donde empieza y termina el patrón." ] }, { @@ -909,7 +908,7 @@ "id": "8f1e5261", "metadata": {}, "source": [ - "If the pattern doesn't appear in the text, the return value from `search` is `None`." + "Si el patrón no aparece en el texto, el valor de retorno de `search` es `None`." ] }, { @@ -925,7 +924,7 @@ "id": "d5ed33ff", "metadata": {}, "source": [ - "So we can check whether the search was successful by checking whether the result is `None`." + "Así que podemos comprobar si la búsqueda tuvo éxito comprobando si el resultado es `None`." ] }, { @@ -941,7 +940,7 @@ "id": "a08e38f6", "metadata": {}, "source": [ - "Putting all that together, here's a function that loops through the lines in the book until it finds one that matches the given pattern, and returns the `Match` object." + "Juntando todo eso, aquí tienes una función que recorre las líneas del libro hasta encontrar una que coincida con el patrón dado, y devuelve el objeto `Match`." ] }, { @@ -957,7 +956,7 @@ "id": "96570515", "metadata": {}, "source": [ - "We can use it to find the first mention of a character." + "Podemos usarla para encontrar la primera mención de un personaje." ] }, { @@ -973,12 +972,12 @@ "id": "3f687fdc", "metadata": {}, "source": [ - "For this example, we didn't have to use regular expressions -- we could have done the same thing more easily with the `in` operator.\n", - "But regular expressions can do things the `in` operator cannot.\n", + "Para este ejemplo, no tuvimos que usar expresiones regulares -- podríamos haber hecho lo mismo más fácilmente con el operador `in`.\n", + "Pero las expresiones regulares pueden hacer cosas que el operador `in` no puede.\n", "\n", - "For example, if the pattern includes the vertical bar character, `'|'`, it can match either the sequence on the left or the sequence on the right.\n", - "Suppose we want to find the first mention of Mina Murray in the book, but we are not sure whether she is referred to by first name or last.\n", - "We can use the following pattern, which matches either name." + "Por ejemplo, si el patrón incluye el carácter de barra vertical, `'|'`, puede coincidir con la secuencia de la izquierda o con la secuencia de la derecha.\n", + "Supongamos que queremos encontrar la primera mención de Mina Murray en el libro, pero no estamos seguros de si se la menciona por su nombre o por su apellido.\n", + "Podemos usar el siguiente patrón, que coincide con cualquiera de los dos nombres." ] }, { @@ -994,8 +993,8 @@ "id": "8bea66a6", "metadata": {}, "source": [ - "We can use a pattern like this to see how many times a character is mentioned by either name.\n", - "Here's a function that loops through the book and counts the number of lines that match the given pattern." + "Podemos usar un patrón como este para ver cuántas veces se menciona a un personaje por cualquiera de los dos nombres.\n", + "Aquí tienes una función que recorre el libro y cuenta el número de líneas que coinciden con el patrón dado." ] }, { @@ -1011,7 +1010,7 @@ "id": "0e753a5b", "metadata": {}, "source": [ - "Now let's see how many times Mina is mentioned." + "Ahora veamos cuántas veces se menciona a Mina." ] }, { @@ -1027,7 +1026,7 @@ "id": "780c9fab", "metadata": {}, "source": [ - "The special character `'^'` matches the beginning of a string, so we can find a line that starts with a given pattern." + "El carácter especial `'^'` coincide con el principio de una cadena, así que podemos encontrar una línea que empieza con un patrón dado." ] }, { @@ -1043,7 +1042,7 @@ "id": "332bad2e", "metadata": {}, "source": [ - "And the special character `'$'` matches the end of a string, so we can find a line that ends with a given pattern (ignoring the newline at the end)." + "Y el carácter especial `'$'` coincide con el final de una cadena, así que podemos encontrar una línea que termina con un patrón dado (ignorando el salto de línea del final)." ] }, { @@ -1059,11 +1058,11 @@ "id": "d4b22b6e", "metadata": {}, "source": [ - "## String substitution\n", + "## Sustitución de cadenas\n", "\n", - "Bram Stoker was born in Ireland, and when *Dracula* was published in 1897, he was living in England.\n", - "So we would expect him to use the British spelling of words like \"centre\" and \"colour\".\n", - "To check, we can use the following pattern, which matches either \"centre\" or the American spelling \"center\"." + "Bram Stoker nació en Irlanda, y cuando *Dracula* se publicó en 1897, vivía en Inglaterra.\n", + "Así que esperaríamos que usara la ortografía británica de palabras como \"centre\" y \"colour\".\n", + "Para comprobarlo, podemos usar el siguiente patrón, que coincide con \"centre\" o con la ortografía estadounidense \"center\"." ] }, { @@ -1079,8 +1078,8 @@ "id": "35abfd7d", "metadata": {}, "source": [ - "In this pattern, the parentheses enclose the part of the pattern the vertical bar applies to.\n", - "So this pattern matches a sequence that starts with `'cent'` and ends with either `'er'` or `'re'`." + "En este patrón, los paréntesis encierran la parte del patrón a la que se aplica la barra vertical.\n", + "Así que este patrón coincide con una secuencia que empieza con `'cent'` y termina con `'er'` o con `'re'`." ] }, { @@ -1096,10 +1095,10 @@ "id": "e5703c18", "metadata": {}, "source": [ - "As expected, he used the British spelling.\n", + "Como esperábamos, usó la ortografía británica.\n", "\n", - "We can also check whether he used the British spelling of \"colour\".\n", - "The following pattern uses the special character `'?'`, which means that the previous character is optional." + "También podemos comprobar si usó la ortografía británica de \"colour\".\n", + "El siguiente patrón usa el carácter especial `'?'`, que significa que el carácter anterior es opcional." ] }, { @@ -1115,7 +1114,7 @@ "id": "beed9a7b", "metadata": {}, "source": [ - "This pattern matches either \"colour\" with the `'u'` or \"color\" without it." + "Este patrón coincide con \"colour\" con la `'u'` o con \"color\" sin ella." ] }, { @@ -1131,10 +1130,10 @@ "id": "1a31f179", "metadata": {}, "source": [ - "Again, as expected, he used the British spelling.\n", + "De nuevo, como esperábamos, usó la ortografía británica.\n", "\n", - "Now suppose we want to produce an edition of the book with American spellings.\n", - "We can use the `sub` function in the `re` module, which does **string substitution**." + "Ahora supongamos que queremos producir una edición del libro con ortografía estadounidense.\n", + "Podemos usar la función `sub` del módulo `re`, que hace **sustitución de cadenas**." ] }, { @@ -1150,8 +1149,8 @@ "id": "04a80fc6", "metadata": {}, "source": [ - "The first argument is the pattern we want to find and replace, the second is what we want to replace it with, and the third is the string we want to search.\n", - "In the result, you can see that \"colour\" has been replaced with \"color\"." + "El primer argumento es el patrón que queremos encontrar y reemplazar, el segundo es aquello con lo que queremos reemplazarlo, y el tercero es la cadena en el que queremos buscar.\n", + "En el resultado, puedes ver que \"colour\" ha sido reemplazado por \"color\"." ] }, { @@ -1179,11 +1178,11 @@ "id": "0318507d", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "When you are reading and writing files, debugging can be tricky.\n", - "If you are working in a Jupyter notebook, you can use **shell commands** to help.\n", - "For example, to display the first few lines of a file, you can use the command `!head`, like this:" + "Cuando lees y escribes archivos, depurar puede ser complicado.\n", + "Si trabajas en un Jupyter notebook, puedes usar **comandos de shell** para ayudar.\n", + "Por ejemplo, para mostrar las primeras líneas de un archivo, puedes usar el comando `!head`, así:" ] }, { @@ -1201,8 +1200,8 @@ "id": "1d480c02", "metadata": {}, "source": [ - "The initial exclamation point, `!`, indicates that this is a shell command, which is not part of Python.\n", - "To display the last few lines, you can use `!tail`." + "El signo de exclamación inicial, `!`, indica que esto es un comando de shell, que no forma parte de Python.\n", + "Para mostrar las últimas líneas, puedes usar `!tail`." ] }, { @@ -1220,10 +1219,10 @@ "id": "6874023a", "metadata": {}, "source": [ - "When you are working with large files, debugging can be difficult because there might be too much output to check by hand.\n", - "A good debugging strategy is to start with just part of the file, get the program working, and then run it with the whole file.\n", + "Cuando trabajas con archivos grandes, depurar puede ser difícil porque puede haber demasiada salida para revisarla a mano.\n", + "Una buena estrategia de depuración es empezar con solo una parte del archivo, hacer que el programa funcione, y luego ejecutarlo con el archivo completo.\n", "\n", - "To make a small file that contains part of a larger file, we can use `!head` again with the redirect operator, `>`, which indicates that the results should be written to a file rather than displayed." + "Para crear un archivo pequeño que contenga parte de un archivo más grande, podemos usar `!head` de nuevo con el operador de redirección, `>`, que indica que los resultados deben escribirse en un archivo en lugar de mostrarse." ] }, { @@ -1239,7 +1238,7 @@ "id": "3fc851f8", "metadata": {}, "source": [ - "By default, `!head` reads the first 10 lines, but it takes an optional argument that indicates the number of lines to read." + "Por defecto, `!head` lee las primeras 10 líneas, pero recibe un argumento opcional que indica el número de líneas a leer." ] }, { @@ -1255,11 +1254,11 @@ "id": "24871c78", "metadata": {}, "source": [ - "This shell command reads the first 100 lines from `pg345_cleaned.txt` and writes them to a file called `pg345_cleaned_100_lines.txt`.\n", + "Este comando de shell lee las primeras 100 líneas de `pg345_cleaned.txt` y las escribe en un archivo llamado `pg345_cleaned_100_lines.txt`.\n", "\n", - "Note: The shell commands `!head` and `!tail` are not available on all operating systems.\n", - "If they don't work for you, we can write similar functions in Python.\n", - "See the first exercise at the end of this chapter for suggestions." + "Nota: Los comandos de shell `!head` y `!tail` no están disponibles en todos los sistemas operativos.\n", + "Si no te funcionan, podemos escribir funciones similares en Python.\n", + "Consulta el primer ejercicio al final de este capítulo para ver sugerencias." ] }, { @@ -1267,43 +1266,43 @@ "id": "c842524d", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**sequence:**\n", - " An ordered collection of values where each value is identified by an integer index.\n", + "**secuencia:**\n", + " Una colección ordenada de valores donde cada valor se identifica mediante un índice entero.\n", "\n", - "**character:**\n", - "An element of a string, including letters, numbers, and symbols.\n", + "**carácter:**\n", + "Un elemento de una cadena, incluidas letras, números y símbolos.\n", "\n", - "**index:**\n", - " An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from `0`.\n", + "**índice:**\n", + " Un valor entero usado para seleccionar un elemento en una secuencia, como un carácter en una cadena. En Python los índices empiezan desde `0`.\n", "\n", - "**slice:**\n", - " A part of a string specified by a range of indices.\n", + "**segmento:**\n", + " Una parte de una cadena especificada por un rango de índices.\n", "\n", - "**empty string:**\n", - "A string that contains no characters and has length `0`.\n", + "**cadena vacía:**\n", + "Una cadena que no contiene caracteres y tiene longitud `0`.\n", "\n", - "**object:**\n", - " Something a variable can refer to. An object has a type and a value.\n", + "**objeto:**\n", + " Algo a lo que una variable puede referirse. Un objeto tiene un tipo y un valor.\n", "\n", - "**immutable:**\n", - "If the elements of an object cannot be changed, the object is immutable.\n", + "**inmutable:**\n", + "Si los elementos de un objeto no se pueden cambiar, el objeto es inmutable.\n", "\n", - "**invocation:**\n", - " An expression -- or part of an expression -- that calls a method.\n", + "**invocación:**\n", + " Una expresión -- o parte de una expresión -- que llama a un método.\n", "\n", - "**regular expression:**\n", - "A sequence of characters that defines a search pattern.\n", + "**expresión regular:**\n", + "Una secuencia de caracteres que define un patrón de búsqueda.\n", "\n", - "**pattern:**\n", - "A rule that specifies the requirements a string has to meet to constitute a match.\n", + "**patrón:**\n", + "Una regla que especifica los requisitos que una cadena debe cumplir para constituir una coincidencia.\n", "\n", - "**string substitution:**\n", - "Replacement of a string, or part of a string, with another string.\n", + "**sustitución de cadenas:**\n", + "Reemplazo de una cadena, o parte de una cadena, por otra cadena.\n", "\n", - "**shell command:**\n", - "A statement in a shell language, which is a language used to interact with an operating system." + "**comando de shell:**\n", + "Una sentencia en un lenguaje de shell, que es un lenguaje usado para interactuar con un sistema operativo." ] }, { @@ -1311,7 +1310,7 @@ "id": "4306e765", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1339,24 +1338,24 @@ "id": "5be97ddc", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, we only scratched the surface of what regular expressions can do.\n", - "To get an idea of what's possible, ask a virtual assistant, \"What are the most common special characters used in Python regular expressions?\"\n", + "En este capítulo, apenas hemos arañado la superficie de lo que pueden hacer las expresiones regulares.\n", + "Para hacerte una idea de lo que es posible, pregunta a un asistente virtual: \"¿Cuáles son los caracteres especiales más comunes que se usan en las expresiones regulares de Python?\"\n", "\n", - "You can also ask for a pattern that matches particular kinds of strings.\n", - "For example, try asking:\n", + "También puedes pedir un patrón que coincida con tipos concretos de cadenas.\n", + "Por ejemplo, prueba a preguntar:\n", "\n", - "* Write a Python regular expression that matches a 10-digit phone number with hyphens.\n", + "* Escribe una expresión regular de Python que coincida con un número de teléfono de 10 dígitos con guiones.\n", "\n", - "* Write a Python regular expression that matches a street address with a number and a street name, followed by `ST` or `AVE`.\n", + "* Escribe una expresión regular de Python que coincida con una dirección con un número y un nombre de calle, seguida de `ST` o `AVE`.\n", "\n", - "* Write a Python regular expression that matches a full name with any common title like `Mr` or `Mrs` followed by any number of names beginning with capital letters, possibly with hyphens between some names.\n", + "* Escribe una expresión regular de Python que coincida con un nombre completo con cualquier título común como `Mr` o `Mrs`, seguido de cualquier número de nombres que empiecen con mayúsculas, posiblemente con guiones entre algunos nombres.\n", "\n", - "And if you want to see something more complicated, try asking for a regular expression that matches any legal URL.\n", + "Y si quieres ver algo más complicado, prueba a pedir una expresión regular que coincida con cualquier URL legal.\n", "\n", - "A regular expression often has the letter `r` before the quotation mark, which indicates that it is a \"raw string\".\n", - "For more information, ask a virtual assistant, \"What is a raw string in Python?\"" + "Una expresión regular a menudo tiene la letra `r` antes de la comilla, lo que indica que es una \"cadena sin procesar\".\n", + "Para más información, pregunta a un asistente virtual: \"¿Qué es una cadena sin procesar en Python?\"" ] }, { @@ -1374,13 +1373,13 @@ "id": "20dcbbb3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "See if you can write a function that does the same thing as the shell command `!head`.\n", - "It should take as arguments the name of a file to read, the number of lines to read, and the name of the file to write the lines into.\n", - "If the third parameter is `None`, it should display the lines rather than write them to a file.\n", + "Mira si puedes escribir una función que haga lo mismo que el comando de shell `!head`.\n", + "Debe recibir como argumentos el nombre de un archivo que leer, el número de líneas que leer y el nombre del archivo donde escribir las líneas.\n", + "Si el tercer parámetro es `None`, debe mostrar las líneas en lugar de escribirlas en un archivo.\n", "\n", - "Consider asking a virtual assistant for help, but if you do, tell it not to use a `with` statement or a `try` statement." + "Considera pedir ayuda a un asistente virtual, pero si lo haces, dile que no use una sentencia `with` ni una sentencia `try`." ] }, { @@ -1398,7 +1397,7 @@ "tags": [] }, "source": [ - "You can use the following examples to test your function." + "Puedes usar los siguientes ejemplos para probar tu función." ] }, { @@ -1436,18 +1435,18 @@ "id": "adb78357", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "\"Wordle\" is an online word game where the objective is to guess a five-letter word in six or fewer attempts.\n", - "Each attempt has to be recognized as a word, not including proper nouns.\n", - "After each attempt, you get information about which of the letters you guessed appear in the target word, and which ones are in the correct position.\n", + "\"Wordle\" es un juego de palabras online donde el objetivo es adivinar una palabra de cinco letras en seis intentos o menos.\n", + "Cada intento tiene que ser reconocido como una palabra, sin incluir nombres propios.\n", + "Después de cada intento, obtienes información sobre cuáles de las letras que adivinaste aparecen en la palabra objetivo, y cuáles están en la posición correcta.\n", "\n", - "For example, suppose the target word is `MOWER` and you guess `TRIED`.\n", - "You would learn that `E` is in the word and in the correct position, `R` is in the word but not in the correct position, and `T`, `I`, and `D` are not in the word.\n", + "Por ejemplo, supongamos que la palabra objetivo es `MOWER` y que intentas `TRIED`.\n", + "Aprenderías que `E` está en la palabra y en la posición correcta, `R` está en la palabra pero no en la posición correcta, y `T`, `I` y `D` no están en la palabra.\n", "\n", - "As a different example, suppose you have guessed the words `SPADE` and `CLERK`, and you've learned that `E` is in the word, but not in either of those positions, and none of the other letters appear in the word.\n", - "Of the words in the word list, how many could be the target word?\n", - "Write a function called `check_word` that takes a five-letter word and checks whether it could be the target word, given these guesses." + "Como ejemplo distinto, supongamos que has intentado las palabras `SPADE` y `CLERK`, y has aprendido que `E` está en la palabra, pero no en ninguna de esas posiciones, y que ninguna de las otras letras aparece en la palabra.\n", + "De las palabras de la lista, ¿cuántas podrían ser la palabra objetivo?\n", + "Escribe una función llamada `check_word` que reciba una palabra de cinco letras y compruebe si podría ser la palabra objetivo, dadas estas conjeturas." ] }, { @@ -1463,7 +1462,7 @@ "id": "87fdf676", "metadata": {}, "source": [ - "You can use any of the functions from the previous chapter, like `uses_any`." + "Puedes usar cualquiera de las funciones del capítulo anterior, como `uses_any`." ] }, { @@ -1483,7 +1482,7 @@ "tags": [] }, "source": [ - "You can use the following loop to test your function." + "Puedes usar el siguiente bucle para probar tu función." ] }, { @@ -1501,9 +1500,9 @@ "id": "d009cb52", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Continuing the previous exercise, suppose you guess the work `TOTEM` and learn that the `E` is *still* not in the right place, but the `M` is. How many words are left?" + "Continuando con el ejercicio anterior, supongamos que intentas la palabra `TOTEM` y aprendes que la `E` *todavía* no está en el lugar correcto, pero la `M` sí. ¿Cuántas palabras quedan?" ] }, { @@ -1527,16 +1526,16 @@ "id": "c1d0f892", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "*The Count of Monte Cristo* is a novel by Alexandre Dumas that is considered a classic.\n", - "Nevertheless, in the introduction of an English translation of the book, the writer Umberto Eco confesses that he found the book to be \"one of the most badly written novels of all time\".\n", + "*The Count of Monte Cristo* es una novela de Alexandre Dumas que se considera un clásico.\n", + "Sin embargo, en la introducción de una traducción inglesa del libro, el escritor Umberto Eco confiesa que le pareció \"una de las novelas peor escritas de todos los tiempos\".\n", "\n", - "In particular, he says it is \"shameless in its repetition of the same adjective,\" and mentions in particular the number of times \"its characters either shudder or turn pale.\"\n", + "En particular, dice que es \"desvergonzada en su repetición del mismo adjetivo\", y menciona en particular el número de veces que \"sus personajes se estremecen o palidecen\".\n", "\n", - "To see whether his objection is valid, let's count the number number of lines that contain the word `pale` in any form, including `pale`, `pales`, `paled`, and `paleness`, as well as the related word `pallor`. \n", - "Use a single regular expression that matches any of these words.\n", - "As an additional challenge, make sure that it doesn't match any other words, like `impale` -- you might want to ask a virtual assistant for help." + "Para ver si su objeción es válida, contemos el número de líneas que contienen la palabra `pale` en cualquier forma, incluidas `pale`, `pales`, `paled` y `paleness`, así como la palabra relacionada `pallor`.\n", + "Usa una sola expresión regular que coincida con cualquiera de estas palabras.\n", + "Como desafío adicional, asegúrate de que no coincida con otras palabras, como `impale` -- quizá quieras pedir ayuda a un asistente virtual." ] }, { @@ -1546,7 +1545,7 @@ "tags": [] }, "source": [ - "The following cell downloads the book from Project Gutenberg ." + "La siguiente celda descarga el libro de Project Gutenberg ." ] }, { @@ -1566,7 +1565,7 @@ "tags": [] }, "source": [ - "The following cell runs a function that reads the file from Project Gutenberg and writes a file that contains only the text of the book, not the added information about the book." + "La siguiente celda ejecuta una función que lee el archivo de Project Gutenberg y escribe un archivo que contiene solo el texto del libro, no la información añadida sobre el libro." ] }, { @@ -1610,7 +1609,7 @@ "tags": [] }, "source": [ - "By this count, these words appear on `223` lines of the book, so Mr. Eco might have a point." + "Según este recuento, estas palabras aparecen en `223` líneas del libro, así que el señor Eco quizá tenga razón." ] }, { @@ -1624,9 +1623,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/blank/chap09.ipynb b/blank/chap09.ipynb index c4cae84..f460356 100644 --- a/blank/chap09.ipynb +++ b/blank/chap09.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,12 +25,12 @@ "id": "3c25ca7e", "metadata": {}, "source": [ - "# Lists\n", + "# Listas\n", "\n", - "This chapter presents one of Python's most useful built-in types, lists.\n", - "You will also learn more about objects and what can happen when multiple variables refer to the same object.\n", + "Este capítulo presenta uno de los tipos integrados más útiles de Python: las listas.\n", + "También aprenderás más sobre objetos y lo que puede ocurrir cuando varias variables se refieren al mismo objeto.\n", "\n", - "In the exercises at the end of the chapter, we'll make a word list and use it to search for special words like palindromes and anagrams." + "En los ejercicios al final del capítulo, construiremos una lista de palabras y la usaremos para buscar palabras especiales como palíndromos y anagramas." ] }, { @@ -38,14 +38,14 @@ "id": "4d32b3e2", "metadata": {}, "source": [ - "## A list is a sequence\n", + "## Una lista es una secuencia\n", "\n", - "Like a string, a **list** is a sequence of values. In a string, the\n", - "values are characters; in a list, they can be any type.\n", - "The values in a list are called **elements**.\n", + "Como un string, una **lista** es una secuencia de valores. En un string, los\n", + "valores son caracteres; en una lista, pueden ser de cualquier tipo.\n", + "Los valores en una lista se llaman **elementos**.\n", "\n", - "There are several ways to create a new list; the simplest is to enclose the elements in square brackets (`[` and `]`).\n", - "For example, here is a list of two integers. " + "Hay varias formas de crear una nueva lista; la más simple es encerrar los elementos entre corchetes (`[` y `]`).\n", + "Por ejemplo, aquí tienes una lista de dos enteros." ] }, { @@ -61,7 +61,7 @@ "id": "b5d6112c", "metadata": {}, "source": [ - "And here's a list of three strings." + "Y aquí tienes una lista de tres strings." ] }, { @@ -77,8 +77,8 @@ "id": "dda58c67", "metadata": {}, "source": [ - "The elements of a list don't have to be the same type.\n", - "The following list contains a string, a float, an integer, and even another list." + "Los elementos de una lista no tienen que ser del mismo tipo.\n", + "La siguiente lista contiene un string, un float, un entero e incluso otra lista." ] }, { @@ -94,10 +94,10 @@ "id": "147fa217", "metadata": {}, "source": [ - "A list within another list is **nested**.\n", + "Una lista dentro de otra lista está **anidada**.\n", "\n", - "A list that contains no elements is called an empty list; you can create\n", - "one with empty brackets, `[]`." + "Una lista que no contiene elementos se llama lista vacía; puedes crear\n", + "una con corchetes vacíos, `[]`." ] }, { @@ -113,7 +113,7 @@ "id": "f95381bc", "metadata": {}, "source": [ - "The `len` function returns the length of a list." + "La función `len` devuelve la longitud de una lista." ] }, { @@ -129,7 +129,7 @@ "id": "371403a3", "metadata": {}, "source": [ - "The length of an empty list is `0`." + "La longitud de una lista vacía es `0`." ] }, { @@ -147,7 +147,7 @@ "id": "d3589a5d", "metadata": {}, "source": [ - "The following figure shows the state diagram for `cheeses`, `numbers` and `empty`." + "La siguiente figura muestra el diagrama de estado de `cheeses`, `numbers` y `empty`." ] }, { @@ -175,7 +175,7 @@ "id": "503f25d8", "metadata": {}, "source": [ - "Lists are represented by boxes with the word \"list\" outside and the numbered elements of the list inside." + "Las listas se representan con cajas con la palabra \"lista\" fuera y los elementos numerados de la lista dentro." ] }, { @@ -183,10 +183,10 @@ "id": "e0b8ff01", "metadata": {}, "source": [ - "## Lists are mutable\n", + "## Las listas son mutables\n", "\n", - "To read an element of a list, we can use the bracket operator.\n", - "The index of the first element is `0`." + "Para leer un elemento de una lista, podemos usar el operador de corchetes.\n", + "El índice del primer elemento es `0`." ] }, { @@ -202,9 +202,9 @@ "id": "9747e951", "metadata": {}, "source": [ - "Unlike strings, lists are mutable. When the bracket operator appears on\n", - "the left side of an assignment, it identifies the element of the list\n", - "that will be assigned." + "A diferencia de los strings, las listas son mutables. Cuando el operador de corchetes aparece en\n", + "el lado izquierdo de una asignación, identifica el elemento de la lista\n", + "al que se asignará el valor." ] }, { @@ -220,19 +220,19 @@ "id": "5097a517", "metadata": {}, "source": [ - "The second element of `numbers`, which used to be `123`, is now `17`.\n", + "El segundo elemento de `numbers`, que antes era `123`, ahora es `17`.\n", "\n", - "List indices work the same way as string indices:\n", + "Los índices de lista funcionan igual que los índices de string:\n", "\n", - "- Any integer expression can be used as an index.\n", + "- Cualquier expresión entera puede usarse como índice.\n", "\n", - "- If you try to read or write an element that does not exist, you get\n", - " an `IndexError`.\n", + "- Si intentas leer o escribir un elemento que no existe, obtienes\n", + " un `IndexError`.\n", "\n", - "- If an index has a negative value, it counts backward from the end of\n", - " the list.\n", + "- Si un índice tiene un valor negativo, cuenta hacia atrás desde el final de\n", + " la lista.\n", "\n", - "The `in` operator works on lists -- it checks whether a given element appears anywhere in the list." + "El operador `in` funciona con listas: comprueba si un elemento dado aparece en algún lugar de la lista." ] }, { @@ -256,7 +256,7 @@ "id": "89d01ebf", "metadata": {}, "source": [ - "Although a list can contain another list, the nested list still counts as a single element -- so in the following list, there are only four elements." + "Aunque una lista puede contener otra lista, la lista anidada sigue contando como un solo elemento; por eso, en la siguiente lista, solo hay cuatro elementos." ] }, { @@ -272,7 +272,7 @@ "id": "4e0ea41d", "metadata": {}, "source": [ - "And `10` is not considered to be an element of `t` because it is an element of a nested list, not `t`." + "Y `10` no se considera un elemento de `t` porque es un elemento de una lista anidada, no de `t`." ] }, { @@ -288,10 +288,10 @@ "id": "1ee7a4d9", "metadata": {}, "source": [ - "## List slices\n", + "## Porciones de lista\n", "\n", - "The slice operator works on lists the same way it works on strings.\n", - "The following example selects the second and third elements from a list of four letters." + "El operador de porción funciona con listas igual que con strings.\n", + "El siguiente ejemplo selecciona el segundo y el tercer elemento de una lista de cuatro letras." ] }, { @@ -307,7 +307,7 @@ "id": "bc59d952", "metadata": {}, "source": [ - "If you omit the first index, the slice starts at the beginning. " + "Si omites el primer índice, la porción empieza al principio." ] }, { @@ -323,7 +323,7 @@ "id": "1aaaae86", "metadata": {}, "source": [ - "If you omit the second, the slice goes to the end. " + "Si omites el segundo, la porción llega hasta el final." ] }, { @@ -339,7 +339,7 @@ "id": "67ad02e8", "metadata": {}, "source": [ - "So if you omit both, the slice is a copy of the whole list." + "Así que, si omites ambos, la porción es una copia de toda la lista." ] }, { @@ -355,7 +355,7 @@ "id": "9232c1ef", "metadata": {}, "source": [ - "Another way to copy a list is to use the `list` function." + "Otra forma de copiar una lista es usar la función `list`." ] }, { @@ -371,7 +371,7 @@ "id": "50e4b182", "metadata": {}, "source": [ - "Because `list` is the name of a built-in function, you should avoid using it as a variable name.\n" + "Como `list` es el nombre de una función integrada, deberías evitar usarlo como nombre de variable.\n" ] }, { @@ -379,9 +379,9 @@ "id": "1b057c0c", "metadata": {}, "source": [ - "## List operations\n", + "## Operaciones con listas\n", "\n", - "The `+` operator concatenates lists." + "El operador `+` concatena listas." ] }, { @@ -397,7 +397,7 @@ "id": "474a5c40", "metadata": {}, "source": [ - "The `*` operator repeats a list a given number of times." + "El operador `*` repite una lista un número determinado de veces." ] }, { @@ -413,7 +413,7 @@ "id": "5b33bc51", "metadata": {}, "source": [ - "No other mathematical operators work with lists, but the built-in function `sum` adds up the elements." + "Ningún otro operador matemático funciona con listas, pero la función integrada `sum` suma los elementos." ] }, { @@ -429,7 +429,7 @@ "id": "f216a14d", "metadata": {}, "source": [ - "And `min` and `max` find the smallest and largest elements." + "Y `min` y `max` encuentran el elemento más pequeño y el más grande." ] }, { @@ -453,10 +453,10 @@ "id": "533a2009", "metadata": {}, "source": [ - "## List methods\n", + "## Métodos de lista\n", "\n", - "Python provides methods that operate on lists. For example, `append`\n", - "adds a new element to the end of a list:" + "Python proporciona métodos que operan sobre listas. Por ejemplo, `append`\n", + "añade un nuevo elemento al final de una lista:" ] }, { @@ -472,7 +472,7 @@ "id": "ccc57f77", "metadata": {}, "source": [ - "`extend` takes a list as an argument and appends all of the elements:" + "`extend` toma una lista como argumento y añade todos sus elementos:" ] }, { @@ -488,8 +488,8 @@ "id": "0f39d9f6", "metadata": {}, "source": [ - "There are two methods that remove elements from a list.\n", - "If you know the index of the element you want, you can use `pop`." + "Hay dos métodos que eliminan elementos de una lista.\n", + "Si conoces el índice del elemento que quieres, puedes usar `pop`." ] }, { @@ -505,8 +505,8 @@ "id": "6729415a", "metadata": {}, "source": [ - "The return value is the element that was removed.\n", - "And we can confirm that the list has been modified." + "El valor de retorno es el elemento que se eliminó.\n", + "Y podemos confirmar que la lista se ha modificado." ] }, { @@ -522,7 +522,7 @@ "id": "1e97ee7d", "metadata": {}, "source": [ - "If you know the element you want to remove (but not the index), you can use `remove`:" + "Si conoces el elemento que quieres eliminar (pero no el índice), puedes usar `remove`:" ] }, { @@ -538,8 +538,8 @@ "id": "60e710fe", "metadata": {}, "source": [ - "The return value from `remove` is `None`.\n", - "But we can confirm that the list has been modified." + "El valor de retorno de `remove` es `None`.\n", + "Pero podemos confirmar que la lista se ha modificado." ] }, { @@ -555,7 +555,7 @@ "id": "2a9448a8", "metadata": {}, "source": [ - "If the element you ask for is not in the list, that's a ValueError." + "Si el elemento que pides no está en la lista, eso es un ValueError." ] }, { @@ -573,11 +573,11 @@ "id": "18305f96", "metadata": {}, "source": [ - "## Lists and strings\n", + "## Listas y strings\n", "\n", - "A string is a sequence of characters and a list is a sequence of values,\n", - "but a list of characters is not the same as a string. \n", - "To convert from a string to a list of characters, you can use the `list` function." + "Un string es una secuencia de caracteres y una lista es una secuencia de valores,\n", + "pero una lista de caracteres no es lo mismo que un string.\n", + "Para convertir un string en una lista de caracteres, puedes usar la función `list`." ] }, { @@ -593,8 +593,8 @@ "id": "0291ef69", "metadata": {}, "source": [ - "The `list` function breaks a string into individual letters.\n", - "If you want to break a string into words, you can use the `split` method:" + "La función `list` divide un string en letras individuales.\n", + "Si quieres dividir un string en palabras, puedes usar el método `split`:" ] }, { @@ -610,7 +610,7 @@ "id": "0e16909d", "metadata": {}, "source": [ - "An optional argument called a **delimiter** specifies which characters to use as word boundaries. The following example uses a hyphen as a delimiter." + "Un argumento opcional llamado **delimitador** especifica qué caracteres se usan como límites entre palabras. El siguiente ejemplo usa un guion como delimitador." ] }, { @@ -626,8 +626,8 @@ "id": "7c61f916", "metadata": {}, "source": [ - "If you have a list of strings, you can concatenate them into a single string using `join`.\n", - "`join` is a string method, so you have to invoke it on the delimiter and pass the list as an argument." + "Si tienes una lista de strings, puedes concatenarlos en un solo string usando `join`.\n", + "`join` es un método de string, así que tienes que invocarlo sobre el delimitador y pasar la lista como argumento." ] }, { @@ -643,9 +643,9 @@ "id": "bedd842b", "metadata": {}, "source": [ - "In this case the delimiter is a space character, so `join` puts a space\n", - "between words.\n", - "To join strings without spaces, you can use the empty string, `''`, as a delimiter." + "En este caso el delimitador es un carácter de espacio, así que `join` pone un espacio\n", + "entre las palabras.\n", + "Para unir strings sin espacios, puedes usar el string vacío, `''`, como delimitador." ] }, { @@ -653,9 +653,9 @@ "id": "181215ce", "metadata": {}, "source": [ - "## Looping through a list\n", + "## Recorrer una lista con un bucle\n", "\n", - "You can use a `for` statement to loop through the elements of a list." + "Puedes usar una sentencia `for` para recorrer los elementos de una lista." ] }, { @@ -671,7 +671,7 @@ "id": "c0e53a09", "metadata": {}, "source": [ - "For example, after using `split` to make a list of words, we can use `for` to loop through them." + "Por ejemplo, después de usar `split` para crear una lista de palabras, podemos usar `for` para recorrerlas." ] }, { @@ -687,7 +687,7 @@ "id": "0857b55b", "metadata": {}, "source": [ - "A `for` loop over an empty list never runs the indented statements." + "Un bucle `for` sobre una lista vacía nunca ejecuta las sentencias indentadas." ] }, { @@ -703,9 +703,9 @@ "id": "6e5f55c9", "metadata": {}, "source": [ - "## Sorting lists\n", + "## Ordenar listas\n", "\n", - "Python provides a built-in function called `sorted` that sorts the elements of a list." + "Python proporciona una función integrada llamada `sorted` que ordena los elementos de una lista." ] }, { @@ -721,7 +721,7 @@ "id": "44e028cf", "metadata": {}, "source": [ - "The original list is unchanged." + "La lista original no cambia." ] }, { @@ -737,7 +737,7 @@ "id": "530146af", "metadata": {}, "source": [ - "`sorted` works with any kind of sequence, not just lists. So we can sort the letters in a string like this." + "`sorted` funciona con cualquier tipo de secuencia, no solo con listas. Así que podemos ordenar las letras de un string así." ] }, { @@ -753,8 +753,8 @@ "id": "f90bd9ea", "metadata": {}, "source": [ - "The result it a list.\n", - "To convert the list to a string, we can use `join`." + "El resultado es una lista.\n", + "Para convertir la lista en un string, podemos usar `join`." ] }, { @@ -770,7 +770,7 @@ "id": "a57084e2", "metadata": {}, "source": [ - "With an empty string as the delimiter, the elements of the list are joined with nothing between them." + "Con un string vacío como delimitador, los elementos de la lista se unen sin nada entre ellos." ] }, { @@ -778,9 +778,9 @@ "id": "ce98b3d5", "metadata": {}, "source": [ - "## Objects and values\n", + "## Objetos y valores\n", "\n", - "If we run these assignment statements:" + "Si ejecutamos estas sentencias de asignación:" ] }, { @@ -796,8 +796,8 @@ "id": "33d020aa", "metadata": {}, "source": [ - "We know that `a` and `b` both refer to a string, but we don't know whether they refer to the *same* string. \n", - "There are two possible states, shown in the following figure." + "Sabemos que `a` y `b` se refieren ambos a un string, pero no sabemos si se refieren al *mismo* string.\n", + "Hay dos estados posibles, mostrados en la siguiente figura." ] }, { @@ -825,9 +825,9 @@ "id": "2f0b0431", "metadata": {}, "source": [ - "In the diagram on the left, `a` and `b` refer to two different objects that have the\n", - "same value. In the diagram on the right, they refer to the same object.\n", - "To check whether two variables refer to the same object, you can use the `is` operator." + "En el diagrama de la izquierda, `a` y `b` se refieren a dos objetos diferentes que tienen el\n", + "mismo valor. En el diagrama de la derecha, se refieren al mismo objeto.\n", + "Para comprobar si dos variables se refieren al mismo objeto, puedes usar el operador `is`." ] }, { @@ -843,9 +843,9 @@ "id": "d1eb0e36", "metadata": {}, "source": [ - "In this example, Python only created one string object, and both `a`\n", - "and `b` refer to it.\n", - "But when you create two lists, you get two objects." + "En este ejemplo, Python solo creó un objeto string, y tanto `a`\n", + "como `b` se refieren a él.\n", + "Pero cuando creas dos listas, obtienes dos objetos." ] }, { @@ -861,7 +861,7 @@ "id": "a8d4c3d4", "metadata": {}, "source": [ - "So the state diagram looks like this." + "Así que el diagrama de estado se ve así." ] }, { @@ -889,8 +889,8 @@ "id": "cc115a9f", "metadata": {}, "source": [ - "In this case we would say that the two lists are **equivalent**, because they have the same elements, but not **identical**, because they are not the same object. \n", - "If two objects are identical, they are also equivalent, but if they are equivalent, they are not necessarily identical." + "En este caso diríamos que las dos listas son **equivalentes**, porque tienen los mismos elementos, pero no **idénticos**, porque no son el mismo objeto.\n", + "Si dos objetos son idénticos, también son equivalentes, pero si son equivalentes, no necesariamente son idénticos." ] }, { @@ -900,7 +900,7 @@ "source": [ "## Aliasing\n", "\n", - "If `a` refers to an object and you assign `b = a`, then both variables refer to the same object." + "Si `a` se refiere a un objeto y asignas `b = a`, entonces ambas variables se refieren al mismo objeto." ] }, { @@ -916,7 +916,7 @@ "id": "f6ab3262", "metadata": {}, "source": [ - "So the state diagram looks like this." + "Así que el diagrama de estado se ve así." ] }, { @@ -944,12 +944,12 @@ "id": "c676fde9", "metadata": {}, "source": [ - "The association of a variable with an object is called a **reference**.\n", - "In this example, there are two references to the same object.\n", + "La asociación de una variable con un objeto se llama **referencia**.\n", + "En este ejemplo, hay dos referencias al mismo objeto.\n", "\n", - "An object with more than one reference has more than one name, so we say the object is **aliased**.\n", - "If the aliased object is mutable, changes made with one name affect the other.\n", - "In this example, if we change the object `b` refers to, we are also changing the object `a` refers to." + "Un objeto con más de una referencia tiene más de un nombre, así que decimos que el objeto está **aliased**.\n", + "Si el aliased objeto es mutable, los cambios hechos con un nombre afectan al otro.\n", + "En este ejemplo, si cambiamos el objeto al que se refiere `b`, también estamos cambiando el objeto al que se refiere `a`." ] }, { @@ -965,12 +965,12 @@ "id": "e3ef0537", "metadata": {}, "source": [ - "So we would say that `a` \"sees\" this change.\n", - "Although this behavior can be useful, it is error-prone.\n", - "In general, it is safer to avoid aliasing when you are working with mutable objects.\n", + "Así que diríamos que `a` \"ve\" este cambio.\n", + "Aunque este comportamiento puede ser útil, es propenso a errores.\n", + "En general, es más seguro evitar el aliasing cuando trabajas con objetos mutables.\n", "\n", - "For immutable objects like strings, aliasing is not as much of a problem.\n", - "In this example:" + "Para objetos inmutables como strings, el aliasing no supone tanto problema.\n", + "En este ejemplo:" ] }, { @@ -986,8 +986,8 @@ "id": "952bbf60", "metadata": {}, "source": [ - "It almost never makes a difference whether `a` and `b` refer to the same\n", - "string or not." + "Casi nunca importa si `a` y `b` se refieren al mismo\n", + "string o no." ] }, { @@ -995,11 +995,11 @@ "id": "35045bef", "metadata": {}, "source": [ - "## List arguments\n", + "## Listas como argumentos\n", "\n", - "When you pass a list to a function, the function gets a reference to the\n", - "list. If the function modifies the list, the caller sees the change. For\n", - "example, `pop_first` uses the list method `pop` to remove the first element from a list." + "Cuando pasas una lista a una función, la función recibe una referencia a la\n", + "lista. Si la función modifica la lista, el código que llama ve el cambio. Por\n", + "ejemplo, `pop_first` usa el método de lista `pop` para eliminar el primer elemento de una lista." ] }, { @@ -1015,7 +1015,7 @@ "id": "4953b0f9", "metadata": {}, "source": [ - "We can use it like this." + "Podemos usarla así." ] }, { @@ -1031,7 +1031,7 @@ "id": "ef5d3c1e", "metadata": {}, "source": [ - "The return value is the first element, which has been removed from the list -- as we can see by displaying the modified list." + "El valor de retorno es el primer elemento, que se ha eliminado de la lista, como podemos ver al mostrar la lista modificada." ] }, { @@ -1047,7 +1047,7 @@ "id": "e5288e08", "metadata": {}, "source": [ - "In this example, the parameter `lst` and the variable `letters` are aliases for the same object, so the state diagram looks like this:" + "En este ejemplo, el parameter `lst` y la variable `letters` son aliases del mismo objeto, así que el diagrama de estado se ve así:" ] }, { @@ -1075,8 +1075,8 @@ "id": "c1a093d2", "metadata": {}, "source": [ - "Passing a reference to an object as an argument to a function creates a form of aliasing.\n", - "If the function modifies the object, those changes persist after the function is done." + "Pasar una referencia a un objeto como argumento a una función crea una forma de aliasing.\n", + "Si la función modifica el objeto, esos cambios persisten después de que la función termine." ] }, { @@ -1086,12 +1086,12 @@ "tags": [] }, "source": [ - "## Making a word list\n", + "## Crear una lista de palabras\n", "\n", - "In the previous chapter, we read the file `words.txt` and searched for words with certain properties, like using the letter `e`.\n", - "But we read the entire file many times, which is not efficient.\n", - "It is better to read the file once and put the words in a list.\n", - "The following loop shows how." + "En el capítulo anterior, leímos el archivo `words.txt` y buscamos palabras con ciertas propiedades, como usar la letra `e`.\n", + "Pero leímos el archivo completo muchas veces, lo cual no es eficiente.\n", + "Es mejor leer el archivo una vez y poner las palabras en una lista.\n", + "El siguiente bucle muestra cómo hacerlo." ] }, { @@ -1117,11 +1117,11 @@ "id": "44450ffa", "metadata": {}, "source": [ - "Before the loop, `word_list` is initialized with an empty list.\n", - "Each time through the loop, the `append` method adds a word to the end.\n", - "When the loop is done, there are more than 113,000 words in the list.\n", + "Antes del bucle, `word_list` se inicializa con una lista vacía.\n", + "Cada vez que pasa por el bucle, el método `append` añade una palabra al final.\n", + "Cuando termina el bucle, hay más de 113 000 palabras en la lista.\n", "\n", - "Another way to do the same thing is to use `read` to read the entire file into a string." + "Otra forma de hacer lo mismo es usar `read` para leer todo el archivo en un string." ] }, { @@ -1137,8 +1137,8 @@ "id": "65718c7f", "metadata": {}, "source": [ - "The result is a single string with more than a million characters.\n", - "We can use the `split` method to split it into a list of words." + "El resultado es un único string con más de un millón de caracteres.\n", + "Podemos usar el método `split` para dividirlo en una lista de palabras." ] }, { @@ -1154,8 +1154,8 @@ "id": "1b5b25a3", "metadata": {}, "source": [ - "Now, to check whether a string appears in the list, we can use the `in` operator.\n", - "For example, `'demotic'` is in the list." + "Ahora, para comprobar si un string aparece en la lista, podemos usar el operador `in`.\n", + "Por ejemplo, `'demotic'` está en la lista." ] }, { @@ -1171,7 +1171,7 @@ "id": "9df6674d", "metadata": {}, "source": [ - "But `'contrafibularities'` is not." + "Pero `'contrafibularities'` no está." ] }, { @@ -1187,7 +1187,7 @@ "id": "243c25b6", "metadata": {}, "source": [ - "And I have to say, I'm anaspeptic about it." + "Y tengo que decir que eso me deja anaspeptic." ] }, { @@ -1195,12 +1195,12 @@ "id": "ce9ffd79", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Note that most list methods modify the argument and return `None`.\n", - "This is the opposite of the string methods, which return a new string and leave the original alone.\n", + "Ten en cuenta que la mayoría de métodos de lista modifican el argumento y devuelven `None`.\n", + "Esto es lo contrario de los métodos de string, que devuelven un nuevo string y dejan el original intacto.\n", "\n", - "If you are used to writing string code like this:" + "Si estás acostumbrado a escribir código con strings así:" ] }, { @@ -1216,7 +1216,7 @@ "id": "d2117582", "metadata": {}, "source": [ - "It is tempting to write list code like this:" + "Es tentador escribir código con listas así:" ] }, { @@ -1232,7 +1232,7 @@ "id": "991c439d", "metadata": {}, "source": [ - "`remove` modifies the list and returns `None`, so next operation you perform with `t` is likely to fail." + "`remove` modifica la lista y devuelve `None`, así que la siguiente operación que realices con `t` probablemente fallará." ] }, { @@ -1250,11 +1250,11 @@ "id": "c500e2d8", "metadata": {}, "source": [ - "This error message takes some explaining.\n", - "An **attribute** of an object is a variable or method associated with it.\n", - "In this case, the value of `t` is `None`, which is a `NoneType` object, which does not have a attribute named `remove`, so the result is an `AttributeError`.\n", + "Este mensaje de error requiere algo de explicación.\n", + "Un **atributo** de un objeto es una variable o método asociado con él.\n", + "En este caso, el valor de `t` es `None`, que es un objeto `NoneType`, que no tiene un atributo llamado `remove`, así que el resultado es un `AttributeError`.\n", "\n", - "If you see an error message like this, you should look backward through the program and see if you might have called a list method incorrectly." + "Si ves un mensaje de error como este, deberías mirar hacia atrás en el programa y ver si podrías haber llamado incorrectamente a un método de lista." ] }, { @@ -1262,34 +1262,34 @@ "id": "f90db780", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**list:**\n", - " An object that contains a sequence of values.\n", + "**lista:**\n", + " Un objeto que contiene una secuencia de valores.\n", "\n", - "**element:**\n", - " One of the values in a list or other sequence.\n", + "**elemento:**\n", + " Uno de los valores de una lista u otra secuencia.\n", "\n", - "**nested list:**\n", - "A list that is an element of another list.\n", + "**lista anidada:**\n", + "Una lista que es un elemento de otra lista.\n", "\n", - "**delimiter:**\n", - " A character or string used to indicate where a string should be split.\n", + "**delimitador:**\n", + " Un carácter o string usado para indicar dónde debe dividirse un string.\n", "\n", - "**equivalent:**\n", - " Having the same value.\n", + "**equivalentes:**\n", + " Tener el mismo valor.\n", "\n", - "**identical:**\n", - " Being the same object (which implies equivalence).\n", + "**idénticos:**\n", + " Ser el mismo objeto (lo que implica equivalencia).\n", "\n", - "**reference:**\n", - " The association between a variable and its value.\n", + "**referencia:**\n", + " La asociación entre una variable y su valor.\n", "\n", "**aliased:**\n", - "If there is more than one variable that refers to an object, the object is aliased.\n", + "Si hay más de una variable que se refiere a un objeto, el objeto está aliased.\n", "\n", - "**attribute:**\n", - " One of the named values associated with an object." + "**atributo:**\n", + " Uno de los valores con nombre asociados con un objeto." ] }, { @@ -1297,7 +1297,7 @@ "id": "e67864e5", "metadata": {}, "source": [ - "## Exercises\n", + "## Ejercicios\n", "\n" ] }, @@ -1316,24 +1316,24 @@ "id": "ae9c42da", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, I used the words \"contrafibularities\" and \"anaspeptic\", but they are not actually English words.\n", - "They were used in the British television show *Black Adder*, Season 3, Episode 2, \"Ink and Incapability\".\n", + "En este capítulo, usé las palabras \"contrafibularities\" y \"anaspeptic\", pero en realidad no son palabras en inglés.\n", + "Se usaron en la serie de televisión británica *Black Adder*, temporada 3, episodio 2, \"Ink and Incapability\".\n", "\n", - "However, when I asked ChatGPT 3.5 (August 3, 2023 version) where those words came from, it initially claimed they are from Monty Python, and later claimed they are from the Tom Stoppard play *Rosencrantz and Guildenstern Are Dead*.\n", + "Sin embargo, cuando pregunté a ChatGPT 3.5 (versión del 3 de agosto de 2023) de dónde venían esas palabras, al principio afirmó que eran de Monty Python, y después afirmó que eran de la obra de Tom Stoppard *Rosencrantz and Guildenstern Are Dead*.\n", "\n", - "If you ask now, you might get different results.\n", - "But this example is a reminder that virtual assistants are not always accurate, so you should check whether the results are correct.\n", - "As you gain experience, you will get a sense of which questions virtual assistants can answer reliably.\n", - "In this example, a conventional web search can identify the source of these words quickly.\n", + "Si preguntas ahora, podrías obtener resultados diferentes.\n", + "Pero este ejemplo es un recordatorio de que los asistentes virtuales no siempre son precisos, así que deberías comprobar si los resultados son correctos.\n", + "A medida que ganes experiencia, desarrollarás intuición sobre qué preguntas pueden responder de forma fiable los asistentes virtuales.\n", + "En este ejemplo, una búsqueda web convencional puede identificar rápidamente el origen de estas palabras.\n", "\n", - "If you get stuck on any of the exercises in this chapter, consider asking a virtual assistant for help.\n", - "If you get a result that uses features we haven't learned yet, you can assign the VA a \"role\".\n", + "Si te quedas atascado en alguno de los ejercicios de este capítulo, considera pedir ayuda a un asistente virtual.\n", + "Si obtienes un resultado que usa características que todavía no hemos aprendido, puedes asignar un \"role\" al asistente virtual.\n", "\n", - "For example, before you ask a question try typing \"Role: Basic Python Programming Instructor\".\n", - "After that, the responses you get should use only basic features.\n", - "If you still see features we you haven't learned, you can follow up with \"Can you write that using only basic Python features?\"" + "Por ejemplo, antes de hacer una pregunta prueba a escribir \"Role: Basic Python Programming Instructor\".\n", + "Después de eso, las respuestas que obtengas deberían usar solo características básicas.\n", + "Si todavía ves características que no hemos aprendido, puedes continuar con \"Can you write that using only basic Python features?\"" ] }, { @@ -1341,15 +1341,15 @@ "id": "31d5b304", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Two words are anagrams if you can rearrange the letters from one to spell the other.\n", - "For example, `tops` is an anagram of `stop`.\n", + "Dos palabras son anagramas si puedes reordenar las letras de una para escribir la otra.\n", + "Por ejemplo, `tops` es un anagrama de `stop`.\n", "\n", - "One way to check whether two words are anagrams is to sort the letters in both words.\n", - "If the lists of sorted letters are the same, the words are anagrams.\n", + "Una forma de comprobar si dos palabras son anagramas es ordenar las letras de ambas palabras.\n", + "Si las listas de letras ordenadas son iguales, las palabras son anagramas.\n", "\n", - "Write a function called `is_anagram` that takes two strings and returns `True` if they are anagrams." + "Escribe una función llamada `is_anagram` que tome dos strings y devuelva `True` si son anagramas." ] }, { @@ -1359,7 +1359,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1387,7 +1387,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1405,7 +1405,7 @@ "id": "8501f3ba", "metadata": {}, "source": [ - "Using your function and the word list, find all the anagrams of `takes`." + "Usando tu función y la lista de palabras, encuentra todos los anagramas de `takes`." ] }, { @@ -1421,9 +1421,9 @@ "id": "7f279f2f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Python provides a built-in function called `reversed` that takes as an argument a sequence of elements -- like a list or string -- and returns a `reversed` object that contains the elements in reverse order." + "Python proporciona una función integrada llamada `reversed` que toma como argumento una secuencia de elementos, como una lista o un string, y devuelve un objeto `reversed` que contiene los elementos en orden inverso." ] }, { @@ -1439,7 +1439,7 @@ "id": "0f95c76f", "metadata": {}, "source": [ - "If you want the reversed elements in a list, you can use the `list` function." + "Si quieres los elementos invertidos en una lista, puedes usar la función `list`." ] }, { @@ -1455,7 +1455,7 @@ "id": "8fc79a2f", "metadata": {}, "source": [ - "Of if you want them in a string, you can use the `join` method." + "O si los quieres en un string, puedes usar el método `join`." ] }, { @@ -1471,7 +1471,7 @@ "id": "ec4ce196", "metadata": {}, "source": [ - "So we can write a function that reverses a word like this." + "Así podemos escribir una función que invierte una palabra así." ] }, { @@ -1487,8 +1487,8 @@ "id": "21550b5f", "metadata": {}, "source": [ - "A palindrome is a word that is spelled the same backward and forward, like \"noon\" and \"rotator\".\n", - "Write a function called `is_palindrome` that takes a string argument and returns `True` if it is a palindrome and `False` otherwise." + "Un palíndromo es una palabra que se escribe igual hacia atrás y hacia adelante, como \"noon\" y \"rotator\".\n", + "Escribe una función llamada `is_palindrome` que tome un string argumento y devuelva `True` si es un palíndromo y `False` en caso contrario." ] }, { @@ -1498,7 +1498,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function with doctests you can use to check your function." + "Aquí tienes un esquema de la función con doctests que puedes usar para comprobar tu función." ] }, { @@ -1534,7 +1534,7 @@ "id": "ad857abf", "metadata": {}, "source": [ - "You can use the following loop to find all of the palindromes in the word list with at least 7 letters." + "Puedes usar el siguiente bucle para encontrar todos los palíndromos en la lista de palabras con al menos 7 letras." ] }, { @@ -1552,13 +1552,13 @@ "id": "11386f70", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `reverse_sentence` that takes as an argument a string that contains any number of words separated by spaces.\n", - "It should return a new string that contains the same words in reverse order.\n", - "For example, if the argument is \"Reverse this sentence\", the result should be \"Sentence this reverse\".\n", + "Escribe una función llamada `reverse_sentence` que tome como argumento un string que contiene cualquier número de palabras separadas por espacios.\n", + "Debe devolver un nuevo string que contiene las mismas palabras en orden inverso.\n", + "Por ejemplo, si el argumento es \"Reverse this sentence\", el resultado debería ser \"Sentence this reverse\".\n", "\n", - "Hint: You can use the `capitalize` methods to capitalize the first word and convert the other words to lowercase. " + "Pista: Puedes usar los métodos `capitalize` para poner en mayúscula la primera palabra y convertir las demás palabras a minúsculas." ] }, { @@ -1568,7 +1568,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1604,10 +1604,10 @@ "id": "fb5f24b1", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `total_length` that takes a list of strings and returns the total length of the strings.\n", - "The total length of the words in `word_list` should be $902{,}728$." + "Escribe una función llamada `total_length` que tome una lista de strings y devuelva la longitud total de los strings.\n", + "La longitud total de las palabras en `word_list` debería ser $902{,}728$." ] }, { @@ -1645,7 +1645,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/blank/chap10.ipynb b/blank/chap10.ipynb index 56d77c9..52d9baa 100644 --- a/blank/chap10.ipynb +++ b/blank/chap10.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,13 +25,13 @@ "id": "737e79eb", "metadata": {}, "source": [ - "# Dictionaries\n", + "# Diccionarios\n", "\n", - "This chapter presents a built-in type called a dictionary.\n", - "It is one of Python's best features -- and the building block of many efficient and elegant algorithms.\n", + "Este capítulo presenta un tipo integrado llamado diccionario.\n", + "Es una de las mejores características de Python, y el bloque de construcción de muchos algoritmos eficientes y elegantes.\n", "\n", - "We'll use dictionaries to compute the number of unique words in a book and the number of times each one appears.\n", - "And in the exercises, we'll use dictionaries to solve word puzzles." + "Usaremos diccionarios para calcular el número de palabras únicas en un libro y el número de veces que aparece cada una.\n", + "Y en los ejercicios, usaremos diccionarios para resolver juegos de palabras." ] }, { @@ -39,11 +39,11 @@ "id": "be7467bb", "metadata": {}, "source": [ - "## A dictionary is a mapping\n", + "## Un diccionario es un mapeo\n", "\n", - "A **dictionary** is like a list, but more general.\n", - "In a list, the indices have to be integers; in a dictionary they can be (almost) any type.\n", - "For example, suppose we make a list of number words, like this." + "Un **diccionario** es como una lista, pero más general.\n", + "En una lista, los índices tienen que ser enteros; en un diccionario pueden ser de (casi) cualquier tipo.\n", + "Por ejemplo, supongamos que hacemos una lista de palabras numéricas, así." ] }, { @@ -59,7 +59,7 @@ "id": "aa626f88", "metadata": {}, "source": [ - "We can use an integer as an index to get the corresponding word." + "Podemos usar un entero como índice para obtener la palabra correspondiente." ] }, { @@ -75,9 +75,9 @@ "id": "c38e143b", "metadata": {}, "source": [ - "But suppose we want to go in the other direction, and look up a word to get the corresponding integer.\n", - "We can't do that with a list, but we can with a dictionary.\n", - "We'll start by creating an empty dictionary and assigning it to `numbers`." + "Pero supongamos que queremos ir en la otra dirección, y buscar una palabra para obtener el entero correspondiente.\n", + "No podemos hacerlo con una lista, pero sí con un diccionario.\n", + "Empezaremos creando un diccionario vacío y asignándolo a `numbers`." ] }, { @@ -93,8 +93,8 @@ "id": "3acce992", "metadata": {}, "source": [ - "The curly braces, `{}`, represent an empty dictionary.\n", - "To add items to the dictionary, we'll use square brackets." + "Las llaves, `{}`, representan un diccionario vacío.\n", + "Para añadir elementos al diccionario, usaremos corchetes." ] }, { @@ -110,9 +110,9 @@ "id": "1dbe12c3", "metadata": {}, "source": [ - "This assignment adds to the dictionary an **item**, which represents the association of a **key** and a **value**.\n", - "In this example, the key is the string `'zero'` and the value is the integer `0`.\n", - "If we display the dictionary, we see that it contains one item, which contains a key and a value separated by a colon, `:`." + "Esta asignación añade al diccionario un **elemento**, que representa la asociación de una **clave** y un **valor**.\n", + "En este ejemplo, la clave es el string `'zero'` y el valor es el entero `0`.\n", + "Si mostramos el diccionario, vemos que contiene un elemento, que contiene una clave y un valor separados por dos puntos, `:`." ] }, { @@ -128,7 +128,7 @@ "id": "ad32c23d", "metadata": {}, "source": [ - "We can add more items like this." + "Podemos añadir más elementos así." ] }, { @@ -144,9 +144,9 @@ "id": "278901e5", "metadata": {}, "source": [ - "Now the dictionary contains three items.\n", + "Ahora el diccionario contiene tres elementos.\n", "\n", - "To look up a key and get the corresponding value, we use the bracket operator." + "Para buscar una clave y obtener el valor correspondiente, usamos el operador de corchetes." ] }, { @@ -162,7 +162,7 @@ "id": "df5724e6", "metadata": {}, "source": [ - "If the key isn't in the dictionary, we get a `KeyError`." + "Si la clave no está en el diccionario, obtenemos un `KeyError`." ] }, { @@ -180,7 +180,7 @@ "id": "2a027a6b", "metadata": {}, "source": [ - "The `len` function works on dictionaries; it returns the number of items." + "La función `len` funciona con diccionarios; devuelve el número de elementos." ] }, { @@ -196,10 +196,10 @@ "id": "58221e96", "metadata": {}, "source": [ - "In mathematical language, a dictionary represents a **mapping** from keys to values, so you can also say that each key \"maps to\" a value.\n", - "In this example, each number word maps to the corresponding integer.\n", + "En lenguaje matemático, un diccionario representa un **mapeo** de claves a valores, así que también puedes decir que cada clave \"mapea a\" un valor.\n", + "En este ejemplo, cada palabra numérica mapea al entero correspondiente.\n", "\n", - "The following figure shows the state diagram for `numbers`." + "La siguiente figura muestra el diagrama de estado de `numbers`." ] }, { @@ -227,9 +227,9 @@ "id": "b092aa61", "metadata": {}, "source": [ - "A dictionary is represented by a box with the word \"dict\" outside and the items inside.\n", - "Each item is represented by a key and an arrow pointing to a value.\n", - "The quotation marks indicate that the keys here are strings, not variable names." + "Un diccionario se representa con una caja con la palabra \"dict\" fuera y los elementos dentro.\n", + "Cada elemento se representa con una clave y una flecha que apunta a un valor.\n", + "Las comillas indican que las claves aquí son strings, no nombres de variables." ] }, { @@ -237,10 +237,10 @@ "id": "2a0a128a", "metadata": {}, "source": [ - "## Creating dictionaries\n", + "## Crear diccionarios\n", "\n", - "In the previous section we created an empty dictionary and added items one at a time using the bracket operator.\n", - "Instead, we could have created the dictionary all at once like this." + "En la sección anterior creamos un diccionario vacío y añadimos elementos uno por uno usando el operador de corchetes.\n", + "En su lugar, podríamos haber creado el diccionario de una vez así." ] }, { @@ -256,11 +256,11 @@ "id": "31ded5b2", "metadata": {}, "source": [ - "Each item consists of a key and a value separated by a colon.\n", - "The items are separated by commas and enclosed in curly braces.\n", + "Cada elemento consiste en una clave y un valor separados por dos puntos.\n", + "Los elementos se separan con comas y se encierran entre llaves.\n", "\n", - "Another way to create a dictionary is to use the `dict` function.\n", - "We can make an empty dictionary like this." + "Otra forma de crear un diccionario es usar la función `dict`.\n", + "Podemos crear un diccionario vacío así." ] }, { @@ -276,7 +276,7 @@ "id": "bfb215c9", "metadata": {}, "source": [ - "And we can make a copy of a dictionary like this." + "Y podemos hacer una copia de un diccionario así." ] }, { @@ -292,7 +292,7 @@ "id": "966c5539", "metadata": {}, "source": [ - "It is often useful to make a copy before performing operations that modify dictionaries." + "A menudo es útil hacer una copia antes de realizar operaciones que modifican diccionarios." ] }, { @@ -302,9 +302,9 @@ "tags": [] }, "source": [ - "## The in operator\n", + "## El operador in\n", "\n", - "The `in` operator works on dictionaries, too; it tells you whether something appears as a *key* in the dictionary." + "El operador `in` también funciona con diccionarios; te dice si algo aparece como *clave* en el diccionario." ] }, { @@ -320,7 +320,7 @@ "id": "80f6b264", "metadata": {}, "source": [ - "The `in` operator does *not* check whether something appears as a value." + "El operador `in` *no* comprueba si algo aparece como valor." ] }, { @@ -336,7 +336,7 @@ "id": "84856c8b", "metadata": {}, "source": [ - "To see whether something appears as a value in a dictionary, you can use the method `values`, which returns a sequence of values, and then use the `in` operator." + "Para ver si algo aparece como valor en un diccionario, puedes usar el método `values`, que devuelve una secuencia de valores, y luego usar el operador `in`." ] }, { @@ -352,8 +352,8 @@ "id": "45dc3d16", "metadata": {}, "source": [ - "The items in a Python dictionary are stored in a **hash table**, which is a way of organizing data that has a remarkable property: the `in` operator takes about the same amount of time no matter how many items are in the dictionary.\n", - "That makes it possible to write some remarkably efficient algorithms." + "Los elementos de un diccionario de Python se almacenan en una **hash table**, que es una forma de organizar datos con una propiedad notable: el operador `in` tarda aproximadamente la misma cantidad de tiempo sin importar cuántos elementos haya en el diccionario.\n", + "Eso hace posible escribir algunos algoritmos notablemente eficientes." ] }, { @@ -371,8 +371,8 @@ "id": "bba0522c", "metadata": {}, "source": [ - "To demonstrate, we'll compare two algorithms for finding pairs of words where one is the reverse of another -- like `stressed` and `desserts`.\n", - "We'll start by reading the word list." + "Para demostrarlo, compararemos dos algoritmos para encontrar pares de palabras donde una es la inversa de la otra, como `stressed` y `desserts`.\n", + "Empezaremos leyendo la lista de palabras." ] }, { @@ -388,7 +388,7 @@ "id": "ab29fb8a", "metadata": {}, "source": [ - "And here's `reverse_word` from the previous chapter." + "Y aquí está `reverse_word` del capítulo anterior." ] }, { @@ -404,8 +404,8 @@ "id": "93f7ac1b", "metadata": {}, "source": [ - "The following function loops through the words in the list.\n", - "For each one, it reverses the letters and then checks whether the reversed word in the word list." + "La siguiente función recorre las palabras de la lista.\n", + "Para cada una, invierte las letras y luego comprueba si la palabra invertida está en la palabra lista." ] }, { @@ -421,9 +421,9 @@ "id": "d4ebb84d", "metadata": {}, "source": [ - "This function takes more than a minute to run.\n", - "The problem is that the `in` operator checks the words in the list one at a time, starting at the beginning.\n", - "If it doesn't find what it's looking for -- which happens most of the time -- it has to search all the way to the end." + "Esta función tarda más de un minuto en ejecutarse.\n", + "El problema es que el operador `in` comprueba las palabras de la lista una por una, empezando por el principio.\n", + "Si no encuentra lo que busca, que ocurre la mayor parte del tiempo, tiene que buscar hasta el final." ] }, { @@ -441,8 +441,8 @@ "id": "2acb6c50", "metadata": {}, "source": [ - "And the `in` operator is inside the loop, so it runs once for each word.\n", - "Since there are more than 100,000 words in the list, and for each one we check more than 100,000 words, the total number of comparisons is the number of words squared -- roughly -- which is almost 13 billion. " + "Y el operador `in` está dentro del bucle, así que se ejecuta una vez por cada palabra.\n", + "Como hay más de 100 000 palabras en la lista, y para cada una comprobamos más de 100 000 palabras, el número total de comparaciones es el número de palabras al cuadrado -- aproximadamente --, que es casi 13 mil millones." ] }, { @@ -458,8 +458,8 @@ "id": "5dbf01b7", "metadata": {}, "source": [ - "We can make this function much faster with a dictionary.\n", - "The following loop creates a dictionary that contains the words as keys." + "Podemos hacer que esta función sea mucho más rápida con un diccionario.\n", + "El siguiente bucle crea un diccionario que contiene las palabras como claves." ] }, { @@ -475,9 +475,9 @@ "id": "b7f6a1b7", "metadata": {}, "source": [ - "The values in `word_dict` are all `1`, but they could be anything, because we won't ever look them up -- we will only use this dictionary to check whether a key exists.\n", + "Los valores en `word_dict` son todos `1`, pero podrían ser cualquier cosa, porque nunca los vamos a buscar; solo usaremos este diccionario para comprobar si existe una clave.\n", "\n", - "Now here's a version of the previous function that replaces `word_list` with `word_dict`." + "Ahora aquí tienes una versión de la función anterior que reemplaza `word_list` por `word_dict`." ] }, { @@ -493,7 +493,7 @@ "id": "5f41e54c", "metadata": {}, "source": [ - "This function takes less than one hundredth of a second, so it's about 10,000 times faster than the previous version." + "Esta función tarda menos de una centésima de segundo, así que es unas 10 000 veces más rápida que la versión anterior." ] }, { @@ -511,8 +511,8 @@ "id": "4cd91c99", "metadata": {}, "source": [ - "In general, the time it takes to find an element in a list is proportional to the length of the list.\n", - "The time it takes to find a key in a dictionary is almost constant -- regardless of the number of items." + "En general, el tiempo que se tarda en encontrar un elemento en una lista es proporcional a la longitud de la lista.\n", + "El tiempo que se tarda en encontrar una clave en un diccionario es casi constante, independientemente del número de elementos." ] }, { @@ -528,11 +528,11 @@ "id": "b3bfa8a5", "metadata": {}, "source": [ - "## A collection of counters\n", + "## Una colección de contadores\n", "\n", - "Suppose you are given a string and you want to count how many times each letter appears.\n", - "A dictionary is a good tool for this job.\n", - "We'll start with an empty dictionary." + "Supongamos que recibes un string y quieres contar cuántas veces aparece cada letra.\n", + "Un diccionario es una buena herramienta para este trabajo.\n", + "Empezaremos con un diccionario vacío." ] }, { @@ -548,8 +548,8 @@ "id": "34a9498a", "metadata": {}, "source": [ - "As we loop through the letters in the string, suppose we see the letter `'a'` for the first time.\n", - "We can add it to the dictionary like this." + "Mientras recorremos las letras del string, supongamos que vemos la letra `'a'` por primera vez.\n", + "Podemos añadirla al diccionario así." ] }, { @@ -565,8 +565,8 @@ "id": "bca9fa11", "metadata": {}, "source": [ - "The value `1` indicates that we have seen the letter once.\n", - "Later, if we see the same letter again, we can increment the counter like this." + "El valor `1` indica que hemos visto la letra una vez.\n", + "Más tarde, si volvemos a ver la misma letra, podemos incrementar el contador así." ] }, { @@ -582,7 +582,7 @@ "id": "274ea014", "metadata": {}, "source": [ - "Now the value associated with `'a'` is `2`, because we've seen the letter twice." + "Ahora el valor asociado con `'a'` es `2`, porque hemos visto la letra dos veces." ] }, { @@ -598,7 +598,7 @@ "id": "2ca8f99d", "metadata": {}, "source": [ - "The following function uses these features to count the number of times each letter appears in a string." + "La siguiente función usa estas características para contar el número de veces que aparece cada letra en un string." ] }, { @@ -614,10 +614,10 @@ "id": "735c758b", "metadata": {}, "source": [ - "Each time through the loop, if `letter` is not in the dictionary, we create a new item with key `letter` and value `1`.\n", - "If `letter` is already in the dictionary we increment the value associated with `letter`.\n", + "Cada vez que pasa por el bucle, si `letter` no está en el diccionario, creamos un nuevo elemento con clave `letter` y valor `1`.\n", + "Si `letter` ya está en el diccionario, incrementamos el valor asociado con `letter`.\n", "\n", - "Here's an example." + "Aquí tienes un ejemplo." ] }, { @@ -633,7 +633,7 @@ "id": "8ac1fea4", "metadata": {}, "source": [ - "The items in `counter` show that the letter `'b'` appears once, `'r'` appears twice, and so on." + "Los elementos de `counter` muestran que la letra `'b'` aparece una vez, `'r'` aparece dos veces, y así sucesivamente." ] }, { @@ -641,10 +641,10 @@ "id": "912bdf5d", "metadata": {}, "source": [ - "## Looping and dictionaries\n", + "## Looping y diccionarios\n", "\n", - "If you use a dictionary in a `for` statement, it traverses the keys of the dictionary.\n", - "To demonstrate, let's make a dictionary that counts the letters in `'banana'`." + "Si usas un diccionario en una sentencia `for`, recorre las claves del diccionario.\n", + "Para demostrarlo, hagamos un diccionario que cuente las letras de `'banana'`." ] }, { @@ -660,7 +660,7 @@ "id": "fe263f3d", "metadata": {}, "source": [ - "The following loop prints the keys, which are the letters." + "El siguiente bucle imprime las claves, que son las letras." ] }, { @@ -676,7 +676,7 @@ "id": "bf1b7824", "metadata": {}, "source": [ - "To print the values, we can use the `values` method." + "Para imprimir los valores, podemos usar el método `values`." ] }, { @@ -692,7 +692,7 @@ "id": "721135be", "metadata": {}, "source": [ - "To print the keys and values, we can loop through the keys and look up the corresponding values." + "Para imprimir las claves y los valores, podemos recorrer las claves y buscar los valores correspondientes." ] }, { @@ -708,7 +708,7 @@ "id": "efa1bce5", "metadata": {}, "source": [ - "In the next chapter, we'll see a more concise way to do the same thing." + "En el próximo capítulo, veremos una forma más concisa de hacer lo mismo." ] }, { @@ -716,10 +716,10 @@ "id": "a160c0ef", "metadata": {}, "source": [ - "## Lists and dictionaries\n", + "## Listas y diccionarios\n", "\n", - "You can put a list in a dictionary as a value.\n", - "For example, here's a dictionary that maps from the number `4` to a list of four letters." + "Puedes poner una lista en un diccionario como valor.\n", + "Por ejemplo, aquí tienes un diccionario que mapea el número `4` a una lista de cuatro letras." ] }, { @@ -735,8 +735,8 @@ "id": "815a829f", "metadata": {}, "source": [ - "But you can't put a list in a dictionary as a key.\n", - "Here's what happens if we try." + "Pero no puedes poner una lista en un diccionario como clave.\n", + "Esto es lo que ocurre si lo intentamos." ] }, { @@ -754,17 +754,17 @@ "id": "2469b08a", "metadata": {}, "source": [ - "I mentioned earlier that dictionaries use hash tables, and that means that the keys have to be **hashable**.\n", + "Mencioné antes que los diccionarios usan hash tables, y eso significa que las claves tienen que ser **hasheable**.\n", "\n", - "A **hash** is a function that takes a value (of any kind) and returns an integer.\n", - "Dictionaries use these integers, called hash values, to store and look up keys.\n", + "Un **hash** es una función que toma un valor (de cualquier tipo) y devuelve un entero.\n", + "Los diccionarios usan estos enteros, llamados hash valores, para almacenar y buscar claves.\n", "\n", - "This system only works if a key is immutable, so its hash value is always the same.\n", - "But if a key is mutable, its hash value could change, and the dictionary would not work.\n", - "That's why keys have to be hashable, and why mutable types like lists aren't.\n", + "Este sistema solo funciona si una clave es inmutable, de modo que su hash valor siempre sea el mismo.\n", + "Pero si una clave es mutable, su hash valor podría cambiar, y el diccionario no funcionaría.\n", + "Por eso las claves tienen que ser hasheables, y por eso tipos mutables como las listas no lo son.\n", "\n", - "Since dictionaries are mutable, they can't be used as keys, either.\n", - "But they *can* be used as values." + "Como los diccionarios son mutables, tampoco pueden usarse como claves.\n", + "Pero *sí* pueden usarse como valores." ] }, { @@ -774,13 +774,13 @@ "tags": [] }, "source": [ - "## Accumulating a list\n", + "## Acumular una lista\n", "\n", - "For many programming tasks, it is useful to loop through one list or dictionary while building another.\n", - "As an example, we'll loop through the words in `word_dict` and make a list of palindromes -- that is, words that are spelled the same backward and forward, like \"noon\" and \"rotator\".\n", + "Para muchas tareas de programación, es útil recorrer una lista o diccionario mientras se construye otro.\n", + "Como ejemplo, recorreremos las palabras en `word_dict` y haremos una lista de palíndromos, es decir, palabras que se escriben igual hacia atrás y hacia adelante, como \"noon\" y \"rotator\".\n", "\n", - "In the previous chapter, one of the exercises asked you to write a function that checks whether a word is a palindrome.\n", - "Here's a solution that uses `reverse_word`." + "En el capítulo anterior, uno de los ejercicios te pidió escribir una función que comprueba si una palabra es un palíndromo.\n", + "Aquí tienes una solución que usa `reverse_word`." ] }, { @@ -796,7 +796,7 @@ "id": "af545fcd", "metadata": {}, "source": [ - "If we loop through the words in `word_dict`, we can count the number of palindromes like this." + "Si recorremos las palabras en `word_dict`, podemos contar el número de palíndromos así." ] }, { @@ -812,15 +812,15 @@ "id": "73c1ce1e", "metadata": {}, "source": [ - "By now, this pattern is familiar.\n", + "A estas alturas, este patrón resulta familiar.\n", "\n", - "* Before the loop, `count` is initialized to `0`.\n", + "* Antes del bucle, `count` se inicializa a `0`.\n", "\n", - "* Inside the loop, if `word` is a palindrome, we increment `count`.\n", + "* Dentro del bucle, si `word` es un palíndromo, incrementamos `count`.\n", "\n", - "* When the loop ends, `count` contains the total number of palindromes.\n", + "* Cuando termina el bucle, `count` contiene el número total de palíndromos.\n", "\n", - "We can use a similar pattern to make a list of palindromes." + "Podemos usar un patrón similar para hacer una lista de palíndromos." ] }, { @@ -836,18 +836,18 @@ "id": "be909f3b", "metadata": {}, "source": [ - "Here's how it works:\n", + "Así es como funciona:\n", "\n", - "* Before the loop, `palindromes` is initialized with an empty list.\n", + "* Antes del bucle, `palindromes` se inicializa con una lista vacía.\n", "\n", - "* Inside the loop, if `word` is a palindrome, we append it to the end of `palindromes`.\n", + "* Dentro del bucle, si `word` es un palíndromo, lo añadimos al final de `palindromes`.\n", "\n", - "* When the loop ends, `palindromes` is a list of palindromes.\n", + "* Cuando termina el bucle, `palindromes` es una lista de palíndromos.\n", "\n", - "In this loop, `palindromes` is used as an **accumulator**, which is a variable that collects or accumulates data during a computation.\n", + "En este bucle, `palindromes` se usa como **accumulator**, que es una variable que recoge o acumula datos durante una computación.\n", "\n", - "Now suppose we want to select only palindromes with seven or more letters.\n", - "We can loop through `palindromes` and make a new list that contains only long palindromes." + "Ahora supongamos que queremos seleccionar solo palíndromos con siete o más letras.\n", + "Podemos recorrer `palindromes` y hacer una nueva lista que contenga solo palíndromos largos." ] }, { @@ -863,7 +863,7 @@ "id": "fa8ed275", "metadata": {}, "source": [ - "Looping through a list like this, selecting some elements and omitting others, is called **filtering**." + "Recorrer una lista así, seleccionando algunos elementos y omitiendo otros, se llama **filtrado**." ] }, { @@ -875,7 +875,7 @@ "source": [ "## Memos\n", "\n", - "If you ran the `fibonacci` function from [Chapter 6](section_fibonacci), maybe you noticed that the bigger the argument you provide, the longer the function takes to run." + "Si ejecutaste la función `fibonacci` del [Capítulo 6](section_fibonacci), quizá notaste que cuanto mayor es el argumento que proporcionas, más tarda la función en ejecutarse." ] }, { @@ -891,9 +891,9 @@ "id": "1b5203c2", "metadata": {}, "source": [ - "Furthermore, the run time increases quickly.\n", - "To understand why, consider the following figure, which shows the **call graph** for\n", - "`fibonacci` with `n=4`:" + "Además, el tiempo de ejecución aumenta rápidamente.\n", + "Para entender por qué, considera la siguiente figura, que muestra el **call graph** de\n", + "`fibonacci` con `n=4`:" ] }, { @@ -931,16 +931,16 @@ "id": "4ee2a87c", "metadata": {}, "source": [ - "A call graph shows a set of function frames, with lines connecting each frame to the frames of the functions it calls.\n", - "At the top of the graph, `fibonacci` with `n=4` calls `fibonacci` with ` n=3` and `n=2`.\n", - "In turn, `fibonacci` with `n=3` calls `fibonacci` with `n=2` and `n=1`. And so on.\n", + "Un call graph muestra un conjunto de función frames, con líneas que conectan cada frame con los frames de las funciones que llama.\n", + "En la parte superior del graph, `fibonacci` con `n=4` llama a `fibonacci` con ` n=3` y `n=2`.\n", + "A su vez, `fibonacci` con `n=3` llama a `fibonacci` con `n=2` y `n=1`. Y así sucesivamente.\n", "\n", - "Count how many times `fibonacci(0)` and `fibonacci(1)` are called. \n", - "This is an inefficient solution to the problem, and it gets worse as the argument gets bigger.\n", + "Cuenta cuántas veces se llama a `fibonacci(0)` y `fibonacci(1)`.\n", + "Esta es una solución ineficiente al problema, y empeora a medida que el argumento crece.\n", "\n", - "One solution is to keep track of values that have already been computed by storing them in a dictionary.\n", - "A previously computed value that is stored for later use is called a **memo**.\n", - "Here is a \"memoized\" version of `fibonacci`:" + "Una solución es llevar un registro de los valores que ya se han calculado almacenándolos en un diccionario.\n", + "Un valor calculado previamente que se almacena para usarlo más tarde se llama **memo**.\n", + "Aquí tienes una versión \"memoized\" de `fibonacci`:" ] }, { @@ -956,16 +956,16 @@ "id": "d2ac4dd7", "metadata": {}, "source": [ - "`known` is a dictionary that keeps track of the Fibonacci numbers we already know\n", - "It starts with two items: `0` maps to `0` and `1` maps to `1`.\n", + "`known` es un diccionario que lleva el registro de los números de Fibonacci que ya conocemos.\n", + "Empieza con dos elementos: `0` mapea a `0` y `1` mapea a `1`.\n", "\n", - "Whenever `fibonacci_memo` is called, it checks `known`.\n", - "If the result is already there, it can return immediately.\n", - "Otherwise it has to compute the new value, add it to the dictionary, and return it.\n", + "Cada vez que se llama a `fibonacci_memo`, comprueba `known`.\n", + "Si el resultado ya está ahí, puede devolverlo inmediatamente.\n", + "De lo contrario, tiene que calcular el nuevo valor, añadirlo al diccionario y devolverlo.\n", "\n", - "Comparing the two functions, `fibonacci(40)` takes about 30 seconds to run.\n", - "`fibonacci_memo(40)` takes about 30 microseconds, so it's a million times faster.\n", - "In the notebook for this chapter, you'll see where these measurements come from." + "Comparando las dos funciones, `fibonacci(40)` tarda unos 30 segundos en ejecutarse.\n", + "`fibonacci_memo(40)` tarda unos 30 microsegundos, así que es un millón de veces más rápida.\n", + "En el notebook de este capítulo, verás de dónde vienen estas mediciones." ] }, { @@ -975,8 +975,8 @@ "tags": [] }, "source": [ - "To measure how long a function takes, we can use `%time` which is one of Jupyter's \"built-in magic commands\".\n", - "These commands are not part of the Python language, so they might not work in other development environments." + "Para medir cuánto tarda una función, podemos usar `%time`, que es uno de los \"built-in magic commands\" de Jupyter.\n", + "Estos comandos no forman parte del lenguaje Python, así que puede que no funcionen en otros entornos de desarrollo." ] }, { @@ -1004,18 +1004,18 @@ "id": "ec969e51", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "As you work with bigger datasets it can become unwieldy to debug by printing and checking the output by hand. Here are some suggestions for debugging large datasets:\n", + "A medida que trabajas con datasets más grandes, puede volverse inmanejable depurar imprimiendo y comprobando la salida a mano. Aquí tienes algunas sugerencias para depurar datasets grandes:\n", "\n", - "1. Scale down the input: If possible, reduce the size of the dataset. For example if the\n", - " program reads a text file, start with just the first 10 lines, or\n", - " with the smallest example you can find. You can either edit the\n", - " files themselves, or (better) modify the program so it reads only\n", - " the first `n` lines.\n", + "1. Reduce el tamaño de la entrada: Si es posible, reduce el tamaño del dataset. Por ejemplo, si el\n", + " programa lee un archivo de texto, empieza solo con las primeras 10 líneas, o\n", + " con el ejemplo más pequeño que puedas encontrar. Puedes editar los\n", + " archivos directamente o, mejor, modificar el programa para que lea solo\n", + " las primeras `n` líneas.\n", "\n", - " If there is an error, you can reduce `n` to the smallest value where the error occurs.\n", - " As you find and correct errors, you can increase `n` gradually." + " Si hay un error, puedes reducir `n` al valor más pequeño donde ocurre el error.\n", + " A medida que encuentres y corrijas errores, puedes aumentar `n` gradualmente." ] }, { @@ -1023,11 +1023,11 @@ "id": "1a62288b", "metadata": {}, "source": [ - "2. Check summaries and types: Instead of printing and checking the entire dataset, consider\n", - " printing summaries of the data -- for example, the number of items in\n", - " a dictionary or the total of a list of numbers.\n", + "2. Comprueba resúmenes y tipos: En lugar de imprimir y comprobar el dataset completo, considera\n", + " imprimir resúmenes de los datos; por ejemplo, el número de elementos en\n", + " un diccionario o el total de una lista de números.\n", "\n", - " A common cause of runtime errors is a value that is not the right type. For debugging this kind of error, it is often enough to print the type of a value." + " Una causa común de errores en tiempo de ejecución es un valor que no tiene el tipo correcto. Para depurar de este tipo de error, a menudo basta con imprimir el tipo de un valor." ] }, { @@ -1035,13 +1035,13 @@ "id": "c749ea3c", "metadata": {}, "source": [ - "3. Write self-checks: Sometimes you can write code to check for errors automatically. For\n", - " example, if you are computing the average of a list of numbers, you\n", - " could check that the result is not greater than the largest element\n", - " in the list or less than the smallest. This is called a \"sanity\n", - " check\" because it detects results that are \"insane\".\n", + "3. Escribe autocomprobaciones: A veces puedes escribir código para comprobar errores automáticamente. Por\n", + " ejemplo, si estás calculando la media de una lista de números, podrías\n", + " comprobar que el resultado no sea mayor que el elemento más grande\n", + " de la lista ni menor que el más pequeño. Esto se llama una \"sanity\n", + " check\" porque detecta resultados que son \"insane\".\n", "\n", - " Another kind of check compares the results of two different computations to see if they are consistent. This is called a \"consistency check\"." + " Otro tipo de comprobación compara los resultados de dos computaciones diferentes para ver si son consistentes. Esto se llama una \"consistency check\"." ] }, { @@ -1049,9 +1049,9 @@ "id": "749b91e9", "metadata": {}, "source": [ - "4. Format the output: Formatting debugging output can make it easier to spot an error. We saw an example in [Chapter 6](section_debugging_factorial). Another tool you might find useful is the `pprint` module, which provides a `pprint` function that displays built-in types in a more human-readable format (`pprint` stands for \"pretty print\").\n", + "4. Formatea la salida: Formatear la salida de depuración puede facilitar detectar un error. Vimos un ejemplo en [Capítulo 6](section_depuración_factorial). Otra herramienta que puede resultarte útil es el módulo `pprint`, que proporciona una función `pprint` que muestra tipos integrados en un formato más legible para humanos (`pprint` significa \"pretty print\").\n", "\n", - " Again, time you spend building scaffolding can reduce the time you spend debugging." + " De nuevo, el tiempo que dediques a construir código de apoyo puede reducir el tiempo que dedicas a depurar." ] }, { @@ -1059,44 +1059,44 @@ "id": "9820175f", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**dictionary:**\n", - " An object that contains key-value pairs, also called items.\n", + "**diccionario:**\n", + " Un objeto que contiene pares clave-valor, también llamados elementos.\n", "\n", - "**item:**\n", - " In a dictionary, another name for a key-value pair.\n", + "**elemento:**\n", + " En un diccionario, otro nombre para un par clave-valor.\n", "\n", - "**key:**\n", - " An object that appears in a dictionary as the first part of a key-value pair.\n", + "**clave:**\n", + " Un objeto que aparece en un diccionario como la primera parte de un par clave-valor.\n", "\n", - "**value:**\n", - " An object that appears in a dictionary as the second part of a key-value pair. This is more specific than our previous use of the word \"value\".\n", + "**valor:**\n", + " Un objeto que aparece en un diccionario como la segunda parte de un par clave-valor. Esto es más específico que nuestro uso anterior de la palabra \"valor\".\n", "\n", - "**mapping:**\n", - " A relationship in which each element of one set corresponds to an element of another set.\n", + "**mapeo:**\n", + " Una relación en la que cada elemento de un conjunto corresponde a un elemento de otro conjunto.\n", "\n", "**hash table:**\n", - "A collection of key-value pairs organized so that we can look up a key and find its value efficiently.\n", + "Una colección de pares clave-valor organizada para que podamos buscar una clave y encontrar su valor de forma eficiente.\n", "\n", - "**hashable:**\n", - " Immutable types like integers, floats and strings are hashable.\n", - " Mutable types like lists and dictionaries are not.\n", + "**hasheable:**\n", + "Tipos inmutables como enteros, floats y strings son hasheable.\n", + "Tipos mutables como listas y diccionarios no lo son.\n", "\n", - "**hash function:**\n", - "A function that takes an object and computes an integer that is used to locate a key in a hash table.\n", + "**función hash:**\n", + "Una función que toma un objeto y calcula un entero que se usa para localizar una clave en una hash table.\n", "\n", "**accumulator:**\n", - " A variable used in a loop to add up or accumulate a result.\n", + " Una variable usada en un bucle para sumar o acumular un resultado.\n", "\n", - "**filtering:**\n", - "Looping through a sequence and selecting or omitting elements.\n", + "**filtrado:**\n", + "Recorrer una secuencia y seleccionar u omitir elementos.\n", "\n", "**call graph:**\n", - "A diagram that shows every frame created during the execution of a program, with an arrow from each caller to each callee.\n", + "Un diagrama que muestra cada frame creado durante la ejecución de un programa, con una flecha desde cada código que llama hacia cada callee.\n", "\n", "**memo:**\n", - " A computed value stored to avoid unnecessary future computation." + " Un valor calculado almacenado para evitar computación futura innecesaria." ] }, { @@ -1104,7 +1104,7 @@ "id": "906c1236", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1122,13 +1122,13 @@ "id": "170f1deb", "metadata": {}, "source": [ - "### Ask an assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, I said the keys in a dictionary have to be hashable and I gave a short explanation. If you would like more details, ask a virtual assistant, \"Why do keys in Python dictionaries have to be hashable?\"\n", + "En este capítulo, dije que las claves de un diccionario tienen que ser hasheabless y di una explicación breve. Si quieres más detalles, pregunta a un asistente virtual: \"¿Por qué las claves de los diccionarios de Python tienen que ser hasheabless?\"\n", "\n", - "In [a previous section](section_dictionary_in_operator), we stored a list of words as keys in a dictionary so that we could use an efficient version of the `in` operator.\n", - "We could have done the same thing using a `set`, which is another built-in data type.\n", - "Ask a virtual assistant, \"How do I make a Python set from a list of strings and check whether a string is an element of the set?\"" + "En [una sección anterior](section_dictionary_in_operator), almacenamos una lista de palabras como claves en un diccionario para poder usar una versión eficiente del operador `in`.\n", + "Podríamos haber hecho lo mismo usando un `set`, que es otro tipo de dato integrado.\n", + "Pregunta a un asistente virtual: \"How do I make a Python set from a lista of strings and check whether a string is an elemento of the set?\"" ] }, { @@ -1136,11 +1136,11 @@ "id": "badf7d65", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Dictionaries have a method called `get` that takes a key and a default value. \n", - "If the key appears in the dictionary, `get` returns the corresponding value; otherwise it returns the default value.\n", - "For example, here's a dictionary that maps from the letters in a string to the number of times they appear." + "Los diccionarios tienen un método llamado `get` que toma una clave y un valor por defecto.\n", + "Si la clave aparece en el diccionario, `get` devuelve el valor correspondiente; de lo contrario devuelve el valor por defecto.\n", + "Por ejemplo, aquí tienes un diccionario que mapea las letras de un string al número de veces que aparecen." ] }, { @@ -1156,7 +1156,7 @@ "id": "c3f6458d", "metadata": {}, "source": [ - "If we look up a letter that appears in the word, `get` returns the number of times it appears." + "Si buscamos una letra que aparece en la palabra, `get` devuelve el número de veces que aparece." ] }, { @@ -1172,7 +1172,7 @@ "id": "49bbff3e", "metadata": {}, "source": [ - "If we look up a letter that doesn't appear, we get the default value, `0`." + "Si buscamos una letra que no aparece, obtenemos el valor por defecto, `0`." ] }, { @@ -1188,8 +1188,8 @@ "id": "4ac3210f", "metadata": {}, "source": [ - "Use `get` to write a more concise version of `value_counts`.\n", - "You should be able to eliminate the `if` statement." + "Usa `get` para escribir una versión más concisa de `value_counts`.\n", + "Deberías poder eliminar la sentencia `if`." ] }, { @@ -1197,12 +1197,12 @@ "id": "5413af6e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "What is the longest word you can think of where each letter appears only once?\n", - "Let's see if we can find one longer than `unpredictably`.\n", + "¿Cuál es la palabra más larga que se te ocurre donde cada letra aparece solo una vez?\n", + "Veamos si podemos encontrar una más larga que `unpredictably`.\n", "\n", - "Write a function named `has_duplicates` that takes a sequence -- like a list or string -- as a parameter and returns `True` if there is any element that appears in the sequence more than once." + "Escribe una función llamada `has_duplicates` que tome una secuencia, como una lista o string, como parameter y devuelva `True` si hay algún elemento que aparece en la secuencia más de una vez." ] }, { @@ -1212,7 +1212,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1240,7 +1240,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1260,7 +1260,7 @@ "tags": [] }, "source": [ - "You can use this loop to find the longest words with no repeated letters." + "Puedes usar este bucle para encontrar las palabras más largas sin letras repetidas." ] }, { @@ -1278,11 +1278,11 @@ "id": "afd5f3b6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write function called `find_repeats` that takes a dictionary that maps from each key to a counter, like the result from `value_counts`.\n", - "It should loop through the dictionary and return a list of keys that have counts greater than `1`.\n", - "You can use the following outline to get started." + "Escribe una función llamada `find_repeats` que tome un diccionario que mapea cada clave a un contador, como el resultado de `value_counts`.\n", + "Debe recorrer el diccionario y devolver una lista de claves que tengan recuentos mayores que `1`.\n", + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1308,8 +1308,8 @@ "tags": [] }, "source": [ - "You can use the following examples to test your code.\n", - "First, we'll make a dictionary that maps from letters to counts." + "Puedes usar los siguientes ejemplos para probar tu código.\n", + "Primero, haremos un diccionario que mapea letras a recuentos." ] }, { @@ -1329,7 +1329,7 @@ "tags": [] }, "source": [ - "The result from `find_repeats` should be `['a', 'n']`." + "El resultado de `find_repeats` debería ser `['a', 'n']`." ] }, { @@ -1349,8 +1349,8 @@ "tags": [] }, "source": [ - "Here's another example that starts with a list of numbers.\n", - "The result should be `[1, 2]`." + "Aquí tienes otro ejemplo que empieza con una lista de números.\n", + "El resultado debería ser `[1, 2]`." ] }, { @@ -1368,9 +1368,9 @@ "id": "1c700d84", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Suppose you run `value_counts` with two different words and save the results in two dictionaries." + "Supongamos que ejecutas `value_counts` con dos palabras diferentes y guardas los resultados en dos diccionarios." ] }, { @@ -1386,11 +1386,11 @@ "id": "deb14c7a", "metadata": {}, "source": [ - "Each dictionary maps from a set of letters to the number of times they appear.\n", - "Write a function called `add_counters` that takes two dictionaries like this and returns a new dictionary that contains all of the letters and the total number of times they appear in either word.\n", + "Cada diccionario mapea un conjunto de letras al número de veces que aparecen.\n", + "Escribe una función llamada `add_counters` que tome dos diccionarios como estos y devuelva un nuevo diccionario que contenga todas las letras y el número total de veces que aparecen en cualquiera de las dos palabras.\n", "\n", - "There are many ways to solve this problem.\n", - "Once you have a working solution, consider asking a virtual assistant for different solutions." + "Hay muchas formas de resolver este problema.\n", + "Cuando tengas una solución que funcione, considera pedir a un asistente virtual soluciones diferentes." ] }, { @@ -1414,16 +1414,16 @@ "id": "f88110a9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A word is \"interlocking\" if we can split it into two words by taking alternating letters.\n", - "For example, \"schooled\" is an interlocking word because it can be split into \"shoe\" and \"cold\".\n", + "Una palabra es \"interlocking\" si podemos dividirla en dos palabras tomando letras alternas.\n", + "Por ejemplo, \"schooled\" es una palabra interlocking porque puede dividirse en \"shoe\" y \"cold\".\n", "\n", - "To select alternating letters from a string, you can use a slice operator with three components that indicate where to start, where to stop, and the \"step size\" between the letters.\n", + "Para seleccionar letras alternas de un string, puedes usar un operador de porción con tres componentes que indican dónde empezar, dónde detenerse y el \"step size\" entre las letras.\n", "\n", - "In the following slice, the first component is `0`, so we start with the first letter.\n", - "The second component is `None`, which means we should go all the way to the end of the string.\n", - "And the third component is `2`, so there are two steps between the letters we select." + "En el siguiente porción, el primer componente es `0`, así que empezamos con la primera letra.\n", + "El segundo componente es `None`, lo que significa que debemos llegar hasta el final del string.\n", + "Y el tercer componente es `2`, así que hay dos pasos entre las letras que seleccionamos." ] }, { @@ -1439,8 +1439,8 @@ "id": "d432332d", "metadata": {}, "source": [ - "Instead of providing `None` as the second component, we can get the same effect by leaving it out altogether.\n", - "For example, the following slice selects alternating letters, starting with the second letter." + "En lugar de proporcionar `None` como segundo componente, podemos obtener el mismo efecto omitiéndolo por completo.\n", + "Por ejemplo, el siguiente porción selecciona letras alternas, empezando por la segunda letra." ] }, { @@ -1456,7 +1456,7 @@ "id": "c8c4e3ba", "metadata": {}, "source": [ - "Write a function called `is_interlocking` that takes a word as an argument and returns `True` if it can be split into two interlocking words." + "Escribe una función llamada `is_interlocking` que tome una palabra como argumento y devuelva `True` si puede dividirse en dos palabras interlocking." ] }, { @@ -1474,7 +1474,7 @@ "tags": [] }, "source": [ - "You can use the following loop to find the interlocking words in the word list." + "Puedes usar el siguiente bucle para encontrar las palabras interlocking en la palabra lista." ] }, { @@ -1504,7 +1504,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/blank/chap11.ipynb b/blank/chap11.ipynb index d80bc23..ca39877 100644 --- a/blank/chap11.ipynb +++ b/blank/chap11.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -27,16 +27,16 @@ "tags": [] }, "source": [ - "# Tuples\n", + "# Tuplas\n", "\n", - "This chapter introduces one more built-in type, the tuple, and then shows how lists, dictionaries, and tuples work together.\n", - "It also presents tuple assignment and a useful feature for functions with variable-length argument lists: the packing and unpacking operators.\n", + "Este capítulo presenta un tipo integrado más, la tupla, y luego muestra cómo listas, diccionarios y tuplas trabajan juntos.\n", + "También presenta la asignación de tuplas y una característica útil para funciones con listas de argumentos de longitud variable: los operadores de empaquetado y desempaquetado.\n", "\n", - "In the exercises, we'll use tuples, along with lists and dictionaries, to solve more word puzzles and implement efficient algorithms.\n", + "En los ejercicios, usaremos tuplas, junto con listas y diccionarios, para resolver más puzles de palabras e implementar algoritmos eficientes.\n", "\n", - "One note: There are two ways to pronounce \"tuple\".\n", - "Some people say \"tuh-ple\", which rhymes with \"supple\".\n", - "But in the context of programming, most people say \"too-ple\", which rhymes with \"quadruple\"." + "Una nota: hay dos maneras de pronunciar \"tupla\".\n", + "Algunas personas dicen \"tuh-ple\", que rima con \"supple\".\n", + "Pero en el contexto de la programación, la mayoría dice \"too-ple\", que rima con \"quadruple\"." ] }, { @@ -44,12 +44,12 @@ "id": "19474596", "metadata": {}, "source": [ - "## Tuples are like lists\n", + "## Las tuplas son como listas\n", "\n", - "A tuple is a sequence of values. The values can be any type, and they are indexed by integers, so tuples are a lot like lists.\n", - "The important difference is that tuples are immutable.\n", + "Una tupla es una secuencia de valores. Los valores pueden ser de cualquier tipo, y se indexan con enteros, así que las tuplas se parecen mucho a las listas.\n", + "La diferencia importante es que las tuplas son inmutables.\n", "\n", - "To create a tuple, you can write a comma-separated list of values." + "Para crear una tupla, puedes escribir una lista de valores separados por comas." ] }, { @@ -65,7 +65,7 @@ "id": "a2ec15d8", "metadata": {}, "source": [ - "Although it is not necessary, it is common to enclose tuples in parentheses." + "Aunque no es necesario, es común encerrar las tuplas entre paréntesis." ] }, { @@ -81,7 +81,7 @@ "id": "9194a159", "metadata": {}, "source": [ - "To create a tuple with a single element, you have to include a final comma." + "Para crear una tupla con un solo elemento, tienes que incluir una coma final." ] }, { @@ -97,7 +97,7 @@ "id": "e39b95a5", "metadata": {}, "source": [ - "A single value in parentheses is not a tuple." + "Un único valor entre paréntesis no es una tupla." ] }, { @@ -113,8 +113,7 @@ "id": "a64bfb64", "metadata": {}, "source": [ - "Another way to create a tuple is the built-in function `tuple`. With no\n", - "argument, it creates an empty tuple." + "Otra forma de crear una tupla es la función integrada `tuple`. Sin argumentos, crea una tupla vacío." ] }, { @@ -130,8 +129,7 @@ "id": "f3447831", "metadata": {}, "source": [ - "If the argument is a sequence (string, list or tuple), the result is a\n", - "tuple with the elements of the sequence." + "Si el argumento es una secuencia (string, lista o tupla), el resultado es una tupla con los elementos de la secuencia." ] }, { @@ -147,10 +145,10 @@ "id": "2e48b980", "metadata": {}, "source": [ - "Because `tuple` is the name of a built-in function, you should avoid using it as a variable name.\n", + "Como `tuple` es el nombre de una función integrada, deberías evitar usarlo como nombre de variable.\n", "\n", - "Most list operators also work with tuples.\n", - "For example, the bracket operator indexes an element." + "La mayoría de los operadores de lista también funcionan con tuplas.\n", + "Por ejemplo, el operador de corchetes indexa un elemento." ] }, { @@ -166,7 +164,7 @@ "id": "2f702785", "metadata": {}, "source": [ - "And the slice operator selects a range of elements." + "Y el operador de porción selecciona un rango de elementos." ] }, { @@ -182,7 +180,7 @@ "id": "c9ed9af2", "metadata": {}, "source": [ - "The `+` operator concatenates tuples." + "El operador `+` concatena tuplas." ] }, { @@ -198,7 +196,7 @@ "id": "1d7dcd6d", "metadata": {}, "source": [ - "And the `*` operator duplicates a tuple a given number of times." + "Y el operador `*` duplica una tupla un número dado de veces." ] }, { @@ -214,7 +212,7 @@ "id": "a53ce8bd", "metadata": {}, "source": [ - "The `sorted` function works with tuples -- but the result is a list, not a tuple." + "La función `sorted` funciona con tuplas -- pero el resultado es una lista, no una tupla." ] }, { @@ -230,7 +228,7 @@ "id": "50e5cadc", "metadata": {}, "source": [ - "The `reversed` function also works with tuples." + "La función `reversed` también funciona con tuplas." ] }, { @@ -246,7 +244,7 @@ "id": "f6d973c5", "metadata": {}, "source": [ - "The result is a `reversed` object, which we can convert to a list or tuple." + "El resultado es un objeto `reversed`, que podemos convertir en una lista o en una tupla." ] }, { @@ -262,7 +260,7 @@ "id": "a7cb9ee6", "metadata": {}, "source": [ - "Based on the examples so far, it might seem like tuples are the same as lists." + "Según los ejemplos hasta ahora, podría parecer que las tuplas son iguales que las listas." ] }, { @@ -270,9 +268,9 @@ "id": "8c3f381e", "metadata": {}, "source": [ - "## But tuples are immutable\n", + "## Pero las tuplas son inmutables\n", "\n", - "If you try to modify a tuple with the bracket operator, you get a `TypeError`." + "Si intentas modificar una tupla con el operador de corchetes, obtienes un `TypeError`." ] }, { @@ -290,7 +288,7 @@ "id": "592ce99c", "metadata": {}, "source": [ - "And tuples don't have any of the methods that modify lists, like `append` and `remove`." + "Y las tuplas no tienen ninguno de los métodos que modifican listas, como `append` y `remove`." ] }, { @@ -308,10 +306,10 @@ "id": "70772ba2", "metadata": {}, "source": [ - "Recall that an \"attribute\" is a variable or method associated with an object -- this error message means that tuples don't have a method named `remove`.\n", + "Recuerda que un \"atributo\" es una variable o método asociado con un objeto -- este mensaje de error significa que las tuplas no tienen un método llamado `remove`.\n", "\n", - "Because tuples are immutable, they are hashable, which means they can be used as keys in a dictionary.\n", - "For example, the following dictionary contains two tuples as keys that map to integers." + "Como las tuplas son inmutables, son hasheables, lo que significa que pueden usarse como claves en un diccionario.\n", + "Por ejemplo, el siguiente diccionario contiene dos tuplas como claves que se asocian con enteros." ] }, { @@ -327,7 +325,7 @@ "id": "47ba17ab", "metadata": {}, "source": [ - "We can look up a tuple in a dictionary like this:" + "Podemos buscar una tupla en un diccionario así:" ] }, { @@ -343,7 +341,7 @@ "id": "f2c0a354", "metadata": {}, "source": [ - "Or if we have a variable that refers to a tuple, we can use it as a key." + "O, si tenemos una variable que se refiere a una tupla, podemos usarla como clave." ] }, { @@ -359,7 +357,7 @@ "id": "2ea8fc3c", "metadata": {}, "source": [ - "Tuples can also appear as values in a dictionary." + "Las tuplas también pueden aparecer como valores en un diccionario." ] }, { @@ -375,9 +373,9 @@ "id": "25655ab3", "metadata": {}, "source": [ - "## Tuple assignment\n", + "## Asignación de tupla\n", "\n", - "You can put a tuple of variables on the left side of an assignment, and a tuple of values on the right." + "Puedes poner una tupla de variables en el lado izquierdo de una asignación, y una tupla de valores en el lado derecho." ] }, { @@ -393,8 +391,8 @@ "id": "92c00ceb", "metadata": {}, "source": [ - "The values are assigned to the variables from left to right -- in this example, `a` gets the value `1` and `b` gets the value `2`.\n", - "We can display the results like this:" + "Los valores se asignan a las variables de izquierda a derecha -- en este ejemplo, `a` recibe el valor `1` y `b` recibe el valor `2`.\n", + "Podemos mostrar los resultados así:" ] }, { @@ -410,8 +408,8 @@ "id": "6362b36e", "metadata": {}, "source": [ - "More generally, if the left side of an assignment is a tuple, the right side can be any kind of sequence -- string, list or tuple. \n", - "For example, to split an email address into a user name and a domain, you could write:" + "De forma más general, si el lado izquierdo de una asignación es una tupla, el lado derecho puede ser cualquier tipo de secuencia -- string, lista o tupla. \n", + "Por ejemplo, para dividir una dirección de email en un nombre de usuario y un dominio, podrías escribir:" ] }, { @@ -427,7 +425,7 @@ "id": "d134a94c", "metadata": {}, "source": [ - "The return value from `split` is a list with two elements -- the first element is assigned to `username`, the second to `domain`." + "El valor de retorno de `split` es una lista con dos elementos -- el primer elemento se asigna a `username`, el segundo a `domain`." ] }, { @@ -443,8 +441,7 @@ "id": "5a7e3c62", "metadata": {}, "source": [ - "The number of variables on the left and the number of values on the\n", - "right have to be the same -- otherwise you get a `ValueError`." + "El número de variables a la izquierda y el número de valores a la derecha tienen que ser iguales -- de lo contrario obtienes un `ValueError`." ] }, { @@ -462,8 +459,8 @@ "id": "808c2928", "metadata": {}, "source": [ - "Tuple assignment is useful if you want to swap the values of two variables.\n", - "With conventional assignments, you have to use a temporary variable, like this:" + "La asignación de tupla es útil si quieres intercambiar los valores de dos variables.\n", + "Con asignaciones convencionales, tienes que usar una variable temporal, así:" ] }, { @@ -479,7 +476,7 @@ "id": "98496d02", "metadata": {}, "source": [ - "That works, but with tuple assignment we can do the same thing without a temporary variable." + "Eso funciona, pero con la asignación de tupla podemos hacer lo mismo sin una variable temporal." ] }, { @@ -495,10 +492,10 @@ "id": "a66a87bc", "metadata": {}, "source": [ - "This works because all of the expressions on the right side are evaluated before any of the assignments.\n", + "Esto funciona porque todas las expresiones del lado derecho se evalúan antes de hacer cualquiera de las asignaciones.\n", "\n", - "We can also use tuple assignment in a `for` statement.\n", - "For example, to loop through the items in a dictionary, we can use the `items` method." + "También podemos usar asignación de tupla en una sentencia `for`.\n", + "Por ejemplo, para hacer un bucle por los elementos de un diccionario, podemos usar el método `items`." ] }, { @@ -514,9 +511,9 @@ "id": "dd0d4feb", "metadata": {}, "source": [ - "Each time through the loop, `item` is assigned a tuple that contains a key and the corresponding value.\n", + "Cada vez que pasa por el bucle, `item` se asigna a una tupla que contiene una clave y el valor correspondiente.\n", "\n", - "We can write this loop more concisely, like this:" + "Podemos escribir este bucle de forma más concisa, así:" ] }, { @@ -532,7 +529,7 @@ "id": "f0513578", "metadata": {}, "source": [ - "Each time through the loop, a key and the corresponding value are assigned directly to `key` and `value`." + "Cada vez que pasa por el bucle, una clave y el valor correspondiente se asignan directamente a `key` y `value`." ] }, { @@ -540,16 +537,12 @@ "id": "efedeb37", "metadata": {}, "source": [ - "## Tuples as return values\n", + "## Tuplas como valores de retorno\n", "\n", - "Strictly speaking, a function can only return one value, but if the\n", - "value is a tuple, the effect is the same as returning multiple values.\n", - "For example, if you want to divide two integers and compute the quotient\n", - "and remainder, it is inefficient to compute `x//y` and then `x%y`. It is\n", - "better to compute them both at the same time.\n", + "Estrictamente hablando, una función solo puede devolver un valor, pero si el valor es una tupla, el efecto es el mismo que devolver múltiples valores.\n", + "Por ejemplo, si quieres dividir dos enteros y calcular el cociente y el resto, es ineficiente calcular `x//y` y luego `x%y`. Es mejor calcular ambos al mismo tiempo.\n", "\n", - "The built-in function `divmod` takes two arguments and returns a tuple\n", - "of two values, the quotient and remainder." + "La función integrada `divmod` toma dos argumentos y devuelve una tupla de dos valores, el cociente y el resto." ] }, { @@ -565,7 +558,7 @@ "id": "33f3c57d", "metadata": {}, "source": [ - "We can use tuple assignment to store the elements of the tuple in two variables. " + "Podemos usar asignación de tupla para guardar los elementos dla tupla en dos variables. " ] }, { @@ -589,7 +582,7 @@ "id": "15079805", "metadata": {}, "source": [ - "Here is an example of a function that returns a tuple." + "Aquí tienes un ejemplo de una función que devuelve una tupla." ] }, { @@ -605,8 +598,8 @@ "id": "43c4e1e0", "metadata": {}, "source": [ - "`max` and `min` are built-in functions that find the largest and smallest elements of a sequence. \n", - "`min_max` computes both and returns a tuple of two values." + "`max` y `min` son funciones integradas que encuentran los elementos mayor y menor de una secuencia. \n", + "`min_max` calcula ambos y devuelve una tupla de dos valores." ] }, { @@ -622,7 +615,7 @@ "id": "86b60e71", "metadata": {}, "source": [ - "We can assign the results to variables like this:" + "Podemos asignar los resultados a variables así:" ] }, { @@ -640,11 +633,11 @@ "tags": [] }, "source": [ - "## Argument packing\n", + "## Empaquetado de argumentos\n", "\n", - "Functions can take a variable number of arguments. \n", - "A parameter name that begins with the `*` operator **packs** arguments into a tuple.\n", - "For example, the following function takes any number of arguments and computes their arithmetic mean -- that is, their sum divided by the number of arguments. " + "Las funciones pueden tomar un número variable de argumentos. \n", + "Un nombre de parámetro que empieza con el operador `*` **empaqueta** argumentos en una tupla.\n", + "Por ejemplo, la siguiente función toma cualquier número de argumentos y calcula su media aritmética -- es decir, su suma dividida por el número de argumentos. " ] }, { @@ -660,8 +653,8 @@ "id": "6044fc1b", "metadata": {}, "source": [ - "The parameter can have any name you like, but `args` is conventional.\n", - "We can call the function like this:" + "El parámetro puede tener cualquier nombre que quieras, pero `args` es convencional.\n", + "Podemos llamar a la función así:" ] }, { @@ -677,8 +670,8 @@ "id": "a5e8b158", "metadata": {}, "source": [ - "If you have a sequence of values and you want to pass them to a function as multiple arguments, you can use the `*` operator to **unpack** the tuple.\n", - "For example, `divmod` takes exactly two arguments -- if you pass a tuple as a parameter, you get an error." + "Si tienes una secuencia de valores y quieres pasarlos a una función como múltiples argumentos, puedes usar el operador `*` para **desempaquetar** la tupla.\n", + "Por ejemplo, `divmod` toma exactamente dos argumentos -- si pasas una tupla como parámetro, obtienes un error." ] }, { @@ -696,8 +689,8 @@ "id": "5a9110db", "metadata": {}, "source": [ - "Even though the tuple contains two elements, it counts as a single argument.\n", - "But if you unpack the tuple, it is treated as two arguments." + "Aunque la tupla contiene dos elementos, cuenta como un único argumento.\n", + "Pero si desempaquetas la tupla, se trata como dos argumentos." ] }, { @@ -713,8 +706,8 @@ "id": "da554863", "metadata": {}, "source": [ - "Packing and unpacking can be useful if you want to adapt the behavior of an existing function.\n", - "For example, this function takes any number of arguments, removes the lowest and highest, and computes the mean of the rest." + "Empaquetado y desempaquetado pueden ser útiles si quieres adaptar el comportamiento de una función existente.\n", + "Por ejemplo, esta función toma cualquier número de argumentos, elimina el menor y el mayor, y calcula la media del resto." ] }, { @@ -730,11 +723,11 @@ "id": "d1e05e49", "metadata": {}, "source": [ - "First it uses `min_max` to find the lowest and highest elements.\n", - "Then it converts `args` to a list so it can use the `remove` method.\n", - "Finally it unpacks the list so the elements are passed to `mean` as separate arguments, rather than as a single list.\n", + "Primero usa `min_max` para encontrar los elementos menor y mayor.\n", + "Luego convierte `args` en una lista para poder usar el método `remove`.\n", + "Finalmente desempaqueta la lista para que los elementos se pasen a `mean` como argumentos separados, en lugar de como una única lista.\n", "\n", - "Here's an example that shows the effect." + "Aquí tienes un ejemplo que muestra el efecto." ] }, { @@ -758,7 +751,7 @@ "id": "35e04996", "metadata": {}, "source": [ - "This kind of \"trimmed\" mean is used in some sports with subjective judging -- like diving and gymnastics -- to reduce the effect of a judge whose score deviates from the others. " + "Este tipo de media \"recortada\" se usa en algunos deportes con puntuación subjetiva -- como saltos y gimnasia -- para reducir el efecto de un juez cuya puntuación se desvía de las demás. " ] }, { @@ -768,8 +761,8 @@ "source": [ "## Zip\n", "\n", - "Tuples are useful for looping through the elements of two sequences and performing operations on corresponding elements.\n", - "For example, suppose two teams play a series of seven games, and we record their scores in two lists, one for each team." + "Las tuplas son útiles para hacer un bucle por los elementos de dos secuencias y realizar operaciones sobre elementos correspondientes.\n", + "Por ejemplo, supongamos que dos equipos juegan una serie de siete partidos, y registramos sus puntuaciones en dos listas, una para cada equipo." ] }, { @@ -785,8 +778,8 @@ "id": "b44f228b", "metadata": {}, "source": [ - "Let's see how many games each team won.\n", - "We'll use `zip`, which is a built-in function that takes two or more sequences and returns a **zip object**, so-called because it pairs up the elements of the sequences like the teeth of a zipper." + "Veamos cuántos partidos ganó cada equipo.\n", + "Usaremos `zip`, que es una función integrada que toma dos o más secuencias y devuelve un **zip objeto**, llamado así porque empareja los elementos de las secuencias como los dientes de una cremallera." ] }, { @@ -802,7 +795,7 @@ "id": "9adcf8f9", "metadata": {}, "source": [ - "We can use the zip object to loop through the values in the sequences pairwise." + "Podemos usar el zip objeto para hacer un bucle por los valores de las secuencias por pares." ] }, { @@ -818,8 +811,8 @@ "id": "51d1dabb", "metadata": {}, "source": [ - "Each time through the loop, `pair` gets assigned a tuple of scores.\n", - "So we can assign the scores to variables, and count the victories for the first team, like this:" + "Cada vez que pasa por el bucle, `pair` recibe una tupla de puntuaciones.\n", + "Así que podemos asignar las puntuaciones a variables y contar las victorias del primer equipo, así:" ] }, { @@ -835,9 +828,9 @@ "id": "ad740fcd", "metadata": {}, "source": [ - "Sadly, the first team won only three games and lost the series.\n", + "Tristemente, el primer equipo ganó solo tres partidos y perdió la serie.\n", "\n", - "If you have two lists and you want a list of pairs, you can use `zip` and `list`." + "Si tienes dos listas y quieres una lista de pares, puedes usar `zip` y `list`." ] }, { @@ -853,7 +846,7 @@ "id": "ec4249fa", "metadata": {}, "source": [ - "The result is a list of tuples, so we can get the result of the last game like this:" + "El resultado es una lista de tuplas, así que podemos obtener el resultado del último partido así:" ] }, { @@ -869,8 +862,8 @@ "id": "436486b9", "metadata": {}, "source": [ - "If you have a list of keys and a list of values, you can use `zip` and `dict` to make a dictionary.\n", - "For example, here's how we can make a dictionary that maps from each letter to its position in the alphabet." + "Si tienes una lista de claves y una lista de valores, puedes usar `zip` y `dict` para crear un diccionario.\n", + "Por ejemplo, así podemos crear un diccionario que asocia cada letra con su posición en el alfabeto." ] }, { @@ -886,7 +879,7 @@ "id": "b4de6974", "metadata": {}, "source": [ - "Now we can look up a letter and get its index in the alphabet." + "Ahora podemos buscar una letra y obtener su índice en el alfabeto." ] }, { @@ -902,9 +895,9 @@ "id": "cc632542", "metadata": {}, "source": [ - "In this mapping, the index of `'a'` is `0` and the index of `'z'` is `25`.\n", + "En este mapeo, el índice de `'a'` es `0` y el índice de `'z'` es `25`.\n", "\n", - "If you need to loop through the elements of a sequence and their indices, you can use the built-in function `enumerate`." + "Si necesitas hacer un bucle por los elementos de una secuencia y sus índices, puedes usar la función integrada `enumerate`." ] }, { @@ -920,7 +913,7 @@ "id": "92ad45bb", "metadata": {}, "source": [ - "The result is an **enumerate object** that loops through a sequence of pairs, where each pair contains an index (starting from 0) and an element from the given sequence." + "El resultado es un **enumerate objeto** que hace un bucle por una secuencia de pares, donde cada par contiene un índice (empezando en 0) y un elemento de la secuencia dada." ] }, { @@ -936,11 +929,11 @@ "id": "cf0b55d7", "metadata": {}, "source": [ - "## Comparing and Sorting\n", + "## Comparación y ordenación\n", "\n", - "The relational operators work with tuples and other sequences.\n", - "For example, if you use the `<` operator with tuples, it starts by comparing the first element from each sequence.\n", - "If they are equal, it goes on to the next pair of elements, and so on, until it finds a pair that differ. " + "Los operadores relacionales funcionan con tuplas y otras secuencias.\n", + "Por ejemplo, si usas el operador `<` con tuplas, empieza comparando el primer elemento de cada secuencia.\n", + "Si son iguales, continúa con el siguiente par de elementos, y así sucesivamente, hasta que encuentra un par que difiere. " ] }, { @@ -956,7 +949,7 @@ "id": "65ceea86", "metadata": {}, "source": [ - "Subsequent elements are not considered -- even if they are really big." + "Los elementos posteriores no se tienen en cuenta -- aunque sean realmente grandes." ] }, { @@ -972,9 +965,9 @@ "id": "55e4a35e", "metadata": {}, "source": [ - "This way of comparing tuples is useful for sorting a list of tuples, or finding the minimum or maximum.\n", - "As an example, let's find the most common letter in a word.\n", - "In the previous chapter, we wrote `value_counts`, which takes a string and returns a dictionary that maps from each letter to the number of times it appears." + "Esta forma de comparar tuplas es útil para ordenar una lista de tuplas, o para encontrar el mínimo o el máximo.\n", + "Como ejemplo, encontremos la letra más común en una palabra.\n", + "En el capítulo anterior, escribimos `value_counts`, que toma un string y devuelve un diccionario que asocia cada letra con el número de veces que aparece." ] }, { @@ -990,7 +983,7 @@ "id": "a80012c1", "metadata": {}, "source": [ - "Here is the result for the string `'banana'`." + "Aquí está el resultado para el string `'banana'`." ] }, { @@ -1006,10 +999,10 @@ "id": "cc1ea4a7", "metadata": {}, "source": [ - "With only three items, we can easily see that the most frequent letter is `'a'`, which appears three times.\n", - "But if there were more items, it would be useful to sort them automatically.\n", + "Con solo tres elementos, podemos ver fácilmente que la letra más frecuente es `'a'`, que aparece tres veces.\n", + "Pero si hubiera más elementos, sería útil ordenarlos automáticamente.\n", "\n", - "We can get the items from `counter` like this." + "Podemos obtener los elementos de `counter` así." ] }, { @@ -1025,7 +1018,7 @@ "id": "ac8dea7a", "metadata": {}, "source": [ - "The result is a `dict_items` object that behaves like a list of tuples, so we can sort it like this." + "El resultado es un objeto `dict_items` que se comporta como una lista de tuplas, así que podemos ordenarlo así." ] }, { @@ -1041,10 +1034,10 @@ "id": "b690d17a", "metadata": {}, "source": [ - "The default behavior is to use the first element from each tuple to sort the list, and use the second element to break ties.\n", + "El comportamiento por defecto es usar el primer elemento de cada tupla para ordenar la lista, y usar el segundo elemento para desempatar.\n", "\n", - "However, to find the items with the highest counts, we want to use the second element to sort the list.\n", - "We can do that by writing a function that takes a tuple and returns the second element." + "Sin embargo, para encontrar los elementos con los conteos más altos, queremos usar el segundo elemento para ordenar la lista.\n", + "Podemos hacerlo escribiendo una función que toma una tupla y devuelve el segundo elemento." ] }, { @@ -1060,7 +1053,7 @@ "id": "b964aa14", "metadata": {}, "source": [ - "Then we can pass that function to `sorted` as an optional argument called `key`, which indicates that this function should be used to compute the **sort key** for each item." + "Luego podemos pasar esa función a `sorted` como un argumento opcional llamado `key`, que indica que esta función debe usarse para calcular la **sort clave** de cada elemento." ] }, { @@ -1076,9 +1069,9 @@ "id": "4dc96848", "metadata": {}, "source": [ - "The sort key determines the order of the items in the list.\n", - "The letter with the lowest count appears first, and the letter with the highest count appears last.\n", - "So we can find the most common letter like this." + "La sort clave determina el orden de los elementos en la lista.\n", + "La letra con el conteo más bajo aparece primero, y la letra con el conteo más alto aparece al final.\n", + "Así podemos encontrar la letra más común." ] }, { @@ -1094,8 +1087,8 @@ "id": "d0d8b999", "metadata": {}, "source": [ - "If we only want the maximum, we don't have to sort the list.\n", - "We can use `max`, which also takes `key` as an optional argument." + "Si solo queremos el máximo, no tenemos que ordenar la lista.\n", + "Podemos usar `max`, que también toma `key` como argumento opcional." ] }, { @@ -1111,7 +1104,7 @@ "id": "8a8327df", "metadata": {}, "source": [ - "To find the letter with the lowest count, we could use `min` the same way." + "Para encontrar la letra con el conteo más bajo, podríamos usar `min` de la misma manera." ] }, { @@ -1119,15 +1112,15 @@ "id": "a62394a5", "metadata": {}, "source": [ - "## Inverting a dictionary\n", + "## Invertir un diccionario\n", "\n", - "Suppose you want to invert a dictionary so you can look up a value and get the corresponding key.\n", - "For example, if you have a word counter that maps from each word to the number of times it appears, you could make a dictionary that maps from integers to the words that appear that number of times.\n", + "Supongamos que quieres invertir un diccionario para poder buscar un valor y obtener la clave correspondiente.\n", + "Por ejemplo, si tienes un contador de palabras que asocia cada palabra con el número de veces que aparece, podrías crear un diccionario que asocia enteros con las palabras que aparecen ese número de veces.\n", "\n", - "But there's a problem -- the keys in a dictionary have to be unique, but the values don't. For example, in a word counter, there could be many words with the same count.\n", + "Pero hay un problema -- las claves de un diccionario tienen que ser únicas, pero los valores no. Por ejemplo, en un contador de palabras, podría haber muchas palabras con el mismo conteo.\n", "\n", - "So one way to invert a dictionary is to create a new dictionary where the values are lists of keys from the original.\n", - "As an example, let's count the letters in `parrot`." + "Así que una forma de invertir un diccionario es crear un nuevo diccionario donde los valores son listas de claves del original.\n", + "Como ejemplo, contemos las letras en `parrot`." ] }, { @@ -1143,9 +1136,9 @@ "id": "f4570eae", "metadata": {}, "source": [ - "If we invert this dictionary, the result should be `{1: ['p', 'a', 'o', 't'], 2: ['r']}`, which indicates that the letters that appear once are `'p'`, `'a'`, `'o'`, and `'t'`, and the letter than appears twice is `'r'`.\n", + "Si invertimos este diccionario, el resultado debería ser `{1: ['p', 'a', 'o', 't'], 2: ['r']}`, lo que indica que las letras que aparecen una vez son `'p'`, `'a'`, `'o'` y `'t'`, y la letra que aparece dos veces es `'r'`.\n", "\n", - "The following function takes a dictionary and returns its inverse as a new dictionary." + "La siguiente función toma un diccionario y devuelve su inverso como un nuevo diccionario." ] }, { @@ -1161,11 +1154,11 @@ "id": "ca5fa025", "metadata": {}, "source": [ - "The `for` statement loops through the keys and values in `d`.\n", - "If the value is not already in the new dictionary, it is added and associated with a list that contains a single element.\n", - "Otherwise it is appended to the existing list.\n", + "La sentencia `for` hace un bucle por las claves y los valores de `d`.\n", + "Si el valor todavía no está en el nuevo diccionario, se añade y se asocia con una lista que contiene un único elemento.\n", + "De lo contrario, se añade a la lista existente.\n", "\n", - "We can test it like this:" + "Podemos probarlo así:" ] }, { @@ -1181,10 +1174,10 @@ "id": "4cfb1693", "metadata": {}, "source": [ - "And we get the result we expected.\n", + "Y obtenemos el resultado que esperábamos.\n", "\n", - "This is the first example we've seen where the values in the dictionary are lists.\n", - "We will see more!" + "Este es el primer ejemplo que hemos visto donde los valores en el diccionario son listas.\n", + "¡Veremos más!" ] }, { @@ -1194,16 +1187,15 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Lists, dictionaries and tuples are **data structures**.\n", - "In this chapter we are starting to see compound data structures, like lists of tuples, or dictionaries that contain tuples as keys and lists as values.\n", - "Compound data structures are useful, but they are prone to errors caused when a data structure has the wrong type, size, or structure.\n", - "For example, if a function expects a list of integers and you give it a plain old integer\n", - "(not in a list), it probably won't work.\n", + "Listas, diccionarios y tuplas son **estructuras de datos**.\n", + "En este capítulo estamos empezando a ver estructuras de datos compuestas, como listas de tuplas, o diccionarios que contienen tuplas como claves y listas como valores.\n", + "Las estructuras de datos compuestas son útiles, pero son propensas a errores cuando una estructura de datos tiene el tipo, tamaño o estructura equivocados.\n", + "Por ejemplo, si una función espera una lista de enteros y le das un entero sin más (no dentro de una lista), probablemente no funcionará.\n", "\n", - "To help debug these kinds of errors, I wrote a module called `structshape` that provides a function, also called `structshape`, that takes any kind of data structure as an argument and returns a string that summarizes its structure.\n", - "You can download it from\n", + "Para ayudar a depurar este tipo de errores, escribí un módulo llamado `structshape` que proporciona una función, también llamada `structshape`, que toma cualquier tipo de estructura de datos como argumento y devuelve un string que resume su estructura.\n", + "Puedes descargarlo desde\n", "." ] }, @@ -1222,7 +1214,7 @@ "id": "646f4d55", "metadata": {}, "source": [ - "We can import it like this." + "Podemos importarlo así." ] }, { @@ -1238,7 +1230,7 @@ "id": "86cc6ccc", "metadata": {}, "source": [ - "Here's an example with a simple list." + "Aquí tienes un ejemplo con una lista simple." ] }, { @@ -1254,7 +1246,7 @@ "id": "9de4f6ec", "metadata": {}, "source": [ - "Here's a list of lists." + "Aquí tienes una lista de listas." ] }, { @@ -1270,8 +1262,7 @@ "id": "aced9984", "metadata": {}, "source": [ - "If the elements of the list are not the same type, `structshape` groups\n", - "them by type." + "Si los elementos de la lista no son del mismo tipo, `structshape` los agrupa por tipo." ] }, { @@ -1287,7 +1278,7 @@ "id": "f63ff690", "metadata": {}, "source": [ - "Here's a list of tuples." + "Aquí tienes una lista de tuplas." ] }, { @@ -1303,7 +1294,7 @@ "id": "c9ec67eb", "metadata": {}, "source": [ - "And here's a dictionary with three items that map integers to strings." + "Y aquí tienes un diccionario con tres elementos que asocian enteros con strings." ] }, { @@ -1319,8 +1310,7 @@ "id": "f29bb82b", "metadata": {}, "source": [ - "If you are having trouble keeping track of your data structures,\n", - "`structshape` can help." + "Si tienes problemas para seguir la pista de tus estructuras de datos, `structshape` puede ayudar." ] }, { @@ -1328,25 +1318,25 @@ "id": "79d93082", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", "**pack:**\n", - "Collect multiple arguments into a tuple.\n", + "Reunir múltiples argumentos en una tupla.\n", "\n", "**unpack:**\n", - "Treat a tuple (or other sequence) as multiple arguments.\n", + "Tratar una tupla (u otra secuencia) como múltiples argumentos.\n", "\n", - "**zip object:**\n", - "The result of calling the built-in function `zip`, can be used to loop through a sequence of tuples.\n", + "**zip objeto:**\n", + "El resultado de llamar a la función integrada `zip`; se puede usar para hacer un bucle por una secuencia de tuplas.\n", "\n", - "**enumerate object:**\n", - "The result of calling the built-in function `enumerate`, can be used to loop through a sequence of tuples.\n", + "**enumerate objeto:**\n", + "El resultado de llamar a la función integrada `enumerate`; se puede usar para hacer un bucle por una secuencia de tuplas.\n", "\n", - "**sort key:**\n", - "A value, or function that computes a value, used to sort the elements of a collection.\n", + "**sort clave:**\n", + "Un valor, o una función que calcula un valor, usado para ordenar los elementos de una colección.\n", "\n", - "**data structure:**\n", - "A collection of values, organized to perform certain operations efficiently." + "**estructura de datos:**\n", + "Una colección de valores, organizada para realizar ciertas operaciones de manera eficiente." ] }, { @@ -1354,7 +1344,7 @@ "id": "1471b3c0", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1372,17 +1362,17 @@ "id": "97a0352d", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "The exercises in this chapter might be more difficult than exercises in previous chapters, so I encourage you to get help from a virtual assistant.\n", - "When you pose more difficult questions, you might find that the answers are not correct on the first attempt, so this is a chance to practice crafting good prompts and following up with good refinements.\n", + "Los ejercicios de este capítulo pueden ser más difíciles que los de capítulos anteriores, así que te animo a pedir ayuda a un asistente virtual.\n", + "Cuando planteas preguntas más difíciles, puede que las respuestas no sean correctas al primer intento, así que esta es una oportunidad para practicar cómo crear buenos prompts y hacer buenos refinamientos.\n", "\n", - "One strategy you might consider is to break a big problems into pieces that can be solved with simple functions.\n", - "Ask the virtual assistant to write the functions and test them.\n", - "Then, once they are working, ask for a solution to the original problem.\n", + "Una estrategia que podrías considerar es dividir un problema grande en piezas que puedan resolverse con funciones simples.\n", + "Pide al asistente virtual que escriba las funciones y las pruebe.\n", + "Luego, cuando funcionen, pide una solución al problema original.\n", "\n", - "For some of the exercises below, I make suggestions about which data structures and algorithms to use.\n", - "You might find these suggestions useful when you work on the problems, but they are also good prompts to pass along to a virtual assistant." + "Para algunos de los ejercicios siguientes, sugiero qué estructuras de datos y algoritmos usar.\n", + "Puede que estas sugerencias te resulten útiles cuando trabajes en los problemas, pero también son buenos prompts para pasárselos a un asistente virtual." ] }, { @@ -1390,12 +1380,12 @@ "id": "f90e011f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In this chapter I said that tuples can be used as keys in dictionaries because they are hashable, and they are hashable because they are immutable.\n", - "But that is not always true.\n", + "En este capítulo dije que las tuplas pueden usarse como claves en diccionarios porque son hasheables, y son hasheables porque son inmutables.\n", + "Pero eso no siempre es cierto.\n", "\n", - "If a tuple contains a mutable value, like a list or a dictionary, the tuple is no longer hashable because it contains elements that are not hashable. As an example, here's a tuple that contains two lists of integers." + "Si una tupla contiene un valor mutable, como una lista o un diccionario, la tupla ya no es hasheable porque contiene elementos que no son hasheablesss. Como ejemplo, aquí tienes una tupla que contiene dos listas de enteros." ] }, { @@ -1411,7 +1401,7 @@ "id": "02799077", "metadata": {}, "source": [ - "Write a line of code that appends the value `6` to the end of the second list in `t`. If you display `t`, the result should be `([1, 2, 3], [4, 5, 6])`." + "Escribe una línea de código que añada el valor `6` al final de la segunda lista en `t`. Si muestras `t`, el resultado debería ser `([1, 2, 3], [4, 5, 6])`." ] }, { @@ -1429,7 +1419,7 @@ "id": "644b1dfb", "metadata": {}, "source": [ - "Try to create a dictionary that maps from `t` to a string, and confirm that you get a `TypeError`." + "Intenta crear un diccionario que asocie `t` con un string, y confirma que obtienes un `TypeError`." ] }, { @@ -1447,7 +1437,7 @@ "id": "fb77a352", "metadata": {}, "source": [ - "For more on this topic, ask a virtual assistant, \"Are Python tuples always hashable?\"" + "Para saber más sobre este tema, pregunta a un asistente virtual: \"Are Python tuplas always hasheable?" ] }, { @@ -1457,9 +1447,9 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In this chapter we made a dictionary that maps from each letter to its index in the alphabet." + "En este capítulo hicimos un diccionario que asocia cada letra con su índice en el alfabeto." ] }, { @@ -1475,7 +1465,7 @@ "id": "a8cd720b", "metadata": {}, "source": [ - "For example, the index of `'a'` is `0`." + "Por ejemplo, el índice de `'a'` es `0`." ] }, { @@ -1491,8 +1481,8 @@ "id": "a04c25db", "metadata": {}, "source": [ - "To go in the other direction, we can use list indexing.\n", - "For example, the letter at index `1` is `'b'`." + "Para ir en la otra dirección, podemos usar indexación de lista.\n", + "Por ejemplo, la letra en el índice `1` es `'b'`." ] }, { @@ -1508,18 +1498,17 @@ "id": "165ab770", "metadata": {}, "source": [ - "We can use `letter_map` and `letters` to encode and decode words using a Caesar cipher.\n", + "Podemos usar `letter_map` y `letters` para codificar y decodificar palabras usando un cifrado César.\n", "\n", - "A Caesar cipher is a weak form of encryption that involves shifting each letter\n", - "by a fixed number of places in the alphabet, wrapping around to the beginning if necessary. For example, `'a'` shifted by 2 is `'c'` and `'z'` shifted by 1 is `'a'`.\n", + "Un cifrado César es una forma débil de cifrado que consiste en desplazar cada letra un número fijo de posiciones en el alfabeto, volviendo al principio si es necesario. Por ejemplo, `'a'` desplazada 2 posiciones es `'c'` y `'z'` desplazada 1 posición es `'a'`.\n", "\n", - "Write a function called `shift_word` that takes as parameters a string and an integer, and returns a new string that contains the letters from the string shifted by the given number of places.\n", + "Escribe una función llamada `shift_word` que tome como parámetros un string y un entero, y devuelva un nuevo string que contiene las letras del string desplazadas el número de posiciones dado.\n", "\n", - "To test your function, confirm that \"cheer\" shifted by 7 is \"jolly\" and \"melon\" shifted by 16 is \"cubed\".\n", + "Para probar tu función, confirma que \"cheer\" desplazada 7 posiciones es \"jolly\" y \"melon\" desplazada 16 posiciones es \"cubed\".\n", "\n", - "Hints: Use the modulus operator to wrap around from `'z'` back to `'a'`. \n", - "Loop through the letters of the word, shift each one, and append the result to a list of letters.\n", - "Then use `join` to concatenate the letters into a string." + "Pistas: usa el operador módulo para volver de `'z'` a `'a'`. \n", + "Haz un bucle por las letras de la palabra, desplaza cada una y añade el resultado a una lista de letras.\n", + "Luego usa `join` para concatenar las letras en un string." ] }, { @@ -1529,7 +1518,7 @@ "tags": [] }, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar." ] }, { @@ -1577,7 +1566,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1595,11 +1584,11 @@ "id": "779f13af", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `most_frequent_letters` that takes a string and prints the letters in decreasing order of frequency.\n", + "Escribe una función llamada `most_frequent_letters` que tome un string e imprima las letras en orden decreciente de frecuencia.\n", "\n", - "To get the items in decreasing order, you can use `reversed` along with `sorted` or you can pass `reverse=True` as a keyword parameter to `sorted`." + "Para obtener los elementos en orden decreciente, puedes usar `reversed` junto con `sorted` o puedes pasar `reverse=True` como keyword parameter a `sorted`." ] }, { @@ -1609,7 +1598,7 @@ "tags": [] }, "source": [ - "You can use this outline of the function to get started." + "Puedes usar este esquema de la función para empezar." ] }, { @@ -1637,7 +1626,7 @@ "tags": [] }, "source": [ - "And this example to test your function." + "Y este ejemplo para probar tu función." ] }, { @@ -1657,7 +1646,7 @@ "tags": [] }, "source": [ - "Once your function is working, you can use the following code to print the most common letters in *Dracula*, which we can download from Project Gutenberg." + "Cuando tu función funcione, puedes usar el siguiente código para imprimir las letras más comunes en *Dracula*, que podemos descargar de Project Gutenberg." ] }, { @@ -1687,8 +1676,8 @@ "tags": [] }, "source": [ - "According to Zim's \"Codes and Secret Writing\", the sequence of letters in decreasing order of frequency in English starts with \"ETAONRISH\".\n", - "How does this sequence compare with the results from *Dracula*?" + "Según *Codes and Secret Writing* de Zim, la secuencia de letras en orden decreciente de frecuencia en inglés empieza con \"ETAONRISH\".\n", + "¿Cómo se compara esta secuencia con los resultados de *Dracula*?" ] }, { @@ -1696,20 +1685,20 @@ "id": "cbe9933e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In a previous exercise, we tested whether two strings are anagrams by sorting the letters in both words and checking whether the sorted letters are the same.\n", - "Now let's make the problem a little more challenging.\n", + "En un ejercicio anterior, probamos si dos strings son anagramas ordenando las letras de ambas palabras y comprobando si las letras ordenadas son iguales.\n", + "Ahora hagamos el problema un poco más desafiante.\n", "\n", - "We'll write a program that takes a list of words and prints all the sets of words that are anagrams.\n", - "Here is an example of what the output might look like:\n", + "Escribiremos un programa que toma una lista de palabras e imprime todos los conjuntos de palabras que son anagramas.\n", + "Aquí tienes un ejemplo de cómo podría verse la salida:\n", "\n", " ['deltas', 'desalt', 'lasted', 'salted', 'slated', 'staled']\n", " ['retainers', 'ternaries']\n", " ['generating', 'greatening']\n", " ['resmelts', 'smelters', 'termless']\n", "\n", - "Hint: For each word in the word list, sort the letters and join them back into a string. Make a dictionary that maps from this sorted string to a list of words that are anagrams of it." + "Pista: para cada palabra de la lista de palabras, ordena las letras y vuelve a unirlas en un string. Crea un diccionario que asocie este string ordenado con una lista de palabras que son anagramas de él." ] }, { @@ -1719,7 +1708,7 @@ "tags": [] }, "source": [ - "The following cells download `words.txt` and read the words into a list." + "Las siguientes celdas descargan `words.txt` y leen las palabras en una lista." ] }, { @@ -1749,7 +1738,7 @@ "tags": [] }, "source": [ - "Here's the `sort_word` function we've used before." + "Aquí está la función `sort_word` que hemos usado antes." ] }, { @@ -1777,8 +1766,8 @@ "tags": [] }, "source": [ - "To find the longest list of anagrams, you can use the following function, which takes a key-value pair where the key is a string and the value is a list of words.\n", - "It returns the length of the list." + "Para encontrar la lista más larga de anagramas, puedes usar la siguiente función, que toma un par clave-valor donde la clave es un string y el valor es una lista de palabras.\n", + "Devuelve la longitud de la lista." ] }, { @@ -1798,7 +1787,7 @@ "tags": [] }, "source": [ - "We can use this function as a sort key to find the longest lists of anagrams." + "Podemos usar esta función como sort clave para encontrar las listas más largas de anagramas." ] }, { @@ -1818,7 +1807,7 @@ "tags": [] }, "source": [ - "If you want to know the longest words that have anagrams, you can use the following loop to print some of them." + "Si quieres saber cuáles son las palabras más largas que tienen anagramas, puedes usar el siguiente bucle para imprimir algunas." ] }, { @@ -1836,11 +1825,11 @@ "id": "4fbe939e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `word_distance` that takes two words with the same length and returns the number of places where the two words differ.\n", + "Escribe una función llamada `word_distance` que tome dos palabras con la misma longitud y devuelva el número de posiciones donde las dos palabras difieren.\n", "\n", - "Hint: Use `zip` to loop through the corresponding letters of the words." + "Pista: usa `zip` para hacer un bucle por las letras correspondientes de las palabras." ] }, { @@ -1850,7 +1839,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function with doctests you can use to check your function." + "Aquí tienes un esquema de la función con doctests que puedes usar para comprobar tu función." ] }, { @@ -1886,15 +1875,15 @@ "id": "066eec59", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "\"Metathesis\" is the transposition of letters in a word.\n", - "Two words form a \"metathesis pair\" if you can transform one into the other by swapping two letters, like `converse` and `conserve`.\n", - "Write a program that finds all of the metathesis pairs in the word list. \n", + "\"Metathesis\" es la transposición de letras en una palabra.\n", + "Dos palabras forman una \"metathesis pair\" si puedes transformar una en la otra intercambiando dos letras, como `converse` y `conserve`.\n", + "Escribe un programa que encuentre todos los pares de metathesis en la lista de palabras. \n", "\n", - "Hint: The words in a metathesis pair must be anagrams of each other.\n", + "Pista: las palabras de un par de metathesis deben ser anagramas entre sí.\n", "\n", - "Credit: This exercise is inspired by an example at ." + "Crédito: este ejercicio está inspirado en un ejemplo de ." ] }, { @@ -1912,49 +1901,47 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "This is a bonus exercise that is not in the book.\n", - "It is more challenging than the other exercises in this chapter, so you might want to ask a virtual assistant for help, or come back to it after you've read a few more chapters.\n", + "Este es un ejercicio extra que no está en el libro.\n", + "Es más desafiante que los otros ejercicios de este capítulo, así que quizá quieras pedir ayuda a un asistente virtual, o volver a él después de leer algunos capítulos más.\n", "\n", - "Here's another Car Talk Puzzler\n", + "Aquí tienes otro Car Talk Puzzler\n", "():\n", "\n", - "> What is the longest English word, that remains a valid English word,\n", - "> as you remove its letters one at a time?\n", + "> ¿Cuál es la palabra inglesa más larga que sigue siendo una palabra inglesa válida\n", + "> mientras le quitas letras una a una?\n", ">\n", - "> Now, letters can be removed from either end, or the middle, but you\n", - "> can't rearrange any of the letters. Every time you drop a letter, you\n", - "> wind up with another English word. If you do that, you're eventually\n", - "> going to wind up with one letter and that too is going to be an\n", - "> English word---one that's found in the dictionary. I want to know\n", - "> what's the longest word and how many letters does it have?\n", + "> Ahora, las letras se pueden quitar de cualquiera de los extremos o del medio, pero\n", + "> no puedes reordenar ninguna de las letras. Cada vez que quitas una letra,\n", + "> terminas con otra palabra inglesa. Si haces eso, al final\n", + "> terminarás con una letra, y esa también será una palabra inglesa -- una que\n", + "> aparece en el diccionario. Quiero saber cuál es la palabra más larga\n", + "> y cuántas letras tiene.\n", ">\n", - "> I'm going to give you a little modest example: Sprite. Ok? You start\n", - "> off with sprite, you take a letter off, one from the interior of the\n", - "> word, take the r away, and we're left with the word spite, then we\n", - "> take the e off the end, we're left with spit, we take the s off, we're\n", - "> left with pit, it, and I.\n", + "> Te voy a dar un ejemplo pequeño: Sprite. ¿Ok? Empiezas\n", + "> con sprite, le quitas una letra, una del interior de la\n", + "> palabra, quitas la r, y nos queda la palabra spite; luego\n", + "> quitamos la e del final, nos queda spit; quitamos la s,\n", + "> nos queda pit, it e I.\n", "\n", - "Write a program to find all words that can be reduced in this way, and\n", - "then find the longest one.\n", + "Escribe un programa para encontrar todas las palabras que pueden reducirse de esta manera, y luego encuentra la más larga.\n", "\n", - "This exercise is a little more challenging than most, so here are some\n", - "suggestions:\n", + "Este ejercicio es un poco más desafiante que la mayoría, así que aquí tienes algunas sugerencias:\n", "\n", - "1. You might want to write a function that takes a word and computes a\n", - " list of all the words that can be formed by removing one letter.\n", - " These are the \"children\" of the word.\n", + "1. Quizá quieras escribir una función que tome una palabra y calcule una\n", + " lista de todas las palabras que pueden formarse quitando una letra.\n", + " Estas son las \"children\" de la palabra.\n", "\n", - "2. Recursively, a word is reducible if any of its children are\n", - " reducible. As a base case, you can consider the empty string\n", + "2. Recursivamente, una palabra es reducible si cualquiera de sus children es\n", + " reducible. Como caso base, puedes considerar que el string vacío es\n", " reducible.\n", "\n", - "3. The word list we've been using doesn't contain single letter\n", - " words. So you might have to add \"I\" and \"a\".\n", + "3. La lista de palabras que hemos estado usando no contiene palabras de una sola letra.\n", + " Así que quizá tengas que añadir \"I\" y \"a\".\n", "\n", - "4. To improve the performance of your program, you might want to\n", - " memoize the words that are known to be reducible." + "4. Para mejorar el rendimiento de tu programa, quizá quieras\n", + " memoizar las palabras que se sabe que son reducibles." ] }, { @@ -2008,7 +1995,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/blank/chap12.ipynb b/blank/chap12.ipynb index 220b664..4d3cadf 100644 --- a/blank/chap12.ipynb +++ b/blank/chap12.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,20 +25,20 @@ "id": "59a8621b", "metadata": {}, "source": [ - "# Text Analysis and Generation\n", + "# Análisis y generación de texto\n", "\n", - "At this point we have covered Python's core data structures -- lists, dictionaries, and tuples -- and some algorithms that use them.\n", - "In this chapter, we'll use them to explore text analysis and Markov generation:\n", + "A estas alturas hemos cubierto las estructuras de datos principales de Python -- listas, diccionarios y tuplas -- y algunos algoritmos que las usan.\n", + "En este capítulo, las usaremos para explorar el análisis de texto y la generación de Markov:\n", "\n", - "* Text analysis is a way to describe the statistical relationships between the words in a document, like the probability that one word is followed by another, and\n", + "* El análisis de texto es una forma de describir las relaciones estadísticas entre las palabras de un documento, como la probabilidad de que una palabra vaya seguida de otra, y\n", "\n", - "* Markov generation is a way to generate new text with words and phrases similar to the original text.\n", + "* La generación de Markov es una forma de generar texto nuevo con palabras y frases similares a las del texto original.\n", "\n", - "These algorithms are similar to parts of a Large Language Model (LLM), which is the key component of a chatbot.\n", + "Estos algoritmos son similares a partes de un Large Language Model (LLM), que es el componente clave de un chatbot.\n", "\n", - "We'll start by counting the number of times each word appears in a book.\n", - "Then we'll look at pairs of words, and make a list of the words that can follow each word.\n", - "We'll make a simple version of a Markov generator, and as an exercise, you'll have a chance to make a more general version." + "Empezaremos contando el número de veces que aparece cada palabra en un libro.\n", + "Luego veremos pares de palabras y haremos una lista de las palabras que pueden seguir a cada palabra.\n", + "Haremos una versión simple de un generador de Markov y, como ejercicio, tendrás la oportunidad de hacer una versión más general." ] }, { @@ -46,10 +46,10 @@ "id": "0e3811b8", "metadata": {}, "source": [ - "## Unique words\n", + "## Palabras únicas\n", "\n", - "As a first step toward text analysis, let's read a book -- *The Strange Case Of Dr. Jekyll And Mr. Hyde* by Robert Louis Stevenson -- and count the number of unique words.\n", - "Instructions for downloading the book are in the notebook for this chapter." + "Como primer paso hacia el análisis de texto, leamos un libro -- *The Strange Case Of Dr. Jekyll And Mr. Hyde* de Robert Louis Stevenson -- y contemos el número de palabras únicas.\n", + "Las instrucciones para descargar el libro están en el notebook de este capítulo." ] }, { @@ -59,7 +59,7 @@ "tags": [] }, "source": [ - "The following cell downloads the book from Project Gutenberg." + "La siguiente celda descarga el libro desde Project Gutenberg." ] }, { @@ -79,8 +79,8 @@ "tags": [] }, "source": [ - "The version available from Project Gutenberg includes information about the book at the beginning and license information at the end.\n", - "We'll use `clean_file` from Chapter 8 to remove this material and write a \"clean\" file that contains only the text of the book." + "La versión disponible en Project Gutenberg incluye información sobre el libro al principio e información de licencia al final.\n", + "Usaremos `clean_file` del Capítulo 8 para eliminar este material y escribir un archivo \"limpio\" que contiene solo el texto del libro." ] }, { @@ -126,8 +126,8 @@ "id": "bc66d7e2", "metadata": {}, "source": [ - "We'll use a `for` loop to read lines from the file and `split` to divide the lines into words.\n", - "Then, to keep track of unique words, we'll store each word as a key in a dictionary." + "Usaremos un bucle `for` para leer líneas del archivo y `split` para dividir las líneas en palabras.\n", + "Luego, para llevar la cuenta de las palabras únicas, guardaremos cada palabra como una clave en un diccionario." ] }, { @@ -143,11 +143,11 @@ "id": "85171a3a", "metadata": {}, "source": [ - "The length of the dictionary is the number of unique words -- about `6000` by this way of counting.\n", - "But if we inspect them, we'll see that some are not valid words.\n", + "La longitud del diccionario es el número de palabras únicas -- unas `6000` con esta forma de contar.\n", + "Pero si las inspeccionamos, veremos que algunas no son palabras válidas.\n", "\n", - "For example, let's look at the longest words in `unique_words`.\n", - "We can use `sorted` to sort the words, passing the `len` function as a keyword argument so the words are sorted by length." + "Por ejemplo, veamos las palabras más largas en `unique_words`.\n", + "Podemos usar `sorted` para ordenar las palabras, pasando la función `len` como keyword argumento para que las palabras se ordenen por longitud." ] }, { @@ -163,13 +163,13 @@ "id": "795f5327", "metadata": {}, "source": [ - "The slice index, `[-5:]`, selects the last `5` elements of the sorted list, which are the longest words. \n", + "El índice de porción, `[-5:]`, selecciona los últimos `5` elementos de la lista ordenada, que son las palabras más largas. \n", "\n", - "The list includes some legitimately long words, like \"circumscription\", and some hyphenated words, like \"chocolate-coloured\".\n", - "But some of the longest \"words\" are actually two words separated by a dash.\n", - "And other words include punctuation like periods, exclamation points, and quotation marks.\n", + "La lista incluye algunas palabras legítimamente largas, como \"circumscription\", y algunas palabras con guion, como \"chocolate-coloured\".\n", + "Pero algunas de las \"palabras\" más largas son en realidad dos palabras separadas por una raya.\n", + "Y otras palabras incluyen puntuación como puntos, signos de exclamación y comillas.\n", "\n", - "So, before we move on, let's deal with dashes and other punctuation." + "Así que, antes de seguir, ocupémonos de las rayas y otros signos de puntuación." ] }, { @@ -177,15 +177,15 @@ "id": "bf89fafa", "metadata": {}, "source": [ - "## Punctuation\n", + "## Puntuación\n", "\n", - "To identify the words in the text, we need to deal with two issues:\n", + "Para identificar las palabras del texto, tenemos que resolver dos cuestiones:\n", "\n", - "* When a dash appears in a line, we should replace it with a space -- then when we use `split`, the words will be separated.\n", + "* Cuando aparece una raya en una línea, deberíamos reemplazarla por un espacio -- así, cuando usemos `split`, las palabras quedarán separadas.\n", "\n", - "* After splitting the words, we can use `strip` to remove punctuation.\n", + "* Después de separar las palabras, podemos usar `strip` para eliminar la puntuación.\n", "\n", - "To handle the first issue, we can use the following function, which takes a string, replaces dashes with spaces, splits the string, and returns the resulting list." + "Para manejar la primera cuestión, podemos usar la siguiente función, que toma un string, reemplaza las rayas por espacios, divide el string y devuelve la lista resultante." ] }, { @@ -201,8 +201,8 @@ "id": "d5decdec", "metadata": {}, "source": [ - "Notice that `split_line` only replaces dashes, not hyphens.\n", - "Here's an example." + "Observa que `split_line` solo reemplaza rayas, no guiones.\n", + "Aquí tienes un ejemplo." ] }, { @@ -218,11 +218,11 @@ "id": "0d9eb318", "metadata": {}, "source": [ - "Now, to remove punctuation from the beginning and end of each word, we can use `strip`, but we need a list of characters that are considered punctuation.\n", + "Ahora, para eliminar la puntuación del principio y del final de cada palabra, podemos usar `strip`, pero necesitamos una lista de caracteres que se consideran puntuación.\n", "\n", - "Characters in Python strings are in Unicode, which is an international standard used to represent letters in nearly every alphabet, numbers, symbols, punctuation marks, and more.\n", - "The `unicodedata` module provides a `category` function we can use to tell which characters are punctuation.\n", - "Given a letter, it returns a string with information about what category the letter is in." + "Los caracteres en los strings de Python están en Unicode, que es un estándar internacional usado para representar letras de casi todos los alfabetos, números, símbolos, signos de puntuación y más.\n", + "El módulo `unicodedata` proporciona una función `category` que podemos usar para saber qué caracteres son puntuación.\n", + "Dada una letra, devuelve un string con información sobre la categoría a la que pertenece." ] }, { @@ -238,9 +238,9 @@ "id": "994835ea", "metadata": {}, "source": [ - "The category string of `'A'` is `'Lu'` -- the `'L'` means it is a letter and the `'u'` means it is uppercase.\n", + "El string de categoría de `'A'` es `'Lu'` -- la `'L'` significa que es una letra y la `'u'` significa que es mayúscula.\n", "\n", - "The category string of `'.'` is `'Po'` -- the `'P'` means it is punctuation and the `'o'` means its subcategory is \"other\"." + "El string de categoría de `'.'` es `'Po'` -- la `'P'` significa que es puntuación y la `'o'` significa que su subcategoría es \"other\"." ] }, { @@ -256,8 +256,8 @@ "id": "03773b9b", "metadata": {}, "source": [ - "We can find the punctuation marks in the book by checking for characters with categories that begin with `'P'`.\n", - "The following loop stores the unique punctuation marks in a dictionary." + "Podemos encontrar los signos de puntuación del libro comprobando los caracteres con categorías que empiezan por `'P'`.\n", + "El siguiente bucle guarda los signos de puntuación únicos en un diccionario." ] }, { @@ -273,7 +273,7 @@ "id": "e6741dfa", "metadata": {}, "source": [ - "To make a list of punctuation marks, we can join the keys of the dictionary into a string." + "Para crear una lista de signos de puntuación, podemos unir las claves del diccionario en un string." ] }, { @@ -289,7 +289,7 @@ "id": "6af8d5a2", "metadata": {}, "source": [ - "Now that we know which characters in the book are punctuation, we can write a function that takes a word, strips punctuation from the beginning and end, and converts it to lower case." + "Ahora que sabemos qué caracteres del libro son puntuación, podemos escribir una función que toma una palabra, elimina la puntuación del principio y del final, y la convierte a minúsculas." ] }, { @@ -305,7 +305,7 @@ "id": "58a78cb1", "metadata": {}, "source": [ - "Here's an example." + "Aquí tienes un ejemplo." ] }, { @@ -321,7 +321,7 @@ "id": "314e4fbd", "metadata": {}, "source": [ - "Because `strip` removes characters from the beginning and end, it leaves hyphenated words alone." + "Como `strip` elimina caracteres del principio y del final, deja intactas las palabras con guion." ] }, { @@ -337,7 +337,7 @@ "id": "99050f8a", "metadata": {}, "source": [ - "Now here's a loop that uses `split_line` and `clean_word` to identify the unique words in the book." + "Ahora aquí tienes un bucle que usa `split_line` y `clean_word` para identificar las palabras únicas del libro." ] }, { @@ -353,8 +353,8 @@ "id": "992e5466", "metadata": {}, "source": [ - "With this stricter definition of what a word is, there are about 4000 unique words.\n", - "And we can confirm that the list of longest words has been cleaned up." + "Con esta definición más estricta de lo que es una palabra, hay unas 4000 palabras únicas.\n", + "Y podemos confirmar que la lista de palabras más largas se ha limpiado." ] }, { @@ -370,7 +370,7 @@ "id": "8014c330", "metadata": {}, "source": [ - "Now let's see how many times each word is used." + "Ahora veamos cuántas veces se usa cada palabra." ] }, { @@ -378,9 +378,9 @@ "id": "7ef40180", "metadata": {}, "source": [ - "## Word frequencies\n", + "## Frecuencias de palabras\n", "\n", - "The following loop computes the frequency of each unique word." + "El siguiente bucle calcula la frecuencia de cada palabra única." ] }, { @@ -396,10 +396,10 @@ "id": "bd680b81", "metadata": {}, "source": [ - "The first time we see a word, we initialize its frequency to `1`. If we see the same word again later, we increment its frequency.\n", + "La primera vez que vemos una palabra, inicializamos su frecuencia a `1`. Si volvemos a ver la misma palabra más adelante, incrementamos su frecuencia.\n", "\n", - "To see which words appear most often, we can use `items` to get the key-value pairs from `word_counter`, and sort them by the second element of the pair, which is the frequency.\n", - "First we'll define a function that selects the second element." + "Para ver qué palabras aparecen con más frecuencia, podemos usar `items` para obtener los pares clave-valor de `word_counter`, y ordenarlos por el segundo elemento del par, que es la frecuencia.\n", + "Primero definiremos una función que selecciona el segundo elemento." ] }, { @@ -415,11 +415,11 @@ "id": "b15a5bd6", "metadata": {}, "source": [ - "Now we can use `sorted` with two keyword arguments:\n", + "Ahora podemos usar `sorted` con dos keyword argumentos:\n", "\n", - "* `key=second_element` means the items will be sorted according to the frequencies of the words.\n", + "* `key=second_element` significa que los elementos se ordenarán según las frecuencias de las palabras.\n", "\n", - "* `reverse=True` means they items will be sorted in reverse order, with the most frequent words first." + "* `reverse=True` significa que los elementos se ordenarán en orden inverso, con las palabras más frecuentes primero." ] }, { @@ -435,7 +435,7 @@ "id": "db6812e2", "metadata": {}, "source": [ - "Here are the five most frequent words." + "Aquí están las cinco palabras más frecuentes." ] }, { @@ -451,8 +451,8 @@ "id": "551e81bb", "metadata": {}, "source": [ - "In the next section, we'll encapsulate this loop in a function.\n", - "And we'll use it to demonstrate a new feature -- optional parameters." + "En la siguiente sección, encapsularemos este bucle en una función.\n", + "Y la usaremos para demostrar una nueva característica -- parámetros opcionales." ] }, { @@ -460,10 +460,10 @@ "id": "45243ccc", "metadata": {}, "source": [ - "## Optional parameters\n", + "## Parámetros opcionales\n", "\n", - "We've used built-in functions that take optional parameters.\n", - "For example, `round` takes an optional parameters called `ndigits` that indicates how many decimal places to keep." + "Hemos usado funciones integradas que toman parámetros opcionales.\n", + "Por ejemplo, `round` toma un parámetro opcional llamado `ndigits` que indica cuántos decimales conservar." ] }, { @@ -479,8 +479,8 @@ "id": "6ae60945", "metadata": {}, "source": [ - "But it's not just built-in functions -- we can write functions with optional parameters, too.\n", - "For example, the following function takes two parameters, `word_counter` and `num`." + "Pero no son solo las funciones integradas -- también podemos escribir funciones con parámetros opcionales.\n", + "Por ejemplo, la siguiente función toma dos parámetros, `word_counter` y `num`." ] }, { @@ -496,9 +496,9 @@ "id": "78cb1531", "metadata": {}, "source": [ - "The second parameter looks like an assignment statement, but it's not -- it's an optional parameter.\n", + "El segundo parámetro parece una sentencia de asignación, pero no lo es -- es un parámetro opcional.\n", "\n", - "If you call this function with one argument, `num` gets the **default value**, which is `5`." + "Si llamas a esta función con un argumento, `num` recibe el **valor por defecto**, que es `5`." ] }, { @@ -514,7 +514,7 @@ "id": "29753ad6", "metadata": {}, "source": [ - "If you call this function with two arguments, the second argument gets assigned to `num` instead of the default value." + "Si llamas a esta función con dos argumentos, el segundo argumento se asigna a `num` en lugar del valor por defecto." ] }, { @@ -530,9 +530,9 @@ "id": "e9bf907b", "metadata": {}, "source": [ - "In that case, we would say the optional argument **overrides** the default value.\n", + "En ese caso, diríamos que el argumento opcional **override** el valor por defecto.\n", "\n", - "If a function has both required and optional parameters, all of the required parameters have to come first, followed by the optional ones." + "Si una función tiene parámetros requeridos y opcionales, todos los parámetros requeridos tienen que ir primero, seguidos por los opcionales." ] }, { @@ -552,14 +552,14 @@ "tags": [] }, "source": [ - "## Dictionary subtraction\n", + "## Resta de diccionarios\n", "\n", - "Suppose we want to spell-check a book -- that is, find a list of words that might be misspelled.\n", - "One way to do that is to find words in the book that don't appear in a list of valid words.\n", - "In previous chapters, we've used a list of words that are considered valid in word games like Scrabble.\n", - "Now we'll use this list to spell-check Robert Louis Stevenson.\n", + "Supongamos que queremos revisar la ortografía de un libro -- es decir, encontrar una lista de palabras que podrían estar mal escritas.\n", + "Una forma de hacerlo es encontrar palabras del libro que no aparecen en una lista de palabras válidas.\n", + "En capítulos anteriores, hemos usado una lista de palabras que se consideran válidas en juegos de palabras como Scrabble.\n", + "Ahora usaremos esta lista para revisar la ortografía de Robert Louis Stevenson.\n", "\n", - "We can think of this problem as set subtraction -- that is, we want to find all the words from one set (the words in the book) that are not in the other (the words in the list)." + "Podemos pensar en este problema como una resta de conjuntos -- es decir, queremos encontrar todas las palabras de un conjunto (las palabras del libro) que no están en el otro (las palabras de la lista)." ] }, { @@ -569,7 +569,7 @@ "tags": [] }, "source": [ - "The following cell downloads the word list." + "La siguiente celda descarga la lista de palabras." ] }, { @@ -587,7 +587,7 @@ "id": "2a46556c", "metadata": {}, "source": [ - "As we've done before, we can read the contents of `words.txt` and split it into a list of strings." + "Como hemos hecho antes, podemos leer el contenido de `words.txt` y dividirlo en una lista de strings." ] }, { @@ -603,7 +603,7 @@ "id": "22becbab", "metadata": {}, "source": [ - "The we'll store the words as keys in a dictionary so we can use the `in` operator to check quickly whether a word is valid." + "Luego guardaremos las palabras como claves en un diccionario para poder usar el operador `in` y comprobar rápidamente si una palabra es válida." ] }, { @@ -619,7 +619,7 @@ "id": "94cc7c61", "metadata": {}, "source": [ - "Now, to identify words that appear in the book but not in the word list, we'll use `subtract`, which takes two dictionaries as parameters and returns a new dictionary that contains all the keys from one that are not in the other." + "Ahora, para identificar palabras que aparecen en el libro pero no en la lista de palabras, usaremos `subtract`, que toma dos diccionarios como parámetros y devuelve un nuevo diccionario que contiene todas las claves de uno que no están en el otro." ] }, { @@ -635,7 +635,7 @@ "id": "e70c63b4", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como lo usamos." ] }, { @@ -651,7 +651,7 @@ "id": "f8ada7bd", "metadata": {}, "source": [ - "To get a sample of words that might be misspelled, we can print the most common words in `diff`." + "Para obtener una muestra de palabras que podrían estar mal escritas, podemos imprimir las palabras más comunes en `diff`." ] }, { @@ -667,10 +667,10 @@ "id": "deeec418", "metadata": {}, "source": [ - "The most common \"misspelled\" words are mostly names and a few single-letter words (Mr. Utterson is Dr. Jekyll's friend and lawyer).\n", + "Las \"palabras mal escritas\" más comunes son en su mayoría nombres y algunas palabras de una sola letra (Mr. Utterson es el amigo y abogado del Dr. Jekyll).\n", "\n", - "If we select words that only appear once, they are more likely to be actual misspellings.\n", - "We can do that by looping through the items and making a list of words with frequency `1`." + "Si seleccionamos palabras que solo aparecen una vez, es más probable que sean errores ortográficos reales.\n", + "Podemos hacerlo haciendo un bucle por los elementos y creando una lista de palabras con frecuencia `1`." ] }, { @@ -686,7 +686,7 @@ "id": "98ae9281", "metadata": {}, "source": [ - "Here are the last few elements of the list." + "Aquí están los últimos elementos de la lista." ] }, { @@ -702,8 +702,8 @@ "id": "c5040834", "metadata": {}, "source": [ - "Most of them are valid words that are not in the word list.\n", - "But `'reindue'` appears to be a misspelling of `'reinduce'`, so at least we found one legitimate error." + "La mayoría son palabras válidas que no están en la lista de palabras.\n", + "Pero `'reindue'` parece ser un error ortográfico de `'reinduce'`, así que al menos encontramos un error legítimo." ] }, { @@ -711,22 +711,22 @@ "id": "afcbbe19", "metadata": {}, "source": [ - "## Random numbers\n", + "## Números aleatorios\n", "\n", - "As a step toward Markov text generation, next we'll choose a random sequence of words from `word_counter`.\n", - "But first let's talk about randomness.\n", + "Como paso hacia la generación de texto de Markov, a continuación elegiremos una secuencia aleatoria de palabras de `word_counter`.\n", + "Pero primero hablemos de aleatoriedad.\n", "\n", - "Given the same inputs, most computer programs are **deterministic**, which means they generate the same outputs every time.\n", - "Determinism is usually a good thing, since we expect the same calculation to yield the same result.\n", - "For some applications, though, we want the computer to be unpredictable.\n", - "Games are one example, but there are more.\n", + "Dados los mismos inputs, la mayoría de los programas de computadora son **determinista**, lo que significa que generan los mismos outputs cada vez.\n", + "El determinismo suele ser algo bueno, ya que esperamos que el mismo cálculo produzca el mismo resultado.\n", + "Para algunas aplicaciones, sin embargo, queremos que la computadora sea impredecible.\n", + "Los juegos son un ejemplo, pero hay más.\n", "\n", - "Making a program truly nondeterministic turns out to be difficult, but there are ways to fake it.\n", - "One is to use algorithms that generate **pseudorandom** numbers.\n", - "Pseudorandom numbers are not truly random because they are generated by a deterministic computation, but just by looking at the numbers it is all but impossible to distinguish them from random.\n", + "Hacer que un programa sea verdaderamente no determinista resulta ser difícil, pero hay formas de simularlo.\n", + "Una es usar algoritmos que generan números **pseudorandom**.\n", + "Los números pseudorandom no son verdaderamente aleatorios porque se generan mediante un cálculo determinista, pero con solo mirar los números es prácticamente imposible distinguirlos de números aleatorios.\n", "\n", - "The `random` module provides functions that generate pseudorandom numbers -- which I will simply call \"random\" from here on.\n", - "We can import it like this." + "El módulo `random` proporciona funciones que generan números pseudorandom -- a los que de aquí en adelante simplemente llamaré \"random\".\n", + "Podemos importarlo así." ] }, { @@ -752,7 +752,7 @@ "id": "8cbbd7f8", "metadata": {}, "source": [ - "The `random` module provides a function called `choice` that chooses an element from a list at random, with every element having the same probability of being chosen." + "El módulo `random` proporciona una función llamada `choice` que elige un elemento de una lista al azar, con la misma probabilidad de elegir cada elemento." ] }, { @@ -768,7 +768,7 @@ "id": "57c15af2", "metadata": {}, "source": [ - "If you call the function again, you might get the same element again, or a different one." + "Si llamas a la función otra vez, podrías obtener el mismo elemento de nuevo, o uno diferente." ] }, { @@ -784,9 +784,9 @@ "id": "6f0c2572", "metadata": {}, "source": [ - "In the long run, we expect to get every element about the same number of times.\n", + "A largo plazo, esperamos obtener cada elemento aproximadamente el mismo número de veces.\n", "\n", - "If you use `choice` with a dictionary, you get a `KeyError`." + "Si usas `choice` con un diccionario, obtienes un `KeyError`." ] }, { @@ -804,7 +804,7 @@ "id": "592722f3", "metadata": {}, "source": [ - "To choose a random key, you have to put the keys in a list and then call `choice`." + "Para elegir una clave aleatoria, tienes que poner las claves en una lista y luego llamar a `choice`." ] }, { @@ -820,7 +820,7 @@ "id": "172d72f6", "metadata": {}, "source": [ - "If we generate a random sequence of words, it doesn't make much sense." + "Si generamos una secuencia aleatoria de palabras, no tiene mucho sentido." ] }, { @@ -836,10 +836,10 @@ "id": "e0e2fbc4", "metadata": {}, "source": [ - "Part of the problem is that we are not taking into account that some words are more common than others.\n", - "The results will be better if we choose words with different \"weights\", so that some are chosen more often than others.\n", + "Parte del problema es que no estamos teniendo en cuenta que algunas palabras son más comunes que otras.\n", + "Los resultados serán mejores si elegimos palabras con distintos \"weights\", de modo que algunas se elijan más a menudo que otras.\n", "\n", - "If we use the values from `word_counter` as weights, each word is chosen with a probability that depends on its frequency." + "Si usamos los valores de `word_counter` como weights, cada palabra se elige con una probabilidad que depende de su frecuencia." ] }, { @@ -855,7 +855,7 @@ "id": "5098bf93", "metadata": {}, "source": [ - "The `random` module provides another function called `choices` that takes weights as an optional argument." + "El módulo `random` proporciona otra función llamada `choices` que toma weights como argumento opcional." ] }, { @@ -871,7 +871,7 @@ "id": "a3341e84", "metadata": {}, "source": [ - "And it takes another optional argument, `k`, that specifies the number of words to select." + "Y toma otro argumento opcional, `k`, que especifica el número de palabras a seleccionar." ] }, { @@ -887,7 +887,7 @@ "id": "e57e6f3d", "metadata": {}, "source": [ - "The result is a list of strings that we can join into something that's looks more like a sentence." + "El resultado es una lista de strings que podemos unir en algo que se parece más a una oración." ] }, { @@ -903,9 +903,9 @@ "id": "c7a35dff", "metadata": {}, "source": [ - "If you choose words from the book at random, you get a sense of the vocabulary, but a series of random words seldom makes sense because there is no relationship between successive words.\n", - "For example, in a real sentence you expect an article like \"the\" to be followed by an adjective or a noun, and probably not a verb or adverb.\n", - "So the next step is to look at these relationships between words." + "Si eliges palabras del libro al azar, obtienes una idea del vocabulario, pero una serie de palabras aleatorias rara vez tiene sentido porque no hay relación entre palabras sucesivas.\n", + "Por ejemplo, en una oración real esperas que un artículo como \"the\" vaya seguido de un adjetivo o un sustantivo, y probablemente no de un verbo o adverbio.\n", + "Así que el siguiente paso es observar estas relaciones entre palabras." ] }, { @@ -913,19 +913,19 @@ "id": "0921dd53", "metadata": {}, "source": [ - "## Bigrams\n", + "## Bigramas\n", "\n", - "Instead of looking at one word at a time, now we'll look at sequences of two words, which are called **bigrams**.\n", - "A sequence of three words is called a **trigram**, and a sequence with some unspecified number of words is called an **n-gram**.\n", + "En lugar de mirar una palabra cada vez, ahora miraremos secuencias de dos palabras, que se llaman **bigramas**.\n", + "Una secuencia de tres palabras se llama **trigram**, y una secuencia con un número no especificado de palabras se llama **n-gram**.\n", "\n", - "Let's write a program that finds all of the bigrams in the book and the number of times each one appears.\n", - "To store the results, we'll use a dictionary where\n", + "Escribamos un programa que encuentre todos los bigramas del libro y el número de veces que aparece cada uno.\n", + "Para guardar los resultados, usaremos un diccionario donde\n", "\n", - "* The keys are tuples of strings that represent bigrams, and \n", + "* Las claves son tuplas de strings que representan bigramas, y \n", "\n", - "* The values are integers that represent frequencies.\n", + "* Los valores son enteros que representan frecuencias.\n", "\n", - "Let's call it `bigram_counter`." + "Llamémoslo `bigram_counter`." ] }, { @@ -941,9 +941,9 @@ "id": "33f97a2a", "metadata": {}, "source": [ - "The following function takes a list of two strings as a parameter.\n", - "First it makes a tuple of the two strings, which can be used as a key in a dictionary.\n", - "Then it adds the key to `bigram_counter`, if it doesn't exist, or increments the frequency if it does." + "La siguiente función toma una lista de dos strings como parámetro.\n", + "Primero crea una tupla con los dos strings, que puede usarse como clave en un diccionario.\n", + "Luego añade la clave a `bigram_counter`, si no existe, o incrementa la frecuencia si existe." ] }, { @@ -959,11 +959,11 @@ "id": "5c30f429", "metadata": {}, "source": [ - "As we go through the book, we have to keep track of each pair of consecutive words.\n", - "So if we see the sequence \"man is not truly one\", we would add the bigrams \"man is\", \"is not\", \"not truly\", and so on.\n", + "A medida que recorremos el libro, tenemos que llevar la cuenta de cada par de palabras consecutivas.\n", + "Así que si vemos la secuencia \"man is not truly one\", añadiríamos los bigramas \"man is\", \"is not\", \"not truly\", y así sucesivamente.\n", "\n", - "To keep track of these bigrams, we'll use a list called `window`, because it is like a window that slides over the pages of the book, showing only two words at a time.\n", - "Initially, `window` is empty." + "Para llevar la cuenta de estos bigramas, usaremos una lista llamada `window`, porque es como una ventana que se desliza sobre las páginas del libro, mostrando solo dos palabras a la vez.\n", + "Inicialmente, `window` está vacía." ] }, { @@ -979,7 +979,7 @@ "id": "9376558c", "metadata": {}, "source": [ - "We'll use the following function to process the words one at a time." + "Usaremos la siguiente función para procesar las palabras una por una." ] }, { @@ -995,14 +995,14 @@ "id": "56895591", "metadata": {}, "source": [ - "The first time this function is called, it appends the given word to `window`.\n", - "Since there is only one word in the window, we don't have a bigram yet, so the function ends.\n", + "La primera vez que se llama a esta función, añade la palabra dada a `window`.\n", + "Como solo hay una palabra en la window, todavía no tenemos un bigrama, así que la función termina.\n", "\n", - "The second time it's called -- and every time thereafter -- it appends a second word to `window`.\n", - "Since there are two words in the window, it calls `count_bigram` to keep track of how many times each bigram appears.\n", - "Then it uses `pop` to remove the first word from the window.\n", + "La segunda vez que se llama -- y todas las veces después -- añade una segunda palabra a `window`.\n", + "Como hay dos palabras en la window, llama a `count_bigram` para llevar la cuenta de cuántas veces aparece cada bigrama.\n", + "Luego usa `pop` para eliminar la primera palabra de la window.\n", "\n", - "The following program loops through the words in the book and processes them one at a time." + "El siguiente programa hace un bucle por las palabras del libro y las procesa una a una." ] }, { @@ -1018,8 +1018,8 @@ "id": "20c4627a", "metadata": {}, "source": [ - "The result is a dictionary that maps from each bigram to the number of times it appears.\n", - "We can use `print_most_common` to see the most common bigrams." + "El resultado es un diccionario que asocia cada bigrama con el número de veces que aparece.\n", + "Podemos usar `print_most_common` para ver los bigramas más comunes." ] }, { @@ -1035,8 +1035,8 @@ "id": "757bd309", "metadata": {}, "source": [ - "Looking at these results, we can get a sense of which pairs of words are most likely to appear together.\n", - "We can also use the results to generate random text, like this." + "Al mirar estos resultados, podemos hacernos una idea de qué pares de palabras tienen más probabilidad de aparecer juntos.\n", + "También podemos usar los resultados para generar texto aleatorio, así." ] }, { @@ -1062,10 +1062,10 @@ "id": "eda80407", "metadata": {}, "source": [ - "`bigrams` is a list of the bigrams that appear in the books.\n", - "`weights` is a list of their frequencies, so `random_bigrams` is a sample where the probability a bigram is selected is proportional to its frequency. \n", + "`bigrams` es una lista de los bigramas que aparecen en los libros.\n", + "`weights` es una lista de sus frecuencias, así que `random_bigrams` es una muestra donde la probabilidad de que se seleccione un bigrama es proporcional a su frecuencia. \n", "\n", - "Here are the results." + "Aquí están los resultados." ] }, { @@ -1081,7 +1081,7 @@ "id": "5f24c3b6", "metadata": {}, "source": [ - "This way of generating text is better than choosing random words, but still doesn't make a lot of sense." + "Esta forma de generar texto es mejor que elegir palabras aleatorias, pero todavía no tiene mucho sentido." ] }, { @@ -1089,10 +1089,10 @@ "id": "a13d93b5", "metadata": {}, "source": [ - "## Markov analysis\n", + "## Análisis de Markov\n", "\n", - "We can do better with Markov chain text analysis, which computes, for each word in a text, the list of words that come next.\n", - "As an example, we'll analyze these lyrics from the Monty Python song *Eric, the Half a Bee*:" + "Podemos hacerlo mejor con el análisis de texto mediante cadenas de Markov, que calcula, para cada palabra de un texto, la lista de palabras que vienen después.\n", + "Como ejemplo, analizaremos esta letra de la canción de Monty Python *Eric, the Half a Bee*:" ] }, { @@ -1108,7 +1108,7 @@ "id": "583ab9f0", "metadata": {}, "source": [ - "To store the results, we'll use a dictionary that maps from each word to the list of words that follow it." + "Para guardar los resultados, usaremos un diccionario que asocia cada palabra con la lista de palabras que la siguen." ] }, { @@ -1124,7 +1124,7 @@ "id": "d5d85b09", "metadata": {}, "source": [ - "As an example, let's start with the first two words of the song." + "Como ejemplo, empecemos con las dos primeras palabras de la canción." ] }, { @@ -1140,7 +1140,7 @@ "id": "0349fe78", "metadata": {}, "source": [ - "If the first word is not in `successor_map`, we have to add a new item that maps from the first word to a list containing the second word." + "Si la primera palabra no está en `successor_map`, tenemos que añadir un nuevo elemento que asocie la primera palabra con una lista que contiene la segunda palabra." ] }, { @@ -1156,7 +1156,7 @@ "id": "55bb8df9", "metadata": {}, "source": [ - "If the first word is already in the dictionary, we can look it up to get the list of successors we've seen so far, and append the new one." + "Si la primera palabra ya está en el diccionario, podemos buscarla para obtener la lista de sucesores que hemos visto hasta ahora, y añadir el nuevo." ] }, { @@ -1172,7 +1172,7 @@ "id": "6289cc32", "metadata": {}, "source": [ - "The following function encapsulates these steps." + "La siguiente función encapsula estos pasos." ] }, { @@ -1188,11 +1188,11 @@ "id": "74a51700", "metadata": {}, "source": [ - "If the same bigram appears more that once, the second word is added to the list more than once.\n", - "In this way, `successor_map` keeps track of how many times each successor appears.\n", + "Si el mismo bigrama aparece más de una vez, la segunda palabra se añade a la lista más de una vez.\n", + "De esta manera, `successor_map` lleva la cuenta de cuántas veces aparece cada sucesor.\n", "\n", - "As we did in the previous section, we'll use a list called `window` to store pairs of consecutive words.\n", - "And we'll use the following function to process the words one at a time." + "Como hicimos en la sección anterior, usaremos una lista llamada `window` para guardar pares de palabras consecutivas.\n", + "Y usaremos la siguiente función para procesar las palabras una por una." ] }, { @@ -1208,7 +1208,7 @@ "id": "861a60d9", "metadata": {}, "source": [ - "Here's how we use it to process the words in the song." + "Así es como la usamos para procesar las palabras de la canción." ] }, { @@ -1224,7 +1224,7 @@ "id": "bf490d67", "metadata": {}, "source": [ - "And here are the results." + "Y aquí están los resultados." ] }, { @@ -1240,11 +1240,11 @@ "id": "ff7bad74", "metadata": {}, "source": [ - "The word `'half'` can be followed by `'a'`, `'not'`, or `'the'`.\n", - "The word `'a'` can be followed by `'bee'` or `'vis'`.\n", - "Most of the other words appear only once, so they are followed by only a single word.\n", + "La palabra `'half'` puede ir seguida de `'a'`, `'not'` o `'the'`.\n", + "La palabra `'a'` puede ir seguida de `'bee'` o `'vis'`.\n", + "La mayoría de las demás palabras aparecen solo una vez, así que van seguidas de una única palabra.\n", "\n", - "Now let's analyze the book." + "Ahora analicemos el libro." ] }, { @@ -1260,7 +1260,7 @@ "id": "2676e2fb", "metadata": {}, "source": [ - "We can look up any word and find the words that can follow it." + "Podemos buscar cualquier palabra y encontrar las palabras que pueden seguirla." ] }, { @@ -1286,7 +1286,7 @@ "id": "7b777a9c", "metadata": {}, "source": [ - "In this list of successors, notice that the word `'to'` appears three times -- the other successors only appear once." + "En esta lista de sucesores, observa que la palabra `'to'` aparece tres veces -- los demás sucesores aparecen solo una vez." ] }, { @@ -1294,18 +1294,18 @@ "id": "e8bf85fc", "metadata": {}, "source": [ - "## Generating text\n", + "## Generar texto\n", "\n", - "We can use the results from the previous section to generate new text with the same relationships between consecutive words as in the original.\n", - "Here's how it works:\n", + "Podemos usar los resultados de la sección anterior para generar texto nuevo con las mismas relaciones entre palabras consecutivas que en el original.\n", + "Así funciona:\n", "\n", - "* Starting with any word that appears in the text, we look up its possible successors and choose one at random.\n", + "* Empezando con cualquier palabra que aparezca en el texto, buscamos sus posibles sucesores y elegimos uno al azar.\n", "\n", - "* Then, using the chosen word, we look up its possible successors, and choose one at random.\n", + "* Luego, usando la palabra elegida, buscamos sus posibles sucesores y elegimos uno al azar.\n", "\n", - "We can repeat this process to generate as many words as we want.\n", - "As an example, let's start with the word `'although'`.\n", - "Here are the words that can follow it." + "Podemos repetir este proceso para generar tantas palabras como queramos.\n", + "Como ejemplo, empecemos con la palabra `'although'`.\n", + "Estas son las palabras que pueden seguirla." ] }, { @@ -1331,7 +1331,7 @@ "id": "b26a2ead", "metadata": {}, "source": [ - "We can use `choice` to choose from the list with equal probability." + "Podemos usar `choice` para elegir de la lista con la misma probabilidad." ] }, { @@ -1347,9 +1347,9 @@ "id": "9741beca", "metadata": {}, "source": [ - "If the same word appears more than once in the list, it is more likely to be selected.\n", + "Si la misma palabra aparece más de una vez en la lista, es más probable que sea seleccionada.\n", "\n", - "Repeating these steps, we can use the following loop to generate a longer series." + "Repitiendo estos pasos, podemos usar el siguiente bucle para generar una serie más larga." ] }, { @@ -1365,11 +1365,11 @@ "id": "38a2d79a", "metadata": {}, "source": [ - "The result sounds more like a real sentence, but it still doesn't make much sense.\n", + "El resultado suena más como una oración real, pero todavía no tiene mucho sentido.\n", "\n", - "We can do better using more than one word as a key in `successor_map`.\n", - "For example, we can make a dictionary that maps from each bigram -- or trigram -- to the list of words that come next.\n", - "As an exercise, you'll have a chance to implement this analysis and see what the results look like." + "Podemos hacerlo mejor usando más de una palabra como clave en `successor_map`.\n", + "Por ejemplo, podemos crear un diccionario que asocie cada bigrama -- o trigram -- con la lista de palabras que vienen después.\n", + "Como ejercicio, tendrás la oportunidad de implementar este análisis y ver cómo son los resultados." ] }, { @@ -1379,32 +1379,32 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "At this point we are writing more substantial programs, and you might find that you are spending more time debugging.\n", - "If you are stuck on a difficult bug, here are a few things to try:\n", + "A estas alturas estamos escribiendo programas más sustanciales, y puede que descubras que pasas más tiempo depurando.\n", + "Si estás atascado con un bug difícil, aquí tienes algunas cosas que puedes probar:\n", "\n", - "* Reading: Examine your code, read it back to yourself, and check that it says what you meant to say.\n", + "* Leer: examina tu código, léelo en voz alta para ti y comprueba que dice lo que querías decir.\n", "\n", - "* Running: Experiment by making changes and running different versions. Often if you display the right thing at the right place in the program, the problem becomes obvious, but sometimes you have to build scaffolding.\n", + "* Ejecutar: experimenta haciendo cambios y ejecutando versiones diferentes. A menudo, si muestras lo correcto en el lugar correcto del programa, el problema se vuelve obvio, pero a veces tienes que construir código de apoyo.\n", "\n", - "* Ruminating: Take some time to think! What kind of error is it: syntax, runtime,\n", - " or semantic? What information can you get from the error messages,\n", - " or from the output of the program? What kind of error could cause\n", - " the problem you're seeing? What did you change last, before the\n", - " problem appeared?\n", + "* Rumiar: ¡tómate tiempo para pensar! ¿Qué tipo de error es: de sintaxis, de runtime,\n", + " o semántico? ¿Qué información puedes obtener de los mensajes de error,\n", + " o del output del programa? ¿Qué tipo de error podría causar\n", + " el problema que estás viendo? ¿Qué cambiaste por última vez, antes de que\n", + " apareciera el problema?\n", "\n", - "* Rubberducking: If you explain the problem to someone else, you sometimes find the\n", - " answer before you finish asking the question. Often you don't need\n", - " the other person; you could just talk to a rubber duck. And that's\n", - " the origin of the well-known strategy called **rubber duck\n", - " debugging**. I am not making this up -- see\n", - " .\n", + "* Rubberducking: si explicas el problema a otra persona, a veces encuentras la\n", + " respuesta antes de terminar de hacer la pregunta. A menudo no necesitas\n", + " a la otra persona; podrías hablarle a un patito de goma. Y ese es\n", + " el origen de la estrategia conocida como **rubber duck\n", + " depuración**. No me lo estoy inventando -- ver\n", + " .\n", "\n", - "* Retreating: At some point, the best thing to do is back up -- undoing recent\n", - " changes -- until you get to a program that works. Then you can start rebuilding.\n", + "* Retirarse: en algún momento, lo mejor es retroceder -- deshacer cambios\n", + " recientes -- hasta llegar a un programa que funcione. Luego puedes empezar a reconstruir.\n", " \n", - "* Resting: If you give your brain a break, sometime it will find the problem for you." + "* Descansar: si le das un respiro a tu cerebro, a veces encontrará el problema por ti." ] }, { @@ -1412,15 +1412,15 @@ "id": "12c2cd32", "metadata": {}, "source": [ - "Beginning programmers sometimes get stuck on one of these activities and forget the others. Each activity comes with its own failure mode.\n", + "Los programadores principiantes a veces se quedan atascados en una de estas actividades y olvidan las demás. Cada actividad tiene su propio modo de fallo.\n", "\n", - "For example, reading your code works if the problem is a typographical error, but not if the problem is a conceptual misunderstanding.\n", - "If you don't understand what your program does, you can read it 100 times and never see the error, because the error is in your head.\n", + "Por ejemplo, leer tu código funciona si el problema es un error tipográfico, pero no si el problema es un malentendido conceptual.\n", + "Si no entiendes lo que hace tu programa, puedes leerlo 100 veces y nunca ver el error, porque el error está en tu cabeza.\n", "\n", - "Running experiments can work, especially if you run small, simple tests.\n", - "But if you run experiments without thinking or reading your code, it can take a long time to figure out what's happening.\n", + "Ejecutar experimentos puede funcionar, especialmente si ejecutas tests pequeños y simples.\n", + "Pero si haces experimentos sin pensar ni leer tu código, puede llevar mucho tiempo averiguar qué está pasando.\n", "\n", - "You have to take time to think. Debugging is like an experimental science. You should have at least one hypothesis about what the problem is. If there are two or more possibilities, try to think of a test that would eliminate one of them." + "Tienes que tomarte tiempo para pensar. Depurar es como una ciencia experimental. Deberías tener al menos una hipótesis sobre cuál es el problema. Si hay dos o más posibilidades, intenta pensar en un test que elimine una de ellas." ] }, { @@ -1428,18 +1428,13 @@ "id": "a55036e1", "metadata": {}, "source": [ - "But even the best debugging techniques will fail if there are too many\n", - "errors, or if the code you are trying to fix is too big and complicated.\n", - "Sometimes the best option is to retreat, simplifying the program until\n", - "you get back to something that works.\n", + "Pero incluso las mejores técnicas de depuración fallarán si hay demasiados errores, o si el código que intentas arreglar es demasiado grande y complicado.\n", + "A veces la mejor opción es retirarse, simplificando el programa hasta volver a algo que funcione.\n", "\n", - "Beginning programmers are often reluctant to retreat because they can't\n", - "stand to delete a line of code (even if it's wrong). If it makes you\n", - "feel better, copy your program into another file before you start\n", - "stripping it down. Then you can copy the pieces back one at a time.\n", + "Los programadores principiantes a menudo se resisten a retirarse porque no soportan borrar una línea de código (aunque esté mal). Si te hace sentir mejor, copia tu programa en otro archivo antes de empezar a recortarlo. Luego puedes copiar las piezas de vuelta una por una.\n", "\n", - "Finding a hard bug requires reading, running, ruminating, retreating, and sometimes resting.\n", - "If you get stuck on one of these activities, try the others." + "Encontrar un bug difícil requiere leer, ejecutar, rumiar, retirarse y a veces descansar.\n", + "Si te atascas en una de estas actividades, prueba las otras." ] }, { @@ -1447,31 +1442,31 @@ "id": "25d091af", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**default value:**\n", - "The value assigned to a parameter if no argument is provided.\n", + "**valor por defecto:**\n", + "El valor asignado a un parámetro si no se proporciona ningún argumento.\n", "\n", "**override:**\n", - " To replace a default value with an argument.\n", + " Reemplazar un valor por defecto por un argumento.\n", "\n", - "**deterministic:**\n", - " A deterministic program does the same thing each time it runs, given the same inputs.\n", + "**determinista:**\n", + " Un programa determinista hace lo mismo cada vez que se ejecuta, dados los mismos inputs.\n", "\n", "**pseudorandom:**\n", - " A pseudorandom sequence of numbers appears to be random, but is generated by a deterministic program.\n", + " Una secuencia pseudorandom de números parece aleatoria, pero es generada por un programa determinista.\n", "\n", - "**bigram:**\n", - "A sequence of two elements, often words.\n", + "**bigrama:**\n", + "Una secuencia de dos elementos, a menudo palabras.\n", "\n", "**trigram:**\n", - "A sequence of three elements.\n", + "Una secuencia de tres elementos.\n", "\n", "**n-gram:**\n", - "A sequence of an unspecified number of elements.\n", + "Una secuencia de un número no especificado de elementos.\n", "\n", - "**rubber duck debugging:**\n", - "A way of debugging by explaining a problem aloud to an inanimate object." + "**rubber duck depuración:**\n", + "Una forma de depurar explicando un problema en voz alta a un objeto inanimado." ] }, { @@ -1479,7 +1474,7 @@ "id": "cde18229", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1497,9 +1492,9 @@ "id": "9b0efab8", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In `add_bigram`, the `if` statement creates a new list or appends an element to an existing list, depending on whether the key is already in the dictionary." + "En `add_bigram`, la sentencia `if` crea una nueva lista o añade un elemento a una lista existente, dependiendo de si la clave ya está en el diccionario." ] }, { @@ -1515,13 +1510,13 @@ "id": "30d9e549", "metadata": {}, "source": [ - "Dictionaries provide a method called `setdefault` that we can use to do the same thing more concisely.\n", - "Ask a virtual assistant how it works, or copy `add_word` into a virtual assistant and ask \"Can you rewrite this using `setdefault`?\"\n", + "Diccionarios proporcionan un método llamado `setdefault` que podemos usar para hacer lo mismo de forma más concisa.\n", + "Pregunta a un asistente virtual cómo funciona, o copia `add_word` en un asistente virtual y pregunta \"Can you rewrite this using `setdefault`?\"\n", "\n", - "In this chapter we implemented Markov chain text analysis and generation.\n", - "If you are curious, you can ask a virtual assistant for more information on the topic.\n", - "One of the things you might learn is that virtual assistants use algorithms that are similar in many ways -- but also different in important ways.\n", - "Ask a VA, \"What are the differences between large language models like GPT and Markov chain text analysis?\"" + "En este capítulo implementamos análisis y generación de texto con cadenas de Markov.\n", + "Si tienes curiosidad, puedes pedirle a un asistente virtual más información sobre el tema.\n", + "Una de las cosas que podrías aprender es que los asistentes virtuales usan algoritmos que son similares en muchos aspectos -- pero también diferentes en aspectos importantes.\n", + "Pregunta a un VA: \"What are the differences between large language models like GPT and Markov chain text analysis?" ] }, { @@ -1529,12 +1524,12 @@ "id": "060c9ef6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function that counts the number of times each trigram (sequence of three words) appears. \n", - "If you test your function with the text of _Dr. Jekyll and Mr. Hyde_, you should find that the most common trigram is \"said the lawyer\".\n", + "Escribe una función que cuente el número de veces que aparece cada trigram (secuencia de tres palabras). \n", + "Si pruebas tu función con el texto de _Dr. Jekyll and Mr. Hyde_, deberías encontrar que el trigram más común es \"said the lawyer\".\n", "\n", - "Hint: Write a function called `count_trigram` that is similar to `count_bigram`. Then write a function called `process_word_trigram` that is similar to `process_word_bigram`." + "Pista: escribe una función llamada `count_trigram` que sea similar a `count_bigram`. Luego escribe una función llamada `process_word_trigram` que sea similar a `process_word_bigram`." ] }, { @@ -1560,7 +1555,7 @@ "tags": [] }, "source": [ - "You can use the following loop to read the book and process the words." + "Puedes usar el siguiente bucle para leer el libro y procesar las palabras." ] }, { @@ -1580,7 +1575,7 @@ "tags": [] }, "source": [ - "Then use `print_most_common` to find the most common trigrams in the book." + "Luego usa `print_most_common` para encontrar los trigrams más comunes del libro." ] }, { @@ -1598,11 +1593,11 @@ "id": "4bd07bb7", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now let's implement Markov chain text analysis with a mapping from each bigram to a list of possible successors.\n", + "Ahora implementemos análisis de texto con cadenas de Markov usando un mapeo de cada bigrama a una lista de posibles sucesores.\n", "\n", - "Starting with `add_bigram`, write a function called `add_trigram` that takes a list of three words and either adds or updates an item in `successor_map`, using the first two words as the key and the third word as a possible successor." + "Empezando con `add_bigram`, escribe una función llamada `add_trigram` que tome una lista de tres palabras y añada o actualice un elemento en `successor_map`, usando las dos primeras palabras como clave y la tercera palabra como posible sucesor." ] }, { @@ -1618,7 +1613,7 @@ "id": "94d683fe", "metadata": {}, "source": [ - "Here's a version of `process_word_trigram` that calls `add_trigram`." + "Aquí tienes una versión de `process_word_trigram` que llama a `add_trigram`." ] }, { @@ -1636,7 +1631,7 @@ "tags": [] }, "source": [ - "You can use the following loop to test your function with the lyrics of \"Eric, the Half a Bee\"." + "Puedes usar el siguiente bucle para probar tu función con la letra de \"Eric, the Half a Bee\"." ] }, { @@ -1656,8 +1651,8 @@ "tags": [] }, "source": [ - "If your function works as intended, the predecessor `('half', 'a')` should map to a list with the single element `'bee'`.\n", - "In fact, as it happens, each bigram in this song appear only once, so all of the values in `successor_map` have a single element." + "Si tu función funciona como se espera, el predecesor `('half', 'a')` debería asociarse con una lista cuyo único elemento es `'bee'`.\n", + "De hecho, resulta que cada bigrama de esta canción aparece solo una vez, así que todos los valores de `successor_map` tienen un único elemento." ] }, { @@ -1675,7 +1670,7 @@ "id": "886212b5", "metadata": {}, "source": [ - "You can use the following loop to test your function with the words from the book." + "Puedes usar el siguiente bucle para probar tu función con las palabras del libro." ] }, { @@ -1691,7 +1686,7 @@ "id": "3e1d073e", "metadata": {}, "source": [ - "In the next exercise, you'll use the results to generate new random text." + "En el siguiente ejercicio, usarás los resultados para generar nuevo texto aleatorio." ] }, { @@ -1699,9 +1694,9 @@ "id": "04d7a6ee", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "For this exercise, we'll assume that `successor_map` is a dictionary that maps from each bigram to the list of words that follow it." + "Para este ejercicio, asumiremos que `successor_map` es un diccionario que asocia cada bigrama con la lista de palabras que lo siguen." ] }, { @@ -1719,7 +1714,7 @@ "id": "fb0f8f7d", "metadata": {}, "source": [ - "To generate random text, we'll start by choosing a random key from `successor_map`." + "Para generar texto aleatorio, empezaremos eligiendo una clave aleatoria de `successor_map`." ] }, { @@ -1735,15 +1730,15 @@ "id": "83ed6c7e", "metadata": {}, "source": [ - "Now write a loop that generates 50 more words following these steps:\n", + "Ahora escribe un bucle que genere 50 palabras más siguiendo estos pasos:\n", "\n", - "1. In `successor_map`, look up the list of words that can follow `bigram`.\n", + "1. En `successor_map`, busca la lista de palabras que pueden seguir a `bigram`.\n", "\n", - "2. Choose one of them at random and print it.\n", + "2. Elige una de ellas al azar e imprímela.\n", "\n", - "3. For the next iteration, make a new bigram that contains the second word from `bigram` and the chosen successor.\n", + "3. Para la siguiente iteración, crea un nuevo bigrama que contenga la segunda palabra de `bigram` y el sucesor elegido.\n", "\n", - "For example, if we start with the bigram `('doubted', 'if')` and choose `'from'` as its successor, the next bigram is `('if', 'from')`." + "Por ejemplo, si empezamos con el bigrama `('doubted', 'if')` y elegimos `'from'` como sucesor, el siguiente bigrama es `('if', 'from')`." ] }, { @@ -1759,9 +1754,9 @@ "id": "c71d8a89", "metadata": {}, "source": [ - "If everything is working, you should find that the generated text is recognizably similar in style to the original, and some phrases make sense, but the text might wander from one topic to another.\n", + "Si todo funciona, deberías encontrar que el texto generado es reconociblemente similar en estilo al original, y algunas frases tienen sentido, pero el texto podría saltar de un tema a otro.\n", "\n", - "As a bonus exercise, modify your solution to the last two exercises to use trigrams as keys in `successor_map`, and see what effect it has on the results." + "Como ejercicio extra, modifica tu solución a los dos últimos ejercicios para usar trigrams como claves en `successor_map`, y mira qué efecto tiene en los resultados." ] }, { @@ -1783,7 +1778,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/blank/chap13.ipynb b/blank/chap13.ipynb index 69616a9..2c8a646 100644 --- a/blank/chap13.ipynb +++ b/blank/chap13.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -27,8 +27,8 @@ "tags": [] }, "source": [ - "Credit: Photos downloaded from [Lorem Picsum](https://picsum.photos/), a service that provides placeholder images.\n", - "The name is a reference to \"lorem ipsum\", which is a name for placeholder text.\n" + "Crédito: las fotos se descargaron de [Lorem Picsum](https://picsum.photos/), un servicio que proporciona imágenes de marcador de posición.\n", + "El nombre es una referencia a \"lorem ipsum\", que es un nombre para texto de marcador de posición.\n" ] }, { @@ -66,19 +66,19 @@ "id": "92934cb0", "metadata": {}, "source": [ - "# Files and Databases\n", + "# Archivos y bases de datos\n", "\n", - "Most of the programs we have seen so far are **ephemeral** in the sense that they run for a short time and produce output, but when they end, their data disappears.\n", - "Each time you run an ephemeral program, it starts with a clean slate.\n", + "La mayoría de los programas que hemos visto hasta ahora son **efímeros** en el sentido de que se ejecutan durante poco tiempo y producen output, pero cuando terminan, sus datos desaparecen.\n", + "Cada vez que ejecutas un programa efímero, empieza desde cero.\n", "\n", - "Other programs are **persistent**: they run for a long time (or all the time); they keep at least some of their data in long-term storage; and if they shut down and restart, they pick up where they left off.\n", + "Otros programas son **persistentes**: se ejecutan durante mucho tiempo (o todo el tiempo); mantienen al menos parte de sus datos en almacenamiento a largo plazo; y, si se cierran y se reinician, continúan donde lo dejaron.\n", "\n", - "A simple way for programs to maintain their data is by reading and writing text files.\n", - "A more versatile alternative is to store data in a database.\n", - "Databases are specialized files that can be read and written more efficiently than text files, and they provide additional capabilities.\n", + "Una forma sencilla de que los programas mantengan sus datos es leer y escribir archivos de texto.\n", + "Una alternativa más versátil es almacenar datos en una base de datos.\n", + "Las bases de datos son archivos especializados que se pueden leer y escribir de forma más eficiente que los archivos de texto, y proporcionan capacidades adicionales.\n", "\n", - "In this chapter, we'll write programs that read and write text files and databases, and as an exercise you'll write a program that searches a collection of photos for duplicates.\n", - "But before you can work with a file, you have to find it, so we'll start with file names, paths, and directories." + "En este capítulo escribiremos programas que leen y escriben archivos de texto y bases de datos, y como ejercicio escribirás un programa que busca duplicados en una colección de fotos.\n", + "Pero antes de poder trabajar con un archivo, tienes que encontrarlo, así que empezaremos con nombres de archivo, rutas y directorios." ] }, { @@ -86,14 +86,14 @@ "id": "75cec7ca", "metadata": {}, "source": [ - "## Filenames and paths\n", + "## Nombres de archivo y rutas\n", "\n", - "Files are organized into **directories**, also called \"folders\".\n", - "Every running program has a **current working directory**, which is the default directory for most operations.\n", - "For example, when you open a file, Python looks for it in the current working directory.\n", + "Los archivos se organizan en **directorios**, también llamados \"carpetas\".\n", + "Todo programa en ejecución tiene un **directorio de trabajo actual**, que es el directorio por defecto para la mayoría de operaciones.\n", + "Por ejemplo, cuando abres un archivo, Python lo busca en el directorio de trabajo actual.\n", "\n", - "The `os` module provides functions for working with files and directories (\"os\" stands for \"operating system\"). \n", - "It provides a function called `getcwd` that gets the name of the current working directory." + "El módulo `os` proporciona funciones para trabajar con archivos y directorios (\"os\" significa \"operating system\"). \n", + "Proporciona una función llamada `getcwd` que obtiene el nombre del directorio de trabajo actual." ] }, { @@ -119,14 +119,14 @@ "id": "6c55575f", "metadata": {}, "source": [ - "The result in this example is the home directory of a user named `dinsdale`.\n", - "A string like `'/home/dinsdale'` that identifies a file or directory is called a **path**.\n", + "El resultado en este ejemplo es el directorio personal de un usuario llamado `dinsdale`.\n", + "Una string como `'/home/dinsdale'` que identifica un archivo o directorio se llama **ruta**.\n", "\n", - "A simple filename like `'memo.txt'` is also considered a path, but it is a **relative path** because it specifies a file name relative to the current directory.\n", - "In this example, the current directory is `/home/dinsdale`, so `'memo.txt'` is equivalent to the complete path `'/home/dinsdale/memo.txt'`.\n", + "Un nombre de archivo sencillo como `'memo.txt'` también se considera una ruta, pero es un **ruta relativa** porque especifica un nombre de archivo relativo al directorio actual.\n", + "En este ejemplo, el directorio actual es `/home/dinsdale`, así que `'memo.txt'` equivale a la ruta completa `'/home/dinsdale/memo.txt'`.\n", "\n", - "A path that begins with `/` does not depend on the current directory -- it is called an **absolute path**. \n", - "To find the absolute path to a file, you can use `abspath`." + "Un ruta que empieza con `/` no depende del directorio actual -- se llama **ruta absoluta**. \n", + "Para encontrar la ruta absoluta de un archivo, puedes usar `abspath`." ] }, { @@ -142,9 +142,9 @@ "id": "f1a0cf04", "metadata": {}, "source": [ - "The `os` module provides other functions for working with filenames and paths.\n", - "`listdir` returns a list of the contents of the given directory, including files and other directories.\n", - "Here's an example that lists the contents of a directory named `photos`." + "El módulo `os` proporciona otras funciones para trabajar con nombres de archivo y rutas.\n", + "`listdir` devuelve una lista con el contenido del directorio indicado, incluyendo archivos y otros directorios.\n", + "Aquí tienes un ejemplo que lista el contenido de un directorio llamado `photos`." ] }, { @@ -160,8 +160,8 @@ "id": "ab160f29", "metadata": {}, "source": [ - "This directory contains a text file named `notes.txt` and three directories.\n", - "The directories contain image files in the JPEG format." + "Este directorio contiene un archivo de texto llamado `notes.txt` y tres directorios.\n", + "Los directorios contienen archivos de imagen en formato JPEG." ] }, { @@ -177,7 +177,7 @@ "id": "06b27c85", "metadata": {}, "source": [ - "To check whether a file or directory exists, we can use `os.path.exists`." + "Para comprobar si existe un archivo o directorio, podemos usar `os.path.exists`." ] }, { @@ -201,7 +201,7 @@ "id": "d41f235c", "metadata": {}, "source": [ - "To check whether a path refers to a file or directory, we can use `isdir`, which return `True` if a path refers to a directory." + "Para comprobar si una ruta se refiere a un archivo o a un directorio, podemos usar `isdir`, que devuelve `True` si una ruta se refiere a un directorio." ] }, { @@ -217,7 +217,7 @@ "id": "4bd70cc9", "metadata": {}, "source": [ - "And `isfile` which returns `True` if a path refers to a file." + "Y `isfile`, que devuelve `True` si una ruta se refiere a un archivo." ] }, { @@ -233,12 +233,12 @@ "id": "c6933c18", "metadata": {}, "source": [ - "One challenge of working with paths is that they look different on different operating systems.\n", - "On macOS and UNIX systems like Linux, the directory and file names in a path are separated by a forward slash, `/`.\n", - "Windows uses a backward slash, `\\`.\n", - "So, if you you run these examples on Windows, you will see backward slashes in the paths, and you'll have to replace the forward slashes in the examples.\n", + "Un desafío al trabajar con rutas es que se ven distintos en diferentes sistemas operativos.\n", + "En macOS y sistemas UNIX como Linux, los nombres de directorios y archivos en una ruta se separan con una barra inclinada, `/`.\n", + "Windows usa una barra invertida, `\\`.\n", + "Así que, si ejecutas estos ejemplos en Windows, verás barras invertidas en los rutas y tendrás que reemplazar las barras inclinadas de los ejemplos.\n", "\n", - "Or, to write code that works on both systems, you can use `os.path.join`, which joins directory and filenames into a path using a forward or backward slash, depending on which operating system you are using." + "O, para escribir código que funcione en ambos sistemas, puedes usar `os.path.join`, que une nombres de directorio y de archivo en una ruta usando una barra inclinada o invertida, según el sistema operativo que estés usando." ] }, { @@ -254,7 +254,7 @@ "id": "0a665cf9", "metadata": {}, "source": [ - "Later in this chapter we'll use these functions to search a set of directories and find all of the image files." + "Más adelante en este capítulo usaremos estas funciones para buscar en un conjunto de directorios y encontrar todos los archivos de imagen." ] }, { @@ -264,10 +264,10 @@ "source": [ "## f-strings\n", "\n", - "One way for programs to store data is to write it to a text file.\n", - "For example, suppose you are a camel spotter, and you want to record the number of camels you have seen during a period of observation.\n", - "And suppose that in one and a half years, you have spotted `23` camels.\n", - "The data in your camel-spotting book might look like this." + "Una forma en que los programas almacenan datos es escribirlos en un archivo de texto.\n", + "Por ejemplo, supón que observas camellos y quieres registrar el número de camellos que has visto durante un periodo de observación.\n", + "Y supón que en un año y medio has visto `23` camellos.\n", + "Los datos de tu cuaderno de observación de camellos podrían verse así." ] }, { @@ -283,11 +283,11 @@ "id": "f652aaac", "metadata": {}, "source": [ - "To write this data to a file, you can use the `write` method, which we saw in Chapter 8.\n", - "The argument of `write` has to be a string, so if we want to put other values in a file, we have to convert them to strings.\n", - "The easiest way to do that is with the built-in function `str`.\n", + "Para escribir estos datos en un archivo, puedes usar el método `write`, que vimos en el Capítulo 8.\n", + "El argumento de `write` tiene que ser una string, así que si queremos poner otros valores en un archivo, tenemos que convertirlos a strings.\n", + "La forma más sencilla de hacerlo es con la función integrada `str`.\n", "\n", - "Here's what that looks like:" + "Así es como se ve:" ] }, { @@ -303,8 +303,8 @@ "id": "307c22d2", "metadata": {}, "source": [ - "That works, but `write` doesn't add a space or newline unless you include it explicitly.\n", - "If we read back the file, we see that the two numbers are run together." + "Eso funciona, pero `write` no añade un espacio ni una nueva línea a menos que lo incluyas explícitamente.\n", + "Si volvemos a leer el archivo, vemos que los dos números quedan pegados." ] }, { @@ -320,11 +320,11 @@ "id": "8008ecdc", "metadata": {}, "source": [ - "At the very least, we should add whitespace between the numbers.\n", - "And while we're at it, let's add some explanatory text.\n", + "Como mínimo, deberíamos añadir espacios en blanco entre los números.\n", + "Y ya que estamos, añadamos algo de texto explicativo.\n", "\n", - "To write a combination of strings and other values, we can use an **f-string**, which is a string that has the letter `f` before the opening quotation mark, and contains one or more Python expressions in curly braces.\n", - "The following f-string contains one expression, which is a variable name." + "Para escribir una combinación de strings y otros valores, podemos usar una **f-string**, que es una string que tiene la letra `f` antes de la comilla de apertura y contiene una o más expresiones de Python entre llaves.\n", + "La siguiente f-string contiene una expresión, que es el nombre de una variable." ] }, { @@ -340,8 +340,8 @@ "id": "a3fb0556", "metadata": {}, "source": [ - "The result is a string where the expression has been evaluated and replaced with the result.\n", - "There can be more than one expression." + "El resultado es una string donde la expresión se ha evaluado y se ha reemplazado por el resultado.\n", + "Puede haber más de una expresión." ] }, { @@ -357,7 +357,7 @@ "id": "bace1539", "metadata": {}, "source": [ - "And the expressions can contain operators and function calls." + "Y las expresiones pueden contener operadores y llamadas a función." ] }, { @@ -373,7 +373,7 @@ "id": "bc6fa094", "metadata": {}, "source": [ - "So we could write the data to a text file like this." + "Así que podríamos escribir los datos en un archivo de texto así." ] }, { @@ -389,9 +389,9 @@ "id": "f916d561", "metadata": {}, "source": [ - "Both f-strings end with the sequence `\\n`, which adds a newline character.\n", + "Ambas f-strings terminan con la secuencia `\\n`, que añade un carácter de nueva línea.\n", "\n", - "We can read the file back like this:" + "Podemos volver a leer el archivo así:" ] }, { @@ -407,7 +407,7 @@ "id": "c3bf6913", "metadata": {}, "source": [ - "In an f-string, an expression in curly brace is converted to a string, so you can include lists, dictionaries, and other types." + "En una f-string, una expresión entre llaves se convierte en una string, así que puedes incluir listas, diccionarios y otros tipos." ] }, { @@ -425,7 +425,7 @@ "tags": [] }, "source": [ - "If a f-string contains an invalid expression, the result is an error." + "Si una f-string contiene una expresión no válida, el resultado es un error." ] }, { @@ -445,11 +445,11 @@ "source": [ "## YAML\n", "\n", - "One of the reasons programs read and write files is to store **configuration data**, which is information that specifies what the program should do and how.\n", + "Una de las razones por las que los programas leen y escriben archivos es para almacenar **datos de configuración**, que son información que especifica qué debe hacer el programa y cómo.\n", "\n", - "For example, in a program that searches for duplicate photos, we might have a dictionary called `config` that contains the name of the directory to search, the name of another directory where it should store the results, and a list of file extensions it should use to identify image files.\n", + "Por ejemplo, en un programa que busca fotos duplicadas, podríamos tener un diccionario llamado `config` que contiene el nombre del directorio donde buscar, el nombre de otro directorio donde debería almacenar los resultados y una lista de extensiones de archivo que debería usar para identificar archivos de imagen.\n", "\n", - "Here's what it might look like:" + "Así podría verse:" ] }, { @@ -465,11 +465,11 @@ "id": "1667bb96", "metadata": {}, "source": [ - "To write this data in a text file, we could use f-strings, as in the previous section. But it is easier to use a module called `yaml` that is designed for just this sort of thing.\n", + "Para escribir estos datos en un archivo de texto, podríamos usar f-strings, como en la sección anterior. Pero es más fácil usar un módulo llamado `yaml` que está diseñado justo para este tipo de cosas.\n", "\n", - "The `yaml` module provides functions to work with YAML files, which are text files formatted to be easy for humans *and* programs to read and write.\n", + "El módulo `yaml` proporciona funciones para trabajar con archivos YAML, que son archivos de texto con un formato pensado para que sean fáciles de leer y escribir tanto para humanos *como* para programas.\n", "\n", - "Here's an example that uses the `dump` function to write the `config` dictionary to a YAML file. " + "Aquí tienes un ejemplo que usa la función `dump` para escribir el diccionario `config` en un archivo YAML. " ] }, { @@ -495,7 +495,7 @@ "id": "92d1b7ff", "metadata": {}, "source": [ - "If we read back the contents of the file, we can see what the YAML format looks like." + "Si volvemos a leer el contenido del archivo, podemos ver cómo es el formato YAML." ] }, { @@ -511,7 +511,7 @@ "id": "33cdfd2c", "metadata": {}, "source": [ - "Now, we can use `safe_load` to read back the YAML file." + "Ahora podemos usar `safe_load` para volver a leer el archivo YAML." ] }, { @@ -527,7 +527,7 @@ "id": "ca55764f", "metadata": {}, "source": [ - "The result is new dictionary that contains the same information as the original, but it is not the same dictionary." + "El resultado es un nuevo diccionario que contiene la misma información que el original, pero no es el mismo diccionario." ] }, { @@ -543,9 +543,9 @@ "id": "969ad306", "metadata": {}, "source": [ - "Converting an object like a dictionary to a string is called **serialization**.\n", - "Converting the string back to an object is called **deserialization**.\n", - "If you serialize and then deserialize an object, the result should be equivalent to the original." + "Convertir un objeto como un diccionario en una string se llama **serialización**.\n", + "Convertir la string de vuelta en un objeto se llama **deserialización**.\n", + "Si serializas y luego deserializas un objeto, el resultado debería ser equivalente al original." ] }, { @@ -555,14 +555,14 @@ "source": [ "## Shelve\n", "\n", - "So far we've been reading and writing text files -- now let's consider databases.\n", - "A **database** is a file that is organized for storing data.\n", - "Some databases are organized like a table with rows and columns of information.\n", - "Others are organized like a dictionary that maps from keys to values; they are sometimes called **key-value stores**.\n", + "Hasta ahora hemos estado leyendo y escribiendo archivos de texto -- ahora consideremos las bases de datos.\n", + "Una **base de datos** es un archivo organizado para almacenar datos.\n", + "Algunas bases de datos se organizan como una tabla con filas y columnas de información.\n", + "Otras se organizan como un diccionario que mapea claves a valores; a veces se llaman **almacenes clave-valor**.\n", "\n", - "The `shelve` module provides functions for creating and updating a key-value store called a \"shelf\".\n", - "As an example, we'll create a shelf to contain captions for the figures in the `photos` directory.\n", - "We'll use the `config` dictionary to get the name of the directory where we should put the shelf." + "El módulo `shelve` proporciona funciones para crear y actualizar un almacén clave-valor llamado \"shelf\".\n", + "Como ejemplo, crearemos un shelf para contener captions de las figuras del directorio `photos`.\n", + "Usaremos el diccionario `config` para obtener el nombre del directorio donde deberíamos poner el shelf." ] }, { @@ -578,7 +578,7 @@ "id": "3e6cfb65", "metadata": {}, "source": [ - "We can use `os.makedirs` to create this directory, if it doesn't already exist." + "Podemos usar `os.makedirs` para crear este directorio, si todavía no existe." ] }, { @@ -594,7 +594,7 @@ "id": "6352f83f", "metadata": {}, "source": [ - "And `os.path.join` to make a path that includes the name of the directory and the name of the shelf file, `captions`." + "Y `os.path.join` para crear una ruta que incluya el nombre del directorio y el nombre del archivo del shelf, `captions`." ] }, { @@ -610,8 +610,8 @@ "id": "cbb08679", "metadata": {}, "source": [ - "Now we can use `shelve.open` to open the shelf file.\n", - "The argument `c` indicates that the file should be created if necessary." + "Ahora podemos usar `shelve.open` para abrir el archivo del shelf.\n", + "El argumento `c` indica que el archivo debería crearse si es necesario." ] }, { @@ -627,10 +627,10 @@ "id": "0e4a2fb3", "metadata": {}, "source": [ - "The return value is officially a `DbfilenameShelf` object, more casually called a shelf object.\n", + "El valor de retorno es oficialmente un objeto `DbfilenameShelf`, llamado de manera más informal un objeto shelf.\n", "\n", - "The shelf object behaves in many ways like a dictionary.\n", - "For example, we can use the bracket operator to add an item, which is a mapping from a key to a value." + "El objeto shelf se comporta de muchas maneras como un diccionario.\n", + "Por ejemplo, podemos usar el operador de corchetes para añadir un elemento, que es un mapeo de una clave a un valor." ] }, { @@ -646,9 +646,9 @@ "id": "36fd5e3a", "metadata": {}, "source": [ - "In this example, the key is the path to an image file and the value is a string that describes the image.\n", + "En este ejemplo, la clave es la ruta a un archivo de imagen y el valor es una string que describe la imagen.\n", "\n", - "We also use the bracket operator to look up a key and get the corresponding value." + "También usamos el operador de corchetes para buscar una clave y obtener el valor correspondiente." ] }, { @@ -664,7 +664,7 @@ "id": "e9b252a7", "metadata": {}, "source": [ - "If you make another assignment to an existing key, `shelve` replaces the old value." + "Si haces otra asignación a una clave existente, `shelve` reemplaza el valor anterior." ] }, { @@ -680,7 +680,7 @@ "id": "003eacbc", "metadata": {}, "source": [ - "Some dictionary methods, like `keys`, `values` and `items`, also work with shelf objects." + "Algunos métodos de diccionario, como `keys`, `values` e `items`, también funcionan con objetos shelf." ] }, { @@ -704,7 +704,7 @@ "id": "056e0bd9", "metadata": {}, "source": [ - "We can use the `in` operator to check whether a key appears in the shelf." + "Podemos usar el operador `in` para comprobar si una clave aparece en el shelf." ] }, { @@ -720,7 +720,7 @@ "id": "982740b4", "metadata": {}, "source": [ - "And we can use a `for` statement to loop through the keys." + "Y podemos usar una sentencia `for` para iterar sobre las claves." ] }, { @@ -736,7 +736,7 @@ "id": "b67a0ddc", "metadata": {}, "source": [ - "As with other files, you should close the database when you are done." + "Como con otros archivos, deberías cerrar la base de datos cuando termines." ] }, { @@ -752,7 +752,7 @@ "id": "a1e08b41", "metadata": {}, "source": [ - "Now if we list the contents of the data directory, we see two files." + "Ahora, si listamos el contenido del directorio de datos, vemos dos archivos." ] }, { @@ -778,9 +778,9 @@ "id": "97453006", "metadata": {}, "source": [ - "`captions.dat` contains the data we just stored.\n", - "`captions.dir` contains information about the organization of the database that makes it more efficient to access.\n", - "The suffix `dir` stands for \"directory\", but it has nothing to do with the directories we've been working with that contain files." + "`captions.dat` contiene los datos que acabamos de almacenar.\n", + "`captions.dir` contiene información sobre la organización de la base de datos que hace que el acceso sea más eficiente.\n", + "El sufijo `dir` significa \"directorio\", pero no tiene nada que ver con los directorios con los que hemos estado trabajando y que contienen archivos." ] }, { @@ -790,17 +790,17 @@ "tags": [] }, "source": [ - "## Storing data structures\n", + "## Almacenar estructuras de datos\n", "\n", - "In the previous example, the keys and values in the shelf are strings.\n", - "But we can also use a shelf to contain data structures like lists and dictionaries.\n", + "En el ejemplo anterior, las claves y valores del shelf son strings.\n", + "Pero también podemos usar un shelf para contener estructuras de datos como listas y diccionarios.\n", "\n", - "As an example, let's revisit the anagram example from an exercise in [Chapter 11](section_exercise_11).\n", - "Recall that we made a dictionary that maps from a sorted string of letters to the\n", - "list of words that can be spelled with those letters.\n", - "For example, the key `'opst'` maps to the list `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", + "Como ejemplo, volvamos al ejemplo de anagramas de un ejercicio en el [Capítulo 11](section_exercise_11).\n", + "Recuerda que hicimos un diccionario que mapea una string ordenada de letras a la\n", + "lista de palabras que se pueden formar con esas letras.\n", + "Por ejemplo, la clave `'opst'` mapea a la lista `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", "\n", - "We'll use the following function to sort the letters in a word." + "Usaremos la siguiente función para ordenar las letras de una palabra." ] }, { @@ -816,7 +816,7 @@ "id": "8c24316c", "metadata": {}, "source": [ - "And here's an example." + "Y aquí tienes un ejemplo." ] }, { @@ -832,8 +832,8 @@ "id": "7c5d7555", "metadata": {}, "source": [ - "Now let's open a shelf called `anagram_map`.\n", - "The argument `'n'` means we should always create a new, empty shelf, even if one already exists." + "Ahora abramos un shelf llamado `anagram_map`.\n", + "El argumento `'n'` significa que siempre deberíamos crear un shelf nuevo y vacío, aunque ya exista uno." ] }, { @@ -849,7 +849,7 @@ "id": "6b495e79", "metadata": {}, "source": [ - "Now we can add an item to the shelf like this." + "Ahora podemos añadir un elemento al shelf así." ] }, { @@ -865,9 +865,9 @@ "id": "f058dff1", "metadata": {}, "source": [ - "In this item, the key is a string and the value is a list of strings.\n", + "En este elemento, la clave es una string y el valor es una lista de strings.\n", "\n", - "Now suppose we find another word that contains the same letters, like `tops`" + "Ahora supón que encontramos otra palabra que contiene las mismas letras, como `tops`" ] }, { @@ -883,8 +883,8 @@ "id": "a215367d", "metadata": {}, "source": [ - "The key is the same as in the previous example, so we want to append a second word to the same list of strings.\n", - "Here's how we would do it if `db` were a dictionary." + "La clave es la misma que en el ejemplo anterior, así que queremos añadir una segunda palabra a la misma lista de strings.\n", + "Así es como lo haríamos si `db` fuera un diccionario." ] }, { @@ -900,7 +900,7 @@ "id": "e1a83f39", "metadata": {}, "source": [ - "But if we run that and then look up the key in the shelf, it looks like it has not been updated." + "Pero si lo ejecutamos y luego buscamos la clave en el shelf, parece que no se ha actualizado." ] }, { @@ -916,8 +916,8 @@ "id": "32a56de9", "metadata": {}, "source": [ - "Here's the problem: when we look up the key, we get a list of strings, but if we modify the list of strings, it does not affect the shelf.\n", - "If we want to update the shelf, we have to read the old value, update it, and then write the new value back to the shelf." + "Este es el problema: cuando buscamos la clave, obtenemos una lista de strings, pero si modificamos la lista de strings, eso no afecta al shelf.\n", + "Si queremos actualizar el shelf, tenemos que leer el valor antiguo, actualizarlo y luego escribir el nuevo valor de vuelta en el shelf." ] }, { @@ -933,7 +933,7 @@ "id": "a054f537", "metadata": {}, "source": [ - "Now the value in the shelf is updated." + "Ahora el valor del shelf está actualizado." ] }, { @@ -949,7 +949,7 @@ "id": "ca02c0d7", "metadata": {}, "source": [ - "As an exercise, you can finish this example by reading the word list and storing all of the anagrams in a shelf." + "Como ejercicio, puedes terminar este ejemplo leyendo la lista de palabras y almacenando todos los anagramas en un shelf." ] }, { @@ -969,15 +969,15 @@ "tags": [] }, "source": [ - "## Checking for equivalent files\n", + "## Comprobar archivos equivalentes\n", "\n", - "Now let's get back to the goal of this chapter: searching for different files that contain the same data.\n", - "One way to check is to read the contents of both files and compare.\n", + "Ahora volvamos al objetivo de este capítulo: buscar archivos diferentes que contienen los mismos datos.\n", + "Una forma de comprobarlo es leer el contenido de ambos archivos y compararlo.\n", "\n", - "If the files contain images, we have to open them with mode `'rb'`, where `'r'` means we want to read the contents and `'b'` indicates **binary mode**.\n", - "In binary mode, the contents are not interpreted as text -- they are treated as a sequence of bytes.\n", + "Si los archivos contienen imágenes, tenemos que abrirlos con el modo `'rb'`, donde `'r'` significa que queremos leer el contenido y `'b'` indica **modo binario**.\n", + "En modo binario, el contenido no se interpreta como texto -- se trata como una secuencia de bytes.\n", "\n", - "Here's an example that opens and reads an image file." + "Aquí tienes un ejemplo que abre y lee un archivo de imagen." ] }, { @@ -993,10 +993,10 @@ "id": "36687da2", "metadata": {}, "source": [ - "The result from `read` is a `bytes` object -- as the name suggests, it contains a sequence of bytes.\n", + "El resultado de `read` es un objeto `bytes` -- como sugiere el nombre, contiene una secuencia de bytes.\n", "\n", - "In general the contents of an image file and not human-readable.\n", - "But if we read the contents from a second file, we can use the `==` operator to compare." + "En general, el contenido de un archivo de imagen no es legible para humanos.\n", + "Pero si leemos el contenido de un segundo archivo, podemos usar el operador `==` para comparar." ] }, { @@ -1012,9 +1012,9 @@ "id": "36006cd4", "metadata": {}, "source": [ - "These two files are not equivalent.\n", + "Estos dos archivos no son equivalentes.\n", "\n", - "Let's encapsulate what we have so far in a function." + "Encapsulemos lo que tenemos hasta ahora en una función." ] }, { @@ -1030,16 +1030,16 @@ "id": "b4e08850", "metadata": {}, "source": [ - "If we have only two files, this function is a good option.\n", - "But suppose we have a large number of files and we want to know whether any two of them contain the same data.\n", - "It would be inefficient to compare every pair of files.\n", + "Si solo tenemos dos archivos, esta función es una buena opción.\n", + "Pero supón que tenemos un gran número de archivos y queremos saber si dos cualesquiera contienen los mismos datos.\n", + "Sería ineficiente comparar cada par de archivos.\n", "\n", - "An alternative is to use a **hash function**, which takes the contents of a file and computes a **digest**, which is usually a large integer.\n", - "If two files contain the same data, they will have the same digest.\n", - "If two files differ, they will *almost always* have different digests.\n", + "Una alternativa es usar una **función hash**, que toma el contenido de un archivo y calcula un **digest**, que normalmente es un entero grande.\n", + "Si dos archivos contienen los mismos datos, tendrán el mismo digest.\n", + "Si dos archivos son diferentes, *casi siempre* tendrán digests diferentes.\n", "\n", - "The `hashlib` module provides several hash functions -- the one we'll use is called `md5`.\n", - "We'll start by using `hashlib.md5` to create a `HASH` object." + "El módulo `hashlib` proporciona varias hash funciones -- la que usaremos se llama `md5`.\n", + "Empezaremos usando `hashlib.md5` para crear un objeto `HASH`." ] }, { @@ -1055,7 +1055,7 @@ "id": "a8e480f0", "metadata": {}, "source": [ - "The `HASH` object provides an `update` method that takes the contents of the file as an argument." + "El objeto `HASH` proporciona un método `update` que toma el contenido del archivo como argumento." ] }, { @@ -1071,7 +1071,7 @@ "id": "86bd6bc0", "metadata": {}, "source": [ - "Now we can use `hexdigest` to get the digest as a string of hexadecimal digits that represent an integer in base 16." + "Ahora podemos usar `hexdigest` para obtener el digest como una string de dígitos hexadecimales que representan un entero en base 16." ] }, { @@ -1087,7 +1087,7 @@ "id": "b9b4b347", "metadata": {}, "source": [ - "The following function encapsulates these steps." + "La siguiente función encapsula estos pasos." ] }, { @@ -1103,7 +1103,7 @@ "id": "914b85b2", "metadata": {}, "source": [ - "If we hash the contents of a different file, we can confirm that we get a different digest." + "Si hacemos hash del contenido de un archivo diferente, podemos confirmar que obtenemos un digest distinto." ] }, { @@ -1119,8 +1119,8 @@ "id": "deeabdde", "metadata": {}, "source": [ - "Now we have almost everything we need to find equivalent files.\n", - "The last step is to search a directory and find all of the images files." + "Ahora tenemos casi todo lo que necesitamos para encontrar archivos equivalentes.\n", + "El último paso es buscar en un directorio y encontrar todos los archivos de imagen." ] }, { @@ -1130,12 +1130,12 @@ "tags": [] }, "source": [ - "## Walking directories\n", + "## Recorrer directorios\n", "\n", - "The following function takes as an argument the directory we want to search.\n", - "It uses `listdir` to loop through the contents of the directory.\n", - "When it finds a file, it prints its complete path.\n", - "When it finds a directory, it calls itself recursively to search the subdirectory." + "La siguiente función toma como argumento el directorio donde queremos buscar.\n", + "Usa `listdir` para iterar sobre el contenido del directorio.\n", + "Cuando encuentra un archivo, imprime su ruta completa.\n", + "Cuando encuentra un directorio, se llama a sí misma recursivamente para buscar en el subdirectorio." ] }, { @@ -1151,7 +1151,7 @@ "id": "faaf5b25", "metadata": {}, "source": [ - "We can use it like this:" + "Podemos usarla así:" ] }, { @@ -1167,7 +1167,7 @@ "id": "897c66bf", "metadata": {}, "source": [ - "The order of the results depends on details of the operating system." + "El orden de los resultados depende de detalles del sistema operativo." ] }, { @@ -1175,12 +1175,12 @@ "id": "c7853f18", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "When you are reading and writing files, you might run into problems with whitespace.\n", - "These errors can be hard to debug because whitespace characters are normally invisible.\n", - "For example, here's a string that contains spaces, a tab represented by the sequence `\\t`, and a newline represented by the sequence `\\n`.\n", - "When we print it, we don't see the whitespace characters." + "Cuando lees y escribes archivos, puedes encontrarte con problemas relacionados con espacios en blanco.\n", + "Estos errores pueden ser difíciles de depurar porque los caracteres de espacio en blanco normalmente son invisibles.\n", + "Por ejemplo, aquí tienes una string que contiene espacios, un tab representado por la secuencia `\\t` y una nueva línea representada por la secuencia `\\n`.\n", + "Cuando la imprimimos, no vemos los caracteres de espacio en blanco." ] }, { @@ -1196,8 +1196,8 @@ "id": "49bbebe6", "metadata": {}, "source": [ - "The built-in function `repr` can help. It takes any object as an argument and returns a string representation of the object.\n", - "For strings, it represents whitespace characters with backslash sequences." + "La función integrada `repr` puede ayudar. Toma cualquier objeto como argumento y devuelve una representación en string del objeto.\n", + "Para strings, representa los caracteres de espacio en blanco con secuencias de barra invertida." ] }, { @@ -1213,15 +1213,15 @@ "id": "790cf8dd", "metadata": {}, "source": [ - "This can be helpful for debugging.\n", + "Esto puede ser útil para depurar.\n", "\n", - "One other problem you might run into is that different systems use different characters to indicate the end of a line. Some systems use a newline, represented `\\n`. Others use a return character, represented `\\r`. \n", - "Some use both. If you move files between different systems, these\n", - "inconsistencies can cause problems.\n", + "Otro problema que puedes encontrar es que distintos sistemas usan distintos caracteres para indicar el final de una línea. Algunos sistemas usan una nueva línea, representada como `\\n`. Otros usan un carácter de retorno, representado como `\\r`. \n", + "Algunos usan ambos. Si mueves archivos entre sistemas diferentes, estas\n", + "inconsistencias pueden causar problemas.\n", "\n", - "File name capitalization is another issue you might encounter if you work with different operating systems.\n", - "In macOS and UNIX, file names can contain lowercase and uppercase letters, digits, and most symbols.\n", - "But many Windows applications ignore the difference between lowercase and uppercase letters, and several symbols that are allowed in macOS and UNIX are not allowed in Windows." + "La capitalización de los nombres de archivo es otro problema que puedes encontrar si trabajas con distintos sistemas operativos.\n", + "En macOS y UNIX, los nombres de archivo pueden contener letras minúsculas y mayúsculas, dígitos y la mayoría de símbolos.\n", + "Pero muchas aplicaciones de Windows ignoran la diferencia entre letras minúsculas y mayúsculas, y varios símbolos que se permiten en macOS y UNIX no se permiten en Windows." ] }, { @@ -1229,55 +1229,55 @@ "id": "cf063639", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**ephemeral:**\n", - "An ephemeral program typically runs for a short time and, when it ends, its data are lost.\n", + "**efímero:**\n", + "Un programa efímero normalmente se ejecuta durante poco tiempo y, cuando termina, sus datos se pierden.\n", "\n", - "**persistent:**\n", - " A persistent program runs indefinitely and keeps at least some of its data in permanent storage.\n", + "**persistente:**\n", + " Un programa persistente se ejecuta indefinidamente y mantiene al menos parte de sus datos en almacenamiento permanente.\n", "\n", - "**directory:**\n", - "A collection of files and other directories.\n", + "**directorio:**\n", + "Una colección de archivos y otros directorios.\n", "\n", - "**current working directory:**\n", - "The default directory used by a program unless another directory is specified.\n", + "**directorio de trabajo actual:**\n", + "El directorio por defecto usado por un programa a menos que se especifique otro directorio.\n", "\n", - "**path:**\n", - " A string that specifies a sequence of directories, often leading to a file.\n", + "**ruta:**\n", + " Una string que especifica una secuencia de directorios, que a menudo conduce a un archivo.\n", "\n", - "**relative path:**\n", - "A path that starts from the current working directory, or some other specified directory.\n", + "**ruta relativa:**\n", + "Un ruta que empieza desde el directorio de trabajo actual, o desde algún otro directorio especificado.\n", "\n", - "**absolute path:**\n", - "A path that does not depend on the current directory.\n", + "**ruta absoluta:**\n", + "Un ruta que no depende del directorio actual.\n", "\n", "**f-string:**\n", - "A string that has the letter `f` before the opening quotation mark, and contains one or more expressions in curly braces.\n", + "Una string que tiene la letra `f` antes de la comilla de apertura y contiene una o más expresiones entre llaves.\n", "\n", - "**configuration data:**\n", - "Data, often stored in a file, that specifies what a program should do and how.\n", + "**datos de configuración:**\n", + "Datos, a menudo almacenados en un archivo, que especifican qué debe hacer un programa y cómo.\n", "\n", - "**serialization:**\n", - "Converting an object to a string.\n", + "**serialización:**\n", + "Convertir un objeto en una string.\n", "\n", - "**deserialization:**\n", - "Converting a string to an object.\n", + "**deserialización:**\n", + "Convertir una string en un objeto.\n", "\n", - "**database:**\n", - " A file whose contents are organized to perform certain operations efficiently.\n", + "**base de datos:**\n", + " Un archivo cuyo contenido está organizado para realizar ciertas operaciones de manera eficiente.\n", "\n", - "**key-value stores:**\n", - "A database whose contents are organized like a dictionary with keys that correspond to values.\n", + "**almacenes clave-valor:**\n", + "Una base de datos cuyo contenido está organizado como un diccionario con claves que corresponden a valores.\n", "\n", - "**binary mode:**\n", - "A way of opening a file so the contents are interpreted as sequence of bytes rather than a sequence of characters.\n", + "**modo binario:**\n", + "Una forma de abrir un archivo para que el contenido se interprete como una secuencia de bytes en lugar de como una secuencia de caracteres.\n", "\n", - "**hash function:**\n", - "A function that takes and object and computes an integer, which is sometimes called a digest.\n", + "**función hash:**\n", + "Una función que toma un objeto y calcula un entero, que a veces se llama digest.\n", "\n", "**digest:**\n", - "The result of a hash function, especially when it is used to check whether two objects are the same." + "El resultado de una función hash, especialmente cuando se usa para comprobar si dos objetos son iguales." ] }, { @@ -1285,7 +1285,7 @@ "id": "67941fdd", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1303,32 +1303,32 @@ "id": "9a537173", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are several topics that came up in this chapter that I did not explain in detail.\n", - "Here are some questions you can ask a virtual assistant to get more information. \n", + "Hay varios temas que surgieron en este capítulo que no expliqué en detalle.\n", + "Aquí tienes algunas preguntas que puedes hacerle a un asistente virtual para obtener más información. \n", "\n", - "* \"What are the differences between ephemeral and persistent programs?\"\n", + "* \"¿Cuáles son las diferencias entre programas efímeros y persistentes?\"\n", "\n", - "* \"What are some examples of persistent programs?\"\n", + "* \"¿Cuáles son algunos ejemplos de programas persistentes?\"\n", "\n", - "* \"What's the difference between a relative path and an absolute path?\"\n", + "* \"¿Cuál es la diferencia entre una ruta relativa y una ruta absoluta?\"\n", "\n", - "* \"Why does the `yaml` module have functions called `load` and `safe_load`?\"\n", + "* \"¿Por qué el módulo `yaml` tiene funciones llamadas `load` y `safe_load`?\"\n", "\n", - "* \"When I write a Python shelf, what are the files with suffixes `dat` and `dir`?\"\n", + "* \"Cuando escribo un shelf de Python, ¿qué son los archivos con sufijos `dat` y `dir`?\"\n", "\n", - "* \"Other than key-values stores, what other kinds of databases are there?\"\n", + "* \"Además de los almacenes clave-valor, ¿qué otros tipos de bases de datos existen?\"\n", "\n", - "* \"When I read a file, what's the difference between binary mode and text mode?\"\n", + "* \"Cuando leo un archivo, ¿cuál es la diferencia entre modo binario y modo texto?\"\n", "\n", - "* \"What are the differences between a bytes object and a string?\"\n", + "* \"¿Cuáles son las diferencias entre un objeto bytes y una string?\"\n", "\n", - "* \"What is a hash function?\"\n", + "* \"¿Qué es una función hash?\"\n", "\n", - "* \"What is an MD5 digest?\"\n", + "* \"¿Qué es un digest MD5?\"\n", "\n", - "As always, if you get stuck on any of the following exercises, consider asking a VA for help. Along with your question, you might want to paste in the relevant functions from this chapter." + "Como siempre, si te quedas atascado en alguno de los ejercicios siguientes, considera pedir ayuda a un AV. Junto con tu pregunta, quizá quieras pegar las funciones relevantes de este capítulo." ] }, { @@ -1336,11 +1336,11 @@ "id": "7586e1e9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `replace_all` that takes as arguments a pattern string, a replacement string, and two filenames.\n", - "It should read the first file and write the contents into the second file (creating it if necessary).\n", - "If the pattern string appears anywhere in the contents, it should be replaced with the replacement string." + "Escribe una función llamada `replace_all` que tome como argumentos una string patrón, una string de reemplazo y dos nombres de archivo.\n", + "Debería leer el primer archivo y escribir el contenido en el segundo archivo (creándolo si es necesario).\n", + "Si la string patrón aparece en cualquier parte del contenido, debería reemplazarse por la string de reemplazo." ] }, { @@ -1350,7 +1350,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1374,7 +1374,7 @@ "id": "7f37245c", "metadata": {}, "source": [ - "To test your function, read the file `photos/notes.txt`, replace `'photos'` with `'images'`, and write the result to the file `photos/new_notes.txt`." + "Para probar tu función, lee el archivo `photos/notes.txt`, reemplaza `'photos'` por `'images'` y escribe el resultado en el archivo `photos/new_notes.txt`." ] }, { @@ -1412,12 +1412,12 @@ "id": "7b2589a4", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In [a previous section](section_storing_data_structure), we used the `shelve` module to make a key-value store that maps from a sorted string of letters to a list of anagrams.\n", - "To finish the example, write a function called `add_word` that takes as arguments a string and a shelf object.\n", + "En [una sección anterior](section_storing_data_structure), usamos el módulo `shelve` para crear un almacén clave-valor que mapea una string ordenada de letras a una lista de anagramas.\n", + "Para terminar el ejemplo, escribe una función llamada `add_word` que tome como argumentos una string y un objeto shelf.\n", "\n", - "It should sort the letters of the word to make a key, then check whether the key is already in the shelf. If not, it should make a list that contains the new word and add it to the shelf. If so, it should append the new word to the existing value. " + "Debería ordenar las letras de la palabra para crear una clave, y luego comprobar si la clave ya está en el shelf. Si no, debería crear una lista que contenga la nueva palabra y añadirla al shelf. Si sí, debería añadir la nueva palabra al valor existente. " ] }, { @@ -1435,7 +1435,7 @@ "tags": [] }, "source": [ - "You can use this loop to test your function." + "Puedes usar este bucle para probar tu función." ] }, { @@ -1465,7 +1465,7 @@ "tags": [] }, "source": [ - "If everything is working, you should be able to look up a key like `'opst'` and get a list of words that can be spelled with those letters." + "Si todo funciona, deberías poder buscar una clave como `'opst'` y obtener una lista de palabras que se pueden formar con esas letras." ] }, { @@ -1503,23 +1503,23 @@ "id": "228e977c", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In a large collection of files, there may be more than one copy of the same file, stored in different directories or with different file names.\n", - "The goal of this exercise is to search for duplicates.\n", - "As an example, we'll work with image files in the `photos` directory.\n", + "En una colección grande de archivos, puede haber más de una copia del mismo archivo, almacenada en distintos directorios o con distintos nombres de archivo.\n", + "El objetivo de este ejercicio es buscar duplicados.\n", + "Como ejemplo, trabajaremos con archivos de imagen en el directorio `photos`.\n", "\n", - "Here's how it will work:\n", + "Así es como funcionará:\n", "\n", - "* We'll use the `walk` function from [](section_walking_directories) to search this directory for files that end with one of the extensions in `config['extensions']`.\n", + "* Usaremos la función `walk` de [](section_walking_directories) para buscar en este directorio archivos que terminen con una de las extensiones en `config['extensions']`.\n", "\n", - "* For each file, we'll use `md5_digest` from [](section_md5_digest) to compute a digest of the contents.\n", + "* Para cada archivo, usaremos `md5_digest` de [](section_md5_digest) para calcular un digest del contenido.\n", "\n", - "* Using a shelf, we'll make a mapping from each digest to a list of paths with that digest.\n", + "* Usando un shelf, haremos un mapeo de cada digest a una lista de rutas con ese digest.\n", "\n", - "* Finally, we'll search the shelf for any digests that map to multiple files.\n", + "* Finalmente, buscaremos en el shelf cualquier digest que mapee a múltiples archivos.\n", "\n", - "* If we find any, we'll use `same_contents` to confirm that the files contain the same data." + "* Si encontramos alguno, usaremos `same_contents` para confirmar que los archivos contienen los mismos datos." ] }, { @@ -1527,9 +1527,9 @@ "id": "8f5365da", "metadata": {}, "source": [ - "I'll suggest some functions to write first, then we'll bring it all together.\n", + "Voy a sugerir algunas funciones para escribir primero, y luego lo juntaremos todo.\n", "\n", - "1. To identify image files, write a function called `is_image` that takes a path and a list of file extensions, and returns `True` if the path ends with one of the extensions in the list. Hint: Use `os.path.splitext` -- or ask a virtual assistant to write this function for you." + "1. Para identificar archivos de imagen, escribe una función llamada `is_image` que tome una ruta y una lista de extensiones de archivo, y devuelva `True` si la ruta termina con una de las extensiones de la lista. Pista: usa `os.path.splitext` -- o pide a un asistente virtual que escriba esta función por ti." ] }, { @@ -1547,7 +1547,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1565,7 +1565,7 @@ "id": "1a7c8f49", "metadata": {}, "source": [ - "2. Write a function called `add_path` that takes as arguments a path and a shelf. It should use `md5_digest` to compute a digest of the file contents. Then it should update the shelf, either creating a new item that maps from the digest to a list containing the path, or appending the path to the list if it exists." + "2. Escribe una función llamada `add_path` que tome como argumentos una ruta y un shelf. Debería usar `md5_digest` para calcular un digest del contenido del archivo. Luego debería actualizar el shelf, ya sea creando un nuevo elemento que mapee el digest a una lista que contenga la ruta, o añadiendo la ruta a la lista si ya existe." ] }, { @@ -1581,7 +1581,7 @@ "id": "08223a21", "metadata": {}, "source": [ - "3. Write a version of `walk` called `walk_images` that takes a directory and walks through the files in the directory and its subdirectories. For each file, it should use `is_image` to check whether it's an image file and `add_path` to add it to the shelf." + "3. Escribe una versión de `walk` llamada `walk_images` que tome un directorio y recorra los archivos del directorio y sus subdirectorios. Para cada archivo, debería usar `is_image` para comprobar si es un archivo de imagen y `add_path` para añadirlo al shelf." ] }, { @@ -1597,7 +1597,7 @@ "id": "1ea76a52", "metadata": {}, "source": [ - "When everything is working, you can use the following program to create the shelf, search the `photos` directory and add paths to the shelf, and then check whether there are multiple files with the same digest." + "Cuando todo funcione, puedes usar el siguiente programa para crear el shelf, buscar en el directorio `photos` y añadir rutas al shelf, y luego comprobar si hay múltiples archivos con el mismo digest." ] }, { @@ -1615,8 +1615,8 @@ "id": "102d4d10", "metadata": {}, "source": [ - "You should find one pair of files that have the same digest.\n", - "Use `same_contents` to check whether they contain the same data." + "Deberías encontrar un par de archivos que tienen el mismo digest.\n", + "Usa `same_contents` para comprobar si contienen los mismos datos." ] }, { @@ -1646,9 +1646,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/blank/chap14.ipynb b/blank/chap14.ipynb index 38aaffc..ad2d4cd 100644 --- a/blank/chap14.ipynb +++ b/blank/chap14.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,14 +25,14 @@ "id": "e826e661", "metadata": {}, "source": [ - "# Classes and Functions\n", + "# Clases y funciones\n", "\n", - "At this point you know how to use functions to organize code and how to use built-in types to organize data.\n", - "The next step is **object-oriented programming**, which uses programmer-defined types to organize both code and data.\n", + "A estas alturas sabes cómo usar funciones para organizar código y cómo usar tipos integrados para organizar datos.\n", + "El siguiente paso es la **programación orientada a objetos**, que usa tipos definidos por el programador para organizar tanto código como datos.\n", "\n", - "Object-oriented programming is a big topic, so we will proceed gradually.\n", - "In this chapter, we'll start with code that is not idiomatic -- that is, it is not the kind of code experienced programmers write -- but it is a good place to start.\n", - "In the next two chapters, we will use additional features to write more idiomatic code." + "La programación orientada a objetos es un tema amplio, así que avanzaremos gradualmente.\n", + "En este capítulo, empezaremos con código que no es idiomático -- es decir, no es el tipo de código que escriben los programadores con experiencia -- pero es un buen punto de partida.\n", + "En los dos capítulos siguientes, usaremos características adicionales para escribir código más idiomático." ] }, { @@ -40,12 +40,12 @@ "id": "6b414d4a", "metadata": {}, "source": [ - "## Programmer-defined types\n", + "## Tipos definidos por el programador\n", "\n", - "We have used many of Python's built-in types -- now we will define a new type.\n", - "As a first example, we'll create a type called `Time` that represents a time of day.\n", - "A programmer-defined type is also called a **class**.\n", - "A class definition looks like this:" + "Hemos usado muchos de los tipos integrados de Python -- ahora definiremos un tipo nuevo.\n", + "Como primer ejemplo, crearemos un tipo llamado `Time` que representa una hora del día.\n", + "Un tipo definido por el programador también se llama **clase**.\n", + "Una definición de clase se ve así:" ] }, { @@ -61,12 +61,12 @@ "id": "e2414cd2", "metadata": {}, "source": [ - "The header indicates that the new class is called `Time`.\n", - "The body is a docstring that explains what the class is for.\n", - "Defining a class creates a **class object**.\n", + "La cabecera indica que la nueva clase se llama `Time`.\n", + "El cuerpo es un docstring que explica para qué sirve la clase.\n", + "Definir una clase crea un **objeto de clase**.\n", "\n", - "The class object is like a factory for creating objects.\n", - "To create a `Time` object, you call `Time` as if it were a function." + "El objeto de clase es como una fábrica para crear objetos.\n", + "Para crear un objeto `Time`, llamas a `Time` como si fuera una función." ] }, { @@ -82,7 +82,7 @@ "id": "f63247d4", "metadata": {}, "source": [ - "The result is a new object whose type is `__main__.Time`, where `__main__` is the name of the module where `Time` is defined." + "El resultado es un objeto nuevo cuyo tipo es `__main__.Time`, donde `__main__` es el nombre del módulo donde se define `Time`." ] }, { @@ -98,7 +98,7 @@ "id": "14d0c96a", "metadata": {}, "source": [ - "When you print an object, Python tells you what type it is and where it is stored in memory (the prefix `0x` means that the following number is in hexadecimal)." + "Cuando imprimes un objeto, Python te dice de qué tipo es y dónde está almacenado en memoria (el prefijo `0x` significa que el número siguiente está en hexadecimal)." ] }, { @@ -114,7 +114,7 @@ "id": "b6445414", "metadata": {}, "source": [ - "Creating a new object is called **instantiation**, and the object is an **instance** of the class." + "Crear un objeto nuevo se llama **instanciación**, y el objeto es una **instancia** de la clase." ] }, { @@ -122,10 +122,10 @@ "id": "4c3768ec", "metadata": {}, "source": [ - "## Attributes\n", + "## Atributos\n", "\n", - "An object can contain variables, which are called **attributes** and pronounced with the emphasis on the first syllable, like \"AT-trib-ute\", rather than the second syllable, like \"a-TRIB-ute\".\n", - "We can create attributes using dot notation." + "Un objeto puede contener variables, que se llaman **atributos**.\n", + "Podemos crear atributos usando notación de punto." ] }, { @@ -141,9 +141,9 @@ "id": "b3fd8858", "metadata": {}, "source": [ - "This example creates attributes called `hour`, `minute`, and `second`, which contain the hours, minutes, and seconds of the time `11:59:01`, which is lunch time as far as I am concerned.\n", + "Este ejemplo crea atributos llamados `hour`, `minute` y `second`, que contienen las horas, minutos y segundos de la hora `11:59:01`, que es la hora de comer por lo que a mí respecta.\n", "\n", - "The following diagram shows the state of `lunch` and its attributes after these assignments. " + "El siguiente diagrama muestra el estado de `lunch` y sus atributos después de estas asignaciones. " ] }, { @@ -171,11 +171,11 @@ "id": "d9df5b48", "metadata": {}, "source": [ - "The variable `lunch` refers to a `Time` object, which contains three attributes. \n", - "Each attribute refers to an integer.\n", - "A state diagram like this -- which shows an object and its attributes -- is called an **object diagram**.\n", + "La variable `lunch` se refiere a un objeto `Time`, que contiene tres atributos. \n", + "Cada atributo se refiere a un entero.\n", + "Un diagrama de estado como este -- que muestra un objeto y sus atributos -- se llama **diagrama de objeto**.\n", "\n", - "You can read the value of an attribute using the dot operator." + "Puedes leer el valor de un atributo usando el operador de punto." ] }, { @@ -191,7 +191,7 @@ "id": "5ccfaea0", "metadata": {}, "source": [ - "You can use an attribute as part of any expression." + "Puedes usar un atributo como parte de cualquier expresión." ] }, { @@ -207,7 +207,7 @@ "id": "c5e6725b", "metadata": {}, "source": [ - "And you can use the dot operator in an expression in an f-string." + "Y puedes usar el operador de punto en una expresión dentro de una f-string." ] }, { @@ -223,10 +223,10 @@ "id": "e70671d2", "metadata": {}, "source": [ - "But notice that the previous example is not in the standard format.\n", - "To fix it, we have to print the `minute` and `second` attributes with a leading zero.\n", - "We can do that by extending the expressions in curly braces with a **format specifier**.\n", - "In the following example, the format specifiers indicate that `minute` and `second` should be displayed with at least two digits and a leading zero if needed." + "Pero observa que el ejemplo anterior no está en el formato estándar.\n", + "Para arreglarlo, tenemos que imprimir los atributos `minute` y `second` con un cero inicial.\n", + "Podemos hacerlo extendiendo las expresiones entre llaves con un **especificador de formato**.\n", + "En el siguiente ejemplo, los especificadores de formato indican que `minute` y `second` deberían mostrarse con al menos dos dígitos y un cero inicial si hace falta." ] }, { @@ -242,9 +242,9 @@ "id": "bcbea13a", "metadata": {}, "source": [ - "We'll use this f-string to write a function that displays the value of a `Time`object.\n", - "You can pass an object as an argument in the usual way.\n", - "For example, the following function takes a `Time` object as an argument. " + "Usaremos esta f-string para escribir una función que muestra el valor de un objeto `Time`.\n", + "Puedes pasar un objeto como argumento de la forma habitual.\n", + "Por ejemplo, la siguiente función toma un objeto `Time` como argumento. " ] }, { @@ -260,7 +260,7 @@ "id": "3b8ccbed", "metadata": {}, "source": [ - "When we call it, we can pass `lunch` as an argument." + "Cuando la llamamos, podemos pasar `lunch` como argumento." ] }, { @@ -276,9 +276,9 @@ "id": "18826e53", "metadata": {}, "source": [ - "## Objects as return values\n", + "## Objetos como valores de retorno\n", "\n", - "Functions can return objects. For example, `make_time` takes parameters called `hour`, `minute`, and `second`, stores them as attributes in a `Time` object, and returns the new object." + "Las funciones pueden devolver objetos. Por ejemplo, `make_time` toma parámetros llamados `hour`, `minute` y `second`, los almacena como atributos en un objeto `Time` y devuelve el objeto nuevo." ] }, { @@ -294,8 +294,8 @@ "id": "d8a6acca", "metadata": {}, "source": [ - "It might be surprising that the parameters have the same names as the attributes, but that's a common way to write a function like this.\n", - "Here's how we use `make_time` to create a `Time` object.`" + "Puede sorprender que los parámetros tengan los mismos nombres que los atributos, pero esa es una forma habitual de escribir una función como esta.\n", + "Así usamos `make_time` para crear un objeto `Time`." ] }, { @@ -311,12 +311,12 @@ "id": "05720bcb", "metadata": {}, "source": [ - "## Objects are mutable\n", + "## Los objetos son mutables\n", "\n", - "Suppose you are going to a screening of a movie, like *Monty Python and the Holy Grail*, which starts at `9:20 PM` and runs for `92` minutes, which is one hour `32` minutes.\n", - "What time will the movie end?\n", + "Supón que vas a una proyección de una película, como *Monty Python and the Holy Grail*, que empieza a las `9:20 PM` y dura `92` minutos, que es una hora y `32` minutos.\n", + "¿A qué hora terminará la película?\n", "\n", - "First, we'll create a `Time` object that represents the start time." + "Primero, crearemos un objeto `Time` que representa la hora de inicio." ] }, { @@ -332,7 +332,7 @@ "id": "001bcda9", "metadata": {}, "source": [ - "To find the end time, we can modify the attributes of the `Time` object, adding the duration of the movie." + "Para encontrar la hora de fin, podemos modificar los atributos del objeto `Time`, añadiendo la duración de la película." ] }, { @@ -348,9 +348,9 @@ "id": "7007ab61", "metadata": {}, "source": [ - "The movie will be over at 10:52 PM.\n", + "La película terminará a las 10:52 PM.\n", "\n", - "Let's encapsulate this computation in a function and generalize it to take the duration of the movie in three parameters: `hours`, `minutes`, and `seconds`." + "Encapsulemos este cálculo en una función y generalicémoslo para que tome la duración de la película en tres parámetros: `hours`, `minutes` y `seconds`." ] }, { @@ -366,7 +366,7 @@ "id": "a51913e2", "metadata": {}, "source": [ - "Here is an example that demonstrates the effect." + "Aquí tienes un ejemplo que demuestra el efecto." ] }, { @@ -382,7 +382,7 @@ "id": "42d7de02", "metadata": {}, "source": [ - "The following stack diagram shows the state of the program just before `increment_time` modifies the object." + "El siguiente stack diagram muestra el estado del programa justo antes de que `increment_time` modifique el objeto." ] }, { @@ -410,11 +410,11 @@ "id": "d1e27667", "metadata": {}, "source": [ - "Inside the function, `time` is an alias for `start`, so when `time` is modified, `start` changes.\n", + "Dentro de la función, `time` es un alias de `start`, así que cuando se modifica `time`, cambia `start`.\n", "\n", - "This function works, but after it runs, we're left with a variable named `start` that refers to an object that represents the *end* time, and we no longer have an object that represents the start time.\n", - "It would be better to leave `start` unchanged and make a new object to represent the end time.\n", - "We can do that by copying `start` and modifying the copy." + "Esta función funciona, pero después de ejecutarse nos quedamos con una variable llamada `start` que se refiere a un objeto que representa la hora de *fin*, y ya no tenemos un objeto que represente la hora de inicio.\n", + "Sería mejor dejar `start` sin cambios y crear un objeto nuevo para representar la hora de fin.\n", + "Podemos hacerlo copiando `start` y modificando la copia." ] }, { @@ -422,10 +422,10 @@ "id": "0128f850", "metadata": {}, "source": [ - "## Copying\n", + "## Copiar\n", "\n", - "The `copy` module provides a function called `copy` that can duplicate any object.\n", - "We can import it like this." + "El módulo `copy` proporciona una función llamada `copy` que puede duplicar cualquier objeto.\n", + "Podemos importarla así." ] }, { @@ -441,7 +441,7 @@ "id": "940adbeb", "metadata": {}, "source": [ - "To see how it works, let's start with a new `Time` object that represents the start time of the movie." + "Para ver cómo funciona, empecemos con un objeto `Time` nuevo que representa la hora de inicio de la película." ] }, { @@ -457,7 +457,7 @@ "id": "514f05b9", "metadata": {}, "source": [ - "And make a copy." + "Y hagamos una copia." ] }, { @@ -473,7 +473,7 @@ "id": "87d8956b", "metadata": {}, "source": [ - "Now `start` and `end` contain the same data." + "Ahora `start` y `end` contienen los mismos datos." ] }, { @@ -489,7 +489,7 @@ "id": "e75c1e09", "metadata": {}, "source": [ - "But the `is` operator confirms that they are not the same object." + "Pero el operador `is` confirma que no son el mismo objeto." ] }, { @@ -505,7 +505,7 @@ "id": "22b68a3f", "metadata": {}, "source": [ - "Let's see what the `==` operator does." + "Veamos qué hace el operador `==`." ] }, { @@ -521,8 +521,8 @@ "id": "78ebf931", "metadata": {}, "source": [ - "You might expect `==` to yield `True` because the objects contain the same data.\n", - "But for programmer-defined classes, the default behavior of the `==` operator is the same as the `is` operator -- it checks identity, not equivalence." + "Podrías esperar que `==` produzca `True` porque los objetos contienen los mismos datos.\n", + "Pero para clases definidas por el programador, el comportamiento por defecto del operador `==` es el mismo que el del operador `is` -- comprueba identidad, no equivalencia." ] }, { @@ -530,11 +530,11 @@ "id": "a3934fdd-d4cd-41e0-86e6-5bb78d0886a7", "metadata": {}, "source": [ - "## Pure functions\n", + "## Funciones puras\n", "\n", - "We can use `copy` to write pure functions that don't modify their parameters.\n", - "For example, here's a function that takes a `Time` object and a duration in hours, minutes and seconds.\n", - "It makes a copy of the original object, uses `increment_time` to modify the copy, and returns it." + "Podemos usar `copy` para escribir funciones puras que no modifican sus parámetros.\n", + "Por ejemplo, aquí tienes una función que toma un objeto `Time` y una duración en horas, minutos y segundos.\n", + "Hace una copia del objeto original, usa `increment_time` para modificar la copia y la devuelve." ] }, { @@ -550,7 +550,7 @@ "id": "c181af12", "metadata": {}, "source": [ - "Here's how we use it." + "Así la usamos." ] }, { @@ -566,8 +566,8 @@ "id": "54b1ca4a", "metadata": {}, "source": [ - "The return value is a new object representing the end time of the movie.\n", - "And we can confirm that `start` is unchanged." + "El valor de retorno es un objeto nuevo que representa la hora de fin de la película.\n", + "Y podemos confirmar que `start` no ha cambiado." ] }, { @@ -583,14 +583,14 @@ "id": "1233b2db", "metadata": {}, "source": [ - "`add_time` is a **pure function** because it does not modify any of the objects passed to it as arguments and its only effect is to return a value.\n", + "`add_time` es una **función pura** porque no modifica ninguno de los objetos que se le pasan como argumentos y su único efecto es devolver un valor.\n", "\n", - "Anything that can be done with impure functions can also be done with pure functions.\n", - "In fact, some programming languages only allow pure functions.\n", - "Programs that use pure functions might be less error-prone, but impure functions are sometimes convenient and can be more efficient.\n", + "Cualquier cosa que se pueda hacer con funciones impuras también se puede hacer con funciones puras.\n", + "De hecho, algunos lenguajes de programación solo permiten funciones puras.\n", + "Los programas que usan funciones puras pueden ser menos propensos a errores, pero las funciones impuras a veces son convenientes y pueden ser más eficientes.\n", "\n", - "In general, I suggest you write pure functions whenever it is reasonable and resort to impure functions only if there is a compelling advantage.\n", - "This approach might be called a **functional programming style**." + "En general, te sugiero que escribas funciones puras siempre que sea razonable y recurras a funciones impuras solo si hay una ventaja convincente.\n", + "Este enfoque podría llamarse un **estilo de programación funcional**." ] }, { @@ -600,10 +600,10 @@ "source": [ "## Prototype and patch\n", "\n", - "In the previous example, `increment_time` and `add_time` seem to work, but if we try another example, we'll see that they are not quite correct.\n", + "En el ejemplo anterior, `increment_time` y `add_time` parecen funcionar, pero si probamos otro ejemplo veremos que no son del todo correctas.\n", "\n", - "Suppose you arrive at the theater and discover that the movie starts at `9:40`, not `9:20`.\n", - "Here's what happens when we compute the updated end time." + "Supón que llegas al cine y descubres que la película empieza a las `9:40`, no a las `9:20`.\n", + "Esto es lo que ocurre cuando calculamos la hora de fin actualizada." ] }, { @@ -619,10 +619,10 @@ "id": "c712ebf7-7e52-490e-91d7-5f1c83334de0", "metadata": {}, "source": [ - "The result is not a valid time.\n", - "The problem is that `increment_time` does not deal with cases where the number of seconds or minutes adds up to more than `60`.\n", + "El resultado no es una hora válida.\n", + "El problema es que `increment_time` no trata los casos en los que el número de segundos o minutos suma más de `60`.\n", "\n", - "Here's an improved version that checks whether `second` exceeds or equals `60` -- if so, it increments `minute` -- then checks whether `minute` exceeds or equals `60` -- if so, it increments `hour`." + "Aquí tienes una versión mejorada que comprueba si `second` supera o iguala `60` -- si es así, incrementa `minute` -- y luego comprueba si `minute` supera o iguala `60` -- si es así, incrementa `hour`." ] }, { @@ -638,8 +638,8 @@ "id": "c133c5d8", "metadata": {}, "source": [ - "Fixing `increment_time` also fixes `add_time`, which uses it.\n", - "So now the previous example works correctly." + "Arreglar `increment_time` también arregla `add_time`, que la usa.\n", + "Así que ahora el ejemplo anterior funciona correctamente." ] }, { @@ -655,9 +655,9 @@ "id": "a2f644a6-ca43-494e-af14-6e845b3d7973", "metadata": {}, "source": [ - "But this function is still not correct, because the arguments might be bigger than `60`.\n", - "For example, suppose we are given the run time as `92` minutes, rather than `1` hours and `32` minutes.\n", - "We might call `add_time` like this." + "Pero esta función todavía no es correcta, porque los argumentos podrían ser mayores que `60`.\n", + "Por ejemplo, supón que recibimos la duración como `92` minutos, en lugar de `1` hora y `32` minutos.\n", + "Podríamos llamar a `add_time` así." ] }, { @@ -673,9 +673,9 @@ "id": "72e0a08b", "metadata": {}, "source": [ - "The result is not a valid time.\n", - "So let's try a different approach, using the `divmod` function.\n", - "We'll make a copy of `start` and modify it by incrementing the `minute` attribute." + "El resultado no es una hora válida.\n", + "Así que probemos un enfoque distinto, usando la función `divmod`.\n", + "Haremos una copia de `start` y la modificaremos incrementando el atributo `minute`." ] }, { @@ -691,8 +691,8 @@ "id": "c56355bc", "metadata": {}, "source": [ - "Now `minute` is `132`, which is `2` hours and `12` minutes.\n", - "We can use `divmod` to divide by `60` and return the number of whole hours and the number of minutes left over." + "Ahora `minute` es `132`, que son `2` horas y `12` minutos.\n", + "Podemos usar `divmod` para dividir por `60` y devolver el número de horas completas y el número de minutos sobrantes." ] }, { @@ -708,7 +708,7 @@ "id": "43204703", "metadata": {}, "source": [ - "Now `minute` is correct, and we can add the hours to `hour`." + "Ahora `minute` es correcto, y podemos añadir las horas a `hour`." ] }, { @@ -724,8 +724,8 @@ "id": "a68ae1cd", "metadata": {}, "source": [ - "The result is a valid time.\n", - "We can do the same thing with `hour` and `second`, and encapsulate the whole process in a function." + "El resultado es una hora válida.\n", + "Podemos hacer lo mismo con `hour` y `second`, y encapsular todo el proceso en una función." ] }, { @@ -741,7 +741,7 @@ "id": "7437113a", "metadata": {}, "source": [ - "With this version of `increment_time`, `add_time` works correctly, even if the arguments exceed `60`." + "Con esta versión de `increment_time`, `add_time` funciona correctamente, incluso si los argumentos superan `60`." ] }, { @@ -757,13 +757,13 @@ "id": "7c6329b2", "metadata": {}, "source": [ - "This section demonstrates a program development plan I call **prototype and patch**.\n", - "We started with a simple prototype that worked correctly for the first example.\n", - "Then we tested it with more difficult examples -- when we found an error, we modified the program to fix it, like putting a patch on tire with a puncture.\n", + "Esta sección demuestra un plan de desarrollo de programas que llamo **prototype and patch**.\n", + "Empezamos con un prototipo simple que funcionaba correctamente para el primer ejemplo.\n", + "Luego lo probamos con ejemplos más difíciles -- cuando encontramos un error, modificamos el programa para corregirlo, como poner un parche en un neumático pinchado.\n", "\n", - "This approach can be effective, especially if you don't yet have a deep understanding of the problem.\n", - "But incremental corrections can generate code that is unnecessarily complicated -- since it deals with many special cases -- and unreliable -- since it is hard to know if you have\n", - "found all the errors." + "Este enfoque puede ser efectivo, especialmente si todavía no tienes una comprensión profunda del problema.\n", + "Pero las correcciones incrementales pueden generar código innecesariamente complicado -- porque trata muchos casos especiales -- y poco fiable -- porque es difícil saber si has\n", + "encontrado todos los errores." ] }, { @@ -773,16 +773,16 @@ "source": [ "## Design-first development\n", "\n", - "An alternative plan is **design-first development**, which involves more planning before prototyping. In a design-first process, sometimes a high-level insight into the problem makes the programming much easier.\n", + "Un plan alternativo es **design-first development**, que implica más planificación antes de prototipar. En un proceso design-first, a veces una idea de alto nivel sobre el problema hace que la programación sea mucho más sencilla.\n", "\n", - "In this case, the insight is that we can think of a `Time` object as a three-digit number in base 60 -- also known as sexagesimal.\n", - "The `second` attribute is the \"ones column\", the `minute` attribute is the \"sixties column\",\n", - "and the `hour` attribute is the \"thirty-six hundreds column\".\n", - "When we wrote `increment_time`, we were effectively doing addition in base 60, which is why we had to carry from one column to the next.\n", + "En este caso, la idea es que podemos pensar en un objeto `Time` como un número de tres dígitos en base 60 -- también conocida como sexagesimal.\n", + "El atributo `second` es la \"columna de las unidades\", el atributo `minute` es la \"columna de los sesenta\",\n", + "y el atributo `hour` es la \"columna de los treinta y seis cientos\".\n", + "Cuando escribimos `increment_time`, en realidad estábamos haciendo suma en base 60, por eso teníamos que llevar de una columna a la siguiente.\n", "\n", - "This observation suggests another approach to the whole problem -- we can convert `Time` objects to integers and take advantage of the fact that Python knows how to do integer arithmetic.\n", + "Esta observación sugiere otro enfoque para todo el problema -- podemos convertir objetos `Time` en enteros y aprovechar que Python sabe hacer aritmética de enteros.\n", "\n", - "Here is a function that converts from a `Time` to an integer." + "Aquí tienes una función que convierte de un `Time` a un entero." ] }, { @@ -798,8 +798,8 @@ "id": "c7e7789e", "metadata": {}, "source": [ - "The result is the number of seconds since the beginning of the day.\n", - "For example, `01:01:01` is `1` hour, `1` minute and `1` second from the beginning of the day, with is the sum of `3600` seconds, `60` seconds, and `1` second." + "El resultado es el número de segundos desde el comienzo del día.\n", + "Por ejemplo, `01:01:01` es `1` hora, `1` minuto y `1` segundo desde el comienzo del día, que es la suma de `3600` segundos, `60` segundos y `1` segundo." ] }, { @@ -815,7 +815,7 @@ "id": "6ea525c8-4547-4bde-91c3-17f45add1bf8", "metadata": {}, "source": [ - "And here's a function that goes in the other direction -- converting an integer to a `Time` object -- using the `divmod` function." + "Y aquí tienes una función que va en la otra dirección -- convierte un entero en un objeto `Time` -- usando la función `divmod`." ] }, { @@ -831,7 +831,7 @@ "id": "4706b5df", "metadata": {}, "source": [ - "We can test it by converting the previous example back to a `Time`." + "Podemos probarla convirtiendo el ejemplo anterior de vuelta a un `Time`." ] }, { @@ -847,7 +847,7 @@ "id": "0c2b8469-d4a7-46f9-a0a1-f2a6c1595183", "metadata": {}, "source": [ - "Using these functions, we can write a more concise version of `add_time`." + "Usando estas funciones, podemos escribir una versión más concisa de `add_time`." ] }, { @@ -863,11 +863,11 @@ "id": "cb560257", "metadata": {}, "source": [ - "The first line converts the arguments to a `Time` object called `duration`.\n", - "The second line converts `time` and `duration` to seconds and adds them.\n", - "The third line converts the sum to a `Time` object and returns it.\n", + "La primera línea convierte los argumentos en un objeto `Time` llamado `duration`.\n", + "La segunda línea convierte `time` y `duration` a segundos y los suma.\n", + "La tercera línea convierte la suma en un objeto `Time` y lo devuelve.\n", "\n", - "Here's how it works." + "Así funciona." ] }, { @@ -883,17 +883,17 @@ "id": "db762aa8-4aab-4c17-a88d-72c5048f18c0", "metadata": {}, "source": [ - "In some ways, converting from base 60 to base 10 and back is harder than\n", - "just dealing with times. Base conversion is more abstract; our intuition\n", - "for dealing with time values is better.\n", + "En cierto sentido, convertir de base 60 a base 10 y de vuelta es más difícil que\n", + "simplemente tratar con horas. La conversión de base es más abstracta; nuestra intuición\n", + "para trabajar con valores de tiempo es mejor.\n", "\n", - "But if we have the insight to treat times as base 60 numbers -- and invest the effort to write the conversion functions `time_to_int` and `int_to_time` -- we get a program that is shorter, easier to read and debug, and more reliable.\n", + "Pero si tenemos la idea de tratar las horas como números en base 60 -- e invertimos el esfuerzo de escribir las funciones de conversión `time_to_int` e `int_to_time` -- obtenemos un programa más corto, más fácil de leer y depurar, y más fiable.\n", "\n", - "It is also easier to add features later. For example, imagine subtracting two `Time` objects to find the duration between them.\n", - "The naive approach is to implement subtraction with borrowing.\n", - "Using the conversion functions is easier and more likely to be correct.\n", + "También es más fácil añadir características más adelante. Por ejemplo, imagina restar dos objetos `Time` para encontrar la duración entre ellos.\n", + "El enfoque ingenuo es implementar la resta con préstamo.\n", + "Usar las funciones de conversión es más fácil y tiene más probabilidades de ser correcto.\n", "\n", - "Ironically, sometimes making a problem harder -- or more general -- makes it easier, because there are fewer special cases and fewer opportunities for error." + "Irónicamente, a veces hacer un problema más difícil -- o más general -- lo hace más fácil, porque hay menos casos especiales y menos oportunidades de error." ] }, { @@ -903,10 +903,10 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Python provides several built-in functions that are useful for testing and debugging programs that work with objects.\n", - "For example, if you are not sure what type an object is, you can ask." + "Python proporciona varias funciones integradas que son útiles para probar y depurar programas que trabajan con objetos.\n", + "Por ejemplo, si no estás seguro de qué tipo es un objeto, puedes preguntarlo." ] }, { @@ -922,7 +922,7 @@ "id": "7ec0eabf", "metadata": {}, "source": [ - "You can also use `isinstance` to check whether an object is an instance of a particular class." + "También puedes usar `isinstance` para comprobar si un objeto es una instancia de una clase concreta." ] }, { @@ -938,8 +938,7 @@ "id": "4f453fe9", "metadata": {}, "source": [ - "If you are not sure whether an object has a particular attribute, you\n", - "can use the built-in function `hasattr`." + "Si no estás seguro de si un objeto tiene un atributo concreto, puedes usar la función integrada `hasattr`." ] }, { @@ -955,7 +954,7 @@ "id": "a0131d84", "metadata": {}, "source": [ - "To get all of the attributes, and their values, in a dictionary, you can use `vars`." + "Para obtener todos los atributos, y sus valores, en un diccionario, puedes usar `vars`." ] }, { @@ -971,7 +970,7 @@ "id": "f1a443c8", "metadata": {}, "source": [ - "The `structshape` module, which we saw in [Chapter 11](section_debugging_11), also works with programmer-defined types." + "El módulo `structshape`, que vimos en el [Capítulo 11](section_depuración_11), también funciona con tipos definidos por el programador." ] }, { @@ -997,43 +996,43 @@ "id": "501436c0-6634-415f-be84-2d130232b2b8", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**object-oriented programming:**\n", - "A style of programming that uses objects to organize code and data.\n", + "**programación orientada a objetos:**\n", + "Un estilo de programación que usa objetos para organizar código y datos.\n", "\n", - "**class:**\n", - " A programmer-defined type. A class definition creates a new class object.\n", + "**clase:**\n", + " Un tipo definido por el programador. Una definición de clase crea un nuevo objeto de clase.\n", "\n", - "**class object:**\n", - "An object that represents a class -- it is the result of a class definition.\n", + "**objeto de clase:**\n", + "Un objeto que representa una clase -- es el resultado de una definición de clase.\n", "\n", - "**instantiation:**\n", - "The process of creating an object that belongs to a class.\n", + "**instanciación:**\n", + "El proceso de crear un objeto que pertenece a una clase.\n", "\n", - "**instance:**\n", - " An object that belongs to a class.\n", + "**instancia:**\n", + " Un objeto que pertenece a una clase.\n", "\n", - "**attribute:**\n", - " A variable associated with an object, also called an instance variable.\n", + "**atributo:**\n", + " Una variable asociada con un objeto, también llamada variable de instancia.\n", "\n", - "**object diagram:**\n", - "A graphical representation of an object, its attributes, and their values.\n", + "**diagrama de objeto:**\n", + "Una representación gráfica de un objeto, sus atributos y sus valores.\n", "\n", - "**format specifier:**\n", - "In an f-string, a format specifier determines how a value is converted to a string.\n", + "**especificador de formato:**\n", + "En una f-string, un especificador de formato determina cómo se convierte un valor en una string.\n", "\n", - "**pure function:**\n", - "A function that does not modify its parameters or have any effect other than returning a value.\n", + "**función pura:**\n", + "Una función que no modifica sus parámetros ni tiene ningún efecto aparte de devolver un valor.\n", "\n", - "**functional programming style:**\n", - "A way of programming that uses pure functions whenever possible.\n", + "**estilo de programación funcional:**\n", + "Una forma de programar que usa funciones puras siempre que sea posible.\n", "\n", "**prototype and patch:**\n", - "A way of developing programs by starting with a rough draft and gradually adding features and fixing bugs.\n", + "Una forma de desarrollar programas empezando con un borrador aproximado y añadiendo características y corrigiendo bugs gradualmente.\n", "\n", "**design-first development:**\n", - "A way of developing programs with more careful planning that prototype and patch." + "Una forma de desarrollar programas con una planificación más cuidadosa que prototype and patch." ] }, { @@ -1041,7 +1040,7 @@ "id": "09dd41c1", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1059,29 +1058,29 @@ "id": "da0aea86", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There is a lot of new vocabulary in this chapter.\n", - "A conversation with a virtual assistant can help solidify your understanding.\n", - "Consider asking:\n", + "Hay mucho vocabulario nuevo en este capítulo.\n", + "Una conversación con un asistente virtual puede ayudarte a consolidar tu comprensión.\n", + "Considera preguntar:\n", "\n", - "* \"What is the difference between a class and a type?\"\n", + "* \"¿Cuál es la diferencia entre una clase y un tipo?\"\n", "\n", - "* \"What is the difference between an object and an instance?\"\n", + "* \"¿Cuál es la diferencia entre un objeto y una instancia?\"\n", "\n", - "* \"What is the difference between a variable and an attribute?\"\n", + "* \"¿Cuál es la diferencia entre una variable y un atributo?\"\n", "\n", - "* \"What are the pros and cons of pure functions compared to impure functions?\"\n", + "* \"¿Cuáles son los pros y los contras de funciones puras comparadas con funciones impuras?\"\n", "\n", - "Because we are just getting started with object oriented programming, the code in this chapter is not idiomatic -- it is not the kind of code experienced programmers write.\n", - "If you ask a virtual assistant for help with the exercises, you will probably see features we have not covered yet.\n", - "In particular, you are likely to see a method called `__init__` used to initialize the attributes of an instance.\n", + "Como apenas estamos empezando con la programación orientada a objetos, el código de este capítulo no es idiomático -- no es el tipo de código que escriben los programadores con experiencia.\n", + "Si pides ayuda a un asistente virtual con los ejercicios, probablemente verás características que todavía no hemos cubierto.\n", + "En particular, es probable que veas un método llamado `__init__` usado para inicializar los atributos de una instancia.\n", "\n", - "If these features make sense to you, go ahead and use them.\n", - "But if not, be patient -- we will get there soon.\n", - "In the meantime, see if you can solve the following exercises using only the features we have covered so far.\n", + "Si estas características tienen sentido para ti, adelante, úsalas.\n", + "Pero si no, ten paciencia -- llegaremos pronto.\n", + "Mientras tanto, mira si puedes resolver los siguientes ejercicios usando solo las características que hemos cubierto hasta ahora.\n", "\n", - "Also, in this chapter we saw one example of a format specifier. For more information, ask \"What format specifiers can be used in a Python f-string?\"" + "Además, en este capítulo vimos un ejemplo de especificador de formato. Para más información, pregunta \"¿Qué especificadores de formato se pueden usar en una f-string de Python?\"" ] }, { @@ -1097,9 +1096,9 @@ "id": "bcdab7d6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `subtract_time` that takes two `Time` objects and returns the interval between them in seconds -- assuming that they are two times during the same day." + "Escribe una función llamada `subtract_time` que tome dos objetos `Time` y devuelva el intervalo entre ellos en segundos -- asumiendo que son dos horas del mismo día." ] }, { @@ -1109,7 +1108,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1137,7 +1136,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1155,9 +1154,9 @@ "id": "c3189549", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `is_after` that takes two `Time` objects and returns `True` if the first time is later in the day than the second, and `False` otherwise." + "Escribe una función llamada `is_after` que tome dos objetos `Time` y devuelva `True` si la primera hora es más tarde en el día que la segunda, y `False` en caso contrario." ] }, { @@ -1167,7 +1166,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1193,7 +1192,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1211,9 +1210,9 @@ "id": "16dff862", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's a definition for a `Date` class that represents a date -- that is, a year, month, and day of the month." + "Aquí tienes una definición de una clase `Date` que representa una fecha -- es decir, un año, mes y día del mes." ] }, { @@ -1229,13 +1228,13 @@ "id": "3311fa97", "metadata": {}, "source": [ - "1. Write a function called `make_date` that takes `year`, `month`, and `day` as parameters, makes a `Date` object, assigns the parameters to attributes, and returns the result the new object. Create an object that represents June 22, 1933.\n", + "1. Escribe una función llamada `make_date` que tome `year`, `month` y `day` como parámetros, cree un objeto `Date`, asigne los parámetros a atributos y devuelva el objeto nuevo resultante. Crea un objeto que represente el 22 de junio de 1933.\n", "\n", - "2. Write a function called `print_date` that takes a `Date` object, uses an f-string to format the attributes, and prints the result. If you test it with the `Date` you created, the result should be `1933-06-22`.\n", + "2. Escribe una función llamada `print_date` que tome un objeto `Date`, use una f-string para formatear los atributos e imprima el resultado. Si la pruebas con la `Date` que creaste, el resultado debería ser `1933-06-22`.\n", "\n", - "3. Write a function called `is_after` that takes two `Date` objects as parameters and returns `True` if the first comes after the second. Create a second object that represents September 17, 1933, and check whether it comes after the first object.\n", + "3. Escribe una función llamada `is_after` que tome dos objetos `Date` como parámetros y devuelva `True` si la primera viene después de la segunda. Crea un segundo objeto que represente el 17 de septiembre de 1933 y comprueba si viene después del primer objeto.\n", "\n", - "Hint: You might find it useful to write a function called `date_to_tuple` that takes a `Date` object and returns a tuple that contains its attributes in year, month, day order." + "Pista: puede resultarte útil escribir una función llamada `date_to_tuple` que tome un objeto `Date` y devuelva una tupla que contenga sus atributos en orden año, mes, día." ] }, { @@ -1245,7 +1244,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1273,7 +1272,7 @@ "tags": [] }, "source": [ - "You can use these examples to test `make_date`." + "Puedes usar estos ejemplos para probar `make_date`." ] }, { @@ -1303,7 +1302,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1331,7 +1330,7 @@ "tags": [] }, "source": [ - "You can use this example to test `print_date`." + "Puedes usar este ejemplo para probar `print_date`." ] }, { @@ -1351,7 +1350,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1387,7 +1386,7 @@ "tags": [] }, "source": [ - "You can use these examples to test `is_after`." + "Puedes usar estos ejemplos para probar `is_after`." ] }, { @@ -1427,9 +1426,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/blank/chap15.ipynb b/blank/chap15.ipynb index 2ffde33..66a140c 100644 --- a/blank/chap15.ipynb +++ b/blank/chap15.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,19 +25,19 @@ "id": "fa22117f", "metadata": {}, "source": [ - "# Classes and Methods\n", + "# Clases y métodos\n", "\n", - "Python is an **object-oriented language** -- that is, it provides features that support object-oriented programming, which has these defining characteristics:\n", + "Python es un **lenguaje orientado a objetos** -- es decir, proporciona funcionalidades que dan soporte a la programación orientada a objetos, que tiene estas características definitorias:\n", "\n", - "- Most of the computation is expressed in terms of operations on objects.\n", + "- La mayor parte del cálculo se expresa en términos de operaciones sobre objetos.\n", "\n", - "- Objects often represent things in the real world, and methods often correspond to the ways things in the real world interact.\n", + "- Los objetos a menudo representan cosas del mundo real, y los métodos suelen corresponder a las formas en que las cosas del mundo real interactúan.\n", "\n", - "- Programs include class and method definitions.\n", + "- Los programas incluyen definiciones de clase y método.\n", "\n", - "For example, in the previous chapter we defined a `Time` class that corresponds to the way people record the time of day, and we defined functions that correspond to the kinds of things people do with times.\n", - "But there was no explicit connection between the definition of the `Time` class and the function definitions that follow.\n", - "We can make the connection explicit by rewriting a function as a **method**, which is defined inside a class definition." + "Por ejemplo, en el capítulo anterior definimos una clase `Time` que corresponde a la forma en que las personas registran la hora del día, y definimos funciones que corresponden a los tipos de cosas que las personas hacen con horas.\n", + "Pero no había una conexión explícita entre la definición de la clase `Time` y las definiciones de función que vienen después.\n", + "Podemos hacer explícita la conexión reescribiendo una función como un **método**, que se define dentro de una definición de clase." ] }, { @@ -45,9 +45,9 @@ "id": "9857823a", "metadata": {}, "source": [ - "## Defining methods\n", + "## Definir métodos\n", "\n", - "In the previous chapter we defined a class named `Time` and wrote a function named `print_time` that displays a time of day." + "En el capítulo anterior definimos una clase llamada `Time` y escribimos una función llamada `print_time` que muestra una hora del día." ] }, { @@ -63,12 +63,10 @@ "id": "a89ddf58", "metadata": {}, "source": [ - "To make `print_time` a method, all we have to do is move the function\n", - "definition inside the class definition. Notice the change in\n", - "indentation.\n", + "Para convertir `print_time` en un método, todo lo que tenemos que hacer es mover la definición de la función dentro de la definición de la clase. Fíjate en el cambio de indentación.\n", "\n", - "At the same time, we'll change the name of the parameter from `time` to `self`.\n", - "This change is not necessary, but it is conventional for the first parameter of a method to be named `self`." + "Al mismo tiempo, cambiaremos el nombre del parámetro de `time` a `self`.\n", + "Este cambio no es necesario, pero es convencional que el primer parámetro de un método se llame `self`." ] }, { @@ -84,8 +82,8 @@ "id": "8da4079c", "metadata": {}, "source": [ - "To call this method, you have to pass a `Time` object as an argument.\n", - "Here's the function we'll use to make a `Time` object." + "Para llamar a este método, tienes que pasar un objeto `Time` como argumento.\n", + "Aquí está la función que usaremos para crear un objeto `Time`." ] }, { @@ -101,7 +99,7 @@ "id": "c6ad4e12", "metadata": {}, "source": [ - "And here's a `Time` instance." + "Y aquí hay una instancia de `Time`." ] }, { @@ -117,8 +115,7 @@ "id": "bbbcd333", "metadata": {}, "source": [ - "Now there are two ways to call `print_time`. The first (and less common)\n", - "way is to use function syntax." + "Ahora hay dos formas de llamar a `print_time`. La primera (y menos común) es usar sintaxis de función." ] }, { @@ -134,8 +131,8 @@ "id": "2eb0847e", "metadata": {}, "source": [ - "In this version, `Time` is the name of the class, `print_time` is the name of the method, and `start` is passed as a parameter.\n", - "The second (and more idiomatic) way is to use method syntax:" + "En esta versión, `Time` es el nombre de la clase, `print_time` es el nombre del método, y `start` se pasa como parámetro.\n", + "La segunda forma (y más idiomática) es usar sintaxis de método:" ] }, { @@ -151,10 +148,10 @@ "id": "c80c40f0", "metadata": {}, "source": [ - "In this version, `start` is the object the method is invoked on, which is called the **receiver**, based on the analogy that invoking a method is like sending a message to an object.\n", + "En esta versión, `start` es el objeto sobre el que se invoca el método, que se llama **receptor**, basándonos en la analogía de que invocar un método es como enviar un mensaje a un objeto.\n", "\n", - "Regardless of the syntax, the behavior of the method is the same.\n", - "The receiver is assigned to the first parameter, so inside the method, `self` refers to the same object as `start`." + "Independientemente de la sintaxis, el comportamiento del método es el mismo.\n", + "El receptor se asigna al primer parámetro, así que dentro del método, `self` se refiere al mismo objeto que `start`." ] }, { @@ -162,9 +159,9 @@ "id": "8deb6c34", "metadata": {}, "source": [ - "## Another method\n", + "## Otro método\n", "\n", - "Here's the `time_to_int` function from the previous chapter." + "Aquí está la función `time_to_int` del capítulo anterior." ] }, { @@ -180,7 +177,7 @@ "id": "144e043f", "metadata": {}, "source": [ - "And here's a version rewritten as a method.\n" + "Y aquí hay una versión reescrita como método.\n" ] }, { @@ -196,14 +193,14 @@ "id": "e3a721ab", "metadata": {}, "source": [ - "The first line uses the special command `add_method_to`, which adds a method to a previously-defined class.\n", - "This command works in a Jupyter notebook, but it is not part of Python, so it won't work in other environments.\n", - "Normally, all methods of a class are inside the class definition, so they get defined at the same time as the class.\n", - "But for this book, it is helpful to define one method at a time.\n", + "La primera línea usa el comando especial `add_method_to`, que añade un método a una clase definida previamente.\n", + "Este comando funciona en un Jupyter notebook, pero no forma parte de Python, así que no funcionará en otros entornos.\n", + "Normalmente, todos los métodos de una clase están dentro de la definición de la clase, así que se definen al mismo tiempo que la clase.\n", + "Pero para este libro, es útil definir un método cada vez.\n", "\n", - "As in the previous example, the method definition is indented and the name of the parameter is `self`.\n", - "Other than that, the method is identical to the function.\n", - "Here's how we invoke it." + "Como en el ejemplo anterior, la definición del método está indentada y el nombre del parámetro es `self`.\n", + "Aparte de eso, el método es idéntico a la función.\n", + "Así es como lo invocamos." ] }, { @@ -219,7 +216,7 @@ "id": "14565505", "metadata": {}, "source": [ - "It is common to say that we \"call\" a function and \"invoke\" a method, but they mean the same thing." + "Es común decir que \"llamamos\" a una función e \"invocamos\" un método, pero significan lo mismo." ] }, { @@ -227,10 +224,10 @@ "id": "7bc24683", "metadata": {}, "source": [ - "## Static methods\n", + "## Métodos estáticos\n", "\n", - "As another example, let's consider the `int_to_time` function.\n", - "Here's the version from the previous chapter." + "Como otro ejemplo, consideremos la función `int_to_time`.\n", + "Aquí está la versión del capítulo anterior." ] }, { @@ -246,12 +243,12 @@ "id": "2b77c2a0", "metadata": {}, "source": [ - "This function takes `seconds` as a parameter and returns a new `Time` object.\n", - "If we transform it into a method of the `Time` class, we have to invoke it on a `Time` object.\n", - "But if we're trying to create a new `Time` object, what are we supposed to invoke it on?\n", + "Esta función toma `seconds` como parámetro y devuelve un nuevo objeto `Time`.\n", + "Si la transformamos en un método de la clase `Time`, tenemos que invocarla sobre un objeto `Time`.\n", + "Pero si estamos intentando crear un nuevo objeto `Time`, ¿sobre qué se supone que debemos invocarla?\n", "\n", - "We can solve this chicken-and-egg problem using a **static method**, which is a method that does not require an instance of the class to be invoked.\n", - "Here's how we rewrite this function as a static method." + "Podemos resolver este problema del huevo y la gallina usando un **método estático**, que es un método que no requiere una instancia de la clase para invocarse.\n", + "Así es como reescribimos esta función como un método estático." ] }, { @@ -267,8 +264,8 @@ "id": "a7e2e788", "metadata": {}, "source": [ - "Because it is a static method, it does not have `self` as a parameter.\n", - "To invoke it, we use `Time`, which is the class object." + "Como es un método estático, no tiene `self` como parámetro.\n", + "Para invocarlo, usamos `Time`, que es el objeto de clase." ] }, { @@ -284,7 +281,7 @@ "id": "d2f4fd5a", "metadata": {}, "source": [ - "The result is a new object that represents 9:40." + "El resultado es un nuevo objeto que representa las 9:40." ] }, { @@ -300,8 +297,8 @@ "id": "e6a18c76", "metadata": {}, "source": [ - "Now that we have `Time.from_seconds`, we can use it to write `add_time` as a method.\n", - "Here's the function from the previous chapter." + "Ahora que tenemos `Time.from_seconds`, podemos usarlo para escribir `add_time` como un método.\n", + "Aquí está la función del capítulo anterior." ] }, { @@ -317,7 +314,7 @@ "id": "8e56da48", "metadata": {}, "source": [ - "And here's a version rewritten as a method." + "Y aquí hay una versión reescrita como método." ] }, { @@ -333,9 +330,9 @@ "id": "b784a4ea", "metadata": {}, "source": [ - "`add_time` has `self` as a parameter because it is not a static method.\n", - "It is an ordinary method -- also called an **instance method**.\n", - "To invoke it, we need a `Time` instance." + "`add_time` tiene `self` como parámetro porque no es un método estático.\n", + "Es un método ordinario -- también llamado **método de instancia**.\n", + "Para invocarlo, necesitamos una instancia de `Time`." ] }, { @@ -351,10 +348,10 @@ "id": "f1c806a9", "metadata": {}, "source": [ - "## Comparing Time objects\n", + "## Comparar objetos Time\n", "\n", - "As one more example, let's write `is_after` as a method.\n", - "Here's the `is_after` function, which is a solution to an exercise in the previous chapter." + "Como un ejemplo más, escribamos `is_after` como método.\n", + "Aquí está la función `is_after`, que es una solución a un ejercicio del capítulo anterior." ] }, { @@ -370,7 +367,7 @@ "id": "8e7153e8", "metadata": {}, "source": [ - "And here it is as a method." + "Y aquí está como método." ] }, { @@ -386,9 +383,8 @@ "id": "50815aec", "metadata": {}, "source": [ - "Because we're comparing two objects, and the first parameter is `self`, we'll call the second parameter `other`.\n", - "To use this method, we have to invoke it on one object and pass the\n", - "other as an argument." + "Como estamos comparando dos objetos, y el primer parámetro es `self`, llamaremos al segundo parámetro `other`.\n", + "Para usar este método, tenemos que invocarlo sobre un objeto y pasar el otro como argumento." ] }, { @@ -404,8 +400,8 @@ "id": "cf97e358", "metadata": {}, "source": [ - "One nice thing about this syntax is that it almost reads like a question,\n", - "\"`end` is after `start`?\"" + "Una cosa buena de esta sintaxis es que casi se lee como una pregunta:\n", + "\"¿`end` va después de `start`?\"" ] }, { @@ -413,12 +409,12 @@ "id": "15a17fce", "metadata": {}, "source": [ - "## The `__str__` method\n", + "## El método `__str__`\n", "\n", - "When you write a method, you can choose almost any name you want.\n", - "However, some names have special meanings.\n", - "For example, if an object has a method named `__str__`, Python uses that method to convert the object to a string.\n", - "For example, here is a `__str__` method for a time object." + "Cuando escribes un método, puedes elegir casi cualquier nombre que quieras.\n", + "Sin embargo, algunos nombres tienen significados especiales.\n", + "Por ejemplo, si un objeto tiene un método llamado `__str__`, Python usa ese método para convertir el objeto a string.\n", + "Por ejemplo, aquí hay un método `__str__` para un objeto de hora." ] }, { @@ -434,9 +430,9 @@ "id": "b056b729", "metadata": {}, "source": [ - "This method is similar to `print_time`, from the previous chapter, except that it returns the string rather than printing it.\n", + "Este método es similar a `print_time`, del capítulo anterior, salvo que devuelve el string en lugar de imprimirlo.\n", "\n", - "You can invoke this method in the usual way." + "Puedes invocar este método de la forma habitual." ] }, { @@ -452,8 +448,8 @@ "id": "76092a0c", "metadata": {}, "source": [ - "But Python can also invoke it for you.\n", - "If you use the built-in function `str` to convert a `Time` object to a string, Python uses the `__str__` method in the `Time` class." + "Pero Python también puede invocarlo por ti.\n", + "Si usas la función integrada `str` para convertir un objeto `Time` a string, Python usa el método `__str__` de la clase `Time`." ] }, { @@ -469,7 +465,7 @@ "id": "8a26caa8", "metadata": {}, "source": [ - "And it does the same if you print a `Time` object." + "Y hace lo mismo si imprimes un objeto `Time`." ] }, { @@ -485,8 +481,8 @@ "id": "97eb30c2", "metadata": {}, "source": [ - "Methods like `__str__` are called **special methods**.\n", - "You can identify them because their names begin and end with two underscores." + "Los métodos como `__str__` se llaman **métodos especiales**.\n", + "Puedes identificarlos porque sus nombres empiezan y terminan con dos guiones bajos." ] }, { @@ -494,10 +490,10 @@ "id": "e01e9673", "metadata": {}, "source": [ - "## The __init__ method\n", + "## El método __init__\n", "\n", - "The most special of the special methods is `__init__`, so-called because it initializes the attributes of a new object.\n", - "An `__init__` method for the `Time` class might look like this:" + "El más especial de los métodos especiales es `__init__`, llamado así porque inicializa los atributos de un nuevo objeto.\n", + "Un método `__init__` para la clase `Time` podría tener este aspecto:" ] }, { @@ -513,8 +509,8 @@ "id": "8ba624c3", "metadata": {}, "source": [ - "Now when we instantiate a `Time` object, Python invokes `__init__`, and passes along the arguments.\n", - "So we can create an object and initialize the attributes at the same time." + "Ahora, cuando instanciamos un objeto `Time`, Python invoca `__init__` y pasa los argumentos.\n", + "Así podemos crear un objeto e inicializar los atributos al mismo tiempo." ] }, { @@ -530,8 +526,8 @@ "id": "55e0e296", "metadata": {}, "source": [ - "In this example, the parameters are optional, so if you call `Time` with no arguments,\n", - "you get the default values." + "En este ejemplo, los parámetros son opcionales, así que si llamas a `Time` sin argumentos,\n", + "obtienes los valores por defecto." ] }, { @@ -547,7 +543,7 @@ "id": "bacb036d", "metadata": {}, "source": [ - "If you provide one argument, it overrides `hour`:" + "Si proporcionas un argumento, sobrescribe `hour`:" ] }, { @@ -563,7 +559,7 @@ "id": "37edb221", "metadata": {}, "source": [ - "If you provide two arguments, they override `hour` and `minute`." + "Si proporcionas dos argumentos, sobrescriben `hour` y `minute`." ] }, { @@ -579,10 +575,9 @@ "id": "277de217", "metadata": {}, "source": [ - "And if you provide three arguments, they override all three default\n", - "values.\n", + "Y si proporcionas tres argumentos, sobrescriben los tres valores por defecto.\n", "\n", - "When I write a new class, I almost always start by writing `__init__`, which makes it easier to create objects, and `__str__`, which is useful for debugging." + "Cuando escribo una clase nueva, casi siempre empiezo escribiendo `__init__`, que hace más fácil crear objetos, y `__str__`, que es útil para depurar." ] }, { @@ -590,14 +585,11 @@ "id": "94bbbd7d", "metadata": {}, "source": [ - "## Operator overloading\n", + "## Sobrecarga de operadores\n", "\n", - "By defining other special methods, you can specify the behavior of\n", - "operators on programmer-defined types. For example, if you define a\n", - "method named `__add__` for the `Time` class, you can use the `+`\n", - "operator on Time objects.\n", + "Definiendo otros métodos especiales, puedes especificar el comportamiento de los operadores sobre tipos definidos por el programador. Por ejemplo, si defines un método llamado `__add__` para la clase `Time`, puedes usar el operador `+` con objetos Time.\n", "\n", - "Here is an `__add__` method." + "Aquí hay un método `__add__`." ] }, { @@ -613,7 +605,7 @@ "id": "0221c9ad", "metadata": {}, "source": [ - "We can use it like this." + "Podemos usarlo así." ] }, { @@ -629,16 +621,16 @@ "id": "7cc7866e", "metadata": {}, "source": [ - "There is a lot happening when we run these three lines of code:\n", + "Están pasando muchas cosas cuando ejecutamos estas tres líneas de código:\n", "\n", - "* When we instantiate a `Time` object, the `__init__` method is invoked.\n", + "* Cuando instanciamos un objeto `Time`, se invoca el método `__init__`.\n", "\n", - "* When we use the `+` operator with a `Time` object, its `__add__` method is invoked.\n", + "* Cuando usamos el operador `+` con un objeto `Time`, se invoca su método `__add__`.\n", "\n", - "* And when we print a `Time` object, its `__str__` method is invoked.\n", + "* Y cuando imprimimos un objeto `Time`, se invoca su método `__str__`.\n", "\n", - "Changing the behavior of an operator so that it works with programmer-defined types is called **operator overloading**.\n", - "For every operator, like `+`, there is a corresponding special method, like `__add__`. " + "Cambiar el comportamiento de un operador para que funcione con tipos definidos por el programador se llama **sobrecarga de operadores**.\n", + "Para cada operador, como `+`, hay un método especial correspondiente, como `__add__`. " ] }, { @@ -646,15 +638,15 @@ "id": "b7299e62", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "A `Time` object is valid if the values of `minute` and `second` are between `0` and `60` -- including `0` but not `60` -- and if `hour` is positive.\n", - "Also, `hour` and `minute` should be integer values, but we might allow `second` to have a fraction part.\n", - "Requirements like these are called **invariants** because they should always be true.\n", - "To put it a different way, if they are not true, something has gone wrong.\n", + "Un objeto `Time` es válido si los valores de `minute` y `second` están entre `0` y `60` -- incluyendo `0` pero no `60` -- y si `hour` es positivo.\n", + "Además, `hour` y `minute` deberían ser valores enteros, pero podríamos permitir que `second` tenga una parte fraccionaria.\n", + "Requisitos como estos se llaman **invariantes** porque siempre deberían ser verdaderos.\n", + "Dicho de otra forma, si no son verdaderos, algo ha ido mal.\n", "\n", - "Writing code to check invariants can help detect errors and find their causes.\n", - "For example, you might have a method like `is_valid` that takes a Time object and returns `False` if it violates an invariant." + "Escribir código para comprobar invariantes puede ayudar a detectar errores y encontrar sus causas.\n", + "Por ejemplo, podrías tener un método como `is_valid` que toma un objeto Time y devuelve `False` si viola una invariante." ] }, { @@ -670,7 +662,7 @@ "id": "a10ad3db", "metadata": {}, "source": [ - "Then, at the beginning of each method you can check the arguments to make sure they are valid." + "Entonces, al principio de cada método puedes comprobar los argumentos para asegurarte de que son válidos." ] }, { @@ -686,8 +678,8 @@ "id": "e7c78e9a", "metadata": {}, "source": [ - "The `assert` statement evaluates the expression that follows. If the result is `True`, it does nothing; if the result is `False`, it causes an `AssertionError`.\n", - "Here's an example." + "La sentencia `assert` evalúa la expresión que le sigue. Si el resultado es `True`, no hace nada; si el resultado es `False`, causa un `AssertionError`.\n", + "Aquí hay un ejemplo." ] }, { @@ -713,7 +705,7 @@ "id": "18bd34ad", "metadata": {}, "source": [ - "`assert` statements are useful because they distinguish code that deals with normal conditions from code that checks for errors." + "Las sentencias `assert` son útiles porque distinguen el código que trata con condiciones normales del código que comprueba errores." ] }, { @@ -721,31 +713,31 @@ "id": "58b86fbe", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**object-oriented language:**\n", - "A language that provides features to support object-oriented programming, notably user-defined types.\n", + "**lenguaje orientado a objetos:**\n", + "Un lenguaje que proporciona funcionalidades para dar soporte a la programación orientada a objetos, especialmente tipos definidos por el usuario.\n", "\n", - "**method:**\n", - "A function that is defined inside a class definition and is invoked on instances of that class.\n", + "**método:**\n", + "Una función que se define dentro de una definición de clase y se invoca sobre instancias de esa clase.\n", "\n", - "**receiver:**\n", - "The object a method is invoked on.\n", + "**receptor (receiver):**\n", + "El objeto sobre el que se invoca un método.\n", "\n", - "**static method:**\n", - "A method that can be invoked without an object as receiver.\n", + "**método estático:**\n", + "Un método que puede invocarse sin un objeto como receptor.\n", "\n", - "**instance method:**\n", - "A method that must be invoked with an object as receiver.\n", + "**método de instancia:**\n", + "Un método que debe invocarse con un objeto como receptor.\n", "\n", - "**special method:**\n", - "A method that changes the way operators and some functions work with an object.\n", + "**método especial:**\n", + "Un método que cambia la forma en que los operadores y algunas funciones funcionan con un objeto.\n", "\n", - "**operator overloading:**\n", - "The process of using special methods to change the way operators with with user-defined types.\n", + "**sobrecarga de operadores:**\n", + "El proceso de usar métodos especiales para cambiar la forma en que los operadores funcionan con tipos definidos por el usuario.\n", "\n", - "**invariant:**\n", - " A condition that should always be true during the execution of a program." + "**invariante:**\n", + " Una condición que siempre debería ser verdadera durante la ejecución de un programa." ] }, { @@ -753,7 +745,7 @@ "id": "796adf5c", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -771,20 +763,20 @@ "id": "25cd6888", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "For more information about static methods, ask a virtual assistant:\n", + "Para obtener más información sobre métodos estáticos, pregunta a un asistente virtual:\n", "\n", - "* \"What's the difference between an instance method and a static method?\"\n", + "* \"¿Cuál es la diferencia entre un método de instancia y un método estático?\"\n", "\n", - "* \"Why are static methods called static?\"\n", + "* \"¿Por qué los métodos estáticos se llaman estáticos?\"\n", "\n", - "If you ask a virtual assistant to generate a static method, the result will probably begin with `@staticmethod`, which is a \"decorator\" that indicates that it is a static method.\n", - "Decorators are not covered in this book, but if you are curious, you can ask a VA for more information.\n", + "Si le pides a un asistente virtual que genere un método estático, el resultado probablemente empezará con `@staticmethod`, que es un \"decorator\" que indica que es un método estático.\n", + "Los decorators no se cubren en este libro, pero si tienes curiosidad, puedes pedirle más información a un AV.\n", "\n", - "In this chapter we rewrote several functions as methods.\n", - "Virtual assistants are generally good at this kind of code transformation.\n", - "As an example, paste the following function into a VA and ask it, \"Rewrite this function as a method of the `Time` class.\"" + "En este capítulo reescribimos varias funciones como métodos.\n", + "Los asistentes virtuales suelen ser buenos en este tipo de transformación de código.\n", + "Como ejemplo, pega la siguiente función en un AV y pídele: \"Reescribe esta función como un método de la clase `Time`.\"" ] }, { @@ -800,20 +792,20 @@ "id": "fc9f135b-e242-4ef6-83eb-8e028235c07b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In the previous chapter, a series of exercises asked you to write a `Date` class and several functions that work with `Date` objects.\n", - "Now let's practice rewriting those functions as methods.\n", + "En el capítulo anterior, una serie de ejercicios te pidió escribir una clase `Date` y varias funciones que trabajan con objetos `Date`.\n", + "Ahora practiquemos reescribir esas funciones como métodos.\n", "\n", - "1. Write a definition for a `Date` class that represents a date -- that is, a year, month, and day of the month.\n", + "1. Escribe una definición para una clase `Date` que represente una fecha -- es decir, un año, un mes y un día del mes.\n", "\n", - "2. Write an `__init__` method that takes `year`, `month`, and `day` as parameters and assigns the parameters to attributes. Create an object that represents June 22, 1933.\n", + "2. Escribe un método `__init__` que tome `year`, `month` y `day` como parámetros y asigne los parámetros a atributos. Crea un objeto que represente el 22 de junio de 1933.\n", "\n", - "2. Write `__str__` method that uses an f-string to format the attributes and returns the result. If you test it with the `Date` you created, the result should be `1933-06-22`.\n", + "2. Escribe un método `__str__` que use un f-string para formatear los atributos y devolver el resultado. Si lo pruebas con el `Date` que creaste, el resultado debería ser `1933-06-22`.\n", "\n", - "3. Write a method called `is_after` that takes two `Date` objects and returns `True` if the first comes after the second. Create a second object that represents September 17, 1933, and check whether it comes after the first object.\n", + "3. Escribe un método llamado `is_after` que tome dos objetos `Date` y devuelva `True` si el primero viene después del segundo. Crea un segundo objeto que represente el 17 de septiembre de 1933 y comprueba si viene después del primer objeto.\n", "\n", - "Hint: You might find it useful write a method called `to_tuple` that returns a tuple that contains the attributes of a `Date` object in year-month-day order." + "Pista: Podría resultarte útil escribir un método llamado `to_tuple` que devuelva una tupla que contiene los atributos de un objeto `Date` en orden año-mes-día." ] }, { @@ -831,7 +823,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your solution." + "Puedes usar estos ejemplos para probar tu solución." ] }, { @@ -889,13 +881,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -921,4 +915,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/blank/chap16.ipynb b/blank/chap16.ipynb index 4309183..5d4deab 100644 --- a/blank/chap16.ipynb +++ b/blank/chap16.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -25,15 +25,15 @@ "id": "e826e661", "metadata": {}, "source": [ - "# Classes and Objects\n", + "# Clases y Objetos\n", "\n", - "At this point we have defined classes and created objects that represent the time of day and the day of the year.\n", - "And we've defined methods that create, modify, and perform computations with these objects.\n", + "Hasta este punto hemos definido clases y creado objetos que representan la hora del día y el día del año.\n", + "Y hemos definido métodos que crean, modifican y realizan cálculos con estos objetos.\n", "\n", - "In this chapter we'll continue our tour of object-oriented programming (OOP) by defining classes that represent geometric objects, including points, lines, rectangles, and circles.\n", - "We'll write methods that create and modify these objects, and we'll use the `jupyturtle` module to draw them.\n", + "En este capítulo continuaremos nuestro recorrido por la programación orientada a objetos (OOP) definiendo clases que representan objetos geométricos, incluidos puntos, líneas, rectángulos y círculos.\n", + "Escribiremos métodos que crean y modifican estos objetos, y usaremos el module `jupyturtle` para dibujarlos.\n", "\n", - "I'll use these classes to demonstrate OOP topics including object identity and equivalence, shallow and deep copying, and polymorphism." + "Usaré estas clases para demostrar temas de OOP, incluida la identidad y equivalencia de objetos, las copias superficiales y profundas, y el polimorfismo." ] }, { @@ -43,22 +43,22 @@ "tags": [] }, "source": [ - "## Creating a Point\n", + "## Crear un Point\n", "\n", - "In computer graphics a location on the screen is often represented using a pair of coordinates in an `x`-`y` plane.\n", - "By convention, the point `(0, 0)` usually represents the upper-left corner of the screen, and `(x, y)` represents the point `x` units to the right and `y` units down from the origin.\n", - "Compared to the Cartesian coordinate system you might have seen in a math class, the `y` axis is upside-down.\n", + "En gráficos por computadora, una ubicación en la pantalla a menudo se representa usando un par de coordenadas en un plano `x`-`y`.\n", + "Por convención, el punto `(0, 0)` suele representar la esquina superior izquierda de la pantalla, y `(x, y)` representa el punto que está `x` unidades a la derecha e `y` unidades hacia abajo desde el origen.\n", + "Comparado con el sistema de coordenadas cartesianas que quizá hayas visto en una clase de matemáticas, el eje `y` está al revés.\n", "\n", - "There are several ways we might represent a point in Python:\n", + "Hay varias formas en que podríamos representar un punto en Python:\n", "\n", - "- We can store the coordinates separately in two variables, `x` and `y`.\n", + "- Podemos almacenar las coordenadas por separado en dos variables, `x` e `y`.\n", "\n", - "- We can store the coordinates as elements in a list or tuple.\n", + "- Podemos almacenar las coordenadas como elementos en una lista o tupla.\n", "\n", - "- We can create a new type to represent points as objects.\n", + "- Podemos crear un nuevo tipo para representar puntos como objetos.\n", "\n", - "In object-oriented programming, it would be most idiomatic to create a new type.\n", - "To do that, we'll start with a class definition for `Point`." + "En programación orientada a objetos, lo más idiomático sería crear un nuevo tipo.\n", + "Para hacerlo, empezaremos con una definición de clase para `Point`." ] }, { @@ -74,10 +74,10 @@ "id": "3d35a095", "metadata": {}, "source": [ - "The `__init__` method takes the coordinates as parameters and assigns them to attributes `x` and `y`.\n", - "The `__str__` method returns a string representation of the `Point`.\n", + "El método `__init__` toma las coordenadas como parámetros y las asigna a los atributos `x` e `y`.\n", + "El método `__str__` devuelve una representación en string del `Point`.\n", "\n", - "Now we can instantiate and display a `Point` object like this." + "Ahora podemos instanciar y mostrar un objeto `Point` así." ] }, { @@ -93,7 +93,7 @@ "id": "b3fd8858", "metadata": {}, "source": [ - "The following diagram shows the state of the new object. " + "El siguiente diagrama muestra el estado del nuevo objeto. " ] }, { @@ -121,9 +121,9 @@ "id": "713b7410", "metadata": {}, "source": [ - "As usual, a programmer-defined type is represented by a box with the name of the type outside and the attributes inside.\n", + "Como de costumbre, un tipo definido por el programador se representa con una caja con el nombre del tipo fuera y los atributos dentro.\n", "\n", - "In general, programmer-defined types are mutable, so we can write a method like `translate` that takes two numbers, `dx` and `dy`, and adds them to the attributes `x` and `y`." + "En general, los tipos definidos por el programador son mutables, así que podemos escribir un método como `translate` que tome dos números, `dx` y `dy`, y los sume a los atributos `x` e `y`." ] }, { @@ -139,8 +139,8 @@ "id": "4d183292", "metadata": {}, "source": [ - "This function translates the `Point` from one location in the plane to another.\n", - "If we don't want to modify an existing `Point`, we can use `copy` to copy the original object and then modify the copy." + "Esta función traslada el `Point` de una ubicación del plano a otra.\n", + "Si no queremos modificar un `Point` existente, podemos usar `copy` para copiar el objeto original y luego modificar la copia." ] }, { @@ -156,7 +156,7 @@ "id": "562567c2", "metadata": {}, "source": [ - "We can encapsulate those steps in another method called `translated`." + "Podemos encapsular esos pasos en otro método llamado `translated`." ] }, { @@ -172,9 +172,9 @@ "id": "a7a635ee", "metadata": {}, "source": [ - "In the same way that the built in function `sort` modifies a list, and the `sorted` function creates a new list, now we have a `translate` method that modifies a `Point` and a `translated` method that creates a new one.\n", + "De la misma manera que la función integrada `sort` modifica una lista, y la función `sorted` crea una lista nueva, ahora tenemos un método `translate` que modifica un `Point` y un método `translated` que crea uno nuevo.\n", "\n", - "Here's an example:" + "Aquí hay un ejemplo:" ] }, { @@ -190,7 +190,7 @@ "id": "923362d2", "metadata": {}, "source": [ - "In the next section, we'll use these points to define and draw a line." + "En la siguiente sección, usaremos estos puntos para definir y dibujar una línea." ] }, { @@ -198,10 +198,10 @@ "id": "837f98fd", "metadata": {}, "source": [ - "## Creating a Line\n", + "## Crear una Line\n", "\n", - "Now let's define a class that represents the line segment between two points.\n", - "As usual, we'll start with an `__init__` method and a `__str__` method." + "Ahora definamos una clase que representa el segmento de línea entre dos puntos.\n", + "Como de costumbre, empezaremos con un método `__init__` y un método `__str__`." ] }, { @@ -217,7 +217,7 @@ "id": "d7dad30e", "metadata": {}, "source": [ - "With those two methods, we can instantiate and display a `Line` object we'll use to represent the `x` axis." + "Con esos dos métodos, podemos instanciar y mostrar un objeto `Line` que usaremos para representar el eje `x`." ] }, { @@ -233,16 +233,16 @@ "id": "e7b5fd9a", "metadata": {}, "source": [ - "When we call `print` and pass `line` as a parameter, `print` invokes `__str__` on `line`.\n", - "The `__str__` method uses an f-string to create a string representation of the `line`. \n", + "Cuando llamamos a `print` y pasamos `line` como parámetro, `print` invoca `__str__` sobre `line`.\n", + "El método `__str__` usa un f-string para crear una representación en string de la `line`. \n", "\n", - "The f-string contains two expressions in curly braces, `self.p1` and `self.p2`.\n", - "When those expressions are evaluated, the results are `Point` objects.\n", - "Then, when they are converted to strings, the `__str__` method from the `Point` class gets invoked.\n", + "El f-string contiene dos expresiones entre llaves, `self.p1` y `self.p2`.\n", + "Cuando se evalúan esas expresiones, los resultados son objetos `Point`.\n", + "Luego, cuando se convierten a strings, se invoca el método `__str__` de la clase `Point`.\n", "\n", - "That's why, when we display a `Line`, the result contains the string representations of the `Point` objects.\n", + "Por eso, cuando mostramos una `Line`, el resultado contiene las representaciones en string de los objetos `Point`.\n", "\n", - "The following object diagram shows the state of this `Line` object." + "El siguiente diagrama de objeto muestra el estado de este objeto `Line`." ] }, { @@ -270,17 +270,17 @@ "id": "079859b5", "metadata": {}, "source": [ - "String representations and object diagrams are useful for debugging, but the point of this example is to generate graphics, not text!\n", - "So we'll use the `jupyturtle` module to draw lines on the screen.\n", + "Las representaciones en string y los diagramas de objeto son útiles para depurar, ¡pero el objetivo de este ejemplo es generar gráficos, no texto!\n", + "Así que usaremos el module `jupyturtle` para dibujar líneas en la pantalla.\n", "\n", - "As we did in [Chapter 4](section_turtle_module), we'll use `make_turtle` to create a `Turtle` object and a small canvas where it can draw.\n", - "To draw lines, we'll use two new functions from the `jupyturtle` module:\n", + "Como hicimos en el [Capítulo 4](section_turtle_module), usaremos `make_turtle` para crear un objeto `Turtle` y un canvas pequeño donde pueda dibujar.\n", + "Para dibujar líneas, usaremos dos funciones nuevas del module `jupyturtle`:\n", "\n", - "* `jumpto`, which takes two coordinates and moves the `Turtle` to the given location without drawing a line, and \n", + "* `jumpto`, que toma dos coordenadas y mueve la `Turtle` a la ubicación dada sin dibujar una línea, y \n", "\n", - "* `moveto`, which moves the `Turtle` from its current location to the given location, and draws a line segment between them.\n", + "* `moveto`, que mueve la `Turtle` desde su ubicación actual a la ubicación dada, y dibuja un segmento de línea entre ellas.\n", "\n", - "Here's how we import them." + "Así es como las importamos." ] }, { @@ -296,7 +296,7 @@ "id": "9d2dd88f", "metadata": {}, "source": [ - "And here's a method that draws a `Line`." + "Y aquí hay un método que dibuja una `Line`." ] }, { @@ -312,7 +312,7 @@ "id": "2341f0e0", "metadata": {}, "source": [ - "To show how it's used, I'll create a second line that represents the `y` axis." + "Para mostrar cómo se usa, crearé una segunda línea que representa el eje `y`." ] }, { @@ -328,7 +328,7 @@ "id": "d7450736", "metadata": {}, "source": [ - "And then draw the axes." + "Y luego dibujamos los ejes." ] }, { @@ -344,8 +344,8 @@ "id": "473c156f", "metadata": {}, "source": [ - "As we define and draw more objects, we'll use these lines again.\n", - "But first let's talk about object equivalence and identity." + "A medida que definamos y dibujemos más objetos, usaremos estas líneas otra vez.\n", + "Pero primero hablemos de equivalencia e identidad de objetos." ] }, { @@ -353,9 +353,9 @@ "id": "950da673", "metadata": {}, "source": [ - "## Equivalence and identity\n", + "## Equivalencia e identidad\n", "\n", - "Suppose we create two points with the same coordinates." + "Supongamos que creamos dos puntos con las mismas coordenadas." ] }, { @@ -371,7 +371,7 @@ "id": "82b14526", "metadata": {}, "source": [ - "If we use the `==` operator to compare them, we get the default behavior for programmer-defined types -- the result is `True` only if they are the same object, which they are not." + "Si usamos el operador `==` para compararlos, obtenemos el comportamiento por defecto para tipos definidos por el programador -- el resultado es `True` solo si son el mismo objeto, y no lo son." ] }, { @@ -387,7 +387,7 @@ "id": "96be0ff8", "metadata": {}, "source": [ - "If we want to change that behavior, we can provide a special method called `__eq__` that defines what it means for two `Point` objects to be equal." + "Si queremos cambiar ese comportamiento, podemos proporcionar un método especial llamado `__eq__` que define qué significa que dos objetos `Point` sean iguales." ] }, { @@ -403,8 +403,8 @@ "id": "7f4409de", "metadata": {}, "source": [ - "This definition considers two `Points` to be equal if their attributes are equal.\n", - "Now when we use the `==` operator, it invokes the `__eq__` method, which indicates that `p1` and `p2` are considered equal." + "Esta definición considera que dos `Points` son iguales si sus atributos son iguales.\n", + "Ahora, cuando usamos el operador `==`, invoca el método `__eq__`, que indica que `p1` y `p2` se consideran iguales." ] }, { @@ -420,7 +420,7 @@ "id": "52662e6a", "metadata": {}, "source": [ - "But the `is` operator still indicates that they are different objects." + "Pero el operador `is` todavía indica que son objetos diferentes." ] }, { @@ -436,9 +436,9 @@ "id": "c008d3dd", "metadata": {}, "source": [ - "It's not possible to override the `is` operator -- it always checks whether the objects are identical.\n", - "But for programmer-defined types, you can override the `==` operator so it checks whether the objects are equivalent.\n", - "And you can define what equivalent means." + "No es posible sobrescribir el operador `is` -- siempre comprueba si los objetos son idénticos.\n", + "Pero para tipos definidos por el programador, puedes sobrescribir el operador `==` para que compruebe si los objetos son equivalentes.\n", + "Y puedes definir qué significa equivalente." ] }, { @@ -446,20 +446,20 @@ "id": "893a8cab", "metadata": {}, "source": [ - "## Creating a Rectangle\n", + "## Crear un Rectangle\n", "\n", - "Now let's define a class that represents and draws rectangles.\n", - "To keep things simple, we'll assume that the rectangles are either vertical or horizontal, not at an angle.\n", - "What attributes do you think we should use to specify the location and size of a rectangle?\n", + "Ahora definamos una clase que representa y dibuja rectángulos.\n", + "Para simplificar las cosas, asumiremos que los rectángulos son verticales u horizontales, no inclinados.\n", + "¿Qué atributos crees que deberíamos usar para especificar la ubicación y el tamaño de un rectángulo?\n", "\n", - "There are at least two possibilities:\n", + "Hay al menos dos posibilidades:\n", "\n", - "- You could specify the width and height of the rectangle and the location of one corner.\n", + "- Podrías especificar el ancho y alto del rectángulo y la ubicación de una esquina.\n", "\n", - "- You could specify two opposing corners.\n", + "- Podrías especificar dos esquinas opuestas.\n", "\n", - "At this point it's hard to say whether either is better than the other, so let's implement the first one.\n", - "Here is the class definition." + "En este punto es difícil decir si una es mejor que la otra, así que implementemos la primera.\n", + "Aquí está la definición de la clase." ] }, { @@ -475,8 +475,8 @@ "id": "df2852f3", "metadata": {}, "source": [ - "As usual, the `__init__` method assigns the parameters to attributes and the `__str__` returns a string representation of the object.\n", - "Now we can instantiate a `Rectangle` object, using a `Point` as the location of the upper-left corner." + "Como de costumbre, el método `__init__` asigna los parámetros a atributos y `__str__` devuelve una representación en string del objeto.\n", + "Ahora podemos instanciar un objeto `Rectangle`, usando un `Point` como ubicación de la esquina superior izquierda." ] }, { @@ -492,7 +492,7 @@ "id": "a9e0b5ec", "metadata": {}, "source": [ - "The following diagram shows the state of this object." + "El siguiente diagrama muestra el estado de este objeto." ] }, { @@ -520,7 +520,7 @@ "id": "bb54e6b5", "metadata": {}, "source": [ - "To draw a rectangle, we'll use the following method to make four `Point` objects to represent the corners." + "Para dibujar un rectángulo, usaremos el siguiente método para crear cuatro objetos `Point` que representen las esquinas." ] }, { @@ -536,7 +536,7 @@ "id": "20dbe0cb", "metadata": {}, "source": [ - "Then we'll make four `Line` objects to represent the sides." + "Luego crearemos cuatro objetos `Line` para representar los lados." ] }, { @@ -552,7 +552,7 @@ "id": "30fe41cc", "metadata": {}, "source": [ - "Then we'll draw the sides." + "Luego dibujaremos los lados." ] }, { @@ -568,7 +568,7 @@ "id": "390ba3e7", "metadata": {}, "source": [ - "Here's an example." + "Aquí hay un ejemplo." ] }, { @@ -584,7 +584,7 @@ "id": "532a4f69", "metadata": {}, "source": [ - "The figure includes two lines to represent the axes." + "La figura incluye dos líneas para representar los ejes." ] }, { @@ -592,13 +592,13 @@ "id": "0e713a90", "metadata": {}, "source": [ - "## Changing rectangles\n", + "## Cambiar rectángulos\n", "\n", - "Now let's consider two methods that modify rectangles, `grow` and `translate`.\n", - "We'll see that `grow` works as expected, but `translate` has a subtle bug.\n", - "See if you can figure it out before I explain.\n", + "Ahora consideremos dos métodos que modifican rectángulos, `grow` y `translate`.\n", + "Veremos que `grow` funciona como se esperaba, pero `translate` tiene un error sutil.\n", + "A ver si puedes descubrirlo antes de que lo explique.\n", "\n", - "`grow` takes two numbers, `dwidth` and `dheight`, and adds them to the `width` and `height` attributes of the rectangle." + "`grow` toma dos números, `dwidth` y `dheight`, y los suma a los atributos `width` y `height` del rectángulo." ] }, { @@ -614,7 +614,7 @@ "id": "a51913e2", "metadata": {}, "source": [ - "Here's an example that demonstrates the effect by making a copy of `box1` and invoking `grow` on the copy." + "Aquí hay un ejemplo que demuestra el efecto creando una copia de `box1` e invocando `grow` sobre la copia." ] }, { @@ -630,7 +630,7 @@ "id": "6d74da62", "metadata": {}, "source": [ - "If we draw `box1` and `box2`, we can confirm that `grow` works as expected." + "Si dibujamos `box1` y `box2`, podemos confirmar que `grow` funciona como se esperaba." ] }, { @@ -646,8 +646,8 @@ "id": "0c940008", "metadata": {}, "source": [ - "Now let's see about `translate`.\n", - "It takes two numbers, `dx` and `dy`, and moves the rectangle the given distances in the `x` and `y` directions. " + "Ahora veamos qué pasa con `translate`.\n", + "Toma dos números, `dx` y `dy`, y mueve el rectángulo las distancias dadas en las direcciones `x` e `y`. " ] }, { @@ -663,7 +663,7 @@ "id": "c27fe91d", "metadata": {}, "source": [ - "To demonstrate the effect, we'll translate `box2` to the right and down." + "Para demostrar el efecto, trasladaremos `box2` a la derecha y hacia abajo." ] }, { @@ -679,7 +679,7 @@ "id": "e01badbc", "metadata": {}, "source": [ - "Now let's see what happens if we draw `box1` and `box2` again." + "Ahora veamos qué pasa si dibujamos `box1` y `box2` otra vez." ] }, { @@ -695,8 +695,8 @@ "id": "5310bdd7", "metadata": {}, "source": [ - "It looks like both rectangles moved, which is not what we intended!\n", - "The next section explains what went wrong." + "Parece que ambos rectángulos se movieron, ¡que no era lo que pretendíamos!\n", + "La siguiente sección explica qué salió mal." ] }, { @@ -704,10 +704,10 @@ "id": "940adbeb", "metadata": {}, "source": [ - "## Deep copy\n", + "## Copia profunda\n", "\n", - "When we use `copy` to duplicate `box1`, it copies the `Rectangle` object but not the `Point` object it contains.\n", - "So `box1` and `box2` are different objects, as intended." + "Cuando usamos `copy` para duplicar `box1`, copia el objeto `Rectangle` pero no el objeto `Point` que contiene.\n", + "Así que `box1` y `box2` son objetos diferentes, como pretendíamos." ] }, { @@ -723,7 +723,7 @@ "id": "eac5309b", "metadata": {}, "source": [ - "But their `corner` attributes refer to the same object." + "Pero sus atributos `corner` se refieren al mismo objeto." ] }, { @@ -739,7 +739,7 @@ "id": "f0cc51b5", "metadata": {}, "source": [ - "The following diagram shows the state of these objects." + "El siguiente diagrama muestra el estado de estos objetos." ] }, { @@ -767,14 +767,14 @@ "id": "35f3e7e1", "metadata": {}, "source": [ - "What `copy` does is called a **shallow copy** because it copies the object but not the objects it contains.\n", - "As a result, changing the `width` or `height` of one `Rectangle` does not affect the other, but changing the attributes of the shared `Point` affects both!\n", - "This behavior is confusing and error-prone.\n", + "Lo que hace `copy` se llama **copia superficial** porque copia el objeto pero no los objetos que contiene.\n", + "Como resultado, cambiar el `width` o `height` de un `Rectangle` no afecta al otro, ¡pero cambiar los atributos del `Point` compartido afecta a ambos!\n", + "Este comportamiento es confuso y propenso a errores.\n", "\n", - "Fortunately, the `copy` module provides another function, called `deepcopy`, that copies not only the object but also the objects it refers to, and the objects *they* refer to, and so on. \n", - "This operation is called a **deep copy**.\n", + "Afortunadamente, el module `copy` proporciona otra función, llamada `deepcopy`, que copia no solo el objeto sino también los objetos a los que se refiere, y los objetos a los que *ellos* se refieren, y así sucesivamente. \n", + "Esta operación se llama **copia profunda**.\n", "\n", - "To demonstrate, let's start with a new `Rectangle` that contains a new `Point`." + "Para demostrarlo, empecemos con un nuevo `Rectangle` que contiene un nuevo `Point`." ] }, { @@ -790,7 +790,7 @@ "id": "ff9ee872", "metadata": {}, "source": [ - "And we'll make a deep copy." + "Y haremos una copia profunda." ] }, { @@ -806,7 +806,7 @@ "id": "7efd0e6a", "metadata": {}, "source": [ - "We can confirm that the two `Rectangle` objects refer to different `Point` objects." + "Podemos confirmar que los dos objetos `Rectangle` se refieren a objetos `Point` diferentes." ] }, { @@ -822,8 +822,8 @@ "id": "ca925206", "metadata": {}, "source": [ - "Because `box3` and `box4` are completely separate objects, we can modify one without affecting the other.\n", - "To demonstrate, we'll move `box3` and grow `box4`." + "Como `box3` y `box4` son objetos completamente separados, podemos modificar uno sin afectar al otro.\n", + "Para demostrarlo, moveremos `box3` y haremos crecer `box4`." ] }, { @@ -839,7 +839,7 @@ "id": "3ff31c7c", "metadata": {}, "source": [ - "And we can confirm that the effect is as expected." + "Y podemos confirmar que el efecto es el esperado." ] }, { @@ -855,10 +855,10 @@ "id": "67051d62", "metadata": {}, "source": [ - "## Polymorphism\n", + "## Polimorfismo\n", "\n", - "In the previous example, we invoked the `draw` method on two `Line` objects and two `Rectangle` objects.\n", - "We can do the same thing more concisely by making a list of objects." + "En el ejemplo anterior, invocamos el método `draw` sobre dos objetos `Line` y dos objetos `Rectangle`.\n", + "Podemos hacer lo mismo de forma más concisa creando una lista de objetos." ] }, { @@ -874,7 +874,7 @@ "id": "773955dd", "metadata": {}, "source": [ - "The elements of this list are different types, but they all provide a `draw` method, so we can loop through the list and invoke `draw` on each one." + "Los elementos de esta lista son de tipos diferentes, pero todos proporcionan un método `draw`, así que podemos recorrer la lista e invocar `draw` sobre cada uno." ] }, { @@ -890,17 +890,17 @@ "id": "a1ae190c", "metadata": {}, "source": [ - "The first and second time through the loop, `shape` refers to a `Line` object, so when `draw` is invoked, the method that runs is the one defined in the `Line` class.\n", + "La primera y segunda vez a través del bucle, `shape` se refiere a un objeto `Line`, así que cuando se invoca `draw`, el método que se ejecuta es el definido en la clase `Line`.\n", "\n", - "The third and fourth time through the loop, `shape` refers to a `Rectangle` object, so when `draw` is invoked, the method that runs is the one defined in the `Rectangle` class.\n", + "La tercera y cuarta vez a través del bucle, `shape` se refiere a un objeto `Rectangle`, así que cuando se invoca `draw`, el método que se ejecuta es el definido en la clase `Rectangle`.\n", "\n", - "In a sense, each object knows how to draw itself.\n", - "This feature is called **polymorphism**.\n", - "The word comes from Greek roots that mean \"many shaped\".\n", - "In object-oriented programming, polymorphism is the ability of different types to provide the same methods, which makes it possible to perform many computations -- like drawing shapes -- by invoking the same method on different types of objects.\n", + "En cierto sentido, cada objeto sabe cómo dibujarse a sí mismo.\n", + "Esta característica se llama **polimorfismo**.\n", + "La palabra viene de raíces griegas que significan \"muchas formas\".\n", + "En programación orientada a objetos, el polimorfismo es la capacidad de diferentes tipos para proporcionar los mismos métodos, lo que hace posible realizar muchos cálculos -- como dibujar formas -- invocando el mismo método sobre objetos de tipos diferentes.\n", "\n", - "As an exercise at the end of this chapter, you'll define a new class that represents a circle and provides a `draw` method.\n", - "Then you can use polymorphism to draw lines, rectangles, and circles." + "Como ejercicio al final de este capítulo, definirás una nueva clase que representa un círculo y proporciona un método `draw`.\n", + "Luego puedes usar polimorfismo para dibujar líneas, rectángulos y círculos." ] }, { @@ -908,15 +908,15 @@ "id": "74d1b48f", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "In this chapter, we ran into a subtle bug that happened because we created a `Point` that was shared by two `Rectangle` objects, and then we modified the `Point`.\n", - "In general, there are two ways to avoid problems like this: you can avoid sharing objects or you can avoid modifying them.\n", + "En este capítulo, nos encontramos con un error sutil que ocurrió porque creamos un `Point` que era compartido por dos objetos `Rectangle`, y luego modificamos el `Point`.\n", + "En general, hay dos formas de evitar problemas como este: puedes evitar compartir objetos o puedes evitar modificarlos.\n", "\n", - "To avoid sharing objects, you can use deep copy, as we did in this chapter.\n", + "Para evitar compartir objetos, puedes usar copia profunda, como hicimos en este capítulo.\n", "\n", - "To avoid modifying objects, consider replacing impure functions like `translate` with pure functions like `translated`.\n", - "For example, here's a version of `translated` that creates a new `Point` and never modifies its attributes." + "Para evitar modificar objetos, considera reemplazar funciones impuras como `translate` por funciones puras como `translated`.\n", + "Por ejemplo, aquí hay una versión de `translated` que crea un nuevo `Point` y nunca modifica sus atributos." ] }, { @@ -932,11 +932,11 @@ "id": "76972167", "metadata": {}, "source": [ - "Python provides features that make it easier to avoid modifying objects.\n", - "They are beyond the scope of this book, but if you are curious, ask a virtual assistant, \"How do I make a Python object immutable?\"\n", + "Python proporciona funcionalidades que hacen más fácil evitar modificar objetos.\n", + "Están fuera del alcance de este libro, pero si tienes curiosidad, pregunta a un asistente virtual: \"¿Cómo hago que un objeto de Python sea inmutable?\"\n", "\n", - "Creating a new object takes more time than modifying an existing one, but the difference seldom matters in practice.\n", - "Programs that avoid shared objects and impure functions are often easier to develop, test, and debug -- and the best kind of debugging is the kind you don't have to do." + "Crear un objeto nuevo toma más tiempo que modificar uno existente, pero la diferencia rara vez importa en la práctica.\n", + "Los programas que evitan objetos compartidos y funciones impuras suelen ser más fáciles de desarrollar, probar y depurar -- y la mejor depuración es el que no tienes que hacer." ] }, { @@ -944,16 +944,16 @@ "id": "02106995", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**shallow copy:**\n", - "A copy operation that does not copy nested objects.\n", + "**copia superficial:**\n", + "Una operación de copia que no copia objetos anidados.\n", "\n", - "**deep copy:**\n", - "A copy operation that also copies nested objects.\n", + "**copia profunda:**\n", + "Una operación de copia que también copia objetos anidados.\n", "\n", - "**polymorphism:**\n", - "The ability of a method or operator to work with multiple types of objects." + "**polimorfismo:**\n", + "La capacidad de un método u operador para funcionar con múltiples tipos de objetos." ] }, { @@ -961,7 +961,7 @@ "id": "09dd41c1", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -979,10 +979,10 @@ "id": "da0aea86", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "For all of the following exercises, consider asking a virtual assistant for help.\n", - "If you do, you'll want include as part of the prompt the class definitions for `Point`, `Line`, and `Rectangle` -- otherwise the VA will make a guess about their attributes and functions, and the code it generates won't work." + "Para todos los ejercicios siguientes, considera pedir ayuda a un asistente virtual.\n", + "Si lo haces, querrás incluir como parte del prompt las definiciones de clase para `Point`, `Line` y `Rectangle` -- de lo contrario el AV hará una suposición sobre sus atributos y funciones, y el código que genere no funcionará." ] }, { @@ -990,9 +990,9 @@ "id": "7721e47b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an `__eq__` method for the `Line` class that returns `True` if the `Line` objects refer to `Point` objects that are equivalent, in either order." + "Escribe un método `__eq__` para la clase `Line` que devuelva `True` si los objetos `Line` se refieren a objetos `Point` que son equivalentes, en cualquier orden." ] }, { @@ -1002,7 +1002,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1032,7 +1032,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your code." + "Puedes usar estos ejemplos para probar tu código." ] }, { @@ -1052,7 +1052,7 @@ "tags": [] }, "source": [ - "This example should be `True` because the `Line` objects refer to `Point` objects that are equivalent, in the same order." + "Este ejemplo debería ser `True` porque los objetos `Line` se refieren a objetos `Point` que son equivalentes, en el mismo orden." ] }, { @@ -1072,7 +1072,7 @@ "tags": [] }, "source": [ - "This example should be `True` because the `Line` objects refer to `Point` objects that are equivalent, in reverse order." + "Este ejemplo debería ser `True` porque los objetos `Line` se refieren a objetos `Point` que son equivalentes, en orden inverso." ] }, { @@ -1092,7 +1092,7 @@ "tags": [] }, "source": [ - "Equivalence should always be transitive -- that is, if `line_a` and `line_b` are equivalent, and `line_a` and `line_c` are equivalent, then `line_b` and `line_c` should also be equivalent." + "La equivalencia siempre debería ser transitiva -- es decir, si `line_a` y `line_b` son equivalentes, y `line_a` y `line_c` son equivalentes, entonces `line_b` y `line_c` también deberían ser equivalentes." ] }, { @@ -1112,7 +1112,7 @@ "tags": [] }, "source": [ - "This example should be `False` because the `Line` objects refer to `Point` objects that are not equivalent." + "Este ejemplo debería ser `False` porque los objetos `Line` se refieren a objetos `Point` que no son equivalentes." ] }, { @@ -1130,9 +1130,9 @@ "id": "0e629491", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Line` method called `midpoint` that computes the midpoint of a line segment and returns the result as a `Point` object." + "Escribe un método de `Line` llamado `midpoint` que calcule el punto medio de un segmento de línea y devuelva el resultado como un objeto `Point`." ] }, { @@ -1142,7 +1142,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1172,7 +1172,7 @@ "tags": [] }, "source": [ - "You can use the following examples to test your code and draw the result." + "Puedes usar los siguientes ejemplos para probar tu código y dibujar el resultado." ] }, { @@ -1230,9 +1230,9 @@ "id": "0518c200", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Rectangle` method called `midpoint` that find the point in the center of a rectangle and returns the result as a `Point` object." + "Escribe un método de `Rectangle` llamado `midpoint` que encuentre el punto en el centro de un rectángulo y devuelva el resultado como un objeto `Point`." ] }, { @@ -1242,7 +1242,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1272,7 +1272,7 @@ "tags": [] }, "source": [ - "You can use the following example to test your code." + "Puedes usar el siguiente ejemplo para probar tu código." ] }, { @@ -1320,15 +1320,15 @@ "id": "00cbc4d9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Rectangle` method called `make_cross` that:\n", + "Escribe un método de `Rectangle` llamado `make_cross` que:\n", "\n", - "1. Uses `make_lines` to get a list of `Line` objects that represent the four sides of the rectangle.\n", + "1. Use `make_lines` para obtener una lista de objetos `Line` que representan los cuatro lados del rectángulo.\n", "\n", - "2. Computes the midpoints of the four lines.\n", + "2. Calcule los puntos medios de las cuatro líneas.\n", "\n", - "3. Makes and returns a list of two `Line` objects that represent lines connecting opposite midpoints, forming a cross through the middle of the rectangle." + "3. Cree y devuelva una lista de dos objetos `Line` que representan líneas que conectan puntos medios opuestos, formando una cruz por el centro del rectángulo." ] }, { @@ -1338,7 +1338,7 @@ "tags": [] }, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar." ] }, { @@ -1368,7 +1368,7 @@ "tags": [] }, "source": [ - "You can use the following example to test your code." + "Puedes usar el siguiente ejemplo para probar tu código." ] }, { @@ -1406,10 +1406,10 @@ "id": "0f707fe3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a definition for a class named `Circle` with attributes `center` and `radius`, where `center` is a Point object and `radius` is a number.\n", - "Include special methods `__init__` and a `__str__`, and a method called `draw` that uses `jupyturtle` functions to draw the circle." + "Escribe una definición para una clase llamada `Circle` con atributos `center` y `radius`, donde `center` es un objeto Point y `radius` es un número.\n", + "Incluye los métodos especiales `__init__` y `__str__`, y un método llamado `draw` que use funciones de `jupyturtle` para dibujar el círculo." ] }, { @@ -1419,7 +1419,7 @@ "tags": [] }, "source": [ - "You can use the following function, which is a version of the `circle` function we wrote in Chapter 4." + "Puedes usar la siguiente función, que es una versión de la función `circle` que escribimos en el Capítulo 4." ] }, { @@ -1447,8 +1447,8 @@ "tags": [] }, "source": [ - "You can use the following example to test your code.\n", - "We'll start with a square `Rectangle` with width and height `100`." + "Puedes usar el siguiente ejemplo para probar tu código.\n", + "Empezaremos con un `Rectangle` cuadrado con `width` y `height` `100`." ] }, { @@ -1468,7 +1468,7 @@ "tags": [] }, "source": [ - "The following code should create a `Circle` that fits inside the square." + "El siguiente código debería crear un `Circle` que encaje dentro del cuadrado." ] }, { @@ -1488,7 +1488,7 @@ "tags": [] }, "source": [ - "If everything worked correctly, the following code should draw the circle inside the square (touching on all four sides)." + "Si todo funcionó correctamente, el siguiente código debería dibujar el círculo dentro del cuadrado (tocando los cuatro lados)." ] }, { @@ -1516,13 +1516,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -1548,4 +1550,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/blank/chap17.ipynb b/blank/chap17.ipynb index bc6b43e..79483c0 100644 --- a/blank/chap17.ipynb +++ b/blank/chap17.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -27,12 +27,12 @@ "tags": [] }, "source": [ - "# Inheritance\n", + "# Herencia\n", "\n", - "The language feature most often associated with object-oriented programming is **inheritance**.\n", - "Inheritance is the ability to define a new class that is a modified version of an existing class.\n", - "In this chapter I demonstrate inheritance using classes that represent playing cards, decks of cards, and poker hands.\n", - "If you don't play poker, don't worry -- I'll tell you what you need to know." + "La característica del lenguaje que más a menudo se asocia con la programación orientada a objetos es la **herencia**.\n", + "La herencia es la capacidad de definir una nueva clase que es una versión modificada de una clase existente.\n", + "En este capítulo demuestro la herencia usando clases que representan cartas de juego, barajas de cartas y manos de póker.\n", + "Si no juegas al póker, no te preocupes: te diré lo que necesitas saber." ] }, { @@ -40,21 +40,21 @@ "id": "b19c4dae", "metadata": {}, "source": [ - "## Representing cards\n", + "## Representar cartas\n", "\n", - "There are 52 playing cards in a standard deck -- each of them belongs to one of four suits and one of thirteen ranks. \n", - "The suits are Spades, Hearts, Diamonds, and Clubs.\n", - "The ranks are Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, and King.\n", - "Depending on which game you are playing, an Ace can be higher than King or lower than 2.\n", + "Hay 52 cartas en una baraja estándar; cada una pertenece a uno de cuatro palos y a uno de trece rangos.\n", + "Los palos son Spades, Hearts, Diamonds y Clubs.\n", + "Los rangos son Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen y King.\n", + "Dependiendo del juego al que estés jugando, un Ace puede ser más alto que King o más bajo que 2.\n", "\n", - "If we want to define a new object to represent a playing card, it is obvious what the attributes should be: `rank` and `suit`.\n", - "It is less obvious what type the attributes should be.\n", - "One possibility is to use strings like `'Spade'` for suits and `'Queen'` for ranks.\n", - "A problem with this implementation is that it would not be easy to compare cards to see which had a higher rank or suit.\n", + "Si queremos definir un nuevo objeto para representar una carta, es obvio cuáles deberían ser los atributos: `rank` y `suit`.\n", + "Es menos obvio qué tipo deberían tener los atributos.\n", + "Una posibilidad es usar strings como `'Spade'` para los palos y `'Queen'` para los rangos.\n", + "Un problema con esta implementación es que no sería fácil comparar cartas para ver cuál tiene un rango o palo más alto.\n", "\n", - "An alternative is to use integers to **encode** the ranks and suits.\n", - "In this context, \"encode\" means that we are going to define a mapping between numbers and suits, or between numbers and ranks.\n", - "This kind of encoding is not meant to be a secret (that would be \"encryption\")." + "Una alternativa es usar enteros para **codificar** los rangos y los palos.\n", + "En este contexto, \"codificar\" significa que vamos a definir una correspondencia entre números y palos, o entre números y rangos.\n", + "Este tipo de codificación no pretende ser secreta (eso sería \"cifrado\")." ] }, { @@ -62,17 +62,17 @@ "id": "a9bafecf", "metadata": {}, "source": [ - "For example, this table shows the suits and the corresponding integer codes:\n", + "Por ejemplo, esta tabla muestra los palos y los códigos enteros correspondientes:\n", "\n", "\n", - "| Suit | Code |\n", + "| Palo | Código |\n", "| --- | --- |\n", "| Spades | 3 |\n", "| Hearts | 2 |\n", "| Diamonds | 1 |\n", "| Clubs | 0 |\n", "\n", - "With this encoding, we can compare suits by comparing their codes." + "Con esta codificación, podemos comparar palos comparando sus códigos." ] }, { @@ -80,21 +80,21 @@ "id": "a1b46b1a", "metadata": {}, "source": [ - "To encode the ranks, we'll use the integer `2` to represent the rank `2`, `3` to represent `3`, and so on up to `10`.\n", - "The following table shows the codes for the face cards.\n", + "Para codificar los rangos, usaremos el entero `2` para representar el rango `2`, `3` para representar `3`, y así sucesivamente hasta `10`.\n", + "La siguiente tabla muestra los códigos para las figuras.\n", "\n", " \n", - "| Rank | Code |\n", + "| Rango | Código |\n", "| --- | --- |\n", "| Jack | 11 |\n", "| Queen | 12 |\n", "| King | 13 |\n", "\n", - "And we can use either `1` or `14` to represent an Ace, depending on whether we want it to be considered lower or higher than the other ranks.\n", + "Y podemos usar `1` o `14` para representar un Ace, dependiendo de si queremos que se considere más bajo o más alto que los demás rangos.\n", "\n", - "To represent these encodings, we will use two lists of strings, one with the names of the suits and the other with the names of the ranks.\n", + "Para representar estas codificaciones, usaremos dos listas de strings, una con los nombres de los palos y otra con los nombres de los rangos.\n", "\n", - "Here's a definition for a class that represents a playing card, with these lists of strings as **class variables**, which are variables defined inside a class definition, but not inside a method." + "Aquí tienes una definición de una clase que representa una carta, con estas listas de strings como **variables de clase**, que son variables definidas dentro de una definición de clase, pero no dentro de un método." ] }, { @@ -110,9 +110,9 @@ "id": "d63f798a", "metadata": {}, "source": [ - "The first element of `rank_names` is `None` because there is no card with rank zero. By including `None` as a place-keeper, we get a list with the nice property that the index `2` maps to the string `'2'`, and so on.\n", + "El primer elemento de `rank_names` es `None` porque no hay ninguna carta con rango cero. Al incluir `None` como marcador de posición, obtenemos una lista con la práctica propiedad de que el índice `2` se corresponde con el string `'2'`, y así sucesivamente.\n", "\n", - "Class variables are associated with the class, rather than an instance of the class, so we can access them like this." + "Las variables de clase están asociadas con la clase, en lugar de con una instancia de la clase, así que podemos acceder a ellas de esta forma." ] }, { @@ -128,7 +128,7 @@ "id": "c837fff6", "metadata": {}, "source": [ - "We can use `suit_names` to look up a suit and get the corresponding string." + "Podemos usar `suit_names` para buscar un palo y obtener el string correspondiente." ] }, { @@ -144,7 +144,7 @@ "id": "a59d905e", "metadata": {}, "source": [ - "And `rank_names` to look up a rank." + "Y `rank_names` para buscar un rango." ] }, { @@ -160,9 +160,9 @@ "id": "50dda19b", "metadata": {}, "source": [ - "## Card attributes\n", + "## Atributos de las cartas\n", "\n", - "Here's an `__init__` method for the `Card` class -- it takes `suit` and `rank` as parameters and assigns them to attributes with the same names." + "Aquí tienes un método `__init__` para la clase `Card`: toma `suit` y `rank` como parámetros y los asigna a atributos con los mismos nombres." ] }, { @@ -178,7 +178,7 @@ "id": "31a2782d", "metadata": {}, "source": [ - "Now we can create a `Card` object like this." + "Ahora podemos crear un objeto `Card` así." ] }, { @@ -194,7 +194,7 @@ "id": "85e5cf5d", "metadata": {}, "source": [ - "We can use the new instance to access the attributes." + "Podemos usar la nueva instancia para acceder a los atributos." ] }, { @@ -210,7 +210,7 @@ "id": "449225d3", "metadata": {}, "source": [ - "It is also legal to use the instance to access the class variables." + "También es válido usar la instancia para acceder a las variables de clase." ] }, { @@ -226,7 +226,7 @@ "id": "97232ffa", "metadata": {}, "source": [ - "But if you use the class, it is clearer that they are class variables, not attributes." + "Pero si usas la clase, queda más claro que son variables de clase, no atributos." ] }, { @@ -234,9 +234,9 @@ "id": "7a0a79ae", "metadata": {}, "source": [ - "## Printing cards\n", + "## Imprimir cartas\n", "\n", - "Here's a `__str__` method for `Card` objects." + "Aquí tienes un método `__str__` para objetos `Card`." ] }, { @@ -252,7 +252,7 @@ "id": "d6c51352", "metadata": {}, "source": [ - "When we print a `Card`, Python calls the `__str__` method to get a human-readable representation of the card." + "Cuando imprimimos una `Card`, Python llama al método `__str__` para obtener una representación de la carta legible para humanos." ] }, { @@ -268,10 +268,10 @@ "id": "76044b9e", "metadata": {}, "source": [ - "The following is a diagram of the `Card` class object and the Card instance.\n", - "`Card` is a class object, so its type is `type`.\n", - "`queen` is an instance of `Card`, so its type is `Card`.\n", - "To save space, I didn't draw the contents of `suit_names` and `rank_names`." + "El siguiente es un diagrama del objeto de clase `Card` y de la instancia de Carta.\n", + "`Card` es un objeto de clase, así que su tipo es `type`.\n", + "`queen` es una instancia de `Card`, así que su tipo es `Card`.\n", + "Para ahorrar espacio, no dibujé el contenido de `suit_names` y `rank_names`." ] }, { @@ -299,7 +299,7 @@ "id": "ccb8e41d", "metadata": {}, "source": [ - "Every `Card` instance has its own `suit` and `rank` attributes, but there is only one `Card` class object, and only one copy of the class variables `suit_names` and `rank_names`." + "Cada instancia de `Card` tiene sus propios atributos `suit` y `rank`, pero solo hay un objeto de clase `Card` y una sola copia de las variables de clase `suit_names` y `rank_names`." ] }, { @@ -307,9 +307,9 @@ "id": "98c6508d", "metadata": {}, "source": [ - "## Comparing cards\n", + "## Comparar cartas\n", "\n", - "Suppose we create a second `Card` object with the same suit and rank." + "Supongamos que creamos un segundo objeto `Card` con el mismo palo y rango." ] }, { @@ -325,7 +325,7 @@ "id": "3c92779c", "metadata": {}, "source": [ - "If we use the `==` operator to compare them, it checks whether `queen` and `queen2` refer to the same object." + "Si usamos el operador `==` para compararlas, comprueba si `queen` y `queen2` hacen referencia al mismo objeto." ] }, { @@ -341,8 +341,8 @@ "id": "278d8abe", "metadata": {}, "source": [ - "They don't, so it returns `False`.\n", - "We can change this behavior by defining the special method `__eq__`." + "No lo hacen, así que devuelve `False`.\n", + "Podemos cambiar este comportamiento definiendo el special método `__eq__`." ] }, { @@ -358,10 +358,10 @@ "id": "bd66a9d3", "metadata": {}, "source": [ - "`__eq__` takes two `Card` objects as parameters and returns `True` if they have the same suit and rank, even if they are not the same object.\n", - "In other words, it checks whether they are equivalent, even if they are not identical.\n", + "`__eq__` toma dos objetos `Card` como parámetros y devuelve `True` si tienen el mismo palo y rango, incluso si no son el mismo objeto.\n", + "En otras palabras, comprueba si son equivalentes, aunque no sean idénticos.\n", "\n", - "When we use the `==` operator with `Card` objects, Python calls the `__eq__` method." + "Cuando usamos el operador `==` con objetos `Card`, Python llama al método `__eq__`." ] }, { @@ -377,7 +377,7 @@ "id": "23d99d3e", "metadata": {}, "source": [ - "As a second test, let's create a card with the same suit and a different rank." + "Como segunda prueba, vamos a crear una carta con el mismo palo y un rango diferente." ] }, { @@ -393,7 +393,7 @@ "id": "c5f66404", "metadata": {}, "source": [ - "We can confirm that `queen` and `six` are not equivalent." + "Podemos confirmar que `queen` y `six` no son equivalentes." ] }, { @@ -409,8 +409,8 @@ "id": "1dcb561f", "metadata": {}, "source": [ - "If we use the `!=` operator, Python invokes a special method called `__ne__`, if it exists.\n", - "Otherwise it invokes`__eq__` and inverts the result -- so if `__eq__` returns `True`, the result of the `!=` operator is `False`." + "Si usamos el operador `!=`, Python invoca un special método llamado `__ne__`, si existe.\n", + "De lo contrario, invoca `__eq__` e invierte el resultado; así que si `__eq__` devuelve `True`, el resultado del operador `!=` es `False`." ] }, { @@ -434,8 +434,8 @@ "id": "77c48464", "metadata": {}, "source": [ - "Now suppose we want to compare two cards to see which is bigger.\n", - "If we use one of the relational operators, we get a `TypeError`." + "Ahora supongamos que queremos comparar dos cartas para ver cuál es mayor.\n", + "Si usamos uno de los operadores relacionales, obtenemos un `TypeError`." ] }, { @@ -453,11 +453,11 @@ "id": "4db0ad52", "metadata": {}, "source": [ - "To change the behavior of the `<` operator, we can define a special method called `__lt__`, which is short for \"less than\".\n", - "For the sake of this example, let's assume that suit is more important than rank -- so all Spades outrank all Hearts, which outrank all Diamonds, and so on.\n", - "If two cards have the same suit, the one with the higher rank wins.\n", + "Para cambiar el comportamiento del operador `<`, podemos definir un special método llamado `__lt__`, abreviatura de \"less than\".\n", + "Para este ejemplo, supongamos que el palo es más importante que el rango: por eso todos los Spades superan a todos los Hearts, que superan a todos los Diamonds, y así sucesivamente.\n", + "Si dos cartas tienen el mismo palo, gana la que tiene el rango más alto.\n", "\n", - "To implement this logic, we'll use the following method, which returns a tuple containing a card's suit and rank, in that order." + "Para implementar esta lógica, usaremos el siguiente método, que devuelve una tupla que contiene el palo y el rango de una carta, en ese orden." ] }, { @@ -473,7 +473,7 @@ "id": "d5062348", "metadata": {}, "source": [ - "We can use this method to write `__lt__`." + "Podemos usar este método para escribir `__lt__`." ] }, { @@ -489,10 +489,10 @@ "id": "bd9ef8f5", "metadata": {}, "source": [ - "Tuple comparison compares the first elements from each tuple, which represent the suits.\n", - "If they are the same, it compares the second elements, which represent the ranks.\n", + "La comparación de tuplas compara los primeros elementos de cada tupla, que representan los palos.\n", + "Si son iguales, compara los segundos elementos, que representan los rangos.\n", "\n", - "Now if we use the `<` operator, it invokes the `__lt__` method." + "Ahora, si usamos el operador `<`, invoca el método `__lt__`." ] }, { @@ -508,8 +508,8 @@ "id": "83289a77", "metadata": {}, "source": [ - "If we use the `>` operator, it invokes a special method called `__gt__`, if it exists.\n", - "Otherwise it invokes `__lt__` with the arguments in the opposite order." + "Si usamos el operador `>`, invoca un special método llamado `__gt__`, si existe.\n", + "De lo contrario, invoca `__lt__` con los argumentos en el orden opuesto." ] }, { @@ -533,7 +533,7 @@ "id": "5d0a91de", "metadata": {}, "source": [ - "Finally, if we use the `<=` operator, it invokes a special method called `__le__`." + "Por último, si usamos el operador `<=`, invoca un special método llamado `__le__`." ] }, { @@ -549,7 +549,7 @@ "id": "6c85ac69", "metadata": {}, "source": [ - "So we can check whether one card is less than or equal to another." + "Así que podemos comprobar si una carta es menor o igual que otra." ] }, { @@ -573,7 +573,7 @@ "id": "7af7b289", "metadata": {}, "source": [ - "If we use the `>=` operator, it uses `__ge__` if it exists. Otherwise, it invokes `__le__` with the arguments in the opposite order." + "Si usamos el operador `>=`, usa `__ge__` si existe. De lo contrario, invoca `__le__` con los argumentos en el orden opuesto." ] }, { @@ -589,9 +589,9 @@ "id": "fe2a81cc", "metadata": {}, "source": [ - "As we have defined them, these methods are complete in the sense that we can compare any two `Card` objects, and consistent in the sense that results from different operators don't contradict each other.\n", - "With these two properties, we can say that `Card` objects are **totally ordered**.\n", - "And that means, as we'll see soon, that they can be sorted." + "Tal como los hemos definido, estos métodos son completos en el sentido de que podemos comparar dos objetos `Card` cualesquiera, y consistentes en el sentido de que los resultados de distintos operadores no se contradicen entre sí.\n", + "Con estas dos propiedades, podemos decir que los objetos `Card` están **totalmente ordenados**.\n", + "Y eso significa, como veremos pronto, que se pueden ordenar." ] }, { @@ -599,11 +599,10 @@ "id": "199f8bfc", "metadata": {}, "source": [ - "## Decks\n", + "## Barajas\n", "\n", - "Now that we have objects that represent cards, let's define objects that represent decks.\n", - "The following is a class definition for `Deck` with\n", - "an `__init__` method takes a list of `Card` objects as a parameter and assigns it to an attribute called `cards`." + "Ahora que tenemos objetos que representan cartas, definamos objetos que representen barajas.\n", + "La siguiente es una definición de clase para `Deck` con un método `__init__` que toma una lista de objetos `Card` como parámetro y la asigna a un atributo llamado `cards`." ] }, { @@ -619,7 +618,7 @@ "id": "2d529789", "metadata": {}, "source": [ - "To create a list that contains the 52 cards in a standard deck, we'll use the following static method." + "Para crear una lista que contiene las 52 cartas de una baraja estándar, usaremos el siguiente método estático." ] }, { @@ -635,11 +634,11 @@ "id": "47ae8f71", "metadata": {}, "source": [ - "In `make_cards`, the outer loop enumerates the suits from `0` to `3`.\n", - "The inner loop enumerates the ranks from `2` to `14` -- where `14` represents an Ace that outranks a King.\n", - "Each iteration creates a new `Card` with the current suit and rank, and appends it to `cards`.\n", + "En `make_cards`, el bucle externo enumera los palos de `0` a `3`.\n", + "El bucle interno enumera los rangos de `2` a `14`, donde `14` representa un Ace que supera a un King.\n", + "Cada iteración crea una nueva `Card` con el palo y el rango actuales, y la añade a `cards`.\n", "\n", - "Here's how we make a list of cards and a `Deck` object that contains it." + "Así es como creamos una lista de cartas y un objeto `Deck` que la contiene." ] }, { @@ -655,7 +654,7 @@ "id": "032ec302", "metadata": {}, "source": [ - "It contains 52 cards, as intended." + "Contiene 52 cartas, tal como queríamos." ] }, { @@ -665,9 +664,9 @@ "tags": [] }, "source": [ - "## Printing the deck\n", + "## Imprimir la baraja\n", "\n", - "Here is a `__str__` method for `Deck`." + "Aquí tienes un método `__str__` para `Deck`." ] }, { @@ -683,9 +682,9 @@ "id": "660f18e6", "metadata": {}, "source": [ - "This method demonstrates an efficient way to accumulate a large string -- building a list of strings and then using the string method `join`. \n", + "Este método demuestra una forma eficiente de acumular un string grande: construir una lista de strings y luego usar el método de string `join`.\n", "\n", - "We'll test this method with a deck that only contains two cards." + "Probaremos este método con una baraja que solo contiene dos cartas." ] }, { @@ -701,7 +700,7 @@ "id": "91c7145f", "metadata": {}, "source": [ - "If we call `str`, it invokes `__str__`." + "Si llamamos a `str`, invoca `__str__`." ] }, { @@ -717,9 +716,9 @@ "id": "00270656", "metadata": {}, "source": [ - "When Jupyter displays a string, it shows the \"representational\" form of the string, which represents a newline with the sequence `\\n`.\n", + "Cuando Jupyter muestra un string, enseña la forma \"representacional\" del string, que representa un salto de línea con la secuencia `\\n`.\n", "\n", - "However, if we print the result, Jupyter shows the \"printable\" form of the string, which prints the newline as whitespace." + "Sin embargo, si imprimimos el resultado, Jupyter muestra la forma \"imprimible\" del string, que imprime el salto de línea como espacio en blanco." ] }, { @@ -735,7 +734,7 @@ "id": "e97810c4", "metadata": {}, "source": [ - "So the cards appear on separate lines." + "Así que las cartas aparecen en líneas separadas." ] }, { @@ -743,11 +742,11 @@ "id": "52d3d597", "metadata": {}, "source": [ - "## Add, remove, shuffle and sort\n", + "## Añadir, quitar, barajar y ordenar\n", "\n", - "To deal cards, we would like a method that removes a card from the deck\n", - "and returns it. The list method `pop` provides a convenient way to do\n", - "that." + "Para repartir cartas, nos gustaría tener un método que quite una carta de la baraja\n", + "y la devuelva. El método de lista `pop` proporciona una forma cómoda de\n", + "hacerlo." ] }, { @@ -763,7 +762,7 @@ "id": "1fcef47b", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como lo usamos." ] }, { @@ -779,7 +778,7 @@ "id": "65427954", "metadata": {}, "source": [ - "We can confirm that there are `51` cards left in the deck." + "Podemos confirmar que quedan `51` cartas en la baraja." ] }, { @@ -795,7 +794,7 @@ "id": "7ca3614e", "metadata": {}, "source": [ - "To add a card, we can use the list method `append`." + "Para añadir una carta, podemos usar el método de lista `append`." ] }, { @@ -811,7 +810,7 @@ "id": "2ecd8703", "metadata": {}, "source": [ - "As an example, we can put back the card we just popped." + "Como ejemplo, podemos volver a poner la carta que acabamos de extraer." ] }, { @@ -827,7 +826,7 @@ "id": "8b5af8ce", "metadata": {}, "source": [ - "To shuffle the deck, we can use the `shuffle` function from the `random` module:" + "Para barajar la baraja, podemos usar la función `shuffle` del module `random`:" ] }, { @@ -861,7 +860,7 @@ "id": "a8cb1a7f", "metadata": {}, "source": [ - "If we shuffle the deck and print the first few cards, we can see that they are in no apparent order." + "Si barajamos la baraja e imprimimos las primeras cartas, podemos ver que no están en ningún orden aparente." ] }, { @@ -877,7 +876,7 @@ "id": "a198dde3", "metadata": {}, "source": [ - "To sort the cards, we can use the list method `sort`, which sorts the elements \"in place\" -- that is, it modifies the list rather than creating a new list." + "Para ordenar las cartas, podemos usar el método de lista `sort`, que ordena los elementos \"in place\"; es decir, modifica la lista en lugar de crear una lista nueva." ] }, { @@ -893,7 +892,7 @@ "id": "d4f017c7", "metadata": {}, "source": [ - "When we invoke `sort`, it uses the `__lt__` method to compare cards." + "Cuando invocamos `sort`, usa el método `__lt__` para comparar cartas." ] }, { @@ -909,7 +908,7 @@ "id": "2bb966fd", "metadata": {}, "source": [ - "If we print the first few cards, we can confirm that they are in increasing order." + "Si imprimimos las primeras cartas, podemos confirmar que están en orden creciente." ] }, { @@ -925,8 +924,8 @@ "id": "5c41ce4d", "metadata": {}, "source": [ - "In this example, `Deck.sort` doesn't do anything other than invoke `list.sort`.\n", - "Passing along responsibility like this is called **delegation**." + "En este ejemplo, `Deck.sort` no hace nada más que invocar `list.sort`.\n", + "Pasar la responsabilidad de esta forma se llama **delegación**." ] }, { @@ -934,18 +933,18 @@ "id": "0502961b", "metadata": {}, "source": [ - "## Parents and children\n", + "## Padres e hijos\n", "\n", - "Inheritance is the ability to define a new class that is a modified version of an existing class.\n", - "As an example, let's say we want a class to represent a \"hand\", that is, the cards held by one player.\n", + "La herencia es la capacidad de definir una nueva clase que es una versión modificada de una clase existente.\n", + "Como ejemplo, digamos que queremos una clase para representar una \"mano\", es decir, las cartas que tiene un jugador.\n", "\n", - "* A hand is similar to a deck -- both are made up of a collection of cards, and both require operations like adding and removing cards.\n", + "* Una mano es similar a una baraja: ambas están formadas por una colección de cartas, y ambas requieren operaciones como añadir y quitar cartas.\n", "\n", - "* A hand is also different from a deck -- there are operations we want for hands that don't make sense for a deck. For example, in poker we might compare two hands to see which one wins. In bridge, we might compute a score for a hand in order to make a bid.\n", + "* Una mano también es diferente de una baraja: hay operaciones que queremos para manos que no tienen sentido para una baraja. Por ejemplo, en póker podríamos comparar dos manos para ver cuál gana. En bridge, podríamos calcular la puntuación de una mano para hacer una apuesta.\n", "\n", - "This relationship between classes -- where one is a specialized version of another -- lends itself to inheritance. \n", + "Esta relación entre clases, donde una es una versión especializada de otra, se presta a la herencia.\n", "\n", - "To define a new class that is based on an existing class, we put the name of the existing class in parentheses." + "Para definir una nueva clase basada en una clase existente, ponemos el nombre de la clase existente entre paréntesis." ] }, { @@ -961,9 +960,9 @@ "id": "339295cd", "metadata": {}, "source": [ - "This definition indicates that `Hand` inherits from `Deck`, which means that `Hand` objects can access methods defined in `Deck`, like `take_card` and `put_card`.\n", + "Esta definición indica que `Hand` hereda de `Deck`, lo que significa que los objetos `Hand` pueden acceder a métodos definidos en `Deck`, como `take_card` y `put_card`.\n", "\n", - "`Hand` also inherits `__init__` from `Deck`, but if we define `__init__` in the `Hand` class, it overrides the one in the `Deck` class." + "`Hand` también hereda `__init__` de `Deck`, pero si definimos `__init__` en la clase `Hand`, sobrescribe el de la clase `Deck`." ] }, { @@ -979,8 +978,8 @@ "id": "9b6a763a", "metadata": {}, "source": [ - "This version of `__init__` takes an optional string as a parameter, and always starts with an empty list of cards.\n", - "When we create a `Hand`, Python invokes this method, not the one in `Deck` -- which we can confirm by checking that the result has a `label` attribute." + "Esta versión de `__init__` toma un string opcional como parámetro y siempre empieza con una lista vacía de cartas.\n", + "Cuando creamos una `Hand`, Python invoca este método, no el de `Deck`, lo que podemos confirmar comprobando que el resultado tiene un atributo `label`." ] }, { @@ -996,7 +995,7 @@ "id": "b1e2a67d", "metadata": {}, "source": [ - "To deal a card, we can use `take_card` to remove a card from a `Deck`, and `put_card` to add the card to a `Hand`." + "Para repartir una carta, podemos usar `take_card` para quitar una carta de un `Deck`, y `put_card` para añadir la carta a una `Hand`." ] }, { @@ -1012,7 +1011,7 @@ "id": "dc2ce06b", "metadata": {}, "source": [ - "Let's encapsulate this code in a `Deck` method called `move_cards`." + "Encapsulemos este código en un método de `Deck` llamado `move_cards`." ] }, { @@ -1028,8 +1027,8 @@ "id": "16e6c404", "metadata": {}, "source": [ - "This method is polymorphic -- that is, it works with more than one type: `self` and `other` can be either a `Hand` or a `Deck`.\n", - "So we can use this method to deal a card from `Deck` to a `Hand`, from one `Hand` to another, or from a `Hand` back to a `Deck`." + "Este método es polimórfico; es decir, funciona con más de un tipo: `self` y `other` pueden ser tanto una `Hand` como un `Deck`.\n", + "Así que podemos usar este método para repartir una carta de `Deck` a `Hand`, de una `Hand` a otra, o de una `Hand` de vuelta a un `Deck`." ] }, { @@ -1037,18 +1036,18 @@ "id": "e648a722", "metadata": {}, "source": [ - "When a new class inherits from an existing one, the existing one is called the **parent** and the new class is called the **child**. In general:\n", + "Cuando una nueva clase hereda de una existente, la existente se llama **padre** y la nueva clase se llama **hija**. En general:\n", "\n", - "* Instances of the child class should have all of the attributes of the parent class, but they can have additional attributes.\n", + "* Las instancias de la clase hija deberían tener todos los atributos de la clase padre, pero pueden tener atributos adicionales.\n", "\n", - "* The child class should have all of the methods of the parent class, but it can have additional methods.\n", + "* La clase hija debería tener todos los métodos de la clase padre, pero puede tener métodos adicionales.\n", "\n", - "* If a child class overrides a method from the parent class, the new method should take the same parameters and return a compatible result.\n", + "* Si una clase hija sobrescribe un método de la clase padre, el nuevo método debería tomar los mismos parámetros y devolver un resultado compatible.\n", "\n", - "This set of rules is called the \"Liskov substitution principle\" after computer scientist Barbara Liskov.\n", + "Este conjunto de reglas se llama \"principio de sustitución de Liskov\", en honor a la científica de la computación Barbara Liskov.\n", "\n", - "If you follow these rules, any function or method designed to work with an instance of a parent class, like a `Deck`, will also work with instances of a child class, like `Hand`.\n", - "If you violate these rules, your code will collapse like a house of cards (sorry)." + "Si sigues estas reglas, cualquier función o método diseñado para trabajar con una instancia de una clase padre, como un `Deck`, también funcionará con instancias de una clase hija, como `Hand`.\n", + "Si rompes estas reglas, tu código se derrumbará como un castillo de naipes (lo siento)." ] }, { @@ -1056,12 +1055,12 @@ "id": "e80873dd", "metadata": {}, "source": [ - "## Specialization\n", + "## Especialización\n", "\n", - "Let's make a class called `BridgeHand` that represents a hand in bridge -- a widely played card game.\n", - "We'll inherit from `Hand` and add a new method called `high_card_point_count` that evaluates a hand using a \"high card point\" method, which adds up points for the high cards in the hand.\n", + "Hagamos una clase llamada `BridgeHand` que representa una mano en bridge, un juego de cartas muy popular.\n", + "Heredaremos de `Hand` y añadiremos un nuevo método llamado `high_card_point_count` que evalúa una mano usando un método de \"high carta point\", que suma puntos por las cartas altas de la mano.\n", "\n", - "Here's a class definition that contains as a class variable a dictionary that maps from card names to their point values." + "Aquí tienes una definición de clase que contiene, como variable de clase, un diccionario que asigna nombres de cartas a sus valores de puntos." ] }, { @@ -1077,7 +1076,7 @@ "id": "4c038717", "metadata": {}, "source": [ - "Given the rank of a card, like `12`, we can use `Card.rank_names` to get the string representation of the rank, and then use `hcp_dict` to get its score." + "Dado el rango de una carta, como `12`, podemos usar `Card.rank_names` para obtener la representación en string del rango, y luego usar `hcp_dict` para obtener su puntuación." ] }, { @@ -1093,7 +1092,7 @@ "id": "c3a7820d", "metadata": {}, "source": [ - "The following method loops through the cards in a `BridgeHand` and adds up their scores." + "El siguiente método recorre las cartas de una `BridgeHand` y suma sus puntuaciones." ] }, { @@ -1119,7 +1118,7 @@ "id": "94535d8e", "metadata": {}, "source": [ - "To test it, we'll deal a hand with five cards -- a bridge hand usually has thirteen, but it's easier to test code with small examples." + "Para probarlo, repartiremos una mano con cinco cartas; una mano de bridge normalmente tiene trece, pero es más fácil probar código con ejemplos pequeños." ] }, { @@ -1135,7 +1134,7 @@ "id": "a1bd2521", "metadata": {}, "source": [ - "And here is the total score for the King and Queen." + "Y aquí está la puntuación total para el King y la Queen." ] }, { @@ -1151,8 +1150,8 @@ "id": "b4f5e107", "metadata": {}, "source": [ - "`BridgeHand` inherits the variables and methods of `Hand` and adds a class variable and a method that are specific to bridge.\n", - "This way of using inheritance is called **specialization** because it defines a new class that is specialized for a particular use, like playing bridge." + "`BridgeHand` hereda las variables y métodos de `Hand` y añade una variable de clase y un método que son específicos de bridge.\n", + "Esta forma de usar la herencia se llama **especialización** porque define una nueva clase especializada para un uso particular, como jugar al bridge." ] }, { @@ -1160,20 +1159,20 @@ "id": "b493622d", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Inheritance is a useful feature.\n", - "Some programs that would be repetitive without inheritance can be written more concisely with it.\n", - "Also, inheritance can facilitate code reuse, since you can customize the behavior of a parent class without having to modify it.\n", - "In some cases, the inheritance structure reflects the natural structure of the problem, which makes the design easier to understand.\n", + "La herencia es una característica útil.\n", + "Algunos programas que serían repetitivos sin herencia se pueden escribir de forma más concisa con ella.\n", + "Además, la herencia puede facilitar la reutilización de código, ya que puedes personalizar el comportamiento de una clase padre sin tener que modificarla.\n", + "En algunos casos, la estructura de herencia refleja la estructura natural del problema, lo que hace que el diseño sea más fácil de entender.\n", "\n", - "On the other hand, inheritance can make programs difficult to read.\n", - "When a method is invoked, it is sometimes not clear where to find its definition -- the relevant code may be spread across several modules.\n", + "Por otro lado, la herencia puede hacer que los programas sean difíciles de leer.\n", + "Cuando se invoca un método, a veces no está claro dónde encontrar su definición: el código relevante puede estar repartido entre varios modules.\n", "\n", - "Any time you are unsure about the flow of execution through your program, the simplest solution is to add print statements at the beginning of the relevant methods.\n", - "If `Deck.shuffle` prints a message that says something like `Running Deck.shuffle`, then as the program runs it traces the flow of execution.\n", + "Siempre que tengas dudas sobre el flujo de ejecución de tu programa, la solución más sencilla es añadir sentencias print al principio de los métodos relevantes.\n", + "Si `Deck.shuffle` imprime un mensaje que dice algo como `Running Deck.shuffle`, entonces, a medida que el programa se ejecuta, traza el flujo de ejecución.\n", "\n", - "As an alternative, you could use the following function, which takes an object and a method name (as a string) and returns the class that provides the definition of the method." + "Como alternativa, podrías usar la siguiente función, que toma un objeto y el nombre de un método (como string) y devuelve la clase que proporciona la definición del método." ] }, { @@ -1189,10 +1188,10 @@ "id": "1ee8f2da", "metadata": {}, "source": [ - "`find_defining_class` uses the `mro` method to get the list of class objects (types) that will be searched for methods.\n", - "\"MRO\" stands for \"method resolution order\", which is the sequence of classes Python searches to \"resolve\" a method name -- that is, to find the function object the name refers to.\n", + "`find_defining_class` usa el método `mro` para obtener la lista de objetos clase (tipos) que se buscarán para encontrar métodos.\n", + "\"MRO\" significa \"método resolution order\", que es la secuencia de clases que Python busca para \"resolver\" el nombre de un método; es decir, para encontrar el objeto función al que se refiere el nombre.\n", "\n", - "As an example, let's instantiate a `BridgeHand` and then find the defining class of `shuffle`." + "Como ejemplo, vamos a instanciar una `BridgeHand` y luego encontrar la clase que define `shuffle`." ] }, { @@ -1208,7 +1207,7 @@ "id": "eeb70a14", "metadata": {}, "source": [ - "The `shuffle` method for the `BridgeHand` object is the one in `Deck`." + "El método `shuffle` para el objeto `BridgeHand` es el que está en `Deck`." ] }, { @@ -1216,31 +1215,31 @@ "id": "07f4c4bb", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**inheritance:**\n", - " The ability to define a new class that is a modified version of a previously defined class.\n", + "**herencia (herencia):**\n", + " La capacidad de definir una nueva clase que es una versión modificada de una clase definida previamente.\n", "\n", - "**encode:**\n", - " To represent one set of values using another set of values by constructing a mapping between them.\n", + "**codificar (encode):**\n", + " Representar un conjunto de valores usando otro conjunto de valores construyendo una correspondencia entre ellos.\n", "\n", - "**class variable:**\n", - "A variable defined inside a class definition, but not inside any method.\n", + "**variable de clase:**\n", + "Una variable definida dentro de una definición de clase, pero no dentro de ningún método.\n", "\n", - "**totally ordered:**\n", - "A set of objects is totally ordered if we can compare any two elements and the results are consistent.\n", + "**totalmente ordenado:**\n", + "Un conjunto de objetos está totalmente ordenado si podemos comparar dos elementos cualesquiera y los resultados son consistentes.\n", "\n", - "**delegation:**\n", - "When one method passes responsibility to another method to do most or all of the work.\n", + "**delegación:**\n", + "Cuando un método pasa la responsabilidad a otro método para que haga la mayor parte o todo el trabajo.\n", "\n", - "**parent class:**\n", - "A class that is inherited from.\n", + "**clase padre:**\n", + "Una clase de la que se hereda.\n", "\n", - "**child class:**\n", - "A class that inherits from another class.\n", + "**clase hija:**\n", + "Una clase que hereda de otra clase.\n", "\n", - "**specialization:**\n", - "A way of using inheritance to create a new class that is a specialized version of an existing class." + "**especialización:**\n", + "Una forma de usar la herencia para crear una nueva clase que es una versión especializada de una clase existente." ] }, { @@ -1248,7 +1247,7 @@ "id": "1aea9b2b", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1266,25 +1265,25 @@ "id": "7913e6b1", "metadata": {}, "source": [ - "### Ask a Virtual Assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "When it goes well, object-oriented programming can make programs more readable, testable, and reusable.\n", - "But it can also make programs complicated and hard to maintain.\n", - "As a result, OOP is a topic of controversy -- some people love it, and some people don't.\n", + "Cuando sale bien, la programación orientada a objetos puede hacer que los programas sean más legibles, fáciles de probar y reutilizables.\n", + "Pero también puede hacer que los programas sean complicados y difíciles de mantener.\n", + "Como resultado, la OOP es un tema controvertido: algunas personas la adoran y a otras no les gusta.\n", "\n", - "To learn more about the topic, ask a virtual assistant:\n", + "Para aprender más sobre el tema, pregunta a un asistente virtual:\n", "\n", - "* What are some pros and cons of object-oriented programming?\n", + "* ¿Cuáles son algunas ventajas y desventajas de la programación orientada a objetos?\n", "\n", - "* What does it mean when people say \"favor composition over inheritance\"?\n", + "* ¿Qué significa cuando la gente dice \"favor composition over herencia\"?\n", "\n", - "* What is the Liskov substitution principle?\n", + "* ¿Qué es el principio de sustitución de Liskov?\n", "\n", - "* Is Python an object-oriented language?\n", + "* ¿Python es un lenguaje orientado a objetos?\n", "\n", - "* What are the requirements for a set to be totally ordered?\n", + "* ¿Cuáles son los requisitos para que un conjunto esté totalmente ordenado?\n", "\n", - "And as always, consider using a virtual assistant to help with the following exercises." + "Y, como siempre, considera usar un asistente virtual para ayudarte con los siguientes ejercicios." ] }, { @@ -1292,10 +1291,10 @@ "id": "1af81269", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In contract bridge, a \"trick\" is a round of play in which each of four players plays one card.\n", - "To represent those cards, we'll define a class that inherits from `Deck`." + "En bridge de contrato, una \"trick\" es una ronda de juego en la que cada uno de cuatro jugadores juega una carta.\n", + "Para representar esas cartas, definiremos una clase que hereda de `Deck`." ] }, { @@ -1311,10 +1310,10 @@ "id": "9916d562", "metadata": {}, "source": [ - "As an example, consider this trick, where the first player leads with the 3 of Diamonds, which means that Diamonds are the \"led suit\".\n", - "The second and third players \"follow suit\", which means they play a card with the led suit.\n", - "The fourth player plays a card of a different suit, which means they cannot win the trick.\n", - "So the winner of this trick is the third player, because they played the highest card in the led suit." + "Como ejemplo, considera esta trick, donde el primer jugador empieza con el 3 of Diamonds, lo que significa que Diamonds es el \"led suit\".\n", + "El segundo y el tercer jugador \"follow suit\", lo que significa que juegan una carta del palo que se ha iniciado.\n", + "El cuarto jugador juega una carta de un palo diferente, lo que significa que no puede ganar la trick.\n", + "Así que el ganador de esta trick es el tercer jugador, porque jugó la carta más alta del led suit." ] }, { @@ -1330,8 +1329,8 @@ "id": "c94a1337", "metadata": {}, "source": [ - "Write a `Trick` method called `find_winner` that loops through the cards in the `Trick` and returns the index of the card that wins.\n", - "In the previous example, the index of the winning card is `2`." + "Escribe un método de `Trick` llamado `find_winner` que recorra las cartas de la `Trick` y devuelva el índice de la carta ganadora.\n", + "En el ejemplo anterior, el índice de la carta ganadora es `2`." ] }, { @@ -1341,7 +1340,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1371,7 +1370,7 @@ "tags": [] }, "source": [ - "If you test your method with the previous example, the index of the winning card should be `2`." + "Si pruebas tu método con el ejemplo anterior, el índice de la carta ganadora debería ser `2`." ] }, { @@ -1389,11 +1388,11 @@ "id": "b5b9fb4b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The next few exercises ask to you write functions that classify poker hands.\n", - "If you are not familiar with poker, I'll explain what you need to know.\n", - "We'll use the following class to represent poker hands." + "Los siguientes ejercicios te piden escribir funciones que clasifiquen manos de póker.\n", + "Si no estás familiarizado con el póker, explicaré lo que necesitas saber.\n", + "Usaremos la siguiente clase para representar manos de póker." ] }, { @@ -1409,18 +1408,18 @@ "id": "2daecced", "metadata": {}, "source": [ - "`PokerHand` provides two methods that will help with the exercises.\n", + "`PokerHand` proporciona dos métodos que ayudarán con los ejercicios.\n", "\n", - "* `get_suit_counts` loops through the cards in the `PokerHand`, counts the number of cards in each suit, and returns a dictionary that maps from each suit code to the number of times it appears.\n", + "* `get_suit_counts` recorre las cartas de la `PokerHand`, cuenta el número de cartas de cada palo y devuelve un diccionario que asigna cada código de palo al número de veces que aparece.\n", "\n", - "* `get_rank_counts` does the same thing with the ranks of the cards, returning a dictionary that maps from each rank code to the number of times it appears.\n", + "* `get_rank_counts` hace lo mismo con los rangos de las cartas, devolviendo un diccionario que asigna cada código de rango al número de veces que aparece.\n", "\n", - "All of the exercises that follow can be done using only the Python features we have learned so far, but some of them are more difficult than most of the previous exercises.\n", - "I encourage you to ask an AI for help.\n", + "Todos los ejercicios que siguen se pueden resolver usando solo las características de Python que hemos aprendido hasta ahora, pero algunos son más difíciles que la mayoría de los ejercicios anteriores.\n", + "Te animo a pedir ayuda a un asistente virtual.\n", "\n", - "For problems like this, it often works well to ask for general advice about strategies and algorithms.\n", - "Then you can either write the code yourself or ask for code.\n", - "If you ask for code, you might want to provide the relevant class definitions as part of the prompt." + "Para problemas como este, suele funcionar bien pedir consejos generales sobre estrategias y algorithms.\n", + "Luego puedes escribir el código tú mismo o pedir código.\n", + "Si pides código, quizá quieras proporcionar las definiciones de clase relevantes como parte del prompt." ] }, { @@ -1428,10 +1427,10 @@ "id": "ccc2d8ca", "metadata": {}, "source": [ - "As a first exercise, we'll write a method called `has_flush` that checks whether a hand has a \"flush\" -- that is, whether it contains at least five cards of the same suit.\n", + "Como primer ejercicio, escribiremos un método llamado `has_flush` que comprueba si una mano tiene un \"flush\"; es decir, si contiene al menos cinco cartas del mismo palo.\n", "\n", - "In most varieties of poker, a hand contains either five or seven cards, but there are some exotic variations where a hand contains other numbers of cards.\n", - "But regardless of how many cards there are in a hand, the only ones that count are the five that make the best hand." + "En la mayoría de variedades de póker, una mano contiene cinco o siete cartas, pero hay algunas variaciones exóticas donde una mano contiene otros números de cartas.\n", + "Pero, independientemente de cuántas cartas haya en una mano, las únicas que cuentan son las cinco que forman la mejor mano." ] }, { @@ -1441,7 +1440,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1471,7 +1470,7 @@ "tags": [] }, "source": [ - "To test this method, we'll construct a hand with five cards that are all Clubs, so it contains a flush." + "Para probar este método, construiremos una mano con cinco cartas que son todas Clubs, así que contiene un flush." ] }, { @@ -1491,7 +1490,7 @@ "tags": [] }, "source": [ - "If we invoke `get_suit_counts`, we can confirm that the rank code `0` appears `5` times." + "Si invocamos `get_suit_counts`, podemos confirmar que el código de rango `0` aparece `5` veces." ] }, { @@ -1511,7 +1510,7 @@ "tags": [] }, "source": [ - "So `has_flush` should return `True`." + "Así que `has_flush` debería devolver `True`." ] }, { @@ -1531,7 +1530,7 @@ "tags": [] }, "source": [ - "As a second test, we'll construct a hand with three Clubs and two other suits." + "Como segunda prueba, construiremos una mano con tres Clubs y otros dos palos." ] }, { @@ -1551,7 +1550,7 @@ "tags": [] }, "source": [ - "So `has_flush` should return `False`." + "Así que `has_flush` debería devolver `False`." ] }, { @@ -1569,13 +1568,13 @@ "id": "ad716880", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a method called `has_straight` that checks whether a hand contains a straight, which is a set of five cards with consecutive ranks.\n", - "For example, if a hand contains ranks `5`, `6`, `7`, `8`, and `9`, it contains a straight.\n", + "Escribe un método llamado `has_straight` que compruebe si una mano contiene una straight, que es un conjunto de cinco cartas con rangos consecutivos.\n", + "Por ejemplo, si una mano contiene los rangos `5`, `6`, `7`, `8` y `9`, contiene una straight.\n", "\n", - "An Ace can come before a two or after a King, so `Ace`, `2`, `3`, `4`, `5` is a straight and so it `10`, `Jack`, `Queen`, `King`, `Ace`.\n", - "But a straight cannot \"wrap around\", so `King`, `Ace`, `2`, `3`, `4` is not a straight." + "Un Ace puede ir antes de un dos o después de un King, así que `Ace`, `2`, `3`, `4`, `5` es una straight, y también lo es `10`, `Jack`, `Queen`, `King`, `Ace`.\n", + "Pero una straight no puede \"dar la vuelta\", así que `King`, `Ace`, `2`, `3`, `4` no es una straight." ] }, { @@ -1585,8 +1584,8 @@ "tags": [] }, "source": [ - "You can use the following outline to get started.\n", - "It includes a few lines of code that count the number of Aces -- represented with the code `1` or `14` -- and store the total in both locations of the counter." + "Puedes usar el siguiente esquema para empezar.\n", + "Incluye unas pocas líneas de código que cuentan el número de Aces, representados con el código `1` o `14`, y almacenan el total en ambas ubicaciones del contador." ] }, { @@ -1616,8 +1615,8 @@ "tags": [] }, "source": [ - "`good_hand`, which we created for the previous exercise, contains a straight.\n", - "If we use `get_rank_counts`, we can confirm that it has at least one card with each of five consecutive ranks." + "`good_hand`, que creamos para el ejercicio anterior, contiene una straight.\n", + "Si usamos `get_rank_counts`, podemos confirmar que tiene al menos una carta de cada uno de cinco rangos consecutivos." ] }, { @@ -1637,7 +1636,7 @@ "tags": [] }, "source": [ - "So `has_straight` should return `True`." + "Así que `has_straight` debería devolver `True`." ] }, { @@ -1657,7 +1656,7 @@ "tags": [] }, "source": [ - "`bad_hand` does not contain a straight, so `has_straight` should return `False`." + "`bad_hand` no contiene una straight, así que `has_straight` debería devolver `False`." ] }, { @@ -1675,10 +1674,10 @@ "id": "c1ecebd3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A hand has a straight flush if it contains a set of five cards that are both a straight and a flush -- that is, five cards of the same suit with consecutive ranks.\n", - "Write a `PokerHand` method that checks whether a hand has a straight flush." + "Una mano tiene una straight flush si contiene un conjunto de cinco cartas que son a la vez una straight y un flush; es decir, cinco cartas del mismo palo con rangos consecutivos.\n", + "Escribe un método de `PokerHand` que compruebe si una mano tiene una straight flush." ] }, { @@ -1688,7 +1687,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1728,7 +1727,7 @@ "tags": [] }, "source": [ - "Use the following examples to test your method." + "Usa los siguientes ejemplos para probar tu método." ] }, { @@ -1758,8 +1757,8 @@ "tags": [] }, "source": [ - "Note that it is not enough to check whether a hand has a straight and a flush.\n", - "To see why, consider the following hand." + "Ten en cuenta que no basta con comprobar si una mano tiene una straight y un flush.\n", + "Para ver por qué, considera la siguiente mano." ] }, { @@ -1779,7 +1778,7 @@ "tags": [] }, "source": [ - "This hand contains a straight and a flush, but they are not the same five cards." + "Esta mano contiene una straight y un flush, pero no son las mismas cinco cartas." ] }, { @@ -1799,7 +1798,7 @@ "tags": [] }, "source": [ - "So it does not contain a straight flush." + "Así que no contiene una straight flush." ] }, { @@ -1817,10 +1816,10 @@ "id": "dd742401", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A poker hand has a pair if it contains two or more cards with the same rank.\n", - "Write a `PokerHand` method that checks whether a hand contains a pair." + "Una mano de póker tiene una pareja si contiene dos o más cartas con el mismo rango.\n", + "Escribe un método de `PokerHand` que compruebe si una mano contiene una pareja." ] }, { @@ -1830,7 +1829,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1868,7 +1867,7 @@ "id": "9f001207", "metadata": {}, "source": [ - "To test your method, here's a hand that has a pair." + "Para probar tu método, aquí tienes una mano que tiene una pareja." ] }, { @@ -1908,10 +1907,10 @@ "id": "c4180a64", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A hand has a full house if it contains three cards of one rank and two cards of another rank.\n", - "Write a `PokerHand` method that checks whether a hand has a full house." + "Una mano tiene un full house si contiene tres cartas de un rango y dos cartas de otro rango.\n", + "Escribe un método de `PokerHand` que compruebe si una mano tiene un full house." ] }, { @@ -1921,7 +1920,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1951,7 +1950,7 @@ "tags": [] }, "source": [ - "You can use this hand to test your method." + "Puedes usar esta mano para probar tu método." ] }, { @@ -1999,10 +1998,10 @@ "id": "666340c1", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "This exercise is a cautionary tale about a common error that can be difficult to debug.\n", - "Consider the following class definition." + "Este ejercicio es una advertencia sobre un error común que puede ser difícil de depurar.\n", + "Considera la siguiente definición de clase." ] }, { @@ -2018,14 +2017,14 @@ "id": "1e349832", "metadata": {}, "source": [ - "`__init__` takes two parameters: `name` is required, but `contents` is optional -- if it's not provided, the default value is an empty list.\n", + "`__init__` toma dos parámetros: `name` es obligatorio, pero `contents` es opcional; si no se proporciona, el valor por defecto es una lista vacía.\n", "\n", - "`__str__` returns a string representation of the object that includes the name and the contents of the pouch.\n", + "`__str__` devuelve una representación en string del objeto que incluye el nombre y el contenido de la bolsa.\n", "\n", - "`put_in_pouch` takes any object and appends it to `contents`.\n", + "`put_in_pouch` toma cualquier objeto y lo añade a `contents`.\n", "\n", - "Now let's see how this class works.\n", - "We'll create two `Kangaroo` objects with the names `'Kanga'` and `'Roo'`." + "Ahora veamos cómo funciona esta clase.\n", + "Crearemos dos objetos `Kangaroo` con los nombres `'Kanga'` y `'Roo'`." ] }, { @@ -2041,7 +2040,7 @@ "id": "533982d1", "metadata": {}, "source": [ - "To Kanga's pouch we'll add two strings and Roo." + "A la bolsa de Kanga le añadiremos dos strings y Roo." ] }, { @@ -2057,7 +2056,7 @@ "id": "41cd6d6e", "metadata": {}, "source": [ - "If we print `kanga`, it seems like everything worked." + "Si imprimimos `kanga`, parece que todo ha funcionado." ] }, { @@ -2073,7 +2072,7 @@ "id": "0ba26163", "metadata": {}, "source": [ - "But what happens if we print `roo`?" + "Pero ¿qué pasa si imprimimos `roo`?" ] }, { @@ -2089,10 +2088,10 @@ "id": "a2aef813", "metadata": {}, "source": [ - "Roo's pouch contains the same contents as Kanga's, including a reference to `roo`!\n", + "¡La bolsa de Roo contiene el mismo contenido que la de Kanga, incluida una referencia a `roo`!\n", "\n", - "See if you can figure out what went wrong.\n", - "Then ask a virtual assistant, \"What's wrong with the following program?\" and paste in the definition of `Kangaroo`." + "A ver si puedes averiguar qué salió mal.\n", + "Luego pregunta a un asistente virtual: \"¿Qué está mal en el siguiente programa?\" y pega la definición de `Kangaroo`." ] }, { @@ -2110,13 +2109,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -2142,4 +2143,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/blank/chap18.ipynb b/blank/chap18.ipynb index 6a069c1..f4269cc 100644 --- a/blank/chap18.ipynb +++ b/blank/chap18.ipynb @@ -5,9 +5,9 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", - "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." + "Puedes comprar las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", + "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325).\n" ] }, { @@ -27,7 +27,7 @@ "tags": [] }, "source": [ - "Here are versions of the `Card`, `Deck`, and `Hand` classes from Chapter 17, which we will use in some examples in this chapter." + "Aquí tienes versiones de las clases `Card`, `Deck` y `Hand` del Capítulo 17, que usaremos en algunos ejemplos de este capítulo.\n" ] }, { @@ -65,14 +65,14 @@ "id": "27e8d827", "metadata": {}, "source": [ - "# Python Extras\n", + "# Extras de Python\n", "\n", - "One of my goals for this book has been to teach you as little Python as possible. \n", - "When there were two ways to do something, I picked one and avoided mentioning the other.\n", - "Or sometimes I put the second one into an exercise.\n", + "Uno de mis objetivos con este libro ha sido enseñarte la menor cantidad posible de Python. \n", + "Cuando había dos maneras de hacer algo, elegí una y evité mencionar la otra.\n", + "O a veces puse la segunda en un ejercicio.\n", "\n", - "Now I want to go back for some of the good bits that got left behind.\n", - "Python provides a number of features that are not really necessary -- you can write good code without them -- but with them you can write code that's more concise, readable, or efficient, and sometimes all three." + "Ahora quiero volver a algunas de las partes buenas que quedaron fuera.\n", + "Python ofrece varias características que no son realmente necesarias -- puedes escribir buen código sin ellas -- pero con ellas puedes escribir código más conciso, legible o eficiente, y a veces las tres cosas.\n" ] }, { @@ -80,10 +80,10 @@ "id": "7ddcece8", "metadata": {}, "source": [ - "## Sets\n", + "## Conjuntos\n", "\n", - "Python provides a class called `set` that represents a collection of unique elements.\n", - "To create an empty set, we can use the class object like a function." + "Python proporciona una clase llamada `set` que representa una colección de elementos únicos.\n", + "Para crear un conjunto vacío, podemos usar el objeto de clase como una función.\n" ] }, { @@ -99,7 +99,7 @@ "id": "904e2071", "metadata": {}, "source": [ - "We can use the `add` method to add elements." + "Podemos usar el método `add` para añadir elementos.\n" ] }, { @@ -115,7 +115,7 @@ "id": "beee02fc", "metadata": {}, "source": [ - "Or we can pass any kind of sequence to `set`." + "O podemos pasar cualquier tipo de secuencia a `set`.\n" ] }, { @@ -131,8 +131,8 @@ "id": "42f99153", "metadata": {}, "source": [ - "An element can only appear once in a `set`.\n", - "If you add an element that's already there, it has no effect." + "Un elemento solo puede aparecer una vez en un `set`.\n", + "Si añades un elemento que ya está, no tiene ningún efecto.\n" ] }, { @@ -148,7 +148,7 @@ "id": "9b0a82ee", "metadata": {}, "source": [ - "Or if you create a set with a sequence that contains duplicates, the result contains only unique elements." + "O, si creas un conjunto con una secuencia que contiene duplicados, el resultado contiene solo elementos únicos.\n" ] }, { @@ -164,8 +164,8 @@ "id": "328e2009", "metadata": {}, "source": [ - "Some of the exercises in this book can be done concisely and efficiently with sets. \n", - "For example, here is a solution to an exercise in Chapter 11 that uses a dictionary to check whether there are any duplicate elements in a sequence." + "Algunos de los ejercicios de este libro se pueden hacer de forma concisa y eficiente con conjuntos. \n", + "Por ejemplo, aquí tienes una solución a un ejercicio del Capítulo 11 que usa un diccionario para comprobar si hay elementos duplicados en una secuencia.\n" ] }, { @@ -181,8 +181,8 @@ "id": "0b250e58", "metadata": {}, "source": [ - "This version adds the element of `t` as keys in a dictionary, and then checks whether there are fewer keys than elements.\n", - "Using sets, we can write the same function like this." + "Esta versión añade los elementos de `t` como claves en un diccionario, y luego comprueba si hay menos claves que elementos.\n", + "Usando conjuntos, podemos escribir la misma función así.\n" ] }, { @@ -208,11 +208,11 @@ "id": "30cf3158", "metadata": {}, "source": [ - "An element can only appear in a set once, so if an element in `t` appears more than once, the set will be smaller than `t`.\n", - "If there are no duplicates, the set will be the same size as `t`.\n", + "Un elemento solo puede aparecer en un conjunto una vez, así que si un elemento de `t` aparece más de una vez, el conjunto será más pequeño que `t`.\n", + "Si no hay duplicados, el conjunto tendrá el mismo tamaño que `t`.\n", "\n", - "`set` objects provide methods that perform set operations.\n", - "For example, `union` computes the union of two sets, which is a new set that contains all elements that appear in either set." + "Los objeto `set` proporcionan métodos que realizan operaciones de conjuntos.\n", + "Por ejemplo, `union` calcula la unión de dos conjuntos, que es un nuevo conjunto que contiene todos los elementos que aparecen en cualquiera de los dos conjuntos.\n" ] }, { @@ -228,8 +228,8 @@ "id": "57b1d50c", "metadata": {}, "source": [ - "Some arithmetic operators work with sets.\n", - "For example, the `-` operator performs set subtraction -- the result is a new set that contains all elements from the first set that are _not_ in the second set." + "Algunos operadores aritméticos funcionan con conjuntos.\n", + "Por ejemplo, el operador `-` realiza la resta de conjuntos -- el resultado es un nuevo conjunto que contiene todos los elementos del primer conjunto que _no_ están en el segundo conjunto.\n" ] }, { @@ -245,8 +245,8 @@ "id": "5099226c", "metadata": {}, "source": [ - "In [Chapter 12](section_dictionary_subtraction) we used dictionaries to find the words that appear in a document but not in a word list.\n", - "We used the following function, which takes two dictionaries and returns a new dictionary that contains only the keys from the first that don't appear in the second." + "En el [Capítulo 12](section_dictionary_subtraction) usamos diccionarios para encontrar las palabras que aparecen en un documento pero no en una lista de palabras.\n", + "Usamos la siguiente función, que recibe dos diccionarios y devuelve un nuevo diccionario que contiene solo las claves del primero que no aparecen en el segundo.\n" ] }, { @@ -262,8 +262,8 @@ "id": "455c3e34", "metadata": {}, "source": [ - "With sets, we don't have to write this function ourselves.\n", - "If `word_counter` is a dictionary that contains the unique words in the document and `word_list` is a list of valid words, we can compute the set difference like this." + "Con conjuntos, no tenemos que escribir esta función nosotros mismos.\n", + "Si `word_counter` es un diccionario que contiene las palabras únicas del documento y `word_list` es una lista de palabras válidas, podemos calcular la diferencia de conjuntos así.\n" ] }, { @@ -291,10 +291,10 @@ "id": "91efe708", "metadata": {}, "source": [ - "The result is a set that contains the words in the document that don't appear in the word list.\n", + "El resultado es un conjunto que contiene las palabras del documento que no aparecen en la lista de palabras.\n", "\n", - "The relational operators work with sets.\n", - "For example, `<=` checks whether one set is a subset of another, including the possibility that they are equal." + "Los operadores relacionales funcionan con conjuntos.\n", + "Por ejemplo, `<=` comprueba si un conjunto es un subconjunto de otro, incluyendo la posibilidad de que sean iguales.\n" ] }, { @@ -310,8 +310,8 @@ "id": "74d4d824", "metadata": {}, "source": [ - "With these operators, we can use sets to do some of the exercises in Chapter 7.\n", - "For example, here's a version of `uses_only` that uses a loop." + "Con estos operadores, podemos usar conjuntos para hacer algunos de los ejercicios del Capítulo 7.\n", + "Por ejemplo, aquí tienes una versión de `uses_only` que usa un bucle.\n" ] }, { @@ -327,8 +327,8 @@ "id": "58c1da26", "metadata": {}, "source": [ - "`uses_only` checks whether all letters in `word` are in `available`.\n", - "With sets, we can rewrite it like this." + "`uses_only` comprueba si todas las letras de `word` están en `available`.\n", + "Con conjuntos, podemos reescribirla así.\n" ] }, { @@ -344,7 +344,7 @@ "id": "01ce8cff", "metadata": {}, "source": [ - "If the letters in `word` are a subset of the letters in `available`, that means that `word` uses only letters in `available`." + "Si las letras de `word` son un subconjunto de las letras de `available`, eso significa que `word` usa solo letras de `available`.\n" ] }, { @@ -354,12 +354,12 @@ "source": [ "## Counters\n", "\n", - "A `Counter` is like a set, except that if an element appears more than once, the `Counter` keeps track of how many times it appears.\n", - "If you are familiar with the mathematical idea of a \"multiset\", a `Counter` is a\n", - "natural way to represent a multiset.\n", + "Un `Counter` es como un conjunto, excepto que si un elemento aparece más de una vez, el `Counter` lleva la cuenta de cuántas veces aparece.\n", + "Si conoces la idea matemática de un \"multiset\", un `Counter` es una forma\n", + "natural de representar un multiset.\n", "\n", - "The `Counter` class is defined in a module called `collections`, so you have to import it.\n", - "Then you can use the class object as a function and pass as an argument a string, list, or any other kind of sequence." + "La clase `Counter` está definida en un module llamado `collections`, así que tienes que importarla.\n", + "Después puedes usar el objeto de clase como una función y pasar como argumento un string, una lista o cualquier otro tipo de secuencia.\n" ] }, { @@ -383,12 +383,12 @@ "id": "8da28fe5", "metadata": {}, "source": [ - "A `Counter` object is like a dictionary that maps from each key to the number of times it appears.\n", - "As in dictionaries, the keys have to be hashable.\n", + "Un objeto `Counter` es como un diccionario que asocia cada clave con el número de veces que aparece.\n", + "Como en los diccionarios, las claves tienen que ser hashable.\n", "\n", - "Unlike dictionaries, `Counter` objects don't raise an exception if you access an\n", - "element that doesn't appear.\n", - "Instead, they return `0`." + "A diferencia de los diccionarios, los objeto `Counter` no lanzan una excepción si accedes a un\n", + "elemento que no aparece.\n", + "En su lugar, devuelven `0`.\n" ] }, { @@ -404,9 +404,9 @@ "id": "9bb2b650", "metadata": {}, "source": [ - "We can use `Counter` objects to solve one of the exercises from Chapter 10, which asks for a function that takes two words and checks whether they are anagrams -- that is, whether the letters from one can be rearranged to spell the other.\n", + "Podemos usar objeto `Counter` para resolver uno de los ejercicios del Capítulo 10, que pide una función que reciba dos palabras y compruebe si son anagramas -- es decir, si las letras de una se pueden reordenar para formar la otra.\n", "\n", - "Here's a solution using `Counter` objects." + "Aquí tienes una solución usando objeto `Counter`.\n" ] }, { @@ -422,9 +422,9 @@ "id": "6907f368", "metadata": {}, "source": [ - "If two words are anagrams, they contain the same letters with the same counts, so their `Counter` objects are equivalent.\n", + "Si dos palabras son anagramas, contienen las mismas letras con los mismos recuentos, así que sus objeto `Counter` son equivalentes.\n", "\n", - "`Counter` provides a method called `most_common` that returns a list of value-frequency pairs, sorted from most common to least." + "`Counter` proporciona un método llamado `most_common` que devuelve una lista de pares valor-frecuencia, ordenados de más común a menos común.\n" ] }, { @@ -440,10 +440,10 @@ "id": "b02b7dff", "metadata": {}, "source": [ - "They also provide methods and operators to perform set-like operations, including addition, subtraction, union and intersection.\n", - "For example, the `+` operator combines two `Counter` objects and creates a new `Counter` that contains the keys from both and the sums of the counts.\n", + "También proporcionan métodos y operadores para realizar operaciones parecidas a las de conjuntos, incluyendo suma, resta, unión e intersección.\n", + "Por ejemplo, el operador `+` combina dos objeto `Counter` y crea un nuevo `Counter` que contiene las claves de ambos y las sumas de los recuentos.\n", "\n", - "We can test it by making a `Counter` with the letters from `'bans'` and adding it to the letters from `'banana'`." + "Podemos probarlo creando un `Counter` con las letras de `'bans'` y sumándolo a las letras de `'banana'`.\n" ] }, { @@ -459,7 +459,7 @@ "id": "5461328e", "metadata": {}, "source": [ - "You'll have a chance to explore other `Counter` operations in the exercises at the end of this chapter." + "Tendrás la oportunidad de explorar otras operaciones de `Counter` en los ejercicios al final de este capítulo.\n" ] }, { @@ -469,13 +469,13 @@ "source": [ "## defaultdict\n", "\n", - "The `collections` module also provides `defaultdict`, which is like a dictionary except that if you access a key that doesn't exist, it generates a new value automatically.\n", + "El module `collections` también proporciona `defaultdict`, que es como un diccionario excepto que, si accedes a una clave que no existe, genera automáticamente un nuevo valor.\n", "\n", - "When you create a `defaultdict`, you provide a function that's used to create new values.\n", - "A function that create objects is sometimes called a **factory**.\n", - "The built-in functions that create lists, sets, and other types can be used as factories.\n", + "Cuando creas un `defaultdict`, proporcionas una función que se usa para crear nuevos valores.\n", + "Una función que crea objetos a veces se llama **fábrica**.\n", + "Las funciones integradas que crean listas, conjuntos y otros tipos se pueden usar como fábricas.\n", "\n", - "For example, here's a `defaultdict` that creates a new `list` when needed. " + "Por ejemplo, aquí tienes un `defaultdict` que crea una nueva `list` cuando hace falta.\n" ] }, { @@ -491,8 +491,8 @@ "id": "9f43d537", "metadata": {}, "source": [ - "Notice that the argument is `list`, which is a class object, not `list()`, which is a function call that creates a new list.\n", - "The factory function doesn't get called unless we access a key that doesn't exist." + "Fíjate en que el argumento es `list`, que es un objeto de clase, no `list()`, que es una llamada a función que crea una nueva lista.\n", + "La fábrica función no se llama a menos que accedamos a una clave que no existe.\n" ] }, { @@ -508,8 +508,8 @@ "id": "01f87415", "metadata": {}, "source": [ - "The new list, which we're calling `t`, is also added to the dictionary.\n", - "So if we modify `t`, the change appears in `d`:" + "La nueva lista, que llamamos `t`, también se añade al diccionario.\n", + "Así que si modificamos `t`, el cambio aparece en `d`:\n" ] }, { @@ -525,12 +525,12 @@ "id": "3e5d0151", "metadata": {}, "source": [ - "If you are making a dictionary of lists, you can often write simpler\n", - "code using `defaultdict`. \n", + "Si estás creando un diccionario de listas, a menudo puedes escribir código más simple\n", + "usando `defaultdict`. \n", "\n", - "In one of the exercises in [Chapter 11](chapter_tuples), I made a dictionary that maps from a sorted string of letters to the list of words that can be spelled with those letters.\n", - "For example, the string `'opst'` maps to the list `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", - "Here's the original code." + "En uno de los ejercicios del [Capítulo 11](chapter_tuples), hice un diccionario que asocia un string de letras ordenadas con la lista de palabras que se pueden formar con esas letras.\n", + "Por ejemplo, el string `'opst'` se asocia con la lista `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", + "Aquí está el código original.\n" ] }, { @@ -546,7 +546,7 @@ "id": "8e9a0a2b", "metadata": {}, "source": [ - "And here's a simpler version using a `defaultdict`." + "Y aquí tienes una versión más simple usando un `defaultdict`.\n" ] }, { @@ -562,7 +562,7 @@ "id": "cccdd46c", "metadata": {}, "source": [ - "In the exercises at the end of the chapter, you'll have a chance to practice using `defaultdict` objects." + "En los ejercicios al final del capítulo, tendrás la oportunidad de practicar usando objeto `defaultdict`.\n" ] }, { @@ -578,9 +578,9 @@ "id": "610359c1", "metadata": {}, "source": [ - "## Conditional expressions\n", + "## Expresiones condicionales\n", "\n", - "Conditional statements are often used to choose one of two values, like this:" + "Las sentencias condicionales se usan a menudo para elegir uno de dos valores, como aquí:\n" ] }, { @@ -616,11 +616,11 @@ "id": "2c5fc3dd", "metadata": {}, "source": [ - "This statement checks whether `x` is positive. If so, it computes its logarithm. \n", - "If not, `math.log` would raise a ValueError.\n", - "To avoid stopping the program, we generate a `NaN`, which is a special floating-point value that represents \"Not a Number\".\n", + "Esta sentencia comprueba si `x` es positivo. Si lo es, calcula su logaritmo. \n", + "Si no, `math.log` lanzaría un ValueError.\n", + "Para evitar detener el programa, generamos un `NaN`, que es un valor especial de punto flotante que representa \"Not a Number\".\n", "\n", - "We can write this statement more concisely using a **conditional expression**." + "Podemos escribir esta sentencia de forma más concisa usando una **conditional expression**.\n" ] }, { @@ -646,10 +646,10 @@ "id": "6a7cf27b", "metadata": {}, "source": [ - "You can almost read this line like English: \"`y` gets log-`x` if `x` is greater than 0; otherwise it gets `NaN`\".\n", + "Casi puedes leer esta línea como si fuera inglés: \"`y` recibe log-`x` si `x` es mayor que 0; de lo contrario recibe `NaN`\".\n", "\n", - "Recursive functions can sometimes be written concisely using conditional expressions. \n", - "For example, here is a version of `factorial` with a conditional _statement_." + "Las funciones recursivas a veces se pueden escribir de forma concisa usando expresiones condicionales. \n", + "Por ejemplo, aquí tienes una versión de `factorial` con una _sentencia_ condicional.\n" ] }, { @@ -665,7 +665,7 @@ "id": "56052b5c", "metadata": {}, "source": [ - "And here's a version with a conditional _expression_." + "Y aquí tienes una versión con una _expresión_ condicional.\n" ] }, { @@ -681,8 +681,8 @@ "id": "d53fbc15", "metadata": {}, "source": [ - "Another use of conditional expressions is handling optional arguments.\n", - "For example, here is class definition with an `__init__` method that uses a conditional statement to check a parameter with a default value." + "Otro uso de las expresiones condicionales es manejar argumentos opcionales.\n", + "Por ejemplo, aquí tienes una definición de clase con un método `__init__` que usa una sentencia condicional para comprobar un parámetro con un valor por defecto.\n" ] }, { @@ -698,7 +698,7 @@ "id": "655bfc46", "metadata": {}, "source": [ - "Here's a version that uses a conditional expression." + "Aquí tienes una versión que usa una expresión condicional.\n" ] }, { @@ -714,7 +714,7 @@ "id": "fef85229", "metadata": {}, "source": [ - "In general, you can replace a conditional statement with a conditional expression if both branches contain a single expression and no statements." + "En general, puedes reemplazar una sentencia condicional por una expresión condicional si ambas ramas contienen una sola expresión y ninguna sentencia.\n" ] }, { @@ -722,10 +722,10 @@ "id": "45d3b306", "metadata": {}, "source": [ - "## List comprehensions\n", + "## Comprensiones de listas\n", "\n", - "In previous chapters, we've seen a few examples where we start with an empty list and add elements, one at a time, using the `append` method.\n", - "For example, suppose we have a string that contains the title of a movie, and we want to capitalize all of the words." + "En capítulos anteriores, hemos visto algunos ejemplos donde empezamos con una lista vacía y añadimos elementos, uno por uno, usando el método `append`.\n", + "Por ejemplo, supón que tenemos un string que contiene el título de una película, y queremos poner en mayúscula la primera letra de todas las palabras.\n" ] }, { @@ -741,7 +741,7 @@ "id": "9eeb45a6", "metadata": {}, "source": [ - "We can split it into a list of strings, loop through the strings, capitalize them, and append them to a list." + "Podemos dividirlo en una lista de strings, recorrer los strings, capitalizarlos y añadirlos a una lista.\n" ] }, { @@ -757,7 +757,7 @@ "id": "b96197c2", "metadata": {}, "source": [ - "We can do the same thing more concisely using a **list comprehension**:" + "Podemos hacer lo mismo de forma más concisa usando una **comprensión de listas**:\n" ] }, { @@ -773,13 +773,13 @@ "id": "e5b565ad", "metadata": {}, "source": [ - "The bracket operators indicate that we are constructing a new list.\n", - "The expression inside the brackets specifies the elements of the list, and the `for` clause indicates what sequence we are looping through.\n", + "Los operadores de corchetes indican que estamos construyendo una nueva lista.\n", + "La expresión dentro de los corchetes especifica los elementos de la lista, y la cláusula `for` indica qué secuencia estamos recorriendo.\n", "\n", - "The syntax of a list comprehension might seem strange, because the loop variable -- `word` in this example -- appears in the expression before we get to its definition.\n", - "But you get used to it.\n", + "La sintaxis de una comprensión de listas puede parecer extraña, porque la variable del bucle -- `word` en este ejemplo -- aparece en la expresión antes de llegar a su definición.\n", + "Pero te acostumbras.\n", "\n", - "As another example, in [Chapter 9](section_word_list) we used this loop to read words from a file and append them to a list." + "Como otro ejemplo, en el [Capítulo 9](section_word_list) usamos este bucle para leer palabras de un archivo y añadirlas a una lista.\n" ] }, { @@ -815,7 +815,7 @@ "id": "2d1df49b", "metadata": {}, "source": [ - "Here's how we can write that as a list comprehension." + "Así es como podemos escribirlo como una comprensión de listas.\n" ] }, { @@ -841,8 +841,8 @@ "id": "92d856ba", "metadata": {}, "source": [ - "A list comprehension can also have an `if` clause that determines which elements are included in the list.\n", - "For example, here's a `for` loop we used in [Chapter 10](section_palindrome_list) to make a list of only the words in `word_list` that are palindromes." + "Una comprensión de listas también puede tener una cláusula `if` que determina qué elementos se incluyen en la lista.\n", + "Por ejemplo, aquí tienes un bucle `for` que usamos en el [Capítulo 10](section_palindrome_list) para crear una lista solo con las palabras de `word_list` que son palíndromos.\n" ] }, { @@ -878,7 +878,7 @@ "id": "151621d8", "metadata": {}, "source": [ - "Here's how we can do the same thing with an list comprehension." + "Así es como podemos hacer lo mismo con una comprensión de listas.\n" ] }, { @@ -904,9 +904,9 @@ "id": "5fc4eab1", "metadata": {}, "source": [ - "When a list comprehension is used as an argument to a function, we can often omit the brackets.\n", - "For example, suppose we want to add up $1 / 2^n$ for values of $n$ from 0 to 9.\n", - "We can use a list comprehension like this." + "Cuando una comprensión de listas se usa como argumento de una función, a menudo podemos omitir los corchetes.\n", + "Por ejemplo, supón que queremos sumar $1 / 2^n$ para valores de $n$ de 0 a 9.\n", + "Podemos usar una comprensión de listas así.\n" ] }, { @@ -922,7 +922,7 @@ "id": "2ee312e0", "metadata": {}, "source": [ - "Or we can leave out the brackets like this." + "O podemos dejar fuera los corchetes así.\n" ] }, { @@ -938,17 +938,17 @@ "id": "3d56d584", "metadata": {}, "source": [ - "In this example, the argument is technically a **generator expression**, not a list comprehension, and it never actually makes a list.\n", - "But other than that, the behavior is the same.\n", + "En este ejemplo, técnicamente el argumento es una **expresión generadora**, no una comprensión de listas, y en realidad nunca crea una lista.\n", + "Pero aparte de eso, el comportamiento es el mismo.\n", "\n", - "List comprehensions and generator expressions are concise and easy to read, at least for simple expressions.\n", - "And they are usually faster than the equivalent for loops, sometimes much faster.\n", - "So if you are mad at me for not mentioning them earlier, I understand.\n", + "Las comprensiones de listas y las expresiones generadoras son concisas y fáciles de leer, al menos para expresiones simples.\n", + "Y normalmente son más rápidas que los bucles `for` equivalentes, a veces mucho más rápidas.\n", + "Así que si estás enfadado conmigo por no haberlas mencionado antes, lo entiendo.\n", "\n", - "But, in my defense, list comprehensions are harder to debug because you can't put a print statement inside the loop.\n", - "I suggest you use them only if the computation is simple enough that you are likely to get it\n", - "right the first time.\n", - "Or consider writing and debugging a `for` loop and then converting it to a list comprehension." + "Pero, en mi defensa, las comprensiones de listas son más difíciles de depurar porque no puedes poner una sentencia print dentro del bucle.\n", + "Te sugiero que las uses solo si el cálculo es lo bastante simple como para que probablemente te salga\n", + "bien a la primera.\n", + "O considera escribir y depurar un bucle `for` y luego convertirlo en una comprensión de listas.\n" ] }, { @@ -956,9 +956,9 @@ "id": "f9fac860", "metadata": {}, "source": [ - "## `any` and `all`\n", + "## `any` y `all`\n", "\n", - "Python provides a built-in function, `any`, that takes a sequence of boolean values and returns `True` if any of the values are `True`." + "Python proporciona una función integrada, `any`, que recibe una secuencia de valores booleanos y devuelve `True` si cualquiera de los valores es `True`.\n" ] }, { @@ -974,7 +974,7 @@ "id": "43217186", "metadata": {}, "source": [ - "`any` is often used with generator expressions." + "`any` se usa a menudo con expresiones generadoras.\n" ] }, { @@ -990,8 +990,8 @@ "id": "22395487", "metadata": {}, "source": [ - "That example isn't very useful because it does the same thing as the `in` operator. \n", - "But we could use `any` to write concise solutions to some of the exercises in [Chapter 7](chapter_search). For example, we can write `uses_none` like this." + "Ese ejemplo no es muy útil porque hace lo mismo que el operador `in`. \n", + "Pero podríamos usar `any` para escribir soluciones concisas a algunos de los ejercicios del [Capítulo 7](chapter_search). Por ejemplo, podemos escribir `uses_none` así.\n" ] }, { @@ -1027,11 +1027,11 @@ "id": "fbefe3c1", "metadata": {}, "source": [ - "This function loops through the letters in `word` and checks whether any of them are in `forbidden`.\n", - "Using `any` with a generator expression is efficient because it stops immediately if it finds a `True` value, so it doesn't have to loop through the whole sequence.\n", + "Esta función recorre las letras de `word` y comprueba si alguna de ellas está en `forbidden`.\n", + "Usar `any` con una expresión generadora es eficiente porque se detiene inmediatamente si encuentra un valor `True`, así que no tiene que recorrer toda la secuencia.\n", "\n", - "Python provides another built-in function, `all`, that returns `True` if every element of the sequence is `True`.\n", - "We can use it to write a concise version of `uses_all`." + "Python proporciona otra función integrada, `all`, que devuelve `True` si todos los elementos de la secuencia son `True`.\n", + "Podemos usarla para escribir una versión concisa de `uses_all`.\n" ] }, { @@ -1067,7 +1067,7 @@ "id": "8d9f7364", "metadata": {}, "source": [ - "Expressions using `any` and `all` can be concise, efficient, and easy to read." + "Las expresiones que usan `any` y `all` pueden ser concisas, eficientes y fáciles de leer.\n" ] }, { @@ -1075,11 +1075,11 @@ "id": "911857a3", "metadata": {}, "source": [ - "## Named tuples\n", + "## Named tuplas\n", "\n", - "The `collections` module provides a function called `namedtuple` that can be used to create simple classes.\n", - "For example, the `Point` object in [Chapter 16](section_create_point) has only two attributes, `x` and `y`.\n", - "Here's how we defined it." + "El module `collections` proporciona una función llamada `namedtuple` que se puede usar para crear clases simples.\n", + "Por ejemplo, el objeto `Point` del [Capítulo 16](section_create_point) solo tiene dos atributos, `x` e `y`.\n", + "Así es como lo definimos.\n" ] }, { @@ -1095,8 +1095,8 @@ "id": "36f08927", "metadata": {}, "source": [ - "That's a lot of code to convey a small amount of information.\n", - "`namedtuple` provides a more concise way to define classes like this." + "Eso es mucho código para transmitir una pequeña cantidad de información.\n", + "`namedtuple` proporciona una forma más concisa de definir clases como esta.\n" ] }, { @@ -1112,12 +1112,12 @@ "id": "942a0877", "metadata": {}, "source": [ - "The first argument is the name of the class you want to create. The\n", - "second is a list of the attributes `Point` objects should have.\n", - "The result is a class object, which is why it is assigned to a capitalized variable name.\n", + "El primer argumento es el nombre de la clase que quieres crear. El\n", + "segundo es una lista de los atributos que deben tener los objeto `Point`.\n", + "El resultado es un objeto de clase, por eso se asigna a un nombre de variable con mayúscula inicial.\n", "\n", - "A class created with `namedtuple` provides an `__init__` method that assigns values to the attributes and a `__str__` that displays the object in a readable form.\n", - "So we can create and display a `Point` object like this." + "Una clase creada con `namedtuple` proporciona un método `__init__` que asigna valores a los atributos y un `__str__` que muestra el objeto de forma legible.\n", + "Así que podemos crear y mostrar un objeto `Point` así.\n" ] }, { @@ -1133,7 +1133,7 @@ "id": "b42ee9a2", "metadata": {}, "source": [ - "`Point` also provides an `__eq__` method that checks whether two `Point` objects are equivalent -- that is, whether their attributes are the same." + "`Point` también proporciona un método `__eq__` que comprueba si dos objeto `Point` son equivalentes -- es decir, si sus atributos son iguales.\n" ] }, { @@ -1149,7 +1149,7 @@ "id": "9bcf275a", "metadata": {}, "source": [ - "You can access the elements of a named tuple by name or by index." + "Puedes acceder a los elementos de una named tupla por nombre o por índice.\n" ] }, { @@ -1173,7 +1173,7 @@ "id": "0768ff41", "metadata": {}, "source": [ - "You can also treat a named tuple as a tuple, as in this assignment." + "También puedes tratar una named tupla como una tupla, como en esta asignación.\n" ] }, { @@ -1189,8 +1189,8 @@ "id": "964aa3bd", "metadata": {}, "source": [ - "But `namedtuple` objects are immutable.\n", - "After the attributes are initialized, they can't be changed." + "Pero los objeto `namedtuple` son inmutables.\n", + "Después de inicializar los atributos, no se pueden cambiar.\n" ] }, { @@ -1218,10 +1218,10 @@ "id": "f2db7783", "metadata": {}, "source": [ - "`namedtuple` provides a quick way to define simple classes.\n", - "The drawback is that simple classes don't always stay simple.\n", - "You might decide later that you want to add methods to a named tuple.\n", - "In that case, you can define a new class that inherits from the named tuple." + "`namedtuple` proporciona una forma rápida de definir clases simples.\n", + "La desventaja es que las clases simples no siempre siguen siendo simples.\n", + "Puede que más adelante decidas que quieres añadir métodos a una named tupla.\n", + "En ese caso, puedes definir una nueva clase que herede de la named tupla.\n" ] }, { @@ -1237,7 +1237,7 @@ "id": "805475ce", "metadata": {}, "source": [ - "Or at that point you could switch to a conventional class definition." + "O en ese punto podrías cambiar a una definición de clase convencional.\n" ] }, { @@ -1245,9 +1245,9 @@ "id": "4f3713a0", "metadata": {}, "source": [ - "## Packing keyword arguments\n", + "## Empaquetar argumentos de palabra clave\n", "\n", - "In [Chapter 11](section_argument_pack), we wrote a function that packs its arguments into a tuple." + "En el [Capítulo 11](section_argument_pack), escribimos una función que empaqueta sus argumentos en una tupla.\n" ] }, { @@ -1263,7 +1263,7 @@ "id": "71e3b049", "metadata": {}, "source": [ - "You can call this function with any number of arguments." + "Puedes llamar a esta función con cualquier número de argumentos.\n" ] }, { @@ -1279,8 +1279,8 @@ "id": "486a690f", "metadata": {}, "source": [ - "But the `*` operator doesn't pack keyword arguments.\n", - "So calling this function with a keyword argument causes an error." + "Pero el operador `*` no empaqueta argumentos de palabra clave.\n", + "Así que llamar a esta función con un argumento de palabra clave causa un error.\n" ] }, { @@ -1298,7 +1298,7 @@ "id": "eb7f9281", "metadata": {}, "source": [ - "To pack keyword arguments, we can use the `**` operator:" + "Para empaquetar argumentos de palabra clave, podemos usar el operador `**`:\n" ] }, { @@ -1314,8 +1314,8 @@ "id": "067bf7c4", "metadata": {}, "source": [ - "The keyword-packing parameter can have any name, but `kwargs` is a common choice.\n", - "The result is a dictionary that maps from keywords to values." + "El parámetro que empaqueta keywords puede tener cualquier nombre, pero `kwargs` es una elección común.\n", + "El resultado es un diccionario que asocia keywords con valores.\n" ] }, { @@ -1331,10 +1331,10 @@ "id": "07be77f3", "metadata": {}, "source": [ - "In this example, the value of `kwargs` is printed, but otherwise is has no effect.\n", + "En este ejemplo, se imprime el valor de `kwargs`, pero por lo demás no tiene ningún efecto.\n", "\n", - "But the `**` operator can also be used in an argument list to unpack a dictionary.\n", - "For example, here's a version of `mean` that packs any keyword arguments it gets and then unpacks them as keyword arguments for `sum`." + "Pero el operador `**` también se puede usar en una lista de argumentos para desempaquetar un diccionario.\n", + "Por ejemplo, aquí tienes una versión de `mean` que empaqueta cualquier argumento de palabra clave que recibe y luego los desempaqueta como argumentos de palabra clave para `sum`.\n" ] }, { @@ -1350,8 +1350,8 @@ "id": "ba00858c", "metadata": {}, "source": [ - "Now if we call `mean` with `start` as a keyword argument, it gets passed along to sum, which uses it as the starting point of the summation.\n", - "In the following example `start=3` adds `3` to the sum before computing the mean, so the sum is `6` and the result is `3`." + "Ahora, si llamamos a `mean` con `start` como argumento de palabra clave, se pasa a sum, que lo usa como punto de partida de la suma.\n", + "En el siguiente ejemplo `start=3` añade `3` a la suma antes de calcular la media, así que la suma es `6` y el resultado es `3`.\n" ] }, { @@ -1367,7 +1367,7 @@ "id": "949a2ca3", "metadata": {}, "source": [ - "As another example, if we have a dictionary with keys `x` and `y`, we can use it with the unpack operator to create a `Point` object." + "Como otro ejemplo, si tenemos un diccionario con las claves `x` e `y`, podemos usarlo con el operador de desempaquetado para crear un objeto `Point`.\n" ] }, { @@ -1383,7 +1383,7 @@ "id": "8aaf128a", "metadata": {}, "source": [ - "Without the unpack operator, `d` is treated as a single positional argument, so it gets assigned to `x`, and we get a `TypeError` because there's no second argument to assign to `y`." + "Sin el operador de desempaquetado, `d` se trata como un único argumento posicional, así que se asigna a `x`, y obtenemos un `TypeError` porque no hay un segundo argumento que asignar a `y`.\n" ] }, { @@ -1401,7 +1401,7 @@ "id": "e8acb958", "metadata": {}, "source": [ - "When you are working with functions that have a large number of keyword arguments, it is often useful to create and pass around dictionaries that specify frequently used options." + "Cuando trabajas con funciones que tienen un gran número de argumentos de palabra clave, a menudo es útil crear y pasar diccionarios que especifican opciones usadas con frecuencia.\n" ] }, { @@ -1417,11 +1417,11 @@ "id": "e046e382", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "In previous chapters, we used `doctest` to test functions.\n", - "For example, here's a function called `add` that takes two numbers and returns their sum.\n", - "In includes a doctest that checks whether `2 + 2` is `4`." + "En capítulos anteriores, usamos `doctest` para probar funciones.\n", + "Por ejemplo, aquí tienes una función llamada `add` que recibe dos números y devuelve su suma.\n", + "Incluye un doctest que comprueba si `2 + 2` es `4`.\n" ] }, { @@ -1437,7 +1437,7 @@ "id": "a5e332d3", "metadata": {}, "source": [ - "This function takes a function object and runs its doctests." + "Esta función recibe un objeto función y ejecuta sus doctests.\n" ] }, { @@ -1453,7 +1453,7 @@ "id": "2d752a40", "metadata": {}, "source": [ - "So we can test `add` like this." + "Así que podemos probar `add` así.\n" ] }, { @@ -1469,10 +1469,10 @@ "id": "77d36e9b", "metadata": {}, "source": [ - "There's no output, which means all tests passed.\n", + "No hay salida, lo que significa que todas las pruebas pasaron.\n", "\n", - "Python provides another tool for running automated tests, called `unittest`.\n", - "It is a little more complicated to use, but here's an example." + "Python proporciona otra herramienta para ejecutar pruebas automatizadas, llamada `unittest`.\n", + "Es un poco más complicada de usar, pero aquí tienes un ejemplo.\n" ] }, { @@ -1488,15 +1488,15 @@ "id": "59b4212a", "metadata": {}, "source": [ - "First we import `TestCase`, which is a class in the `unittest` module.\n", - "To use it, we have to define a new class that inherits from `TestCase` and provides at least one test method.\n", - "The name of the test method must begin with `test` and should indicate which function it tests.\n", + "Primero importamos `TestCase`, que es una clase del module `unittest`.\n", + "Para usarla, tenemos que definir una nueva clase que herede de `TestCase` y proporcione al menos un método de test.\n", + "El nombre del método de test debe empezar con `test` y debería indicar qué función prueba.\n", "\n", - "In this example, `test_add` tests the `add` function by calling it, saving the result, and invoking `assertEqual`, which is inherited from `TestCase`.\n", - "`assertEqual` takes two arguments and checks whether they are equal.\n", + "En este ejemplo, `test_add` prueba la función `add` llamándola, guardando el resultado e invocando `assertEqual`, que se hereda de `TestCase`.\n", + "`assertEqual` recibe dos argumentos y comprueba si son iguales.\n", "\n", - "In order to run this test method, we have to run a function in `unittest` called `main` and provide several keyword arguments.\n", - "The following function shows the details -- if you are curious, you can ask a virtual assistant to explain how it works." + "Para ejecutar este método de test, tenemos que ejecutar una función de `unittest` llamada `main` y proporcionar varios argumentos de palabra clave.\n", + "La siguiente función muestra los detalles -- si tienes curiosidad, puedes pedirle a un asistente virtual que explique cómo funciona.\n" ] }, { @@ -1512,11 +1512,11 @@ "id": "5409ea0c", "metadata": {}, "source": [ - "`run_unittest` does not take `TestExample` as an argument -- instead, it searches for classes that inherit from `TestCase`.\n", - "Then it searches for methods that begin with `test` and runs them.\n", - "This process is called **test discovery**.\n", + "`run_unittest` no recibe `TestExample` como argumento -- en su lugar, busca clases que heredan de `TestCase`.\n", + "Luego busca métodos que empiezan con `test` y los ejecuta.\n", + "Este proceso se llama **test discovery**.\n", "\n", - "Here's what happens when we call `run_unittest`." + "Esto es lo que pasa cuando llamamos a `run_unittest`.\n" ] }, { @@ -1532,10 +1532,10 @@ "id": "7775304a", "metadata": {}, "source": [ - "`unittest.main` reports the number of tests it ran and the results.\n", - "In this case `OK` indicates that the tests passed.\n", + "`unittest.main` informa del número de pruebas que ejecutó y de los resultados.\n", + "En este caso `OK` indica que las pruebas pasaron.\n", "\n", - "To see what happens when a test fails, we'll add an incorrect test method to `TestExample`." + "Para ver qué pasa cuando un test falla, añadiremos un método de test incorrecto a `TestExample`.\n" ] }, { @@ -1551,7 +1551,7 @@ "id": "96810614", "metadata": {}, "source": [ - "Here's what happens when we run the tests." + "Esto es lo que pasa cuando ejecutamos las pruebas.\n" ] }, { @@ -1567,10 +1567,10 @@ "id": "64b743cb", "metadata": {}, "source": [ - "The report includes the test method that failed and an error message showing where.\n", - "The summary indicates that two tests ran and one failed.\n", + "El informe incluye el método de test que falló y un mensaje de error que muestra dónde.\n", + "El resumen indica que se ejecutaron dos pruebas y una falló.\n", "\n", - "In the exercises below, I'll suggest some prompts you can use to ask a virtual assistant for more information about `unittest`." + "En los ejercicios siguientes, sugeriré algunos prompts que puedes usar para pedir más información sobre `unittest` a un asistente virtual.\n" ] }, { @@ -1578,22 +1578,22 @@ "id": "7d0fb256", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**factory:**\n", - " A function used to create objects, often passed as a parameter to a function.\n", + "**fábrica:**\n", + " Una función usada para crear objetos, que a menudo se pasa como parámetro a una función.\n", "\n", "**conditional expression:**\n", - "An expression that uses a conditional to select one of two values.\n", + "Una expresión que usa un condicional para seleccionar uno de dos valores.\n", "\n", - "**list comprehension:**\n", - "A concise way to loop through a sequence and create a list.\n", + "**comprensión de listas:**\n", + "Una forma concisa de recorrer una secuencia y crear una lista.\n", "\n", - "**generator expression:**\n", - "Similar to a list comprehension except that it does not create a list.\n", + "**expresión generadora:**\n", + "Similar a una comprensión de listas, excepto que no crea una lista.\n", "\n", "**test discovery:**\n", - "A process used to find and run tests." + "Un proceso usado para encontrar y ejecutar pruebas.\n" ] }, { @@ -1601,7 +1601,7 @@ "id": "bc03f15d", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios\n" ] }, { @@ -1619,28 +1619,28 @@ "id": "fe10415e", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are a few topics in this chapter you might want to learn about.\n", - "Here are some question to ask an AI.\n", + "Hay algunos temas de este capítulo sobre los que quizá quieras aprender más.\n", + "Aquí tienes algunas preguntas para hacerle a una AI.\n", "\n", - "* \"What are the methods and operators of Python's set class?\"\n", + "* \"¿Cuáles son los métodos y operadores de la clase conjunto de Python?\"\n", "\n", - "* \"What are the methods and operators of Python's Counter class?\"\n", + "* \"¿Cuáles son los métodos y operadores de la clase Counter de Python?\"\n", "\n", - "* \"What is the difference between a Python list comprehension and a generator expression?\"\n", + "* \"¿Cuál es la diferencia entre una comprensión de listas de Python y una expresión generadora?\"\n", "\n", - "* \"When should I use Python's `namedtuple` rather than define a new class?\"\n", + "* \"¿Cuándo debería usar `namedtuple` de Python en lugar de definir una nueva clase?\"\n", "\n", - "* \"What are some uses of packing and unpacking keyword arguments?\"\n", + "* \"¿Cuáles son algunos usos de empaquetar y desempaquetar argumentos de palabra clave?\"\n", "\n", - "* \"How does `unittest` do test discovery?\"\n", + "* \"¿Cómo hace `unittest` test discovery?\"\n", "\n", - "\"Along with `assertEqual`, what are the most commonly used methods in `unittest.TestCase`?\"\n", + "\"Junto con `assertEqual`, ¿cuáles son los métodos más usados en `unittest.TestCase`?\"\n", "\n", - "\"What are the pros and cons of `doctest` and `unittest`?\"\n", + "\"¿Cuáles son los pros y los contras de `doctest` y `unittest`?\"\n", "\n", - "For the following exercises, consider asking an AI for help, but as always, remember to test the results." + "Para los siguientes ejercicios, considera pedir ayuda a una AI, pero como siempre, recuerda probar los resultados.\n" ] }, { @@ -1648,9 +1648,9 @@ "id": "c61ecde2", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "One of the exercises in Chapter 7 asks for a function called `uses_none` that takes a word and a string of forbidden letters, and returns `True` if the word does not use any of the letters. Here's a solution." + "Uno de los ejercicios del Capítulo 7 pide una función llamada `uses_none` que recibe una palabra y un string de letras prohibidas, y devuelve `True` si la palabra no usa ninguna de esas letras. Aquí tienes una solución.\n" ] }, { @@ -1666,8 +1666,8 @@ "id": "b558b8b3", "metadata": {}, "source": [ - "Write a version of this function that uses `set` operations instead of a `for` loop.\n", - "Hint: ask an AI \"How do I compute the intersection of Python sets?\"" + "Escribe una versión de esta función que use operaciones de `set` en lugar de un bucle `for`.\n", + "Pista: pregunta a una AI \"¿Cómo calculo la intersección de conjuntos de Python?\"\n" ] }, { @@ -1677,7 +1677,7 @@ "tags": [] }, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar.\n" ] }, { @@ -1723,12 +1723,12 @@ "id": "d2d670cf", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Scrabble is a board game where the objective is to use letter tiles to spell words.\n", - "For example, if we have tiles with the letters `T`, `A`, `B`, `L`, `E`, we can spell `BELT` and `LATE` using a subset of the tiles -- but we can't spell `BEET` because we don't have two `E`s.\n", + "Scrabble es un juego de mesa donde el objetivo es usar fichas de letras para formar palabras.\n", + "Por ejemplo, si tenemos fichas con las letras `T`, `A`, `B`, `L`, `E`, podemos formar `BELT` y `LATE` usando un subconjunto de las fichas -- pero no podemos formar `BEET` porque no tenemos dos `E`.\n", "\n", - "Write a function that takes a string of letters and a word, and checks whether the letters can spell the word, taking into account how many times each letter appears." + "Escribe una función que reciba un string de letras y una palabra, y compruebe si las letras pueden formar la palabra, teniendo en cuenta cuántas veces aparece cada letra.\n" ] }, { @@ -1738,7 +1738,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar.\n" ] }, { @@ -1774,9 +1774,9 @@ "id": "de2dc099", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In one of the exercises from [Chapter 17](chapter_inheritance), my solution to `has_straightflush` uses the following method, which partitions a `PokerHand` into a list of four hands, where each hand contains cards of the same suit." + "En uno de los ejercicios del [Capítulo 17](chapter_inheritance), mi solución para `has_straightflush` usa el siguiente método, que particiona una `PokerHand` en una lista de cuatro manos, donde cada mano contiene cartas del mismo palo.\n" ] }, { @@ -1792,7 +1792,7 @@ "id": "cd04a7a3", "metadata": {}, "source": [ - "Write a simplified version of this function using a `defaultdict`." + "Escribe una versión simplificada de esta función usando un `defaultdict`.\n" ] }, { @@ -1802,7 +1802,7 @@ "tags": [] }, "source": [ - "Here's an outline of the `PokerHand` class and the `partition_suits` function you can use to get started." + "Aquí tienes un esquema de la clase `PokerHand` y de la función `partition_suits` que puedes usar para empezar.\n" ] }, { @@ -1830,7 +1830,7 @@ "tags": [] }, "source": [ - "To test your code, we'll make a deck and shuffle it." + "Para probar tu código, crearemos un mazo y lo barajaremos.\n" ] }, { @@ -1850,7 +1850,7 @@ "tags": [] }, "source": [ - "Then create a `PokerHand` and add seven cards to it." + "Luego crea una `PokerHand` y añádele siete cartas.\n" ] }, { @@ -1870,7 +1870,7 @@ "tags": [] }, "source": [ - "If you invoke `partition` and print the results, each hand should contain cards of one suit only." + "Si invocas `partition` e imprimes los resultados, cada mano debería contener solo cartas de un palo.\n" ] }, { @@ -1888,9 +1888,9 @@ "id": "218798e3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's the function from Chapter 11 that computes Fibonacci numbers." + "Aquí tienes la función del Capítulo 11 que calcula números de Fibonacci.\n" ] }, { @@ -1906,7 +1906,7 @@ "id": "6acab624", "metadata": {}, "source": [ - "Write a version of this function with a single return statement that use two conditional expressions, one nested inside the other." + "Escribe una versión de esta función con una sola sentencia retorno que use dos expresiones condicionales, una anidada dentro de la otra.\n" ] }, { @@ -1942,9 +1942,9 @@ "id": "2deb0e1f", "metadata": {}, "source": [ - "### Exercise\n", - "The following is a function that computes the binomial coefficient\n", - "recursively." + "### Ejercicio\n", + "La siguiente es una función que calcula el coeficiente binomial\n", + "de forma recursiva.\n" ] }, { @@ -1960,10 +1960,10 @@ "id": "656c61f6", "metadata": {}, "source": [ - "Rewrite the body of the function using nested conditional expressions.\n", + "Reescribe el cuerpo de la función usando expresiones condicionales anidadas.\n", "\n", - "This function is not very efficient because it ends up computing the same values over and over.\n", - "Make it more efficient by memoizing it, as described in [Chapter 10](section_memos)." + "Esta función no es muy eficiente porque acaba calculando los mismos valores una y otra vez.\n", + "Hazla más eficiente memoizándola, como se describe en el [Capítulo 10](section_memos).\n" ] }, { @@ -1987,9 +1987,9 @@ "id": "921719dc", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's the `__str__` method from the `Deck` class in [Chapter 17](section_print_deck)." + "Aquí tienes el método `__str__` de la clase `Deck` en el [Capítulo 17](section_print_deck).\n" ] }, { @@ -2005,7 +2005,7 @@ "id": "27f189cf", "metadata": {}, "source": [ - "Write a more concise version of this method with a list comprehension or generator expression." + "Escribe una versión más concisa de este método con una comprensión de listas o una expresión generadora.\n" ] }, { @@ -2025,7 +2025,7 @@ "tags": [] }, "source": [ - "You can use this example to test your solution." + "Puedes usar este ejemplo para probar tu solución.\n" ] }, { @@ -2053,13 +2053,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n" ] } ], @@ -2085,4 +2087,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/blank/chap19.ipynb b/blank/chap19.ipynb index 4d86fb8..be0fc26 100644 --- a/blank/chap19.ipynb +++ b/blank/chap19.ipynb @@ -5,9 +5,9 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", - "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." + "Puedes encargar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", + "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325).\n" ] }, { @@ -15,7 +15,7 @@ "id": "171aca73", "metadata": {}, "source": [ - "# Final thoughts" + "# Reflexiones finales\n" ] }, { @@ -23,19 +23,19 @@ "id": "4d551c99", "metadata": {}, "source": [ - "Learning to program is not easy, but if you made it this far, you are off to a good start.\n", - "Now I have some suggestions for ways you can keep learning and apply what you have learned.\n", + "Aprender a programar no es fácil, pero si has llegado hasta aquí, has empezado con buen pie.\n", + "Ahora tengo algunas sugerencias sobre cómo puedes seguir aprendiendo y aplicar lo que has aprendido.\n", "\n", - "This book is meant to be a general introduction to programming, so we have not focused on specific applications.\n", - "Depending on your interests, there are any number of areas where you can apply your new skills.\n", + "Este libro pretende ser una introducción general a la programación, así que no nos hemos centrado en aplicaciones específicas.\n", + "Según tus intereses, hay muchas áreas en las que puedes aplicar tus nuevas habilidades.\n", "\n", - "If you are interested in Data Science, there are three books of mine you might like:\n", + "Si te interesa la ciencia de datos, hay tres libros míos que podrían gustarte:\n", "\n", "* *Think Stats: Exploratory Data Analysis*, O'Reilly Media, 2014.\n", "\n", "* *Think Bayes: Bayesian Statistics in Python*, O'Reilly Media, 2021.\n", "\n", - "* *Think DSP: Digital Signal Processing in Python*, O'Reilly Media, 2016." + "* *Think DSP: Digital Signal Processing in Python*, O'Reilly Media, 2016.\n" ] }, { @@ -43,13 +43,13 @@ "id": "cceabe36", "metadata": {}, "source": [ - "If you are interested in physical modeling and complex systems, you might like:\n", + "Si te interesan el modelado físico y los sistemas complejos, quizá te gusten:\n", "\n", "* *Modeling and Simulation in Python: An Introduction for Scientists and Engineers*, No Starch Press, 2023.\n", "\n", "* *Think Complexity: Complexity Science and Computational Modeling*, O'Reilly Media, 2018.\n", "\n", - "These use NumPy, SciPy, pandas, and other Python libraries for data science and scientific computing." + "Estos libros usan NumPy, SciPy, pandas y otras librerías de Python para ciencia de datos y computación científica.\n" ] }, { @@ -57,13 +57,13 @@ "id": "54a39121", "metadata": {}, "source": [ - "This book tries to find a balance between general principles of programming and details of Python.\n", - "As a result, it does not include every feature of the Python language.\n", - "For more about Python, and good advice about how to use it, I recommend *Fluent Python: Clear, Concise, and Effective Programming*, second edition by Luciano Ramalho, O'Reilly Media, 2022.\n", + "Este libro intenta encontrar un equilibrio entre los principios generales de la programación y los detalles de Python.\n", + "Como resultado, no incluye todas las características del lenguaje Python.\n", + "Para saber más sobre Python, y para buenos consejos sobre cómo usarlo, recomiendo *Fluent Python: Clear, Concise, and Effective Programming*, segunda edición de Luciano Ramalho, O'Reilly Media, 2022.\n", "\n", - "After an introduction to programming, a common next step is to learn about data structures and algorithms.\n", - "I have a work in progress on this topic, called *Data Structures and Information Retrieval in Python*.\n", - "A free electronic version is available from Green Tea Press at ." + "Después de una introducción a la programación, un siguiente paso habitual es aprender sobre estructuras de datos y algoritmos.\n", + "Tengo una obra en curso sobre este tema, llamada *Data Structures and Information Retrieval in Python*.\n", + "Hay una versión electrónica gratuita disponible en Green Tea Press en .\n" ] }, { @@ -71,11 +71,11 @@ "id": "a1598510", "metadata": {}, "source": [ - "As you work on more complex programs, you will encounter new challenges.\n", - "You might find it helpful to review the sections in this book about debugging.\n", - "In particular, remember the Six R's of debugging from [Chapter 12](section_debugging_12): reading, running, ruminating, rubber-ducking, retreating, and resting.\n", + "A medida que trabajes en programas más complejos, encontrarás nuevos desafíos.\n", + "Puede resultarte útil repasar las secciones de este libro sobre depuración.\n", + "En particular, recuerda las seis R de la depuración del [Capítulo 12](section_deerrorging_12) (por sus nombres en inglés): leer, ejecutar, reflexionar, explicárselo a un patito de goma, tomar distancia y descansar.\n", "\n", - "This book suggests tools to help with debugging, including the `print` and `repr` functions, the `structshape` function in [Chapter 11](section_debugging_11) -- and the built-in functions `isinstance`, `hasattr`, and `vars` in [Chapter 14](section_debugging_14)." + "Este libro sugiere herramientas para ayudar con la depuración, incluidas las funciones `print` y `repr`, la función `structshape` del [Capítulo 11](section_deerrorging_11) -- y las funciones integradas `isinstance`, `hasattr` y `vars` del [Capítulo 14](section_deerrorging_14).\n" ] }, { @@ -83,12 +83,12 @@ "id": "fb4dd345", "metadata": {}, "source": [ - "It also suggests tools for testing programs, including the `assert` statement, the `doctest` module, and the `unittest` module.\n", - "Including tests in your programs is one of the best ways to prevent and detect errors, and save time debugging.\n", + "También sugiere herramientas para probar programas, incluidas la sentencia `assert`, el módulo `doctest` y el módulo `unittest`.\n", + "Incluir pruebas en tus programas es una de las mejores formas de prevenir y detectar errores, y de ahorrar tiempo en depuración.\n", "\n", - "But the best kind of debugging is the kind you don't have to do.\n", - "If you use an incremental development process as described in [Chapter 6](section_incremental) -- and test as you go -- you will make fewer errors and find them more quickly when you do.\n", - "Also, remember encapsulation and generalization from [Chapter 4](section_encapsulation), which is particularly useful when you are developing code in Jupyter notebooks." + "Pero la mejor depuración es el que no tienes que hacer.\n", + "Si usas un proceso de desarrollo incremental como se describe en el [Capítulo 6](section_incremental) -- y pruebas a medida que avanzas -- cometerás menos errores y los encontrarás más rápido cuando aparezcan.\n", + "Además, recuerda la encapsulación y la generalización del [Capítulo 4](section_encapsulation), que son especialmente útiles cuando desarrollas código en Jupyter notebooks.\n" ] }, { @@ -96,16 +96,16 @@ "id": "0d29933e", "metadata": {}, "source": [ - "Throughout this book, I've suggested ways to use virtual assistants to help you learn, program, and debug.\n", - "I hope you are finding these tools useful.\n", + "A lo largo de este libro, he sugerido formas de usar asistentes virtuales para ayudarte a aprender, programar y depurar.\n", + "Espero que estas herramientas te estén resultando útiles.\n", "\n", - "In additional to virtual assistants like ChatGPT, you might also want to use a tool like Copilot that autocompletes code as you type.\n", - "I did not recommend using these tools, initially, because they can be overwhelming for beginners.\n", - "But you might want to explore them now.\n", + "Además de asistentes virtuales como ChatGPT, quizá también quieras usar una herramienta como Copilot, que autocompleta código mientras escribes.\n", + "Al principio no recomendé usar estas herramientas porque pueden resultar abrumadoras para principiantes.\n", + "Pero quizá ahora quieras explorarlas.\n", "\n", - "Using AI tools effectively requires some experimentation and reflection to find a flow that works for you.\n", - "If you think it's a nuisance to copy code from ChatGPT to Jupyter, you might prefer something like Copilot.\n", - "But the cognitive work you do to compose a prompt and interpret the response can be as valuable as the code the tool generates, in the same vein as rubber duck debugging." + "Usar herramientas de AI de forma efectiva requiere algo de experimentación y reflexión para encontrar un flujo que funcione para ti.\n", + "Si te resulta molesto copiar código de ChatGPT a Jupyter, quizá prefieras algo como Copilot.\n", + "Pero el trabajo cognitivo que haces para componer un prompt e interpretar la respuesta puede ser tan valioso como el código que genera la herramienta, en la misma línea que la depuración con patito de goma.\n" ] }, { @@ -113,17 +113,17 @@ "id": "c28d6815", "metadata": {}, "source": [ - "As you gain programming experience, you might want to explore other development environments.\n", - "I think Jupyter notebooks are a good place to start, but they are relatively new and not as widely-used as conventional integrated development environments (IDE).\n", - "For Python, the most popular IDEs include PyCharm and Spyder -- and Thonny, which is often recommended for beginners.\n", - "Other IDEs, like Visual Studio Code and Eclipse, work with other programming languages as well.\n", - "Or, as a simpler alternative, you can write Python programs using any text editor you like.\n", - "\n", - "As you continue your programming journey, you don't have to go alone!\n", - "If you live in or near a city, there's a good chance there is a Python user group you can join.\n", - "These groups are usually friendly to beginners, so don't be afraid.\n", - "If there is no group near you, you might be able to join events remotely.\n", - "Also, keep an eye out for regional Python conferences." + "A medida que ganes experiencia programando, quizá quieras explorar otros entornos de desarrollo.\n", + "Creo que Jupyter notebooks es un buen lugar para empezar, pero son relativamente nuevos y no se usan tanto como los entornos de desarrollo integrados (IDE) convencionales.\n", + "Para Python, los IDE más populares incluyen PyCharm y Spyder -- y Thonny, que suele recomendarse para principiantes.\n", + "Otros IDE, como Visual Studio Código y Eclipse, también funcionan con otros lenguajes de programación.\n", + "O, como alternativa más sencilla, puedes escribir programas en Python usando cualquier editor de texto que te guste.\n", + "\n", + "Mientras continúas tu viaje en la programación, no tienes que hacerlo en soledad.\n", + "Si vives en una ciudad o cerca de una, es muy probable que haya un grupo de usuarios de Python al que puedas unirte.\n", + "Estos grupos suelen ser amables con principiantes, así que no tengas miedo.\n", + "Si no hay ningún grupo cerca de ti, quizá puedas unirte a eventos de forma remota.\n", + "Además, mantente atento a conferencias regionales de Python.\n" ] }, { @@ -131,12 +131,12 @@ "id": "28cb22bf", "metadata": {}, "source": [ - "One of the best ways to improve your programming skills is to learn another language.\n", - "If you are interested in statistics and data science, you might want to learn R.\n", - "But I particularly recommend learning a functional language like Racket or Elixir.\n", - "Functional programming requires a different kind of thinking, which changes the way you think about programs.\n", + "Una de las mejores formas de mejorar tus habilidades de programación es aprender otro lenguaje.\n", + "Si te interesan la estadística y ciencia de datos, quizá quieras aprender R.\n", + "Pero recomiendo especialmente aprender un lenguaje funcional como Racket o Elixir.\n", + "La programación funcional requiere una forma distinta de pensar, lo que cambia la manera en que piensas sobre los programas.\n", "\n", - "Good luck!" + "¡Buena suerte!\n" ] }, { @@ -154,13 +154,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n" ] } ], @@ -185,4 +187,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/chap00.ipynb b/chapters/chap00.ipynb index e7c283c..73fca92 100644 --- a/chapters/chap00.ipynb +++ b/chapters/chap00.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -15,7 +15,7 @@ "id": "d9724920", "metadata": {}, "source": [ - "# Preface\n", + "# Prefacio\n", "\n" ] }, @@ -24,21 +24,21 @@ "id": "b76f38c6", "metadata": {}, "source": [ - "## Who Is This Book For?\n", + "## ¿Para quién es este libro?\n", "\n", - "If you want to learn to program, you have come to the right place.\n", - "Python is one of the best programming languages for beginners -- and it is also one of the most in-demand skills.\n", + "Si quieres aprender a programar, has llegado al lugar adecuado.\n", + "Python es uno de los mejores lenguajes de programación para principiantes, y también una de las habilidades más demandadas.\n", "\n", - "You have also come at the right time, because learning to program now is probably easier than ever.\n", - "With virtual assistants like ChatGPT, you don't have to learn alone.\n", - "Throughout this book, I'll suggest ways you can use these tools to accelerate your learning.\n", + "También has llegado en el momento adecuado, porque aprender a programar ahora probablemente sea más fácil que nunca.\n", + "Con asistentes virtuales como ChatGPT, no tienes que aprender en soledad.\n", + "A lo largo de este libro, sugeriré formas de usar estas herramientas para acelerar tu aprendizaje.\n", "\n", - "This book is primarily for people who have never programmed before and people who have some experience in another programming language.\n", - "If you have substantial experience in Python, you might find the first few chapters too slow.\n", + "Este libro es principalmente para personas que nunca han programado y para personas que tienen algo de experiencia en otro lenguaje de programación.\n", + "Si tienes bastante experiencia en Python, quizá los primeros capítulos te parezcan demasiado lentos.\n", "\n", - "One of the challenges of learning to program is that you have to learn *two* languages: one is the programming language itself; the other is the vocabulary we use to talk about programs.\n", - "If you learn only the programming language, you are likely to have problems when you need to interpret an error message, read documentation, talk to another person, or use virtual assistants.\n", - "If you have done some programming, but you have not also learned this second language, I hope you find this book helpful." + "Uno de los retos de aprender a programar es que tienes que aprender *dos* lenguajes: uno es el propio lenguaje de programación; el otro es el vocabulario que usamos para hablar de programas.\n", + "Si solo aprendes el lenguaje de programación, es probable que tengas problemas cuando necesites interpretar un mensaje de error, leer documentación, hablar con otra persona o usar asistentes virtuales.\n", + "Si has programado algo, pero no has aprendido también este segundo lenguaje, espero que este libro te resulte útil." ] }, { @@ -46,21 +46,21 @@ "id": "b4dd57bc", "metadata": {}, "source": [ - "## Goals of the Book\n", + "## Objetivos del libro\n", "\n", - "Writing this book, I tried to be careful with the vocabulary.\n", - "I define each term when it first appears.\n", - "And there is a glossary at the end of each chapter that reviews the terms that were introduced.\n", + "Al escribir este libro, intenté tener cuidado con el vocabulario.\n", + "Defino cada término cuando aparece por primera vez.\n", + "Y al final de cada capítulo hay un glosario que repasa los términos que se han introducido.\n", "\n", - "I also tried to be concise.\n", - "The less mental effort it takes to read the book, the more capacity you will have for programming.\n", + "También intenté ser conciso.\n", + "Cuanto menos esfuerzo mental requiera leer el libro, más capacidad tendrás para programar.\n", "\n", - "But you can't learn to program just by reading a book -- you have to practice.\n", - "For that reason, this book includes exercises at the end of every chapter where you can practice what you have learned.\n", + "Pero no puedes aprender a programar solo leyendo un libro: tienes que practicar.\n", + "Por eso, este libro incluye ejercicios al final de cada capítulo en los que puedes practicar lo que has aprendido.\n", "\n", - "If you read carefully and work on exercises consistently, you will make progress.\n", - "But I'll warn you now -- learning to program is not easy, and even for experienced programmers it can be frustrating.\n", - "As we go, I will suggest strategies to help you write correct programs and fix incorrect ones." + "Si lees con atención y trabajas en los ejercicios de forma constante, avanzarás.\n", + "Pero te aviso desde ahora: aprender a programar no es fácil, e incluso para programadores con experiencia puede ser frustrante.\n", + "A medida que avancemos, sugeriré estrategias para ayudarte a escribir programas correctos y arreglar los incorrectos." ] }, { @@ -68,31 +68,31 @@ "id": "6516d914", "metadata": {}, "source": [ - "## Navigating the Book\n", + "## Cómo navegar por el libro\n", "\n", - "Each chapter in this book builds on the previous ones, so you should read them in order and take time to work on the exercises before you move on.\n", + "Cada capítulo de este libro se basa en los anteriores, así que deberías leerlos en orden y dedicar tiempo a trabajar en los ejercicios antes de seguir adelante.\n", "\n", - "The first six chapters introduce basic elements like arithmetic, conditionals, and loops.\n", - "They also introduce the most important concept in programming, functions, and a powerful way to use them, recursion.\n", + "Los primeros seis capítulos presentan elementos básicos como la aritmética, los condicionales y los bucles.\n", + "También presentan el concepto más importante de la programación, las funciones, y una forma potente de usarlas, la recursión.\n", "\n", - "Chapters 7 and 8 introduce strings -- which can represent letter, words, and sentences -- and algorithms for working with them.\n", + "Los capítulos 7 y 8 presentan strings, que pueden representar letras, palabras y frases, y algoritmos para trabajar con ellas.\n", "\n", - "Chapters 9 through 12 introduce Python's core data structures -- lists, dictionaries, and tuples -- which are powerful tools for writing efficient programs.\n", - "Chapter 12 presents algorithms for analyzing text and randomly generating new text.\n", - "Algorithms like these are at the core of large language models (LLMs), so this chapter will give you an idea of how tools like ChatGPT work.\n", + "Los capítulos 9 a 12 presentan las estructuras de datos principales de Python: listas, diccionarios y tuplas, que son herramientas potentes para escribir programas eficientes.\n", + "El capítulo 12 presenta algoritmos para analizar texto y generar texto nuevo de forma aleatoria.\n", + "Algoritmos como estos están en el núcleo de los modelos de lenguaje grandes (LLMs), así que este capítulo te dará una idea de cómo funcionan herramientas como ChatGPT.\n", "\n", - "Chapter 13 is about ways to store data in long-term storage -- files and databases.\n", - "As an exercise, you can write a program that searches a file system and finds duplicate files.\n", + "El capítulo 13 trata sobre formas de almacenar datos a largo plazo: archivos y bases de datos.\n", + "Como ejercicio, puedes escribir un programa que busque en un sistema de archivos y encuentre archivos duplicados.\n", "\n", - "Chapters 14 through 17 introduce object-oriented programming (OOP), which is a way to organize programs and the data they work with.\n", - "Many Python libraries are written in object-oriented style, so these chapters will help you understand their design -- and define your own objects.\n", + "Los capítulos 14 a 17 presentan la programación orientada a objetos (OOP), que es una forma de organizar programas y los datos con los que trabajan.\n", + "Muchas librerías de Python están escritas con estilo orientado a objetos, así que estos capítulos te ayudarán a entender su diseño y a definir tus propios objetos.\n", "\n", - "The goal of this book is not to cover the entire Python language.\n", - "Rather, I focus on a subset of the language that provides the greatest capability with the fewest concepts.\n", - "Nevertheless, Python has a lot of features you can use to solve common problems efficiently.\n", - "Chapter 18 presents some of these features.\n", + "El objetivo de este libro no es cubrir todo el lenguaje Python.\n", + "En cambio, me centro en un subconjunto del lenguaje que ofrece la mayor capacidad con el menor número de conceptos.\n", + "Aun así, Python tiene muchas características que puedes usar para resolver problemas comunes de forma eficiente.\n", + "El capítulo 18 presenta algunas de estas características.\n", "\n", - "Finally, Chapter 19 presents my parting thoughts and suggestions for continuing your programming journey." + "Por último, el capítulo 19 presenta mis reflexiones finales y sugerencias para continuar tu camino en la programación." ] }, { @@ -100,38 +100,38 @@ "id": "23013838", "metadata": {}, "source": [ - "## What's new in the third edition?\n", + "## ¿Qué hay de nuevo en la tercera edición?\n", "\n", - "The biggest changes in this edition were driven by two new technologies -- Jupyter notebooks and virtual assistants.\n", + "Los cambios más grandes de esta edición fueron impulsados por dos tecnologías nuevas: los Jupyter notebooks y los asistentes virtuales.\n", "\n", - "Each chapter of this book is a Jupyter notebook, which is a document that contains both ordinary text and code.\n", - "For me, that makes it easier to write the code, test it, and keep it consistent with the text.\n", - "For you, it means you can run the code, modify it, and work on the exercises, all in one place.\n", - "Instructions for working with the notebooks are in the first chapter.\n", + "Cada capítulo de este libro es un Jupyter notebook, que es un documento que contiene tanto texto normal como código.\n", + "Para mí, eso facilita escribir el código, probarlo y mantenerlo coherente con el texto.\n", + "Para ti, significa que puedes ejecutar el código, modificarlo y trabajar en los ejercicios, todo en un solo lugar.\n", + "Las instrucciones para trabajar con los notebooks están en el primer capítulo.\n", "\n", - "The other big change is that I've added advice for working with virtual assistants like ChatGPT and using them to accelerate your learning.\n", - "When the previous edition of this book was published in 2016, the predecessors of these tools were far less useful and most people were unaware of them. \n", - "Now they are a standard tool for software engineering, and I think they will be a transformational tool for learning to program -- and learning a lot of other things, too.\n", + "El otro gran cambio es que he añadido consejos para trabajar con asistentes virtuales como ChatGPT y usarlos para acelerar tu aprendizaje.\n", + "Cuando se publicó la edición anterior de este libro en 2016, los predecesores de estas herramientas eran mucho menos útiles y la mayoría de la gente no los conocía. \n", + "Ahora son una herramienta estándar para la ingeniería de software, y creo que serán una herramienta transformadora para aprender a programar, y para aprender muchas otras cosas también.\n", "\n", - "The other changes in the book were motivated by my regrets about the second edition.\n", + "Los demás cambios del libro fueron motivados por mis arrepentimientos sobre la segunda edición.\n", "\n", - "The first is that I did not emphasize software testing.\n", - "That was already a regrettable omission in 2016, but with the advent of virtual assistants, automated testing has become even more important.\n", - "So this edition presents Python's most widely-used testing tools, `doctest` and `unittest`, and includes several exercises where you can practice working with them.\n", + "El primero es que no puse suficiente énfasis en las pruebas de software.\n", + "Eso ya era una omisión lamentable en 2016, pero con la llegada de los asistentes virtuales, las pruebas automatizadas se han vuelto aún más importantes.\n", + "Así que esta edición presenta las herramientas de testing más usadas de Python, `doctest` y `unittest`, e incluye varios ejercicios donde puedes practicar con ellas.\n", "\n", - "My other regret is that the exercises in the second edition were uneven -- some were more interesting than others and some were too hard.\n", - "Moving to Jupyter notebooks helped me develop and test a more engaging and effective sequence of exercises.\n", + "Mi otro arrepentimiento es que los ejercicios de la segunda edición eran desiguales: algunos eran más interesantes que otros y algunos eran demasiado difíciles.\n", + "Pasar a Jupyter notebooks me ayudó a desarrollar y probar una secuencia de ejercicios más atractiva y eficaz.\n", "\n", - "In this revision, the sequence of topics is almost the same, but I rearranged a few of the chapters and compressed two short chapters into one.\n", - "Also, I expanded the coverage of strings to include regular expressions.\n", + "En esta revisión, la secuencia de temas es casi la misma, pero reorganicé algunos capítulos y comprimí dos capítulos cortos en uno.\n", + "Además, amplié la cobertura de strings para incluir expresiones regulares.\n", "\n", - "A few chapters use turtle graphics.\n", - "In previous editions, I used Python's `turtle` module, but unfortunately it doesn't work in Jupyter notebooks.\n", - "So I replaced it with a new turtle module that should be easier to use.\n", + "Algunos capítulos usan turtle graphics.\n", + "En ediciones anteriores usé el módulo `turtle` de Python, pero por desgracia no funciona en Jupyter notebooks.\n", + "Así que lo reemplacé por un nuevo turtle módulo que debería ser más fácil de usar.\n", "\n", - "Finally, I rewrote a substantial fraction of the text, clarifying places that needed it and cutting back in places where I was not as concise as I could be.\n", + "Por último, reescribí una parte considerable del texto, aclarando lugares que lo necesitaban y recortando en lugares donde no fui tan conciso como podía ser.\n", "\n", - "I am very proud of this new edition -- I hope you like it!" + "Estoy muy orgulloso de esta nueva edición. ¡Espero que te guste!" ] }, { @@ -139,27 +139,27 @@ "id": "bfb779bb", "metadata": {}, "source": [ - "## Getting started\n", + "## Primeros pasos\n", "\n", - "For most programming languages, including Python, there are many tools you can use to write and run programs. \n", - "These tools are called integrated development environments (IDEs).\n", - "In general, there are two kinds of IDEs:\n", + "Para la mayoría de los lenguajes de programación, incluido Python, hay muchas herramientas que puedes usar para escribir y ejecutar programas. \n", + "Estas herramientas se llaman entornos de desarrollo integrados (IDEs).\n", + "En general, hay dos tipos de IDEs:\n", "\n", - "* Some work with files that contain code, so they provide tools for editing and running these files.\n", + "* Algunos trabajan con archivos que contienen código, así que proporcionan herramientas para editar y ejecutar esos archivos.\n", "\n", - "* Others work primarily with notebooks, which are documents that contain text and code.\n", + "* Otros trabajan principalmente con notebooks, que son documentos que contienen texto y código.\n", "\n", - "For beginners, I recommend starting with a notebook development environment like Jupyter.\n", + "Para principiantes, recomiendo empezar con un entorno de desarrollo de notebooks como Jupyter.\n", "\n", - "The notebooks for this book are available from an online repository at .\n", + "Los notebooks de este libro están disponibles en un repositorio online en .\n", "\n", - "There are two ways to use them:\n", + "Hay dos formas de usarlos:\n", "\n", - "* You can download the notebooks and run them on your own computer. In that case, you have to install Python and Jupyter, which is not hard, but if you want to learn Python, it can be frustrating to spend a lot of time installing software.\n", + "* Puedes descargar los notebooks y ejecutarlos en tu propio ordenador. En ese caso, tienes que instalar Python y Jupyter, lo cual no es difícil, pero si quieres aprender Python puede ser frustrante pasar mucho tiempo instalando software.\n", "\n", - "* An alternative is to run the notebooks on Colab, which is a Jupyter environment that runs in a web browser, so you don't have to install anything. Colab is operated by Google, and it is free to use.\n", + "* Una alternativa es ejecutar los notebooks en Colab, que es un entorno Jupyter que se ejecuta en un navegador web, así que no tienes que instalar nada. Colab está operado por Google y es gratuito.\n", "\n", - "If you are just getting started, I strongly recommend you start with Colab." + "Si estás empezando, te recomiendo encarecidamente que empieces con Colab." ] }, { @@ -167,17 +167,17 @@ "id": "2ebd2412", "metadata": {}, "source": [ - "## Resources for Teachers\n", + "## Recursos para docentes\n", "\n", - "If you are teaching with this book, here are some resources you might find useful.\n", + "Si enseñas con este libro, aquí tienes algunos recursos que pueden resultarte útiles.\n", "\n", - "* You can find notebooks with solutions to the exercises at , along with links to the additional resources below.\n", + "* Puedes encontrar notebooks con soluciones a los ejercicios en , junto con enlaces a los recursos adicionales de abajo.\n", "\n", - "* Quizzes for each chapter, and a summative quiz for the whole book, are available on request.\n", + "* Hay cuestionarios para cada capítulo, y un cuestionario final para todo el libro, disponibles bajo petición.\n", "\n", - "* *Teaching and Learning with Jupyter* is an online book with suggestions for using Jupyter effectively in the classroom. You can read the book at \n", + "* *Teaching and Learning with Jupyter* es un libro online con sugerencias para usar Jupyter de forma eficaz en el aula. Puedes leer el libro en \n", "\n", - "* One of the best ways to use notebooks is live coding, where an instructor writes code and students follow along in their own notebooks. To learn about live coding -- and get other great advice about teaching programming -- I recommend the instructor training provided by The Carpentries, at " + "* Una de las mejores formas de usar notebooks es programación en vivo (live coding), donde un instructor escribe código y los estudiantes le siguen en sus propios notebooks. Para aprender sobre programación en vivo, y obtener otros grandes consejos sobre enseñanza de programación, recomiendo la formación para instructores ofrecida por The Carpentries, en " ] }, { @@ -185,29 +185,29 @@ "id": "28e7de55", "metadata": {}, "source": [ - "## Acknowledgments\n", + "## Agradecimientos\n", "\n", - "Many thanks to Jeff Elkner, who translated my Java book into Python,\n", - "which got this project started and introduced me to what has turned out\n", - "to be my favorite language.\n", - "Thanks also to Chris Meyers, who contributed several sections to *How to Think Like a Computer Scientist*.\n", + "Muchas gracias a Jeff Elkner, que tradujo mi libro de Java a Python,\n", + "lo que puso en marcha este proyecto y me presentó lo que ha acabado siendo\n", + "mi lenguaje favorito.\n", + "Gracias también a Chris Meyers, que contribuyó con varias secciones a *How to Think Like a Computer Scientist*.\n", "\n", - "Thanks to the Free Software Foundation for developing the GNU Free Documentation License, which helped make my collaboration with Jeff and Chris possible, and thanks to the Creative Commons for the license I am using now.\n", + "Gracias a la Free Software Foundation por desarrollar la GNU Free Documentation License, que ayudó a hacer posible mi colaboración con Jeff y Chris, y gracias a Creative Commons por la licencia que uso ahora.\n", "\n", - "Thanks to the developers and maintainers of the Python language and the libraries I used, including the Turtle graphics module; the tools I used to develop the book, including Jupyter and JupyterBook; and the services I used, including ChatGPT, Copilot, Colab and GitHub.\n", + "Gracias a quienes desarrollan y mantienen el lenguaje Python y las librerías que usé, incluido el módulo de Turtle graphics; las herramientas que usé para desarrollar el libro, incluidos Jupyter y JupyterBook; y los servicios que usé, incluidos ChatGPT, Copilot, Colab y GitHub.\n", "\n", - "Thanks to the editors at Lulu who worked on *How to Think Like a Computer Scientist* and the editors at O'Reilly Media who worked on *Think Python*.\n", + "Gracias a los editores de Lulu que trabajaron en *How to Think Like a Computer Scientist* y a los editores de O'Reilly Media que trabajaron en *Think Python*.\n", "\n", - "Special thanks to the technical reviewers for the second edition, Melissa Lewis and Luciano Ramalho, and for the third edition, Sam Lau and Luciano Ramalho (again!).\n", - "I am also grateful to Luciano for developing the turtle graphics module I use in several chapters, called `jupyturtle`.\n", + "Un agradecimiento especial a los revisores técnicos de la segunda edición, Melissa Lewis y Luciano Ramalho, y de la tercera edición, Sam Lau y Luciano Ramalho (¡otra vez!).\n", + "También agradezco a Luciano haber desarrollado el turtle graphics módulo que uso en varios capítulos, llamado `jupyturtle`.\n", "\n", - "Thanks to all the students who worked with earlier versions of this book and all the contributors who sent in corrections and suggestions.\n", - "More than 100 sharp-eyed and thoughtful readers have sent in suggestions and corrections over the past few years. Their contributions, and enthusiasm for this project, have been a huge help.\n", + "Gracias a todos los estudiantes que trabajaron con versiones anteriores de este libro y a todos los colaboradores que enviaron correcciones y sugerencias.\n", + "Más de 100 lectores atentos y reflexivos han enviado sugerencias y correcciones durante los últimos años. Sus contribuciones, y su entusiasmo por este proyecto, han sido de enorme ayuda.\n", "\n", - "If you have a suggestion or correction, please send email to `feedback@thinkpython.com`.\n", - "If you include at least part of the sentence the error appears in, that\n", - "makes it easy for me to search. Page and section numbers are fine, too,\n", - "but not quite as easy to work with. Thanks!" + "Si tienes una sugerencia o corrección, envía un email a `feedback@thinkpython.com`.\n", + "Si incluyes al menos una parte de la frase en la que aparece el error, eso\n", + "me facilita la búsqueda. Los números de página y sección también sirven,\n", + "pero no son tan fáciles de manejar. ¡Gracias!" ] }, { @@ -225,13 +225,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/chapters/chap01.ipynb b/chapters/chap01.ipynb index bd3875d..5f4c579 100644 --- a/chapters/chap01.ipynb +++ b/chapters/chap01.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -17,14 +17,14 @@ "tags": [] }, "source": [ - "# Welcome\n", + "# Bienvenida\n", "\n", - "This is the Jupyter notebook for Chapter 1 of [*Think Python*, 3rd edition](https://greenteapress.com/wp/think-python-3rd-edition), by Allen B. Downey.\n", + "Este es el Jupyter notebook del capítulo 1 de [*Think Python*, 3.ª edición](https://greenteapress.com/wp/think-python-3rd-edition), de Allen B. Downey.\n", "\n", - "If you are not familiar with Jupyter notebooks,\n", - "[click here for a short introduction](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb).\n", + "Si no conoces los Jupyter notebooks,\n", + "[haz clic aquí para ver una breve introducción](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb).\n", "\n", - "Then, if you are not already running this notebook on Colab, [click here to run this notebook on Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." + "Luego, si aún no estás ejecutando este notebook en Colab, [haz clic aquí para ejecutar este notebook en Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." ] }, { @@ -34,9 +34,9 @@ "tags": [] }, "source": [ - "The following cell downloads a file and runs some code that is used specifically for this book.\n", - "You don't have to understand this code yet, but you should run it before you do anything else in this notebook.\n", - "Remember that you can run the code by selecting the cell and pressing the play button (a triangle in a circle) or hold down `Shift` and press `Enter`." + "La siguiente celda descarga un archivo y ejecuta algo de código que se usa específicamente para este libro.\n", + "Todavía no tienes que entender este código, pero deberías ejecutarlo antes de hacer cualquier otra cosa en este notebook.\n", + "Recuerda que puedes ejecutar el código seleccionando la celda y pulsando el botón de reproducción (un triángulo dentro de un círculo) o manteniendo pulsada la tecla `Shift` y presionando `Enter`." ] }, { @@ -71,21 +71,21 @@ "tags": [] }, "source": [ - "# Programming as a way of thinking\n", + "# Programar como una forma de pensar\n", "\n", - "The first goal of this book is to teach you how to program in Python.\n", - "But learning to program means learning a new way to think, so the second goal of this book is to help you think like a computer scientist.\n", - "This way of thinking combines some of the best features of mathematics, engineering, and natural science.\n", - "Like mathematicians, computer scientists use formal languages to denote ideas -- specifically computations.\n", - "Like engineers, they design things, assembling components into systems and evaluating trade-offs among alternatives.\n", - "Like scientists, they observe the behavior of complex systems, form hypotheses, and test predictions.\n", + "El primer objetivo de este libro es enseñarte a programar en Python.\n", + "Pero aprender a programar implica aprender una nueva forma de pensar, así que el segundo objetivo de este libro es ayudarte a pensar como un científico de la computación.\n", + "Esta forma de pensar combina algunas de las mejores características de las matemáticas, la ingeniería y las ciencias naturales.\n", + "Como los matemáticos, los científicos de la computación usan lenguajes formales para expresar ideas -- específicamente, cómputos.\n", + "Como los ingenieros, diseñan cosas, ensamblan componentes en sistemas y evalúan las ventajas y desventajas de distintas alternativas.\n", + "Como los científicos, observan el comportamiento de sistemas complejos, formulan hipótesis y prueban predicciones.\n", "\n", - "We will start with the most basic elements of programming and work our way up.\n", - "In this chapter, we'll see how Python represents numbers, letters, and words.\n", - "And you'll learn to perform arithmetic operations.\n", + "Empezaremos con los elementos más básicos de la programación y avanzaremos poco a poco.\n", + "En este capítulo veremos cómo Python representa números, letras y palabras.\n", + "Y aprenderás a realizar operaciones aritméticas.\n", "\n", - "You will also start to learn the vocabulary of programming, including terms like operator, expression, value, and type.\n", - "This vocabulary is important -- you will need it to understand the rest of the book, to communicate with other programmers, and to use and understand virtual assistants." + "También empezarás a aprender el vocabulario de la programación, incluyendo términos como operador, expresión, valor y tipo.\n", + "Este vocabulario es importante -- lo necesitarás para entender el resto del libro, comunicarte con otros programadores y usar y entender asistentes virtuales." ] }, { @@ -93,9 +93,9 @@ "id": "a371aea3", "metadata": {}, "source": [ - "## Arithmetic operators\n", + "## Operadores aritméticos\n", "\n", - "An **arithmetic operator** is a symbol that represents an arithmetic computation. For example, the plus sign, `+`, performs addition." + "Un **operador aritmético** es un símbolo que representa un cálculo aritmético. Por ejemplo, el signo más, `+`, realiza una suma." ] }, { @@ -113,7 +113,7 @@ "id": "fc0e7ce8", "metadata": {}, "source": [ - "The minus sign, `-`, is the operator that performs subtraction." + "El signo menos, `-`, es el operador que realiza una resta." ] }, { @@ -131,7 +131,7 @@ "id": "63e4e780", "metadata": {}, "source": [ - "The asterisk, `*`, performs multiplication." + "El asterisco, `*`, realiza una multiplicación." ] }, { @@ -149,7 +149,7 @@ "id": "a6192d13", "metadata": {}, "source": [ - "And the forward slash, `/`, performs division:" + "Y la barra inclinada, `/`, realiza una división:" ] }, { @@ -167,16 +167,16 @@ "id": "641ad233", "metadata": {}, "source": [ - "Notice that the result of the division is `42.0` rather than `42`. That's because there are two types of numbers in Python: \n", + "Observa que el resultado de la división es `42.0` en lugar de `42`. Eso se debe a que hay dos tipos de números en Python: \n", "\n", - "* **integers**, which represent numbers with no fractional or decimal part, and \n", + "* **enteros**, que representan números sin parte fraccionaria o decimal, y \n", "\n", - "* **floating-point numbers**, which represent integers and numbers with a decimal point.\n", + "* **números de coma flotante**, que representan enteros y números con punto decimal.\n", "\n", - "If you add, subtract, or multiply two integers, the result is an integer.\n", - "But if you divide two integers, the result is a floating-point number.\n", - "Python provides another operator, `//`, that performs **integer division**.\n", - "The result of integer division is always an integer." + "Si sumas, restas o multiplicas dos enteros, el resultado es un entero.\n", + "Pero si divides dos enteros, el resultado es un número de coma flotante.\n", + "Python proporciona otro operador, `//`, que realiza **división entera**.\n", + "El resultado de la división entera siempre es un entero." ] }, { @@ -194,7 +194,7 @@ "id": "b2a620ab", "metadata": {}, "source": [ - "Integer division is also called \"floor division\" because it always rounds down (toward the \"floor\"). " + "La división entera también se llama \"división de piso\" porque siempre redondea hacia abajo (hacia el \"piso\"). " ] }, { @@ -212,8 +212,7 @@ "id": "41e2886a", "metadata": {}, "source": [ - "Finally, the operator `**` performs exponentiation; that is, it raises a\n", - "number to a power:" + "Por último, el operador `**` realiza exponenciación; es decir, eleva un número a una potencia:" ] }, { @@ -231,9 +230,8 @@ "id": "b2502fb6", "metadata": {}, "source": [ - "In some other languages, the caret, `^`, is used for exponentiation, but in Python\n", - "it is a bitwise operator called XOR.\n", - "If you are not familiar with bitwise operators, the result might be unexpected:" + "En algunos otros lenguajes, el acento circunflejo, `^`, se usa para la exponenciación, pero en Python es un operador bit a bit llamado XOR.\n", + "Si no conoces los operadores bit a bit, el resultado puede ser inesperado:" ] }, { @@ -251,8 +249,7 @@ "id": "30078370", "metadata": {}, "source": [ - "I won't cover bitwise operators in this book, but you can read about\n", - "them at ." + "No cubriré los operadores bit a bit en este libro, pero puedes leer sobre ellos en ." ] }, { @@ -260,11 +257,11 @@ "id": "0f5b7e97", "metadata": {}, "source": [ - "## Expressions\n", + "## Expresiones\n", "\n", - "A collection of operators and numbers is called an **expression**.\n", - "An expression can contain any number of operators and numbers.\n", - "For example, here's an expression that contains two operators." + "Un conjunto de operadores y números se llama una **expresión**.\n", + "Una expresión puede contener cualquier cantidad de operadores y números.\n", + "Por ejemplo, aquí hay una expresión que contiene dos operadores." ] }, { @@ -282,10 +279,10 @@ "id": "8e95039c", "metadata": {}, "source": [ - "Notice that exponentiation happens before addition.\n", - "Python follows the order of operations you might have learned in a math class: exponentiation happens before multiplication and division, which happen before addition and subtraction.\n", + "Observa que la exponenciación ocurre antes que la suma.\n", + "Python sigue el orden de operaciones que quizá aprendiste en clase de matemáticas: la exponenciación ocurre antes que la multiplicación y la división, que ocurren antes que la suma y la resta.\n", "\n", - "In the following example, multiplication happens before addition." + "En el siguiente ejemplo, la multiplicación ocurre antes que la suma." ] }, { @@ -303,7 +300,7 @@ "id": "914a60d8", "metadata": {}, "source": [ - "If you want the addition to happen first, you can use parentheses." + "Si quieres que la suma ocurra primero, puedes usar paréntesis." ] }, { @@ -321,8 +318,8 @@ "id": "67ae0ae9", "metadata": {}, "source": [ - "Every expression has a **value**.\n", - "For example, the expression `6 * 7` has the value `42`." + "Toda expresión tiene un **valor**.\n", + "Por ejemplo, la expresión `6 * 7` tiene el valor `42`." ] }, { @@ -330,10 +327,10 @@ "id": "caebaa51", "metadata": {}, "source": [ - "## Arithmetic functions\n", + "## Funciones aritméticas\n", "\n", - "In addition to the arithmetic operators, Python provides a few **functions** that work with numbers.\n", - "For example, the `round` function takes a floating-point number and rounds it off to the nearest integer." + "Además de los operadores aritméticos, Python proporciona algunas **funciones** que trabajan con números.\n", + "Por ejemplo, la función `round` toma un número de coma flotante y lo redondea al entero más cercano." ] }, { @@ -361,8 +358,8 @@ "id": "f5738b4b", "metadata": {}, "source": [ - "The `abs` function computes the absolute value of a number.\n", - "For a positive number, the absolute value is the number itself." + "La función `abs` calcula el valor absoluto de un número.\n", + "Para un número positivo, el valor absoluto es el propio número." ] }, { @@ -380,7 +377,7 @@ "id": "e518494a", "metadata": {}, "source": [ - "For a negative number, the absolute value is positive." + "Para un número negativo, el valor absoluto es positivo." ] }, { @@ -398,11 +395,11 @@ "id": "6969ce45", "metadata": {}, "source": [ - "When we use a function like this, we say we're **calling** the function.\n", - "An expression that calls a function is a **function call**.\n", + "Cuando usamos una función como esta, decimos que estamos **llamando** a la función.\n", + "Una expresión que llama a una función es una **llamada a función**.\n", "\n", - "When you call a function, the parentheses are required.\n", - "If you leave them out, you get an error message." + "Cuando llamas a una función, los paréntesis son obligatorios.\n", + "Si los omites, obtienes un mensaje de error." ] }, { @@ -412,8 +409,8 @@ "tags": [] }, "source": [ - "NOTE: The following cell uses `%%expect`, which is a Jupyter \"magic command\" that means we expect the code in this cell to produce an error. For more on this topic, see the\n", - "[Jupyter notebook introduction](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." + "NOTA: La siguiente celda usa `%%expect`, que es un \"magic command\" de Jupyter que significa que esperamos que el código de esta celda produzca un error. Para más información sobre este tema, consulta la\n", + "[introducción a Jupyter notebook](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." ] }, { @@ -435,13 +432,13 @@ "id": "7d356f1b", "metadata": {}, "source": [ - "You can ignore the first line of this message; it doesn't contain any information we need to understand right now.\n", - "The second line is the code that contains the error, with a caret (`^`) beneath it to indicate where the error was discovered.\n", + "Puedes ignorar la primera línea de este mensaje; no contiene ninguna información que necesitemos entender ahora mismo.\n", + "La segunda línea es el código que contiene el error, con un acento circunflejo (`^`) debajo para indicar dónde se descubrió el error.\n", "\n", - "The last line indicates that this is a **syntax error**, which means that there is something wrong with the structure of the expression.\n", - "In this example, the problem is that a function call requires parentheses.\n", + "La última línea indica que se trata de un **error de sintaxis**, lo que significa que hay algo incorrecto en la estructura de la expresión.\n", + "En este ejemplo, el problema es que una llamada a función requiere paréntesis.\n", "\n", - "Let's see what happens if you leave out the parentheses *and* the value." + "Veamos qué ocurre si omites los paréntesis *y* el valor." ] }, { @@ -459,8 +456,8 @@ "id": "94478885", "metadata": {}, "source": [ - "A function name all by itself is a legal expression that has a value.\n", - "When it's displayed, the value indicates that `abs` is a function, and it includes some additional information I'll explain later." + "Un nombre de función por sí solo es una expresión válida que tiene un valor.\n", + "Cuando se muestra, el valor indica que `abs` es una función e incluye información adicional que explicaré más adelante." ] }, { @@ -470,8 +467,8 @@ "source": [ "## Strings\n", "\n", - "In addition to numbers, Python can also represent sequences of letters, which are called **strings** because the letters are strung together like beads on a necklace.\n", - "To write a string, we can put a sequence of letters inside straight quotation marks." + "Además de números, Python también puede representar secuencias de letras, que se llaman **strings** porque las letras están ensartadas como cuentas en un collar.\n", + "Para escribir un string, podemos poner una secuencia de letras entre comillas rectas." ] }, { @@ -489,7 +486,7 @@ "id": "d20050d8", "metadata": {}, "source": [ - "It is also legal to use double quotation marks." + "También es válido usar comillas dobles." ] }, { @@ -507,7 +504,7 @@ "id": "76f5edb7", "metadata": {}, "source": [ - "Double quotes make it easy to write a string that contains an apostrophe, which is the same symbol as a straight quote." + "Las comillas dobles facilitan escribir un string que contiene un apóstrofo, que es el mismo símbolo que una comilla recta." ] }, { @@ -525,7 +522,7 @@ "id": "d62d4b1c", "metadata": {}, "source": [ - "Strings can also contain spaces, punctuation, and digits." + "Los strings también pueden contener espacios, signos de puntuación y dígitos." ] }, { @@ -543,7 +540,7 @@ "id": "9ad47f7a", "metadata": {}, "source": [ - "The `+` operator works with strings; it joins two strings into a single string, which is called **concatenation**" + "El operador `+` funciona con strings; une dos strings en un solo string, lo que se llama **concatenación**" ] }, { @@ -561,7 +558,7 @@ "id": "0ad969a3", "metadata": {}, "source": [ - "The `*` operator also works with strings; it makes multiple copies of a string and concatenates them." + "El operador `*` también funciona con strings; hace varias copias de un string y las concatena." ] }, { @@ -579,9 +576,9 @@ "id": "dfba16a5", "metadata": {}, "source": [ - "The other arithmetic operators don't work with strings.\n", + "Los otros operadores aritméticos no funcionan con strings.\n", "\n", - "Python provides a function called `len` that computes the length of a string." + "Python proporciona una función llamada `len` que calcula la longitud de un string." ] }, { @@ -599,10 +596,10 @@ "id": "d91e00b3", "metadata": {}, "source": [ - "Notice that `len` counts the letters between the quotes, but not the quotes.\n", + "Observa que `len` cuenta las letras entre las comillas, pero no las comillas.\n", "\n", - "When you create a string, be sure to use straight quotes.\n", - "The back quote, also known as a backtick, causes a syntax error." + "Cuando crees un string, asegúrate de usar comillas rectas.\n", + "La comilla invertida, también conocida como backtick, causa un error de sintaxis." ] }, { @@ -624,7 +621,7 @@ "id": "40d893d1", "metadata": {}, "source": [ - "Smart quotes, also known as curly quotes, are also illegal." + "Las comillas tipográficas, también conocidas como comillas curvas, tampoco son válidas." ] }, { @@ -646,21 +643,21 @@ "id": "5471d4f8", "metadata": {}, "source": [ - "## Values and types\n", + "## Valores y tipos\n", "\n", - "So far we've seen three kinds of values:\n", + "Hasta ahora hemos visto tres clases de valores:\n", "\n", - "* `2` is an integer,\n", + "* `2` es un entero,\n", "\n", - "* `42.0` is a floating-point number, and \n", + "* `42.0` es un número de coma flotante, y \n", "\n", - "* `'Hello'` is a string.\n", + "* `'Hello'` es un string.\n", "\n", - "A kind of value is called a **type**.\n", - "Every value has a type -- or we sometimes say it \"belongs to\" a type.\n", + "Una clase de valor se llama **tipo**.\n", + "Todo valor tiene un tipo -- o a veces decimos que \"pertenece a\" un tipo.\n", "\n", - "Python provides a function called `type` that tells you the type of any value.\n", - "The type of an integer is `int`." + "Python proporciona una función llamada `type` que te dice el tipo de cualquier valor.\n", + "El tipo de un entero es `int`." ] }, { @@ -678,7 +675,7 @@ "id": "b137814c", "metadata": {}, "source": [ - "The type of a floating-point number is `float`." + "El tipo de un número de coma flotante es `float`." ] }, { @@ -696,7 +693,7 @@ "id": "266dea4e", "metadata": {}, "source": [ - "And the type of a string is `str`." + "Y el tipo de un string es `str`." ] }, { @@ -714,8 +711,8 @@ "id": "76d216ed", "metadata": {}, "source": [ - "The types `int`, `float`, and `str` can be used as functions.\n", - "For example, `int` can take a floating-point number and convert it to an integer (always rounding down)." + "Los tipos `int`, `float` y `str` se pueden usar como funciones.\n", + "Por ejemplo, `int` puede tomar un número de coma flotante y convertirlo en un entero (siempre redondeando hacia abajo)." ] }, { @@ -733,7 +730,7 @@ "id": "dcd8d114", "metadata": {}, "source": [ - "And `float` can convert an integer to a floating-point value." + "Y `float` puede convertir un entero en un valor de punto flotante." ] }, { @@ -751,8 +748,8 @@ "id": "eda70b61", "metadata": {}, "source": [ - "Now, here's something that can be confusing.\n", - "What do you get if you put a sequence of digits in quotes?" + "Ahora, aquí hay algo que puede ser confuso.\n", + "¿Qué obtienes si pones una secuencia de dígitos entre comillas?" ] }, { @@ -770,7 +767,7 @@ "id": "fdded653", "metadata": {}, "source": [ - "It looks like a number, but it is actually a string." + "Parece un número, pero en realidad es un string." ] }, { @@ -788,7 +785,7 @@ "id": "2683ac35", "metadata": {}, "source": [ - "If you try to use it like a number, you might get an error." + "Si intentas usarlo como un número, puede que obtengas un error." ] }, { @@ -810,10 +807,10 @@ "id": "32c11cc4", "metadata": {}, "source": [ - "This example generates a `TypeError`, which means that the values in the expression, which are called **operands**, have the wrong type.\n", - "The error message indicates that the `/` operator does not support the types of these values, which are `str` and `int`.\n", + "Este ejemplo genera un `TypeError`, lo que significa que los valores de la expresión, que se llaman **operandos**, tienen el tipo incorrecto.\n", + "El mensaje de error indica que el operador `/` no admite los tipos de estos valores, que son `str` e `int`.\n", "\n", - "If you have a string that contains digits, you can use `int` to convert it to an integer." + "Si tienes un string que contiene dígitos, puedes usar `int` para convertirlo en un entero." ] }, { @@ -831,7 +828,7 @@ "id": "86935d56", "metadata": {}, "source": [ - "If you have a string that contains digits and a decimal point, you can use `float` to convert it to a floating-point number." + "Si tienes un string que contiene dígitos y un punto decimal, puedes usar `float` para convertirlo en un número de coma flotante." ] }, { @@ -849,9 +846,8 @@ "id": "03103ef4", "metadata": {}, "source": [ - "When you write a large integer, you might be tempted to use commas\n", - "between groups of digits, as in `1,000,000`.\n", - "This is a legal expression in Python, but the result is not an integer." + "Cuando escribes un entero grande, puede que te sientas tentado a usar comas entre grupos de dígitos, como en `1,000,000`.\n", + "Esta es una expresión válida en Python, pero el resultado no es un entero." ] }, { @@ -869,10 +865,10 @@ "id": "3d24af71", "metadata": {}, "source": [ - "Python interprets `1,000,000` as a comma-separated sequence of integers.\n", - "We'll learn more about this kind of sequence later.\n", + "Python interpreta `1,000,000` como una secuencia de enteros separados por comas.\n", + "Aprenderemos más sobre este tipo de secuencia más adelante.\n", "\n", - "You can use underscores to make large numbers easier to read." + "Puedes usar guiones bajos para que los números grandes sean más fáciles de leer." ] }, { @@ -890,13 +886,13 @@ "id": "1761cbac", "metadata": {}, "source": [ - "## Formal and natural languages\n", + "## Lenguajes formales y naturales\n", "\n", - "**Natural languages** are the languages people speak, like English, Spanish, and French. They were not designed by people; they evolved naturally.\n", + "Los **lenguajes naturales** son los idiomas que hablan las personas, como inglés, español y francés. No fueron diseñados por personas; evolucionaron de forma natural.\n", "\n", - "**Formal languages** are languages that are designed by people for specific applications. \n", - "For example, the notation that mathematicians use is a formal language that is particularly good at denoting relationships among numbers and symbols.\n", - "Similarly, programming languages are formal languages that have been designed to express computations." + "Los **lenguajes formales** son lenguajes diseñados por personas para aplicaciones específicas. \n", + "Por ejemplo, la notación que usan los matemáticos es un lenguaje formal especialmente bueno para representar relaciones entre números y símbolos.\n", + "De forma similar, los lenguajes de programación son lenguajes formales diseñados para expresar cómputos." ] }, { @@ -904,19 +900,13 @@ "id": "1bf3d2dc", "metadata": {}, "source": [ - "Although formal and natural languages have some features in\n", - "common there are important differences:\n", + "Aunque los lenguajes formales y naturales tienen algunas características en común, hay diferencias importantes:\n", "\n", - "* Ambiguity: Natural languages are full of ambiguity, which people deal with by\n", - " using contextual clues and other information. Formal languages are\n", - " designed to be nearly or completely unambiguous, which means that\n", - " any program has exactly one meaning, regardless of context.\n", + "* Ambigüedad: Los lenguajes naturales están llenos de ambigüedad, que las personas manejan usando pistas contextuales y otra información. Los lenguajes formales están diseñados para ser casi o completamente no ambiguos, lo que significa que cualquier programa tiene exactamente un significado, independientemente del contexto.\n", "\n", - "* Redundancy: In order to make up for ambiguity and reduce misunderstandings,\n", - " natural languages use redundancy. As a result, they are\n", - " often verbose. Formal languages are less redundant and more concise.\n", + "* Redundancia: Para compensar la ambigüedad y reducir malentendidos, los lenguajes naturales usan redundancia. Como resultado, a menudo son verbosos. Los lenguajes formales son menos redundantes y más concisos.\n", "\n", - "* Literalness: Natural languages are full of idiom and metaphor. Formal languages mean exactly what they say." + "* Literalidad: Los lenguajes naturales están llenos de modismos y metáforas. Los lenguajes formales significan exactamente lo que dicen." ] }, { @@ -924,12 +914,10 @@ "id": "78a1cec8", "metadata": {}, "source": [ - "Because we all grow up speaking natural languages, it is sometimes hard to adjust to formal languages.\n", - "Formal languages are more dense than natural languages, so it takes longer to read them.\n", - "Also, the structure is important, so it is not always best to read from top to bottom, left to right.\n", - "Finally, the details matter. Small errors in spelling and\n", - "punctuation, which you can get away with in natural languages, can make\n", - "a big difference in a formal language." + "Como todos crecemos hablando lenguajes naturales, a veces cuesta adaptarse a los lenguajes formales.\n", + "Los lenguajes formales son más densos que los lenguajes naturales, así que lleva más tiempo leerlos.\n", + "Además, la estructura es importante, por lo que no siempre es mejor leer de arriba abajo, de izquierda a derecha.\n", + "Por último, los detalles importan. Pequeños errores de ortografía y puntuación, que puedes tolerar en los lenguajes naturales, pueden marcar una gran diferencia en un lenguaje formal." ] }, { @@ -939,15 +927,15 @@ "source": [ "## Debugging\n", "\n", - "Programmers make mistakes. For whimsical reasons, programming errors are called **bugs** and the process of tracking them down is called **debugging**.\n", + "Los programadores cometen errores. Por razones caprichosas, los errores de programación se llaman **bugs** y el proceso de encontrarlos se llama **debugging**.\n", "\n", - "Programming, and especially debugging, sometimes brings out strong emotions. If you are struggling with a difficult bug, you might feel angry, sad, or embarrassed.\n", + "Programar, y especialmente debugging, a veces provoca emociones intensas. Si estás luchando con un bug difícil, puede que sientas enfado, tristeza o vergüenza.\n", "\n", - "Preparing for these reactions might help you deal with them. One approach is to think of the computer as an employee with certain strengths, like speed and precision, and particular weaknesses, like lack of empathy and inability to grasp the big picture.\n", + "Prepararte para estas reacciones puede ayudarte a manejarlas. Un enfoque es pensar en la computadora como un empleado con ciertas fortalezas, como velocidad y precisión, y debilidades particulares, como falta de empatía e incapacidad para captar el panorama general.\n", "\n", - "Your job is to be a good manager: find ways to take advantage of the strengths and mitigate the weaknesses. And find ways to use your emotions to engage with the problem, without letting your reactions interfere with your ability to work effectively.\n", + "Tu trabajo es ser un buen gerente: encontrar formas de aprovechar las fortalezas y mitigar las debilidades. Y encontrar formas de usar tus emociones para involucrarte con el problema, sin dejar que tus reacciones interfieran con tu capacidad de trabajar eficazmente.\n", "\n", - "Learning to debug can be frustrating, but it is a valuable skill that is useful for many activities beyond programming. At the end of each chapter there is a section, like this one, with my suggestions for debugging. I hope they help!" + "Aprender a debug puede ser frustrante, pero es una habilidad valiosa que resulta útil para muchas actividades más allá de la programación. Al final de cada capítulo hay una sección, como esta, con mis sugerencias para debugging. ¡Espero que te ayuden!" ] }, { @@ -955,62 +943,62 @@ "id": "33b8ad00", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**arithmetic operator:**\n", - "A symbol, like `+` and `*`, that denotes an arithmetic operation like addition or multiplication.\n", + "**operador aritmético:**\n", + "Un símbolo, como `+` y `*`, que denota una operación aritmética como suma o multiplicación.\n", "\n", - "**integer:**\n", - "A type that represents numbers with no fractional or decimal part.\n", + "**entero:**\n", + "Un tipo que representa números sin parte fraccionaria o decimal.\n", "\n", - "**floating-point:**\n", - "A type that represents integers and numbers with decimal parts.\n", + "**número de coma flotante:**\n", + "Un tipo que representa enteros y números con partes decimales.\n", "\n", - "**integer division:**\n", - "An operator, `//`, that divides two numbers and rounds down to an integer.\n", + "**división entera:**\n", + "Un operador, `//`, que divide dos números y redondea hacia abajo a un entero.\n", "\n", - "**expression:**\n", - "A combination of variables, values, and operators.\n", + "**expresión:**\n", + "Una combinación de variables, valores y operadores.\n", "\n", - "**value:**\n", - "An integer, floating-point number, or string -- or one of other kinds of values we will see later.\n", + "**valor:**\n", + "Un entero, número de coma flotante o string -- u otro de los tipos de valores que veremos más adelante.\n", "\n", - "**function:**\n", - "A named sequence of statements that performs some useful operation.\n", - "Functions may or may not take arguments and may or may not produce a result.\n", + "**función:**\n", + "Una secuencia con nombre de sentencias que realiza alguna operación útil.\n", + "Las funciones pueden tomar argumentos o no, y pueden producir un resultado o no.\n", "\n", - "**function call:**\n", - "An expression -- or part of an expression -- that runs a function.\n", - "It consists of the function name followed by an argument list in parentheses.\n", + "**llamada a función:**\n", + "Una expresión -- o parte de una expresión -- que ejecuta una función.\n", + "Consiste en el nombre de la función seguido de una lista de argumentos entre paréntesis.\n", "\n", - "**syntax error:**\n", - "An error in a program that makes it impossible to parse -- and therefore impossible to run.\n", + "**error de sintaxis:**\n", + "Un error en un programa que hace imposible analizarlo -- y por lo tanto imposible ejecutarlo.\n", "\n", "**string:**\n", - " A type that represents sequences of characters.\n", + " Un tipo que representa secuencias de caracteres.\n", "\n", - "**concatenation:**\n", - "Joining two strings end-to-end.\n", + "**concatenación:**\n", + "Unir dos strings extremo con extremo.\n", "\n", - "**type:**\n", - "A category of values.\n", - "The types we have seen so far are integers (type `int`), floating-point numbers (type ` float`), and strings (type `str`).\n", + "**tipo:**\n", + "Una categoría de valores.\n", + "Los tipos que hemos visto hasta ahora son enteros (tipo `int`), números de coma flotante (tipo ` float`) y strings (tipo `str`).\n", "\n", - "**operand:**\n", - "One of the values on which an operator operates.\n", + "**operando:**\n", + "Uno de los valores sobre los que opera un operador.\n", "\n", - "**natural language:**\n", - "Any of the languages that people speak that evolved naturally.\n", + "**lenguaje natural:**\n", + "Cualquiera de los idiomas que hablan las personas y que evolucionaron de forma natural.\n", "\n", - "**formal language:**\n", - "Any of the languages that people have designed for specific purposes, such as representing mathematical ideas or computer programs.\n", - "All programming languages are formal languages.\n", + "**lenguaje formal:**\n", + "Cualquiera de los lenguajes que las personas han diseñado para propósitos específicos, como representar ideas matemáticas o programas de computadora.\n", + "Todos los lenguajes de programación son lenguajes formales.\n", "\n", "**bug:**\n", - "An error in a program.\n", + "Un error en un programa.\n", "\n", "**debugging:**\n", - "The process of finding and correcting errors." + "El proceso de encontrar y corregir errores." ] }, { @@ -1018,7 +1006,7 @@ "id": "ed4ec01b", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1041,15 +1029,15 @@ "id": "23adf208", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregúntale a un asistente virtual\n", "\n", - "As you work through this book, there are several ways you can use a virtual assistant or chatbot to help you learn.\n", + "A medida que avances en este libro, hay varias formas en las que puedes usar un asistente virtual o chatbot para ayudarte a aprender.\n", "\n", - "* If you want to learn more about a topic in the chapter, or anything is unclear, you can ask for an explanation.\n", + "* Si quieres aprender más sobre un tema del capítulo, o algo no está claro, puedes pedir una explicación.\n", "\n", - "* If you are having a hard time with any of the exercises, you can ask for help.\n", + "* Si tienes dificultades con alguno de los ejercicios, puedes pedir ayuda.\n", "\n", - "In each chapter, I'll suggest exercises you can do with a virtual assistant, but I encourage you to try things on your own and see what works for you." + "En cada capítulo sugeriré ejercicios que puedes hacer con un asistente virtual, pero te animo a probar cosas por tu cuenta y ver qué te funciona." ] }, { @@ -1057,15 +1045,15 @@ "id": "ebf1a451", "metadata": {}, "source": [ - "Here are some topics you could ask a virtual assistant about:\n", + "Aquí tienes algunos temas sobre los que podrías preguntar a un asistente virtual:\n", "\n", - "* Earlier I mentioned bitwise operators but I didn't explain why the value of `7 ^ 2` is 5. Try asking \"What are the bitwise operators in Python?\" or \"What is the value of `7 XOR 2`?\"\n", + "* Antes mencioné los operadores bit a bit, pero no expliqué por qué el valor de `7 ^ 2` es 5. Prueba a preguntar \"¿Cuáles son los operadores bit a bit en Python?\" o \"¿Cuál es el valor de `7 XOR 2`?\"\n", "\n", - "* I also mentioned the order of operations. For more details, ask \"What is the order of operations in Python?\"\n", + "* También mencioné el orden de operaciones. Para más detalles, pregunta \"¿Cuál es el orden de las operaciones en Python?\"\n", "\n", - "* The `round` function, which we used to round a floating-point number to the nearest integer, can take a second argument. Try asking \"What are the arguments of the round function?\" or \"How do I round pi off to three decimal places?\"\n", + "* La función `round`, que usamos para redondear un número de coma flotante al entero más cercano, puede tomar un segundo argumento. Prueba a preguntar \"¿Cuáles son los argumentos de la función round?\" o \"¿Cómo redondeo pi a tres decimales?\"\n", "\n", - "* There's one more arithmetic operator I didn't mention; try asking \"What is the modulus operator in Python?\"" + "* Hay un operador aritmético más que no mencioné; prueba a preguntar \"¿Qué es el operador módulo en Python?\"" ] }, { @@ -1073,9 +1061,9 @@ "id": "9be3e1c7", "metadata": {}, "source": [ - "Most virtual assistants know about Python, so they answer questions like this pretty reliably.\n", - "But remember that these tools make mistakes.\n", - "If you get code from a chatbot, test it!" + "La mayoría de los asistentes virtuales saben sobre Python, así que responden preguntas como estas de forma bastante fiable.\n", + "Pero recuerda que estas herramientas cometen errores.\n", + "Si obtienes código de un chatbot, ¡pruébalo!" ] }, { @@ -1083,11 +1071,11 @@ "id": "03c1ef93", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "You might wonder what `round` does if a number ends in `0.5`.\n", - "The answer is that it sometimes rounds up and sometimes rounds down.\n", - "Try these examples and see if you can figure out what rule it follows." + "Quizá te preguntes qué hace `round` si un número termina en `0.5`.\n", + "La respuesta es que a veces redondea hacia arriba y a veces hacia abajo.\n", + "Prueba estos ejemplos y mira si puedes averiguar qué regla sigue." ] }, { @@ -1115,7 +1103,7 @@ "id": "dd2f890e", "metadata": {}, "source": [ - "If you are curious, ask a virtual assistant, \"If a number ends in 0.5, does Python round up or down?\"" + "Si tienes curiosidad, pregunta a un asistente virtual: \"Si un número termina en 0.5, ¿Python redondea hacia arriba o hacia abajo?\"" ] }, { @@ -1123,17 +1111,17 @@ "id": "2cd03bcb", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "When you learn about a new feature, you should try it out and make mistakes on purpose.\n", - "That way, you learn the error messages, and when you see them again, you will know what they mean.\n", - "It is better to make mistakes now and deliberately than later and accidentally.\n", + "Cuando aprendes una característica nueva, deberías probarla y cometer errores a propósito.\n", + "Así aprendes los mensajes de error y, cuando los vuelvas a ver, sabrás qué significan.\n", + "Es mejor cometer errores ahora y deliberadamente que más tarde y accidentalmente.\n", "\n", - "1. You can use a minus sign to make a negative number like `-2`. What happens if you put a plus sign before a number? What about `2++2`?\n", + "1. Puedes usar un signo menos para crear un número negativo como `-2`. ¿Qué ocurre si pones un signo más delante de un número? ¿Y con `2++2`?\n", "\n", - "2. What happens if you have two values with no operator between them, like `4 2`?\n", + "2. ¿Qué ocurre si tienes dos valores sin operador entre ellos, como `4 2`?\n", "\n", - "3. If you call a function like `round(42.5)`, what happens if you leave out one or both parentheses?" + "3. Si llamas a una función como `round(42.5)`, ¿qué ocurre si omites uno o ambos paréntesis?" ] }, { @@ -1141,11 +1129,11 @@ "id": "1fb0adfe", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Recall that every expression has a value, every value has a type, and we can use the `type` function to find the type of any value.\n", + "Recuerda que toda expresión tiene un valor, todo valor tiene un tipo, y podemos usar la función `type` para encontrar el tipo de cualquier valor.\n", "\n", - "What is the type of the value of the following expressions? Make your best guess for each one, and then use `type` to find out.\n", + "¿Cuál es el tipo del valor de las siguientes expresiones? Haz tu mejor conjetura para cada una y luego usa `type` para averiguarlo.\n", "\n", "* `765`\n", "\n", @@ -1169,22 +1157,22 @@ "id": "23762eec", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The following questions give you a chance to practice writing arithmetic expressions.\n", + "Las siguientes preguntas te dan la oportunidad de practicar escribiendo expresiones aritméticas.\n", "\n", - "1. How many seconds are there in 42 minutes 42 seconds?\n", + "1. ¿Cuántos segundos hay en 42 minutos y 42 segundos?\n", "\n", - "2. How many miles are there in 10 kilometers? Hint: there are 1.61 kilometers in a mile.\n", + "2. ¿Cuántas millas hay en 10 kilómetros? Pista: hay 1,61 kilómetros en una milla.\n", "\n", - "3. If you run a 10 kilometer race in 42 minutes 42 seconds, what is your average pace in seconds per mile? \n", + "3. Si corres una carrera de 10 kilómetros en 42 minutos y 42 segundos, ¿cuál es tu ritmo medio en segundos por milla? \n", " \n", - "4. What is your average pace in minutes and seconds per mile?\n", + "4. ¿Cuál es tu ritmo medio en minutos y segundos por milla?\n", "\n", - "5. What is your average speed in miles per hour?\n", + "5. ¿Cuál es tu velocidad media en millas por hora?\n", "\n", - "If you already know about variables, you can use them for this exercise.\n", - "If you don't, you can do the exercise without them -- and then we'll see them in the next chapter." + "Si ya sabes sobre variables, puedes usarlas para este ejercicio.\n", + "Si no, puedes hacer el ejercicio sin ellas -- y luego las veremos en el siguiente capítulo." ] }, { @@ -1272,13 +1260,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap02.ipynb b/chapters/chap02.ipynb index fb2369f..e9882ff 100644 --- a/chapters/chap02.ipynb +++ b/chapters/chap02.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,12 +41,12 @@ "id": "d0286422", "metadata": {}, "source": [ - "# Variables and Statements\n", + "# Variables y sentencias\n", "\n", - "In the previous chapter, we used operators to write expressions that perform arithmetic computations.\n", + "En el capítulo anterior usamos operadores para escribir expresiones que realizan cálculos aritméticos.\n", "\n", - "In this chapter, you'll learn about variables and statements, the `import` statement, and the `print` function.\n", - "And I'll introduce more of the vocabulary we use to talk about programs, including \"argument\" and \"module\".\n" + "En este capítulo aprenderás sobre variables y sentencias, la sentencia `import` y la función `print`.\n", + "Y presentaré más vocabulario que usamos para hablar de programas, incluyendo \"argumento\" y \"módulo\".\n" ] }, { @@ -56,8 +56,8 @@ "source": [ "## Variables\n", "\n", - "A **variable** is a name that refers to a value.\n", - "To create a variable, we can write a **assignment statement** like this." + "Una **variable** es un nombre que se refiere a un valor.\n", + "Para crear una variable, podemos escribir una **sentencia de asignación** como esta." ] }, { @@ -75,9 +75,9 @@ "id": "52f187f1", "metadata": {}, "source": [ - "An assignment statement has three parts: the name of the variable on the left, the equals operator, `=`, and an expression on the right.\n", - "In this example, the expression is an integer.\n", - "In the following example, the expression is a floating-point number." + "Una sentencia de asignación tiene tres partes: el nombre de la variable a la izquierda, el operador igual, `=`, y una expresión a la derecha.\n", + "En este ejemplo, la expresión es un entero.\n", + "En el siguiente ejemplo, la expresión es un número de punto flotante." ] }, { @@ -95,7 +95,7 @@ "id": "3e27e65c", "metadata": {}, "source": [ - "And in the following example, the expression is a string." + "Y en el siguiente ejemplo, la expresión es un string." ] }, { @@ -113,10 +113,10 @@ "id": "cb5916ea", "metadata": {}, "source": [ - "When you run an assignment statement, there is no output.\n", - "Python creates the variable and gives it a value, but the assignment statement has no visible effect.\n", - "However, after creating a variable, you can use it as an expression.\n", - "So we can display the value of `message` like this:" + "Cuando ejecutas una sentencia de asignación, no hay salida.\n", + "Python crea la variable y le da un valor, pero la sentencia de asignación no tiene ningún efecto visible.\n", + "Sin embargo, después de crear una variable, puedes usarla como una expresión.\n", + "Así que podemos mostrar el valor de `message` así:" ] }, { @@ -134,7 +134,7 @@ "id": "e3fd81de", "metadata": {}, "source": [ - "You can also use a variable as part of an expression with arithmetic operators." + "También puedes usar una variable como parte de una expresión con operadores aritméticos." ] }, { @@ -162,7 +162,7 @@ "id": "97396e7d", "metadata": {}, "source": [ - "And you can use a variable when you call a function." + "Y puedes usar una variable cuando llamas a una función." ] }, { @@ -190,10 +190,9 @@ "id": "397d9da3", "metadata": {}, "source": [ - "## State diagrams\n", + "## Diagramas de estado\n", "\n", - "A common way to represent variables on paper is to write the name with\n", - "an arrow pointing to its value. " + "Una forma común de representar variables en papel es escribir el nombre con una flecha apuntando a su valor. " ] }, { @@ -239,8 +238,8 @@ "id": "6f40da93", "metadata": {}, "source": [ - "This kind of figure is called a **state diagram** because it shows what state each of the variables is in (think of it as the variable's state of mind).\n", - "We'll use state diagrams throughout the book to represent a model of how Python stores variables and their values." + "Este tipo de figura se llama **diagrama de estado** porque muestra en qué estado está cada una de las variables (piensa en ello como el estado mental de la variable).\n", + "Usaremos diagramas de estado a lo largo del libro para representar un modelo de cómo Python almacena variables y sus valores." ] }, { @@ -248,16 +247,15 @@ "id": "ba252c85", "metadata": {}, "source": [ - "## Variable names\n", + "## Nombres de variables\n", "\n", - "Variable names can be as long as you like. They can contain both letters and numbers, but they can't begin with a number. \n", - "It is legal to use uppercase letters, but it is conventional to use only lower case for\n", - "variable names.\n", + "Los nombres de variables pueden ser tan largos como quieras. Pueden contener letras y números, pero no pueden comenzar con un número. \n", + "Es válido usar letras mayúsculas, pero lo convencional es usar solo minúsculas para los nombres de variables.\n", "\n", - "The only punctuation that can appear in a variable name is the underscore character, `_`. It is often used in names with multiple words, such as `your_name` or `airspeed_of_unladen_swallow`.\n", + "El único signo de puntuación que puede aparecer en un nombre de variable es el carácter de guion bajo, `_`. Se usa a menudo en nombres con varias palabras, como `your_name` o `airspeed_of_unladen_swallow`.\n", "\n", - "If you give a variable an illegal name, you get a syntax error.\n", - "The name `million!` is illegal because it contains punctuation." + "Si le das a una variable un nombre no válido, obtienes un error de sintaxis.\n", + "El nombre `million!` no es válido porque contiene puntuación." ] }, { @@ -279,7 +277,7 @@ "id": "a1cefe3e", "metadata": {}, "source": [ - "`76trombones` is illegal because it starts with a number." + "`76trombones` no es válido porque empieza con un número." ] }, { @@ -301,7 +299,7 @@ "id": "94aa7e60", "metadata": {}, "source": [ - "`class` is also illegal, but it might not be obvious why." + "`class` tampoco es válido, pero puede que no sea obvio por qué." ] }, { @@ -323,10 +321,10 @@ "id": "784cfb5c", "metadata": {}, "source": [ - "It turns out that `class` is a **keyword**, which is a special word used to specify the structure of a program.\n", - "Keywords can't be used as variable names.\n", + "Resulta que `class` es una **palabra clave**, que es una palabra especial usada para especificar la estructura de un programa.\n", + "Las palabras clave no se pueden usar como nombres de variables.\n", "\n", - "Here's a complete list of Python's keywords:" + "Aquí tienes una lista completa de las palabras clave de Python:" ] }, { @@ -364,9 +362,7 @@ "id": "6f14d301", "metadata": {}, "source": [ - "You don't have to memorize this list. In most development environments,\n", - "keywords are displayed in a different color; if you try to use one as a\n", - "variable name, you'll know." + "No tienes que memorizar esta lista. En la mayoría de los entornos de desarrollo, las palabras clave se muestran en un color diferente; si intentas usar una como nombre de variable, lo sabrás." ] }, { @@ -374,10 +370,10 @@ "id": "c954a3b0", "metadata": {}, "source": [ - "## The import statement\n", + "## La sentencia import\n", "\n", - "In order to use some Python features, you have to **import** them.\n", - "For example, the following statement imports the `math` module." + "Para usar algunas características de Python, tienes que **importarlas**.\n", + "Por ejemplo, la siguiente sentencia importa el módulo `math`." ] }, { @@ -395,9 +391,9 @@ "id": "ea4f75ec", "metadata": {}, "source": [ - "A **module** is a collection of variables and functions.\n", - "The math module provides a variable called `pi` that contains the value of the mathematical constant denoted $\\pi$.\n", - "We can display its value like this." + "Un **módulo** es una colección de variables y funciones.\n", + "El módulo math proporciona una variable llamada `pi` que contiene el valor de la constante matemática denotada $\\pi$.\n", + "Podemos mostrar su valor así." ] }, { @@ -415,10 +411,10 @@ "id": "c96106e4", "metadata": {}, "source": [ - "To use a variable in a module, you have to use the **dot operator** (`.`) between the name of the module and the name of the variable.\n", + "Para usar una variable de un módulo, tienes que usar el **operador punto** (`.`) entre el nombre del módulo y el nombre de la variable.\n", "\n", - "The math module also contains functions.\n", - "For example, `sqrt` computes square roots." + "El módulo math también contiene funciones.\n", + "Por ejemplo, `sqrt` calcula raíces cuadradas." ] }, { @@ -436,7 +432,7 @@ "id": "185e94a3", "metadata": {}, "source": [ - "And `pow` raises one number to the power of a second number." + "Y `pow` eleva un número a la potencia de un segundo número." ] }, { @@ -454,8 +450,8 @@ "id": "5df25a9a", "metadata": {}, "source": [ - "At this point we've seen two ways to raise a number to a power: we can use the `math.pow` function or the exponentiation operator, `**`.\n", - "Either one is fine, but the operator is used more often than the function." + "En este punto hemos visto dos formas de elevar un número a una potencia: podemos usar la función `math.pow` o el operador de exponenciación, `**`.\n", + "Cualquiera de las dos está bien, pero el operador se usa más a menudo que la función." ] }, { @@ -463,13 +459,13 @@ "id": "6538f22b", "metadata": {}, "source": [ - "## Expressions and statements\n", + "## Expresiones y sentencias\n", "\n", - "So far, we've seen a few kinds of expressions.\n", - "An expression can be a single value, like an integer, floating-point number, or string.\n", - "It can also be a collection of values and operators.\n", - "And it can include variable names and function calls.\n", - "Here's an expression that includes several of these elements." + "Hasta ahora hemos visto algunos tipos de expresiones.\n", + "Una expresión puede ser un solo valor, como un entero, un número de punto flotante o un string.\n", + "También puede ser una colección de valores y operadores.\n", + "Y puede incluir nombres de variables y llamadas a funciones.\n", + "Aquí hay una expresión que incluye varios de estos elementos." ] }, { @@ -487,9 +483,9 @@ "id": "000dd2ba", "metadata": {}, "source": [ - "We have also seen a few kind of statements.\n", - "A **statement** is a unit of code that has an effect, but no value.\n", - "For example, an assignment statement creates a variable and gives it a value, but the statement itself has no value." + "También hemos visto algunos tipos de sentencias.\n", + "Una **sentencia** es una unidad de código que tiene un efecto, pero no un valor.\n", + "Por ejemplo, una sentencia de asignación crea una variable y le da un valor, pero la sentencia en sí no tiene valor." ] }, { @@ -507,7 +503,7 @@ "id": "cff0414b", "metadata": {}, "source": [ - "Similarly, an import statement has an effect -- it imports a module so we can use the variables and functions it contains -- but it has no visible effect." + "De forma similar, una sentencia import tiene un efecto -- importa un módulo para que podamos usar las variables y funciones que contiene -- pero no tiene efecto visible." ] }, { @@ -525,8 +521,8 @@ "id": "2aeb1000", "metadata": {}, "source": [ - "Computing the value of an expression is called **evaluation**.\n", - "Running a statement is called **execution**." + "Calcular el valor de una expresión se llama **evaluación**.\n", + "Ejecutar una sentencia se llama **ejecución**." ] }, { @@ -534,9 +530,9 @@ "id": "f61601e4", "metadata": {}, "source": [ - "## The print function\n", + "## La función print\n", "\n", - "When you evaluate an expression, the result is displayed." + "Cuando evalúas una expresión, se muestra el resultado." ] }, { @@ -554,7 +550,7 @@ "id": "efacf0fa", "metadata": {}, "source": [ - "But if you evaluate more than one expression, only the value of the last one is displayed." + "Pero si evalúas más de una expresión, solo se muestra el valor de la última." ] }, { @@ -573,7 +569,7 @@ "id": "cf2b991d", "metadata": {}, "source": [ - "To display more than one value, you can use the `print` function." + "Para mostrar más de un valor, puedes usar la función `print`." ] }, { @@ -592,7 +588,7 @@ "id": "29af1f89", "metadata": {}, "source": [ - "It also works with floating-point numbers and strings." + "También funciona con números de punto flotante y strings." ] }, { @@ -611,7 +607,7 @@ "id": "8b4d7f4a", "metadata": {}, "source": [ - "You can also use a sequence of expressions separated by commas." + "También puedes usar una secuencia de expresiones separadas por comas." ] }, { @@ -629,7 +625,7 @@ "id": "af447ec4", "metadata": {}, "source": [ - "Notice that the `print` function puts a space between the values." + "Observa que la función `print` coloca un espacio entre los valores." ] }, { @@ -637,12 +633,12 @@ "id": "7c73a2fa", "metadata": {}, "source": [ - "## Arguments\n", + "## Argumentos\n", "\n", - "When you call a function, the expression in parenthesis is called an **argument**.\n", - "Normally I would explain why, but in this case the technical meaning of a term has almost nothing to do with the common meaning of the word, so I won't even try.\n", + "Cuando llamas a una función, la expresión entre paréntesis se llama un **argumento**.\n", + "Normalmente explicaría por qué, pero en este caso el significado técnico de un término no tiene casi nada que ver con el significado común de la palabra, así que ni siquiera lo intentaré.\n", "\n", - "Some of the functions we've seen so far take only one argument, like `int`." + "Algunas de las funciones que hemos visto hasta ahora toman solo un argumento, como `int`." ] }, { @@ -660,7 +656,7 @@ "id": "c4ad4f2c", "metadata": {}, "source": [ - "Some take two, like `math.pow`." + "Algunas toman dos, como `math.pow`." ] }, { @@ -678,8 +674,8 @@ "id": "17293749", "metadata": {}, "source": [ - "Some can take additional arguments that are optional. \n", - "For example, `int` can take a second argument that specifies the base of the number." + "Algunas pueden tomar argumentos adicionales que son opcionales. \n", + "Por ejemplo, `int` puede tomar un segundo argumento que especifica la base del número." ] }, { @@ -697,9 +693,9 @@ "id": "c95589a1", "metadata": {}, "source": [ - "The sequence of digits `101` in base 2 represents the number 5 in base 10.\n", + "La secuencia de dígitos `101` en base 2 representa el número 5 en base 10.\n", "\n", - "`round` also takes an optional second argument, which is the number of decimal places to round off to." + "`round` también toma un segundo argumento opcional, que es el número de posiciones decimales al que redondear." ] }, { @@ -717,7 +713,7 @@ "id": "21e4a448", "metadata": {}, "source": [ - "Some functions can take any number of arguments, like `print`." + "Algunas funciones pueden tomar cualquier número de argumentos, como `print`." ] }, { @@ -735,7 +731,7 @@ "id": "667cff14", "metadata": {}, "source": [ - "If you call a function and provide too many arguments, that's a `TypeError`." + "Si llamas a una función y proporcionas demasiados argumentos, eso es un `TypeError`." ] }, { @@ -757,7 +753,7 @@ "id": "5103368e", "metadata": {}, "source": [ - "If you provide too few arguments, that's also a `TypeError`." + "Si proporcionas muy pocos argumentos, eso también es un `TypeError`." ] }, { @@ -779,7 +775,7 @@ "id": "5333c416", "metadata": {}, "source": [ - "And if you provide an argument with a type the function can't handle, that's a `TypeError`, too." + "Y si proporcionas un argumento con un tipo que la función no puede manejar, eso también es un `TypeError`." ] }, { @@ -801,7 +797,7 @@ "id": "548828af", "metadata": {}, "source": [ - "This kind of checking can be annoying when you are getting started, but it helps you detect and correct errors." + "Este tipo de comprobación puede ser molesto cuando estás empezando, pero te ayuda a detectar y corregir errores." ] }, { @@ -809,13 +805,13 @@ "id": "be2b6a9b", "metadata": {}, "source": [ - "## Comments\n", + "## Comentarios\n", "\n", - "As programs get bigger and more complicated, they get more difficult to read.\n", - "Formal languages are dense, and it is often difficult to look at a piece of code and figure out what it is doing and why.\n", + "A medida que los programas se hacen más grandes y complicados, se vuelven más difíciles de leer.\n", + "Los lenguajes formales son densos, y a menudo es difícil mirar un fragmento de código y averiguar qué hace y por qué.\n", "\n", - "For this reason, it is a good idea to add notes to your programs to explain in natural language what the program is doing. \n", - "These notes are called **comments**, and they start with the `#` symbol." + "Por esta razón, es buena idea añadir notas a tus programas para explicar en lenguaje natural qué está haciendo el programa. \n", + "Estas notas se llaman **comentarios**, y empiezan con el símbolo `#`." ] }, { @@ -834,8 +830,7 @@ "id": "519c83a9", "metadata": {}, "source": [ - "In this case, the comment appears on a line by itself. You can also put\n", - "comments at the end of a line:" + "En este caso, el comentario aparece en una línea por sí solo. También puedes poner comentarios al final de una línea:" ] }, { @@ -853,13 +848,12 @@ "id": "87c8d10c", "metadata": {}, "source": [ - "Everything from the `#` to the end of the line is ignored---it has no\n", - "effect on the execution of the program.\n", + "Todo desde el `#` hasta el final de la línea se ignora---no tiene efecto en la ejecución del programa.\n", "\n", - "Comments are most useful when they document non-obvious features of the code.\n", - "It is reasonable to assume that the reader can figure out *what* the code does; it is more useful to explain *why*.\n", + "Los comentarios son más útiles cuando documentan características no obvias del código.\n", + "Es razonable suponer que el lector puede averiguar *qué* hace el código; es más útil explicar *por qué*.\n", "\n", - "This comment is redundant with the code and useless:" + "Este comentario es redundante con el código y no sirve:" ] }, { @@ -877,7 +871,7 @@ "id": "eb83b14a", "metadata": {}, "source": [ - "This comment contains useful information that is not in the code:" + "Este comentario contiene información útil que no está en el código:" ] }, { @@ -895,8 +889,7 @@ "id": "6cd60d4f", "metadata": {}, "source": [ - "Good variable names can reduce the need for comments, but long names can\n", - "make complex expressions hard to read, so there is a tradeoff." + "Los buenos nombres de variables pueden reducir la necesidad de comentarios, pero los nombres largos pueden hacer que las expresiones complejas sean difíciles de leer, así que hay una compensación." ] }, { @@ -906,14 +899,14 @@ "source": [ "## Debugging\n", "\n", - "Three kinds of errors can occur in a program: syntax errors, runtime errors, and semantic errors.\n", - "It is useful to distinguish between them in order to track them down more quickly.\n", + "En un programa pueden ocurrir tres tipos de errores: errores de sintaxis, errores en tiempo de ejecución y errores semánticos.\n", + "Es útil distinguirlos para localizarlos más rápidamente.\n", "\n", - "* **Syntax error**: \"Syntax\" refers to the structure of a program and the rules about that structure. If there is a syntax error anywhere in your program, Python does not run the program. It displays an error message immediately.\n", + "* **Error de sintaxis**: \"Sintaxis\" se refiere a la estructura de un programa y a las reglas sobre esa estructura. Si hay un error de sintaxis en cualquier parte de tu programa, Python no ejecuta el programa. Muestra un mensaje de error inmediatamente.\n", "\n", - "* **Runtime error**: If there are no syntax errors in your program, it can start running. But if something goes wrong, Python displays an error message and stops. This type of error is called a runtime error. It is also called an **exception** because it indicates that something exceptional has happened.\n", + "* **Error en tiempo de ejecución**: Si no hay errores de sintaxis en tu programa, puede empezar a ejecutarse. Pero si algo sale mal, Python muestra un mensaje de error y se detiene. Este tipo de error se llama error en tiempo de ejecución. También se llama una **excepción** porque indica que ha ocurrido algo excepcional.\n", "\n", - "* **Semantic error**: The third type of error is \"semantic\", which means related to meaning. If there is a semantic error in your program, it runs without generating error messages, but it does not do what you intended. Identifying semantic errors can be tricky because it requires you to work backward by looking at the output of the program and trying to figure out what it is doing." + "* **Error semántico**: El tercer tipo de error es \"semántico\", lo que significa relacionado con el significado. Si hay un error semántico en tu programa, se ejecuta sin generar mensajes de error, pero no hace lo que pretendías. Identificar errores semánticos puede ser complicado porque requiere que trabajes hacia atrás mirando la salida del programa e intentando averiguar qué está haciendo." ] }, { @@ -921,7 +914,7 @@ "id": "6cd52721", "metadata": {}, "source": [ - "As we've seen, an illegal variable name is a syntax error." + "Como hemos visto, un nombre de variable no válido es un error de sintaxis." ] }, { @@ -943,7 +936,7 @@ "id": "b8971d33", "metadata": {}, "source": [ - "If you use an operator with a type it doesn't support, that's a runtime error. " + "Si usas un operador con un tipo que no admite, eso es un error en tiempo de ejecución. " ] }, { @@ -965,8 +958,8 @@ "id": "e51fa6e2", "metadata": {}, "source": [ - "Finally, here's an example of a semantic error.\n", - "Suppose we want to compute the average of `1` and `3`, but we forget about the order of operations and write this:" + "Por último, aquí tienes un ejemplo de error semántico.\n", + "Supongamos que queremos calcular la media de `1` y `3`, pero olvidamos el orden de operaciones y escribimos esto:" ] }, { @@ -984,9 +977,9 @@ "id": "0828afc0", "metadata": {}, "source": [ - "When this expression is evaluated, it does not produce an error message, so there is no syntax error or runtime error.\n", - "But the result is not the average of `1` and `3`, so the program is not correct.\n", - "This is a semantic error because the program runs but it doesn't do what's intended." + "Cuando se evalúa esta expresión, no produce un mensaje de error, así que no hay error de sintaxis ni error en tiempo de ejecución.\n", + "Pero el resultado no es la media de `1` y `3`, así que el programa no es correcto.\n", + "Este es un error semántico porque el programa se ejecuta pero no hace lo que se pretendía." ] }, { @@ -994,52 +987,52 @@ "id": "07396f3d", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", "**variable:**\n", - "A name that refers to a value.\n", + "Un nombre que se refiere a un valor.\n", "\n", - "**assignment statement:**\n", - "A statement that assigns a value to a variable.\n", + "**sentencia de asignación:**\n", + "Una sentencia que asigna un valor a una variable.\n", "\n", - "**state diagram:**\n", - "A graphical representation of a set of variables and the values they refer to.\n", + "**diagrama de estado:**\n", + "Una representación gráfica de un conjunto de variables y los valores a los que se refieren.\n", "\n", - "**keyword:**\n", - "A special word used to specify the structure of a program.\n", + "**palabra clave:**\n", + "Una palabra especial usada para especificar la estructura de un programa.\n", "\n", - "**import statement:**\n", - "A statement that reads a module file so we can use the variables and functions it contains.\n", + "**sentencia de importación:**\n", + "Una sentencia que lee un archivo de módulo para que podamos usar las variables y funciones que contiene.\n", "\n", - "**module:**\n", - "A file that contains Python code, including function definitions and sometimes other statements.\n", + "**módulo:**\n", + "Un archivo que contiene código Python, incluyendo definiciones de funciones y a veces otras sentencias.\n", "\n", - "**dot operator:**\n", - "The operator, `.`, used to access a function in another module by specifying the module name followed by a dot and the function name.\n", + "**operador punto:**\n", + "El operador, `.`, usado para acceder a una función en otro módulo especificando el nombre del módulo seguido de un punto y el nombre de la función.\n", "\n", - "**evaluate:**\n", - "Perform the operations in an expression in order to compute a value.\n", + "**evaluar:**\n", + "Realizar las operaciones de una expresión para calcular un valor.\n", "\n", - "**statement:**\n", - "One or more lines of code that represent a command or action.\n", + "**sentencia:**\n", + "Una o más líneas de código que representan una orden o acción.\n", "\n", - "**execute:**\n", - "Run a statement and do what it says.\n", + "**ejecutar:**\n", + "Ejecutar una sentencia y hacer lo que dice.\n", "\n", - "**argument:**\n", - "A value provided to a function when the function is called.\n", + "**argumento:**\n", + "Un valor proporcionado a una función cuando se llama a la función.\n", "\n", - "**comment:**\n", - "Text included in a program that provides information about the program but has no effect on its execution.\n", + "**comentario:**\n", + "Texto incluido en un programa que proporciona información sobre el programa pero no tiene efecto en su ejecución.\n", "\n", - "**runtime error:**\n", - "An error that causes a program to display an error message and exit.\n", + "**error en tiempo de ejecución:**\n", + "Un error que hace que un programa muestre un mensaje de error y termine.\n", "\n", - "**exception:**\n", - "An error that is detected while the program is running.\n", + "**excepción:**\n", + "Un error que se detecta mientras el programa se está ejecutando.\n", "\n", - "**semantic error:**\n", - "An error that causes a program to do the wrong thing, but not to display an error message." + "**error semántico:**\n", + "Un error que hace que un programa haga algo incorrecto, pero no muestre un mensaje de error." ] }, { @@ -1047,7 +1040,7 @@ "id": "70ee273d", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1070,20 +1063,20 @@ "id": "7256a9b2", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregúntale a un asistente virtual\n", "\n", - "Again, I encourage you to use a virtual assistant to learn more about any of the topics in this chapter.\n", + "De nuevo, te animo a usar un asistente virtual para aprender más sobre cualquiera de los temas de este capítulo.\n", "\n", - "If you are curious about any of keywords I listed, you could ask \"Why is class a keyword?\" or \"Why can't variable names be keywords?\"\n", + "Si tienes curiosidad por alguna de las palabras clave que enumeré, podrías preguntar \"¿Por qué class es una palabra clave?\" o \"¿Por qué los nombres de variables no pueden ser palabras clave?\"\n", "\n", - "You might have noticed that `int`, `float`, and `str` are not Python keywords.\n", - "They are variables that represent types, and they can be used as functions.\n", - "So it is *legal* to have a variable or function with one of those names, but it is strongly discouraged. Ask an assistant \"Why is it bad to use int, float, and str as variable names?\"\n", + "Quizá hayas notado que `int`, `float` y `str` no son palabras clave de Python.\n", + "Son variables que representan tipos, y se pueden usar como funciones.\n", + "Así que es *legal* tener una variable o función con uno de esos nombres, pero se desaconseja firmemente. Pregunta a un asistente: \"¿Por qué es mala idea usar int, float y str como nombres de variables?\"\n", "\n", - "Also ask, \"What are the built-in functions in Python?\"\n", - "If you are curious about any of them, ask for more information.\n", + "Pregunta también: \"¿Cuáles son las funciones incorporadas de Python?\"\n", + "Si tienes curiosidad por alguna de ellas, pide más información.\n", "\n", - "In this chapter we imported the `math` module and used some of the variable and functions it provides. Ask an assistant, \"What variables and functions are in the math module?\" and \"Other than math, what modules are considered core Python?\"" + "En este capítulo importamos el módulo `math` y usamos algunas de las variables y funciones que proporciona. Pregunta a un asistente: \"¿Qué variables y funciones hay en el módulo math?\" y \"Además de math, ¿qué módulos se consideran parte del núcleo de Python?\"" ] }, { @@ -1091,20 +1084,19 @@ "id": "f92afde0", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Repeating my advice from the previous chapter, whenever you learn a new feature, you should make errors on purpose to see what goes wrong.\n", + "Repitiendo mi consejo del capítulo anterior: siempre que aprendas una característica nueva, deberías cometer errores a propósito para ver qué falla.\n", "\n", - "- We've seen that `n = 17` is legal. What about `17 = n`?\n", + "- Hemos visto que `n = 17` es válido. ¿Qué pasa con `17 = n`?\n", "\n", - "- How about `x = y = 1`?\n", + "- ¿Y con `x = y = 1`?\n", "\n", - "- In some languages every statement ends with a semi-colon (`;`). What\n", - " happens if you put a semi-colon at the end of a Python statement?\n", + "- En algunos lenguajes, cada sentencia termina con punto y coma (`;`). ¿Qué ocurre si pones un punto y coma al final de una sentencia de Python?\n", "\n", - "- What if you put a period at the end of a statement?\n", + "- ¿Qué pasa si pones un punto al final de una sentencia?\n", "\n", - "- What happens if you spell the name of a module wrong and try to import `maath`?" + "- ¿Qué ocurre si escribes mal el nombre de un módulo e intentas importar `maath`?" ] }, { @@ -1112,11 +1104,11 @@ "id": "9d562609", "metadata": {}, "source": [ - "### Exercise\n", - "Practice using the Python interpreter as a calculator:\n", + "### Ejercicio\n", + "Practica usando el intérprete de Python como calculadora:\n", "\n", - "**Part 1.** The volume of a sphere with radius $r$ is $\\frac{4}{3} \\pi r^3$.\n", - "What is the volume of a sphere with radius 5? Start with a variable named `radius` and then assign the result to a variable named `volume`. Display the result. Add comments to indicate that `radius` is in centimeters and `volume` in cubic centimeters." + "**Parte 1.** El volumen de una esfera con radio $r$ es $\\frac{4}{3} \\pi r^3$.\n", + "¿Cuál es el volumen de una esfera con radio 5? Empieza con una variable llamada `radius` y luego asigna el resultado a una variable llamada `volume`. Muestra el resultado. Añade comentarios para indicar que `radius` está en centímetros y `volume` en centímetros cúbicos." ] }, { @@ -1134,12 +1126,12 @@ "id": "6449b12b", "metadata": {}, "source": [ - "**Part 2.** A rule of trigonometry says that for any value of $x$, $(\\cos x)^2 + (\\sin x)^2 = 1$. Let's see if it's true for a specific value of $x$ like 42.\n", + "**Parte 2.** Una regla de trigonometría dice que para cualquier valor de $x$, $(\\cos x)^2 + (\\sin x)^2 = 1$. Veamos si es cierta para un valor específico de $x$, como 42.\n", "\n", - "Create a variable named `x` with this value.\n", - "Then use `math.cos` and `math.sin` to compute the sine and cosine of $x$, and the sum of their squared.\n", + "Crea una variable llamada `x` con este valor.\n", + "Luego usa `math.cos` y `math.sin` para calcular el seno y el coseno de $x$, y la suma de sus cuadrados.\n", "\n", - "The result should be close to 1. It might not be exactly 1 because floating-point arithmetic is not exact---it is only approximately correct." + "El resultado debería estar cerca de 1. Puede que no sea exactamente 1 porque la aritmética de punto flotante no es exacta---solo es aproximadamente correcta." ] }, { @@ -1157,16 +1149,16 @@ "id": "4986801f", "metadata": {}, "source": [ - "**Part 3.** In addition to `pi`, the other variable defined in the `math` module is `e`, which represents the base of the natural logarithm, written in math notation as $e$. If you are not familiar with this value, ask a virtual assistant \"What is `math.e`?\" Now let's compute $e^2$ three ways:\n", + "**Parte 3.** Además de `pi`, la otra variable definida en el módulo `math` es `e`, que representa la base del logaritmo natural, escrita en notación matemática como $e$. Si no conoces este valor, pregunta a un asistente virtual \"¿Qué es `math.e`?\" Ahora calculemos $e^2$ de tres formas:\n", "\n", - "* Use `math.e` and the exponentiation operator (`**`).\n", + "* Usa `math.e` y el operador de exponenciación (`**`).\n", "\n", - "* Use `math.pow` to raise `math.e` to the power `2`.\n", + "* Usa `math.pow` para elevar `math.e` a la potencia `2`.\n", "\n", - "* Use `math.exp`, which takes as an argument a value, $x$, and computes $e^x$.\n", + "* Usa `math.exp`, que toma como argumento un valor, $x$, y calcula $e^x$.\n", "\n", - "You might notice that the last result is slightly different from the other two.\n", - "See if you can find out which is correct." + "Puede que notes que el último resultado es ligeramente diferente de los otros dos.\n", + "Mira si puedes averiguar cuál es correcto." ] }, { @@ -1214,13 +1206,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap03.ipynb b/chapters/chap03.ipynb index 5f2cb1d..d728b65 100644 --- a/chapters/chap03.ipynb +++ b/chapters/chap03.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,15 +41,15 @@ "id": "6bd858a8", "metadata": {}, "source": [ - "# Functions\n", + "# Funciones\n", "\n", - "In the previous chapter we used several functions provided by Python, like `int` and `float`, and a few provided by the `math` module, like `sqrt` and `pow`.\n", - "In this chapter, you will learn how to create your own functions and run them.\n", - "And we'll see how one function can call another.\n", - "As examples, we'll display lyrics from Monty Python songs.\n", - "These silly examples demonstrate an important feature -- the ability to write your own functions is the foundation of programming.\n", + "En el capítulo anterior usamos varias funciones proporcionadas por Python, como `int` y `float`, y algunas proporcionadas por el módulo `math`, como `sqrt` y `pow`.\n", + "En este capítulo aprenderás a crear tus propias funciones y a ejecutarlas.\n", + "Y veremos cómo una función puede llamar a otra.\n", + "Como ejemplos, mostraremos letras de canciones de Monty Python.\n", + "Estos ejemplos absurdos demuestran una característica importante: la capacidad de escribir tus propias funciones es la base de la programación.\n", "\n", - "This chapter also introduces a new statement, the `for` loop, which is used to repeat a computation." + "Este capítulo también introduce una nueva sentencia, el bucle `for`, que se usa para repetir un cálculo." ] }, { @@ -57,9 +57,9 @@ "id": "b4ea99c5", "metadata": {}, "source": [ - "## Defining new functions\n", + "## Definir nuevas funciones\n", "\n", - "A **function definition** specifies the name of a new function and the sequence of statements that run when the function is called. Here's an example:" + "Una **definición de función** especifica el nombre de una nueva función y la secuencia de sentencias que se ejecutan cuando se llama a la función. Aquí tienes un ejemplo:" ] }, { @@ -79,17 +79,17 @@ "id": "0174fc41", "metadata": {}, "source": [ - "`def` is a keyword that indicates that this is a function definition.\n", - "The name of the function is `print_lyrics`.\n", - "Anything that's a legal variable name is also a legal function name.\n", + "`def` es una palabra clave que indica que esto es una definición de función.\n", + "El nombre de la función es `print_lyrics`.\n", + "Cualquier cosa que sea un nombre de variable válido también es un nombre de función válido.\n", "\n", - "The empty parentheses after the name indicate that this function doesn't take any arguments.\n", + "Los paréntesis vacíos después del nombre indican que esta función no recibe argumentos.\n", "\n", - "The first line of the function definition is called the **header** -- the rest is called the **body**.\n", - "The header has to end with a colon and the body has to be indented. By convention, indentation is always four spaces. \n", - "The body of this function is two print statements; in general, the body of a function can contain any number of statements of any kind.\n", + "La primera línea de la definición de función se llama **encabezado**; el resto se llama **cuerpo**.\n", + "El encabezado tiene que terminar con dos puntos y el cuerpo tiene que estar indentado. Por convención, la indentación es siempre de cuatro espacios. \n", + "El cuerpo de esta función son dos sentencias `print`; en general, el cuerpo de una función puede contener cualquier número de sentencias de cualquier tipo.\n", "\n", - "Defining a function creates a **function object**, which we can display like this." + "Definir una función crea un **objeto función**, que podemos mostrar así." ] }, { @@ -107,10 +107,10 @@ "id": "12bd0879", "metadata": {}, "source": [ - "The output indicates that `print_lyrics` is a function that takes no arguments.\n", - "`__main__` is the name of the module that contains `print_lyrics`.\n", + "La salida indica que `print_lyrics` es una función que no recibe argumentos.\n", + "`__main__` es el nombre del módulo que contiene `print_lyrics`.\n", "\n", - "Now that we've defined a function, we can call it the same way we call built-in functions." + "Ahora que hemos definido una función, podemos llamarla del mismo modo que llamamos a las funciones incorporadas." ] }, { @@ -128,7 +128,7 @@ "id": "8f0fc45d", "metadata": {}, "source": [ - "When the function runs, it executes the statements in the body, which display the first two lines of \"The Lumberjack Song\"." + "Cuando la función se ejecuta, ejecuta las sentencias del cuerpo, que muestran las dos primeras líneas de \"The Lumberjack Song\"." ] }, { @@ -136,12 +136,12 @@ "id": "6d35193e", "metadata": {}, "source": [ - "## Parameters\n", + "## Parámetros\n", "\n", - "Some of the functions we have seen require arguments; for example, when you call `abs` you pass a number as an argument.\n", - "Some functions take more than one argument; for example, `math.pow` takes two, the base and the exponent.\n", + "Algunas de las funciones que hemos visto requieren argumentos; por ejemplo, cuando llamas a `abs` pasas un número como argumento.\n", + "Algunas funciones reciben más de un argumento; por ejemplo, `math.pow` recibe dos: la base y el exponente.\n", "\n", - "Here is a definition for a function that takes an argument." + "Aquí tienes la definición de una función que recibe un argumento." ] }, { @@ -161,9 +161,9 @@ "id": "1716e3dc", "metadata": {}, "source": [ - "The variable name in parentheses is a **parameter**.\n", - "When the function is called, the value of the argument is assigned to the parameter.\n", - "For example, we can call `print_twice` like this." + "El nombre de variable entre paréntesis es un **parámetro**.\n", + "Cuando se llama a la función, el valor del argumento se asigna al parámetro.\n", + "Por ejemplo, podemos llamar a `print_twice` así." ] }, { @@ -181,7 +181,7 @@ "id": "f02be6d2", "metadata": {}, "source": [ - "Running this function has the same effect as assigning the argument to the parameter and then executing the body of the function, like this." + "Ejecutar esta función tiene el mismo efecto que asignar el argumento al parámetro y luego ejecutar el cuerpo de la función, así." ] }, { @@ -201,7 +201,7 @@ "id": "ea8b8b6e", "metadata": {}, "source": [ - "You can also use a variable as an argument." + "También puedes usar una variable como argumento." ] }, { @@ -220,7 +220,7 @@ "id": "5c1884ad", "metadata": {}, "source": [ - "In this example, the value of `line` gets assigned to the parameter `string`." + "En este ejemplo, el valor de `line` se asigna al parámetro `string`." ] }, { @@ -228,10 +228,10 @@ "id": "a3e5a790", "metadata": {}, "source": [ - "## Calling functions\n", + "## Llamar funciones\n", "\n", - "Once you have defined a function, you can use it inside another function.\n", - "To demonstrate, we'll write functions that print the lyrics of \"The Spam Song\" ().\n", + "Una vez que has definido una función, puedes usarla dentro de otra función.\n", + "Para demostrarlo, escribiremos funciones que imprimen la letra de \"The Spam Song\" ().\n", "\n", "> Spam, Spam, Spam, Spam, \n", "> Spam, Spam, Spam, Spam, \n", @@ -239,7 +239,7 @@ "> (Lovely Spam, Wonderful Spam!) \n", "> Spam, Spam,\n", "\n", - "We'll start with the following function, which takes two parameters.\n" + "Empezaremos con la siguiente función, que recibe dos parámetros.\n" ] }, { @@ -258,7 +258,7 @@ "id": "bdd4daa4", "metadata": {}, "source": [ - "We can use this function to print the first line of the song, like this." + "Podemos usar esta función para imprimir la primera línea de la canción, así." ] }, { @@ -277,7 +277,7 @@ "id": "c6f81e09", "metadata": {}, "source": [ - "To display the first two lines, we can define a new function that uses `repeat`." + "Para mostrar las dos primeras líneas, podemos definir una nueva función que use `repeat`." ] }, { @@ -297,7 +297,7 @@ "id": "8058ffe4", "metadata": {}, "source": [ - "And then call it like this." + "Y luego llamarla así." ] }, { @@ -315,7 +315,7 @@ "id": "07ca432a", "metadata": {}, "source": [ - "To display the last three lines, we can define another function, which also uses `repeat`." + "Para mostrar las últimas tres líneas, podemos definir otra función, que también usa `repeat`." ] }, { @@ -346,7 +346,7 @@ "id": "d6456a19", "metadata": {}, "source": [ - "Finally, we can bring it all together with one function that prints the whole verse." + "Por último, podemos unirlo todo con una función que imprime la estrofa completa." ] }, { @@ -376,10 +376,10 @@ "id": "d088fe68", "metadata": {}, "source": [ - "When we run `print_verse`, it calls `first_two_lines`, which calls `repeat`, which calls `print`.\n", - "That's a lot of functions.\n", + "Cuando ejecutamos `print_verse`, llama a `first_two_lines`, que llama a `repeat`, que llama a `print`.\n", + "Son muchas funciones.\n", "\n", - "Of course, we could have done the same thing with fewer functions, but the point of this example is to show how functions can work together." + "Por supuesto, podríamos haber hecho lo mismo con menos funciones, pero el objetivo de este ejemplo es mostrar cómo las funciones pueden trabajar juntas." ] }, { @@ -387,10 +387,10 @@ "id": "c3b16e3f", "metadata": {}, "source": [ - "## Repetition\n", + "## Repetición\n", "\n", - "If we want to display more than one verse, we can use a `for` statement.\n", - "Here's a simple example." + "Si queremos mostrar más de una estrofa, podemos usar una sentencia `for`.\n", + "Aquí tienes un ejemplo sencillo." ] }, { @@ -409,20 +409,20 @@ "id": "bf320549", "metadata": {}, "source": [ - "The first line is a header that ends with a colon.\n", - "The second line is the body, which has to be indented.\n", + "La primera línea es un encabezado que termina con dos puntos.\n", + "La segunda línea es el cuerpo, que tiene que estar indentado.\n", "\n", - "The header starts with the keyword `for`, a new variable named `i`, and another keyword, `in`. \n", - "It uses the `range` function to create a sequence of two values, which are `0` and `1`.\n", - "In Python, when we start counting, we usually start from `0`.\n", + "El encabezado empieza con la palabra clave `for`, una nueva variable llamada `i` y otra palabra clave, `in`. \n", + "Usa la función `range` para crear una secuencia de dos valores, que son `0` y `1`.\n", + "En Python, cuando empezamos a contar, normalmente empezamos desde `0`.\n", "\n", - "When the `for` statement runs, it assigns the first value from `range` to `i` and then runs the `print` function in the body, which displays `0`.\n", + "Cuando la sentencia `for` se ejecuta, asigna el primer valor de `range` a `i` y luego ejecuta la función `print` en el cuerpo, que muestra `0`.\n", "\n", - "When it gets to the end of the body, it loops back around to the header, which is why this statement is called a **loop**.\n", - "The second time through the loop, it assigns the next value from `range` to `i`, and displays it.\n", - "Then, because that's the last value from `range`, the loop ends.\n", + "Cuando llega al final del cuerpo, vuelve al encabezado, por eso esta sentencia se llama **bucle**.\n", + "La segunda vez que recorre el bucle, asigna el siguiente valor de `range` a `i` y lo muestra.\n", + "Entonces, como ese es el último valor de `range`, el bucle termina.\n", "\n", - "Here's how we can use a `for` loop to print two verses of the song." + "Así es como podemos usar un bucle `for` para imprimir dos estrofas de la canción." ] }, { @@ -443,8 +443,8 @@ "id": "88a46733", "metadata": {}, "source": [ - "You can put a `for` loop inside a function.\n", - "For example, `print_n_verses` takes a parameter named `n`, which has to be an integer, and displays the given number of verses. " + "Puedes poner un bucle `for` dentro de una función.\n", + "Por ejemplo, `print_n_verses` recibe un parámetro llamado `n`, que tiene que ser un entero, y muestra el número dado de estrofas. " ] }, { @@ -465,7 +465,7 @@ "id": "ad8060fe", "metadata": {}, "source": [ - "In this example, we don't use `i` in the body of the loop, but there has to be a variable name in the header anyway." + "En este ejemplo, no usamos `i` en el cuerpo del bucle, pero de todos modos tiene que haber un nombre de variable en el encabezado." ] }, { @@ -473,11 +473,11 @@ "id": "b320ec90", "metadata": {}, "source": [ - "## Variables and parameters are local\n", + "## Las variables y los parámetros son locales\n", "\n", - "When you create a variable inside a function, it is **local**, which\n", - "means that it only exists inside the function.\n", - "For example, the following function takes two arguments, concatenates them, and prints the result twice." + "Cuando creas una variable dentro de una función, es **local**, lo que\n", + "significa que solo existe dentro de la función.\n", + "Por ejemplo, la siguiente función recibe dos argumentos, los concatena e imprime el resultado dos veces." ] }, { @@ -497,7 +497,7 @@ "id": "3a35a6d0", "metadata": {}, "source": [ - "Here's an example that uses it:" + "Aquí tienes un ejemplo que la usa:" ] }, { @@ -517,8 +517,8 @@ "id": "4ab4e008", "metadata": {}, "source": [ - "When `cat_twice` runs, it creates a local variable named `cat`, which is destroyed when the function ends.\n", - "If we try to display it, we get a `NameError`:" + "Cuando `cat_twice` se ejecuta, crea una variable local llamada `cat`, que se destruye cuando termina la función.\n", + "Si intentamos mostrarla, obtenemos un `NameError`:" ] }, { @@ -540,10 +540,10 @@ "id": "3ae36c29", "metadata": {}, "source": [ - "Outside of the function, `cat` is not defined. \n", + "Fuera de la función, `cat` no está definida. \n", "\n", - "Parameters are also local.\n", - "For example, outside `cat_twice`, there is no such thing as `part1` or `part2`." + "Los parámetros también son locales.\n", + "Por ejemplo, fuera de `cat_twice`, no existe nada llamado `part1` o `part2`." ] }, { @@ -551,15 +551,15 @@ "id": "eabac8a6", "metadata": {}, "source": [ - "## Stack diagrams\n", + "## Diagramas de pila\n", "\n", - "To keep track of which variables can be used where, it is sometimes useful to draw a **stack diagram**. \n", - "Like state diagrams, stack diagrams show the value of each variable, but they also show the function each variable belongs to.\n", + "Para llevar la cuenta de qué variables se pueden usar en cada lugar, a veces es útil dibujar un **diagrama de pila**. \n", + "Como los diagramas de estado, los diagramas de pila muestran el valor de cada variable, pero también muestran la función a la que pertenece cada variable.\n", "\n", - "Each function is represented by a **frame**.\n", - "A frame is a box with the name of a function on the outside and the parameters and local variables of the function on the inside.\n", + "Cada función se representa mediante un **marco**.\n", + "Un marco es una caja con el nombre de una función por fuera y los parámetros y variables locales de la función por dentro.\n", "\n", - "Here's the stack diagram for the previous example." + "Aquí tienes el diagrama de pila del ejemplo anterior." ] }, { @@ -617,12 +617,12 @@ "id": "854fee12", "metadata": {}, "source": [ - "The frames are arranged in a stack that indicates which function called\n", - "which, and so on. Reading from the bottom, `print` was called by `print_twice`, which was called by `cat_twice`, which was called by `__main__` -- which is a special name for the topmost frame.\n", - "When you create a variable outside of any function, it belongs to `__main__`.\n", + "Los marcos se organizan en un stack que indica qué función llamó a\n", + "cuál, y así sucesivamente. Leyendo desde abajo, `print` fue llamada por `print_twice`, que fue llamada por `cat_twice`, que fue llamada por `__main__`, que es un nombre especial para el marco superior.\n", + "Cuando creas una variable fuera de cualquier función, pertenece a `__main__`.\n", "\n", - "In the frame for `print`, the question mark indicates that we don't know the name of the parameter.\n", - "If you are curious, ask a virtual assistant, \"What are the parameters of the Python print function?\"" + "En el marco de `print`, el signo de interrogación indica que no sabemos el nombre del parámetro.\n", + "Si tienes curiosidad, pregunta a un asistente virtual: \"¿Cuáles son los parámetros de la función `print` de Python?" ] }, { @@ -632,8 +632,8 @@ "source": [ "## Tracebacks\n", "\n", - "When a runtime error occurs in a function, Python displays the name of the function that was running, the name of the function that called it, and so on, up the stack.\n", - "To see an example, I'll define a version of `print_twice` that contains an error -- it tries to print `cat`, which is a local variable in another function." + "Cuando ocurre un error en tiempo de ejecución dentro de una función, Python muestra el nombre de la función que se estaba ejecutando, el nombre de la función que la llamó, y así sucesivamente, subiendo por el stack.\n", + "Para ver un ejemplo, definiré una versión de `print_twice` que contiene un error: intenta imprimir `cat`, que es una variable local de otra función." ] }, { @@ -653,7 +653,7 @@ "id": "d7c0713b", "metadata": {}, "source": [ - "Now here's what happens when we run `cat_twice`." + "Ahora esto es lo que ocurre cuando ejecutamos `cat_twice`." ] }, { @@ -690,11 +690,11 @@ "id": "2f4defcf", "metadata": {}, "source": [ - "The error message includes a **traceback**, which shows the function that was running when the error occurred, the function that called it, and so on.\n", - "In this example, it shows that `cat_twice` called `print_twice`, and the error occurred in a `print_twice`.\n", + "El mensaje de error incluye un **traceback**, que muestra la función que se estaba ejecutando cuando ocurrió el error, la función que la llamó, y así sucesivamente.\n", + "En este ejemplo, muestra que `cat_twice` llamó a `print_twice`, y que el error ocurrió en un `print_twice`.\n", "\n", - "The order of the functions in the traceback is the same as the order of the frames in the stack diagram.\n", - "The function that was running is at the bottom." + "El orden de las funciones en el traceback es el mismo que el orden de los marcos en el diagrama de pila.\n", + "La función que se estaba ejecutando está abajo del todo." ] }, { @@ -702,23 +702,23 @@ "id": "374b4696", "metadata": {}, "source": [ - "## Why functions?\n", + "## ¿Por qué funciones?\n", "\n", - "It may not be clear yet why it is worth the trouble to divide a program into\n", - "functions.\n", - "There are several reasons:\n", + "Puede que todavía no esté claro por qué merece la pena dividir un programa en\n", + "funciones.\n", + "Hay varias razones:\n", "\n", - "- Creating a new function gives you an opportunity to name a group of\n", - " statements, which makes your program easier to read and debug.\n", + "- Crear una nueva función te da la oportunidad de nombrar un grupo de\n", + " sentencias, lo que hace que tu programa sea más fácil de leer y depurar.\n", "\n", - "- Functions can make a program smaller by eliminating repetitive code.\n", - " Later, if you make a change, you only have to make it in one place.\n", + "- Las funciones pueden hacer que un programa sea más pequeño al eliminar código repetitivo.\n", + " Más adelante, si haces un cambio, solo tienes que hacerlo en un lugar.\n", "\n", - "- Dividing a long program into functions allows you to debug the parts\n", - " one at a time and then assemble them into a working whole.\n", + "- Dividir un programa largo en funciones te permite depurar las partes\n", + " de una en una y luego ensamblarlas en un todo que funciona.\n", "\n", - "- Well-designed functions are often useful for many programs. Once you\n", - " write and debug one, you can reuse it." + "- Las funciones bien diseñadas suelen ser útiles para muchos programas. Una vez que\n", + " escribes y depuras una, puedes reutilizarla." ] }, { @@ -726,25 +726,25 @@ "id": "c6dd486e", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Debugging can be frustrating, but it is also challenging, interesting, and sometimes even fun.\n", - "And it is one of the most important skills you can learn.\n", + "Depurar puede ser frustrante, pero también es desafiante, interesante y a veces incluso divertido.\n", + "Y es una de las habilidades más importantes que puedes aprender.\n", "\n", - "In some ways debugging is like detective work.\n", - "You are given clues and you have to infer the events that led to the\n", - "results you see.\n", + "En cierto modo, depurar es como hacer trabajo de detective.\n", + "Se te dan pistas y tienes que inferir los eventos que llevaron a los\n", + "resultados que ves.\n", "\n", - "Debugging is also like experimental science.\n", - "Once you have an idea about what is going wrong, you modify your program and try again.\n", - "If your hypothesis was correct, you can predict the result of the modification, and you take a step closer to a working program.\n", - "If your hypothesis was wrong, you have to come up with a new one.\n", + "Depurar también se parece a la ciencia experimental.\n", + "Una vez que tienes una idea de qué va mal, modificas tu programa y vuelves a intentarlo.\n", + "Si tu hipótesis era correcta, puedes predecir el resultado de la modificación, y das un paso más hacia un programa que funciona.\n", + "Si tu hipótesis era incorrecta, tienes que proponer una nueva.\n", "\n", - "For some people, programming and debugging are the same thing; that is, programming is the process of gradually debugging a program until it does what you want.\n", - "The idea is that you should start with a working program and make small modifications, debugging them as you go.\n", + "Para algunas personas, programar y depurar son lo mismo; es decir, programar es el proceso de depurar gradualmente un programa hasta que hace lo que quieres.\n", + "La idea es que deberías empezar con un programa que funciona y hacer pequeñas modificaciones, depurándolas sobre la marcha.\n", "\n", - "If you find yourself spending a lot of time debugging, that is often a sign that you are writing too much code before you start tests.\n", - "If you take smaller steps, you might find that you can move faster." + "Si te encuentras pasando mucho tiempo depurando, a menudo es una señal de que estás escribiendo demasiado código antes de empezar a hacer pruebas.\n", + "Si das pasos más pequeños, puede que descubras que puedes avanzar más rápido." ] }, { @@ -752,39 +752,39 @@ "id": "d4e95e63", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**function definition:**\n", - "A statement that creates a function.\n", + "**definición de función:**\n", + "Una sentencia que crea una función.\n", "\n", - "**header:**\n", - " The first line of a function definition.\n", + "**encabezado:**\n", + " La primera línea de una definición de función.\n", "\n", - "**body:**\n", - " The sequence of statements inside a function definition.\n", + "**cuerpo:**\n", + " La secuencia de sentencias dentro de una definición de función.\n", "\n", - "**function object:**\n", - "A value created by a function definition.\n", - "The name of the function is a variable that refers to a function object.\n", + "**objeto de función:**\n", + "Un valor creado por una definición de función.\n", + "El nombre de la función es una variable que se refiere a un objeto función.\n", "\n", - "**parameter:**\n", - " A name used inside a function to refer to the value passed as an argument.\n", + "**parámetro:**\n", + " Un nombre usado dentro de una función para referirse al valor pasado como argumento.\n", "\n", - "**loop:**\n", - " A statement that runs one or more statements, often repeatedly.\n", + "**bucle:**\n", + " Una sentencia que ejecuta una o más sentencias, a menudo repetidamente.\n", "\n", - "**local variable:**\n", - "A variable defined inside a function, and which can only be accessed inside the function.\n", + "**variable local:**\n", + "Una variable definida dentro de una función, y a la que solo se puede acceder dentro de la función.\n", "\n", - "**stack diagram:**\n", - "A graphical representation of a stack of functions, their variables, and the values they refer to.\n", + "**diagrama de pila:**\n", + "Una representación gráfica de un stack de funciones, sus variables y los valores a los que se refieren.\n", "\n", - "**frame:**\n", - " A box in a stack diagram that represents a function call.\n", - " It contains the local variables and parameters of the function.\n", + "**marco:**\n", + " Una caja en un diagrama de pila que representa una llamada a función.\n", + " Contiene las variables locales y los parámetros de la función.\n", "\n", "**traceback:**\n", - " A list of the functions that are executing, printed when an exception occurs." + " Una lista de las funciones que se están ejecutando, impresa cuando ocurre una excepción." ] }, { @@ -792,7 +792,7 @@ "id": "eca485f2", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -815,23 +815,23 @@ "id": "82951027", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "The statements in a function or a `for` loop are indented by four spaces, by convention.\n", - "But not everyone agrees with that convention.\n", - "If you are curious about the history of this great debate, ask a virtual assistant to \"tell me about spaces and tabs in Python\".\n", + "Las sentencias dentro de una función o un bucle `for` se indentan con cuatro espacios, por convención.\n", + "Pero no todo el mundo está de acuerdo con esa convención.\n", + "Si tienes curiosidad por la historia de este gran debate, pregunta a un asistente virtual que te hable sobre \"espacios y tabulaciones en Python\".\n", "\n", - "Virtual assistant are pretty good at writing small functions.\n", + "Los asistentes virtuales son bastante buenos escribiendo funciones pequeñas.\n", "\n", - "1. Ask your favorite VA to \"Write a function called repeat that takes a string and an integer and prints the string the given number of times.\" \n", + "1. Pregunta a tu asistente virtual favorito: \"Escribe una función llamada repeat que reciba un string y un entero e imprima el string el número de veces indicado\". \n", "\n", - "2. If the result uses a `for` loop, you could ask, \"Can you do it without a for loop?\"\n", + "2. Si el resultado usa un bucle `for`, podrías preguntar: \"¿Puedes hacerlo sin un bucle for?\"\n", "\n", - "3. Pick any other function in this chapter and ask a VA to write it. The challenge is to describe the function precisely enough to get what you want. Use the vocabulary you have learned so far in this book.\n", + "3. Elige cualquier otra función de este capítulo y pide a un asistente virtual que la escriba. El reto es describir la función con suficiente precisión para obtener lo que quieres. Usa el vocabulario que has aprendido hasta ahora en este libro.\n", "\n", - "Virtual assistants are also pretty good at debugging functions.\n", + "Los asistentes virtuales también son bastante buenos depurando funciones.\n", "\n", - "1. Ask a VA what's wrong with this version of `print_twice`.\n", + "1. Pregunta a un asistente virtual qué está mal en esta versión de `print_twice`.\n", "\n", " ```\n", " def print_twice(string):\n", @@ -839,7 +839,7 @@ " print(cat)\n", " ```\n", " \n", - "And if you get stuck on any of the exercises below, consider asking a VA for help." + "Y si te bloqueas en cualquiera de los ejercicios siguientes, considera pedir ayuda a un asistente virtual." ] }, { @@ -847,9 +847,9 @@ "id": "b7157b09", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function named `print_right` that takes a string named `text` as a parameter and prints the string with enough leading spaces that the last letter of the string is in the 40th column of the display." + "Escribe una función llamada `print_right` que reciba un string llamado `text` como parámetro e imprima el string con suficientes espacios iniciales para que la última letra del string esté en la columna 40 de la pantalla." ] }, { @@ -867,9 +867,9 @@ "id": "428fbee5", "metadata": {}, "source": [ - "Hint: Use the `len` function, the string concatenation operator (`+`) and the string repetition operator (`*`).\n", + "Pista: usa la función `len`, el operador de concatenación de strings (`+`) y el operador de repetición de strings (`*`).\n", "\n", - "Here's an example that shows how it should work." + "Aquí tienes un ejemplo que muestra cómo debería funcionar." ] }, { @@ -891,9 +891,9 @@ "id": "b47467fa", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `triangle` that takes a string and an integer and draws a pyramid with the given height, made up using copies of the string. Here's an example of a pyramid with `5` levels, using the string `'L'`." + "Escribe una función llamada `triangle` que reciba un string y un entero, y dibuje una pirámide con la altura dada, hecha usando copias del string. Aquí tienes un ejemplo de una pirámide con `5` niveles, usando el string `'L'`." ] }, { @@ -924,9 +924,9 @@ "id": "4a28f635", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rectangle` that takes a string and two integers and draws a rectangle with the given width and height, made up using copies of the string. Here's an example of a rectangle with width `5` and height `4`, made up of the string `'H'`." + "Escribe una función llamada `rectangle` que reciba un string y dos enteros, y dibuje un rectángulo con la anchura y altura dadas, hecho usando copias del string. Aquí tienes un ejemplo de un rectángulo con anchura `5` y altura `4`, hecho con el string `'H'`." ] }, { @@ -957,20 +957,20 @@ "id": "44a5de6f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The song \"99 Bottles of Beer\" starts with this verse:\n", + "La canción \"99 Bottles of Beer\" empieza con esta estrofa:\n", "\n", "> 99 bottles of beer on the wall \n", "> 99 bottles of beer \n", "> Take one down, pass it around \n", "> 98 bottles of beer on the wall \n", "\n", - "Then the second verse is the same, except that it starts with 98 bottles and ends with 97. The song continues -- for a very long time -- until there are 0 bottles of beer.\n", + "Luego la segunda estrofa es igual, excepto que empieza con 98 botellas y termina con 97. La canción continúa, durante muchísimo tiempo, hasta que hay 0 botellas de cerveza.\n", "\n", - "Write a function called `bottle_verse` that takes a number as a parameter and displays the verse that starts with the given number of bottles.\n", + "Escribe una función llamada `bottle_verse` que reciba un número como parámetro y muestre la estrofa que empieza con el número dado de botellas.\n", "\n", - "Hint: Consider starting with a function that can print the first, second, or last line of the verse, and then use it to write `bottle_verse`." + "Pista: considera empezar con una función que pueda imprimir la primera, segunda o última línea de la estrofa, y luego úsala para escribir `bottle_verse`." ] }, { @@ -1000,7 +1000,7 @@ "tags": [] }, "source": [ - "Use this function call to display the first verse." + "Usa esta llamada a función para mostrar la primera estrofa." ] }, { @@ -1022,8 +1022,8 @@ "tags": [] }, "source": [ - "If you want to print the whole song, you can use this `for` loop, which counts down from `99` to `1`.\n", - "You don't have to completely understand this example---we'll learn more about `for` loops and the `range` function later." + "Si quieres imprimir la canción completa, puedes usar este bucle `for`, que cuenta hacia atrás desde `99` hasta `1`.\n", + "No tienes que entender completamente este ejemplo; aprenderemos más sobre los bucles `for` y la función `range` más adelante." ] }, { @@ -1055,13 +1055,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap04.ipynb b/chapters/chap04.ipynb index 7117af6..bae44fc 100644 --- a/chapters/chap04.ipynb +++ b/chapters/chap04.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -55,10 +55,10 @@ "id": "fbb4d5a2", "metadata": {}, "source": [ - "# Functions and Interfaces\n", + "# Funciones e interfaces\n", "\n", - "This chapter introduces a module called `jupyturtle`, which allows you to create simple drawings by giving instructions to an imaginary turtle.\n", - "We will use this module to write functions that draw squares, polygons, and circles -- and to demonstrate **interface design**, which is a way of designing functions that work together." + "Este capítulo introduce un módulo llamado `jupyturtle`, que te permite crear dibujos sencillos dando instrucciones a una turtle imaginaria.\n", + "Usaremos este módulo para escribir funciones que dibujan cuadrados, polígonos y círculos, y para demostrar el **diseño de interfaces**, que es una forma de diseñar funciones que trabajan juntas." ] }, { @@ -68,9 +68,9 @@ "tags": [] }, "source": [ - "## The jupyturtle module\n", + "## El módulo jupyturtle\n", "\n", - "To use the `jupyturtle` module, we can import it like this." + "Para usar el módulo `jupyturtle`, podemos importarlo así." ] }, { @@ -88,7 +88,7 @@ "id": "8c801121", "metadata": {}, "source": [ - "Now we can use the functions defined in the module, like `make_turtle` and `forward`." + "Ahora podemos usar las funciones definidas en el módulo, como `make_turtle` y `forward`." ] }, { @@ -107,14 +107,14 @@ "id": "77a61cbb", "metadata": {}, "source": [ - "`make_turtle` creates a **canvas**, which is a space on the screen where we can draw, and a turtle, which is represented by a circular shell and a triangular head.\n", - "The circle shows the location of the turtle and the triangle indicates the direction it is facing.\n", + "`make_turtle` crea un **canvas**, que es un espacio en la pantalla donde podemos dibujar, y una turtle, que se representa con un caparazón circular y una cabeza triangular.\n", + "El círculo muestra la ubicación de la turtle y el triángulo indica la dirección hacia la que mira.\n", "\n", - "`forward` moves the turtle a given distance in the direction it's facing, drawing a line segment along the way.\n", - "The distance is in arbitrary units -- the actual size depends on your computer's screen.\n", + "`forward` mueve la turtle una distancia dada en la dirección hacia la que mira, dibujando un segmento de línea por el camino.\n", + "La distancia está en unidades arbitrarias: el tamaño real depende de la pantalla de tu ordenador.\n", "\n", - "We will use functions defined in the `jupyturtle` module many times, so it would be nice if we did not have to write the name of the module every time.\n", - "That's possible if we import the module like this." + "Usaremos muchas veces funciones definidas en el módulo `jupyturtle`, así que estaría bien no tener que escribir el nombre del módulo cada vez.\n", + "Eso es posible si importamos el módulo así." ] }, { @@ -132,7 +132,7 @@ "id": "c1322d31", "metadata": {}, "source": [ - "This version of the import statement imports `make_turtle` and `forward` from the `jupyturtle` module so we can call them like this." + "Esta versión de la sentencia `import` importa `make_turtle` y `forward` desde el módulo `jupyturtle`, de modo que podemos llamarlas así." ] }, { @@ -151,8 +151,8 @@ "id": "bd319754", "metadata": {}, "source": [ - "`jupyturtle` provides two other functions we'll use, called `left` and `right`.\n", - "We'll import them like this." + "`jupyturtle` proporciona otras dos funciones que usaremos, llamadas `left` y `right`.\n", + "Las importaremos así." ] }, { @@ -170,8 +170,8 @@ "id": "0da2a311", "metadata": {}, "source": [ - "`left` causes the turtle to turn left. It takes one argument, which is the angle of the turn in degrees.\n", - "For example, we can make a 90 degree left turn like this." + "`left` hace que la turtle gire a la izquierda. Recibe un argumento, que es el ángulo del giro en grados.\n", + "Por ejemplo, podemos hacer un giro a la izquierda de 90 grados así." ] }, { @@ -192,8 +192,8 @@ "id": "cea2940f", "metadata": {}, "source": [ - "This program moves the turtle east and then north, leaving two line segments behind.\n", - "Before you go on, see if you can modify the previous program to make a square." + "Este programa mueve la turtle hacia el este y luego hacia el norte, dejando dos segmentos de línea detrás.\n", + "Antes de continuar, prueba si puedes modificar el programa anterior para hacer un cuadrado." ] }, { @@ -201,9 +201,9 @@ "id": "e20ea96c", "metadata": {}, "source": [ - "## Making a square\n", + "## Hacer un cuadrado\n", "\n", - "Here's one way to make a square." + "Aquí tienes una forma de hacer un cuadrado." ] }, { @@ -233,7 +233,7 @@ "id": "a7500957", "metadata": {}, "source": [ - "Because this program repeats the same pair of lines four times, we can do the same thing more concisely with a `for` loop." + "Como este programa repite el mismo par de líneas cuatro veces, podemos hacer lo mismo de forma más concisa con un bucle `for`." ] }, { @@ -256,9 +256,9 @@ "tags": [] }, "source": [ - "## Encapsulation and generalization\n", + "## Encapsulación y generalización\n", "\n", - "Let's take the square-drawing code from the previous section and put it in a function called `square`." + "Tomemos el código para dibujar cuadrados de la sección anterior y pongámoslo en una función llamada `square`." ] }, { @@ -279,7 +279,7 @@ "id": "0789b5d9", "metadata": {}, "source": [ - "Now we can call the function like this." + "Ahora podemos llamar a la función así." ] }, { @@ -298,11 +298,11 @@ "id": "da905fc6", "metadata": {}, "source": [ - "Wrapping a piece of code up in a function is called **encapsulation**.\n", - "One of the benefits of encapsulation is that it attaches a name to the code, which serves as a kind of documentation. Another advantage is that if you re-use the code, it is more concise to call a function twice than to copy and paste the body!\n", + "Envolver un fragmento de código en una función se llama **encapsulación**.\n", + "Uno de los beneficios de la encapsulación es que le da un nombre al código, que sirve como una especie de documentación. ¡Otra ventaja es que, si reutilizas el código, es más conciso llamar a una función dos veces que copiar y pegar el cuerpo!\n", "\n", - "In the current version, the size of the square is always `50`.\n", - "If we want to draw squares with different sizes, we can take the length of the sides as a parameter. " + "En la versión actual, el tamaño del cuadrado siempre es `50`.\n", + "Si queremos dibujar cuadrados de distintos tamaños, podemos tomar la longitud de los lados como parámetro. " ] }, { @@ -323,7 +323,7 @@ "id": "397fda4b", "metadata": {}, "source": [ - "Now we can draw squares with different sizes." + "Ahora podemos dibujar cuadrados de distintos tamaños." ] }, { @@ -343,10 +343,10 @@ "id": "5a46bf64", "metadata": {}, "source": [ - "Adding a parameter to a function is called **generalization** because it makes the function more general: with the previous version, the square is always the same size; with this version it can be any size.\n", + "Añadir un parámetro a una función se llama **generalización** porque hace que la función sea más general: con la versión anterior, el cuadrado siempre tiene el mismo tamaño; con esta versión puede tener cualquier tamaño.\n", "\n", - "If we add another parameter, we can make it even more general.\n", - "The following function draws regular polygons with a given number of sides." + "Si añadimos otro parámetro, podemos hacerla aún más general.\n", + "La siguiente función dibuja polígonos regulares con un número dado de lados." ] }, { @@ -368,9 +368,9 @@ "id": "286d3c77", "metadata": {}, "source": [ - "In a regular polygon with `n` sides, the angle between adjacent sides is `360 / n` degrees. \n", + "En un polígono regular con `n` lados, el ángulo entre lados adyacentes es de `360 / n` grados. \n", "\n", - "The following example draws a `7`-sided polygon with side length `30`." + "El siguiente ejemplo dibuja un polígono de `7` lados con longitud de lado `30`." ] }, { @@ -389,8 +389,8 @@ "id": "dc0226db", "metadata": {}, "source": [ - "When a function has more than a few numeric arguments, it is easy to forget what they are, or what order they should be in. \n", - "It can be a good idea to include the names of the parameters in the argument list." + "Cuando una función tiene más de unos pocos argumentos numéricos, es fácil olvidar qué son o en qué orden deberían ir. \n", + "Puede ser una buena idea incluir los nombres de los parámetros en la lista de argumentos." ] }, { @@ -411,10 +411,10 @@ "id": "6aa28eba", "metadata": {}, "source": [ - "These are sometimes called \"named arguments\" because they include the parameter names.\n", - "But in Python they are more often called **keyword arguments** (not to be confused with Python keywords like `for` and `def`).\n", + "A veces se llaman \"argumentos con nombre\" porque incluyen los nombres de los parámetros.\n", + "Pero en Python se llaman más a menudo **argumentos de palabra clave** (no deben confundirse con las palabras clave de Python como `for` y `def`).\n", "\n", - "This use of the assignment operator, `=`, is a reminder about how arguments and parameters work -- when you call a function, the arguments are assigned to the parameters." + "Este uso del operador de asignación, `=`, sirve como recordatorio de cómo funcionan los argumentos y los parámetros: cuando llamas a una función, los argumentos se asignan a los parámetros." ] }, { @@ -422,11 +422,11 @@ "id": "b10184b4", "metadata": {}, "source": [ - "## Approximating a circle\n", + "## Aproximar un círculo\n", "\n", - "Now suppose we want to draw a circle.\n", - "We can do that, approximately, by drawing a polygon with a large number of sides, so each side is small enough that it's hard to see.\n", - "Here is a function that uses `polygon` to draw a `30`-sided polygon that approximates a circle." + "Ahora supongamos que queremos dibujar un círculo.\n", + "Podemos hacerlo, aproximadamente, dibujando un polígono con un gran número de lados, de modo que cada lado sea lo bastante pequeño como para que cueste verlo.\n", + "Aquí tienes una función que usa `polygon` para dibujar un polígono de `30` lados que aproxima un círculo." ] }, { @@ -450,13 +450,13 @@ "id": "39023314", "metadata": {}, "source": [ - "`circle` takes the radius of the the circle as a parameter.\n", - "It computes `circumference`, which is the circumference of a circle with the given radius.\n", - "`n` is the number of sides, so `circumference / n` is the length of each side.\n", + "`circle` recibe el radio del círculo como parámetro.\n", + "Calcula `circumference`, que es la circunferencia de un círculo con el radio dado.\n", + "`n` es el número de lados, así que `circumference / n` es la longitud de cada lado.\n", "\n", - "This function might take a long time to run.\n", - "We can speed it up by calling `make_turtle` with a keyword argument called `delay` that sets the time, in seconds, the turtle waits after each step.\n", - "The default value is `0.2` seconds -- if we set it to `0.02` it runs about 10 times faster." + "Esta función podría tardar mucho en ejecutarse.\n", + "Podemos acelerarla llamando a `make_turtle` con un argumento de palabra clave llamado `delay` que establece el tiempo, en segundos, que la turtle espera después de cada paso.\n", + "El valor predeterminado es `0.2` segundos; si lo establecemos en `0.02`, se ejecuta unas 10 veces más rápido." ] }, { @@ -475,11 +475,11 @@ "id": "701f9cf8", "metadata": {}, "source": [ - "A limitation of this solution is that `n` is a constant, which means\n", - "that for very big circles, the sides are too long, and for small\n", - "circles, we waste time drawing very short sides.\n", - "One option is to generalize the function by taking `n` as a parameter.\n", - "But let's keep it simple for now." + "Una limitación de esta solución es que `n` es una constante, lo que significa\n", + "que para círculos muy grandes los lados son demasiado largos, y para círculos pequeños\n", + "perdemos tiempo dibujando lados muy cortos.\n", + "Una opción es generalizar la función tomando `n` como parámetro.\n", + "Pero mantengámoslo sencillo por ahora." ] }, { @@ -487,15 +487,15 @@ "id": "c48f262c", "metadata": {}, "source": [ - "## Refactoring\n", + "## Refactorización\n", "\n", - "Now let's write a more general version of `circle`, called `arc`, that takes a second parameter, `angle`, and draws an arc of a circle that spans the given angle.\n", - "For example, if `angle` is `360` degrees, it draws a complete circle. If `angle` is `180` degrees, it draws a half circle.\n", + "Ahora escribamos una versión más general de `circle`, llamada `arc`, que recibe un segundo parámetro, `angle`, y dibuja un arco de un círculo que abarca el ángulo dado.\n", + "Por ejemplo, si `angle` es `360` grados, dibuja un círculo completo. Si `angle` es `180` grados, dibuja un semicírculo.\n", "\n", - "To write `circle`, we were able to reuse `polygon`, because a many-sided polygon is a good approximation of a circle.\n", - "But we can't use `polygon` to write `arc`.\n", + "Para escribir `circle`, pudimos reutilizar `polygon`, porque un polígono con muchos lados es una buena aproximación de un círculo.\n", + "Pero no podemos usar `polygon` para escribir `arc`.\n", "\n", - "Instead, we'll create the more general version of `polygon`, called `polyline`." + "En su lugar, crearemos una versión más general de `polygon`, llamada `polyline`." ] }, { @@ -516,9 +516,9 @@ "id": "c2b2503e", "metadata": {}, "source": [ - "`polyline` takes as parameters the number of line segments to draw, `n`, the length of the segments, `length`, and the angle between them, `angle`.\n", + "`polyline` recibe como parámetros el número de segmentos de línea que debe dibujar, `n`, la longitud de los segmentos, `length`, y el ángulo entre ellos, `angle`.\n", "\n", - "Now we can rewrite `polygon` to use `polyline`." + "Ahora podemos reescribir `polygon` para que use `polyline`." ] }, { @@ -538,7 +538,7 @@ "id": "2714a59e", "metadata": {}, "source": [ - "And we can use `polyline` to write `arc`." + "Y podemos usar `polyline` para escribir `arc`." ] }, { @@ -561,9 +561,9 @@ "id": "3c18773c", "metadata": {}, "source": [ - "`arc` is similar to `circle`, except that it computes `arc_length`, which is a fraction of the circumference of a circle.\n", + "`arc` es similar a `circle`, salvo que calcula `arc_length`, que es una fracción de la circunferencia de un círculo.\n", "\n", - "Finally, we can rewrite `circle` to use `arc`." + "Por último, podemos reescribir `circle` para que use `arc`." ] }, { @@ -582,8 +582,8 @@ "id": "313a357c", "metadata": {}, "source": [ - "To check that these functions work as expected, we'll use them to draw something like a snail.\n", - "With `delay=0`, the turtle runs as fast as possible." + "Para comprobar que estas funciones funcionan como esperamos, las usaremos para dibujar algo parecido a un caracol.\n", + "Con `delay=0`, la turtle va lo más rápido posible." ] }, { @@ -604,12 +604,12 @@ "id": "a34da3d8", "metadata": {}, "source": [ - "In this example, we started with working code and reorganized it with different functions.\n", - "Changes like this, which improve the code without changing its behavior, are called **refactoring**.\n", + "En este ejemplo, empezamos con código que funcionaba y lo reorganizamos con funciones diferentes.\n", + "Los cambios como este, que mejoran el código sin cambiar su comportamiento, se llaman **refactorización**.\n", "\n", - "If we had planned ahead, we might have written `polyline` first and avoided refactoring, but often you don't know enough at the beginning of a project to design all the functions.\n", - "Once you start coding, you understand the problem better.\n", - "Sometimes refactoring is a sign that you have learned something." + "Si lo hubiéramos planeado con antelación, quizá habríamos escrito `polyline` primero y evitado la refactorización, pero a menudo no sabes lo suficiente al principio de un proyecto para diseñar todas las funciones.\n", + "Una vez que empiezas a programar, entiendes mejor el problema.\n", + "A veces la refactorización es una señal de que has aprendido algo." ] }, { @@ -617,10 +617,10 @@ "id": "d18c9d16", "metadata": {}, "source": [ - "## Stack diagram\n", + "## Diagrama de pila\n", "\n", - "When we call `circle`, it calls `arc`, which calls `polyline`.\n", - "We can use a stack diagram to show this sequence of function calls and the parameters for each one." + "Cuando llamamos a `circle`, llama a `arc`, que llama a `polyline`.\n", + "Podemos usar un diagrama de pila para mostrar esta secuencia de llamadas a funciones y los parámetros de cada una." ] }, { @@ -666,8 +666,8 @@ "id": "3160bba1", "metadata": {}, "source": [ - "Notice that the value of `angle` in `polyline` is different from the value of `angle` in `arc`.\n", - "Parameters are local, which means you can use the same parameter name in different functions; it's a different variable in each function, and it can refer to a different value. " + "Observa que el valor de `angle` en `polyline` es diferente del valor de `angle` en `arc`.\n", + "Los parámetros son locales, lo que significa que puedes usar el mismo nombre de parámetro en funciones diferentes; es una variable distinta en cada función y puede referirse a un valor diferente. " ] }, { @@ -675,27 +675,27 @@ "id": "c23552d3", "metadata": {}, "source": [ - "## A development plan\n", + "## Un plan de desarrollo\n", "\n", - "A **development plan** is a process for writing programs.\n", - "The process we used in this chapter is \"encapsulation and generalization\".\n", - "The steps of this process are:\n", + "Un **plan de desarrollo** es un proceso para escribir programas.\n", + "El proceso que usamos en este capítulo es \"encapsulación y generalización\".\n", + "Los pasos de este proceso son:\n", "\n", - "1. Start by writing a small program with no function definitions.\n", + "1. Empieza escribiendo un programa pequeño sin definiciones de funciones.\n", "\n", - "2. Once you get the program working, identify a coherent piece of it,\n", - " encapsulate the piece in a function and give it a name.\n", + "2. Una vez que consigas que el programa funcione, identifica una parte coherente,\n", + " encapsula esa parte en una función y dale un nombre.\n", "\n", - "3. Generalize the function by adding appropriate parameters.\n", + "3. Generaliza la función añadiendo los parámetros adecuados.\n", "\n", - "4. Repeat Steps 1 to 3 until you have a set of working functions.\n", + "4. Repite los pasos 1 a 3 hasta que tengas un conjunto de funciones que funcionen.\n", "\n", - "5. Look for opportunities to improve the program by refactoring. For\n", - " example, if you have similar code in several places, consider\n", - " factoring it into an appropriately general function.\n", + "5. Busca oportunidades para mejorar el programa mediante refactorización. Por\n", + " ejemplo, si tienes código similar en varios lugares, considera\n", + " factorizarlo en una función adecuadamente general.\n", "\n", - "This process has some drawbacks -- we will see alternatives later -- but it can be useful if you don't know ahead of time how to divide the program into functions.\n", - "This approach lets you design as you go along." + "Este proceso tiene algunas desventajas (veremos alternativas más adelante), pero puede ser útil si no sabes de antemano cómo dividir el programa en funciones.\n", + "Este enfoque te permite diseñar sobre la marcha." ] }, { @@ -703,13 +703,13 @@ "id": "a3b6b83d", "metadata": {}, "source": [ - "The design of a function has two parts:\n", + "El diseño de una función tiene dos partes:\n", "\n", - "* The **interface** is how the function is used, including its name, the parameters it takes and what the function is supposed to do.\n", + "* La **interfaz** es cómo se usa la función, incluyendo su nombre, los parámetros que recibe y lo que se supone que debe hacer.\n", "\n", - "* The **implementation** is how the function does what it's supposed to do.\n", + "* La **implementación** es cómo la función hace lo que se supone que debe hacer.\n", "\n", - "For example, here's the first version of `circle` we wrote, which uses `polygon`." + "Por ejemplo, aquí tienes la primera versión de `circle` que escribimos, que usa `polygon`." ] }, { @@ -731,7 +731,7 @@ "id": "5d3d2e79", "metadata": {}, "source": [ - "And here's the refactored version that uses `arc`." + "Y aquí tienes la versión refactorizada que usa `arc`." ] }, { @@ -750,7 +750,7 @@ "id": "b726f72c", "metadata": {}, "source": [ - "These two functions have the same interface -- they take the same parameters and do the same thing -- but they have different implementations." + "Estas dos funciones tienen la misma interfaz: reciben los mismos parámetros y hacen lo mismo, pero tienen implementaciones diferentes." ] }, { @@ -762,8 +762,8 @@ "source": [ "## Docstrings\n", "\n", - "A **docstring** is a string at the beginning of a function that explains the interface (\"doc\" is short for \"documentation\").\n", - "Here is an example:" + "Un **docstring** es un string al principio de una función que explica la interfaz (\"doc\" es la abreviatura de \"documentación\").\n", + "Aquí tienes un ejemplo:" ] }, { @@ -790,18 +790,18 @@ "id": "55b60cbc", "metadata": {}, "source": [ - "By convention, docstrings are triple-quoted strings, also known as **multiline strings** because the triple quotes allow the string to span more than one line.\n", + "Por convención, los docstrings son strings entre comillas triples, también conocidos como **strings multilínea** porque las comillas triples permiten que el string ocupe más de una línea.\n", "\n", - "A docstring should:\n", + "Un docstring debería:\n", "\n", - "* Explain concisely what the function does, without getting into the details of how it works,\n", + "* Explicar de forma concisa qué hace la función, sin entrar en los detalles de cómo funciona,\n", "\n", - "* Explain what effect each parameter has on the behavior of the function, and\n", + "* Explicar qué efecto tiene cada parámetro en el comportamiento de la función, e\n", "\n", - "* Indicate what type each parameter should be, if it is not obvious.\n", + "* Indicar qué tipo debería tener cada parámetro, si no es obvio.\n", "\n", - "Writing this kind of documentation is an important part of interface design.\n", - "A well-designed interface should be simple to explain; if you have a hard time explaining one of your functions, maybe the interface could be improved." + "Escribir este tipo de documentación es una parte importante del diseño de interfaces.\n", + "Una interfaz bien diseñada debería ser sencilla de explicar; si te cuesta explicar una de tus funciones, quizá la interfaz podría mejorarse." ] }, { @@ -809,20 +809,20 @@ "id": "f1115940", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "An interface is like a contract between a function and a caller. The\n", - "caller agrees to provide certain arguments and the function agrees to\n", - "do certain work.\n", + "Una interfaz es como un contrato entre una función y quien la llama. Quien\n", + "llama acepta proporcionar ciertos argumentos y la función acepta\n", + "hacer cierto trabajo.\n", "\n", - "For example, `polyline` requires three arguments: `n` has to be an integer; `length` should be a positive number; and `angle` has to be a number, which is understood to be in degrees.\n", + "Por ejemplo, `polyline` requiere tres argumentos: `n` tiene que ser un entero; `length` debería ser un número positivo; y `angle` tiene que ser un número, que se entiende que está en grados.\n", "\n", - "These requirements are called **preconditions** because they are supposed to be true before the function starts executing. Conversely, conditions at the end of the function are **postconditions**.\n", - "Postconditions include the intended effect of the function (like drawing line segments) and any side effects (like moving the turtle or making other changes).\n", + "Estos requisitos se llaman **precondiciones** porque se supone que deben ser verdaderos antes de que la función empiece a ejecutarse. Por el contrario, las condiciones al final de la función son **postcondiciones**.\n", + "Las postcondiciones incluyen el efecto previsto de la función (como dibujar segmentos de línea) y cualquier efecto secundario (como mover la turtle o hacer otros cambios).\n", "\n", - "Preconditions are the responsibility of the caller. If the caller violates a precondition and the function doesn't work correctly, the bug is in the caller, not the function.\n", + "Las precondiciones son responsabilidad de quien llama. Si quien llama viola una precondición y la función no funciona correctamente, el bug está en quien llama, no en la función.\n", "\n", - "If the preconditions are satisfied and the postconditions are not, the bug is in the function. If your pre- and postconditions are clear, they can help with debugging." + "Si las precondiciones se satisfacen y las postcondiciones no, el bug está en la función. Si tus precondiciones y postcondiciones están claras, pueden ayudar con la depuración." ] }, { @@ -830,40 +830,40 @@ "id": "a4d33a70", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**interface design:**\n", - "A process for designing the interface of a function, which includes the parameters it should take.\n", + "**diseño de interfaces:**\n", + "Un proceso para diseñar la interfaz de una función, que incluye los parámetros que debería recibir.\n", "\n", - "**canvas:**\n", - "A window used to display graphical elements including lines, circles, rectangles, and other shapes.\n", + "**lienzo:**\n", + "Una ventana usada para mostrar elementos gráficos, incluyendo líneas, círculos, rectángulos y otras formas.\n", "\n", - "**encapsulation:**\n", - " The process of transforming a sequence of statements into a function definition.\n", + "**encapsulación:**\n", + " El proceso de transformar una secuencia de sentencias en una definición de función.\n", "\n", - "**generalization:**\n", - " The process of replacing something unnecessarily specific (like a number) with something appropriately general (like a variable or parameter).\n", + "**generalización:**\n", + " El proceso de reemplazar algo innecesariamente específico (como un número) por algo adecuadamente general (como una variable o un parámetro).\n", "\n", - "**keyword argument:**\n", - "An argument that includes the name of the parameter.\n", + "**argumento de palabra clave:**\n", + "Un argumento que incluye el nombre del parámetro.\n", "\n", - "**refactoring:**\n", - " The process of modifying a working program to improve function interfaces and other qualities of the code.\n", + "**refactorización:**\n", + " El proceso de modificar un programa que funciona para mejorar las interfaces de las funciones y otras cualidades del código.\n", "\n", - "**development plan:**\n", - "A process for writing programs.\n", + "**plan de desarrollo:**\n", + "Un proceso para escribir programas.\n", "\n", "**docstring:**\n", - " A string that appears at the top of a function definition to document the function's interface.\n", + " Un string que aparece al principio de una definición de función para documentar la interfaz de la función.\n", "\n", - "**multiline string:**\n", - "A string enclosed in triple quotes that can span more than one line of a program.\n", + "**string multilínea:**\n", + "Un string encerrado entre comillas triples que puede ocupar más de una línea de un programa.\n", "\n", - "**precondition:**\n", - " A requirement that should be satisfied by the caller before a function starts.\n", + "**precondición:**\n", + " Un requisito que debería satisfacer quien llama antes de que empiece una función.\n", "\n", - "**postcondition:**\n", - " A requirement that should be satisfied by the function before it ends." + "**postcondición:**\n", + " Un requisito que debería satisfacer la función antes de terminar." ] }, { @@ -871,7 +871,7 @@ "id": "0bfe2e19", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -894,13 +894,13 @@ "id": "50ed5c38", "metadata": {}, "source": [ - "For the exercises below, there are a few more turtle functions you might want to use.\n", + "Para los ejercicios siguientes, hay algunas funciones más de turtle que quizá quieras usar.\n", "\n", - "* `penup` lifts the turtle's imaginary pen so it doesn't leave a trail when it moves.\n", + "* `penup` levanta el lápiz imaginario de la turtle para que no deje rastro cuando se mueve.\n", "\n", - "* `pendown` puts the pen back down.\n", + "* `pendown` vuelve a bajar el lápiz.\n", "\n", - "The following function uses `penup` and `pendown` to move the turtle without leaving a trail." + "La siguiente función usa `penup` y `pendown` para mover la turtle sin dejar rastro." ] }, { @@ -927,10 +927,10 @@ "id": "c78c1e17", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rectangle` that draws a rectangle with given side lengths.\n", - "For example, here's a rectangle that's `80` units wide and `40` units tall." + "Escribe una función llamada `rectangle` que dibuje un rectángulo con longitudes de lado dadas.\n", + "Por ejemplo, aquí tienes un rectángulo de `80` unidades de ancho y `40` unidades de alto." ] }, { @@ -950,7 +950,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your function." + "Puedes usar el siguiente código para probar tu función." ] }, { @@ -971,9 +971,9 @@ "id": "8b8faaf6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `rhombus` that draws a rhombus with a given side length and a given interior angle. For example, here's a rhombus with side length `50` and an interior angle of `60` degrees." + "Escribe una función llamada `rhombus` que dibuje un rombo con una longitud de lado dada y un ángulo interior dado. Por ejemplo, aquí tienes un rombo con longitud de lado `50` y un ángulo interior de `60` grados." ] }, { @@ -993,7 +993,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your function." + "Puedes usar el siguiente código para probar tu función." ] }, { @@ -1014,9 +1014,9 @@ "id": "a9175a90", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now write a more general function called `parallelogram` that draws a quadrilateral with parallel sides. Then rewrite `rectangle` and `rhombus` to use `parallelogram`." + "Ahora escribe una función más general llamada `parallelogram` que dibuje un cuadrilátero con lados paralelos. Luego reescribe `rectangle` y `rhombus` para que usen `parallelogram`." ] }, { @@ -1056,7 +1056,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions." + "Puedes usar el siguiente código para probar tus funciones." ] }, { @@ -1083,13 +1083,13 @@ "id": "991ab59d", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an appropriately general set of functions that can draw shapes like this.\n", + "Escribe un conjunto de funciones adecuadamente general que pueda dibujar formas como esta.\n", "\n", "![](https://github.com/AllenDowney/ThinkPython/raw/v3/jupyturtle_pie.png)\n", "\n", - "Hint: Write a function called `triangle` that draws one triangular segment, and then a function called `draw_pie` that uses `triangle`." + "Pista: escribe una función llamada `triangle` que dibuje un segmento triangular, y luego una función llamada `draw_pie` que use `triangle`." ] }, { @@ -1119,7 +1119,7 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions." + "Puedes usar el siguiente código para probar tus funciones." ] }, { @@ -1159,13 +1159,13 @@ "id": "9c78b76f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an appropriately general set of functions that can draw flowers like this.\n", + "Escribe un conjunto de funciones adecuadamente general que pueda dibujar flores como esta.\n", "\n", "![](https://github.com/AllenDowney/ThinkPython/raw/v3/jupyturtle_flower.png)\n", "\n", - "Hint: Use `arc` to write a function called `petal` that draws one flower petal." + "Pista: usa `arc` para escribir una función llamada `petal` que dibuje un pétalo de flor." ] }, { @@ -1195,12 +1195,12 @@ "tags": [] }, "source": [ - "You can use the following code to test your functions.\n", + "Puedes usar el siguiente código para probar tus funciones.\n", "\n", - "Because the solution draws a lot of small line segments, it tends to slow down as it runs.\n", - "To avoid that, you can add the keyword argument `auto_render=False` to avoid drawing after every step, and then call the `render` function at the end to show the result.\n", + "Como la solución dibuja muchos segmentos de línea pequeños, tiende a ralentizarse mientras se ejecuta.\n", + "Para evitarlo, puedes añadir el argumento de palabra clave `auto_render=False` para evitar dibujar después de cada paso, y luego llamar a la función `render` al final para mostrar el resultado.\n", "\n", - "While you are debugging, you might want to remove `auto_render=False`." + "Mientras estés depurando, quizá quieras quitar `auto_render=False`." ] }, { @@ -1248,12 +1248,12 @@ "id": "9d9f35d1", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are several modules like `jupyturtle` in Python, and the one we used in this chapter has been customized for this book.\n", - "So if you ask a virtual assistant for help, it won't know which module to use.\n", - "But if you give it a few examples to work with, it can probably figure it out.\n", - "For example, try this prompt and see if it can write a function that draws a spiral:\n", + "Hay varios módulos como `jupyturtle` en Python, y el que usamos en este capítulo se ha personalizado para este libro.\n", + "Así que, si pides ayuda a un asistente virtual, no sabrá qué módulo usar.\n", + "Pero si le das algunos ejemplos con los que trabajar, probablemente pueda deducirlo.\n", + "Por ejemplo, prueba este prompt y mira si puede escribir una función que dibuje una espiral:\n", "\n", "```\n", "The following program uses a turtle graphics module to draw a circle:\n", @@ -1285,9 +1285,9 @@ "id": "7beb2afe", "metadata": {}, "source": [ - "Keep in mind that the result might use features we have not seen yet, and it might have errors.\n", - "Copy the code from the VA and see if you can get it working.\n", - "If you didn't get what you wanted, try modifying the prompt.\n" + "Ten en cuenta que el resultado podría usar características que aún no hemos visto, y podría tener errores.\n", + "Copia el código del asistente virtual y comprueba si puedes hacerlo funcionar.\n", + "Si no obtuviste lo que querías, prueba a modificar el prompt.\n" ] }, { @@ -1317,13 +1317,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap05.ipynb b/chapters/chap05.ipynb index 23e5094..73237f2 100644 --- a/chapters/chap05.ipynb +++ b/chapters/chap05.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -42,12 +42,12 @@ "id": "75b60d6c", "metadata": {}, "source": [ - "# Conditionals and Recursion\n", + "# Condicionales y recursión\n", "\n", - "The main topic of this chapter is the `if` statement, which executes different code depending on the state of the program.\n", - "And with the `if` statement we'll be able to explore one of the most powerful ideas in computing, **recursion**.\n", + "El tema principal de este capítulo es la sentencia `if`, que ejecuta código distinto según el estado del programa.\n", + "Y con la sentencia `if` podremos explorar una de las ideas más potentes de la informática: la **recursión**.\n", "\n", - "But we'll start with three new features: the modulus operator, boolean expressions, and logical operators." + "Pero empezaremos con tres características nuevas: el operador módulo, las expresiones booleanas y los operadores lógicos." ] }, { @@ -55,13 +55,13 @@ "id": "4ab7caf4", "metadata": {}, "source": [ - "## Integer division and modulus\n", + "## División entera y módulo\n", "\n", - "Recall that the integer division operator, `//`, divides two numbers and rounds\n", - "down to an integer.\n", - "For example, suppose the run time of a movie is 105 minutes. \n", - "You might want to know how long that is in hours.\n", - "Conventional division returns a floating-point number:" + "Recuerda que el operador de división entera, `//`, divide dos números y redondea\n", + "hacia abajo hasta un entero.\n", + "Por ejemplo, supón que la duración de una película es de 105 minutos. \n", + "Puede que quieras saber cuánto es eso en horas.\n", + "La división convencional devuelve un número de punto flotante:" ] }, { @@ -80,8 +80,8 @@ "id": "3f224403", "metadata": {}, "source": [ - "But we don't normally write hours with decimal points.\n", - "Integer division returns the integer number of hours, rounding down:" + "Pero normalmente no escribimos las horas con decimales.\n", + "La división entera devuelve el número entero de horas, redondeando hacia abajo:" ] }, { @@ -101,7 +101,7 @@ "id": "bfa9b0cf", "metadata": {}, "source": [ - "To get the remainder, you could subtract off one hour in minutes:" + "Para obtener el resto, podrías restar una hora expresada en minutos:" ] }, { @@ -120,7 +120,7 @@ "id": "05caf27f", "metadata": {}, "source": [ - "Or you could use the **modulus operator**, `%`, which divides two numbers and returns the remainder." + "O podrías usar el **operador módulo**, `%`, que divide dos números y devuelve el resto." ] }, { @@ -139,12 +139,12 @@ "id": "18c1e0d0", "metadata": {}, "source": [ - "The modulus operator is more useful than it might seem.\n", - "For example, it can check whether one number is divisible by another -- if `x % y` is zero, then `x` is divisible by `y`.\n", + "El operador módulo es más útil de lo que podría parecer.\n", + "Por ejemplo, puede comprobar si un número es divisible por otro: si `x % y` es cero, entonces `x` es divisible por `y`.\n", "\n", - "Also, it can extract the right-most digit or digits from a number.\n", - "For example, `x % 10` yields the right-most digit of `x` (in base 10).\n", - "Similarly, `x % 100` yields the last two digits." + "También puede extraer el dígito o los dígitos más a la derecha de un número.\n", + "Por ejemplo, `x % 10` produce el dígito más a la derecha de `x` (en base 10).\n", + "De forma similar, `x % 100` produce los dos últimos dígitos." ] }, { @@ -173,8 +173,8 @@ "id": "f2344fc0", "metadata": {}, "source": [ - "Finally, the modulus operator can do \"clock arithmetic\".\n", - "For example, if an event starts at 11 AM and lasts three hours, we can use the modulus operator to figure out what time it ends." + "Por último, el operador módulo puede hacer «aritmética de reloj».\n", + "Por ejemplo, si un evento empieza a las 11 AM y dura tres horas, podemos usar el operador módulo para averiguar a qué hora termina." ] }, { @@ -195,7 +195,7 @@ "id": "351c30df", "metadata": {}, "source": [ - "The event would end at 2 PM." + "El evento terminaría a las 2 PM." ] }, { @@ -203,10 +203,10 @@ "id": "5ed1b58b", "metadata": {}, "source": [ - "## Boolean Expressions\n", + "## Expresiones booleanas\n", "\n", - "A **boolean expression** is an expression that is either true or false.\n", - "For example, the following expressions use the equals operator, `==`, which compares two values and produces `True` if they are equal and `False` otherwise:" + "Una **expresión booleana** es una expresión que es verdadera o falsa.\n", + "Por ejemplo, las siguientes expresiones usan el operador de igualdad, `==`, que compara dos valores y produce `True` si son iguales y `False` en caso contrario:" ] }, { @@ -234,8 +234,8 @@ "id": "41fbc642", "metadata": {}, "source": [ - "A common error is to use a single equal sign (`=`) instead of a double equal sign (`==`).\n", - "Remember that `=` assigns a value to a variable and `==` compares two values. " + "Un error común es usar un solo signo igual (`=`) en lugar de un doble signo igual (`==`).\n", + "Recuerda que `=` asigna un valor a una variable y `==` compara dos valores. " ] }, { @@ -264,8 +264,8 @@ "id": "d3ec6b48", "metadata": {}, "source": [ - "`True` and `False` are special values that belong to the type `bool`;\n", - "they are not strings:" + "`True` y `False` son valores especiales que pertenecen al tipo `bool`;\n", + "no son cadenas:" ] }, { @@ -293,7 +293,7 @@ "id": "451b2e8d", "metadata": {}, "source": [ - "The `==` operator is one of the **relational operators**; the others are:" + "El operador `==` es uno de los **operadores relacionales**; los otros son:" ] }, { @@ -351,12 +351,12 @@ "id": "db5a9477", "metadata": {}, "source": [ - "## Logical operators\n", + "## Operadores lógicos\n", "\n", - "To combine boolean values into expressions, we can use **logical operators**.\n", - "The most common are `and`, ` or`, and `not`.\n", - "The meaning of these operators is similar to their meaning in English.\n", - "For example, the value of the following expression is `True` only if `x` is greater than `0` *and* less than `10`." + "Para combinar valores booleanos en expresiones, podemos usar **operadores lógicos**.\n", + "Los más comunes son `and`, ` or` y `not`.\n", + "El significado de estos operadores es parecido a su significado en inglés.\n", + "Por ejemplo, el valor de la siguiente expresión es `True` solo si `x` es mayor que `0` *y* menor que `10`." ] }, { @@ -374,7 +374,7 @@ "id": "e8c14026", "metadata": {}, "source": [ - "The following expression is `True` if *either or both* of the conditions is true, that is, if the number is divisible by 2 *or* 3:" + "La siguiente expresión es `True` si *una o ambas* condiciones son verdaderas, es decir, si el número es divisible por 2 *o* por 3:" ] }, { @@ -392,7 +392,7 @@ "id": "3bd0ef52", "metadata": {}, "source": [ - "Finally, the `not` operator negates a boolean expression, so the following expression is `True` if `x > y` is `False`." + "Por último, el operador `not` niega una expresión booleana, de modo que la siguiente expresión es `True` si `x > y` es `False`." ] }, { @@ -410,8 +410,8 @@ "id": "fc6098c2", "metadata": {}, "source": [ - "Strictly speaking, the operands of a logical operator should be boolean expressions, but Python is not very strict.\n", - "Any nonzero number is interpreted as `True`:" + "En sentido estricto, los operandos de un operador lógico deberían ser expresiones booleanas, pero Python no es muy estricto.\n", + "Cualquier número distinto de cero se interpreta como `True`:" ] }, { @@ -429,8 +429,8 @@ "id": "102ceab9", "metadata": {}, "source": [ - "This flexibility can be useful, but there are some subtleties to it that can be confusing.\n", - "You might want to avoid it." + "Esta flexibilidad puede ser útil, pero tiene algunas sutilezas que pueden resultar confusas.\n", + "Quizá prefieras evitarla." ] }, { @@ -438,12 +438,12 @@ "id": "6b0f2dc1", "metadata": {}, "source": [ - "## if statements\n", + "## Sentencias `if`\n", "\n", - "In order to write useful programs, we almost always need the ability to\n", - "check conditions and change the behavior of the program accordingly.\n", - "**Conditional statements** give us this ability. The simplest form is\n", - "the `if` statement:" + "Para escribir programas útiles, casi siempre necesitamos la capacidad de\n", + "comprobar condiciones y cambiar el comportamiento del programa en consecuencia.\n", + "Las **sentencias condicionales** nos dan esta capacidad. La forma más sencilla es\n", + "la sentencia `if`:" ] }, { @@ -462,16 +462,16 @@ "id": "973f705e", "metadata": {}, "source": [ - "`if` is a Python keyword.\n", - "`if` statements have the same structure as function definitions: a\n", - "header followed by an indented statement or sequence of statements called a **block**.\n", + "`if` es una palabra clave de Python.\n", + "Las sentencias `if` tienen la misma estructura que las definiciones de función: una\n", + "cabecera seguida de una sentencia indentada o de una secuencia de sentencias llamada **bloque**.\n", "\n", - "The boolean expression after `if` is called the **condition**.\n", - "If it is true, the statements in the indented block run. If not, they don't.\n", + "La expresión booleana que va después de `if` se llama **condición**.\n", + "Si es verdadera, se ejecutan las sentencias del bloque indentado. Si no, no se ejecutan.\n", "\n", - "There is no limit to the number of statements that can appear in the block, but there has to be at least one.\n", - "Occasionally, it is useful to have a block that does nothing -- usually as a place keeper for code you haven't written yet.\n", - "In that case, you can use the `pass` statement, which does nothing." + "No hay límite para el número de sentencias que pueden aparecer en el bloque, pero tiene que haber al menos una.\n", + "A veces resulta útil tener un bloque que no hace nada, normalmente como marcador de posición para código que todavía no has escrito.\n", + "En ese caso, puedes usar la sentencia `pass`, que no hace nada." ] }, { @@ -490,7 +490,7 @@ "id": "adf3f6c5", "metadata": {}, "source": [ - "The word `TODO` in a comment is a conventional reminder that there's something you need to do later." + "La palabra `TODO` en un comentario es un recordatorio convencional de que hay algo que tienes que hacer más adelante." ] }, { @@ -498,10 +498,10 @@ "id": "eb39bcd9", "metadata": {}, "source": [ - "## The `else` clause\n", + "## La cláusula `else`\n", "\n", - "An `if` statement can have a second part, called an `else` clause.\n", - "The syntax looks like this:" + "Una sentencia `if` puede tener una segunda parte, llamada cláusula `else`.\n", + "La sintaxis tiene este aspecto:" ] }, { @@ -522,14 +522,14 @@ "id": "e7dc8943", "metadata": {}, "source": [ - "If the condition is true, the first indented statement runs; otherwise, the second indented statement runs.\n", + "Si la condición es verdadera, se ejecuta la primera sentencia indentada; si no, se ejecuta la segunda sentencia indentada.\n", "\n", - "In this example, if `x` is even, the remainder when `x` is divided by `2` is `0`, so the condition is true and the program displays `x is even`.\n", - "If `x` is odd, the remainder is `1`, so the condition\n", - "is false, and the program displays `x is odd`.\n", + "En este ejemplo, si `x` es par, el resto al dividir `x` entre `2` es `0`, así que la condición es verdadera y el programa muestra `x is even`.\n", + "Si `x` es impar, el resto es `1`, así que la condición\n", + "es falsa, y el programa muestra `x is odd`.\n", "\n", - "Since the condition must be true or false, exactly one of the alternatives will run. \n", - "The alternatives are called **branches**." + "Como la condición debe ser verdadera o falsa, se ejecutará exactamente una de las alternativas. \n", + "Las alternativas se llaman **ramas**." ] }, { @@ -537,10 +537,10 @@ "id": "20c8adb6", "metadata": {}, "source": [ - "## Chained conditionals\n", + "## Condicionales encadenados\n", "\n", - "Sometimes there are more than two possibilities and we need more than two branches.\n", - "One way to express a computation like that is a **chained conditional**, which includes an `elif` clause." + "A veces hay más de dos posibilidades y necesitamos más de dos ramas.\n", + "Una forma de expresar un cálculo así es un **condicional encadenado**, que incluye una cláusula `elif`." ] }, { @@ -563,15 +563,15 @@ "id": "46916379", "metadata": {}, "source": [ - "`elif` is an abbreviation of \"else if\".\n", - "There is no limit on the number of `elif` clauses.\n", - "If there is an `else` clause, it has to be at the end, but there doesn't have to be\n", - "one.\n", + "`elif` es una abreviatura de «else if».\n", + "No hay límite en el número de cláusulas `elif`.\n", + "Si hay una cláusula `else`, tiene que ir al final, pero no tiene por qué haber\n", + "una.\n", "\n", - "Each condition is checked in order.\n", - "If the first is false, the next is checked, and so on.\n", - "If one of them is true, the corresponding branch runs and the `if` statement ends.\n", - "Even if more than one condition is true, only the first true branch runs." + "Cada condición se comprueba en orden.\n", + "Si la primera es falsa, se comprueba la siguiente, y así sucesivamente.\n", + "Si una de ellas es verdadera, se ejecuta la rama correspondiente y termina la sentencia `if`.\n", + "Aunque más de una condición sea verdadera, solo se ejecuta la primera rama verdadera." ] }, { @@ -579,10 +579,10 @@ "id": "e0c0b9dd", "metadata": {}, "source": [ - "## Nested Conditionals\n", + "## Condicionales anidados\n", "\n", - "One conditional can also be nested within another.\n", - "We could have written the example in the previous section like this:" + "Un condicional también puede estar anidado dentro de otro.\n", + "Podríamos haber escrito el ejemplo de la sección anterior así:" ] }, { @@ -606,15 +606,15 @@ "id": "29f67a0a", "metadata": {}, "source": [ - "The outer `if` statement contains two branches. \n", - "The first branch contains a simple statement. The second branch contains another `if` statement, which has two branches of its own.\n", - "Those two branches are both simple statements, although they could have been conditional statements as well.\n", + "La sentencia `if` exterior contiene dos ramas. \n", + "La primera rama contiene una sentencia sencilla. La segunda rama contiene otra sentencia `if`, que tiene dos ramas propias.\n", + "Esas dos ramas son ambas sentencias sencillas, aunque también podrían haber sido sentencias condicionales.\n", "\n", - "Although the indentation of the statements makes the structure apparent, **nested conditionals** can be difficult to read.\n", - "I suggest you avoid them when you can.\n", + "Aunque la indentación de las sentencias hace visible la estructura, los **condicionales anidados** pueden ser difíciles de leer.\n", + "Te sugiero que los evites cuando puedas.\n", "\n", - "Logical operators often provide a way to simplify nested conditional statements.\n", - "Here's an example with a nested conditional." + "Los operadores lógicos suelen proporcionar una forma de simplificar sentencias condicionales anidadas.\n", + "Aquí tienes un ejemplo con un condicional anidado." ] }, { @@ -634,7 +634,7 @@ "id": "5292eb11", "metadata": {}, "source": [ - "The `print` statement runs only if we make it past both conditionals, so we get the same effect with the `and` operator." + "La sentencia `print` se ejecuta solo si superamos ambos condicionales, así que conseguimos el mismo efecto con el operador `and`." ] }, { @@ -653,7 +653,7 @@ "id": "dd8e808a", "metadata": {}, "source": [ - "For this kind of condition, Python provides a more concise option:" + "Para este tipo de condición, Python ofrece una opción más concisa:" ] }, { @@ -672,11 +672,11 @@ "id": "db583cd9", "metadata": {}, "source": [ - "## Recursion\n", + "## Recursión\n", "\n", - "It is legal for a function to call itself.\n", - "It may not be obvious why that is a good thing, but it turns out to be one of the most magical things a program can do.\n", - "Here's an example." + "Es legal que una función se llame a sí misma.\n", + "Puede que no sea obvio por qué eso es algo bueno, pero resulta ser una de las cosas más mágicas que puede hacer un programa.\n", + "Aquí tienes un ejemplo." ] }, { @@ -699,10 +699,10 @@ "id": "c88e0dc7", "metadata": {}, "source": [ - "If `n` is 0 or negative, `countdown` outputs the word, \"Blastoff!\" Otherwise, it\n", - "outputs `n` and then calls itself, passing `n-1` as an argument.\n", + "Si `n` es 0 o negativo, `countdown` muestra la palabra «Blastoff!». En caso contrario,\n", + "muestra `n` y luego se llama a sí misma, pasando `n-1` como argumento.\n", "\n", - "Here's what happens when we call this function with the argument `3`." + "Esto es lo que ocurre cuando llamamos a esta función con el argumento `3`." ] }, { @@ -720,23 +720,23 @@ "id": "3f3c87ec", "metadata": {}, "source": [ - "The execution of `countdown` begins with `n=3`, and since `n` is greater\n", - "than `0`, it displays `3`, and then calls itself\\...\n", + "La ejecución de `countdown` empieza con `n=3`, y como `n` es mayor\n", + "que `0`, muestra `3` y luego se llama a sí misma\\...\n", "\n", - "> The execution of `countdown` begins with `n=2`, and since `n` is\n", - "> greater than `0`, it displays `2`, and then calls itself\\...\n", + "> La ejecución de `countdown` empieza con `n=2`, y como `n` es\n", + "> mayor que `0`, muestra `2` y luego se llama a sí misma\\...\n", ">\n", - "> > The execution of `countdown` begins with `n=1`, and since `n` is\n", - "> > greater than `0`, it displays `1`, and then calls itself\\...\n", + "> > La ejecución de `countdown` empieza con `n=1`, y como `n` es\n", + "> > mayor que `0`, muestra `1` y luego se llama a sí misma\\...\n", "> >\n", - "> > > The execution of `countdown` begins with `n=0`, and since `n` is\n", - "> > > not greater than `0`, it displays \"Blastoff!\" and returns.\n", + "> > > La ejecución de `countdown` empieza con `n=0`, y como `n` no es\n", + "> > > mayor que `0`, muestra «Blastoff!» y retorna.\n", "> >\n", - "> > The `countdown` that got `n=1` returns.\n", + "> > La `countdown` que recibió `n=1` retorna.\n", ">\n", - "> The `countdown` that got `n=2` returns.\n", + "> La `countdown` que recibió `n=2` retorna.\n", "\n", - "The `countdown` that got `n=3` returns." + "La `countdown` que recibió `n=3` retorna." ] }, { @@ -744,8 +744,8 @@ "id": "782e95bb", "metadata": {}, "source": [ - "A function that calls itself is **recursive**.\n", - "As another example, we can write a function that prints a string `n` times." + "Una función que se llama a sí misma es **recursiva**.\n", + "Como otro ejemplo, podemos escribir una función que imprime una cadena `n` veces." ] }, { @@ -766,11 +766,11 @@ "id": "73d07c17", "metadata": {}, "source": [ - "If `n` is positive, `print_n_times` displays the value of `string` and then calls itself, passing along `string` and `n-1` as arguments.\n", + "Si `n` es positivo, `print_n_times` muestra el valor de `string` y luego se llama a sí misma, pasando `string` y `n-1` como argumentos.\n", "\n", - "If `n` is `0` or negative, the condition is false and `print_n_times` does nothing.\n", + "Si `n` es `0` o negativo, la condición es falsa y `print_n_times` no hace nada.\n", "\n", - "Here's how it works." + "Así es como funciona." ] }, { @@ -788,9 +788,9 @@ "id": "1fb55a78", "metadata": {}, "source": [ - "For simple examples like this, it is probably easier to use a `for`\n", - "loop. But we will see examples later that are hard to write with a `for`\n", - "loop and easy to write with recursion, so it is good to start early." + "Para ejemplos sencillos como este, probablemente sea más fácil usar un bucle `for`.\n", + "Pero más adelante veremos ejemplos que son difíciles de escribir con un bucle `for`\n", + "y fáciles de escribir con recursión, así que conviene empezar pronto." ] }, { @@ -798,9 +798,9 @@ "id": "c652c739", "metadata": {}, "source": [ - "## Stack diagrams for recursive functions\n", + "## Diagramas de stack para funciones recursivas\n", "\n", - "Here's a stack diagram that shows the frames created when we called `countdown` with `n = 3`." + "Aquí tienes un diagrama de stack que muestra los marcos creados cuando llamamos a `countdown` con `n = 3`." ] }, { @@ -846,9 +846,9 @@ "id": "9282331b", "metadata": {}, "source": [ - "The four `countdown` frames have different values for the parameter `n`.\n", - "The bottom of the stack, where `n=0`, is called the **base case**.\n", - "It does not make a recursive call, so there are no more frames." + "Los cuatro marcos de `countdown` tienen valores distintos para el parámetro `n`.\n", + "La parte inferior del stack, donde `n=0`, se llama **caso base**.\n", + "No hace una llamada recursiva, así que no hay más marcos." ] }, { @@ -882,12 +882,12 @@ "id": "37bbc2b8", "metadata": {}, "source": [ - "## Infinite recursion\n", + "## Recursión infinita\n", "\n", - "If a recursion never reaches a base case, it goes on making recursive\n", - "calls forever, and the program never terminates. This is known as\n", - "**infinite recursion**, and it is generally not a good idea.\n", - "Here's a minimal function with an infinite recursion." + "Si una recursión nunca alcanza un caso base, sigue haciendo llamadas\n", + "recursivas para siempre, y el programa nunca termina. Esto se conoce como\n", + "**recursión infinita**, y por lo general no es una buena idea.\n", + "Aquí tienes una función mínima con una recursión infinita." ] }, { @@ -906,9 +906,9 @@ "id": "450a20ac", "metadata": {}, "source": [ - "Every time `recurse` is called, it calls itself, which creates another frame.\n", - "In Python, there is a limit to the number of frames that can be on the stack at the same time.\n", - "If a program exceeds the limit, it causes a runtime error." + "Cada vez que se llama a `recurse`, se llama a sí misma, lo que crea otro marco.\n", + "En Python, hay un límite para el número de marcos que pueden estar en el stack al mismo tiempo.\n", + "Si un programa supera el límite, provoca un error en tiempo de ejecución." ] }, { @@ -942,9 +942,9 @@ "id": "39fc5c31", "metadata": {}, "source": [ - "The traceback indicates that there were almost 3000 frames on the stack when the error occurred.\n", + "El traceback indica que había casi 3000 marcos en el stack cuando ocurrió el error.\n", "\n", - "If you encounter an infinite recursion by accident, review your function to confirm that there is a base case that does not make a recursive call. And if there is a base case, check whether you are guaranteed to reach it." + "Si te encuentras por accidente con una recursión infinita, revisa tu función para confirmar que hay un caso base que no hace una llamada recursiva. Y si hay un caso base, comprueba si tienes garantizado llegar a él." ] }, { @@ -952,15 +952,15 @@ "id": "45299414", "metadata": {}, "source": [ - "## Keyboard input\n", + "## Entrada por teclado\n", "\n", - "The programs we have written so far accept no input from the user. They\n", - "just do the same thing every time.\n", + "Los programas que hemos escrito hasta ahora no aceptan entrada del usuario. Simplemente\n", + "hacen lo mismo cada vez.\n", "\n", - "Python provides a built-in function called `input` that stops the\n", - "program and waits for the user to type something. When the user presses\n", - "*Return* or *Enter*, the program resumes and `input` returns what the user\n", - "typed as a string." + "Python proporciona una función integrada llamada `input` que detiene el\n", + "programa y espera a que el usuario escriba algo. Cuando el usuario pulsa\n", + "*Return* o *Enter*, el programa continúa y `input` devuelve lo que el usuario\n", + "ha escrito como una cadena." ] }, { @@ -990,8 +990,8 @@ "id": "acf9ec53", "metadata": {}, "source": [ - "Before getting input from the user, you might want to display a prompt\n", - "telling the user what to type. `input` can take a prompt as an argument:" + "Antes de obtener entrada del usuario, puede que quieras mostrar un prompt\n", + "que le indique qué debe escribir. `input` puede recibir un prompt como argumento:" ] }, { @@ -1022,9 +1022,10 @@ "id": "1b754b39", "metadata": {}, "source": [ - "The sequence `\\n` at the end of the prompt represents a **newline**, which is a special character that causes a line break -- that way the user's input appears below the prompt.\n", + "La secuencia `\n", + "` al final del prompt representa una **nueva línea**, que es un carácter especial que provoca un salto de línea; así, la entrada del usuario aparece debajo del prompt.\n", "\n", - "If you expect the user to type an integer, you can use the `int` function to convert the return value to `int`." + "Si esperas que el usuario escriba un entero, puedes usar la función `int` para convertir el valor de retorno a `int`." ] }, { @@ -1056,7 +1057,7 @@ "id": "0a65f2af", "metadata": {}, "source": [ - "But if they type something that's not an integer, you'll get a runtime error." + "Pero si escribe algo que no es un entero, obtendrás un error en tiempo de ejecución." ] }, { @@ -1090,7 +1091,7 @@ "id": "a4ce3ed5", "metadata": {}, "source": [ - "We will see how to handle this kind of error later." + "Más adelante veremos cómo manejar este tipo de error." ] }, { @@ -1100,17 +1101,16 @@ "source": [ "## Debugging\n", "\n", - "When a syntax or runtime error occurs, the error message contains a lot\n", - "of information, but it can be overwhelming. The most useful parts are\n", - "usually:\n", + "Cuando ocurre un error de sintaxis o en tiempo de ejecución, el mensaje de error contiene mucha\n", + "información, pero puede resultar abrumador. Las partes más útiles suelen ser:\n", "\n", - "- What kind of error it was, and\n", + "- Qué tipo de error fue, y\n", "\n", - "- Where it occurred.\n", + "- Dónde ocurrió.\n", "\n", - "Syntax errors are usually easy to find, but there are a few gotchas.\n", - "Errors related to spaces and tabs can be tricky because they are invisible\n", - "and we are used to ignoring them." + "Los errores de sintaxis suelen ser fáciles de encontrar, pero hay algunas trampas.\n", + "Los errores relacionados con espacios y tabulaciones pueden ser complicados porque son invisibles\n", + "y estamos acostumbrados a ignorarlos." ] }, { @@ -1132,12 +1132,12 @@ "id": "d1d06263", "metadata": {}, "source": [ - "In this example, the problem is that the second line is indented by one space.\n", - "But the error message points to `y`, which is misleading.\n", - "Error messages indicate where the problem was discovered, but the actual error might be earlier in the code.\n", + "En este ejemplo, el problema es que la segunda línea está indentada con un espacio.\n", + "Pero el mensaje de error señala a `y`, lo que resulta engañoso.\n", + "Los mensajes de error indican dónde se descubrió el problema, pero el error real podría estar antes en el código.\n", "\n", - "The same is true of runtime errors. \n", - "For example, suppose you are trying to convert a ratio to decibels, like this:" + "Lo mismo ocurre con los errores en tiempo de ejecución. \n", + "Por ejemplo, supón que intentas convertir una razón a decibelios, así:" ] }, { @@ -1174,11 +1174,11 @@ "id": "55914374", "metadata": {}, "source": [ - "The error message indicates line 5, but there is nothing wrong with that line.\n", - "The problem is in line 4, which uses integer division instead of floating-point division -- as a result, the value of `ratio` is `0`.\n", - "When we call `math.log10`, we get a `ValueError` with the message `math domain error`, because `0` is not in the \"domain\" of valid arguments for `math.log10`, because the logarithm of `0` is undefined.\n", + "El mensaje de error indica la línea 5, pero no hay nada malo en esa línea.\n", + "El problema está en la línea 4, que usa división entera en lugar de división de punto flotante; como resultado, el valor de `ratio` es `0`.\n", + "Cuando llamamos a `math.log10`, obtenemos un `ValueError` con el mensaje `math domain error`, porque `0` no está en el «dominio» de argumentos válidos para `math.log10`, ya que el logaritmo de `0` no está definido.\n", "\n", - "In general, you should take the time to read error messages carefully, but don't assume that everything they say is correct." + "En general, deberías tomarte el tiempo de leer cuidadosamente los mensajes de error, pero no asumas que todo lo que dicen es correcto." ] }, { @@ -1186,53 +1186,53 @@ "id": "8ffe690e", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**recursion:**\n", - "The process of calling the function that is currently executing.\n", + "**recursión:**\n", + "El proceso de llamar a la función que se está ejecutando en ese momento.\n", "\n", - "**modulus operator:**\n", - "An operator, `%`, that works on integers and returns the remainder when one number is divided by another.\n", + "**operador módulo:**\n", + "Un operador, `%`, que funciona con enteros y devuelve el resto cuando un número se divide entre otro.\n", "\n", - "**boolean expression:**\n", - "An expression whose value is either `True` or `False`.\n", + "**expresión booleana:**\n", + "Una expresión cuyo valor es `True` o `False`.\n", "\n", - "**relational operator:**\n", - "One of the operators that compares its operands: `==`, `!=`, `>`, `<`, `>=`, and `<=`.\n", + "**operador relacional:**\n", + "Uno de los operadores que compara sus operandos: `==`, `!=`, `>`, `<`, `>=` y `<=`.\n", "\n", - "**logical operator:**\n", - "One of the operators that combines boolean expressions, including `and`, `or`, and `not`.\n", + "**operador lógico:**\n", + "Uno de los operadores que combina expresiones booleanas, incluidos `and`, `or` y `not`.\n", "\n", - "**conditional statement:**\n", - "A statement that controls the flow of execution depending on some condition.\n", + "**sentencia condicional:**\n", + "Una sentencia que controla el flujo de ejecución dependiendo de alguna condición.\n", "\n", - "**condition:**\n", - "The boolean expression in a conditional statement that determines which branch runs.\n", + "**condición:**\n", + "La expresión booleana en una sentencia condicional que determina qué rama se ejecuta.\n", "\n", - "**block:**\n", - "One or more statements indented to indicate they are part of another statement.\n", + "**bloque:**\n", + "Una o más sentencias indentadas para indicar que forman parte de otra sentencia.\n", "\n", - "**branch:**\n", - "One of the alternative sequences of statements in a conditional statement.\n", + "**rama:**\n", + "Una de las secuencias alternativas de sentencias en una sentencia condicional.\n", "\n", - "**chained conditional:**\n", - "A conditional statement with a series of alternative branches.\n", + "**condicional encadenado:**\n", + "Una sentencia condicional con una serie de ramas alternativas.\n", "\n", - "**nested conditional:**\n", - "A conditional statement that appears in one of the branches of another conditional statement.\n", + "**condicional anidado:**\n", + "Una sentencia condicional que aparece en una de las ramas de otra sentencia condicional.\n", "\n", - "**recursive:**\n", - "A function that calls itself is recursive.\n", + "**recursiva:**\n", + "Una función que se llama a sí misma es recursiva.\n", "\n", - "**base case:**\n", - "A conditional branch in a recursive function that does not make a recursive call.\n", + "**caso base:**\n", + "Una rama condicional en una función recursiva que no hace una llamada recursiva.\n", "\n", - "**infinite recursion:**\n", - "A recursion that doesn't have a base case, or never reaches it.\n", - "Eventually, an infinite recursion causes a runtime error.\n", + "**recursión infinita:**\n", + "Una recursión que no tiene caso base o que nunca lo alcanza.\n", + "Con el tiempo, una recursión infinita provoca un error en tiempo de ejecución.\n", "\n", - "**newline:**\n", - "A character that creates a line break between two parts of a string." + "**nueva línea:**\n", + "Un carácter que crea un salto de línea entre dos partes de una cadena." ] }, { @@ -1240,7 +1240,7 @@ "id": "8d783953", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1263,15 +1263,15 @@ "id": "02f9f1d7", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "* Ask a virtual assistant, \"What are some uses of the modulus operator?\"\n", + "* Pregunta a un asistente virtual: «¿Cuáles son algunos usos del operador módulo?»\n", "\n", - "* Python provides operators to compute the logical operations `and`, `or`, and `not`, but it doesn't have an operator that computes the exclusive `or` operation, usually written `xor`. Ask an assistant \"What is the logical xor operation and how do I compute it in Python?\"\n", + "* Python proporciona operadores para calcular las operaciones lógicas `and`, `or` y `not`, pero no tiene un operador que calcule la operación `or` exclusiva, que normalmente se escribe `xor`. Pregunta a un asistente: «¿Qué es la operación lógica xor y cómo la calculo en Python?»\n", "\n", - "In this chapter, we saw two ways to write an `if` statement with three branches, using a chained conditional or a nested conditional.\n", - "You can use a virtual assistant to convert from one to the other.\n", - "For example, ask a VA, \"Convert this statement to a chained conditional.\"" + "En este capítulo, vimos dos formas de escribir una sentencia `if` con tres ramas: usando un condicional encadenado o un condicional anidado.\n", + "Puedes usar un asistente virtual para convertir de una forma a la otra.\n", + "Por ejemplo, pregunta a un asistente virtual: «Convierte esta sentencia en un condicional encadenado»." ] }, { @@ -1308,7 +1308,7 @@ "id": "9c2a8466", "metadata": {}, "source": [ - "Ask a VA, \"Rewrite this statement with a single conditional.\"" + "Pregunta a un asistente virtual: «Reescribe esta sentencia con un único condicional»." ] }, { @@ -1328,7 +1328,7 @@ "id": "e0fbed08", "metadata": {}, "source": [ - "See if a VA can simplify this unnecessary complexity." + "Comprueba si un asistente virtual puede simplificar esta complejidad innecesaria." ] }, { @@ -1347,7 +1347,7 @@ "id": "74ef776d", "metadata": {}, "source": [ - "Here's an attempt at a recursive function that counts down by two." + "Aquí tienes un intento de función recursiva que cuenta hacia atrás de dos en dos." ] }, { @@ -1370,7 +1370,7 @@ "id": "77178e79", "metadata": {}, "source": [ - "It seems to work." + "Parece funcionar." ] }, { @@ -1388,8 +1388,8 @@ "id": "c9d3a8dc", "metadata": {}, "source": [ - "But it has an error. Ask a virtual assistant what's wrong and how to fix it.\n", - "Paste the solution it provides back here and test it." + "Pero tiene un error. Pregunta a un asistente virtual qué está mal y cómo arreglarlo.\n", + "Pega aquí la solución que te proporcione y pruébala." ] }, { @@ -1397,10 +1397,10 @@ "id": "240a3888", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The `time` module provides a function, also called `time`, that returns\n", - "returns the number of seconds since the \"Unix epoch\", which is January 1, 1970, 00:00:00 UTC (Coordinated Universal Time)." + "El módulo `time` proporciona una función, también llamada `time`, que devuelve\n", + "el número de segundos transcurridos desde la «época Unix», que es el 1 de enero de 1970, 00:00:00 UTC (tiempo universal coordinado)." ] }, { @@ -1421,7 +1421,7 @@ "id": "054c3197", "metadata": {}, "source": [ - "Use integer division and the modulus operator to compute the number of days since January 1, 1970 and the current time of day in hours, minutes, and seconds." + "Usa la división entera y el operador módulo para calcular el número de días transcurridos desde el 1 de enero de 1970 y la hora actual del día en horas, minutos y segundos." ] }, { @@ -1431,7 +1431,7 @@ "tags": [] }, "source": [ - "You can read more about the `time` module at ." + "Puedes leer más sobre el módulo `time` en ." ] }, { @@ -1479,23 +1479,22 @@ "id": "6b1fd514", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "If you are given three sticks, you may or may not be able to arrange\n", - "them in a triangle. For example, if one of the sticks is 12 inches long\n", - "and the other two are one inch long, you will not be able to get the\n", - "short sticks to meet in the middle. For any three lengths, there is a\n", - "test to see if it is possible to form a triangle:\n", + "Si te dan tres palos, puede que puedas colocarlos formando un triángulo, o puede que no. Por ejemplo, si uno de los palos mide 12 pulgadas\n", + "y los otros dos miden una pulgada, no podrás hacer que los\n", + "palos cortos se encuentren en el centro. Para tres longitudes cualesquiera, hay una\n", + "prueba para ver si es posible formar un triángulo:\n", "\n", - "> If any of the three lengths is greater than the sum of the other two,\n", - "> then you cannot form a triangle. Otherwise, you can. (If the sum of\n", - "> two lengths equals the third, they form what is called a \"degenerate\"\n", - "> triangle.)\n", + "> Si cualquiera de las tres longitudes es mayor que la suma de las otras dos,\n", + "> entonces no puedes formar un triángulo. En caso contrario, sí puedes. (Si la suma de\n", + "> dos longitudes es igual a la tercera, forman lo que se llama un triángulo\n", + "> «degenerado».)\n", "\n", - "Write a function named `is_triangle` that takes three integers as\n", - "arguments, and that prints either \"Yes\" or \"No\", depending on\n", - "whether you can or cannot form a triangle from sticks with the given\n", - "lengths. Hint: Use a chained conditional.\n", + "Escribe una función llamada `is_triangle` que reciba tres enteros como\n", + "argumentos, y que imprima «Yes» o «No», dependiendo de\n", + "si se puede o no formar un triángulo con palos de las longitudes dadas.\n", + "Pista: usa un condicional encadenado.\n", "\n" ] }, @@ -1518,7 +1517,7 @@ "tags": [] }, "source": [ - "Test your function with the following cases." + "Prueba tu función con los siguientes casos." ] }, { @@ -1574,10 +1573,10 @@ "id": "2ba42106", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "What is the output of the following program? Draw a stack diagram that\n", - "shows the state of the program when it prints the result." + "¿Cuál es la salida del siguiente programa? Dibuja un diagrama de stack que\n", + "muestre el estado del programa cuando imprime el resultado." ] }, { @@ -1623,14 +1622,14 @@ "id": "bca9517d", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The following exercises use the `jupyturtle` module, described in Chapter 4.\n", + "Los siguientes ejercicios usan el módulo `jupyturtle`, descrito en el Capítulo 4.\n", "\n", - "Read the following function and see if you can figure out what it does.\n", - "Then run it and see if you got it right.\n", - "Adjust the values of `length`, `angle` and `factor` and see what effect they have on the result.\n", - "If you are not sure you understand how it works, try asking a virtual assistant." + "Lee la siguiente función y mira si puedes averiguar qué hace.\n", + "Luego ejecútala y comprueba si acertaste.\n", + "Ajusta los valores de `length`, `angle` y `factor`, y observa qué efecto tienen en el resultado.\n", + "Si no tienes claro cómo funciona, prueba a preguntar a un asistente virtual." ] }, { @@ -1671,30 +1670,30 @@ "id": "e525ba59", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Ask a virtual assistant \"What is the Koch curve?\"\n", + "Pregunta a un asistente virtual: «¿Qué es la curva de Koch?»\n", "\n", - "To draw a Koch curve with length `x`, all you\n", - "have to do is\n", + "Para dibujar una curva de Koch con longitud `x`, todo lo que\n", + "tienes que hacer es\n", "\n", - "1. Draw a Koch curve with length `x/3`.\n", + "1. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "2. Turn left 60 degrees.\n", + "2. Girar a la izquierda 60 grados.\n", "\n", - "3. Draw a Koch curve with length `x/3`.\n", + "3. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "4. Turn right 120 degrees.\n", + "4. Girar a la derecha 120 grados.\n", "\n", - "5. Draw a Koch curve with length `x/3`.\n", + "5. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "6. Turn left 60 degrees.\n", + "6. Girar a la izquierda 60 grados.\n", "\n", - "7. Draw a Koch curve with length `x/3`.\n", + "7. Dibujar una curva de Koch con longitud `x/3`.\n", "\n", - "The exception is if `x` is less than `5` -- in that case, you can just draw a straight line with length `x`.\n", + "La excepción es si `x` es menor que `5`; en ese caso, puedes dibujar simplemente una línea recta con longitud `x`.\n", "\n", - "Write a function called `koch` that takes `x` as an argument and draws a Koch curve with the given length.\n" + "Escribe una función llamada `koch` que reciba `x` como argumento y dibuje una curva de Koch con la longitud dada.\n" ] }, { @@ -1712,7 +1711,7 @@ "id": "2991143a", "metadata": {}, "source": [ - "The result should look like this:" + "El resultado debería verse así:" ] }, { @@ -1733,7 +1732,7 @@ "tags": [] }, "source": [ - "Once you have koch working, you can use this loop to draw three Koch curves in the shape of a snowflake." + "Cuando tengas `koch` funcionando, puedes usar este bucle para dibujar tres curvas de Koch con forma de copo de nieve." ] }, { @@ -1756,17 +1755,17 @@ "id": "4c964239", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Virtual assistants know about the functions in the `jupyturtle` module, but there are many versions of these functions, with different names, so a VA might not know which one you are talking about.\n", + "Los asistentes virtuales conocen las funciones del módulo `jupyturtle`, pero hay muchas versiones de estas funciones, con nombres distintos, así que un asistente virtual podría no saber de cuál estás hablando.\n", "\n", - "To solve this problem, you can provide additional information before you ask a question.\n", - "For example, you could start a prompt with \"Here's a program that uses the `jupyturtle` module,\" and then paste in one of the examples from this chapter.\n", - "After that, the VA should be able to generate code that uses this module.\n", + "Para resolver este problema, puedes proporcionar información adicional antes de hacer una pregunta.\n", + "Por ejemplo, podrías empezar un prompt con «Aquí tienes un programa que usa el módulo `jupyturtle`», y luego pegar uno de los ejemplos de este capítulo.\n", + "Después de eso, el asistente virtual debería poder generar código que use este módulo.\n", "\n", - "As an example, ask a VA for a program that draws a Sierpiński triangle.\n", - "The code you get should be a good starting place, but you might have to do some debugging.\n", - "If the first attempt doesn't work, you can tell the VA what happened and ask for help -- or you can debug it yourself." + "Como ejemplo, pide a un asistente virtual un programa que dibuje un triángulo de Sierpiński.\n", + "El código que obtengas debería ser un buen punto de partida, pero quizá tengas que hacer algo de debugging.\n", + "Si el primer intento no funciona, puedes contarle al asistente virtual qué ocurrió y pedir ayuda, o puedes depurarlo por tu cuenta." ] }, { @@ -1784,7 +1783,7 @@ "id": "6a95097a", "metadata": {}, "source": [ - "Here's what the result might look like, although the version you get might be different." + "Este es un posible aspecto del resultado, aunque la versión que obtengas podría ser diferente." ] }, { @@ -1818,9 +1817,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap06.ipynb b/chapters/chap06.ipynb index a8d03c3..943d61c 100644 --- a/chapters/chap06.ipynb +++ b/chapters/chap06.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,16 +41,16 @@ "id": "88ecc443", "metadata": {}, "source": [ - "# Return Values\n", + "# Valores de retorno\n", "\n", - "In previous chapters, we've used built-in functions -- like `abs` and `round` -- and functions in the math module -- like `sqrt` and `pow`.\n", - "When you call one of these functions, it returns a value you can assign to a variable or use as part of an expression.\n", + "En capítulos anteriores, hemos usado funciones integradas -- como `abs` y `round` -- y funciones del módulo math -- como `sqrt` y `pow`.\n", + "Cuando llamas a una de estas funciones, devuelve un valor que puedes asignar a una variable o usar como parte de una expresión.\n", "\n", - "The functions we have written so far are different.\n", - "Some use the `print` function to display values, and some use turtle functions to draw figures.\n", - "But they don't return values we assign to variables or use in expressions.\n", + "Las funciones que hemos escrito hasta ahora son diferentes.\n", + "Algunas usan la función `print` para mostrar valores, y otras usan funciones de turtle para dibujar figuras.\n", + "Pero no devuelven valores que asignemos a variables o usemos en expresiones.\n", "\n", - "In this chapter, we'll see how to write functions that return values." + "En este capítulo veremos cómo escribir funciones que devuelven valores." ] }, { @@ -58,10 +58,10 @@ "id": "6cf2cf80", "metadata": {}, "source": [ - "## Some functions have return values\n", + "## Algunas funciones tienen valores de retorno\n", "\n", - "When you call a function like `math.sqrt`, the result is called a **return value**.\n", - "If the function call appears at the end of a cell, Jupyter displays the return value immediately." + "Cuando llamas a una función como `math.sqrt`, el resultado se llama **valor de retorno**.\n", + "Si la llamada a la función aparece al final de una celda, Jupyter muestra inmediatamente el valor de retorno." ] }, { @@ -81,7 +81,7 @@ "id": "4b4885c2", "metadata": {}, "source": [ - "If you assign the return value to a variable, it doesn't get displayed." + "Si asignas el valor de retorno a una variable, no se muestra." ] }, { @@ -99,7 +99,7 @@ "id": "196c692b", "metadata": {}, "source": [ - "But you can display it later." + "Pero puedes mostrarlo más tarde." ] }, { @@ -117,7 +117,7 @@ "id": "257b28d5", "metadata": {}, "source": [ - "Or you can use the return value as part of an expression." + "O puedes usar el valor de retorno como parte de una expresión." ] }, { @@ -135,7 +135,7 @@ "id": "23ed47ab", "metadata": {}, "source": [ - "Here's an example of a function that returns a value." + "Aquí tienes un ejemplo de una función que devuelve un valor." ] }, { @@ -155,11 +155,12 @@ "id": "273acabc", "metadata": {}, "source": [ - "`circle_area` takes `radius` as a parameter and computes the area of a circle with that radius.\n", + "`circle_area` toma `radius` como parámetro y calcula el área de un círculo con ese radio.\n", "\n", - "The last line is a `return` statement that returns the value of `area`.\n", + "La última línea es una sentencia `return` que devuelve el valor de `area`.\n", "\n", - "If we call the function like this, Jupyter displays the return value.\n" + "Si llamamos a la función así, Jupyter muestra el valor de retorno.\n", + "\n" ] }, { @@ -177,7 +178,7 @@ "id": "4f28bfd6", "metadata": {}, "source": [ - "We can assign the return value to a variable." + "Podemos asignar el valor de retorno a una variable." ] }, { @@ -195,7 +196,7 @@ "id": "3f82fe70", "metadata": {}, "source": [ - "Or use it as part of an expression." + "O usarlo como parte de una expresión." ] }, { @@ -213,7 +214,7 @@ "id": "15122fd2", "metadata": {}, "source": [ - "Later we can display the value of the variable we assigned the result to." + "Más tarde podemos mostrar el valor de la variable a la que asignamos el resultado." ] }, { @@ -231,7 +232,7 @@ "id": "a3f6dcae", "metadata": {}, "source": [ - "But we can't access `area`." + "Pero no podemos acceder a `area`." ] }, { @@ -253,7 +254,7 @@ "id": "f8ace9ce", "metadata": {}, "source": [ - "`area` is a local variable in a function, so we can't access it from outside the function." + "`area` es una variable local dentro de una función, así que no podemos acceder a ella desde fuera de la función." ] }, { @@ -261,10 +262,10 @@ "id": "41a4f03f", "metadata": {}, "source": [ - "## And some have None\n", + "## Y algunas tienen None\n", "\n", - "If a function doesn't have a `return` statement, it returns `None`, which is a special value like `True` and `False`.\n", - "For example, here's the `repeat` function from Chapter 3." + "Si una función no tiene una sentencia `return`, devuelve `None`, que es un valor especial como `True` y `False`.\n", + "Por ejemplo, aquí está la función `repeat` del Capítulo 3." ] }, { @@ -283,7 +284,7 @@ "id": "6ada19cf", "metadata": {}, "source": [ - "If we call it like this, it displays the first line of the Monty Python song \"Finland\"." + "Si la llamamos así, muestra la primera línea de la canción \"Finland\" de Monty Python." ] }, { @@ -301,8 +302,8 @@ "id": "fe49f5e5", "metadata": {}, "source": [ - "This function uses the `print` function to display a string, but it does not use a `return` statement to return a value.\n", - "If we assign the result to a variable, it displays the string anyway. " + "Esta función usa la función `print` para mostrar una cadena, pero no usa una sentencia `return` para devolver un valor.\n", + "Si asignamos el resultado a una variable, muestra la cadena de todos modos. " ] }, { @@ -320,7 +321,7 @@ "id": "4ecabbdb", "metadata": {}, "source": [ - "And if we display the value of the variable, we get nothing." + "Y si mostramos el valor de la variable, no obtenemos nada." ] }, { @@ -338,8 +339,8 @@ "id": "07033959", "metadata": {}, "source": [ - "`result` actually has a value, but Jupyter doesn't show it.\n", - "However, we can display it like this." + "`result` en realidad tiene un valor, pero Jupyter no lo muestra.\n", + "Sin embargo, podemos mostrarlo así." ] }, { @@ -357,9 +358,9 @@ "id": "379b98c5", "metadata": {}, "source": [ - "The return value from `repeat` is `None`.\n", + "El valor de retorno de `repeat` es `None`.\n", "\n", - "Now here's a function similar to `repeat` except that has a return value." + "Ahora aquí tienes una función parecida a `repeat`, excepto que sí tiene un valor de retorno." ] }, { @@ -378,10 +379,10 @@ "id": "db6ad3d4", "metadata": {}, "source": [ - "Notice that we can use an expression in a `return` statement, not just a variable.\n", + "Observa que podemos usar una expresión en una sentencia `return`, no solo una variable.\n", "\n", - "With this version, we can assign the result to a variable.\n", - "When the function runs, it doesn't display anything." + "Con esta versión, podemos asignar el resultado a una variable.\n", + "Cuando la función se ejecuta, no muestra nada." ] }, { @@ -399,7 +400,7 @@ "id": "1232cd8a", "metadata": {}, "source": [ - "But later we can display the value assigned to `line`." + "Pero más tarde podemos mostrar el valor asignado a `line`." ] }, { @@ -417,7 +418,7 @@ "id": "ae02c7d2", "metadata": {}, "source": [ - "A function like this is called a **pure function** because it doesn't display anything or have any other effect -- other than returning a value." + "Una función como esta se llama **función pura** porque no muestra nada ni tiene ningún otro efecto -- aparte de devolver un valor." ] }, { @@ -425,9 +426,9 @@ "id": "567ae734", "metadata": {}, "source": [ - "## Return values and conditionals\n", + "## Valores de retorno y condicionales\n", "\n", - "If Python did not provide `abs`, we could write it like this." + "Si Python no proporcionara `abs`, podríamos escribirla así." ] }, { @@ -449,12 +450,12 @@ "id": "ffd559b8", "metadata": {}, "source": [ - "If `x` is negative, the first `return` statement returns `-x` and the function ends immediately.\n", - "Otherwise, the second `return` statement returns `x` and the function ends.\n", - "So this function is correct.\n", + "Si `x` es negativo, la primera sentencia `return` devuelve `-x` y la función termina inmediatamente.\n", + "En caso contrario, la segunda sentencia `return` devuelve `x` y la función termina.\n", + "Así que esta función es correcta.\n", "\n", - "However, if you put `return` statements in a conditional, you have to make sure that every possible path through the program hits a `return` statement.\n", - "For example, here's an incorrect version of `absolute_value`." + "Sin embargo, si pones sentencias `return` en un condicional, tienes que asegurarte de que todos los caminos posibles del programa lleguen a una sentencia `return`.\n", + "Por ejemplo, aquí tienes una versión incorrecta de `absolute_value`." ] }, { @@ -476,7 +477,7 @@ "id": "da3280ae", "metadata": {}, "source": [ - "Here's what happens if we call this function with `0` as an argument." + "Esto es lo que ocurre si llamamos a esta función con `0` como argumento." ] }, { @@ -494,9 +495,9 @@ "id": "5733f239", "metadata": {}, "source": [ - "We get nothing! Here's the problem: when `x` is `0`, neither condition is true, and the function ends without hitting a `return` statement, which means that the return value is `None`, so Jupyter displays nothing.\n", + "¡No obtenemos nada! Este es el problema: cuando `x` es `0`, ninguna condición es verdadera, y la función termina sin llegar a una sentencia `return`, lo que significa que el valor de retorno es `None`, así que Jupyter no muestra nada.\n", "\n", - "As another example, here's a version of `absolute_value` with an extra `return` statement at the end." + "Como otro ejemplo, aquí tienes una versión de `absolute_value` con una sentencia `return` adicional al final." ] }, { @@ -520,12 +521,12 @@ "id": "cf5486fd", "metadata": {}, "source": [ - "If `x` is negative, the first `return` statement runs and the function ends.\n", - "Otherwise the second `return` statement runs and the function ends.\n", - "Either way, we never get to the third `return` statement -- so it can never run.\n", + "Si `x` es negativo, se ejecuta la primera sentencia `return` y la función termina.\n", + "En caso contrario, se ejecuta la segunda sentencia `return` y la función termina.\n", + "De cualquier manera, nunca llegamos a la tercera sentencia `return` -- así que nunca puede ejecutarse.\n", "\n", - "Code that can never run is called **dead code**.\n", - "In general, dead code doesn't do any harm, but it often indicates a misunderstanding, and it might be confusing to someone trying to understand the program." + "El código que nunca puede ejecutarse se llama **código muerto**.\n", + "En general, el código muerto no hace daño, pero a menudo indica un malentendido y podría confundir a alguien que intenta entender el programa." ] }, { @@ -535,22 +536,22 @@ "tags": [] }, "source": [ - "## Incremental development\n", + "## Desarrollo incremental\n", "\n", - "As you write larger functions, you might find yourself spending more\n", - "time debugging.\n", - "To deal with increasingly complex programs, you might want to try **incremental development**, which is a way of adding and testing only a small amount of code at a time.\n", + "A medida que escribas funciones más grandes, puede que notes que pasas más\n", + "tiempo depurando.\n", + "Para enfrentarte a programas cada vez más complejos, quizá quieras probar el **desarrollo incremental**, que es una forma de añadir y probar solo una pequeña cantidad de código cada vez.\n", "\n", - "As an example, suppose you want to find the distance between two points represented by the coordinates $(x_1, y_1)$ and $(x_2, y_2)$.\n", - "By the Pythagorean theorem, the distance is:\n", + "Como ejemplo, supón que quieres encontrar la distancia entre dos puntos representados por las coordenadas $(x_1, y_1)$ y $(x_2, y_2)$.\n", + "Por el teorema de Pitágoras, la distancia es:\n", "\n", "$$\\mathrm{distance} = \\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$ \n", "\n", - "The first step is to consider what a `distance` function should look like in Python -- that is, what are the inputs (parameters) and what is the output (return value)?\n", + "El primer paso es considerar cómo debería ser una función `distance` en Python -- es decir, cuáles son las entradas (parámetros) y cuál es la salida (valor de retorno).\n", "\n", - "For this function, the inputs are the coordinates of the points.\n", - "The return value is the distance.\n", - "Immediately you can write an outline of the function:" + "Para esta función, las entradas son las coordenadas de los puntos.\n", + "El valor de retorno es la distancia.\n", + "De inmediato puedes escribir un esquema de la función:" ] }, { @@ -569,10 +570,10 @@ "id": "7b384fcf", "metadata": {}, "source": [ - "This version doesn't compute distances yet -- it always returns zero.\n", - "But it is a complete function with a return value, which means that you can test it before you make it more complicated.\n", + "Esta versión todavía no calcula distancias -- siempre devuelve cero.\n", + "Pero es una función completa con un valor de retorno, lo que significa que puedes probarla antes de hacerla más complicada.\n", "\n", - "To test the new function, we'll call it with sample arguments:" + "Para probar la nueva función, la llamaremos con argumentos de ejemplo:" ] }, { @@ -590,13 +591,13 @@ "id": "13a98096", "metadata": {}, "source": [ - "I chose these values so that the horizontal distance is `3` and the\n", - "vertical distance is `4`.\n", - "That way, the result is `5`, the hypotenuse of a `3-4-5` right triangle. When testing a function, it is useful to know the right answer.\n", + "Elegí estos valores para que la distancia horizontal sea `3` y la\n", + "distancia vertical sea `4`.\n", + "Así, el resultado es `5`, la hipotenusa de un triángulo rectángulo `3-4-5`. Al probar una función, es útil conocer la respuesta correcta.\n", "\n", - "At this point we have confirmed that the function runs and returns a value, and we can start adding code to the body.\n", - "A good next step is to find the differences `x2 - x1` and `y2 - y1`. \n", - "Here's a version that stores those values in temporary variables and displays them." + "En este punto hemos confirmado que la función se ejecuta y devuelve un valor, y podemos empezar a añadir código al cuerpo.\n", + "Un buen siguiente paso es encontrar las diferencias `x2 - x1` e `y2 - y1`. \n", + "Aquí tienes una versión que almacena esos valores en variables temporales y los muestra." ] }, { @@ -619,10 +620,10 @@ "id": "c342a3bd", "metadata": {}, "source": [ - "If the function is working, it should display `dx is 3` and `dy is 4`.\n", - "If so, we know that the function is getting the right arguments and\n", - "performing the first computation correctly. If not, there are only a few\n", - "lines to check." + "Si la función funciona, debería mostrar `dx is 3` y `dy is 4`.\n", + "Si es así, sabemos que la función está recibiendo los argumentos correctos y\n", + "realizando correctamente el primer cálculo. Si no, solo hay unas pocas\n", + "líneas que revisar." ] }, { @@ -640,7 +641,7 @@ "id": "9424eca9", "metadata": {}, "source": [ - "Good so far. Next we compute the sum of squares of `dx` and `dy`:" + "Hasta aquí, bien. A continuación calculamos la suma de los cuadrados de `dx` e `dy`:" ] }, { @@ -663,7 +664,7 @@ "id": "e28262f9", "metadata": {}, "source": [ - "Again, we can run the function and check the output, which should be `25`. " + "De nuevo, podemos ejecutar la función y comprobar la salida, que debería ser `25`. " ] }, { @@ -681,7 +682,7 @@ "id": "c09f0ddc", "metadata": {}, "source": [ - "Finally, we can use `math.sqrt` to compute the distance:" + "Por último, podemos usar `math.sqrt` para calcular la distancia:" ] }, { @@ -704,7 +705,7 @@ "id": "f27902ac", "metadata": {}, "source": [ - "And test it." + "Y probarla." ] }, { @@ -722,9 +723,9 @@ "id": "8ad2e626", "metadata": {}, "source": [ - "The result is correct, but this version of the function displays the result rather than returning it, so the return value is `None`.\n", + "El resultado es correcto, pero esta versión de la función muestra el resultado en lugar de devolverlo, así que el valor de retorno es `None`.\n", "\n", - "We can fix that by replacing the `print` function with a `return` statement." + "Podemos arreglarlo sustituyendo la función `print` por una sentencia `return`." ] }, { @@ -747,8 +748,8 @@ "id": "f3a13a14", "metadata": {}, "source": [ - "This version of `distance` is a pure function.\n", - "If we call it like this, only the result is displayed." + "Esta versión de `distance` es una función pura.\n", + "Si la llamamos así, solo se muestra el resultado." ] }, { @@ -766,7 +767,7 @@ "id": "7db8cf86", "metadata": {}, "source": [ - "And if we assign the result to a variable, nothing is displayed." + "Y si asignamos el resultado a una variable, no se muestra nada." ] }, { @@ -784,20 +785,20 @@ "id": "0c3b8829", "metadata": {}, "source": [ - "The `print` statements we wrote are useful for debugging, but once the function is working, we can remove them. \n", - "Code like that is called **scaffolding** because it is helpful for building the program but is not part of the final product.\n", + "Las sentencias `print` que escribimos son útiles para depurar, pero una vez que la función funciona, podemos eliminarlas. \n", + "El código de ese tipo se llama **andamiaje** porque ayuda a construir el programa, pero no forma parte del producto final.\n", "\n", - "This example demonstrates incremental development.\n", - "The key aspects of this process are:\n", + "Este ejemplo demuestra el desarrollo incremental.\n", + "Los aspectos clave de este proceso son:\n", "\n", - "1. Start with a working program, make small changes, and test after every change.\n", + "1. Empieza con un programa que funcione, haz cambios pequeños y prueba después de cada cambio.\n", "\n", - "2. Use variables to hold intermediate values so you can display and check them.\n", + "2. Usa variables para guardar valores intermedios, de modo que puedas mostrarlos y comprobarlos.\n", "\n", - "3. Once the program is working, remove the scaffolding.\n", + "3. Una vez que el programa funcione, elimina el andamiaje.\n", "\n", - "At any point, if there is an error, you should have a good idea where it is.\n", - "Incremental development can save you a lot of debugging time." + "En cualquier punto, si hay un error, deberías tener una buena idea de dónde está.\n", + "El desarrollo incremental puede ahorrarte mucho tiempo de debugging." ] }, { @@ -805,10 +806,10 @@ "id": "3dd7514f", "metadata": {}, "source": [ - "## Boolean functions\n", + "## Funciones booleanas\n", "\n", - "Functions can return the boolean values `True` and `False`, which is often convenient for encapsulating a complex test in a function.\n", - "For example, `is_divisible` checks whether `x` is divisible by `y` with no remainder." + "Las funciones pueden devolver los valores booleanos `True` y `False`, lo que a menudo resulta conveniente para encapsular una prueba compleja en una función.\n", + "Por ejemplo, `is_divisible` comprueba si `x` es divisible por `y` sin resto." ] }, { @@ -830,7 +831,7 @@ "id": "f3a58afb", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como la usamos." ] }, { @@ -858,8 +859,8 @@ "id": "e9103ece", "metadata": {}, "source": [ - "Inside the function, the result of the `==` operator is a boolean, so we can write the\n", - "function more concisely by returning it directly." + "Dentro de la función, el resultado del operador `==` es un booleano, así que podemos escribir la\n", + "función de forma más concisa devolviéndolo directamente." ] }, { @@ -878,7 +879,7 @@ "id": "4d82dae5", "metadata": {}, "source": [ - "Boolean functions are often used in conditional statements." + "Las funciones booleanas se usan a menudo en sentencias condicionales." ] }, { @@ -897,7 +898,7 @@ "id": "9e232afc", "metadata": {}, "source": [ - "It might be tempting to write something like this:" + "Podría ser tentador escribir algo como esto:" ] }, { @@ -916,7 +917,7 @@ "id": "ff9e5160", "metadata": {}, "source": [ - "But the comparison is unnecessary." + "Pero la comparación es innecesaria." ] }, { @@ -924,27 +925,27 @@ "id": "a932a966", "metadata": {}, "source": [ - "## Recursion with return values\n", + "## Recursión con valores de retorno\n", "\n", - "Now that we can write functions with return values, we can write recursive functions with return values, and with that capability, we have passed an important threshold -- the subset of Python we have is now **Turing complete**, which means that we can perform any computation that can be described by an algorithm.\n", + "Ahora que podemos escribir funciones con valores de retorno, podemos escribir funciones recursivas con valores de retorno, y con esa capacidad hemos cruzado un umbral importante -- el subconjunto de Python que tenemos ahora es **Turing completo**, lo que significa que podemos realizar cualquier cálculo que pueda describirse mediante un algoritmo.\n", "\n", - "To demonstrate recursion with return values, we'll evaluate a few recursively defined mathematical functions.\n", - "A recursive definition is similar to a circular definition, in the sense that the definition refers to the thing being defined. A truly circular definition is not very useful:\n", + "Para demostrar la recursión con valores de retorno, evaluaremos algunas funciones matemáticas definidas de forma recursiva.\n", + "Una definición recursiva se parece a una definición circular, en el sentido de que la definición se refiere a la cosa que se está definiendo. Una definición verdaderamente circular no es muy útil:\n", "\n", - "> vorpal: An adjective used to describe something that is vorpal.\n", + "> vorpal: Un adjetivo usado para describir algo que es vorpal.\n", "\n", - "If you saw that definition in the dictionary, you might be annoyed. \n", - "On the other hand, if you looked up the definition of the factorial function, denoted with the symbol $!$, you might get something like this: \n", + "Si vieras esa definición en el diccionario, quizá te molestaría. \n", + "Por otro lado, si buscaras la definición de la función factorial, denotada con el símbolo $!$, podrías encontrar algo como esto: \n", "\n", - "$$\\begin{aligned}\n", - "0! &= 1 \\\\\n", + "$$\begin{aligned}\n", + "0! &= 1 \\\n", "n! &= n~(n-1)!\n", "\\end{aligned}$$ \n", "\n", - "This definition says that the factorial of $0$ is $1$, and the factorial of any other value, $n$, is $n$ multiplied by the factorial of $n-1$.\n", + "Esta definición dice que el factorial de $0$ es $1$, y que el factorial de cualquier otro valor, $n$, es $n$ multiplicado por el factorial de $n-1$.\n", "\n", - "If you can write a recursive definition of something, you can write a Python program to evaluate it. \n", - "Following an incremental development process, we'll start with a function that take `n` as a parameter and always returns `0`." + "Si puedes escribir una definición recursiva de algo, puedes escribir un programa en Python para evaluarlo. \n", + "Siguiendo un proceso de desarrollo incremental, empezaremos con una función que toma `n` como parámetro y siempre devuelve `0`." ] }, { @@ -963,7 +964,7 @@ "id": "ee1f63b8", "metadata": {}, "source": [ - "Now let's add the first part of the definition -- if the argument happens to be `0`, all we have to do is return `1`:" + "Ahora añadamos la primera parte de la definición -- si resulta que el argumento es `0`, todo lo que tenemos que hacer es devolver `1`:" ] }, { @@ -985,8 +986,8 @@ "id": "4f2fd7c7", "metadata": {}, "source": [ - "Now let's fill in the second part -- if `n` is not `0`, we have to make a recursive\n", - "call to find the factorial of `n-1` and then multiply the result by `n`:" + "Ahora completemos la segunda parte -- si `n` no es `0`, tenemos que hacer una llamada recursiva\n", + "para encontrar el factorial de `n-1` y luego multiplicar el resultado por `n`:" ] }, { @@ -1009,32 +1010,32 @@ "id": "da3d1595", "metadata": {}, "source": [ - "The flow of execution for this program is similar to the flow of `countdown` in Chapter 5.\n", - "If we call `factorial` with the value `3`:\n", + "El flujo de ejecución de este programa es similar al flujo de `countdown` en el Capítulo 5.\n", + "Si llamamos a `factorial` con el valor `3`:\n", "\n", - "Since `3` is not `0`, we take the second branch and calculate the factorial\n", - "of `n-1`\\...\n", + "Como `3` no es `0`, tomamos la segunda rama y calculamos el factorial\n", + "de `n-1`\\...\n", "\n", - "> Since `2` is not `0`, we take the second branch and calculate the\n", - "> factorial of `n-1`\\...\n", + "> Como `2` no es `0`, tomamos la segunda rama y calculamos el\n", + "> factorial de `n-1`\\...\n", ">\n", - "> > Since `1` is not `0`, we take the second branch and calculate the\n", - "> > factorial of `n-1`\\...\n", + "> > Como `1` no es `0`, tomamos la segunda rama y calculamos el\n", + "> > factorial de `n-1`\\...\n", "> >\n", - "> > > Since `0` equals `0`, we take the first branch and return `1` without\n", - "> > > making any more recursive calls.\n", + "> > > Como `0` es igual a `0`, tomamos la primera rama y devolvemos `1` sin\n", + "> > > hacer más llamadas recursivas.\n", "> >\n", - "> > The return value, `1`, is multiplied by `n`, which is `1`, and the\n", - "> > result is returned.\n", + "> > El valor de retorno, `1`, se multiplica por `n`, que es `1`, y se\n", + "> > devuelve el resultado.\n", ">\n", - "> The return value, `1`, is multiplied by `n`, which is `2`, and the result\n", - "> is returned.\n", + "> El valor de retorno, `1`, se multiplica por `n`, que es `2`, y se devuelve\n", + "> el resultado.\n", "\n", - "The return value `2` is multiplied by `n`, which is `3`, and the result,\n", - "`6`, becomes the return value of the function call that started the whole\n", - "process.\n", + "El valor de retorno `2` se multiplica por `n`, que es `3`, y el resultado,\n", + "`6`, se convierte en el valor de retorno de la llamada a la función que inició todo el\n", + "proceso.\n", "\n", - "The following figure shows the stack diagram for this sequence of function calls." + "La figura siguiente muestra el diagrama de pila para esta secuencia de llamadas a funciones." ] }, { @@ -1093,10 +1094,10 @@ "id": "f924c539", "metadata": {}, "source": [ - "The return values are shown being passed back up the stack.\n", - "In each frame, the return value is the product of `n` and `recurse`.\n", + "Los valores de retorno se muestran pasando de vuelta hacia arriba por la pila.\n", + "En cada marco, el valor de retorno es el producto de `n` y `recurse`.\n", "\n", - "In the last frame, the local variable `recurse` does not exist because the branch that creates it does not run." + "En el último marco, la variable local `recurse` no existe porque la rama que la crea no se ejecuta." ] }, { @@ -1104,20 +1105,20 @@ "id": "acea9dc1", "metadata": {}, "source": [ - "## Leap of faith\n", + "## Salto de fe\n", "\n", - "Following the flow of execution is one way to read programs, but it can quickly become overwhelming. An alternative is what I call the \"leap of faith\". When you come to a function call, instead of following the flow of execution, you *assume* that the function works correctly and returns the right result.\n", + "Seguir el flujo de ejecución es una forma de leer programas, pero puede volverse abrumadora rápidamente. Una alternativa es lo que llamo el \"salto de fe\". Cuando llegas a una llamada a una función, en lugar de seguir el flujo de ejecución, *asumes* que la función funciona correctamente y devuelve el resultado adecuado.\n", "\n", - "In fact, you are already practicing this leap of faith when you use built-in functions.\n", - "When you call `abs` or `math.sqrt`, you don't examine the bodies of those functions -- you just assume that they work.\n", + "De hecho, ya estás practicando este salto de fe cuando usas funciones integradas.\n", + "Cuando llamas a `abs` o `math.sqrt`, no examinas los cuerpos de esas funciones -- simplemente asumes que funcionan.\n", "\n", - "The same is true when you call one of your own functions. For example, earlier we wrote a function called `is_divisible` that determines whether one number is divisible by another. Once we convince ourselves that this function is correct, we can use it without looking at the body again.\n", + "Lo mismo ocurre cuando llamas a una de tus propias funciones. Por ejemplo, antes escribimos una función llamada `is_divisible` que determina si un número es divisible por otro. Una vez que nos convencemos de que esta función es correcta, podemos usarla sin volver a mirar el cuerpo.\n", "\n", - "The same is true of recursive programs.\n", - "When you get to the recursive call, instead of following the flow of execution, you should assume that the recursive call works and then ask yourself, \"Assuming that I can compute the factorial of $n-1$, can I compute the factorial of $n$?\"\n", - "The recursive definition of factorial implies that you can, by multiplying by $n$.\n", + "Lo mismo ocurre con los programas recursivos.\n", + "Cuando llegas a la llamada recursiva, en lugar de seguir el flujo de ejecución, deberías asumir que la llamada recursiva funciona y luego preguntarte: \"Suponiendo que puedo calcular el factorial de $n-1$, ¿puedo calcular el factorial de $n$?\"\n", + "La definición recursiva del factorial implica que sí puedes, multiplicando por $n$.\n", "\n", - "Of course, it's a bit strange to assume that the function works correctly when you haven't finished writing it, but that's why it's called a leap of faith!" + "Por supuesto, es un poco extraño asumir que la función funciona correctamente cuando aún no has terminado de escribirla, ¡pero por eso se llama salto de fe!" ] }, { @@ -1129,15 +1130,15 @@ "source": [ "## Fibonacci\n", "\n", - "After `factorial`, the most common example of a recursive function is `fibonacci`, which has the following definition: \n", + "Después de `factorial`, el ejemplo más común de función recursiva es `fibonacci`, que tiene la siguiente definición: \n", "\n", - "$$\\begin{aligned}\n", - "\\mathrm{fibonacci}(0) &= 0 \\\\\n", - "\\mathrm{fibonacci}(1) &= 1 \\\\\n", + "$$\begin{aligned}\n", + "\\mathrm{fibonacci}(0) &= 0 \\\n", + "\\mathrm{fibonacci}(1) &= 1 \\\n", "\\mathrm{fibonacci}(n) &= \\mathrm{fibonacci}(n-1) + \\mathrm{fibonacci}(n-2)\n", "\\end{aligned}$$ \n", "\n", - "Translated into Python, it looks like this:" + "Traducida a Python, se ve así:" ] }, { @@ -1161,11 +1162,11 @@ "id": "69d56a0b", "metadata": {}, "source": [ - "If you try to follow the flow of execution here, even for small values of $n$, your head explodes.\n", - "But according to the leap of faith, if you assume that the two recursive calls work correctly, you can be confident that the last `return` statement is correct.\n", + "Si intentas seguir aquí el flujo de ejecución, incluso para valores pequeños de $n$, te explota la cabeza.\n", + "Pero según el salto de fe, si asumes que las dos llamadas recursivas funcionan correctamente, puedes confiar en que la última sentencia `return` es correcta.\n", "\n", - "As an aside, this way of computing Fibonacci numbers is very inefficient.\n", - "In [Chapter 10](section_memos) I'll explain why and suggest a way to improve it." + "Como nota aparte, esta forma de calcular números de Fibonacci es muy ineficiente.\n", + "En el [Capítulo 10](section_memos) explicaré por qué y sugeriré una forma de mejorarla." ] }, { @@ -1173,9 +1174,9 @@ "id": "26d9706b", "metadata": {}, "source": [ - "## Checking types\n", + "## Comprobación de tipos\n", "\n", - "What happens if we call `factorial` and give it `1.5` as an argument?" + "¿Qué ocurre si llamamos a `factorial` y le damos `1.5` como argumento?" ] }, { @@ -1197,16 +1198,16 @@ "id": "0bec7ba4", "metadata": {}, "source": [ - "It looks like an infinite recursion. How can that be? The function has base cases when `n == 1` or `n == 0`.\n", - "But if `n` is not an integer, we can *miss* the base case and recurse forever.\n", + "Parece una recursión infinita. ¿Cómo puede ser? La función tiene casos base cuando `n == 1` o `n == 0`.\n", + "Pero si `n` no es un entero, podemos *saltarnos* el caso base y hacer recursión para siempre.\n", "\n", - "In this example, the initial value of `n` is `1.5`.\n", - "In the first recursive call, the value of `n` is `0.5`.\n", - "In the next, it is `-0.5`. \n", - "From there, it gets smaller (more negative), but it will never be `0`.\n", + "En este ejemplo, el valor inicial de `n` es `1.5`.\n", + "En la primera llamada recursiva, el valor de `n` es `0.5`.\n", + "En la siguiente, es `-0.5`. \n", + "A partir de ahí, se hace más pequeño (más negativo), pero nunca será `0`.\n", "\n", - "To avoid infinite recursion we can use the built-in function `isinstance` to check the type of the argument.\n", - "Here's how we check whether a value is an integer." + "Para evitar la recursión infinita podemos usar la función integrada `isinstance` para comprobar el tipo del argumento.\n", + "Así comprobamos si un valor es un entero." ] }, { @@ -1234,7 +1235,7 @@ "id": "b0017b42", "metadata": {}, "source": [ - "Now here's a version of `factorial` with error-checking." + "Ahora aquí tienes una versión de `factorial` con comprobación de errores." ] }, { @@ -1262,8 +1263,9 @@ "id": "0561e3f5", "metadata": {}, "source": [ - "First it checks whether `n` is an integer.\n", - "If not, it displays an error message and returns `None`.\n", + "Primero comprueba si `n` es un entero.\n", + "Si no lo es, muestra un mensaje de error y devuelve `None`.\n", + "\n", "\n" ] }, @@ -1282,8 +1284,8 @@ "id": "10b00a39", "metadata": {}, "source": [ - "Then it checks whether `n` is negative.\n", - "If so, it displays an error message and returns `None.`" + "Luego comprueba si `n` es negativo.\n", + "Si lo es, muestra un mensaje de error y devuelve `None`." ] }, { @@ -1301,8 +1303,8 @@ "id": "96aa1403", "metadata": {}, "source": [ - "If we get past both checks, we know that `n` is a non-negative integer, so we can be confident the recursion will terminate.\n", - "Checking the parameters of a function to make sure they have the correct types and values is called **input validation**." + "Si superamos ambas comprobaciones, sabemos que `n` es un entero no negativo, así que podemos confiar en que la recursión terminará.\n", + "Comprobar los parámetros de una función para asegurarse de que tienen los tipos y valores correctos se llama **validación de entrada**." ] }, { @@ -1314,25 +1316,25 @@ "source": [ "## Debugging\n", "\n", - "Breaking a large program into smaller functions creates natural checkpoints for debugging.\n", - "If a function is not working, there are three possibilities to consider:\n", + "Dividir un programa grande en funciones más pequeñas crea puntos de control naturales para depurar.\n", + "Si una función no funciona, hay tres posibilidades que considerar:\n", "\n", - "- There is something wrong with the arguments the function is getting -- that is, a precondition is violated.\n", + "- Hay algo mal con los argumentos que recibe la función -- es decir, se viola una precondición.\n", "\n", - "- There is something wrong with the function -- that is, a postcondition is violated.\n", + "- Hay algo mal con la función -- es decir, se viola una postcondición.\n", "\n", - "- The caller is doing something wrong with the return value.\n", + "- Quien llama a la función está haciendo algo mal con el valor de retorno.\n", "\n", - "To rule out the first possibility, you can add a `print` statement at the beginning of the function that displays the values of the parameters (and maybe their types).\n", - "Or you can write code that checks the preconditions explicitly.\n", + "Para descartar la primera posibilidad, puedes añadir una sentencia `print` al principio de la función que muestre los valores de los parámetros (y quizá sus tipos).\n", + "O puedes escribir código que compruebe explícitamente las precondiciones.\n", "\n", - "If the parameters look good, you can add a `print` statement before each `return` statement and display the return value.\n", - "If possible, call the function with arguments that make it easy check the result. \n", + "Si los parámetros parecen correctos, puedes añadir una sentencia `print` antes de cada sentencia `return` y mostrar el valor de retorno.\n", + "Si es posible, llama a la función con argumentos que faciliten comprobar el resultado. \n", "\n", - "If the function seems to be working, look at the function call to make sure the return value is being used correctly -- or used at all!\n", + "Si la función parece funcionar, mira la llamada a la función para asegurarte de que el valor de retorno se está usando correctamente -- ¡o de que se está usando siquiera!\n", "\n", - "Adding `print` statements at the beginning and end of a function can help make the flow of execution more visible.\n", - "For example, here is a version of `factorial` with print statements:" + "Añadir sentencias `print` al principio y al final de una función puede ayudar a hacer más visible el flujo de ejecución.\n", + "Por ejemplo, aquí tienes una versión de `factorial` con sentencias print:" ] }, { @@ -1360,8 +1362,8 @@ "id": "0c044111", "metadata": {}, "source": [ - "`space` is a string of space characters that controls the indentation of\n", - "the output. Here is the result of `factorial(3)` :" + "`space` es una cadena de caracteres de espacio que controla la indentación de\n", + "la salida. Este es el resultado de `factorial(3)` :" ] }, { @@ -1379,8 +1381,8 @@ "id": "43b3e408", "metadata": {}, "source": [ - "If you are confused about the flow of execution, this kind of output can be helpful.\n", - "It takes some time to develop effective scaffolding, but a little bit of scaffolding can save a lot of debugging." + "Si tienes dudas sobre el flujo de ejecución, este tipo de salida puede ser útil.\n", + "Lleva tiempo desarrollar andamiaje eficaz, pero un poco de andamiaje puede ahorrar mucho debugging." ] }, { @@ -1388,29 +1390,29 @@ "id": "b7c3962f", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**return value:**\n", - "The result of a function. If a function call is used as an expression, the return value is the value of the expression.\n", + "**valor de retorno:**\n", + "El resultado de una función. Si una llamada a una función se usa como expresión, el valor de retorno es el valor de la expresión.\n", "\n", - "**pure function:**\n", - "A function that does not display anything or have any other effect, other than returning a return value.\n", + "**función pura:**\n", + "Una función que no muestra nada ni tiene ningún otro efecto, aparte de devolver un valor de retorno.\n", "\n", "\n", - "**dead code:**\n", - "Part of a program that can never run, often because it appears after a `return` statement.\n", + "**código muerto:**\n", + "Parte de un programa que nunca puede ejecutarse, a menudo porque aparece después de una sentencia `return`.\n", "\n", - "**incremental development:**\n", - "A program development plan intended to avoid debugging by adding and testing only a small amount of code at a time.\n", + "**desarrollo incremental:**\n", + "Un plan de desarrollo de programas pensado para evitar la depuración añadiendo y probando solo una pequeña cantidad de código cada vez.\n", "\n", - "**scaffolding:**\n", - " Code that is used during program development but is not part of the final version.\n", + "**andamiaje:**\n", + " Código que se usa durante el desarrollo del programa pero que no forma parte de la versión final.\n", "\n", - "**Turing complete:**\n", - "A language, or subset of a language, is Turing complete if it can perform any computation that can be described by an algorithm.\n", + "**Turing completo:**\n", + "Un lenguaje, o un subconjunto de un lenguaje, es Turing completo si puede realizar cualquier cálculo que pueda describirse mediante un algoritmo.\n", "\n", - "**input validation:**\n", - "Checking the parameters of a function to make sure they have the correct types and values" + "**validación de entrada:**\n", + "Comprobar los parámetros de una función para asegurarse de que tienen los tipos y valores correctos" ] }, { @@ -1418,7 +1420,7 @@ "id": "ff7b1edf", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1441,9 +1443,9 @@ "id": "0da2daaf", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, we saw an incorrect function that can end without returning a value." + "En este capítulo vimos una función incorrecta que puede terminar sin devolver un valor." ] }, { @@ -1465,7 +1467,7 @@ "id": "69563d4b", "metadata": {}, "source": [ - "And a version of the same function that has dead code at the end." + "Y una versión de la misma función que tiene código muerto al final." ] }, { @@ -1489,7 +1491,7 @@ "id": "9fe8ae2e", "metadata": {}, "source": [ - "And we saw the following example, which is correct but not idiomatic." + "Y vimos el siguiente ejemplo, que es correcto pero no idiomático." ] }, { @@ -1511,9 +1513,9 @@ "id": "14f52688", "metadata": {}, "source": [ - "Ask a virtual assistant what's wrong with each of these functions and see if it can spot the errors or improve the style.\n", + "Pregunta a un asistente virtual qué está mal en cada una de estas funciones y comprueba si puede detectar los errores o mejorar el estilo.\n", "\n", - "Then ask \"Write a function that takes coordinates of two points and computes the distance between them.\" See if the result resembles the version of `distance` we wrote in this chapter." + "Luego pregunta: \"Escribe una función que tome las coordenadas de dos puntos y calcule la distancia entre ellos.\" Comprueba si el resultado se parece a la versión de `distance` que escribimos en este capítulo." ] }, { @@ -1521,14 +1523,14 @@ "id": "fd23bb60", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Use incremental development to write a function called `hypot` that returns the length of the hypotenuse of a right triangle given the lengths of the other two legs as arguments.\n", + "Usa desarrollo incremental para escribir una función llamada `hypot` que devuelva la longitud de la hipotenusa de un triángulo rectángulo dadas las longitudes de los otros dos catetos como argumentos.\n", "\n", - "Note: There's a function in the math module called `hypot` that does the same thing, but you should not use it for this exercise!\n", + "Nota: Hay una función en el módulo math llamada `hypot` que hace lo mismo, ¡pero no deberías usarla para este ejercicio!\n", "\n", - "Even if you can write the function correctly on the first try, start with a function that always returns `0` and practice making small changes, testing as you go.\n", - "When you are done, the function should only return a value -- it should not display anything." + "Aunque puedas escribir la función correctamente al primer intento, empieza con una función que siempre devuelva `0` y practica haciendo cambios pequeños, probando a medida que avanzas.\n", + "Cuando termines, la función solo debería devolver un valor -- no debería mostrar nada." ] }, { @@ -1636,10 +1638,10 @@ "id": "0a66d82a", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a boolean function, `is_between(x, y, z)`, that returns `True` if $x < y < z$ or if \n", - "$z < y < x$, and`False` otherwise." + "Escribe una función booleana, `is_between(x, y, z)`, que devuelva `True` si $x < y < z$ o si \n", + "$z < y < x$, y `False` en caso contrario." ] }, { @@ -1659,7 +1661,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1715,20 +1717,20 @@ "id": "57f06466", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The Ackermann function, $A(m, n)$, is defined:\n", + "La función de Ackermann, $A(m, n)$, se define así:\n", "\n", - "$$\\begin{aligned}\n", - "A(m, n) = \\begin{cases} \n", - " n+1 & \\mbox{if } m = 0 \\\\ \n", - " A(m-1, 1) & \\mbox{if } m > 0 \\mbox{ and } n = 0 \\\\ \n", + "$$\begin{aligned}\n", + "A(m, n) = \begin{cases} \n", + " n+1 & \\mbox{if } m = 0 \\ \n", + " A(m-1, 1) & \\mbox{if } m > 0 \\mbox{ and } n = 0 \\ \n", "A(m-1, A(m, n-1)) & \\mbox{if } m > 0 \\mbox{ and } n > 0.\n", "\\end{cases} \n", "\\end{aligned}$$ \n", "\n", - "Write a function named `ackermann` that evaluates the Ackermann function.\n", - "What happens if you call `ackermann(5, 5)`?" + "Escribe una función llamada `ackermann` que evalúe la función de Ackermann.\n", + "¿Qué ocurre si llamas a `ackermann(5, 5)`?" ] }, { @@ -1748,7 +1750,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1794,7 +1796,7 @@ "tags": [] }, "source": [ - "If you call this function with values bigger than 4, you get a `RecursionError`." + "Si llamas a esta función con valores mayores que 4, obtienes un `RecursionError`." ] }, { @@ -1818,7 +1820,7 @@ "tags": [] }, "source": [ - "To see why, add a print statement to the beginning of the function to display the values of the parameters, and then run the examples again." + "Para ver por qué, añade una sentencia print al principio de la función para mostrar los valores de los parámetros, y luego ejecuta los ejemplos de nuevo." ] }, { @@ -1828,12 +1830,12 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A number, $a$, is a power of $b$ if it is divisible by $b$ and $a/b$ is\n", - "a power of $b$. Write a function called `is_power` that takes parameters\n", - "`a` and `b` and returns `True` if `a` is a power of `b`. Note: you will\n", - "have to think about the base case." + "Un número, $a$, es una potencia de $b$ si es divisible por $b$ y $a/b$ es\n", + "una potencia de $b$. Escribe una función llamada `is_power` que tome los parámetros\n", + "`a` y `b`, y devuelva `True` si `a` es una potencia de `b`. Nota: tendrás\n", + "que pensar en el caso base." ] }, { @@ -1853,7 +1855,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1909,17 +1911,17 @@ "id": "a33bbd07", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The greatest common divisor (GCD) of $a$ and $b$ is the largest number\n", - "that divides both of them with no remainder.\n", + "El máximo común divisor (MCD) de $a$ y $b$ es el número más grande\n", + "que divide a ambos sin dejar resto.\n", "\n", - "One way to find the GCD of two numbers is based on the observation that\n", - "if $r$ is the remainder when $a$ is divided by $b$, then $gcd(a,\n", - "b) = gcd(b, r)$. As a base case, we can use $gcd(a, 0) = a$.\n", + "Una forma de encontrar el MCD de dos números se basa en la observación de que\n", + "si $r$ es el resto cuando $a$ se divide por $b$, entonces $gcd(a,\n", + "b) = gcd(b, r)$. Como caso base, podemos usar $gcd(a, 0) = a$.\n", "\n", - "Write a function called `gcd` that takes parameters `a` and `b` and\n", - "returns their greatest common divisor." + "Escribe una función llamada `gcd` que tome los parámetros `a` y `b`, y\n", + "devuelva su máximo común divisor." ] }, { @@ -1939,7 +1941,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your function." + "Puedes usar estos ejemplos para probar tu función." ] }, { @@ -1985,9 +1987,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap07.ipynb b/chapters/chap07.ipynb index 9d9c634..2f7fa5f 100644 --- a/chapters/chap07.ipynb +++ b/chapters/chap07.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y libro electrónico de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -43,15 +43,15 @@ "tags": [] }, "source": [ - "# Iteration and Search\n", + "# Iteración y búsqueda\n", "\n", - "In 1939 Ernest Vincent Wright published a 50,000 word novel called *Gadsby* that does not contain the letter \"e\". Since \"e\" is the most common letter in English, writing even a few words without using it is difficult.\n", - "To get a sense of how difficult, in this chapter we'll compute the fraction of English words have at least one \"e\".\n", + "En 1939, Ernest Vincent Wright publicó una novela de 50.000 palabras llamada *Gadsby* que no contiene la letra \"e\". Como \"e\" es la letra más común en inglés, escribir incluso unas pocas palabras sin usarla es difícil.\n", + "Para hacernos una idea de lo difícil que es, en este capítulo calcularemos la fracción de palabras en inglés que tienen al menos una \"e\".\n", "\n", - "For that, we'll use `for` statements to loop through the letters in a string and the words in a file, and we'll update variables in a loop to count the number of words that contain an \"e\".\n", - "We'll use the `in` operator to check whether a letter appears in a word, and you'll learn a programming pattern called a \"linear search\".\n", + "Para ello, usaremos sentencias `for` para recorrer las letras de una cadena y las palabras de un archivo, y actualizaremos variables en un bucle para contar el número de palabras que contienen una \"e\".\n", + "Usaremos el operador `in` para comprobar si una letra aparece en una palabra, y aprenderás un patrón de programación llamado \"búsqueda lineal\".\n", "\n", - "As an exercise, you'll use these tools to solve a word puzzle called \"Spelling Bee\"." + "Como ejercicio, usarás estas herramientas para resolver un juego de palabras llamado \"Spelling Bee\"." ] }, { @@ -59,9 +59,9 @@ "id": "389f5162-0a8c-4cc7-99f1-a261e0b39006", "metadata": {}, "source": [ - "## Loops and strings\n", + "## Bucles y cadenas\n", "\n", - "In Chapter 3 we saw a `for` loop that uses the `range` function to display a sequence of numbers." + "En el capítulo 3 vimos un bucle `for` que usa la función `range` para mostrar una secuencia de números." ] }, { @@ -80,9 +80,9 @@ "id": "937a0af9-5486-4195-8e59-6f819db1cf3f", "metadata": {}, "source": [ - "This version uses the keyword argument `end` so the `print` function puts a space after each number rather than a newline.\n", + "Esta versión usa el argumento de palabra clave `end` para que la función `print` añada un espacio después de cada número en lugar de un salto de línea.\n", "\n", - "We can also use a `for` loop to display the letters in a string." + "También podemos usar un bucle `for` para mostrar las letras de una cadena." ] }, { @@ -101,10 +101,10 @@ "id": "72044436-ed85-407b-8821-9696648ec29c", "metadata": {}, "source": [ - "Notice that I changed the name of the variable from `i` to `letter`, which provides more information about the value it refers to.\n", - "The variable defined in a `for` loop is called the **loop variable**.\n", + "Fíjate en que he cambiado el nombre de la variable de `i` a `letter`, lo que proporciona más información sobre el valor al que se refiere.\n", + "La variable definida en un bucle `for` se llama **variable de bucle**.\n", "\n", - "Now that we can loop through the letters in a word, we can check whether it contains the letter \"e\"." + "Ahora que podemos recorrer las letras de una palabra, podemos comprobar si contiene la letra \"e\"." ] }, { @@ -124,7 +124,7 @@ "id": "644b7df2-4528-48d9-a003-2d21fbefbaab", "metadata": {}, "source": [ - "Before we go on, let's encapsulate that loop in a function." + "Antes de seguir, encapsulemos ese bucle en una función." ] }, { @@ -145,7 +145,7 @@ "id": "31cfacd9-5721-457a-be40-80cf002723b2", "metadata": {}, "source": [ - "And let's make it a pure function that return `True` if the word contains an \"e\" and `False` otherwise." + "Y convirtámosla en una función pura que devuelva `True` si la palabra contiene una \"e\" y `False` en caso contrario." ] }, { @@ -167,7 +167,7 @@ "id": "8f45502e-6db3-4fcc-802c-c97398787dbd", "metadata": {}, "source": [ - "We can generalize it to take the word as a parameter." + "Podemos generalizarla para que tome la palabra como parámetro." ] }, { @@ -189,7 +189,7 @@ "id": "590f4399-16d3-4f1c-93bc-b1fe7ce46633", "metadata": {}, "source": [ - "Now we can test it like this:" + "Ahora podemos probarla así:" ] }, { @@ -217,10 +217,10 @@ "id": "8adf1e92-435e-4b54-837a-bad603ebcafd", "metadata": {}, "source": [ - "## Reading the word list\n", + "## Leer la lista de palabras\n", "\n", - "To see how many words contain an \"e\", we'll need a word list.\n", - "The one we'll use is a list of about 114,000 official crosswords; that is, words that are considered valid in crossword puzzles and other word games. " + "Para ver cuántas palabras contienen una \"e\", necesitaremos una lista de palabras.\n", + "La que usaremos es una lista de unas 114.000 palabras oficiales de crucigramas; es decir, palabras que se consideran válidas en crucigramas y otros juegos de palabras." ] }, { @@ -230,7 +230,7 @@ "tags": [] }, "source": [ - "The following cell downloads the word list, which is a modified version of a list collected and contributed to the public domain by Grady Ward as part of the Moby lexicon project (see )." + "La siguiente celda descarga la lista de palabras, que es una versión modificada de una lista recopilada y aportada al dominio público por Grady Ward como parte del proyecto léxico Moby (consulta )." ] }, { @@ -250,8 +250,8 @@ "id": "5b383a3c-d173-4a66-bf86-23b329032004", "metadata": {}, "source": [ - "The word list is in a file called `words.txt`, which is downloaded in the notebook for this chapter.\n", - "To read it, we'll use the built-in function `open`, which takes the name of the file as a parameter and returns a **file object** we can use to read the file." + "La lista de palabras está en un archivo llamado `words.txt`, que se descarga en el notebook de este capítulo.\n", + "Para leerlo, usaremos la función integrada `open`, que toma el nombre del archivo como parámetro y devuelve un **objeto de archivo** que podemos usar para leer el archivo." ] }, { @@ -269,7 +269,7 @@ "id": "4414d9b1-cb8e-472e-818c-0555e29b1ad5", "metadata": {}, "source": [ - "The file object provides a function called `readline`, which reads characters from the file until it gets to a newline and returns the result as a string:" + "El objeto de archivo proporciona un método llamado `readline`, que lee caracteres del archivo hasta llegar a un salto de línea y devuelve el resultado como una cadena:" ] }, { @@ -287,14 +287,15 @@ "id": "d74e9fe9-117e-436a-ade3-3d08dfda2a00", "metadata": {}, "source": [ - "Notice that the syntax for calling `readline` is different from functions we've seen so far. That's because it is a **method**, which is a function associated with an object.\n", - "In this case `readline` is associated with the file object, so we call it using the name of the object, the dot operator, and the name of the method.\n", + "Fíjate en que la sintaxis para llamar a `readline` es diferente de la de las funciones que hemos visto hasta ahora. Eso se debe a que es un **método**, que es una función asociada a un objeto.\n", + "En este caso `readline` está asociado al objeto de archivo, así que lo llamamos usando el nombre del objeto, el operador punto y el nombre del método.\n", "\n", - "The first word in the list is \"aa\", which is a kind of lava.\n", - "The sequence `\\n` represents the newline character that separates this word from the next.\n", + "La primera palabra de la lista es \"aa\", que es un tipo de lava.\n", + "La secuencia `\n", + "` representa el carácter de salto de línea que separa esta palabra de la siguiente.\n", "\n", - "The file object keeps track of where it is in the file, so if you call\n", - "`readline` again, you get the next word:" + "El objeto de archivo lleva la cuenta de en qué parte del archivo está, así que si llamas a\n", + "`readline` de nuevo, obtienes la siguiente palabra:" ] }, { @@ -313,7 +314,7 @@ "id": "cd466fdb-38ce-4e5b-92c7-05dc23922005", "metadata": {}, "source": [ - "To remove the newline from the end of the word, we can use `strip`, which is a method associated with strings, so we can call it like this." + "Para eliminar el salto de línea del final de la palabra, podemos usar `strip`, que es un método asociado con las cadenas, así que podemos llamarlo así." ] }, { @@ -332,10 +333,10 @@ "id": "6dda6bac-e02e-47ee-9bab-70cef8c27d7a", "metadata": {}, "source": [ - "`strip` removes whitespace characters -- including spaces, tabs, and newlines -- from the beginning and end of the string.\n", + "`strip` elimina caracteres de espacio en blanco -- incluidos espacios, tabulaciones y saltos de línea -- del principio y el final de la cadena.\n", "\n", - "You can also use a file object as part of a `for` loop. \n", - "This program reads `words.txt` and prints each word, one per line:" + "También puedes usar un objeto de archivo como parte de un bucle `for`.\n", + "Este programa lee `words.txt` e imprime cada palabra, una por línea:" ] }, { @@ -357,8 +358,8 @@ "id": "93e320a5-4827-487e-a8ce-216392f398a8", "metadata": {}, "source": [ - "Now that we can read the word list, the next step is to count them.\n", - "For that, we will need the ability to update variables." + "Ahora que podemos leer la lista de palabras, el siguiente paso es contarlas.\n", + "Para eso, necesitaremos la capacidad de actualizar variables." ] }, { @@ -366,13 +367,12 @@ "id": "b63a6877", "metadata": {}, "source": [ - "## Updating variables\n", + "## Actualizar variables\n", "\n", - "As you may have discovered, it is legal to make more than one assignment\n", - "to the same variable.\n", - "A new assignment makes an existing variable refer to a new value (and stop referring to the old value).\n", + "Como quizá hayas descubierto, es legal hacer más de una asignación a la misma variable.\n", + "Una nueva asignación hace que una variable existente se refiera a un valor nuevo (y deje de referirse al valor anterior).\n", "\n", - "For example, here is an initial assignment that creates a variable." + "Por ejemplo, aquí hay una asignación inicial que crea una variable." ] }, { @@ -391,7 +391,7 @@ "id": "c9735982", "metadata": {}, "source": [ - "And here is an assignment that changes the value of a variable." + "Y aquí hay una asignación que cambia el valor de una variable." ] }, { @@ -410,7 +410,7 @@ "id": "fbcd1092-ce06-47fc-9204-fce1c9a100a5", "metadata": {}, "source": [ - "The following figure shows what these assignments looks like in a state diagram." + "La siguiente figura muestra cómo se ven estas asignaciones en un diagrama de estado." ] }, { @@ -449,11 +449,11 @@ "id": "42b7b044-f83b-4483-9a24-64980c688c94", "metadata": {}, "source": [ - "The dotted arrow indicates that `x` no longer refers to `5`.\n", - "The solid arrow indicates that it now refers to `7`.\n", + "La flecha punteada indica que `x` ya no se refiere a `5`.\n", + "La flecha sólida indica que ahora se refiere a `7`.\n", "\n", - "A common kind of assignment is an **update**, where the new value of\n", - "the variable depends on the old." + "Un tipo común de asignación es una **actualización**, donde el nuevo valor de\n", + "la variable depende del anterior." ] }, { @@ -484,9 +484,9 @@ "id": "d3025706", "metadata": {}, "source": [ - "This statement means \"get the current value of `x`, add one, and assign the result back to `x`.\"\n", + "Esta sentencia significa \"obtén el valor actual de `x`, suma uno y asigna el resultado de nuevo a `x`.\"\n", "\n", - "If you try to update a variable that doesn't exist, you get an error, because Python evaluates the expression on the right before it assigns a value to the variable on the left." + "Si intentas actualizar una variable que no existe, obtienes un error, porque Python evalúa la expresión de la derecha antes de asignar un valor a la variable de la izquierda." ] }, { @@ -508,8 +508,8 @@ "id": "03d3959f", "metadata": {}, "source": [ - "Before you can update a variable, you have to **initialize** it, usually\n", - "with a simple assignment:" + "Antes de poder actualizar una variable, tienes que **inicializarla**, normalmente\n", + "con una asignación sencilla:" ] }, { @@ -529,9 +529,9 @@ "id": "374fb3d5", "metadata": {}, "source": [ - "Increasing the value of a variable is called an **increment**; decreasing the value is called a **decrement**.\n", - "Because these operations are so common, Python provides **augmented assignment operators** that update a variable more concisely.\n", - "For example, the `+=` operator increments a variable by the given amount." + "Aumentar el valor de una variable se llama **incremento**; disminuir el valor se llama **decremento**.\n", + "Como estas operaciones son tan comunes, Python proporciona **operadores de asignación aumentada** que actualizan una variable de forma más concisa.\n", + "Por ejemplo, el operador `+=` incrementa una variable en la cantidad dada." ] }, { @@ -550,7 +550,7 @@ "id": "3f4eedf1", "metadata": {}, "source": [ - "There are augmented assignment operators for the other arithmetic operators, including `-=` and `*=`." + "Hay operadores de asignación aumentada para los otros operadores aritméticos, incluidos `-=` y `*=`." ] }, { @@ -558,9 +558,9 @@ "id": "70eeef60-6a34-403a-96bb-aa5c4574a5fe", "metadata": {}, "source": [ - "## Looping and counting\n", + "## Recorrer y contar\n", "\n", - "The following program counts the number of words in the word list." + "El siguiente programa cuenta el número de palabras en la lista de palabras." ] }, { @@ -582,9 +582,9 @@ "id": "9bd83ddd", "metadata": {}, "source": [ - "It starts by initializing `total` to `0`.\n", - "Each time through the loop, it increments `total` by `1`.\n", - "So when the loop exits, `total` refers to the total number of words." + "Empieza inicializando `total` a `0`.\n", + "Cada vez que pasa por el bucle, incrementa `total` en `1`.\n", + "Así que cuando el bucle termina, `total` se refiere al número total de palabras." ] }, { @@ -602,9 +602,9 @@ "id": "54904394", "metadata": {}, "source": [ - "A variable like this, used to count the number of times something happens, is called a **counter**.\n", + "Una variable como esta, usada para contar el número de veces que ocurre algo, se llama **contador**.\n", "\n", - "We can add a second counter to the program to keep track of the number of words that contain an \"e\"." + "Podemos añadir un segundo contador al programa para llevar la cuenta del número de palabras que contienen una \"e\"." ] }, { @@ -629,7 +629,7 @@ "id": "ab73c1e3", "metadata": {}, "source": [ - "Let's see how many words contain an \"e\"." + "Veamos cuántas palabras contienen una \"e\"." ] }, { @@ -647,7 +647,7 @@ "id": "d2262e64", "metadata": {}, "source": [ - "As a percentage of `total`, about two-thirds of the words use the letter \"e\"." + "Como porcentaje de `total`, alrededor de dos tercios de las palabras usan la letra \"e\"." ] }, { @@ -665,7 +665,7 @@ "id": "fe002dde", "metadata": {}, "source": [ - "So you can understand why it's difficult to craft a book without using any such words." + "Así puedes entender por qué es difícil escribir un libro sin usar ninguna de esas palabras." ] }, { @@ -673,10 +673,10 @@ "id": "632a992f", "metadata": {}, "source": [ - "## The in operator\n", + "## El operador in\n", "\n", - "The version of `has_e` we wrote in this chapter is more complicated than it needs to be.\n", - "Python provides an operator, `in`, that checks whether a character appears in a string." + "La versión de `has_e` que escribimos en este capítulo es más complicada de lo necesario.\n", + "Python proporciona un operador, `in`, que comprueba si un carácter aparece en una cadena." ] }, { @@ -695,7 +695,7 @@ "id": "ede36fe9", "metadata": {}, "source": [ - "So we can rewrite `has_e` like this." + "Así que podemos reescribir `has_e` así." ] }, { @@ -717,7 +717,7 @@ "id": "f86f6fc7", "metadata": {}, "source": [ - "And because the conditional of the `if` statement has a boolean value, we can eliminate the `if` statement and return the boolean directly." + "Y como la condición de la sentencia `if` tiene un valor booleano, podemos eliminar la sentencia `if` y devolver el valor booleano directamente." ] }, { @@ -736,8 +736,8 @@ "id": "f2a05319", "metadata": {}, "source": [ - "We can simplify this function even more using the method `lower`, which converts the letters in a string to lowercase.\n", - "Here's an example." + "Podemos simplificar esta función todavía más usando el método `lower`, que convierte las letras de una cadena a minúsculas.\n", + "Aquí tienes un ejemplo." ] }, { @@ -755,7 +755,7 @@ "id": "57aa625a", "metadata": {}, "source": [ - "`lower` makes a new string -- it does not modify the existing string -- so the value of `word` is unchanged. " + "`lower` crea una cadena nueva -- no modifica la cadena existente -- así que el valor de `word` no cambia." ] }, { @@ -773,7 +773,7 @@ "id": "9f0bd075", "metadata": {}, "source": [ - "Here's how we can use `lower` in `has_e`." + "Así es como podemos usar `lower` en `has_e`." ] }, { @@ -812,10 +812,10 @@ "id": "1c39cb6b", "metadata": {}, "source": [ - "## Search\n", + "## Búsqueda\n", "\n", - "Based on this simpler version of `has_e`, let's write a more general function called `uses_any` that takes a second parameter that is a string of letters.\n", - "It returns `True` if the word uses any of the letters and `False` otherwise." + "Basándonos en esta versión más sencilla de `has_e`, escribamos una función más general llamada `uses_any` que recibe un segundo parámetro que es una cadena de letras.\n", + "Devuelve `True` si la palabra usa cualquiera de las letras y `False` en caso contrario." ] }, { @@ -837,7 +837,7 @@ "id": "dc2d6290", "metadata": {}, "source": [ - "Here's an example where the result is `True`." + "Aquí tienes un ejemplo donde el resultado es `True`." ] }, { @@ -855,7 +855,7 @@ "id": "2c3c1553", "metadata": {}, "source": [ - "And another where it is `False`." + "Y otro donde es `False`." ] }, { @@ -873,7 +873,7 @@ "id": "b2acc611", "metadata": {}, "source": [ - "`uses_any` converts `word` and `letters` to lowercase, so it works with any combination of cases. " + "`uses_any` convierte `word` y `letters` a minúsculas, así que funciona con cualquier combinación de mayúsculas y minúsculas." ] }, { @@ -891,13 +891,13 @@ "id": "673786a5", "metadata": {}, "source": [ - "The structure of `uses_any` is similar to `has_e`.\n", - "It loops through the letters in `word` and checks them one at a time.\n", - "If it finds one that appears in `letters`, it returns `True` immediately.\n", - "If it gets all the way through the loop without finding any, it returns `False`.\n", + "La estructura de `uses_any` es similar a la de `has_e`.\n", + "Recorre las letras de `word` y las comprueba una por una.\n", + "Si encuentra una que aparece en `letters`, devuelve `True` inmediatamente.\n", + "Si llega hasta el final del bucle sin encontrar ninguna, devuelve `False`.\n", "\n", - "This pattern is called a **linear search**.\n", - "In the exercises at the end of this chapter, you'll write more functions that use this pattern." + "Este patrón se llama **búsqueda lineal**.\n", + "En los ejercicios al final de este capítulo, escribirás más funciones que usan este patrón." ] }, { @@ -907,9 +907,9 @@ "source": [ "## Doctest\n", "\n", - "In [Chapter 4](section_docstring) we used a docstring to document a function -- that is, to explain what it does.\n", - "It is also possible to use a docstring to *test* a function.\n", - "Here's a version of `uses_any` with a docstring that includes tests." + "En el [capítulo 4](section_docstring) usamos un docstring para documentar una función -- es decir, para explicar qué hace.\n", + "También es posible usar un docstring para *probar* una función.\n", + "Aquí tienes una versión de `uses_any` con un docstring que incluye pruebas." ] }, { @@ -938,15 +938,15 @@ "id": "2871d018", "metadata": {}, "source": [ - "Each test begins with `>>>`, which is used as a prompt in some Python environments to indicate where the user can type code.\n", - "In a doctest, the prompt is followed by an expression, usually a function call.\n", - "The following line indicates the value the expression should have if the function works correctly.\n", + "Cada prueba empieza con `>>>`, que se usa como indicador en algunos entornos de Python para indicar dónde el usuario puede escribir código.\n", + "En un doctest, al indicador le sigue una expresión, normalmente una llamada a función.\n", + "La línea siguiente indica el valor que debería tener la expresión si la función funciona correctamente.\n", "\n", - "In the first example, `'banana'` uses `'a'`, so the result should be `True`.\n", - "In the second example, `'apple'` does not use any of `'xyz'`, so the result should be `False`.\n", + "En el primer ejemplo, `'banana'` usa `'a'`, así que el resultado debería ser `True`.\n", + "En el segundo ejemplo, `'apple'` no usa ninguna de `'xyz'`, así que el resultado debería ser `False`.\n", "\n", - "To run these tests, we have to import the `doctest` module and run a function called `run_docstring_examples`.\n", - "To make this function easier to use, I wrote the following function, which takes a function object as an argument." + "Para ejecutar estas pruebas, tenemos que importar el módulo `doctest` y ejecutar una función llamada `run_docstring_examples`.\n", + "Para que esta función sea más fácil de usar, escribí la siguiente función, que toma un objeto que representa una función como argumento." ] }, { @@ -967,8 +967,8 @@ "id": "79e3de21", "metadata": {}, "source": [ - "We haven't learned about `globals` and `__name__` yet -- you can ignore them.\n", - "Now we can test `uses_any` like this." + "Todavía no hemos aprendido sobre `globals` y `__name__` -- puedes ignorarlos.\n", + "Ahora podemos probar `uses_any` así." ] }, { @@ -986,12 +986,11 @@ "id": "432d8c31", "metadata": {}, "source": [ - "`run_doctests` finds the expressions in the docstring and evaluates them.\n", - "If the result is the expected value, the test **passes**.\n", - "Otherwise it **fails**.\n", - "\n", - "If all tests pass, `run_doctests` displays no output -- in that case, no news is good news.\n", - "To see what happens when a test fails, here's an incorrect version of `uses_any`." + "`run_doctests` encuentra las expresiones en el docstring y las evalúa.\n", + "Si el resultado es el valor esperado, la prueba **pasa**.\n", + "En caso contrario, **falla**.\n", + "Si todas las pruebas pasan, `run_doctests` no muestra ninguna salida -- en ese caso, no tener noticias es buena señal.\n", + "Para ver qué ocurre cuando una prueba falla, aquí tienes una versión incorrecta de `uses_any`." ] }, { @@ -1021,7 +1020,7 @@ "id": "34b78be4", "metadata": {}, "source": [ - "And here's what happens when we test it." + "Y esto es lo que ocurre cuando la probamos." ] }, { @@ -1039,9 +1038,9 @@ "id": "473aa6ec", "metadata": {}, "source": [ - "The output includes the example that failed, the value the function was expected to produce, and the value the function actually produced.\n", + "La salida incluye el ejemplo que falló, el valor que se esperaba que devolviera la función y el valor que produjo realmente.\n", "\n", - "If you are not sure why this test failed, you'll have a chance to debug it as an exercise." + "Si no tienes claro por qué falló esta prueba, tendrás la oportunidad de depurarla como ejercicio." ] }, { @@ -1049,40 +1048,40 @@ "id": "382c134e", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**loop variable:**\n", - "A variable defined in the header of a `for` loop.\n", + "**variable de bucle:**\n", + "Una variable definida en la cabecera de un bucle `for`.\n", "\n", - "**file object:**\n", - "An object that represents an open file and keeps track of which parts of the file have been read or written.\n", + "**objeto de archivo:**\n", + "Un objeto que representa un archivo abierto y lleva la cuenta de qué partes del archivo se han leído o escrito.\n", "\n", - "**method:**\n", - " A function that is associated with an object and called using the dot operator.\n", + "**método:**\n", + " Una función asociada a un objeto que se llama usando el operador punto.\n", "\n", - "**update:**\n", - "An assignment statement that give a new value to a variable that already exists, rather than creating a new variables.\n", + "**actualización:**\n", + "Una sentencia de asignación que da un valor nuevo a una variable que ya existe, en lugar de crear una variable nueva.\n", "\n", - "**initialize:**\n", - "Create a new variable and give it a value.\n", + "**inicializar:**\n", + "Crear una variable nueva y darle un valor.\n", "\n", - "**increment:**\n", - "Increase the value of a variable.\n", + "**incremento:**\n", + "Aumentar el valor de una variable.\n", "\n", - "**decrement:**\n", - "Decrease the value of a variable.\n", + "**decremento:**\n", + "Disminuir el valor de una variable.\n", "\n", - "**counter:**\n", - " A variable used to count something, usually initialized to zero and then incremented.\n", + "**contador:**\n", + " Una variable usada para contar algo, normalmente inicializada a cero y luego incrementada.\n", "\n", - "**linear search:**\n", - "A computational pattern that searches through a sequence of elements and stops when it finds what it is looking for.\n", + "**búsqueda lineal:**\n", + "Un patrón computacional que busca en una secuencia de elementos y se detiene cuando encuentra lo que está buscando.\n", "\n", - "**pass:**\n", - "If a test runs and the result is as expected, the test passes.\n", + "**pasar:**\n", + "Si una prueba se ejecuta y el resultado es el esperado, la prueba pasa.\n", "\n", - "**fail:**\n", - "If a test runs and the result is not as expected, the test fails." + "**fallar:**\n", + "Si una prueba se ejecuta y el resultado no es el esperado, la prueba falla." ] }, { @@ -1090,7 +1089,7 @@ "id": "0a2b3510-e8d3-439b-a771-a4a58db6ac59", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1113,9 +1112,9 @@ "id": "8e8606b8-9a48-4cbd-a0b0-ea848666c77d", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In `uses_any`, you might have noticed that the first `return` statement is inside the loop and the second is outside." + "En `uses_any`, quizá hayas notado que la primera sentencia `return` está dentro del bucle y la segunda está fuera." ] }, { @@ -1137,7 +1136,7 @@ "id": "e1920737-b485-4823-ac20-c1e35aa93e7f", "metadata": {}, "source": [ - "When people first write functions like this, it is a common error to put both `return` statements inside the loop, like this." + "Cuando la gente escribe por primera vez funciones como esta, es un error común poner ambas sentencias `return` dentro del bucle, así." ] }, { @@ -1160,7 +1159,7 @@ "id": "d9b46591-6c80-4ff8-9378-e9318ce5e429", "metadata": {}, "source": [ - "Ask a virtual assistant what's wrong with this version." + "Pregunta a un asistente virtual qué está mal en esta versión." ] }, { @@ -1168,12 +1167,12 @@ "id": "99eff99e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function named `uses_none` that takes a word and a string of forbidden letters, and returns `True` if the word does not use any of the forbidden letters.\n", + "Escribe una función llamada `uses_none` que reciba una palabra y una cadena de letras prohibidas, y devuelva `True` si la palabra no usa ninguna de las letras prohibidas.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1221,12 +1220,12 @@ "id": "9465b09f-0c62-49f6-bbe2-365ecf1717ef", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `uses_only` that takes a word and a string of letters, and that returns `True` if the word contains only letters in the string.\n", + "Escribe una función llamada `uses_only` que reciba una palabra y una cadena de letras, y que devuelva `True` si la palabra contiene solo letras de la cadena.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1274,12 +1273,12 @@ "id": "74259f36", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `uses_all` that takes a word and a string of letters, and that returns `True` if the word contains all of the letters in the string at least once.\n", + "Escribe una función llamada `uses_all` que reciba una palabra y una cadena de letras, y que devuelva `True` si la palabra contiene todas las letras de la cadena al menos una vez.\n", "\n", - "Here's an outline of the function that includes two doctests.\n", - "Fill in the function so it passes these tests, and add at least one more doctest." + "Aquí tienes un esquema de la función que incluye dos doctests.\n", + "Completa la función para que pase estas pruebas, y añade al menos un doctest más." ] }, { @@ -1327,21 +1326,21 @@ "id": "7210adfa", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "*The New York Times* publishes a daily puzzle called \"Spelling Bee\" that challenges readers to spell as many words as possible using only seven letters, where one of the letters is required.\n", - "The words must have at least four letters.\n", + "*The New York Times* publica un juego diario llamado \"Spelling Bee\" que reta a los lectores a formar tantas palabras como sea posible usando solo siete letras, donde una de las letras es obligatoria.\n", + "Las palabras deben tener al menos cuatro letras.\n", "\n", - "For example, on the day I wrote this, the letters were `ACDLORT`, with `R` as the required letter.\n", - "So \"color\" is an acceptable word, but \"told\" is not, because it does not use `R`, and \"rat\" is not because it has only three letters.\n", - "Letters can be repeated, so \"ratatat\" is acceptable.\n", + "Por ejemplo, el día que escribí esto, las letras eran `ACDLORT`, con `R` como letra obligatoria.\n", + "Así que \"color\" es una palabra aceptable, pero \"told\" no, porque no usa `R`, y \"rat\" tampoco porque solo tiene tres letras.\n", + "Las letras se pueden repetir, así que \"ratatat\" es aceptable.\n", "\n", - "Write a function called `check_word` that checks whether a given word is acceptable.\n", - "It should take as parameters the word to check, a string of seven available letters, and a string containing the single required letter.\n", - "You can use the functions you wrote in previous exercises.\n", + "Escribe una función llamada `check_word` que compruebe si una palabra dada es aceptable.\n", + "Debe recibir como parámetros la palabra que se va a comprobar, una cadena de siete letras disponibles y una cadena que contiene la única letra obligatoria.\n", + "Puedes usar las funciones que escribiste en ejercicios anteriores.\n", "\n", - "Here's an outline of the function that includes doctests.\n", - "Fill in the function and then check that all tests pass." + "Aquí tienes un esquema de la función que incluye doctests.\n", + "Completa la función y luego comprueba que todas las pruebas pasan." ] }, { @@ -1395,18 +1394,18 @@ "id": "0b9589fc", "metadata": {}, "source": [ - "According to the \"Spelling Bee\" rules,\n", + "Según las reglas de \"Spelling Bee\",\n", "\n", - "* Four-letter words are worth 1 point each.\n", + "* Las palabras de cuatro letras valen 1 punto cada una.\n", "\n", - "* Longer words earn 1 point per letter.\n", + "* Las palabras más largas obtienen 1 punto por letra.\n", "\n", - "* Each puzzle includes at least one \"pangram\" which uses every letter. These are worth 7 extra points!\n", + "* Cada juego incluye al menos un \"pangram\" que usa todas las letras. ¡Estos valen 7 puntos extra!\n", "\n", - "Write a function called `score_word` that takes a word and a string of available letters and returns its score.\n", - "You can assume that the word is acceptable.\n", + "Escribe una función llamada `score_word` que reciba una palabra y una cadena de letras disponibles y devuelva su puntuación.\n", + "Puedes asumir que la palabra es aceptable.\n", "\n", - "Again, here's an outline of the function with doctests." + "De nuevo, aquí tienes un esquema de la función con doctests." ] }, { @@ -1458,7 +1457,7 @@ "tags": [] }, "source": [ - "When all of your functions pass their tests, use the following loop to search the word list for acceptable words and add up their scores." + "Cuando todas tus funciones pasen sus pruebas, usa el siguiente bucle para buscar palabras aceptables en la lista de palabras y sumar sus puntuaciones." ] }, { @@ -1493,9 +1492,9 @@ "tags": [] }, "source": [ - "Visit the \"Spelling Bee\" page at and type in the available letters for the day. The letter in the middle is required.\n", + "Visita la página de \"Spelling Bee\" en y escribe las letras disponibles del día. La letra del centro es obligatoria.\n", "\n", - "I found a set of letters that spells words with a total score of 5820. Can you beat that? Finding the best set of letters might be too hard -- you have to be a realist." + "Encontré un conjunto de letras que forma palabras con una puntuación total de 5820. ¿Puedes superarlo? Encontrar el mejor conjunto de letras podría ser demasiado difícil -- hay que ser realista." ] }, { @@ -1503,12 +1502,12 @@ "id": "9ae466ed", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "You might have noticed that the functions you wrote in the previous exercises had a lot in common.\n", - "In fact, they are so similar you can often use one function to write another.\n", + "Quizá hayas notado que las funciones que escribiste en los ejercicios anteriores tenían mucho en común.\n", + "De hecho, son tan parecidas que a menudo puedes usar una función para escribir otra.\n", "\n", - "For example, if a word uses none of a set forbidden letters, that means it doesn't use any. So we can write a version of `uses_none` like this." + "Por ejemplo, si una palabra no usa ninguna letra de un conjunto de letras prohibidas, eso significa que no usa ninguna. Así que podemos escribir una versión de `uses_none` así." ] }, { @@ -1548,8 +1547,8 @@ "id": "32aa2c09", "metadata": {}, "source": [ - "There is also a similarity between `uses_only` and `uses_all` that you can take advantage of.\n", - "If you have a working version of `uses_only`, see if you can write a version of `uses_all` that calls `uses_only`." + "También hay una similitud entre `uses_only` y `uses_all` que puedes aprovechar.\n", + "Si tienes una versión funcional de `uses_only`, mira si puedes escribir una versión de `uses_all` que llame a `uses_only`." ] }, { @@ -1557,11 +1556,11 @@ "id": "fa758462", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "If you got stuck on the previous question, try asking a virtual assistant, \"Given a function, `uses_only`, which takes two strings and checks that the first uses only the letters in the second, use it to write `uses_all`, which takes two strings and checks whether the first uses all the letters in the second, allowing repeats.\"\n", + "Si te atascaste en la pregunta anterior, prueba a preguntar a un asistente virtual: \"Dada una función, `uses_only`, que recibe dos cadenas y comprueba que la primera usa solo las letras del segundo, úsala para escribir `uses_all`, que recibe dos cadenas y comprueba si la primera usa todas las letras del segundo, permitiendo repeticiones.\"\n", "\n", - "Use `run_doctests` to check the answer." + "Usa `run_doctests` para comprobar la respuesta." ] }, { @@ -1591,13 +1590,13 @@ "id": "18f407b3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now let's see if we can write `uses_all` based on `uses_any`.\n", + "Ahora veamos si podemos escribir `uses_all` basándonos en `uses_any`.\n", "\n", - "Ask a virtual assistant, \"Given a function, `uses_any`, which takes two strings and checks whether the first uses any of the letters in the second, can you use it to write `uses_all`, which takes two strings and checks whether the first uses all the letters in the second, allowing repeats.\"\n", + "Pregunta a un asistente virtual: \"Dada una función, `uses_any`, que recibe dos cadenas y comprueba si la primera usa cualquiera de las letras del segundo, ¿puedes usarla para escribir `uses_all`, que recibe dos cadenas y comprueba si la primera usa todas las letras del segundo, permitiendo repeticiones?\"\n", "\n", - "If it says it can, be sure to test the result!" + "Si dice que puede, ¡asegúrate de probar el resultado!" ] }, { @@ -1649,9 +1648,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap08.ipynb b/chapters/chap08.ipynb index 0108312..c216e66 100644 --- a/chapters/chap08.ipynb +++ b/chapters/chap08.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes comprar versiones impresas y libro electrónico de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,14 +41,14 @@ "id": "9d97603b", "metadata": {}, "source": [ - "# Strings and Regular Expressions\n", + "# Cadenas y expresiones regulares\n", "\n", - "Strings are not like integers, floats, and booleans. A string is a **sequence**, which means it contains multiple values in a particular order.\n", - "In this chapter we'll see how to access the values that make up a string, and we'll use functions that process strings.\n", + "Las cadenas no son como los enteros, los flotantes y los booleanos. Una cadena es una **secuencia**, lo que significa que contiene múltiples valores en un orden particular.\n", + "En este capítulo veremos cómo acceder a los valores que componen una cadena, y usaremos funciones que procesan cadenas.\n", "\n", - "We'll also use regular expressions, which are a powerful tool for finding patterns in a string and performing operations like search and replace.\n", + "También usaremos expresiones regulares, que son una herramienta poderosa para encontrar patrones en una cadena y realizar operaciones como búsqueda y reemplazo.\n", "\n", - "As an exercise, you'll have a chance to apply these tools to a word game called Wordle." + "Como ejercicio, tendrás la oportunidad de aplicar estas herramientas a un juego de palabras llamado Wordle." ] }, { @@ -56,13 +56,13 @@ "id": "1280dd83", "metadata": {}, "source": [ - "## A string is a sequence\n", + "## Una cadena es una secuencia\n", "\n", - "A string is a sequence of characters. A **character** can be a letter (in almost any alphabet), a digit, a punctuation mark, or white space.\n", + "Una cadena es una secuencia de caracteres. Un **carácter** puede ser una letra (en casi cualquier alfabeto), un dígito, un signo de puntuación o un espacio en blanco.\n", "\n", - "You can select a character from a string with the bracket operator.\n", - "This example statement selects character number 1 from `fruit` and\n", - "assigns it to `letter`:" + "Puedes seleccionar un carácter de una cadena con el operador de corchetes.\n", + "Esta sentencia de ejemplo selecciona el carácter número 1 de `fruit` y\n", + "lo asigna a `letter`:" ] }, { @@ -81,8 +81,8 @@ "id": "a307e429", "metadata": {}, "source": [ - "The expression in brackets is an **index**, so called because it *indicates* which character in the sequence to select.\n", - "But the result might not be what you expect." + "La expresión entre corchetes es un **índice**, llamado así porque *indica* qué carácter de la secuencia seleccionar.\n", + "Pero el resultado quizá no sea lo que esperas." ] }, { @@ -100,8 +100,8 @@ "id": "57c13319", "metadata": {}, "source": [ - "The letter with index `1` is actually the second letter of the string.\n", - "An index is an offset from the beginning of the string, so the offset of the first letter is `0`." + "La letra con índice `1` es en realidad la segunda letra de la cadena.\n", + "Un índice es un desplazamiento desde el principio de la cadena, así que el desplazamiento de la primera letra es `0`." ] }, { @@ -119,9 +119,9 @@ "id": "57d8e54c", "metadata": {}, "source": [ - "You can think of `'b'` as the 0th letter of `'banana'` -- pronounced \"zero-eth\".\n", + "Puedes pensar en `'b'` como la letra 0 de `'banana'` -- pronunciada \"ceroésima\".\n", "\n", - "The index in brackets can be a variable." + "El índice entre corchetes puede ser una variable." ] }, { @@ -140,7 +140,7 @@ "id": "9630e2e7", "metadata": {}, "source": [ - "Or an expression that contains variables and operators." + "O una expresión que contiene variables y operadores." ] }, { @@ -158,7 +158,7 @@ "id": "939b602d", "metadata": {}, "source": [ - "But the value of the index has to be an integer -- otherwise you get a `TypeError`." + "Pero el valor del índice tiene que ser un entero -- de lo contrario obtienes un `TypeError`." ] }, { @@ -180,7 +180,7 @@ "id": "3f0f7e3a", "metadata": {}, "source": [ - "As we saw in Chapter 1, we can use the built-in function `len` to get the length of a string." + "Como vimos en el capítulo 1, podemos usar la función integrada `len` para obtener la longitud de una cadena." ] }, { @@ -199,7 +199,7 @@ "id": "29013c47", "metadata": {}, "source": [ - "To get the last letter of a string, you might be tempted to write this:" + "Para obtener la última letra de una cadena, podrías sentir la tentación de escribir esto:" ] }, { @@ -221,7 +221,7 @@ "id": "b87e09bd", "metadata": {}, "source": [ - "But that causes an `IndexError` because there is no letter in `'banana'` with the index 6. Because we started counting at `0`, the six letters are numbered `0` to `5`. To get the last character, you have to subtract `1` from `n`:" + "Pero eso causa un `IndexError` porque no hay ninguna letra en `'banana'` con el índice 6. Como empezamos a contar en `0`, las seis letras están numeradas de `0` a `5`. Para obtener el último carácter, tienes que restar `1` a `n`:" ] }, { @@ -239,8 +239,8 @@ "id": "3c79dcec", "metadata": {}, "source": [ - "But there's an easier way.\n", - "To get the last letter in a string, you can use a negative index, which counts backward from the end. " + "Pero hay una forma más sencilla.\n", + "Para obtener la última letra de una cadena, puedes usar un índice negativo, que cuenta hacia atrás desde el final." ] }, { @@ -258,7 +258,7 @@ "id": "5677b727", "metadata": {}, "source": [ - "The index `-1` selects the last letter, `-2` selects the second to last, and so on." + "El índice `-1` selecciona la última letra, `-2` selecciona la penúltima, y así sucesivamente." ] }, { @@ -266,10 +266,10 @@ "id": "8392a12a", "metadata": {}, "source": [ - "## String slices\n", + "## Segmentos de cadenas\n", "\n", - "A segment of a string is called a **slice**.\n", - "Selecting a slice is similar to selecting a character." + "Un segmento de una cadena se llama **segmento**.\n", + "Seleccionar un segmento es similar a seleccionar un carácter." ] }, { @@ -288,9 +288,9 @@ "id": "5cc12531", "metadata": {}, "source": [ - "The operator `[n:m]` returns the part of the string from the `n`th\n", - "character to the `m`th character, including the first but excluding the second.\n", - "This behavior is counterintuitive, but it might help to imagine the indices pointing *between* the characters, as in this figure:" + "El operador `[n:m]` devuelve la parte de la cadena desde el carácter `n`-ésimo\n", + "hasta el carácter `m`-ésimo, incluyendo el primero pero excluyendo el segundo.\n", + "Este comportamiento es contraintuitivo, pero puede ayudar imaginar que los índices apuntan *entre* los caracteres, como en esta figura:" ] }, { @@ -348,10 +348,10 @@ "id": "c391abbf", "metadata": {}, "source": [ - "For example, the slice `[3:6]` selects the letters `ana`, which means that `6` is legal as part of a slice, but not legal as an index.\n", + "Por ejemplo, el segmento `[3:6]` selecciona las letras `ana`, lo que significa que `6` es legal como parte de un segmento, pero no como índice.\n", "\n", "\n", - "If you omit the first index, the slice starts at the beginning of the string." + "Si omites el primer índice, el segmento empieza al principio de la cadena." ] }, { @@ -369,7 +369,7 @@ "id": "1bd7dcb1", "metadata": {}, "source": [ - "If you omit the second index, the slice goes to the end of the string:" + "Si omites el segundo índice, el segmento va hasta el final de la cadena:" ] }, { @@ -387,7 +387,7 @@ "id": "4701123b", "metadata": {}, "source": [ - "If the first index is greater than or equal to the second, the result is an **empty string**, represented by two quotation marks:" + "Si el primer índice es mayor o igual que el segundo, el resultado es una **cadena vacía**, representado por dos comillas:" ] }, { @@ -405,10 +405,10 @@ "id": "d12735ab", "metadata": {}, "source": [ - "An empty string contains no characters and has length 0.\n", + "Una cadena vacío no contiene caracteres y tiene longitud 0.\n", "\n", - "Continuing this example, what do you think `fruit[:]` means? Try it and\n", - "see." + "Continuando con este ejemplo, ¿qué crees que significa `fruit[:]`? Pruébalo y\n", + "mira." ] }, { @@ -428,10 +428,10 @@ "id": "918d3dd0", "metadata": {}, "source": [ - "## Strings are immutable\n", + "## Las cadenas son inmutables\n", "\n", - "It is tempting to use the `[]` operator on the left side of an\n", - "assignment, with the intention of changing a character in a string, like this:" + "Es tentador usar el operador `[]` en el lado izquierdo de una\n", + "asignación, con la intención de cambiar un carácter en una cadena, así:" ] }, { @@ -454,13 +454,13 @@ "id": "df3dd7d1", "metadata": {}, "source": [ - "The result is a `TypeError`.\n", - "In the error message, the \"object\" is the string and the \"item\" is the character\n", - "we tried to assign.\n", - "For now, an **object** is the same thing as a value, but we will refine that definition later.\n", + "El resultado es un `TypeError`.\n", + "En el mensaje de error, el \"objeto\" es la cadena y el \"item\" es el carácter\n", + "que intentamos asignar.\n", + "Por ahora, un **objeto** es lo mismo que un valor, pero refinaremos esa definición más adelante.\n", "\n", - "The reason for this error is that strings are **immutable**, which means you can't change an existing string.\n", - "The best you can do is create a new string that is a variation of the original." + "La razón de este error es que las cadenas son **inmutables**, lo que significa que no puedes cambiar una cadena existente.\n", + "Lo máximo que puedes hacer es crear una cadena nueva que sea una variación del original." ] }, { @@ -479,8 +479,8 @@ "id": "2848546f", "metadata": {}, "source": [ - "This example concatenates a new first letter onto a slice of `greeting`.\n", - "It has no effect on the original string." + "Este ejemplo concatena una nueva primera letra con un segmento de `greeting`.\n", + "No tiene ningún efecto sobre la cadena original." ] }, { @@ -498,10 +498,10 @@ "id": "49e4da57", "metadata": {}, "source": [ - "## String comparison\n", + "## Comparación de cadenas\n", "\n", - "The relational operators work on strings. To see if two strings are\n", - "equal, we can use the `==` operator." + "Los operadores relacionales funcionan con cadenas. Para ver si dos cadenas son\n", + "iguales, podemos usar el operador `==`." ] }, { @@ -522,8 +522,7 @@ "id": "e9be6097", "metadata": {}, "source": [ - "Other relational operations are useful for putting words in alphabetical\n", - "order:" + "Otras operaciones relacionales son útiles para poner palabras en orden alfabético:" ] }, { @@ -557,9 +556,9 @@ "id": "b66f449a", "metadata": {}, "source": [ - "Python does not handle uppercase and lowercase letters the same way\n", - "people do. All the uppercase letters come before all the lowercase\n", - "letters, so:" + "Python no trata las letras mayúsculas y minúsculas de la misma manera que\n", + "lo hacen las personas. Todas las letras mayúsculas van antes que todas las\n", + "minúsculas, así que:" ] }, { @@ -577,8 +576,8 @@ "id": "f9b916c9", "metadata": {}, "source": [ - "To solve this problem, we can convert strings to a standard format, such as all lowercase, before performing the comparison.\n", - "Keep that in mind if you have to defend yourself against a man armed with a Pineapple." + "Para resolver este problema, podemos convertir las cadenas a un formato estándar, como todo en minúsculas, antes de realizar la comparación.\n", + "Tenlo en cuenta si tienes que defenderte de un hombre armado con una piña." ] }, { @@ -586,13 +585,13 @@ "id": "531069f1", "metadata": {}, "source": [ - "## String methods\n", + "## Métodos de cadenas\n", "\n", - "Strings provide methods that perform a variety of useful operations. \n", - "A method is similar to a function -- it takes arguments and returns a value -- but the syntax is different.\n", - "For example, the method `upper` takes a string and returns a new string with all uppercase letters.\n", + "Las cadenas proporcionan métodos que realizan una variedad de operaciones útiles.\n", + "Un método es similar a una función -- recibe argumentos y devuelve un valor -- pero la sintaxis es diferente.\n", + "Por ejemplo, el método `upper` recibe una cadena y devuelve una cadena nueva con todas las letras en mayúsculas.\n", "\n", - "Instead of the function syntax `upper(word)`, it uses the method syntax `word.upper()`." + "En lugar de la sintaxis de función `upper(word)`, usa la sintaxis de método `word.upper()`." ] }, { @@ -612,10 +611,10 @@ "id": "1ac41744", "metadata": {}, "source": [ - "This use of the dot operator specifies the name of the method, `upper`, and the name of the string to apply the method to, `word`.\n", - "The empty parentheses indicate that this method takes no arguments.\n", + "Este uso del operador punto especifica el nombre del método, `upper`, y el nombre de la cadena al que aplicar el método, `word`.\n", + "Los paréntesis vacíos indican que este método no toma argumentos.\n", "\n", - "A method call is called an **invocation**; in this case, we would say that we are invoking `upper` on `word`." + "Una llamada a método se llama **invocación**; en este caso, diríamos que estamos invocando `upper` sobre `word`." ] }, { @@ -625,10 +624,10 @@ "tags": [] }, "source": [ - "## Writing files\n", + "## Escribir archivos\n", "\n", - "String operators and methods are useful for reading and writing text files.\n", - "As an example, we'll work with the text of *Dracula*, a novel by Bram Stoker that is available from Project Gutenberg ()." + "Los operadores y métodos de cadena son útiles para leer y escribir archivos de texto.\n", + "Como ejemplo, trabajaremos con el texto de *Dracula*, una novela de Bram Stoker que está disponible en Project Gutenberg ()." ] }, { @@ -651,7 +650,7 @@ "id": "963dda79", "metadata": {}, "source": [ - "I've downloaded the book in a plain text file called `pg345.txt`, which we can open for reading like this:" + "He descargado el libro en un archivo de texto plano llamado `pg345.txt`, que podemos abrir para lectura así:" ] }, { @@ -669,11 +668,11 @@ "id": "b5d99e8c", "metadata": {}, "source": [ - "In addition to the text of the book, this file contains a section at the beginning with information about the book and a section at the end with information about the license.\n", - "Before we process the text, we can remove this extra material by finding the special lines at the beginning and end that begin with `'***'`.\n", + "Además del texto del libro, este archivo contiene una sección al principio con información sobre el libro y una sección al final con información sobre la licencia.\n", + "Antes de procesar el texto, podemos eliminar este material extra encontrando las líneas especiales al principio y al final que empiezan con `'***'`.\n", "\n", - "The following function takes a line and checks whether it is one of the special lines.\n", - "It uses the `startswith` method, which checks whether a string starts with a given sequence of characters." + "La siguiente función recibe una línea y comprueba si es una de las líneas especiales.\n", + "Usa el método `startswith`, que comprueba si una cadena empieza con una secuencia determinada de caracteres." ] }, { @@ -692,7 +691,7 @@ "id": "2efdfe35", "metadata": {}, "source": [ - "We can use this function to loop through the lines in the file and print only the special lines." + "Podemos usar esta función para recorrer las líneas del archivo e imprimir solo las líneas especiales." ] }, { @@ -712,9 +711,9 @@ "id": "07fb5992", "metadata": {}, "source": [ - "Now let's create a new file, called `pg345_cleaned.txt`, that contains only the text of the book.\n", - "In order to loop through the book again, we have to open it again for reading.\n", - "And, to write a new file, we can open it for writing." + "Ahora creemos un archivo nuevo, llamado `pg345_cleaned.txt`, que contenga solo el texto del libro.\n", + "Para recorrer el libro de nuevo, tenemos que abrirlo otra vez para lectura.\n", + "Y, para escribir un archivo nuevo, podemos abrirlo para escritura." ] }, { @@ -733,10 +732,10 @@ "id": "96d881aa", "metadata": {}, "source": [ - "`open` takes an optional parameters that specifies the \"mode\" -- in this example, `'w'` indicates that we're opening the file for writing.\n", - "If the file doesn't exist, it will be created; if it already exists, the contents will be replaced.\n", + "`open` recibe un parámetro opcional que especifica el \"modo\" -- en este ejemplo, `'w'` indica que estamos abriendo el archivo para escritura.\n", + "Si el archivo no existe, se creará; si ya existe, el contenido será reemplazado.\n", "\n", - "As a first step, we'll loop through the file until we find the first special line." + "Como primer paso, recorreremos el archivo hasta encontrar la primera línea especial." ] }, { @@ -756,9 +755,9 @@ "id": "1989d5a1", "metadata": {}, "source": [ - "The `break` statement \"breaks\" out of the loop -- that is, it causes the loop to end immediately, before we get to the end of the file.\n", + "La sentencia `break` \"rompe\" el bucle -- es decir, hace que el bucle termine inmediatamente, antes de llegar al final del archivo.\n", "\n", - "When the loop exits, `line` contains the special line that made the conditional true." + "Cuando el bucle termina, `line` contiene la línea especial que hizo que la condición fuera verdadera." ] }, { @@ -776,11 +775,11 @@ "id": "9f28c3b4", "metadata": {}, "source": [ - "Because `reader` keeps track of where it is in the file, we can use a second loop to pick up where we left off.\n", + "Como `reader` lleva la cuenta de en qué parte del archivo está, podemos usar un segundo bucle para continuar donde lo dejamos.\n", "\n", - "The following loop reads the rest of the file, one line at a time.\n", - "When it finds the special line that indicates the end of the text, it breaks out of the loop.\n", - "Otherwise, it writes the line to the output file." + "El siguiente bucle lee el resto del archivo, una línea cada vez.\n", + "Cuando encuentra la línea especial que indica el final del texto, rompe el bucle.\n", + "En caso contrario, escribe la línea en el archivo de salida." ] }, { @@ -801,7 +800,7 @@ "id": "c07032a4", "metadata": {}, "source": [ - "When this loop exits, `line` contains the second special line." + "Cuando este bucle termina, `line` contiene la segunda línea especial." ] }, { @@ -819,8 +818,8 @@ "id": "0c30b41c", "metadata": {}, "source": [ - "At this point `reader` and `writer` are still open, which means we could keep reading lines from `reader` or writing lines to `writer`.\n", - "To indicate that we're done, we can close both files by invoking the `close` method." + "En este punto `reader` y `writer` siguen abiertos, lo que significa que podríamos seguir leyendo líneas de `reader` o escribiendo líneas en `writer`.\n", + "Para indicar que hemos terminado, podemos cerrar ambos archivos invocando el método `close`." ] }, { @@ -839,7 +838,7 @@ "id": "d5084cdc", "metadata": {}, "source": [ - "To check whether this process was successful, we can read the first few lines from the new file we just created." + "Para comprobar si este proceso tuvo éxito, podemos leer las primeras líneas del archivo nuevo que acabamos de crear." ] }, { @@ -862,7 +861,7 @@ "id": "34c93df3", "metadata": {}, "source": [ - "The `endswith` method checks whether a string ends with a given sequence of characters." + "El método `endswith` comprueba si una cadena termina con una secuencia determinada de caracteres." ] }, { @@ -870,12 +869,12 @@ "id": "fcdb4bbf", "metadata": {}, "source": [ - "## Find and replace\n", + "## Buscar y reemplazar\n", "\n", - "In the Icelandic translation of *Dracula* from 1901, the name of one of the characters was changed from \"Jonathan\" to \"Thomas\".\n", - "To make this change in the English version, we can loop through the book, use the `replace` method to replace one name with another, and write the result to a new file.\n", + "En la traducción islandesa de *Dracula* de 1901, el nombre de uno de los personajes se cambió de \"Jonathan\" a \"Thomas\".\n", + "Para hacer este cambio en la versión inglesa, podemos recorrer el libro, usar el método `replace` para reemplazar un nombre por otro y escribir el resultado en un archivo nuevo.\n", "\n", - "We'll start by counting the lines in the cleaned version of the file." + "Empezaremos contando las líneas en la versión limpia del archivo." ] }, { @@ -897,7 +896,7 @@ "id": "8ba9b9ca", "metadata": {}, "source": [ - "To see whether a line contains \"Jonathan\", we can use the `in` operator, which checks whether this sequence of characters appears anywhere in the line." + "Para ver si una línea contiene \"Jonathan\", podemos usar el operador `in`, que comprueba si esta secuencia de caracteres aparece en cualquier parte de la línea." ] }, { @@ -920,8 +919,8 @@ "id": "27805245", "metadata": {}, "source": [ - "There are 199 lines that contain the name, but that's not quite the total number of times it appears, because it can appear more than once in a line.\n", - "To get the total, we can use the `count` method, which returns the number of times a sequence appears in a string." + "Hay 199 líneas que contienen el nombre, pero ese no es exactamente el número total de veces que aparece, porque puede aparecer más de una vez en una línea.\n", + "Para obtener el total, podemos usar el método `count`, que devuelve el número de veces que una secuencia aparece en una cadena." ] }, { @@ -943,7 +942,7 @@ "id": "68026797", "metadata": {}, "source": [ - "Now we can replace `'Jonathan'` with `'Thomas'` like this:" + "Ahora podemos reemplazar `'Jonathan'` por `'Thomas'` así:" ] }, { @@ -965,7 +964,7 @@ "id": "57ba56f3", "metadata": {}, "source": [ - "The result is a new file called `pg345_replaced.txt` that contains a version of *Dracula* where Jonathan Harker is called Thomas." + "El resultado es un archivo nuevo llamado `pg345_replaced.txt` que contiene una versión de *Dracula* donde Jonathan Harker se llama Thomas." ] }, { @@ -989,15 +988,15 @@ "id": "cc9af187", "metadata": {}, "source": [ - "## Regular expressions\n", + "## Expresiones regulares\n", "\n", - "If we know exactly what sequence of characters we're looking for, we can use the `in` operator to find it and the `replace` method to replace it.\n", - "But there is another tool, called a **regular expression** that can also perform these operations -- and a lot more.\n", + "Si sabemos exactamente qué secuencia de caracteres estamos buscando, podemos usar el operador `in` para encontrarla y el método `replace` para reemplazarla.\n", + "Pero hay otra herramienta, llamada **expresión regular**, que también puede realizar estas operaciones -- y muchas más.\n", "\n", - "To demonstrate, I'll start with a simple example and we'll work our way up.\n", - "Suppose, again, that we want to find all lines that contain a particular word.\n", - "For a change, let's look for references to the titular character of the book, Count Dracula.\n", - "Here's a line that mentions him." + "Para demostrarlo, empezaré con un ejemplo sencillo y avanzaremos poco a poco.\n", + "Supongamos, otra vez, que queremos encontrar todas las líneas que contienen una palabra concreta.\n", + "Para variar, busquemos referencias al personaje titular del libro, el conde Dracula.\n", + "Aquí tienes una línea que lo menciona." ] }, { @@ -1015,7 +1014,7 @@ "id": "d4fd6d11", "metadata": {}, "source": [ - "And here's the **pattern** we'll use to search." + "Y aquí está el **patrón** que usaremos para buscar." ] }, { @@ -1033,8 +1032,8 @@ "id": "268f647c", "metadata": {}, "source": [ - "A module called `re` provides functions related to regular expressions.\n", - "We can import it like this and use the `search` function to check whether the pattern appears in the text." + "Un módulo llamado `re` proporciona funciones relacionadas con expresiones regulares.\n", + "Podemos importarlo así y usar la función `search` para comprobar si el patrón aparece en el texto." ] }, { @@ -1055,8 +1054,8 @@ "id": "e17f6731", "metadata": {}, "source": [ - "If the pattern appears in the text, `search` returns a `Match` object that contains the results of the search.\n", - "Among other information, it has a variable named `string` that contains the text that was searched." + "Si el patrón aparece en el texto, `search` devuelve un objeto `Match` que contiene los resultados de la búsqueda.\n", + "Entre otra información, tiene una variable llamada `string` que contiene el texto en el que se buscó." ] }, { @@ -1074,7 +1073,7 @@ "id": "a8eab0f6", "metadata": {}, "source": [ - "It also provides a method called `group` that returns the part of the text that matched the pattern." + "También proporciona un método llamado `group` que devuelve la parte del texto que coincidió con el patrón." ] }, { @@ -1092,7 +1091,7 @@ "id": "b6962a7d", "metadata": {}, "source": [ - "And it provides a method called `span` that returns the index in the text where the pattern starts and ends." + "Y proporciona un método llamado `span` que devuelve el índice en el texto donde empieza y termina el patrón." ] }, { @@ -1110,7 +1109,7 @@ "id": "8f1e5261", "metadata": {}, "source": [ - "If the pattern doesn't appear in the text, the return value from `search` is `None`." + "Si el patrón no aparece en el texto, el valor de retorno de `search` es `None`." ] }, { @@ -1129,7 +1128,7 @@ "id": "d5ed33ff", "metadata": {}, "source": [ - "So we can check whether the search was successful by checking whether the result is `None`." + "Así que podemos comprobar si la búsqueda tuvo éxito comprobando si el resultado es `None`." ] }, { @@ -1147,7 +1146,7 @@ "id": "a08e38f6", "metadata": {}, "source": [ - "Putting all that together, here's a function that loops through the lines in the book until it finds one that matches the given pattern, and returns the `Match` object." + "Juntando todo eso, aquí tienes una función que recorre las líneas del libro hasta encontrar una que coincida con el patrón dado, y devuelve el objeto `Match`." ] }, { @@ -1169,7 +1168,7 @@ "id": "96570515", "metadata": {}, "source": [ - "We can use it to find the first mention of a character." + "Podemos usarla para encontrar la primera mención de un personaje." ] }, { @@ -1188,12 +1187,12 @@ "id": "3f687fdc", "metadata": {}, "source": [ - "For this example, we didn't have to use regular expressions -- we could have done the same thing more easily with the `in` operator.\n", - "But regular expressions can do things the `in` operator cannot.\n", + "Para este ejemplo, no tuvimos que usar expresiones regulares -- podríamos haber hecho lo mismo más fácilmente con el operador `in`.\n", + "Pero las expresiones regulares pueden hacer cosas que el operador `in` no puede.\n", "\n", - "For example, if the pattern includes the vertical bar character, `'|'`, it can match either the sequence on the left or the sequence on the right.\n", - "Suppose we want to find the first mention of Mina Murray in the book, but we are not sure whether she is referred to by first name or last.\n", - "We can use the following pattern, which matches either name." + "Por ejemplo, si el patrón incluye el carácter de barra vertical, `'|'`, puede coincidir con la secuencia de la izquierda o con la secuencia de la derecha.\n", + "Supongamos que queremos encontrar la primera mención de Mina Murray en el libro, pero no estamos seguros de si se la menciona por su nombre o por su apellido.\n", + "Podemos usar el siguiente patrón, que coincide con cualquiera de los dos nombres." ] }, { @@ -1213,8 +1212,8 @@ "id": "8bea66a6", "metadata": {}, "source": [ - "We can use a pattern like this to see how many times a character is mentioned by either name.\n", - "Here's a function that loops through the book and counts the number of lines that match the given pattern." + "Podemos usar un patrón como este para ver cuántas veces se menciona a un personaje por cualquiera de los dos nombres.\n", + "Aquí tienes una función que recorre el libro y cuenta el número de líneas que coinciden con el patrón dado." ] }, { @@ -1238,7 +1237,7 @@ "id": "0e753a5b", "metadata": {}, "source": [ - "Now let's see how many times Mina is mentioned." + "Ahora veamos cuántas veces se menciona a Mina." ] }, { @@ -1256,7 +1255,7 @@ "id": "780c9fab", "metadata": {}, "source": [ - "The special character `'^'` matches the beginning of a string, so we can find a line that starts with a given pattern." + "El carácter especial `'^'` coincide con el principio de una cadena, así que podemos encontrar una línea que empieza con un patrón dado." ] }, { @@ -1275,7 +1274,7 @@ "id": "332bad2e", "metadata": {}, "source": [ - "And the special character `'$'` matches the end of a string, so we can find a line that ends with a given pattern (ignoring the newline at the end)." + "Y el carácter especial `'$'` coincide con el final de una cadena, así que podemos encontrar una línea que termina con un patrón dado (ignorando el salto de línea del final)." ] }, { @@ -1294,11 +1293,11 @@ "id": "d4b22b6e", "metadata": {}, "source": [ - "## String substitution\n", + "## Sustitución de cadenas\n", "\n", - "Bram Stoker was born in Ireland, and when *Dracula* was published in 1897, he was living in England.\n", - "So we would expect him to use the British spelling of words like \"centre\" and \"colour\".\n", - "To check, we can use the following pattern, which matches either \"centre\" or the American spelling \"center\"." + "Bram Stoker nació en Irlanda, y cuando *Dracula* se publicó en 1897, vivía en Inglaterra.\n", + "Así que esperaríamos que usara la ortografía británica de palabras como \"centre\" y \"colour\".\n", + "Para comprobarlo, podemos usar el siguiente patrón, que coincide con \"centre\" o con la ortografía estadounidense \"center\"." ] }, { @@ -1316,8 +1315,8 @@ "id": "35abfd7d", "metadata": {}, "source": [ - "In this pattern, the parentheses enclose the part of the pattern the vertical bar applies to.\n", - "So this pattern matches a sequence that starts with `'cent'` and ends with either `'er'` or `'re'`." + "En este patrón, los paréntesis encierran la parte del patrón a la que se aplica la barra vertical.\n", + "Así que este patrón coincide con una secuencia que empieza con `'cent'` y termina con `'er'` o con `'re'`." ] }, { @@ -1336,10 +1335,10 @@ "id": "e5703c18", "metadata": {}, "source": [ - "As expected, he used the British spelling.\n", + "Como esperábamos, usó la ortografía británica.\n", "\n", - "We can also check whether he used the British spelling of \"colour\".\n", - "The following pattern uses the special character `'?'`, which means that the previous character is optional." + "También podemos comprobar si usó la ortografía británica de \"colour\".\n", + "El siguiente patrón usa el carácter especial `'?'`, que significa que el carácter anterior es opcional." ] }, { @@ -1357,7 +1356,7 @@ "id": "beed9a7b", "metadata": {}, "source": [ - "This pattern matches either \"colour\" with the `'u'` or \"color\" without it." + "Este patrón coincide con \"colour\" con la `'u'` o con \"color\" sin ella." ] }, { @@ -1377,10 +1376,10 @@ "id": "1a31f179", "metadata": {}, "source": [ - "Again, as expected, he used the British spelling.\n", + "De nuevo, como esperábamos, usó la ortografía británica.\n", "\n", - "Now suppose we want to produce an edition of the book with American spellings.\n", - "We can use the `sub` function in the `re` module, which does **string substitution**." + "Ahora supongamos que queremos producir una edición del libro con ortografía estadounidense.\n", + "Podemos usar la función `sub` del módulo `re`, que hace **sustitución de cadenas**." ] }, { @@ -1398,8 +1397,8 @@ "id": "04a80fc6", "metadata": {}, "source": [ - "The first argument is the pattern we want to find and replace, the second is what we want to replace it with, and the third is the string we want to search.\n", - "In the result, you can see that \"colour\" has been replaced with \"color\"." + "El primer argumento es el patrón que queremos encontrar y reemplazar, el segundo es aquello con lo que queremos reemplazarlo, y el tercero es la cadena en el que queremos buscar.\n", + "En el resultado, puedes ver que \"colour\" ha sido reemplazado por \"color\"." ] }, { @@ -1441,11 +1440,11 @@ "id": "0318507d", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "When you are reading and writing files, debugging can be tricky.\n", - "If you are working in a Jupyter notebook, you can use **shell commands** to help.\n", - "For example, to display the first few lines of a file, you can use the command `!head`, like this:" + "Cuando lees y escribes archivos, depurar puede ser complicado.\n", + "Si trabajas en un Jupyter notebook, puedes usar **comandos de shell** para ayudar.\n", + "Por ejemplo, para mostrar las primeras líneas de un archivo, puedes usar el comando `!head`, así:" ] }, { @@ -1465,8 +1464,8 @@ "id": "1d480c02", "metadata": {}, "source": [ - "The initial exclamation point, `!`, indicates that this is a shell command, which is not part of Python.\n", - "To display the last few lines, you can use `!tail`." + "El signo de exclamación inicial, `!`, indica que esto es un comando de shell, que no forma parte de Python.\n", + "Para mostrar las últimas líneas, puedes usar `!tail`." ] }, { @@ -1486,10 +1485,10 @@ "id": "6874023a", "metadata": {}, "source": [ - "When you are working with large files, debugging can be difficult because there might be too much output to check by hand.\n", - "A good debugging strategy is to start with just part of the file, get the program working, and then run it with the whole file.\n", + "Cuando trabajas con archivos grandes, depurar puede ser difícil porque puede haber demasiada salida para revisarla a mano.\n", + "Una buena estrategia de depuración es empezar con solo una parte del archivo, hacer que el programa funcione, y luego ejecutarlo con el archivo completo.\n", "\n", - "To make a small file that contains part of a larger file, we can use `!head` again with the redirect operator, `>`, which indicates that the results should be written to a file rather than displayed." + "Para crear un archivo pequeño que contenga parte de un archivo más grande, podemos usar `!head` de nuevo con el operador de redirección, `>`, que indica que los resultados deben escribirse en un archivo en lugar de mostrarse." ] }, { @@ -1507,7 +1506,7 @@ "id": "3fc851f8", "metadata": {}, "source": [ - "By default, `!head` reads the first 10 lines, but it takes an optional argument that indicates the number of lines to read." + "Por defecto, `!head` lee las primeras 10 líneas, pero recibe un argumento opcional que indica el número de líneas a leer." ] }, { @@ -1525,11 +1524,11 @@ "id": "24871c78", "metadata": {}, "source": [ - "This shell command reads the first 100 lines from `pg345_cleaned.txt` and writes them to a file called `pg345_cleaned_100_lines.txt`.\n", + "Este comando de shell lee las primeras 100 líneas de `pg345_cleaned.txt` y las escribe en un archivo llamado `pg345_cleaned_100_lines.txt`.\n", "\n", - "Note: The shell commands `!head` and `!tail` are not available on all operating systems.\n", - "If they don't work for you, we can write similar functions in Python.\n", - "See the first exercise at the end of this chapter for suggestions." + "Nota: Los comandos de shell `!head` y `!tail` no están disponibles en todos los sistemas operativos.\n", + "Si no te funcionan, podemos escribir funciones similares en Python.\n", + "Consulta el primer ejercicio al final de este capítulo para ver sugerencias." ] }, { @@ -1537,43 +1536,43 @@ "id": "c842524d", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**sequence:**\n", - " An ordered collection of values where each value is identified by an integer index.\n", + "**secuencia:**\n", + " Una colección ordenada de valores donde cada valor se identifica mediante un índice entero.\n", "\n", - "**character:**\n", - "An element of a string, including letters, numbers, and symbols.\n", + "**carácter:**\n", + "Un elemento de una cadena, incluidas letras, números y símbolos.\n", "\n", - "**index:**\n", - " An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from `0`.\n", + "**índice:**\n", + " Un valor entero usado para seleccionar un elemento en una secuencia, como un carácter en una cadena. En Python los índices empiezan desde `0`.\n", "\n", - "**slice:**\n", - " A part of a string specified by a range of indices.\n", + "**segmento:**\n", + " Una parte de una cadena especificada por un rango de índices.\n", "\n", - "**empty string:**\n", - "A string that contains no characters and has length `0`.\n", + "**cadena vacía:**\n", + "Una cadena que no contiene caracteres y tiene longitud `0`.\n", "\n", - "**object:**\n", - " Something a variable can refer to. An object has a type and a value.\n", + "**objeto:**\n", + " Algo a lo que una variable puede referirse. Un objeto tiene un tipo y un valor.\n", "\n", - "**immutable:**\n", - "If the elements of an object cannot be changed, the object is immutable.\n", + "**inmutable:**\n", + "Si los elementos de un objeto no se pueden cambiar, el objeto es inmutable.\n", "\n", - "**invocation:**\n", - " An expression -- or part of an expression -- that calls a method.\n", + "**invocación:**\n", + " Una expresión -- o parte de una expresión -- que llama a un método.\n", "\n", - "**regular expression:**\n", - "A sequence of characters that defines a search pattern.\n", + "**expresión regular:**\n", + "Una secuencia de caracteres que define un patrón de búsqueda.\n", "\n", - "**pattern:**\n", - "A rule that specifies the requirements a string has to meet to constitute a match.\n", + "**patrón:**\n", + "Una regla que especifica los requisitos que una cadena debe cumplir para constituir una coincidencia.\n", "\n", - "**string substitution:**\n", - "Replacement of a string, or part of a string, with another string.\n", + "**sustitución de cadenas:**\n", + "Reemplazo de una cadena, o parte de una cadena, por otra cadena.\n", "\n", - "**shell command:**\n", - "A statement in a shell language, which is a language used to interact with an operating system." + "**comando de shell:**\n", + "Una sentencia en un lenguaje de shell, que es un lenguaje usado para interactuar con un sistema operativo." ] }, { @@ -1581,7 +1580,7 @@ "id": "4306e765", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1616,24 +1615,24 @@ "id": "5be97ddc", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, we only scratched the surface of what regular expressions can do.\n", - "To get an idea of what's possible, ask a virtual assistant, \"What are the most common special characters used in Python regular expressions?\"\n", + "En este capítulo, apenas hemos arañado la superficie de lo que pueden hacer las expresiones regulares.\n", + "Para hacerte una idea de lo que es posible, pregunta a un asistente virtual: \"¿Cuáles son los caracteres especiales más comunes que se usan en las expresiones regulares de Python?\"\n", "\n", - "You can also ask for a pattern that matches particular kinds of strings.\n", - "For example, try asking:\n", + "También puedes pedir un patrón que coincida con tipos concretos de cadenas.\n", + "Por ejemplo, prueba a preguntar:\n", "\n", - "* Write a Python regular expression that matches a 10-digit phone number with hyphens.\n", + "* Escribe una expresión regular de Python que coincida con un número de teléfono de 10 dígitos con guiones.\n", "\n", - "* Write a Python regular expression that matches a street address with a number and a street name, followed by `ST` or `AVE`.\n", + "* Escribe una expresión regular de Python que coincida con una dirección con un número y un nombre de calle, seguida de `ST` o `AVE`.\n", "\n", - "* Write a Python regular expression that matches a full name with any common title like `Mr` or `Mrs` followed by any number of names beginning with capital letters, possibly with hyphens between some names.\n", + "* Escribe una expresión regular de Python que coincida con un nombre completo con cualquier título común como `Mr` o `Mrs`, seguido de cualquier número de nombres que empiecen con mayúsculas, posiblemente con guiones entre algunos nombres.\n", "\n", - "And if you want to see something more complicated, try asking for a regular expression that matches any legal URL.\n", + "Y si quieres ver algo más complicado, prueba a pedir una expresión regular que coincida con cualquier URL legal.\n", "\n", - "A regular expression often has the letter `r` before the quotation mark, which indicates that it is a \"raw string\".\n", - "For more information, ask a virtual assistant, \"What is a raw string in Python?\"" + "Una expresión regular a menudo tiene la letra `r` antes de la comilla, lo que indica que es una \"cadena sin procesar\".\n", + "Para más información, pregunta a un asistente virtual: \"¿Qué es una cadena sin procesar en Python?\"" ] }, { @@ -1656,13 +1655,13 @@ "id": "20dcbbb3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "See if you can write a function that does the same thing as the shell command `!head`.\n", - "It should take as arguments the name of a file to read, the number of lines to read, and the name of the file to write the lines into.\n", - "If the third parameter is `None`, it should display the lines rather than write them to a file.\n", + "Mira si puedes escribir una función que haga lo mismo que el comando de shell `!head`.\n", + "Debe recibir como argumentos el nombre de un archivo que leer, el número de líneas que leer y el nombre del archivo donde escribir las líneas.\n", + "Si el tercer parámetro es `None`, debe mostrar las líneas en lugar de escribirlas en un archivo.\n", "\n", - "Consider asking a virtual assistant for help, but if you do, tell it not to use a `with` statement or a `try` statement." + "Considera pedir ayuda a un asistente virtual, pero si lo haces, dile que no use una sentencia `with` ni una sentencia `try`." ] }, { @@ -1682,7 +1681,7 @@ "tags": [] }, "source": [ - "You can use the following examples to test your function." + "Puedes usar los siguientes ejemplos para probar tu función." ] }, { @@ -1726,18 +1725,18 @@ "id": "adb78357", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "\"Wordle\" is an online word game where the objective is to guess a five-letter word in six or fewer attempts.\n", - "Each attempt has to be recognized as a word, not including proper nouns.\n", - "After each attempt, you get information about which of the letters you guessed appear in the target word, and which ones are in the correct position.\n", + "\"Wordle\" es un juego de palabras online donde el objetivo es adivinar una palabra de cinco letras en seis intentos o menos.\n", + "Cada intento tiene que ser reconocido como una palabra, sin incluir nombres propios.\n", + "Después de cada intento, obtienes información sobre cuáles de las letras que adivinaste aparecen en la palabra objetivo, y cuáles están en la posición correcta.\n", "\n", - "For example, suppose the target word is `MOWER` and you guess `TRIED`.\n", - "You would learn that `E` is in the word and in the correct position, `R` is in the word but not in the correct position, and `T`, `I`, and `D` are not in the word.\n", + "Por ejemplo, supongamos que la palabra objetivo es `MOWER` y que intentas `TRIED`.\n", + "Aprenderías que `E` está en la palabra y en la posición correcta, `R` está en la palabra pero no en la posición correcta, y `T`, `I` y `D` no están en la palabra.\n", "\n", - "As a different example, suppose you have guessed the words `SPADE` and `CLERK`, and you've learned that `E` is in the word, but not in either of those positions, and none of the other letters appear in the word.\n", - "Of the words in the word list, how many could be the target word?\n", - "Write a function called `check_word` that takes a five-letter word and checks whether it could be the target word, given these guesses." + "Como ejemplo distinto, supongamos que has intentado las palabras `SPADE` y `CLERK`, y has aprendido que `E` está en la palabra, pero no en ninguna de esas posiciones, y que ninguna de las otras letras aparece en la palabra.\n", + "De las palabras de la lista, ¿cuántas podrían ser la palabra objetivo?\n", + "Escribe una función llamada `check_word` que reciba una palabra de cinco letras y compruebe si podría ser la palabra objetivo, dadas estas conjeturas." ] }, { @@ -1755,7 +1754,7 @@ "id": "87fdf676", "metadata": {}, "source": [ - "You can use any of the functions from the previous chapter, like `uses_any`." + "Puedes usar cualquiera de las funciones del capítulo anterior, como `uses_any`." ] }, { @@ -1781,7 +1780,7 @@ "tags": [] }, "source": [ - "You can use the following loop to test your function." + "Puedes usar el siguiente bucle para probar tu función." ] }, { @@ -1804,9 +1803,9 @@ "id": "d009cb52", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Continuing the previous exercise, suppose you guess the work `TOTEM` and learn that the `E` is *still* not in the right place, but the `M` is. How many words are left?" + "Continuando con el ejercicio anterior, supongamos que intentas la palabra `TOTEM` y aprendes que la `E` *todavía* no está en el lugar correcto, pero la `M` sí. ¿Cuántas palabras quedan?" ] }, { @@ -1834,16 +1833,16 @@ "id": "c1d0f892", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "*The Count of Monte Cristo* is a novel by Alexandre Dumas that is considered a classic.\n", - "Nevertheless, in the introduction of an English translation of the book, the writer Umberto Eco confesses that he found the book to be \"one of the most badly written novels of all time\".\n", + "*The Count of Monte Cristo* es una novela de Alexandre Dumas que se considera un clásico.\n", + "Sin embargo, en la introducción de una traducción inglesa del libro, el escritor Umberto Eco confiesa que le pareció \"una de las novelas peor escritas de todos los tiempos\".\n", "\n", - "In particular, he says it is \"shameless in its repetition of the same adjective,\" and mentions in particular the number of times \"its characters either shudder or turn pale.\"\n", + "En particular, dice que es \"desvergonzada en su repetición del mismo adjetivo\", y menciona en particular el número de veces que \"sus personajes se estremecen o palidecen\".\n", "\n", - "To see whether his objection is valid, let's count the number number of lines that contain the word `pale` in any form, including `pale`, `pales`, `paled`, and `paleness`, as well as the related word `pallor`. \n", - "Use a single regular expression that matches any of these words.\n", - "As an additional challenge, make sure that it doesn't match any other words, like `impale` -- you might want to ask a virtual assistant for help." + "Para ver si su objeción es válida, contemos el número de líneas que contienen la palabra `pale` en cualquier forma, incluidas `pale`, `pales`, `paled` y `paleness`, así como la palabra relacionada `pallor`.\n", + "Usa una sola expresión regular que coincida con cualquiera de estas palabras.\n", + "Como desafío adicional, asegúrate de que no coincida con otras palabras, como `impale` -- quizá quieras pedir ayuda a un asistente virtual." ] }, { @@ -1853,7 +1852,7 @@ "tags": [] }, "source": [ - "The following cell downloads the book from Project Gutenberg ." + "La siguiente celda descarga el libro de Project Gutenberg ." ] }, { @@ -1878,7 +1877,7 @@ "tags": [] }, "source": [ - "The following cell runs a function that reads the file from Project Gutenberg and writes a file that contains only the text of the book, not the added information about the book." + "La siguiente celda ejecuta una función que lee el archivo de Project Gutenberg y escribe un archivo que contiene solo el texto del libro, no la información añadida sobre el libro." ] }, { @@ -1946,7 +1945,7 @@ "tags": [] }, "source": [ - "By this count, these words appear on `223` lines of the book, so Mr. Eco might have a point." + "Según este recuento, estas palabras aparecen en `223` líneas del libro, así que el señor Eco quizá tenga razón." ] }, { @@ -1960,9 +1959,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] } ], diff --git a/chapters/chap09.ipynb b/chapters/chap09.ipynb index 755c656..c850bb8 100644 --- a/chapters/chap09.ipynb +++ b/chapters/chap09.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,12 +41,12 @@ "id": "3c25ca7e", "metadata": {}, "source": [ - "# Lists\n", + "# Listas\n", "\n", - "This chapter presents one of Python's most useful built-in types, lists.\n", - "You will also learn more about objects and what can happen when multiple variables refer to the same object.\n", + "Este capítulo presenta uno de los tipos integrados más útiles de Python: las listas.\n", + "También aprenderás más sobre objetos y lo que puede ocurrir cuando varias variables se refieren al mismo objeto.\n", "\n", - "In the exercises at the end of the chapter, we'll make a word list and use it to search for special words like palindromes and anagrams." + "En los ejercicios al final del capítulo, construiremos una lista de palabras y la usaremos para buscar palabras especiales como palíndromos y anagramas." ] }, { @@ -54,14 +54,14 @@ "id": "4d32b3e2", "metadata": {}, "source": [ - "## A list is a sequence\n", + "## Una lista es una secuencia\n", "\n", - "Like a string, a **list** is a sequence of values. In a string, the\n", - "values are characters; in a list, they can be any type.\n", - "The values in a list are called **elements**.\n", + "Como un string, una **lista** es una secuencia de valores. En un string, los\n", + "valores son caracteres; en una lista, pueden ser de cualquier tipo.\n", + "Los valores en una lista se llaman **elementos**.\n", "\n", - "There are several ways to create a new list; the simplest is to enclose the elements in square brackets (`[` and `]`).\n", - "For example, here is a list of two integers. " + "Hay varias formas de crear una nueva lista; la más simple es encerrar los elementos entre corchetes (`[` y `]`).\n", + "Por ejemplo, aquí tienes una lista de dos enteros." ] }, { @@ -79,7 +79,7 @@ "id": "b5d6112c", "metadata": {}, "source": [ - "And here's a list of three strings." + "Y aquí tienes una lista de tres strings." ] }, { @@ -97,8 +97,8 @@ "id": "dda58c67", "metadata": {}, "source": [ - "The elements of a list don't have to be the same type.\n", - "The following list contains a string, a float, an integer, and even another list." + "Los elementos de una lista no tienen que ser del mismo tipo.\n", + "La siguiente lista contiene un string, un float, un entero e incluso otra lista." ] }, { @@ -116,10 +116,10 @@ "id": "147fa217", "metadata": {}, "source": [ - "A list within another list is **nested**.\n", + "Una lista dentro de otra lista está **anidada**.\n", "\n", - "A list that contains no elements is called an empty list; you can create\n", - "one with empty brackets, `[]`." + "Una lista que no contiene elementos se llama lista vacía; puedes crear\n", + "una con corchetes vacíos, `[]`." ] }, { @@ -137,7 +137,7 @@ "id": "f95381bc", "metadata": {}, "source": [ - "The `len` function returns the length of a list." + "La función `len` devuelve la longitud de una lista." ] }, { @@ -155,7 +155,7 @@ "id": "371403a3", "metadata": {}, "source": [ - "The length of an empty list is `0`." + "La longitud de una lista vacía es `0`." ] }, { @@ -175,7 +175,7 @@ "id": "d3589a5d", "metadata": {}, "source": [ - "The following figure shows the state diagram for `cheeses`, `numbers` and `empty`." + "La siguiente figura muestra el diagrama de estado de `cheeses`, `numbers` y `empty`." ] }, { @@ -225,7 +225,7 @@ "id": "503f25d8", "metadata": {}, "source": [ - "Lists are represented by boxes with the word \"list\" outside and the numbered elements of the list inside." + "Las listas se representan con cajas con la palabra \"lista\" fuera y los elementos numerados de la lista dentro." ] }, { @@ -233,10 +233,10 @@ "id": "e0b8ff01", "metadata": {}, "source": [ - "## Lists are mutable\n", + "## Las listas son mutables\n", "\n", - "To read an element of a list, we can use the bracket operator.\n", - "The index of the first element is `0`." + "Para leer un elemento de una lista, podemos usar el operador de corchetes.\n", + "El índice del primer elemento es `0`." ] }, { @@ -254,9 +254,9 @@ "id": "9747e951", "metadata": {}, "source": [ - "Unlike strings, lists are mutable. When the bracket operator appears on\n", - "the left side of an assignment, it identifies the element of the list\n", - "that will be assigned." + "A diferencia de los strings, las listas son mutables. Cuando el operador de corchetes aparece en\n", + "el lado izquierdo de una asignación, identifica el elemento de la lista\n", + "al que se asignará el valor." ] }, { @@ -275,19 +275,19 @@ "id": "5097a517", "metadata": {}, "source": [ - "The second element of `numbers`, which used to be `123`, is now `17`.\n", + "El segundo elemento de `numbers`, que antes era `123`, ahora es `17`.\n", "\n", - "List indices work the same way as string indices:\n", + "Los índices de lista funcionan igual que los índices de string:\n", "\n", - "- Any integer expression can be used as an index.\n", + "- Cualquier expresión entera puede usarse como índice.\n", "\n", - "- If you try to read or write an element that does not exist, you get\n", - " an `IndexError`.\n", + "- Si intentas leer o escribir un elemento que no existe, obtienes\n", + " un `IndexError`.\n", "\n", - "- If an index has a negative value, it counts backward from the end of\n", - " the list.\n", + "- Si un índice tiene un valor negativo, cuenta hacia atrás desde el final de\n", + " la lista.\n", "\n", - "The `in` operator works on lists -- it checks whether a given element appears anywhere in the list." + "El operador `in` funciona con listas: comprueba si un elemento dado aparece en algún lugar de la lista." ] }, { @@ -315,7 +315,7 @@ "id": "89d01ebf", "metadata": {}, "source": [ - "Although a list can contain another list, the nested list still counts as a single element -- so in the following list, there are only four elements." + "Aunque una lista puede contener otra lista, la lista anidada sigue contando como un solo elemento; por eso, en la siguiente lista, solo hay cuatro elementos." ] }, { @@ -334,7 +334,7 @@ "id": "4e0ea41d", "metadata": {}, "source": [ - "And `10` is not considered to be an element of `t` because it is an element of a nested list, not `t`." + "Y `10` no se considera un elemento de `t` porque es un elemento de una lista anidada, no de `t`." ] }, { @@ -352,10 +352,10 @@ "id": "1ee7a4d9", "metadata": {}, "source": [ - "## List slices\n", + "## Porciones de lista\n", "\n", - "The slice operator works on lists the same way it works on strings.\n", - "The following example selects the second and third elements from a list of four letters." + "El operador de porción funciona con listas igual que con strings.\n", + "El siguiente ejemplo selecciona el segundo y el tercer elemento de una lista de cuatro letras." ] }, { @@ -374,7 +374,7 @@ "id": "bc59d952", "metadata": {}, "source": [ - "If you omit the first index, the slice starts at the beginning. " + "Si omites el primer índice, la porción empieza al principio." ] }, { @@ -392,7 +392,7 @@ "id": "1aaaae86", "metadata": {}, "source": [ - "If you omit the second, the slice goes to the end. " + "Si omites el segundo, la porción llega hasta el final." ] }, { @@ -410,7 +410,7 @@ "id": "67ad02e8", "metadata": {}, "source": [ - "So if you omit both, the slice is a copy of the whole list." + "Así que, si omites ambos, la porción es una copia de toda la lista." ] }, { @@ -428,7 +428,7 @@ "id": "9232c1ef", "metadata": {}, "source": [ - "Another way to copy a list is to use the `list` function." + "Otra forma de copiar una lista es usar la función `list`." ] }, { @@ -446,7 +446,7 @@ "id": "50e4b182", "metadata": {}, "source": [ - "Because `list` is the name of a built-in function, you should avoid using it as a variable name.\n" + "Como `list` es el nombre de una función integrada, deberías evitar usarlo como nombre de variable.\n" ] }, { @@ -454,9 +454,9 @@ "id": "1b057c0c", "metadata": {}, "source": [ - "## List operations\n", + "## Operaciones con listas\n", "\n", - "The `+` operator concatenates lists." + "El operador `+` concatena listas." ] }, { @@ -476,7 +476,7 @@ "id": "474a5c40", "metadata": {}, "source": [ - "The `*` operator repeats a list a given number of times." + "El operador `*` repite una lista un número determinado de veces." ] }, { @@ -494,7 +494,7 @@ "id": "5b33bc51", "metadata": {}, "source": [ - "No other mathematical operators work with lists, but the built-in function `sum` adds up the elements." + "Ningún otro operador matemático funciona con listas, pero la función integrada `sum` suma los elementos." ] }, { @@ -512,7 +512,7 @@ "id": "f216a14d", "metadata": {}, "source": [ - "And `min` and `max` find the smallest and largest elements." + "Y `min` y `max` encuentran el elemento más pequeño y el más grande." ] }, { @@ -540,10 +540,10 @@ "id": "533a2009", "metadata": {}, "source": [ - "## List methods\n", + "## Métodos de lista\n", "\n", - "Python provides methods that operate on lists. For example, `append`\n", - "adds a new element to the end of a list:" + "Python proporciona métodos que operan sobre listas. Por ejemplo, `append`\n", + "añade un nuevo elemento al final de una lista:" ] }, { @@ -562,7 +562,7 @@ "id": "ccc57f77", "metadata": {}, "source": [ - "`extend` takes a list as an argument and appends all of the elements:" + "`extend` toma una lista como argumento y añade todos sus elementos:" ] }, { @@ -581,8 +581,8 @@ "id": "0f39d9f6", "metadata": {}, "source": [ - "There are two methods that remove elements from a list.\n", - "If you know the index of the element you want, you can use `pop`." + "Hay dos métodos que eliminan elementos de una lista.\n", + "Si conoces el índice del elemento que quieres, puedes usar `pop`." ] }, { @@ -601,8 +601,8 @@ "id": "6729415a", "metadata": {}, "source": [ - "The return value is the element that was removed.\n", - "And we can confirm that the list has been modified." + "El valor de retorno es el elemento que se eliminó.\n", + "Y podemos confirmar que la lista se ha modificado." ] }, { @@ -620,7 +620,7 @@ "id": "1e97ee7d", "metadata": {}, "source": [ - "If you know the element you want to remove (but not the index), you can use `remove`:" + "Si conoces el elemento que quieres eliminar (pero no el índice), puedes usar `remove`:" ] }, { @@ -639,8 +639,8 @@ "id": "60e710fe", "metadata": {}, "source": [ - "The return value from `remove` is `None`.\n", - "But we can confirm that the list has been modified." + "El valor de retorno de `remove` es `None`.\n", + "Pero podemos confirmar que la lista se ha modificado." ] }, { @@ -658,7 +658,7 @@ "id": "2a9448a8", "metadata": {}, "source": [ - "If the element you ask for is not in the list, that's a ValueError." + "Si el elemento que pides no está en la lista, eso es un ValueError." ] }, { @@ -680,11 +680,11 @@ "id": "18305f96", "metadata": {}, "source": [ - "## Lists and strings\n", + "## Listas y strings\n", "\n", - "A string is a sequence of characters and a list is a sequence of values,\n", - "but a list of characters is not the same as a string. \n", - "To convert from a string to a list of characters, you can use the `list` function." + "Un string es una secuencia de caracteres y una lista es una secuencia de valores,\n", + "pero una lista de caracteres no es lo mismo que un string.\n", + "Para convertir un string en una lista de caracteres, puedes usar la función `list`." ] }, { @@ -704,8 +704,8 @@ "id": "0291ef69", "metadata": {}, "source": [ - "The `list` function breaks a string into individual letters.\n", - "If you want to break a string into words, you can use the `split` method:" + "La función `list` divide un string en letras individuales.\n", + "Si quieres dividir un string en palabras, puedes usar el método `split`:" ] }, { @@ -725,7 +725,7 @@ "id": "0e16909d", "metadata": {}, "source": [ - "An optional argument called a **delimiter** specifies which characters to use as word boundaries. The following example uses a hyphen as a delimiter." + "Un argumento opcional llamado **delimitador** especifica qué caracteres se usan como límites entre palabras. El siguiente ejemplo usa un guion como delimitador." ] }, { @@ -745,8 +745,8 @@ "id": "7c61f916", "metadata": {}, "source": [ - "If you have a list of strings, you can concatenate them into a single string using `join`.\n", - "`join` is a string method, so you have to invoke it on the delimiter and pass the list as an argument." + "Si tienes una lista de strings, puedes concatenarlos en un solo string usando `join`.\n", + "`join` es un método de string, así que tienes que invocarlo sobre el delimitador y pasar la lista como argumento." ] }, { @@ -767,9 +767,9 @@ "id": "bedd842b", "metadata": {}, "source": [ - "In this case the delimiter is a space character, so `join` puts a space\n", - "between words.\n", - "To join strings without spaces, you can use the empty string, `''`, as a delimiter." + "En este caso el delimitador es un carácter de espacio, así que `join` pone un espacio\n", + "entre las palabras.\n", + "Para unir strings sin espacios, puedes usar el string vacío, `''`, como delimitador." ] }, { @@ -777,9 +777,9 @@ "id": "181215ce", "metadata": {}, "source": [ - "## Looping through a list\n", + "## Recorrer una lista con un bucle\n", "\n", - "You can use a `for` statement to loop through the elements of a list." + "Puedes usar una sentencia `for` para recorrer los elementos de una lista." ] }, { @@ -798,7 +798,7 @@ "id": "c0e53a09", "metadata": {}, "source": [ - "For example, after using `split` to make a list of words, we can use `for` to loop through them." + "Por ejemplo, después de usar `split` para crear una lista de palabras, podemos usar `for` para recorrerlas." ] }, { @@ -819,7 +819,7 @@ "id": "0857b55b", "metadata": {}, "source": [ - "A `for` loop over an empty list never runs the indented statements." + "Un bucle `for` sobre una lista vacía nunca ejecuta las sentencias indentadas." ] }, { @@ -838,9 +838,9 @@ "id": "6e5f55c9", "metadata": {}, "source": [ - "## Sorting lists\n", + "## Ordenar listas\n", "\n", - "Python provides a built-in function called `sorted` that sorts the elements of a list." + "Python proporciona una función integrada llamada `sorted` que ordena los elementos de una lista." ] }, { @@ -859,7 +859,7 @@ "id": "44e028cf", "metadata": {}, "source": [ - "The original list is unchanged." + "La lista original no cambia." ] }, { @@ -877,7 +877,7 @@ "id": "530146af", "metadata": {}, "source": [ - "`sorted` works with any kind of sequence, not just lists. So we can sort the letters in a string like this." + "`sorted` funciona con cualquier tipo de secuencia, no solo con listas. Así que podemos ordenar las letras de un string así." ] }, { @@ -895,8 +895,8 @@ "id": "f90bd9ea", "metadata": {}, "source": [ - "The result is a list.\n", - "To convert the list to a string, we can use `join`." + "El resultado es una lista.\n", + "Para convertir la lista en un string, podemos usar `join`." ] }, { @@ -914,7 +914,7 @@ "id": "a57084e2", "metadata": {}, "source": [ - "With an empty string as the delimiter, the elements of the list are joined with nothing between them." + "Con un string vacío como delimitador, los elementos de la lista se unen sin nada entre ellos." ] }, { @@ -922,9 +922,9 @@ "id": "ce98b3d5", "metadata": {}, "source": [ - "## Objects and values\n", + "## Objetos y valores\n", "\n", - "If we run these assignment statements:" + "Si ejecutamos estas sentencias de asignación:" ] }, { @@ -943,8 +943,8 @@ "id": "33d020aa", "metadata": {}, "source": [ - "We know that `a` and `b` both refer to a string, but we don't know whether they refer to the *same* string. \n", - "There are two possible states, shown in the following figure." + "Sabemos que `a` y `b` se refieren ambos a un string, pero no sabemos si se refieren al *mismo* string.\n", + "Hay dos estados posibles, mostrados en la siguiente figura." ] }, { @@ -989,9 +989,9 @@ "id": "2f0b0431", "metadata": {}, "source": [ - "In the diagram on the left, `a` and `b` refer to two different objects that have the\n", - "same value. In the diagram on the right, they refer to the same object.\n", - "To check whether two variables refer to the same object, you can use the `is` operator." + "En el diagrama de la izquierda, `a` y `b` se refieren a dos objetos diferentes que tienen el\n", + "mismo valor. En el diagrama de la derecha, se refieren al mismo objeto.\n", + "Para comprobar si dos variables se refieren al mismo objeto, puedes usar el operador `is`." ] }, { @@ -1011,9 +1011,9 @@ "id": "d1eb0e36", "metadata": {}, "source": [ - "In this example, Python only created one string object, and both `a`\n", - "and `b` refer to it.\n", - "But when you create two lists, you get two objects." + "En este ejemplo, Python solo creó un objeto string, y tanto `a`\n", + "como `b` se refieren a él.\n", + "Pero cuando creas dos listas, obtienes dos objetos." ] }, { @@ -1033,7 +1033,7 @@ "id": "a8d4c3d4", "metadata": {}, "source": [ - "So the state diagram looks like this." + "Así que el diagrama de estado se ve así." ] }, { @@ -1071,8 +1071,8 @@ "id": "cc115a9f", "metadata": {}, "source": [ - "In this case we would say that the two lists are **equivalent**, because they have the same elements, but not **identical**, because they are not the same object. \n", - "If two objects are identical, they are also equivalent, but if they are equivalent, they are not necessarily identical." + "En este caso diríamos que las dos listas son **equivalentes**, porque tienen los mismos elementos, pero no **idénticos**, porque no son el mismo objeto.\n", + "Si dos objetos son idénticos, también son equivalentes, pero si son equivalentes, no necesariamente son idénticos." ] }, { @@ -1082,7 +1082,7 @@ "source": [ "## Aliasing\n", "\n", - "If `a` refers to an object and you assign `b = a`, then both variables refer to the same object." + "Si `a` se refiere a un objeto y asignas `b = a`, entonces ambas variables se refieren al mismo objeto." ] }, { @@ -1102,7 +1102,7 @@ "id": "f6ab3262", "metadata": {}, "source": [ - "So the state diagram looks like this." + "Así que el diagrama de estado se ve así." ] }, { @@ -1140,12 +1140,12 @@ "id": "c676fde9", "metadata": {}, "source": [ - "The association of a variable with an object is called a **reference**.\n", - "In this example, there are two references to the same object.\n", + "La asociación de una variable con un objeto se llama **referencia**.\n", + "En este ejemplo, hay dos referencias al mismo objeto.\n", "\n", - "An object with more than one reference has more than one name, so we say the object is **aliased**.\n", - "If the aliased object is mutable, changes made with one name affect the other.\n", - "In this example, if we change the object `b` refers to, we are also changing the object `a` refers to." + "Un objeto con más de una referencia tiene más de un nombre, así que decimos que el objeto está **aliased**.\n", + "Si el aliased objeto es mutable, los cambios hechos con un nombre afectan al otro.\n", + "En este ejemplo, si cambiamos el objeto al que se refiere `b`, también estamos cambiando el objeto al que se refiere `a`." ] }, { @@ -1164,12 +1164,12 @@ "id": "e3ef0537", "metadata": {}, "source": [ - "So we would say that `a` \"sees\" this change.\n", - "Although this behavior can be useful, it is error-prone.\n", - "In general, it is safer to avoid aliasing when you are working with mutable objects.\n", + "Así que diríamos que `a` \"ve\" este cambio.\n", + "Aunque este comportamiento puede ser útil, es propenso a errores.\n", + "En general, es más seguro evitar el aliasing cuando trabajas con objetos mutables.\n", "\n", - "For immutable objects like strings, aliasing is not as much of a problem.\n", - "In this example:" + "Para objetos inmutables como strings, el aliasing no supone tanto problema.\n", + "En este ejemplo:" ] }, { @@ -1188,8 +1188,8 @@ "id": "952bbf60", "metadata": {}, "source": [ - "It almost never makes a difference whether `a` and `b` refer to the same\n", - "string or not." + "Casi nunca importa si `a` y `b` se refieren al mismo\n", + "string o no." ] }, { @@ -1197,11 +1197,11 @@ "id": "35045bef", "metadata": {}, "source": [ - "## List arguments\n", + "## Listas como argumentos\n", "\n", - "When you pass a list to a function, the function gets a reference to the\n", - "list. If the function modifies the list, the caller sees the change. For\n", - "example, `pop_first` uses the list method `pop` to remove the first element from a list." + "Cuando pasas una lista a una función, la función recibe una referencia a la\n", + "lista. Si la función modifica la lista, el código que llama ve el cambio. Por\n", + "ejemplo, `pop_first` usa el método de lista `pop` para eliminar el primer elemento de una lista." ] }, { @@ -1220,7 +1220,7 @@ "id": "4953b0f9", "metadata": {}, "source": [ - "We can use it like this." + "Podemos usarla así." ] }, { @@ -1239,7 +1239,7 @@ "id": "ef5d3c1e", "metadata": {}, "source": [ - "The return value is the first element, which has been removed from the list -- as we can see by displaying the modified list." + "El valor de retorno es el primer elemento, que se ha eliminado de la lista, como podemos ver al mostrar la lista modificada." ] }, { @@ -1257,7 +1257,7 @@ "id": "e5288e08", "metadata": {}, "source": [ - "In this example, the parameter `lst` and the variable `letters` are aliases for the same object, so the state diagram looks like this:" + "En este ejemplo, el parameter `lst` y la variable `letters` son aliases del mismo objeto, así que el diagrama de estado se ve así:" ] }, { @@ -1301,8 +1301,8 @@ "id": "c1a093d2", "metadata": {}, "source": [ - "Passing a reference to an object as an argument to a function creates a form of aliasing.\n", - "If the function modifies the object, those changes persist after the function is done." + "Pasar una referencia a un objeto como argumento a una función crea una forma de aliasing.\n", + "Si la función modifica el objeto, esos cambios persisten después de que la función termine." ] }, { @@ -1312,12 +1312,12 @@ "tags": [] }, "source": [ - "## Making a word list\n", + "## Crear una lista de palabras\n", "\n", - "In the previous chapter, we read the file `words.txt` and searched for words with certain properties, like using the letter `e`.\n", - "But we read the entire file many times, which is not efficient.\n", - "It is better to read the file once and put the words in a list.\n", - "The following loop shows how." + "En el capítulo anterior, leímos el archivo `words.txt` y buscamos palabras con ciertas propiedades, como usar la letra `e`.\n", + "Pero leímos el archivo completo muchas veces, lo cual no es eficiente.\n", + "Es mejor leer el archivo una vez y poner las palabras en una lista.\n", + "El siguiente bucle muestra cómo hacerlo." ] }, { @@ -1353,11 +1353,11 @@ "id": "44450ffa", "metadata": {}, "source": [ - "Before the loop, `word_list` is initialized with an empty list.\n", - "Each time through the loop, the `append` method adds a word to the end.\n", - "When the loop is done, there are more than 113,000 words in the list.\n", + "Antes del bucle, `word_list` se inicializa con una lista vacía.\n", + "Cada vez que pasa por el bucle, el método `append` añade una palabra al final.\n", + "Cuando termina el bucle, hay más de 113 000 palabras en la lista.\n", "\n", - "Another way to do the same thing is to use `read` to read the entire file into a string." + "Otra forma de hacer lo mismo es usar `read` para leer todo el archivo en un string." ] }, { @@ -1376,8 +1376,8 @@ "id": "65718c7f", "metadata": {}, "source": [ - "The result is a single string with more than a million characters.\n", - "We can use the `split` method to split it into a list of words." + "El resultado es un único string con más de un millón de caracteres.\n", + "Podemos usar el método `split` para dividirlo en una lista de palabras." ] }, { @@ -1396,8 +1396,8 @@ "id": "1b5b25a3", "metadata": {}, "source": [ - "Now, to check whether a string appears in the list, we can use the `in` operator.\n", - "For example, `'demotic'` is in the list." + "Ahora, para comprobar si un string aparece en la lista, podemos usar el operador `in`.\n", + "Por ejemplo, `'demotic'` está en la lista." ] }, { @@ -1415,7 +1415,7 @@ "id": "9df6674d", "metadata": {}, "source": [ - "But `'contrafibularities'` is not." + "Pero `'contrafibularities'` no está." ] }, { @@ -1433,7 +1433,7 @@ "id": "243c25b6", "metadata": {}, "source": [ - "And I have to say, I'm anaspeptic about it." + "Y tengo que decir que eso me deja anaspeptic." ] }, { @@ -1441,12 +1441,12 @@ "id": "ce9ffd79", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Note that most list methods modify the argument and return `None`.\n", - "This is the opposite of the string methods, which return a new string and leave the original alone.\n", + "Ten en cuenta que la mayoría de métodos de lista modifican el argumento y devuelven `None`.\n", + "Esto es lo contrario de los métodos de string, que devuelven un nuevo string y dejan el original intacto.\n", "\n", - "If you are used to writing string code like this:" + "Si estás acostumbrado a escribir código con strings así:" ] }, { @@ -1466,7 +1466,7 @@ "id": "d2117582", "metadata": {}, "source": [ - "It is tempting to write list code like this:" + "Es tentador escribir código con listas así:" ] }, { @@ -1485,7 +1485,7 @@ "id": "991c439d", "metadata": {}, "source": [ - "`remove` modifies the list and returns `None`, so next operation you perform with `t` is likely to fail." + "`remove` modifica la lista y devuelve `None`, así que la siguiente operación que realices con `t` probablemente fallará." ] }, { @@ -1507,11 +1507,11 @@ "id": "c500e2d8", "metadata": {}, "source": [ - "This error message takes some explaining.\n", - "An **attribute** of an object is a variable or method associated with it.\n", - "In this case, the value of `t` is `None`, which is a `NoneType` object, which does not have a attribute named `remove`, so the result is an `AttributeError`.\n", + "Este mensaje de error requiere algo de explicación.\n", + "Un **atributo** de un objeto es una variable o método asociado con él.\n", + "En este caso, el valor de `t` es `None`, que es un objeto `NoneType`, que no tiene un atributo llamado `remove`, así que el resultado es un `AttributeError`.\n", "\n", - "If you see an error message like this, you should look backward through the program and see if you might have called a list method incorrectly." + "Si ves un mensaje de error como este, deberías mirar hacia atrás en el programa y ver si podrías haber llamado incorrectamente a un método de lista." ] }, { @@ -1519,34 +1519,34 @@ "id": "f90db780", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**list:**\n", - " An object that contains a sequence of values.\n", + "**lista:**\n", + " Un objeto que contiene una secuencia de valores.\n", "\n", - "**element:**\n", - " One of the values in a list or other sequence.\n", + "**elemento:**\n", + " Uno de los valores de una lista u otra secuencia.\n", "\n", - "**nested list:**\n", - "A list that is an element of another list.\n", + "**lista anidada:**\n", + "Una lista que es un elemento de otra lista.\n", "\n", - "**delimiter:**\n", - " A character or string used to indicate where a string should be split.\n", + "**delimitador:**\n", + " Un carácter o string usado para indicar dónde debe dividirse un string.\n", "\n", - "**equivalent:**\n", - " Having the same value.\n", + "**equivalentes:**\n", + " Tener el mismo valor.\n", "\n", - "**identical:**\n", - " Being the same object (which implies equivalence).\n", + "**idénticos:**\n", + " Ser el mismo objeto (lo que implica equivalencia).\n", "\n", - "**reference:**\n", - " The association between a variable and its value.\n", + "**referencia:**\n", + " La asociación entre una variable y su valor.\n", "\n", "**aliased:**\n", - "If there is more than one variable that refers to an object, the object is aliased.\n", + "Si hay más de una variable que se refiere a un objeto, el objeto está aliased.\n", "\n", - "**attribute:**\n", - " One of the named values associated with an object." + "**atributo:**\n", + " Uno de los valores con nombre asociados con un objeto." ] }, { @@ -1554,7 +1554,7 @@ "id": "e67864e5", "metadata": {}, "source": [ - "## Exercises\n", + "## Ejercicios\n", "\n" ] }, @@ -1578,24 +1578,24 @@ "id": "ae9c42da", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, I used the words \"contrafibularities\" and \"anaspeptic\", but they are not actually English words.\n", - "They were used in the British television show *Black Adder*, Season 3, Episode 2, \"Ink and Incapability\".\n", + "En este capítulo, usé las palabras \"contrafibularities\" y \"anaspeptic\", pero en realidad no son palabras en inglés.\n", + "Se usaron en la serie de televisión británica *Black Adder*, temporada 3, episodio 2, \"Ink and Incapability\".\n", "\n", - "However, when I asked ChatGPT 3.5 (August 3, 2023 version) where those words came from, it initially claimed they are from Monty Python, and later claimed they are from the Tom Stoppard play *Rosencrantz and Guildenstern Are Dead*.\n", + "Sin embargo, cuando pregunté a ChatGPT 3.5 (versión del 3 de agosto de 2023) de dónde venían esas palabras, al principio afirmó que eran de Monty Python, y después afirmó que eran de la obra de Tom Stoppard *Rosencrantz and Guildenstern Are Dead*.\n", "\n", - "If you ask now, you might get different results.\n", - "But this example is a reminder that virtual assistants are not always accurate, so you should check whether the results are correct.\n", - "As you gain experience, you will get a sense of which questions virtual assistants can answer reliably.\n", - "In this example, a conventional web search can identify the source of these words quickly.\n", + "Si preguntas ahora, podrías obtener resultados diferentes.\n", + "Pero este ejemplo es un recordatorio de que los asistentes virtuales no siempre son precisos, así que deberías comprobar si los resultados son correctos.\n", + "A medida que ganes experiencia, desarrollarás intuición sobre qué preguntas pueden responder de forma fiable los asistentes virtuales.\n", + "En este ejemplo, una búsqueda web convencional puede identificar rápidamente el origen de estas palabras.\n", "\n", - "If you get stuck on any of the exercises in this chapter, consider asking a virtual assistant for help.\n", - "If you get a result that uses features we haven't learned yet, you can assign the VA a \"role\".\n", + "Si te quedas atascado en alguno de los ejercicios de este capítulo, considera pedir ayuda a un asistente virtual.\n", + "Si obtienes un resultado que usa características que todavía no hemos aprendido, puedes asignar un \"role\" al asistente virtual.\n", "\n", - "For example, before you ask a question try typing \"Role: Basic Python Programming Instructor\".\n", - "After that, the responses you get should use only basic features.\n", - "If you still see features we you haven't learned, you can follow up with \"Can you write that using only basic Python features?\"" + "Por ejemplo, antes de hacer una pregunta prueba a escribir \"Role: Basic Python Programming Instructor\".\n", + "Después de eso, las respuestas que obtengas deberían usar solo características básicas.\n", + "Si todavía ves características que no hemos aprendido, puedes continuar con \"Can you write that using only basic Python features?\"" ] }, { @@ -1603,15 +1603,15 @@ "id": "31d5b304", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Two words are anagrams if you can rearrange the letters from one to spell the other.\n", - "For example, `tops` is an anagram of `stop`.\n", + "Dos palabras son anagramas si puedes reordenar las letras de una para escribir la otra.\n", + "Por ejemplo, `tops` es un anagrama de `stop`.\n", "\n", - "One way to check whether two words are anagrams is to sort the letters in both words.\n", - "If the lists of sorted letters are the same, the words are anagrams.\n", + "Una forma de comprobar si dos palabras son anagramas es ordenar las letras de ambas palabras.\n", + "Si las listas de letras ordenadas son iguales, las palabras son anagramas.\n", "\n", - "Write a function called `is_anagram` that takes two strings and returns `True` if they are anagrams." + "Escribe una función llamada `is_anagram` que tome dos strings y devuelva `True` si son anagramas." ] }, { @@ -1621,7 +1621,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1665,7 +1665,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1690,7 +1690,7 @@ "id": "8501f3ba", "metadata": {}, "source": [ - "Using your function and the word list, find all the anagrams of `takes`." + "Usando tu función y la lista de palabras, encuentra todos los anagramas de `takes`." ] }, { @@ -1708,9 +1708,9 @@ "id": "7f279f2f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Python provides a built-in function called `reversed` that takes as an argument a sequence of elements -- like a list or string -- and returns a `reversed` object that contains the elements in reverse order." + "Python proporciona una función integrada llamada `reversed` que toma como argumento una secuencia de elementos, como una lista o un string, y devuelve un objeto `reversed` que contiene los elementos en orden inverso." ] }, { @@ -1728,7 +1728,7 @@ "id": "0f95c76f", "metadata": {}, "source": [ - "If you want the reversed elements in a list, you can use the `list` function." + "Si quieres los elementos invertidos en una lista, puedes usar la función `list`." ] }, { @@ -1746,7 +1746,7 @@ "id": "8fc79a2f", "metadata": {}, "source": [ - "Or if you want them in a string, you can use the `join` method." + "O si los quieres en un string, puedes usar el método `join`." ] }, { @@ -1764,7 +1764,7 @@ "id": "ec4ce196", "metadata": {}, "source": [ - "So we can write a function that reverses a word like this." + "Así podemos escribir una función que invierte una palabra así." ] }, { @@ -1783,8 +1783,8 @@ "id": "21550b5f", "metadata": {}, "source": [ - "A palindrome is a word that is spelled the same backward and forward, like \"noon\" and \"rotator\".\n", - "Write a function called `is_palindrome` that takes a string argument and returns `True` if it is a palindrome and `False` otherwise." + "Un palíndromo es una palabra que se escribe igual hacia atrás y hacia adelante, como \"noon\" y \"rotator\".\n", + "Escribe una función llamada `is_palindrome` que tome un string argumento y devuelva `True` si es un palíndromo y `False` en caso contrario." ] }, { @@ -1794,7 +1794,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function with doctests you can use to check your function." + "Aquí tienes un esquema de la función con doctests que puedes usar para comprobar tu función." ] }, { @@ -1848,7 +1848,7 @@ "id": "ad857abf", "metadata": {}, "source": [ - "You can use the following loop to find all of the palindromes in the word list with at least 7 letters." + "Puedes usar el siguiente bucle para encontrar todos los palíndromos en la lista de palabras con al menos 7 letras." ] }, { @@ -1870,13 +1870,13 @@ "id": "11386f70", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `reverse_sentence` that takes as an argument a string that contains any number of words separated by spaces.\n", - "It should return a new string that contains the same words in reverse order.\n", - "For example, if the argument is \"Reverse this sentence\", the result should be \"Sentence this reverse\".\n", + "Escribe una función llamada `reverse_sentence` que tome como argumento un string que contiene cualquier número de palabras separadas por espacios.\n", + "Debe devolver un nuevo string que contiene las mismas palabras en orden inverso.\n", + "Por ejemplo, si el argumento es \"Reverse this sentence\", el resultado debería ser \"Sentence this reverse\".\n", "\n", - "Hint: You can use the `capitalize` methods to capitalize the first word and convert the other words to lowercase. " + "Pista: Puedes usar los métodos `capitalize` para poner en mayúscula la primera palabra y convertir las demás palabras a minúsculas." ] }, { @@ -1886,7 +1886,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1943,10 +1943,10 @@ "id": "fb5f24b1", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `total_length` that takes a list of strings and returns the total length of the strings.\n", - "The total length of the words in `word_list` should be $902{,}728$." + "Escribe una función llamada `total_length` que tome una lista de strings y devuelva la longitud total de los strings.\n", + "La longitud total de las palabras en `word_list` debería ser $902{,}728$." ] }, { @@ -1988,7 +1988,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/chapters/chap10.ipynb b/chapters/chap10.ipynb index 742da86..58738fc 100644 --- a/chapters/chap10.ipynb +++ b/chapters/chap10.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,13 +41,13 @@ "id": "737e79eb", "metadata": {}, "source": [ - "# Dictionaries\n", + "# Diccionarios\n", "\n", - "This chapter presents a built-in type called a dictionary.\n", - "It is one of Python's best features -- and the building block of many efficient and elegant algorithms.\n", + "Este capítulo presenta un tipo integrado llamado diccionario.\n", + "Es una de las mejores características de Python, y el bloque de construcción de muchos algoritmos eficientes y elegantes.\n", "\n", - "We'll use dictionaries to compute the number of unique words in a book and the number of times each one appears.\n", - "And in the exercises, we'll use dictionaries to solve word puzzles." + "Usaremos diccionarios para calcular el número de palabras únicas en un libro y el número de veces que aparece cada una.\n", + "Y en los ejercicios, usaremos diccionarios para resolver juegos de palabras." ] }, { @@ -55,11 +55,11 @@ "id": "be7467bb", "metadata": {}, "source": [ - "## A dictionary is a mapping\n", + "## Un diccionario es un mapeo\n", "\n", - "A **dictionary** is like a list, but more general.\n", - "In a list, the indices have to be integers; in a dictionary they can be (almost) any type.\n", - "For example, suppose we make a list of number words, like this." + "Un **diccionario** es como una lista, pero más general.\n", + "En una lista, los índices tienen que ser enteros; en un diccionario pueden ser de (casi) cualquier tipo.\n", + "Por ejemplo, supongamos que hacemos una lista de palabras numéricas, así." ] }, { @@ -77,7 +77,7 @@ "id": "aa626f88", "metadata": {}, "source": [ - "We can use an integer as an index to get the corresponding word." + "Podemos usar un entero como índice para obtener la palabra correspondiente." ] }, { @@ -95,9 +95,9 @@ "id": "c38e143b", "metadata": {}, "source": [ - "But suppose we want to go in the other direction, and look up a word to get the corresponding integer.\n", - "We can't do that with a list, but we can with a dictionary.\n", - "We'll start by creating an empty dictionary and assigning it to `numbers`." + "Pero supongamos que queremos ir en la otra dirección, y buscar una palabra para obtener el entero correspondiente.\n", + "No podemos hacerlo con una lista, pero sí con un diccionario.\n", + "Empezaremos creando un diccionario vacío y asignándolo a `numbers`." ] }, { @@ -116,8 +116,8 @@ "id": "3acce992", "metadata": {}, "source": [ - "The curly braces, `{}`, represent an empty dictionary.\n", - "To add items to the dictionary, we'll use square brackets." + "Las llaves, `{}`, representan un diccionario vacío.\n", + "Para añadir elementos al diccionario, usaremos corchetes." ] }, { @@ -135,9 +135,9 @@ "id": "1dbe12c3", "metadata": {}, "source": [ - "This assignment adds to the dictionary an **item**, which represents the association of a **key** and a **value**.\n", - "In this example, the key is the string `'zero'` and the value is the integer `0`.\n", - "If we display the dictionary, we see that it contains one item, which contains a key and a value separated by a colon, `:`." + "Esta asignación añade al diccionario un **elemento**, que representa la asociación de una **clave** y un **valor**.\n", + "En este ejemplo, la clave es el string `'zero'` y el valor es el entero `0`.\n", + "Si mostramos el diccionario, vemos que contiene un elemento, que contiene una clave y un valor separados por dos puntos, `:`." ] }, { @@ -155,7 +155,7 @@ "id": "ad32c23d", "metadata": {}, "source": [ - "We can add more items like this." + "Podemos añadir más elementos así." ] }, { @@ -175,9 +175,9 @@ "id": "278901e5", "metadata": {}, "source": [ - "Now the dictionary contains three items.\n", + "Ahora el diccionario contiene tres elementos.\n", "\n", - "To look up a key and get the corresponding value, we use the bracket operator." + "Para buscar una clave y obtener el valor correspondiente, usamos el operador de corchetes." ] }, { @@ -195,7 +195,7 @@ "id": "df5724e6", "metadata": {}, "source": [ - "If the key isn't in the dictionary, we get a `KeyError`." + "Si la clave no está en el diccionario, obtenemos un `KeyError`." ] }, { @@ -216,7 +216,7 @@ "id": "2a027a6b", "metadata": {}, "source": [ - "The `len` function works on dictionaries; it returns the number of items." + "La función `len` funciona con diccionarios; devuelve el número de elementos." ] }, { @@ -234,10 +234,10 @@ "id": "58221e96", "metadata": {}, "source": [ - "In mathematical language, a dictionary represents a **mapping** from keys to values, so you can also say that each key \"maps to\" a value.\n", - "In this example, each number word maps to the corresponding integer.\n", + "En lenguaje matemático, un diccionario representa un **mapeo** de claves a valores, así que también puedes decir que cada clave \"mapea a\" un valor.\n", + "En este ejemplo, cada palabra numérica mapea al entero correspondiente.\n", "\n", - "The following figure shows the state diagram for `numbers`." + "La siguiente figura muestra el diagrama de estado de `numbers`." ] }, { @@ -277,9 +277,9 @@ "id": "b092aa61", "metadata": {}, "source": [ - "A dictionary is represented by a box with the word \"dict\" outside and the items inside.\n", - "Each item is represented by a key and an arrow pointing to a value.\n", - "The quotation marks indicate that the keys here are strings, not variable names." + "Un diccionario se representa con una caja con la palabra \"dict\" fuera y los elementos dentro.\n", + "Cada elemento se representa con una clave y una flecha que apunta a un valor.\n", + "Las comillas indican que las claves aquí son strings, no nombres de variables." ] }, { @@ -287,10 +287,10 @@ "id": "2a0a128a", "metadata": {}, "source": [ - "## Creating dictionaries\n", + "## Crear diccionarios\n", "\n", - "In the previous section we created an empty dictionary and added items one at a time using the bracket operator.\n", - "Instead, we could have created the dictionary all at once like this." + "En la sección anterior creamos un diccionario vacío y añadimos elementos uno por uno usando el operador de corchetes.\n", + "En su lugar, podríamos haber creado el diccionario de una vez así." ] }, { @@ -308,11 +308,11 @@ "id": "31ded5b2", "metadata": {}, "source": [ - "Each item consists of a key and a value separated by a colon.\n", - "The items are separated by commas and enclosed in curly braces.\n", + "Cada elemento consiste en una clave y un valor separados por dos puntos.\n", + "Los elementos se separan con comas y se encierran entre llaves.\n", "\n", - "Another way to create a dictionary is to use the `dict` function.\n", - "We can make an empty dictionary like this." + "Otra forma de crear un diccionario es usar la función `dict`.\n", + "Podemos crear un diccionario vacío así." ] }, { @@ -331,7 +331,7 @@ "id": "bfb215c9", "metadata": {}, "source": [ - "And we can make a copy of a dictionary like this." + "Y podemos hacer una copia de un diccionario así." ] }, { @@ -350,7 +350,7 @@ "id": "966c5539", "metadata": {}, "source": [ - "It is often useful to make a copy before performing operations that modify dictionaries." + "A menudo es útil hacer una copia antes de realizar operaciones que modifican diccionarios." ] }, { @@ -360,9 +360,9 @@ "tags": [] }, "source": [ - "## The in operator\n", + "## El operador in\n", "\n", - "The `in` operator works on dictionaries, too; it tells you whether something appears as a *key* in the dictionary." + "El operador `in` también funciona con diccionarios; te dice si algo aparece como *clave* en el diccionario." ] }, { @@ -380,7 +380,7 @@ "id": "80f6b264", "metadata": {}, "source": [ - "The `in` operator does *not* check whether something appears as a value." + "El operador `in` *no* comprueba si algo aparece como valor." ] }, { @@ -398,7 +398,7 @@ "id": "84856c8b", "metadata": {}, "source": [ - "To see whether something appears as a value in a dictionary, you can use the method `values`, which returns a sequence of values, and then use the `in` operator." + "Para ver si algo aparece como valor en un diccionario, puedes usar el método `values`, que devuelve una secuencia de valores, y luego usar el operador `in`." ] }, { @@ -416,8 +416,8 @@ "id": "45dc3d16", "metadata": {}, "source": [ - "The items in a Python dictionary are stored in a **hash table**, which is a way of organizing data that has a remarkable property: the `in` operator takes about the same amount of time no matter how many items are in the dictionary.\n", - "That makes it possible to write some remarkably efficient algorithms." + "Los elementos de un diccionario de Python se almacenan en una **hash table**, que es una forma de organizar datos con una propiedad notable: el operador `in` tarda aproximadamente la misma cantidad de tiempo sin importar cuántos elementos haya en el diccionario.\n", + "Eso hace posible escribir algunos algoritmos notablemente eficientes." ] }, { @@ -437,8 +437,8 @@ "id": "bba0522c", "metadata": {}, "source": [ - "To demonstrate, we'll compare two algorithms for finding pairs of words where one is the reverse of another -- like `stressed` and `desserts`.\n", - "We'll start by reading the word list." + "Para demostrarlo, compararemos dos algoritmos para encontrar pares de palabras donde una es la inversa de la otra, como `stressed` y `desserts`.\n", + "Empezaremos leyendo la lista de palabras." ] }, { @@ -457,7 +457,7 @@ "id": "ab29fb8a", "metadata": {}, "source": [ - "And here's `reverse_word` from the previous chapter." + "Y aquí está `reverse_word` del capítulo anterior." ] }, { @@ -476,8 +476,8 @@ "id": "93f7ac1b", "metadata": {}, "source": [ - "The following function loops through the words in the list.\n", - "For each one, it reverses the letters and then checks whether the reversed word is in the word list." + "La siguiente función recorre las palabras de la lista.\n", + "Para cada una, invierte las letras y luego comprueba si la palabra invertida está en la palabra lista." ] }, { @@ -500,9 +500,9 @@ "id": "d4ebb84d", "metadata": {}, "source": [ - "This function takes more than a minute to run.\n", - "The problem is that the `in` operator checks the words in the list one at a time, starting at the beginning.\n", - "If it doesn't find what it's looking for -- which happens most of the time -- it has to search all the way to the end." + "Esta función tarda más de un minuto en ejecutarse.\n", + "El problema es que el operador `in` comprueba las palabras de la lista una por una, empezando por el principio.\n", + "Si no encuentra lo que busca, que ocurre la mayor parte del tiempo, tiene que buscar hasta el final." ] }, { @@ -512,8 +512,8 @@ "tags": [] }, "source": [ - "To measure how long a function takes, we can use `%time` which is one of Jupyter's \"built-in magic commands\".\n", - "These commands are not part of the Python language, so they might not work in other development environments." + "Para medir cuánto tarda una función, podemos usar `%time`, que es uno de los \"built-in magic commands\" de Jupyter.\n", + "Estos comandos no forman parte del lenguaje Python, así que puede que no funcionen en otros entornos de desarrollo." ] }, { @@ -533,8 +533,8 @@ "id": "2acb6c50", "metadata": {}, "source": [ - "And the `in` operator is inside the loop, so it runs once for each word.\n", - "Since there are more than 100,000 words in the list, and for each one we check more than 100,000 words, the total number of comparisons is the number of words squared -- roughly -- which is almost 13 billion. " + "Y el operador `in` está dentro del bucle, así que se ejecuta una vez por cada palabra.\n", + "Como hay más de 100 000 palabras en la lista, y para cada una comprobamos más de 100 000 palabras, el número total de comparaciones es el número de palabras al cuadrado -- aproximadamente --, que es casi 13 mil millones." ] }, { @@ -552,8 +552,8 @@ "id": "5dbf01b7", "metadata": {}, "source": [ - "We can make this function much faster with a dictionary.\n", - "The following loop creates a dictionary that contains the words as keys." + "Podemos hacer que esta función sea mucho más rápida con un diccionario.\n", + "El siguiente bucle crea un diccionario que contiene las palabras como claves." ] }, { @@ -573,9 +573,9 @@ "id": "b7f6a1b7", "metadata": {}, "source": [ - "The values in `word_dict` are all `1`, but they could be anything, because we won't ever look them up -- we will only use this dictionary to check whether a key exists.\n", + "Los valores en `word_dict` son todos `1`, pero podrían ser cualquier cosa, porque nunca los vamos a buscar; solo usaremos este diccionario para comprobar si existe una clave.\n", "\n", - "Now here's a version of the previous function that replaces `word_list` with `word_dict`." + "Ahora aquí tienes una versión de la función anterior que reemplaza `word_list` por `word_dict`." ] }, { @@ -598,7 +598,7 @@ "id": "5f41e54c", "metadata": {}, "source": [ - "This function takes less than one hundredth of a second, so it's about 10,000 times faster than the previous version." + "Esta función tarda menos de una centésima de segundo, así que es unas 10 000 veces más rápida que la versión anterior." ] }, { @@ -606,8 +606,8 @@ "id": "4cd91c99", "metadata": {}, "source": [ - "In general, the time it takes to find an element in a list is proportional to the length of the list.\n", - "The time it takes to find a key in a dictionary is almost constant -- regardless of the number of items." + "En general, el tiempo que se tarda en encontrar un elemento en una lista es proporcional a la longitud de la lista.\n", + "El tiempo que se tarda en encontrar una clave en un diccionario es casi constante, independientemente del número de elementos." ] }, { @@ -627,11 +627,11 @@ "id": "b3bfa8a5", "metadata": {}, "source": [ - "## A collection of counters\n", + "## Una colección de contadores\n", "\n", - "Suppose you are given a string and you want to count how many times each letter appears.\n", - "A dictionary is a good tool for this job.\n", - "We'll start with an empty dictionary." + "Supongamos que recibes un string y quieres contar cuántas veces aparece cada letra.\n", + "Un diccionario es una buena herramienta para este trabajo.\n", + "Empezaremos con un diccionario vacío." ] }, { @@ -649,8 +649,8 @@ "id": "34a9498a", "metadata": {}, "source": [ - "As we loop through the letters in the string, suppose we see the letter `'a'` for the first time.\n", - "We can add it to the dictionary like this." + "Mientras recorremos las letras del string, supongamos que vemos la letra `'a'` por primera vez.\n", + "Podemos añadirla al diccionario así." ] }, { @@ -668,8 +668,8 @@ "id": "bca9fa11", "metadata": {}, "source": [ - "The value `1` indicates that we have seen the letter once.\n", - "Later, if we see the same letter again, we can increment the counter like this." + "El valor `1` indica que hemos visto la letra una vez.\n", + "Más tarde, si volvemos a ver la misma letra, podemos incrementar el contador así." ] }, { @@ -687,7 +687,7 @@ "id": "274ea014", "metadata": {}, "source": [ - "Now the value associated with `'a'` is `2`, because we've seen the letter twice." + "Ahora el valor asociado con `'a'` es `2`, porque hemos visto la letra dos veces." ] }, { @@ -705,7 +705,7 @@ "id": "2ca8f99d", "metadata": {}, "source": [ - "The following function uses these features to count the number of times each letter appears in a string." + "La siguiente función usa estas características para contar el número de veces que aparece cada letra en un string." ] }, { @@ -730,10 +730,10 @@ "id": "735c758b", "metadata": {}, "source": [ - "Each time through the loop, if `letter` is not in the dictionary, we create a new item with key `letter` and value `1`.\n", - "If `letter` is already in the dictionary we increment the value associated with `letter`.\n", + "Cada vez que pasa por el bucle, si `letter` no está en el diccionario, creamos un nuevo elemento con clave `letter` y valor `1`.\n", + "Si `letter` ya está en el diccionario, incrementamos el valor asociado con `letter`.\n", "\n", - "Here's an example." + "Aquí tienes un ejemplo." ] }, { @@ -752,7 +752,7 @@ "id": "8ac1fea4", "metadata": {}, "source": [ - "The items in `counter` show that the letter `'b'` appears once, `'r'` appears twice, and so on." + "Los elementos de `counter` muestran que la letra `'b'` aparece una vez, `'r'` aparece dos veces, y así sucesivamente." ] }, { @@ -760,10 +760,10 @@ "id": "912bdf5d", "metadata": {}, "source": [ - "## Looping and dictionaries\n", + "## Looping y diccionarios\n", "\n", - "If you use a dictionary in a `for` statement, it traverses the keys of the dictionary.\n", - "To demonstrate, let's make a dictionary that counts the letters in `'banana'`." + "Si usas un diccionario en una sentencia `for`, recorre las claves del diccionario.\n", + "Para demostrarlo, hagamos un diccionario que cuente las letras de `'banana'`." ] }, { @@ -782,7 +782,7 @@ "id": "fe263f3d", "metadata": {}, "source": [ - "The following loop prints the keys, which are the letters." + "El siguiente bucle imprime las claves, que son las letras." ] }, { @@ -801,7 +801,7 @@ "id": "bf1b7824", "metadata": {}, "source": [ - "To print the values, we can use the `values` method." + "Para imprimir los valores, podemos usar el método `values`." ] }, { @@ -820,7 +820,7 @@ "id": "721135be", "metadata": {}, "source": [ - "To print the keys and values, we can loop through the keys and look up the corresponding values." + "Para imprimir las claves y los valores, podemos recorrer las claves y buscar los valores correspondientes." ] }, { @@ -840,7 +840,7 @@ "id": "efa1bce5", "metadata": {}, "source": [ - "In the next chapter, we'll see a more concise way to do the same thing." + "En el próximo capítulo, veremos una forma más concisa de hacer lo mismo." ] }, { @@ -848,10 +848,10 @@ "id": "a160c0ef", "metadata": {}, "source": [ - "## Lists and dictionaries\n", + "## Listas y diccionarios\n", "\n", - "You can put a list in a dictionary as a value.\n", - "For example, here's a dictionary that maps from the number `4` to a list of four letters." + "Puedes poner una lista en un diccionario como valor.\n", + "Por ejemplo, aquí tienes un diccionario que mapea el número `4` a una lista de cuatro letras." ] }, { @@ -870,8 +870,8 @@ "id": "815a829f", "metadata": {}, "source": [ - "But you can't put a list in a dictionary as a key.\n", - "Here's what happens if we try." + "Pero no puedes poner una lista en un diccionario como clave.\n", + "Esto es lo que ocurre si lo intentamos." ] }, { @@ -893,17 +893,17 @@ "id": "2469b08a", "metadata": {}, "source": [ - "I mentioned earlier that dictionaries use hash tables, and that means that the keys have to be **hashable**.\n", + "Mencioné antes que los diccionarios usan hash tables, y eso significa que las claves tienen que ser **hasheable**.\n", "\n", - "A **hash** is a function that takes a value (of any kind) and returns an integer.\n", - "Dictionaries use these integers, called hash values, to store and look up keys.\n", + "Un **hash** es una función que toma un valor (de cualquier tipo) y devuelve un entero.\n", + "Los diccionarios usan estos enteros, llamados hash valores, para almacenar y buscar claves.\n", "\n", - "This system only works if a key is immutable, so its hash value is always the same.\n", - "But if a key is mutable, its hash value could change, and the dictionary would not work.\n", - "That's why keys have to be hashable, and why mutable types like lists aren't.\n", + "Este sistema solo funciona si una clave es inmutable, de modo que su hash valor siempre sea el mismo.\n", + "Pero si una clave es mutable, su hash valor podría cambiar, y el diccionario no funcionaría.\n", + "Por eso las claves tienen que ser hasheables, y por eso tipos mutables como las listas no lo son.\n", "\n", - "Since dictionaries are mutable, they can't be used as keys, either.\n", - "But they *can* be used as values." + "Como los diccionarios son mutables, tampoco pueden usarse como claves.\n", + "Pero *sí* pueden usarse como valores." ] }, { @@ -913,13 +913,13 @@ "tags": [] }, "source": [ - "## Accumulating a list\n", + "## Acumular una lista\n", "\n", - "For many programming tasks, it is useful to loop through one list or dictionary while building another.\n", - "As an example, we'll loop through the words in `word_dict` and make a list of palindromes -- that is, words that are spelled the same backward and forward, like \"noon\" and \"rotator\".\n", + "Para muchas tareas de programación, es útil recorrer una lista o diccionario mientras se construye otro.\n", + "Como ejemplo, recorreremos las palabras en `word_dict` y haremos una lista de palíndromos, es decir, palabras que se escriben igual hacia atrás y hacia adelante, como \"noon\" y \"rotator\".\n", "\n", - "In the previous chapter, one of the exercises asked you to write a function that checks whether a word is a palindrome.\n", - "Here's a solution that uses `reverse_word`." + "En el capítulo anterior, uno de los ejercicios te pidió escribir una función que comprueba si una palabra es un palíndromo.\n", + "Aquí tienes una solución que usa `reverse_word`." ] }, { @@ -939,7 +939,7 @@ "id": "af545fcd", "metadata": {}, "source": [ - "If we loop through the words in `word_dict`, we can count the number of palindromes like this." + "Si recorremos las palabras en `word_dict`, podemos contar el número de palíndromos así." ] }, { @@ -963,15 +963,15 @@ "id": "73c1ce1e", "metadata": {}, "source": [ - "By now, this pattern is familiar.\n", + "A estas alturas, este patrón resulta familiar.\n", "\n", - "* Before the loop, `count` is initialized to `0`.\n", + "* Antes del bucle, `count` se inicializa a `0`.\n", "\n", - "* Inside the loop, if `word` is a palindrome, we increment `count`.\n", + "* Dentro del bucle, si `word` es un palíndromo, incrementamos `count`.\n", "\n", - "* When the loop ends, `count` contains the total number of palindromes.\n", + "* Cuando termina el bucle, `count` contiene el número total de palíndromos.\n", "\n", - "We can use a similar pattern to make a list of palindromes." + "Podemos usar un patrón similar para hacer una lista de palíndromos." ] }, { @@ -995,18 +995,18 @@ "id": "be909f3b", "metadata": {}, "source": [ - "Here's how it works:\n", + "Así es como funciona:\n", "\n", - "* Before the loop, `palindromes` is initialized with an empty list.\n", + "* Antes del bucle, `palindromes` se inicializa con una lista vacía.\n", "\n", - "* Inside the loop, if `word` is a palindrome, we append it to the end of `palindromes`.\n", + "* Dentro del bucle, si `word` es un palíndromo, lo añadimos al final de `palindromes`.\n", "\n", - "* When the loop ends, `palindromes` is a list of palindromes.\n", + "* Cuando termina el bucle, `palindromes` es una lista de palíndromos.\n", "\n", - "In this loop, `palindromes` is used as an **accumulator**, which is a variable that collects or accumulates data during a computation.\n", + "En este bucle, `palindromes` se usa como **accumulator**, que es una variable que recoge o acumula datos durante una computación.\n", "\n", - "Now suppose we want to select only palindromes with seven or more letters.\n", - "We can loop through `palindromes` and make a new list that contains only long palindromes." + "Ahora supongamos que queremos seleccionar solo palíndromos con siete o más letras.\n", + "Podemos recorrer `palindromes` y hacer una nueva lista que contenga solo palíndromos largos." ] }, { @@ -1030,7 +1030,7 @@ "id": "fa8ed275", "metadata": {}, "source": [ - "Looping through a list like this, selecting some elements and omitting others, is called **filtering**." + "Recorrer una lista así, seleccionando algunos elementos y omitiendo otros, se llama **filtrado**." ] }, { @@ -1042,7 +1042,7 @@ "source": [ "## Memos\n", "\n", - "If you ran the `fibonacci` function from [Chapter 6](section_fibonacci), maybe you noticed that the bigger the argument you provide, the longer the function takes to run." + "Si ejecutaste la función `fibonacci` del [Capítulo 6](section_fibonacci), quizá notaste que cuanto mayor es el argumento que proporcionas, más tarda la función en ejecutarse." ] }, { @@ -1067,9 +1067,9 @@ "id": "1b5203c2", "metadata": {}, "source": [ - "Furthermore, the run time increases quickly.\n", - "To understand why, consider the following figure, which shows the **call graph** for\n", - "`fibonacci` with `n=4`:" + "Además, el tiempo de ejecución aumenta rápidamente.\n", + "Para entender por qué, considera la siguiente figura, que muestra el **call graph** de\n", + "`fibonacci` con `n=4`:" ] }, { @@ -1165,16 +1165,16 @@ "id": "4ee2a87c", "metadata": {}, "source": [ - "A call graph shows a set of function frames, with lines connecting each frame to the frames of the functions it calls.\n", - "At the top of the graph, `fibonacci` with `n=4` calls `fibonacci` with ` n=3` and `n=2`.\n", - "In turn, `fibonacci` with `n=3` calls `fibonacci` with `n=2` and `n=1`. And so on.\n", + "Un call graph muestra un conjunto de función frames, con líneas que conectan cada frame con los frames de las funciones que llama.\n", + "En la parte superior del graph, `fibonacci` con `n=4` llama a `fibonacci` con ` n=3` y `n=2`.\n", + "A su vez, `fibonacci` con `n=3` llama a `fibonacci` con `n=2` y `n=1`. Y así sucesivamente.\n", "\n", - "Count how many times `fibonacci(0)` and `fibonacci(1)` are called. \n", - "This is an inefficient solution to the problem, and it gets worse as the argument gets bigger.\n", + "Cuenta cuántas veces se llama a `fibonacci(0)` y `fibonacci(1)`.\n", + "Esta es una solución ineficiente al problema, y empeora a medida que el argumento crece.\n", "\n", - "One solution is to keep track of values that have already been computed by storing them in a dictionary.\n", - "A previously computed value that is stored for later use is called a **memo**.\n", - "Here is a \"memoized\" version of `fibonacci`:" + "Una solución es llevar un registro de los valores que ya se han calculado almacenándolos en un diccionario.\n", + "Un valor calculado previamente que se almacena para usarlo más tarde se llama **memo**.\n", + "Aquí tienes una versión \"memoized\" de `fibonacci`:" ] }, { @@ -1200,16 +1200,16 @@ "id": "d2ac4dd7", "metadata": {}, "source": [ - "`known` is a dictionary that keeps track of the Fibonacci numbers we already know\n", - "It starts with two items: `0` maps to `0` and `1` maps to `1`.\n", + "`known` es un diccionario que lleva el registro de los números de Fibonacci que ya conocemos.\n", + "Empieza con dos elementos: `0` mapea a `0` y `1` mapea a `1`.\n", "\n", - "Whenever `fibonacci_memo` is called, it checks `known`.\n", - "If the result is already there, it can return immediately.\n", - "Otherwise it has to compute the new value, add it to the dictionary, and return it.\n", + "Cada vez que se llama a `fibonacci_memo`, comprueba `known`.\n", + "Si el resultado ya está ahí, puede devolverlo inmediatamente.\n", + "De lo contrario, tiene que calcular el nuevo valor, añadirlo al diccionario y devolverlo.\n", "\n", - "Comparing the two functions, `fibonacci(40)` takes about 30 seconds to run.\n", - "`fibonacci_memo(40)` takes about 30 microseconds, so it's a million times faster.\n", - "In the notebook for this chapter, you'll see where these measurements come from." + "Comparando las dos funciones, `fibonacci(40)` tarda unos 30 segundos en ejecutarse.\n", + "`fibonacci_memo(40)` tarda unos 30 microsegundos, así que es un millón de veces más rápida.\n", + "En el notebook de este capítulo, verás de dónde vienen estas mediciones." ] }, { @@ -1241,18 +1241,18 @@ "id": "ec969e51", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "As you work with bigger datasets it can become unwieldy to debug by printing and checking the output by hand. Here are some suggestions for debugging large datasets:\n", + "A medida que trabajas con datasets más grandes, puede volverse inmanejable depurar imprimiendo y comprobando la salida a mano. Aquí tienes algunas sugerencias para depurar datasets grandes:\n", "\n", - "1. Scale down the input: If possible, reduce the size of the dataset. For example if the\n", - " program reads a text file, start with just the first 10 lines, or\n", - " with the smallest example you can find. You can either edit the\n", - " files themselves, or (better) modify the program so it reads only\n", - " the first `n` lines.\n", + "1. Reduce el tamaño de la entrada: Si es posible, reduce el tamaño del dataset. Por ejemplo, si el\n", + " programa lee un archivo de texto, empieza solo con las primeras 10 líneas, o\n", + " con el ejemplo más pequeño que puedas encontrar. Puedes editar los\n", + " archivos directamente o, mejor, modificar el programa para que lea solo\n", + " las primeras `n` líneas.\n", "\n", - " If there is an error, you can reduce `n` to the smallest value where the error occurs.\n", - " As you find and correct errors, you can increase `n` gradually." + " Si hay un error, puedes reducir `n` al valor más pequeño donde ocurre el error.\n", + " A medida que encuentres y corrijas errores, puedes aumentar `n` gradualmente." ] }, { @@ -1260,11 +1260,11 @@ "id": "1a62288b", "metadata": {}, "source": [ - "2. Check summaries and types: Instead of printing and checking the entire dataset, consider\n", - " printing summaries of the data -- for example, the number of items in\n", - " a dictionary or the total of a list of numbers.\n", + "2. Comprueba resúmenes y tipos: En lugar de imprimir y comprobar el dataset completo, considera\n", + " imprimir resúmenes de los datos; por ejemplo, el número de elementos en\n", + " un diccionario o el total de una lista de números.\n", "\n", - " A common cause of runtime errors is a value that is not the right type. For debugging this kind of error, it is often enough to print the type of a value." + " Una causa común de errores en tiempo de ejecución es un valor que no tiene el tipo correcto. Para depurar de este tipo de error, a menudo basta con imprimir el tipo de un valor." ] }, { @@ -1272,13 +1272,13 @@ "id": "c749ea3c", "metadata": {}, "source": [ - "3. Write self-checks: Sometimes you can write code to check for errors automatically. For\n", - " example, if you are computing the average of a list of numbers, you\n", - " could check that the result is not greater than the largest element\n", - " in the list or less than the smallest. This is called a \"sanity\n", - " check\" because it detects results that are \"insane\".\n", + "3. Escribe autocomprobaciones: A veces puedes escribir código para comprobar errores automáticamente. Por\n", + " ejemplo, si estás calculando la media de una lista de números, podrías\n", + " comprobar que el resultado no sea mayor que el elemento más grande\n", + " de la lista ni menor que el más pequeño. Esto se llama una \"sanity\n", + " check\" porque detecta resultados que son \"insane\".\n", "\n", - " Another kind of check compares the results of two different computations to see if they are consistent. This is called a \"consistency check\"." + " Otro tipo de comprobación compara los resultados de dos computaciones diferentes para ver si son consistentes. Esto se llama una \"consistency check\"." ] }, { @@ -1286,9 +1286,9 @@ "id": "749b91e9", "metadata": {}, "source": [ - "4. Format the output: Formatting debugging output can make it easier to spot an error. We saw an example in [Chapter 6](section_debugging_factorial). Another tool you might find useful is the `pprint` module, which provides a `pprint` function that displays built-in types in a more human-readable format (`pprint` stands for \"pretty print\").\n", + "4. Formatea la salida: Formatear la salida de depuración puede facilitar detectar un error. Vimos un ejemplo en [Capítulo 6](section_depuración_factorial). Otra herramienta que puede resultarte útil es el módulo `pprint`, que proporciona una función `pprint` que muestra tipos integrados en un formato más legible para humanos (`pprint` significa \"pretty print\").\n", "\n", - " Again, time you spend building scaffolding can reduce the time you spend debugging." + " De nuevo, el tiempo que dediques a construir código de apoyo puede reducir el tiempo que dedicas a depurar." ] }, { @@ -1296,44 +1296,44 @@ "id": "9820175f", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**dictionary:**\n", - " An object that contains key-value pairs, also called items.\n", + "**diccionario:**\n", + " Un objeto que contiene pares clave-valor, también llamados elementos.\n", "\n", - "**item:**\n", - " In a dictionary, another name for a key-value pair.\n", + "**elemento:**\n", + " En un diccionario, otro nombre para un par clave-valor.\n", "\n", - "**key:**\n", - " An object that appears in a dictionary as the first part of a key-value pair.\n", + "**clave:**\n", + " Un objeto que aparece en un diccionario como la primera parte de un par clave-valor.\n", "\n", - "**value:**\n", - " An object that appears in a dictionary as the second part of a key-value pair. This is more specific than our previous use of the word \"value\".\n", + "**valor:**\n", + " Un objeto que aparece en un diccionario como la segunda parte de un par clave-valor. Esto es más específico que nuestro uso anterior de la palabra \"valor\".\n", "\n", - "**mapping:**\n", - " A relationship in which each element of one set corresponds to an element of another set.\n", + "**mapeo:**\n", + " Una relación en la que cada elemento de un conjunto corresponde a un elemento de otro conjunto.\n", "\n", "**hash table:**\n", - "A collection of key-value pairs organized so that we can look up a key and find its value efficiently.\n", + "Una colección de pares clave-valor organizada para que podamos buscar una clave y encontrar su valor de forma eficiente.\n", "\n", - "**hashable:**\n", - " Immutable types like integers, floats and strings are hashable.\n", - " Mutable types like lists and dictionaries are not.\n", + "**hasheable:**\n", + "Tipos inmutables como enteros, floats y strings son hasheable.\n", + "Tipos mutables como listas y diccionarios no lo son.\n", "\n", - "**hash function:**\n", - "A function that takes an object and computes an integer that is used to locate a key in a hash table.\n", + "**función hash:**\n", + "Una función que toma un objeto y calcula un entero que se usa para localizar una clave en una hash table.\n", "\n", "**accumulator:**\n", - " A variable used in a loop to add up or accumulate a result.\n", + " Una variable usada en un bucle para sumar o acumular un resultado.\n", "\n", - "**filtering:**\n", - "Looping through a sequence and selecting or omitting elements.\n", + "**filtrado:**\n", + "Recorrer una secuencia y seleccionar u omitir elementos.\n", "\n", "**call graph:**\n", - "A diagram that shows every frame created during the execution of a program, with an arrow from each caller to each callee.\n", + "Un diagrama que muestra cada frame creado durante la ejecución de un programa, con una flecha desde cada código que llama hacia cada callee.\n", "\n", "**memo:**\n", - " A computed value stored to avoid unnecessary future computation." + " Un valor calculado almacenado para evitar computación futura innecesaria." ] }, { @@ -1341,7 +1341,7 @@ "id": "906c1236", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1364,13 +1364,13 @@ "id": "170f1deb", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In this chapter, I said the keys in a dictionary have to be hashable and I gave a short explanation. If you would like more details, ask a virtual assistant, \"Why do keys in Python dictionaries have to be hashable?\"\n", + "En este capítulo, dije que las claves de un diccionario tienen que ser hasheabless y di una explicación breve. Si quieres más detalles, pregunta a un asistente virtual: \"¿Por qué las claves de los diccionarios de Python tienen que ser hasheabless?\"\n", "\n", - "In [a previous section](section_dictionary_in_operator), we stored a list of words as keys in a dictionary so that we could use an efficient version of the `in` operator.\n", - "We could have done the same thing using a `set`, which is another built-in data type.\n", - "Ask a virtual assistant, \"How do I make a Python set from a list of strings and check whether a string is an element of the set?\"" + "En [una sección anterior](section_dictionary_in_operator), almacenamos una lista de palabras como claves en un diccionario para poder usar una versión eficiente del operador `in`.\n", + "Podríamos haber hecho lo mismo usando un `set`, que es otro tipo de dato integrado.\n", + "Pregunta a un asistente virtual: \"How do I make a Python set from a lista of strings and check whether a string is an elemento of the set?\"" ] }, { @@ -1378,11 +1378,11 @@ "id": "badf7d65", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Dictionaries have a method called `get` that takes a key and a default value. \n", - "If the key appears in the dictionary, `get` returns the corresponding value; otherwise it returns the default value.\n", - "For example, here's a dictionary that maps from the letters in a string to the number of times they appear." + "Los diccionarios tienen un método llamado `get` que toma una clave y un valor por defecto.\n", + "Si la clave aparece en el diccionario, `get` devuelve el valor correspondiente; de lo contrario devuelve el valor por defecto.\n", + "Por ejemplo, aquí tienes un diccionario que mapea las letras de un string al número de veces que aparecen." ] }, { @@ -1400,7 +1400,7 @@ "id": "c3f6458d", "metadata": {}, "source": [ - "If we look up a letter that appears in the word, `get` returns the number of times it appears." + "Si buscamos una letra que aparece en la palabra, `get` devuelve el número de veces que aparece." ] }, { @@ -1418,7 +1418,7 @@ "id": "49bbff3e", "metadata": {}, "source": [ - "If we look up a letter that doesn't appear, we get the default value, `0`." + "Si buscamos una letra que no aparece, obtenemos el valor por defecto, `0`." ] }, { @@ -1436,8 +1436,8 @@ "id": "4ac3210f", "metadata": {}, "source": [ - "Use `get` to write a more concise version of `value_counts`.\n", - "You should be able to eliminate the `if` statement." + "Usa `get` para escribir una versión más concisa de `value_counts`.\n", + "Deberías poder eliminar la sentencia `if`." ] }, { @@ -1445,12 +1445,12 @@ "id": "5413af6e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "What is the longest word you can think of where each letter appears only once?\n", - "Let's see if we can find one longer than `unpredictably`.\n", + "¿Cuál es la palabra más larga que se te ocurre donde cada letra aparece solo una vez?\n", + "Veamos si podemos encontrar una más larga que `unpredictably`.\n", "\n", - "Write a function named `has_duplicates` that takes a sequence -- like a list or string -- as a parameter and returns `True` if there is any element that appears in the sequence more than once." + "Escribe una función llamada `has_duplicates` que tome una secuencia, como una lista o string, como parameter y devuelva `True` si hay algún elemento que aparece en la secuencia más de una vez." ] }, { @@ -1460,7 +1460,7 @@ "tags": [] }, "source": [ - "To get you started, here's an outline of the function with doctests." + "Para empezar, aquí tienes un esquema de la función con doctests." ] }, { @@ -1504,7 +1504,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1531,7 +1531,7 @@ "tags": [] }, "source": [ - "You can use this loop to find the longest words with no repeated letters." + "Puedes usar este bucle para encontrar las palabras más largas sin letras repetidas." ] }, { @@ -1557,11 +1557,11 @@ "id": "afd5f3b6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `find_repeats` that takes a dictionary that maps from each key to a counter, like the result from `value_counts`.\n", - "It should loop through the dictionary and return a list of keys that have counts greater than `1`.\n", - "You can use the following outline to get started." + "Escribe una función llamada `find_repeats` que tome un diccionario que mapea cada clave a un contador, como el resultado de `value_counts`.\n", + "Debe recorrer el diccionario y devolver una lista de claves que tengan recuentos mayores que `1`.\n", + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1598,8 +1598,8 @@ "tags": [] }, "source": [ - "You can use the following examples to test your code.\n", - "First, we'll make a dictionary that maps from letters to counts." + "Puedes usar los siguientes ejemplos para probar tu código.\n", + "Primero, haremos un diccionario que mapea letras a recuentos." ] }, { @@ -1622,7 +1622,7 @@ "tags": [] }, "source": [ - "The result from `find_repeats` should be `['a', 'n']`." + "El resultado de `find_repeats` debería ser `['a', 'n']`." ] }, { @@ -1645,8 +1645,8 @@ "tags": [] }, "source": [ - "Here's another example that starts with a list of numbers.\n", - "The result should be `[1, 2]`." + "Aquí tienes otro ejemplo que empieza con una lista de números.\n", + "El resultado debería ser `[1, 2]`." ] }, { @@ -1668,9 +1668,9 @@ "id": "1c700d84", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Suppose you run `value_counts` with two different words and save the results in two dictionaries." + "Supongamos que ejecutas `value_counts` con dos palabras diferentes y guardas los resultados en dos diccionarios." ] }, { @@ -1689,11 +1689,11 @@ "id": "deb14c7a", "metadata": {}, "source": [ - "Each dictionary maps from a set of letters to the number of times they appear.\n", - "Write a function called `add_counters` that takes two dictionaries like this and returns a new dictionary that contains all of the letters and the total number of times they appear in either word.\n", + "Cada diccionario mapea un conjunto de letras al número de veces que aparecen.\n", + "Escribe una función llamada `add_counters` que tome dos diccionarios como estos y devuelva un nuevo diccionario que contenga todas las letras y el número total de veces que aparecen en cualquiera de las dos palabras.\n", "\n", - "There are many ways to solve this problem.\n", - "Once you have a working solution, consider asking a virtual assistant for different solutions." + "Hay muchas formas de resolver este problema.\n", + "Cuando tengas una solución que funcione, considera pedir a un asistente virtual soluciones diferentes." ] }, { @@ -1721,16 +1721,16 @@ "id": "f88110a9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A word is \"interlocking\" if we can split it into two words by taking alternating letters.\n", - "For example, \"schooled\" is an interlocking word because it can be split into \"shoe\" and \"cold\".\n", + "Una palabra es \"interlocking\" si podemos dividirla en dos palabras tomando letras alternas.\n", + "Por ejemplo, \"schooled\" es una palabra interlocking porque puede dividirse en \"shoe\" y \"cold\".\n", "\n", - "To select alternating letters from a string, you can use a slice operator with three components that indicate where to start, where to stop, and the \"step size\" between the letters.\n", + "Para seleccionar letras alternas de un string, puedes usar un operador de porción con tres componentes que indican dónde empezar, dónde detenerse y el \"step size\" entre las letras.\n", "\n", - "In the following slice, the first component is `0`, so we start with the first letter.\n", - "The second component is `None`, which means we should go all the way to the end of the string.\n", - "And the third component is `2`, so there are two steps between the letters we select." + "En el siguiente porción, el primer componente es `0`, así que empezamos con la primera letra.\n", + "El segundo componente es `None`, lo que significa que debemos llegar hasta el final del string.\n", + "Y el tercer componente es `2`, así que hay dos pasos entre las letras que seleccionamos." ] }, { @@ -1750,8 +1750,8 @@ "id": "d432332d", "metadata": {}, "source": [ - "Instead of providing `None` as the second component, we can get the same effect by leaving it out altogether.\n", - "For example, the following slice selects alternating letters, starting with the second letter." + "En lugar de proporcionar `None` como segundo componente, podemos obtener el mismo efecto omitiéndolo por completo.\n", + "Por ejemplo, el siguiente porción selecciona letras alternas, empezando por la segunda letra." ] }, { @@ -1770,7 +1770,7 @@ "id": "c8c4e3ba", "metadata": {}, "source": [ - "Write a function called `is_interlocking` that takes a word as an argument and returns `True` if it can be split into two interlocking words." + "Escribe una función llamada `is_interlocking` que tome una palabra como argumento y devuelva `True` si puede dividirse en dos palabras interlocking." ] }, { @@ -1790,7 +1790,7 @@ "tags": [] }, "source": [ - "You can use the following loop to find the interlocking words in the word list." + "Puedes usar el siguiente bucle para encontrar las palabras interlocking en la palabra lista." ] }, { @@ -1828,7 +1828,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/chapters/chap11.ipynb b/chapters/chap11.ipynb index e10980c..67b115c 100644 --- a/chapters/chap11.ipynb +++ b/chapters/chap11.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -43,16 +43,16 @@ "tags": [] }, "source": [ - "# Tuples\n", + "# Tuplas\n", "\n", - "This chapter introduces one more built-in type, the tuple, and then shows how lists, dictionaries, and tuples work together.\n", - "It also presents tuple assignment and a useful feature for functions with variable-length argument lists: the packing and unpacking operators.\n", + "Este capítulo presenta un tipo integrado más, la tupla, y luego muestra cómo listas, diccionarios y tuplas trabajan juntos.\n", + "También presenta la asignación de tuplas y una característica útil para funciones con listas de argumentos de longitud variable: los operadores de empaquetado y desempaquetado.\n", "\n", - "In the exercises, we'll use tuples, along with lists and dictionaries, to solve more word puzzles and implement efficient algorithms.\n", + "En los ejercicios, usaremos tuplas, junto con listas y diccionarios, para resolver más puzles de palabras e implementar algoritmos eficientes.\n", "\n", - "One note: There are two ways to pronounce \"tuple\".\n", - "Some people say \"tuh-ple\", which rhymes with \"supple\".\n", - "But in the context of programming, most people say \"too-ple\", which rhymes with \"quadruple\"." + "Una nota: hay dos maneras de pronunciar \"tupla\".\n", + "Algunas personas dicen \"tuh-ple\", que rima con \"supple\".\n", + "Pero en el contexto de la programación, la mayoría dice \"too-ple\", que rima con \"quadruple\"." ] }, { @@ -60,12 +60,12 @@ "id": "19474596", "metadata": {}, "source": [ - "## Tuples are like lists\n", + "## Las tuplas son como listas\n", "\n", - "A tuple is a sequence of values. The values can be any type, and they are indexed by integers, so tuples are a lot like lists.\n", - "The important difference is that tuples are immutable.\n", + "Una tupla es una secuencia de valores. Los valores pueden ser de cualquier tipo, y se indexan con enteros, así que las tuplas se parecen mucho a las listas.\n", + "La diferencia importante es que las tuplas son inmutables.\n", "\n", - "To create a tuple, you can write a comma-separated list of values." + "Para crear una tupla, puedes escribir una lista de valores separados por comas." ] }, { @@ -84,7 +84,7 @@ "id": "a2ec15d8", "metadata": {}, "source": [ - "Although it is not necessary, it is common to enclose tuples in parentheses." + "Aunque no es necesario, es común encerrar las tuplas entre paréntesis." ] }, { @@ -103,7 +103,7 @@ "id": "9194a159", "metadata": {}, "source": [ - "To create a tuple with a single element, you have to include a final comma." + "Para crear una tupla con un solo elemento, tienes que incluir una coma final." ] }, { @@ -122,7 +122,7 @@ "id": "e39b95a5", "metadata": {}, "source": [ - "A single value in parentheses is not a tuple." + "Un único valor entre paréntesis no es una tupla." ] }, { @@ -141,8 +141,7 @@ "id": "a64bfb64", "metadata": {}, "source": [ - "Another way to create a tuple is the built-in function `tuple`. With no\n", - "argument, it creates an empty tuple." + "Otra forma de crear una tupla es la función integrada `tuple`. Sin argumentos, crea una tupla vacío." ] }, { @@ -161,8 +160,7 @@ "id": "f3447831", "metadata": {}, "source": [ - "If the argument is a sequence (string, list or tuple), the result is a\n", - "tuple with the elements of the sequence." + "Si el argumento es una secuencia (string, lista o tupla), el resultado es una tupla con los elementos de la secuencia." ] }, { @@ -181,10 +179,10 @@ "id": "2e48b980", "metadata": {}, "source": [ - "Because `tuple` is the name of a built-in function, you should avoid using it as a variable name.\n", + "Como `tuple` es el nombre de una función integrada, deberías evitar usarlo como nombre de variable.\n", "\n", - "Most list operators also work with tuples.\n", - "For example, the bracket operator indexes an element." + "La mayoría de los operadores de lista también funcionan con tuplas.\n", + "Por ejemplo, el operador de corchetes indexa un elemento." ] }, { @@ -202,7 +200,7 @@ "id": "2f702785", "metadata": {}, "source": [ - "And the slice operator selects a range of elements." + "Y el operador de porción selecciona un rango de elementos." ] }, { @@ -220,7 +218,7 @@ "id": "c9ed9af2", "metadata": {}, "source": [ - "The `+` operator concatenates tuples." + "El operador `+` concatena tuplas." ] }, { @@ -238,7 +236,7 @@ "id": "1d7dcd6d", "metadata": {}, "source": [ - "And the `*` operator duplicates a tuple a given number of times." + "Y el operador `*` duplica una tupla un número dado de veces." ] }, { @@ -256,7 +254,7 @@ "id": "a53ce8bd", "metadata": {}, "source": [ - "The `sorted` function works with tuples -- but the result is a list, not a tuple." + "La función `sorted` funciona con tuplas -- pero el resultado es una lista, no una tupla." ] }, { @@ -274,7 +272,7 @@ "id": "50e5cadc", "metadata": {}, "source": [ - "The `reversed` function also works with tuples." + "La función `reversed` también funciona con tuplas." ] }, { @@ -292,7 +290,7 @@ "id": "f6d973c5", "metadata": {}, "source": [ - "The result is a `reversed` object, which we can convert to a list or tuple." + "El resultado es un objeto `reversed`, que podemos convertir en una lista o en una tupla." ] }, { @@ -310,7 +308,7 @@ "id": "a7cb9ee6", "metadata": {}, "source": [ - "Based on the examples so far, it might seem like tuples are the same as lists." + "Según los ejemplos hasta ahora, podría parecer que las tuplas son iguales que las listas." ] }, { @@ -318,9 +316,9 @@ "id": "8c3f381e", "metadata": {}, "source": [ - "## But tuples are immutable\n", + "## Pero las tuplas son inmutables\n", "\n", - "If you try to modify a tuple with the bracket operator, you get a `TypeError`." + "Si intentas modificar una tupla con el operador de corchetes, obtienes un `TypeError`." ] }, { @@ -341,7 +339,7 @@ "id": "592ce99c", "metadata": {}, "source": [ - "And tuples don't have any of the methods that modify lists, like `append` and `remove`." + "Y las tuplas no tienen ninguno de los métodos que modifican listas, como `append` y `remove`." ] }, { @@ -363,10 +361,10 @@ "id": "70772ba2", "metadata": {}, "source": [ - "Recall that an \"attribute\" is a variable or method associated with an object -- this error message means that tuples don't have a method named `remove`.\n", + "Recuerda que un \"atributo\" es una variable o método asociado con un objeto -- este mensaje de error significa que las tuplas no tienen un método llamado `remove`.\n", "\n", - "Because tuples are immutable, they are hashable, which means they can be used as keys in a dictionary.\n", - "For example, the following dictionary contains two tuples as keys that map to integers." + "Como las tuplas son inmutables, son hasheables, lo que significa que pueden usarse como claves en un diccionario.\n", + "Por ejemplo, el siguiente diccionario contiene dos tuplas como claves que se asocian con enteros." ] }, { @@ -386,7 +384,7 @@ "id": "47ba17ab", "metadata": {}, "source": [ - "We can look up a tuple in a dictionary like this:" + "Podemos buscar una tupla en un diccionario así:" ] }, { @@ -404,7 +402,7 @@ "id": "f2c0a354", "metadata": {}, "source": [ - "Or if we have a variable that refers to a tuple, we can use it as a key." + "O, si tenemos una variable que se refiere a una tupla, podemos usarla como clave." ] }, { @@ -423,7 +421,7 @@ "id": "2ea8fc3c", "metadata": {}, "source": [ - "Tuples can also appear as values in a dictionary." + "Las tuplas también pueden aparecer como valores en un diccionario." ] }, { @@ -443,9 +441,9 @@ "id": "25655ab3", "metadata": {}, "source": [ - "## Tuple assignment\n", + "## Asignación de tupla\n", "\n", - "You can put a tuple of variables on the left side of an assignment, and a tuple of values on the right." + "Puedes poner una tupla de variables en el lado izquierdo de una asignación, y una tupla de valores en el lado derecho." ] }, { @@ -463,8 +461,8 @@ "id": "92c00ceb", "metadata": {}, "source": [ - "The values are assigned to the variables from left to right -- in this example, `a` gets the value `1` and `b` gets the value `2`.\n", - "We can display the results like this:" + "Los valores se asignan a las variables de izquierda a derecha -- en este ejemplo, `a` recibe el valor `1` y `b` recibe el valor `2`.\n", + "Podemos mostrar los resultados así:" ] }, { @@ -482,8 +480,8 @@ "id": "6362b36e", "metadata": {}, "source": [ - "More generally, if the left side of an assignment is a tuple, the right side can be any kind of sequence -- string, list or tuple. \n", - "For example, to split an email address into a user name and a domain, you could write:" + "De forma más general, si el lado izquierdo de una asignación es una tupla, el lado derecho puede ser cualquier tipo de secuencia -- string, lista o tupla. \n", + "Por ejemplo, para dividir una dirección de email en un nombre de usuario y un dominio, podrías escribir:" ] }, { @@ -502,7 +500,7 @@ "id": "d134a94c", "metadata": {}, "source": [ - "The return value from `split` is a list with two elements -- the first element is assigned to `username`, the second to `domain`." + "El valor de retorno de `split` es una lista con dos elementos -- el primer elemento se asigna a `username`, el segundo a `domain`." ] }, { @@ -520,8 +518,7 @@ "id": "5a7e3c62", "metadata": {}, "source": [ - "The number of variables on the left and the number of values on the\n", - "right have to be the same -- otherwise you get a `ValueError`." + "El número de variables a la izquierda y el número de valores a la derecha tienen que ser iguales -- de lo contrario obtienes un `ValueError`." ] }, { @@ -542,8 +539,8 @@ "id": "808c2928", "metadata": {}, "source": [ - "Tuple assignment is useful if you want to swap the values of two variables.\n", - "With conventional assignments, you have to use a temporary variable, like this:" + "La asignación de tupla es útil si quieres intercambiar los valores de dos variables.\n", + "Con asignaciones convencionales, tienes que usar una variable temporal, así:" ] }, { @@ -563,7 +560,7 @@ "id": "98496d02", "metadata": {}, "source": [ - "That works, but with tuple assignment we can do the same thing without a temporary variable." + "Eso funciona, pero con la asignación de tupla podemos hacer lo mismo sin una variable temporal." ] }, { @@ -581,10 +578,10 @@ "id": "a66a87bc", "metadata": {}, "source": [ - "This works because all of the expressions on the right side are evaluated before any of the assignments.\n", + "Esto funciona porque todas las expresiones del lado derecho se evalúan antes de hacer cualquiera de las asignaciones.\n", "\n", - "We can also use tuple assignment in a `for` statement.\n", - "For example, to loop through the items in a dictionary, we can use the `items` method." + "También podemos usar asignación de tupla en una sentencia `for`.\n", + "Por ejemplo, para hacer un bucle por los elementos de un diccionario, podemos usar el método `items`." ] }, { @@ -606,9 +603,9 @@ "id": "dd0d4feb", "metadata": {}, "source": [ - "Each time through the loop, `item` is assigned a tuple that contains a key and the corresponding value.\n", + "Cada vez que pasa por el bucle, `item` se asigna a una tupla que contiene una clave y el valor correspondiente.\n", "\n", - "We can write this loop more concisely, like this:" + "Podemos escribir este bucle de forma más concisa, así:" ] }, { @@ -627,7 +624,7 @@ "id": "f0513578", "metadata": {}, "source": [ - "Each time through the loop, a key and the corresponding value are assigned directly to `key` and `value`." + "Cada vez que pasa por el bucle, una clave y el valor correspondiente se asignan directamente a `key` y `value`." ] }, { @@ -635,16 +632,12 @@ "id": "efedeb37", "metadata": {}, "source": [ - "## Tuples as return values\n", + "## Tuplas como valores de retorno\n", "\n", - "Strictly speaking, a function can only return one value, but if the\n", - "value is a tuple, the effect is the same as returning multiple values.\n", - "For example, if you want to divide two integers and compute the quotient\n", - "and remainder, it is inefficient to compute `x//y` and then `x%y`. It is\n", - "better to compute them both at the same time.\n", + "Estrictamente hablando, una función solo puede devolver un valor, pero si el valor es una tupla, el efecto es el mismo que devolver múltiples valores.\n", + "Por ejemplo, si quieres dividir dos enteros y calcular el cociente y el resto, es ineficiente calcular `x//y` y luego `x%y`. Es mejor calcular ambos al mismo tiempo.\n", "\n", - "The built-in function `divmod` takes two arguments and returns a tuple\n", - "of two values, the quotient and remainder." + "La función integrada `divmod` toma dos argumentos y devuelve una tupla de dos valores, el cociente y el resto." ] }, { @@ -662,7 +655,7 @@ "id": "33f3c57d", "metadata": {}, "source": [ - "We can use tuple assignment to store the elements of the tuple in two variables. " + "Podemos usar asignación de tupla para guardar los elementos dla tupla en dos variables. " ] }, { @@ -691,7 +684,7 @@ "id": "15079805", "metadata": {}, "source": [ - "Here is an example of a function that returns a tuple." + "Aquí tienes un ejemplo de una función que devuelve una tupla." ] }, { @@ -710,8 +703,8 @@ "id": "43c4e1e0", "metadata": {}, "source": [ - "`max` and `min` are built-in functions that find the largest and smallest elements of a sequence. \n", - "`min_max` computes both and returns a tuple of two values." + "`max` y `min` son funciones integradas que encuentran los elementos mayor y menor de una secuencia. \n", + "`min_max` calcula ambos y devuelve una tupla de dos valores." ] }, { @@ -729,7 +722,7 @@ "id": "86b60e71", "metadata": {}, "source": [ - "We can assign the results to variables like this:" + "Podemos asignar los resultados a variables así:" ] }, { @@ -750,11 +743,11 @@ "tags": [] }, "source": [ - "## Argument packing\n", + "## Empaquetado de argumentos\n", "\n", - "Functions can take a variable number of arguments. \n", - "A parameter name that begins with the `*` operator **packs** arguments into a tuple.\n", - "For example, the following function takes any number of arguments and computes their arithmetic mean -- that is, their sum divided by the number of arguments. " + "Las funciones pueden tomar un número variable de argumentos. \n", + "Un nombre de parámetro que empieza con el operador `*` **empaqueta** argumentos en una tupla.\n", + "Por ejemplo, la siguiente función toma cualquier número de argumentos y calcula su media aritmética -- es decir, su suma dividida por el número de argumentos. " ] }, { @@ -773,8 +766,8 @@ "id": "6044fc1b", "metadata": {}, "source": [ - "The parameter can have any name you like, but `args` is conventional.\n", - "We can call the function like this:" + "El parámetro puede tener cualquier nombre que quieras, pero `args` es convencional.\n", + "Podemos llamar a la función así:" ] }, { @@ -792,8 +785,8 @@ "id": "a5e8b158", "metadata": {}, "source": [ - "If you have a sequence of values and you want to pass them to a function as multiple arguments, you can use the `*` operator to **unpack** the tuple.\n", - "For example, `divmod` takes exactly two arguments -- if you pass a tuple as a parameter, you get an error." + "Si tienes una secuencia de valores y quieres pasarlos a una función como múltiples argumentos, puedes usar el operador `*` para **desempaquetar** la tupla.\n", + "Por ejemplo, `divmod` toma exactamente dos argumentos -- si pasas una tupla como parámetro, obtienes un error." ] }, { @@ -815,8 +808,8 @@ "id": "5a9110db", "metadata": {}, "source": [ - "Even though the tuple contains two elements, it counts as a single argument.\n", - "But if you unpack the tuple, it is treated as two arguments." + "Aunque la tupla contiene dos elementos, cuenta como un único argumento.\n", + "Pero si desempaquetas la tupla, se trata como dos argumentos." ] }, { @@ -834,8 +827,8 @@ "id": "da554863", "metadata": {}, "source": [ - "Packing and unpacking can be useful if you want to adapt the behavior of an existing function.\n", - "For example, this function takes any number of arguments, removes the lowest and highest, and computes the mean of the rest." + "Empaquetado y desempaquetado pueden ser útiles si quieres adaptar el comportamiento de una función existente.\n", + "Por ejemplo, esta función toma cualquier número de argumentos, elimina el menor y el mayor, y calcula la media del resto." ] }, { @@ -858,11 +851,11 @@ "id": "d1e05e49", "metadata": {}, "source": [ - "First it uses `min_max` to find the lowest and highest elements.\n", - "Then it converts `args` to a list so it can use the `remove` method.\n", - "Finally it unpacks the list so the elements are passed to `mean` as separate arguments, rather than as a single list.\n", + "Primero usa `min_max` para encontrar los elementos menor y mayor.\n", + "Luego convierte `args` en una lista para poder usar el método `remove`.\n", + "Finalmente desempaqueta la lista para que los elementos se pasen a `mean` como argumentos separados, en lugar de como una única lista.\n", "\n", - "Here's an example that shows the effect." + "Aquí tienes un ejemplo que muestra el efecto." ] }, { @@ -890,7 +883,7 @@ "id": "35e04996", "metadata": {}, "source": [ - "This kind of \"trimmed\" mean is used in some sports with subjective judging -- like diving and gymnastics -- to reduce the effect of a judge whose score deviates from the others. " + "Este tipo de media \"recortada\" se usa en algunos deportes con puntuación subjetiva -- como saltos y gimnasia -- para reducir el efecto de un juez cuya puntuación se desvía de las demás. " ] }, { @@ -900,8 +893,8 @@ "source": [ "## Zip\n", "\n", - "Tuples are useful for looping through the elements of two sequences and performing operations on corresponding elements.\n", - "For example, suppose two teams play a series of seven games, and we record their scores in two lists, one for each team." + "Las tuplas son útiles para hacer un bucle por los elementos de dos secuencias y realizar operaciones sobre elementos correspondientes.\n", + "Por ejemplo, supongamos que dos equipos juegan una serie de siete partidos, y registramos sus puntuaciones en dos listas, una para cada equipo." ] }, { @@ -920,8 +913,8 @@ "id": "b44f228b", "metadata": {}, "source": [ - "Let's see how many games each team won.\n", - "We'll use `zip`, which is a built-in function that takes two or more sequences and returns a **zip object**, so-called because it pairs up the elements of the sequences like the teeth of a zipper." + "Veamos cuántos partidos ganó cada equipo.\n", + "Usaremos `zip`, que es una función integrada que toma dos o más secuencias y devuelve un **zip objeto**, llamado así porque empareja los elementos de las secuencias como los dientes de una cremallera." ] }, { @@ -939,7 +932,7 @@ "id": "9adcf8f9", "metadata": {}, "source": [ - "We can use the zip object to loop through the values in the sequences pairwise." + "Podemos usar el zip objeto para hacer un bucle por los valores de las secuencias por pares." ] }, { @@ -958,8 +951,8 @@ "id": "51d1dabb", "metadata": {}, "source": [ - "Each time through the loop, `pair` gets assigned a tuple of scores.\n", - "So we can assign the scores to variables, and count the victories for the first team, like this:" + "Cada vez que pasa por el bucle, `pair` recibe una tupla de puntuaciones.\n", + "Así que podemos asignar las puntuaciones a variables y contar las victorias del primer equipo, así:" ] }, { @@ -982,9 +975,9 @@ "id": "ad740fcd", "metadata": {}, "source": [ - "Sadly, the first team won only three games and lost the series.\n", + "Tristemente, el primer equipo ganó solo tres partidos y perdió la serie.\n", "\n", - "If you have two lists and you want a list of pairs, you can use `zip` and `list`." + "Si tienes dos listas y quieres una lista de pares, puedes usar `zip` y `list`." ] }, { @@ -1003,7 +996,7 @@ "id": "ec4249fa", "metadata": {}, "source": [ - "The result is a list of tuples, so we can get the result of the last game like this:" + "El resultado es una lista de tuplas, así que podemos obtener el resultado del último partido así:" ] }, { @@ -1021,8 +1014,8 @@ "id": "436486b9", "metadata": {}, "source": [ - "If you have a list of keys and a list of values, you can use `zip` and `dict` to make a dictionary.\n", - "For example, here's how we can make a dictionary that maps from each letter to its position in the alphabet." + "Si tienes una lista de claves y una lista de valores, puedes usar `zip` y `dict` para crear un diccionario.\n", + "Por ejemplo, así podemos crear un diccionario que asocia cada letra con su posición en el alfabeto." ] }, { @@ -1042,7 +1035,7 @@ "id": "b4de6974", "metadata": {}, "source": [ - "Now we can look up a letter and get its index in the alphabet." + "Ahora podemos buscar una letra y obtener su índice en el alfabeto." ] }, { @@ -1060,9 +1053,9 @@ "id": "cc632542", "metadata": {}, "source": [ - "In this mapping, the index of `'a'` is `0` and the index of `'z'` is `25`.\n", + "En este mapeo, el índice de `'a'` es `0` y el índice de `'z'` es `25`.\n", "\n", - "If you need to loop through the elements of a sequence and their indices, you can use the built-in function `enumerate`." + "Si necesitas hacer un bucle por los elementos de una secuencia y sus índices, puedes usar la función integrada `enumerate`." ] }, { @@ -1080,7 +1073,7 @@ "id": "92ad45bb", "metadata": {}, "source": [ - "The result is an **enumerate object** that loops through a sequence of pairs, where each pair contains an index (starting from 0) and an element from the given sequence." + "El resultado es un **enumerate objeto** que hace un bucle por una secuencia de pares, donde cada par contiene un índice (empezando en 0) y un elemento de la secuencia dada." ] }, { @@ -1099,11 +1092,11 @@ "id": "cf0b55d7", "metadata": {}, "source": [ - "## Comparing and Sorting\n", + "## Comparación y ordenación\n", "\n", - "The relational operators work with tuples and other sequences.\n", - "For example, if you use the `<` operator with tuples, it starts by comparing the first element from each sequence.\n", - "If they are equal, it goes on to the next pair of elements, and so on, until it finds a pair that differ. " + "Los operadores relacionales funcionan con tuplas y otras secuencias.\n", + "Por ejemplo, si usas el operador `<` con tuplas, empieza comparando el primer elemento de cada secuencia.\n", + "Si son iguales, continúa con el siguiente par de elementos, y así sucesivamente, hasta que encuentra un par que difiere. " ] }, { @@ -1121,7 +1114,7 @@ "id": "65ceea86", "metadata": {}, "source": [ - "Subsequent elements are not considered -- even if they are really big." + "Los elementos posteriores no se tienen en cuenta -- aunque sean realmente grandes." ] }, { @@ -1139,9 +1132,9 @@ "id": "55e4a35e", "metadata": {}, "source": [ - "This way of comparing tuples is useful for sorting a list of tuples, or finding the minimum or maximum.\n", - "As an example, let's find the most common letter in a word.\n", - "In the previous chapter, we wrote `value_counts`, which takes a string and returns a dictionary that maps from each letter to the number of times it appears." + "Esta forma de comparar tuplas es útil para ordenar una lista de tuplas, o para encontrar el mínimo o el máximo.\n", + "Como ejemplo, encontremos la letra más común en una palabra.\n", + "En el capítulo anterior, escribimos `value_counts`, que toma un string y devuelve un diccionario que asocia cada letra con el número de veces que aparece." ] }, { @@ -1166,7 +1159,7 @@ "id": "a80012c1", "metadata": {}, "source": [ - "Here is the result for the string `'banana'`." + "Aquí está el resultado para el string `'banana'`." ] }, { @@ -1185,10 +1178,10 @@ "id": "cc1ea4a7", "metadata": {}, "source": [ - "With only three items, we can easily see that the most frequent letter is `'a'`, which appears three times.\n", - "But if there were more items, it would be useful to sort them automatically.\n", + "Con solo tres elementos, podemos ver fácilmente que la letra más frecuente es `'a'`, que aparece tres veces.\n", + "Pero si hubiera más elementos, sería útil ordenarlos automáticamente.\n", "\n", - "We can get the items from `counter` like this." + "Podemos obtener los elementos de `counter` así." ] }, { @@ -1207,7 +1200,7 @@ "id": "ac8dea7a", "metadata": {}, "source": [ - "The result is a `dict_items` object that behaves like a list of tuples, so we can sort it like this." + "El resultado es un objeto `dict_items` que se comporta como una lista de tuplas, así que podemos ordenarlo así." ] }, { @@ -1225,10 +1218,10 @@ "id": "b690d17a", "metadata": {}, "source": [ - "The default behavior is to use the first element from each tuple to sort the list, and use the second element to break ties.\n", + "El comportamiento por defecto es usar el primer elemento de cada tupla para ordenar la lista, y usar el segundo elemento para desempatar.\n", "\n", - "However, to find the items with the highest counts, we want to use the second element to sort the list.\n", - "We can do that by writing a function that takes a tuple and returns the second element." + "Sin embargo, para encontrar los elementos con los conteos más altos, queremos usar el segundo elemento para ordenar la lista.\n", + "Podemos hacerlo escribiendo una función que toma una tupla y devuelve el segundo elemento." ] }, { @@ -1247,7 +1240,7 @@ "id": "b964aa14", "metadata": {}, "source": [ - "Then we can pass that function to `sorted` as an optional argument called `key`, which indicates that this function should be used to compute the **sort key** for each item." + "Luego podemos pasar esa función a `sorted` como un argumento opcional llamado `key`, que indica que esta función debe usarse para calcular la **sort clave** de cada elemento." ] }, { @@ -1266,9 +1259,9 @@ "id": "4dc96848", "metadata": {}, "source": [ - "The sort key determines the order of the items in the list.\n", - "The letter with the lowest count appears first, and the letter with the highest count appears last.\n", - "So we can find the most common letter like this." + "La sort clave determina el orden de los elementos en la lista.\n", + "La letra con el conteo más bajo aparece primero, y la letra con el conteo más alto aparece al final.\n", + "Así podemos encontrar la letra más común." ] }, { @@ -1286,8 +1279,8 @@ "id": "d0d8b999", "metadata": {}, "source": [ - "If we only want the maximum, we don't have to sort the list.\n", - "We can use `max`, which also takes `key` as an optional argument." + "Si solo queremos el máximo, no tenemos que ordenar la lista.\n", + "Podemos usar `max`, que también toma `key` como argumento opcional." ] }, { @@ -1305,7 +1298,7 @@ "id": "8a8327df", "metadata": {}, "source": [ - "To find the letter with the lowest count, we could use `min` the same way." + "Para encontrar la letra con el conteo más bajo, podríamos usar `min` de la misma manera." ] }, { @@ -1313,15 +1306,15 @@ "id": "a62394a5", "metadata": {}, "source": [ - "## Inverting a dictionary\n", + "## Invertir un diccionario\n", "\n", - "Suppose you want to invert a dictionary so you can look up a value and get the corresponding key.\n", - "For example, if you have a word counter that maps from each word to the number of times it appears, you could make a dictionary that maps from integers to the words that appear that number of times.\n", + "Supongamos que quieres invertir un diccionario para poder buscar un valor y obtener la clave correspondiente.\n", + "Por ejemplo, si tienes un contador de palabras que asocia cada palabra con el número de veces que aparece, podrías crear un diccionario que asocia enteros con las palabras que aparecen ese número de veces.\n", "\n", - "But there's a problem -- the keys in a dictionary have to be unique, but the values don't. For example, in a word counter, there could be many words with the same count.\n", + "Pero hay un problema -- las claves de un diccionario tienen que ser únicas, pero los valores no. Por ejemplo, en un contador de palabras, podría haber muchas palabras con el mismo conteo.\n", "\n", - "So one way to invert a dictionary is to create a new dictionary where the values are lists of keys from the original.\n", - "As an example, let's count the letters in `parrot`." + "Así que una forma de invertir un diccionario es crear un nuevo diccionario donde los valores son listas de claves del original.\n", + "Como ejemplo, contemos las letras en `parrot`." ] }, { @@ -1340,9 +1333,9 @@ "id": "f4570eae", "metadata": {}, "source": [ - "If we invert this dictionary, the result should be `{1: ['p', 'a', 'o', 't'], 2: ['r']}`, which indicates that the letters that appear once are `'p'`, `'a'`, `'o'`, and `'t'`, and the letter than appears twice is `'r'`.\n", + "Si invertimos este diccionario, el resultado debería ser `{1: ['p', 'a', 'o', 't'], 2: ['r']}`, lo que indica que las letras que aparecen una vez son `'p'`, `'a'`, `'o'` y `'t'`, y la letra que aparece dos veces es `'r'`.\n", "\n", - "The following function takes a dictionary and returns its inverse as a new dictionary." + "La siguiente función toma un diccionario y devuelve su inverso como un nuevo diccionario." ] }, { @@ -1367,11 +1360,11 @@ "id": "ca5fa025", "metadata": {}, "source": [ - "The `for` statement loops through the keys and values in `d`.\n", - "If the value is not already in the new dictionary, it is added and associated with a list that contains a single element.\n", - "Otherwise it is appended to the existing list.\n", + "La sentencia `for` hace un bucle por las claves y los valores de `d`.\n", + "Si el valor todavía no está en el nuevo diccionario, se añade y se asocia con una lista que contiene un único elemento.\n", + "De lo contrario, se añade a la lista existente.\n", "\n", - "We can test it like this:" + "Podemos probarlo así:" ] }, { @@ -1389,10 +1382,10 @@ "id": "4cfb1693", "metadata": {}, "source": [ - "And we get the result we expected.\n", + "Y obtenemos el resultado que esperábamos.\n", "\n", - "This is the first example we've seen where the values in the dictionary are lists.\n", - "We will see more!" + "Este es el primer ejemplo que hemos visto donde los valores en el diccionario son listas.\n", + "¡Veremos más!" ] }, { @@ -1402,16 +1395,15 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Lists, dictionaries and tuples are **data structures**.\n", - "In this chapter we are starting to see compound data structures, like lists of tuples, or dictionaries that contain tuples as keys and lists as values.\n", - "Compound data structures are useful, but they are prone to errors caused when a data structure has the wrong type, size, or structure.\n", - "For example, if a function expects a list of integers and you give it a plain old integer\n", - "(not in a list), it probably won't work.\n", + "Listas, diccionarios y tuplas son **estructuras de datos**.\n", + "En este capítulo estamos empezando a ver estructuras de datos compuestas, como listas de tuplas, o diccionarios que contienen tuplas como claves y listas como valores.\n", + "Las estructuras de datos compuestas son útiles, pero son propensas a errores cuando una estructura de datos tiene el tipo, tamaño o estructura equivocados.\n", + "Por ejemplo, si una función espera una lista de enteros y le das un entero sin más (no dentro de una lista), probablemente no funcionará.\n", "\n", - "To help debug these kinds of errors, I wrote a module called `structshape` that provides a function, also called `structshape`, that takes any kind of data structure as an argument and returns a string that summarizes its structure.\n", - "You can download it from\n", + "Para ayudar a depurar este tipo de errores, escribí un módulo llamado `structshape` que proporciona una función, también llamada `structshape`, que toma cualquier tipo de estructura de datos como argumento y devuelve un string que resume su estructura.\n", + "Puedes descargarlo desde\n", "." ] }, @@ -1432,7 +1424,7 @@ "id": "646f4d55", "metadata": {}, "source": [ - "We can import it like this." + "Podemos importarlo así." ] }, { @@ -1450,7 +1442,7 @@ "id": "86cc6ccc", "metadata": {}, "source": [ - "Here's an example with a simple list." + "Aquí tienes un ejemplo con una lista simple." ] }, { @@ -1469,7 +1461,7 @@ "id": "9de4f6ec", "metadata": {}, "source": [ - "Here's a list of lists." + "Aquí tienes una lista de listas." ] }, { @@ -1488,8 +1480,7 @@ "id": "aced9984", "metadata": {}, "source": [ - "If the elements of the list are not the same type, `structshape` groups\n", - "them by type." + "Si los elementos de la lista no son del mismo tipo, `structshape` los agrupa por tipo." ] }, { @@ -1508,7 +1499,7 @@ "id": "f63ff690", "metadata": {}, "source": [ - "Here's a list of tuples." + "Aquí tienes una lista de tuplas." ] }, { @@ -1528,7 +1519,7 @@ "id": "c9ec67eb", "metadata": {}, "source": [ - "And here's a dictionary with three items that map integers to strings." + "Y aquí tienes un diccionario con tres elementos que asocian enteros con strings." ] }, { @@ -1547,8 +1538,7 @@ "id": "f29bb82b", "metadata": {}, "source": [ - "If you are having trouble keeping track of your data structures,\n", - "`structshape` can help." + "Si tienes problemas para seguir la pista de tus estructuras de datos, `structshape` puede ayudar." ] }, { @@ -1556,25 +1546,25 @@ "id": "79d93082", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", "**pack:**\n", - "Collect multiple arguments into a tuple.\n", + "Reunir múltiples argumentos en una tupla.\n", "\n", "**unpack:**\n", - "Treat a tuple (or other sequence) as multiple arguments.\n", + "Tratar una tupla (u otra secuencia) como múltiples argumentos.\n", "\n", - "**zip object:**\n", - "The result of calling the built-in function `zip`, can be used to loop through a sequence of tuples.\n", + "**zip objeto:**\n", + "El resultado de llamar a la función integrada `zip`; se puede usar para hacer un bucle por una secuencia de tuplas.\n", "\n", - "**enumerate object:**\n", - "The result of calling the built-in function `enumerate`, can be used to loop through a sequence of tuples.\n", + "**enumerate objeto:**\n", + "El resultado de llamar a la función integrada `enumerate`; se puede usar para hacer un bucle por una secuencia de tuplas.\n", "\n", - "**sort key:**\n", - "A value, or function that computes a value, used to sort the elements of a collection.\n", + "**sort clave:**\n", + "Un valor, o una función que calcula un valor, usado para ordenar los elementos de una colección.\n", "\n", - "**data structure:**\n", - "A collection of values, organized to perform certain operations efficiently." + "**estructura de datos:**\n", + "Una colección de valores, organizada para realizar ciertas operaciones de manera eficiente." ] }, { @@ -1582,7 +1572,7 @@ "id": "1471b3c0", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1605,17 +1595,17 @@ "id": "97a0352d", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "The exercises in this chapter might be more difficult than exercises in previous chapters, so I encourage you to get help from a virtual assistant.\n", - "When you pose more difficult questions, you might find that the answers are not correct on the first attempt, so this is a chance to practice crafting good prompts and following up with good refinements.\n", + "Los ejercicios de este capítulo pueden ser más difíciles que los de capítulos anteriores, así que te animo a pedir ayuda a un asistente virtual.\n", + "Cuando planteas preguntas más difíciles, puede que las respuestas no sean correctas al primer intento, así que esta es una oportunidad para practicar cómo crear buenos prompts y hacer buenos refinamientos.\n", "\n", - "One strategy you might consider is to break a big problems into pieces that can be solved with simple functions.\n", - "Ask the virtual assistant to write the functions and test them.\n", - "Then, once they are working, ask for a solution to the original problem.\n", + "Una estrategia que podrías considerar es dividir un problema grande en piezas que puedan resolverse con funciones simples.\n", + "Pide al asistente virtual que escriba las funciones y las pruebe.\n", + "Luego, cuando funcionen, pide una solución al problema original.\n", "\n", - "For some of the exercises below, I make suggestions about which data structures and algorithms to use.\n", - "You might find these suggestions useful when you work on the problems, but they are also good prompts to pass along to a virtual assistant." + "Para algunos de los ejercicios siguientes, sugiero qué estructuras de datos y algoritmos usar.\n", + "Puede que estas sugerencias te resulten útiles cuando trabajes en los problemas, pero también son buenos prompts para pasárselos a un asistente virtual." ] }, { @@ -1623,12 +1613,12 @@ "id": "f90e011f", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In this chapter I said that tuples can be used as keys in dictionaries because they are hashable, and they are hashable because they are immutable.\n", - "But that is not always true.\n", + "En este capítulo dije que las tuplas pueden usarse como claves en diccionarios porque son hasheables, y son hasheables porque son inmutables.\n", + "Pero eso no siempre es cierto.\n", "\n", - "If a tuple contains a mutable value, like a list or a dictionary, the tuple is no longer hashable because it contains elements that are not hashable. As an example, here's a tuple that contains two lists of integers." + "Si una tupla contiene un valor mutable, como una lista o un diccionario, la tupla ya no es hasheable porque contiene elementos que no son hasheablesss. Como ejemplo, aquí tienes una tupla que contiene dos listas de enteros." ] }, { @@ -1650,7 +1640,7 @@ "id": "02799077", "metadata": {}, "source": [ - "Write a line of code that appends the value `6` to the end of the second list in `t`. If you display `t`, the result should be `([1, 2, 3], [4, 5, 6])`." + "Escribe una línea de código que añada el valor `6` al final de la segunda lista en `t`. Si muestras `t`, el resultado debería ser `([1, 2, 3], [4, 5, 6])`." ] }, { @@ -1670,7 +1660,7 @@ "id": "644b1dfb", "metadata": {}, "source": [ - "Try to create a dictionary that maps from `t` to a string, and confirm that you get a `TypeError`." + "Intenta crear un diccionario que asocie `t` con un string, y confirma que obtienes un `TypeError`." ] }, { @@ -1690,7 +1680,7 @@ "id": "fb77a352", "metadata": {}, "source": [ - "For more on this topic, ask a virtual assistant, \"Are Python tuples always hashable?\"" + "Para saber más sobre este tema, pregunta a un asistente virtual: \"Are Python tuplas always hasheable?" ] }, { @@ -1700,9 +1690,9 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In this chapter we made a dictionary that maps from each letter to its index in the alphabet." + "En este capítulo hicimos un diccionario que asocia cada letra con su índice en el alfabeto." ] }, { @@ -1722,7 +1712,7 @@ "id": "a8cd720b", "metadata": {}, "source": [ - "For example, the index of `'a'` is `0`." + "Por ejemplo, el índice de `'a'` es `0`." ] }, { @@ -1740,8 +1730,8 @@ "id": "a04c25db", "metadata": {}, "source": [ - "To go in the other direction, we can use list indexing.\n", - "For example, the letter at index `1` is `'b'`." + "Para ir en la otra dirección, podemos usar indexación de lista.\n", + "Por ejemplo, la letra en el índice `1` es `'b'`." ] }, { @@ -1759,18 +1749,17 @@ "id": "165ab770", "metadata": {}, "source": [ - "We can use `letter_map` and `letters` to encode and decode words using a Caesar cipher.\n", + "Podemos usar `letter_map` y `letters` para codificar y decodificar palabras usando un cifrado César.\n", "\n", - "A Caesar cipher is a weak form of encryption that involves shifting each letter\n", - "by a fixed number of places in the alphabet, wrapping around to the beginning if necessary. For example, `'a'` shifted by 2 is `'c'` and `'z'` shifted by 1 is `'a'`.\n", + "Un cifrado César es una forma débil de cifrado que consiste en desplazar cada letra un número fijo de posiciones en el alfabeto, volviendo al principio si es necesario. Por ejemplo, `'a'` desplazada 2 posiciones es `'c'` y `'z'` desplazada 1 posición es `'a'`.\n", "\n", - "Write a function called `shift_word` that takes as parameters a string and an integer, and returns a new string that contains the letters from the string shifted by the given number of places.\n", + "Escribe una función llamada `shift_word` que tome como parámetros un string y un entero, y devuelva un nuevo string que contiene las letras del string desplazadas el número de posiciones dado.\n", "\n", - "To test your function, confirm that \"cheer\" shifted by 7 is \"jolly\" and \"melon\" shifted by 16 is \"cubed\".\n", + "Para probar tu función, confirma que \"cheer\" desplazada 7 posiciones es \"jolly\" y \"melon\" desplazada 16 posiciones es \"cubed\".\n", "\n", - "Hints: Use the modulus operator to wrap around from `'z'` back to `'a'`. \n", - "Loop through the letters of the word, shift each one, and append the result to a list of letters.\n", - "Then use `join` to concatenate the letters into a string." + "Pistas: usa el operador módulo para volver de `'z'` a `'a'`. \n", + "Haz un bucle por las letras de la palabra, desplaza cada una y añade el resultado a una lista de letras.\n", + "Luego usa `join` para concatenar las letras en un string." ] }, { @@ -1780,7 +1769,7 @@ "tags": [] }, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar." ] }, { @@ -1844,7 +1833,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1869,11 +1858,11 @@ "id": "779f13af", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `most_frequent_letters` that takes a string and prints the letters in decreasing order of frequency.\n", + "Escribe una función llamada `most_frequent_letters` que tome un string e imprima las letras en orden decreciente de frecuencia.\n", "\n", - "To get the items in decreasing order, you can use `reversed` along with `sorted` or you can pass `reverse=True` as a keyword parameter to `sorted`." + "Para obtener los elementos en orden decreciente, puedes usar `reversed` junto con `sorted` o puedes pasar `reverse=True` como keyword parameter a `sorted`." ] }, { @@ -1883,7 +1872,7 @@ "tags": [] }, "source": [ - "You can use this outline of the function to get started." + "Puedes usar este esquema de la función para empezar." ] }, { @@ -1916,7 +1905,7 @@ "tags": [] }, "source": [ - "And this example to test your function." + "Y este ejemplo para probar tu función." ] }, { @@ -1938,7 +1927,7 @@ "tags": [] }, "source": [ - "Once your function is working, you can use the following code to print the most common letters in *Dracula*, which we can download from Project Gutenberg." + "Cuando tu función funcione, puedes usar el siguiente código para imprimir las letras más comunes en *Dracula*, que podemos descargar de Project Gutenberg." ] }, { @@ -1973,8 +1962,8 @@ "tags": [] }, "source": [ - "According to Zim's \"Codes and Secret Writing\", the sequence of letters in decreasing order of frequency in English starts with \"ETAONRISH\".\n", - "How does this sequence compare with the results from *Dracula*?" + "Según *Codes and Secret Writing* de Zim, la secuencia de letras en orden decreciente de frecuencia en inglés empieza con \"ETAONRISH\".\n", + "¿Cómo se compara esta secuencia con los resultados de *Dracula*?" ] }, { @@ -1982,20 +1971,20 @@ "id": "cbe9933e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In a previous exercise, we tested whether two strings are anagrams by sorting the letters in both words and checking whether the sorted letters are the same.\n", - "Now let's make the problem a little more challenging.\n", + "En un ejercicio anterior, probamos si dos strings son anagramas ordenando las letras de ambas palabras y comprobando si las letras ordenadas son iguales.\n", + "Ahora hagamos el problema un poco más desafiante.\n", "\n", - "We'll write a program that takes a list of words and prints all the sets of words that are anagrams.\n", - "Here is an example of what the output might look like:\n", + "Escribiremos un programa que toma una lista de palabras e imprime todos los conjuntos de palabras que son anagramas.\n", + "Aquí tienes un ejemplo de cómo podría verse la salida:\n", "\n", " ['deltas', 'desalt', 'lasted', 'salted', 'slated', 'staled']\n", " ['retainers', 'ternaries']\n", " ['generating', 'greatening']\n", " ['resmelts', 'smelters', 'termless']\n", "\n", - "Hint: For each word in the word list, sort the letters and join them back into a string. Make a dictionary that maps from this sorted string to a list of words that are anagrams of it." + "Pista: para cada palabra de la lista de palabras, ordena las letras y vuelve a unirlas en un string. Crea un diccionario que asocie este string ordenado con una lista de palabras que son anagramas de él." ] }, { @@ -2005,7 +1994,7 @@ "tags": [] }, "source": [ - "The following cells download `words.txt` and read the words into a list." + "Las siguientes celdas descargan `words.txt` y leen las palabras en una lista." ] }, { @@ -2039,7 +2028,7 @@ "tags": [] }, "source": [ - "Here's the `sort_word` function we've used before." + "Aquí está la función `sort_word` que hemos usado antes." ] }, { @@ -2072,8 +2061,8 @@ "tags": [] }, "source": [ - "To find the longest list of anagrams, you can use the following function, which takes a key-value pair where the key is a string and the value is a list of words.\n", - "It returns the length of the list." + "Para encontrar la lista más larga de anagramas, puedes usar la siguiente función, que toma un par clave-valor donde la clave es un string y el valor es una lista de palabras.\n", + "Devuelve la longitud de la lista." ] }, { @@ -2097,7 +2086,7 @@ "tags": [] }, "source": [ - "We can use this function as a sort key to find the longest lists of anagrams." + "Podemos usar esta función como sort clave para encontrar las listas más largas de anagramas." ] }, { @@ -2121,7 +2110,7 @@ "tags": [] }, "source": [ - "If you want to know the longest words that have anagrams, you can use the following loop to print some of them." + "Si quieres saber cuáles son las palabras más largas que tienen anagramas, puedes usar el siguiente bucle para imprimir algunas." ] }, { @@ -2148,11 +2137,11 @@ "id": "4fbe939e", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `word_distance` that takes two words with the same length and returns the number of places where the two words differ.\n", + "Escribe una función llamada `word_distance` que tome dos palabras con la misma longitud y devuelva el número de posiciones donde las dos palabras difieren.\n", "\n", - "Hint: Use `zip` to loop through the corresponding letters of the words." + "Pista: usa `zip` para hacer un bucle por las letras correspondientes de las palabras." ] }, { @@ -2162,7 +2151,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function with doctests you can use to check your function." + "Aquí tienes un esquema de la función con doctests que puedes usar para comprobar tu función." ] }, { @@ -2219,15 +2208,15 @@ "id": "066eec59", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "\"Metathesis\" is the transposition of letters in a word.\n", - "Two words form a \"metathesis pair\" if you can transform one into the other by swapping two letters, like `converse` and `conserve`.\n", - "Write a program that finds all of the metathesis pairs in the word list. \n", + "\"Metathesis\" es la transposición de letras en una palabra.\n", + "Dos palabras forman una \"metathesis pair\" si puedes transformar una en la otra intercambiando dos letras, como `converse` y `conserve`.\n", + "Escribe un programa que encuentre todos los pares de metathesis en la lista de palabras. \n", "\n", - "Hint: The words in a metathesis pair must be anagrams of each other.\n", + "Pista: las palabras de un par de metathesis deben ser anagramas entre sí.\n", "\n", - "Credit: This exercise is inspired by an example at ." + "Crédito: este ejercicio está inspirado en un ejemplo de ." ] }, { @@ -2247,49 +2236,47 @@ "tags": [] }, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "This is a bonus exercise that is not in the book.\n", - "It is more challenging than the other exercises in this chapter, so you might want to ask a virtual assistant for help, or come back to it after you've read a few more chapters.\n", + "Este es un ejercicio extra que no está en el libro.\n", + "Es más desafiante que los otros ejercicios de este capítulo, así que quizá quieras pedir ayuda a un asistente virtual, o volver a él después de leer algunos capítulos más.\n", "\n", - "Here's another Car Talk Puzzler\n", + "Aquí tienes otro Car Talk Puzzler\n", "():\n", "\n", - "> What is the longest English word, that remains a valid English word,\n", - "> as you remove its letters one at a time?\n", + "> ¿Cuál es la palabra inglesa más larga que sigue siendo una palabra inglesa válida\n", + "> mientras le quitas letras una a una?\n", ">\n", - "> Now, letters can be removed from either end, or the middle, but you\n", - "> can't rearrange any of the letters. Every time you drop a letter, you\n", - "> wind up with another English word. If you do that, you're eventually\n", - "> going to wind up with one letter and that too is going to be an\n", - "> English word---one that's found in the dictionary. I want to know\n", - "> what's the longest word and how many letters does it have?\n", + "> Ahora, las letras se pueden quitar de cualquiera de los extremos o del medio, pero\n", + "> no puedes reordenar ninguna de las letras. Cada vez que quitas una letra,\n", + "> terminas con otra palabra inglesa. Si haces eso, al final\n", + "> terminarás con una letra, y esa también será una palabra inglesa -- una que\n", + "> aparece en el diccionario. Quiero saber cuál es la palabra más larga\n", + "> y cuántas letras tiene.\n", ">\n", - "> I'm going to give you a little modest example: Sprite. Ok? You start\n", - "> off with sprite, you take a letter off, one from the interior of the\n", - "> word, take the r away, and we're left with the word spite, then we\n", - "> take the e off the end, we're left with spit, we take the s off, we're\n", - "> left with pit, it, and I.\n", + "> Te voy a dar un ejemplo pequeño: Sprite. ¿Ok? Empiezas\n", + "> con sprite, le quitas una letra, una del interior de la\n", + "> palabra, quitas la r, y nos queda la palabra spite; luego\n", + "> quitamos la e del final, nos queda spit; quitamos la s,\n", + "> nos queda pit, it e I.\n", "\n", - "Write a program to find all words that can be reduced in this way, and\n", - "then find the longest one.\n", + "Escribe un programa para encontrar todas las palabras que pueden reducirse de esta manera, y luego encuentra la más larga.\n", "\n", - "This exercise is a little more challenging than most, so here are some\n", - "suggestions:\n", + "Este ejercicio es un poco más desafiante que la mayoría, así que aquí tienes algunas sugerencias:\n", "\n", - "1. You might want to write a function that takes a word and computes a\n", - " list of all the words that can be formed by removing one letter.\n", - " These are the \"children\" of the word.\n", + "1. Quizá quieras escribir una función que tome una palabra y calcule una\n", + " lista de todas las palabras que pueden formarse quitando una letra.\n", + " Estas son las \"children\" de la palabra.\n", "\n", - "2. Recursively, a word is reducible if any of its children are\n", - " reducible. As a base case, you can consider the empty string\n", + "2. Recursivamente, una palabra es reducible si cualquiera de sus children es\n", + " reducible. Como caso base, puedes considerar que el string vacío es\n", " reducible.\n", "\n", - "3. The word list we've been using doesn't contain single letter\n", - " words. So you might have to add \"I\" and \"a\".\n", + "3. La lista de palabras que hemos estado usando no contiene palabras de una sola letra.\n", + " Así que quizá tengas que añadir \"I\" y \"a\".\n", "\n", - "4. To improve the performance of your program, you might want to\n", - " memoize the words that are known to be reducible." + "4. Para mejorar el rendimiento de tu programa, quizá quieras\n", + " memoizar las palabras que se sabe que son reducibles." ] }, { @@ -2353,7 +2340,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/chapters/chap12.ipynb b/chapters/chap12.ipynb index f2d5d23..87d82b4 100644 --- a/chapters/chap12.ipynb +++ b/chapters/chap12.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,20 +41,20 @@ "id": "59a8621b", "metadata": {}, "source": [ - "# Text Analysis and Generation\n", + "# Análisis y generación de texto\n", "\n", - "At this point we have covered Python's core data structures -- lists, dictionaries, and tuples -- and some algorithms that use them.\n", - "In this chapter, we'll use them to explore text analysis and Markov generation:\n", + "A estas alturas hemos cubierto las estructuras de datos principales de Python -- listas, diccionarios y tuplas -- y algunos algoritmos que las usan.\n", + "En este capítulo, las usaremos para explorar el análisis de texto y la generación de Markov:\n", "\n", - "* Text analysis is a way to describe the statistical relationships between the words in a document, like the probability that one word is followed by another, and\n", + "* El análisis de texto es una forma de describir las relaciones estadísticas entre las palabras de un documento, como la probabilidad de que una palabra vaya seguida de otra, y\n", "\n", - "* Markov generation is a way to generate new text with words and phrases similar to the original text.\n", + "* La generación de Markov es una forma de generar texto nuevo con palabras y frases similares a las del texto original.\n", "\n", - "These algorithms are similar to parts of a Large Language Model (LLM), which is the key component of a chatbot.\n", + "Estos algoritmos son similares a partes de un Large Language Model (LLM), que es el componente clave de un chatbot.\n", "\n", - "We'll start by counting the number of times each word appears in a book.\n", - "Then we'll look at pairs of words, and make a list of the words that can follow each word.\n", - "We'll make a simple version of a Markov generator, and as an exercise, you'll have a chance to make a more general version." + "Empezaremos contando el número de veces que aparece cada palabra en un libro.\n", + "Luego veremos pares de palabras y haremos una lista de las palabras que pueden seguir a cada palabra.\n", + "Haremos una versión simple de un generador de Markov y, como ejercicio, tendrás la oportunidad de hacer una versión más general." ] }, { @@ -62,10 +62,10 @@ "id": "0e3811b8", "metadata": {}, "source": [ - "## Unique words\n", + "## Palabras únicas\n", "\n", - "As a first step toward text analysis, let's read a book -- *The Strange Case Of Dr. Jekyll And Mr. Hyde* by Robert Louis Stevenson -- and count the number of unique words.\n", - "Instructions for downloading the book are in the notebook for this chapter." + "Como primer paso hacia el análisis de texto, leamos un libro -- *The Strange Case Of Dr. Jekyll And Mr. Hyde* de Robert Louis Stevenson -- y contemos el número de palabras únicas.\n", + "Las instrucciones para descargar el libro están en el notebook de este capítulo." ] }, { @@ -75,7 +75,7 @@ "tags": [] }, "source": [ - "The following cell downloads the book from Project Gutenberg." + "La siguiente celda descarga el libro desde Project Gutenberg." ] }, { @@ -97,8 +97,8 @@ "tags": [] }, "source": [ - "The version available from Project Gutenberg includes information about the book at the beginning and license information at the end.\n", - "We'll use `clean_file` from Chapter 8 to remove this material and write a \"clean\" file that contains only the text of the book." + "La versión disponible en Project Gutenberg incluye información sobre el libro al principio e información de licencia al final.\n", + "Usaremos `clean_file` del Capítulo 8 para eliminar este material y escribir un archivo \"limpio\" que contiene solo el texto del libro." ] }, { @@ -167,8 +167,8 @@ "id": "bc66d7e2", "metadata": {}, "source": [ - "We'll use a `for` loop to read lines from the file and `split` to divide the lines into words.\n", - "Then, to keep track of unique words, we'll store each word as a key in a dictionary." + "Usaremos un bucle `for` para leer líneas del archivo y `split` para dividir las líneas en palabras.\n", + "Luego, para llevar la cuenta de las palabras únicas, guardaremos cada palabra como una clave en un diccionario." ] }, { @@ -192,11 +192,11 @@ "id": "85171a3a", "metadata": {}, "source": [ - "The length of the dictionary is the number of unique words -- about `6000` by this way of counting.\n", - "But if we inspect them, we'll see that some are not valid words.\n", + "La longitud del diccionario es el número de palabras únicas -- unas `6000` con esta forma de contar.\n", + "Pero si las inspeccionamos, veremos que algunas no son palabras válidas.\n", "\n", - "For example, let's look at the longest words in `unique_words`.\n", - "We can use `sorted` to sort the words, passing the `len` function as a keyword argument so the words are sorted by length." + "Por ejemplo, veamos las palabras más largas en `unique_words`.\n", + "Podemos usar `sorted` para ordenar las palabras, pasando la función `len` como keyword argumento para que las palabras se ordenen por longitud." ] }, { @@ -214,13 +214,13 @@ "id": "795f5327", "metadata": {}, "source": [ - "The slice index, `[-5:]`, selects the last `5` elements of the sorted list, which are the longest words. \n", + "El índice de porción, `[-5:]`, selecciona los últimos `5` elementos de la lista ordenada, que son las palabras más largas. \n", "\n", - "The list includes some legitimately long words, like \"circumscription\", and some hyphenated words, like \"chocolate-coloured\".\n", - "But some of the longest \"words\" are actually two words separated by a dash.\n", - "And other words include punctuation like periods, exclamation points, and quotation marks.\n", + "La lista incluye algunas palabras legítimamente largas, como \"circumscription\", y algunas palabras con guion, como \"chocolate-coloured\".\n", + "Pero algunas de las \"palabras\" más largas son en realidad dos palabras separadas por una raya.\n", + "Y otras palabras incluyen puntuación como puntos, signos de exclamación y comillas.\n", "\n", - "So, before we move on, let's deal with dashes and other punctuation." + "Así que, antes de seguir, ocupémonos de las rayas y otros signos de puntuación." ] }, { @@ -228,15 +228,15 @@ "id": "bf89fafa", "metadata": {}, "source": [ - "## Punctuation\n", + "## Puntuación\n", "\n", - "To identify the words in the text, we need to deal with two issues:\n", + "Para identificar las palabras del texto, tenemos que resolver dos cuestiones:\n", "\n", - "* When a dash appears in a line, we should replace it with a space -- then when we use `split`, the words will be separated.\n", + "* Cuando aparece una raya en una línea, deberíamos reemplazarla por un espacio -- así, cuando usemos `split`, las palabras quedarán separadas.\n", "\n", - "* After splitting the words, we can use `strip` to remove punctuation.\n", + "* Después de separar las palabras, podemos usar `strip` para eliminar la puntuación.\n", "\n", - "To handle the first issue, we can use the following function, which takes a string, replaces dashes with spaces, splits the string, and returns the resulting list." + "Para manejar la primera cuestión, podemos usar la siguiente función, que toma un string, reemplaza las rayas por espacios, divide el string y devuelve la lista resultante." ] }, { @@ -255,8 +255,8 @@ "id": "d5decdec", "metadata": {}, "source": [ - "Notice that `split_line` only replaces dashes, not hyphens.\n", - "Here's an example." + "Observa que `split_line` solo reemplaza rayas, no guiones.\n", + "Aquí tienes un ejemplo." ] }, { @@ -274,11 +274,11 @@ "id": "0d9eb318", "metadata": {}, "source": [ - "Now, to remove punctuation from the beginning and end of each word, we can use `strip`, but we need a list of characters that are considered punctuation.\n", + "Ahora, para eliminar la puntuación del principio y del final de cada palabra, podemos usar `strip`, pero necesitamos una lista de caracteres que se consideran puntuación.\n", "\n", - "Characters in Python strings are in Unicode, which is an international standard used to represent letters in nearly every alphabet, numbers, symbols, punctuation marks, and more.\n", - "The `unicodedata` module provides a `category` function we can use to tell which characters are punctuation.\n", - "Given a letter, it returns a string with information about what category the letter is in." + "Los caracteres en los strings de Python están en Unicode, que es un estándar internacional usado para representar letras de casi todos los alfabetos, números, símbolos, signos de puntuación y más.\n", + "El módulo `unicodedata` proporciona una función `category` que podemos usar para saber qué caracteres son puntuación.\n", + "Dada una letra, devuelve un string con información sobre la categoría a la que pertenece." ] }, { @@ -298,9 +298,9 @@ "id": "994835ea", "metadata": {}, "source": [ - "The category string of `'A'` is `'Lu'` -- the `'L'` means it is a letter and the `'u'` means it is uppercase.\n", + "El string de categoría de `'A'` es `'Lu'` -- la `'L'` significa que es una letra y la `'u'` significa que es mayúscula.\n", "\n", - "The category string of `'.'` is `'Po'` -- the `'P'` means it is punctuation and the `'o'` means its subcategory is \"other\"." + "El string de categoría de `'.'` es `'Po'` -- la `'P'` significa que es puntuación y la `'o'` significa que su subcategoría es \"other\"." ] }, { @@ -318,8 +318,8 @@ "id": "03773b9b", "metadata": {}, "source": [ - "We can find the punctuation marks in the book by checking for characters with categories that begin with `'P'`.\n", - "The following loop stores the unique punctuation marks in a dictionary." + "Podemos encontrar los signos de puntuación del libro comprobando los caracteres con categorías que empiezan por `'P'`.\n", + "El siguiente bucle guarda los signos de puntuación únicos en un diccionario." ] }, { @@ -342,7 +342,7 @@ "id": "e6741dfa", "metadata": {}, "source": [ - "To make a list of punctuation marks, we can join the keys of the dictionary into a string." + "Para crear una lista de signos de puntuación, podemos unir las claves del diccionario en un string." ] }, { @@ -361,7 +361,7 @@ "id": "6af8d5a2", "metadata": {}, "source": [ - "Now that we know which characters in the book are punctuation, we can write a function that takes a word, strips punctuation from the beginning and end, and converts it to lower case." + "Ahora que sabemos qué caracteres del libro son puntuación, podemos escribir una función que toma una palabra, elimina la puntuación del principio y del final, y la convierte a minúsculas." ] }, { @@ -380,7 +380,7 @@ "id": "58a78cb1", "metadata": {}, "source": [ - "Here's an example." + "Aquí tienes un ejemplo." ] }, { @@ -398,7 +398,7 @@ "id": "314e4fbd", "metadata": {}, "source": [ - "Because `strip` removes characters from the beginning and end, it leaves hyphenated words alone." + "Como `strip` elimina caracteres del principio y del final, deja intactas las palabras con guion." ] }, { @@ -416,7 +416,7 @@ "id": "99050f8a", "metadata": {}, "source": [ - "Now here's a loop that uses `split_line` and `clean_word` to identify the unique words in the book." + "Ahora aquí tienes un bucle que usa `split_line` y `clean_word` para identificar las palabras únicas del libro." ] }, { @@ -440,8 +440,8 @@ "id": "992e5466", "metadata": {}, "source": [ - "With this stricter definition of what a word is, there are about 4000 unique words.\n", - "And we can confirm that the list of longest words has been cleaned up." + "Con esta definición más estricta de lo que es una palabra, hay unas 4000 palabras únicas.\n", + "Y podemos confirmar que la lista de palabras más largas se ha limpiado." ] }, { @@ -459,7 +459,7 @@ "id": "8014c330", "metadata": {}, "source": [ - "Now let's see how many times each word is used." + "Ahora veamos cuántas veces se usa cada palabra." ] }, { @@ -467,9 +467,9 @@ "id": "7ef40180", "metadata": {}, "source": [ - "## Word frequencies\n", + "## Frecuencias de palabras\n", "\n", - "The following loop computes the frequency of each unique word." + "El siguiente bucle calcula la frecuencia de cada palabra única." ] }, { @@ -494,10 +494,10 @@ "id": "bd680b81", "metadata": {}, "source": [ - "The first time we see a word, we initialize its frequency to `1`. If we see the same word again later, we increment its frequency.\n", + "La primera vez que vemos una palabra, inicializamos su frecuencia a `1`. Si volvemos a ver la misma palabra más adelante, incrementamos su frecuencia.\n", "\n", - "To see which words appear most often, we can use `items` to get the key-value pairs from `word_counter`, and sort them by the second element of the pair, which is the frequency.\n", - "First we'll define a function that selects the second element." + "Para ver qué palabras aparecen con más frecuencia, podemos usar `items` para obtener los pares clave-valor de `word_counter`, y ordenarlos por el segundo elemento del par, que es la frecuencia.\n", + "Primero definiremos una función que selecciona el segundo elemento." ] }, { @@ -516,11 +516,11 @@ "id": "b15a5bd6", "metadata": {}, "source": [ - "Now we can use `sorted` with two keyword arguments:\n", + "Ahora podemos usar `sorted` con dos keyword argumentos:\n", "\n", - "* `key=second_element` means the items will be sorted according to the frequencies of the words.\n", + "* `key=second_element` significa que los elementos se ordenarán según las frecuencias de las palabras.\n", "\n", - "* `reverse=True` means the items will be sorted in reverse order, with the most frequent words first." + "* `reverse=True` significa que los elementos se ordenarán en orden inverso, con las palabras más frecuentes primero." ] }, { @@ -538,7 +538,7 @@ "id": "db6812e2", "metadata": {}, "source": [ - "Here are the five most frequent words." + "Aquí están las cinco palabras más frecuentes." ] }, { @@ -557,8 +557,8 @@ "id": "551e81bb", "metadata": {}, "source": [ - "In the next section, we'll encapsulate this loop in a function.\n", - "And we'll use it to demonstrate a new feature -- optional parameters." + "En la siguiente sección, encapsularemos este bucle en una función.\n", + "Y la usaremos para demostrar una nueva característica -- parámetros opcionales." ] }, { @@ -566,10 +566,10 @@ "id": "45243ccc", "metadata": {}, "source": [ - "## Optional parameters\n", + "## Parámetros opcionales\n", "\n", - "We've used built-in functions that take optional parameters.\n", - "For example, `round` takes an optional parameters called `ndigits` that indicates how many decimal places to keep." + "Hemos usado funciones integradas que toman parámetros opcionales.\n", + "Por ejemplo, `round` toma un parámetro opcional llamado `ndigits` que indica cuántos decimales conservar." ] }, { @@ -587,8 +587,8 @@ "id": "6ae60945", "metadata": {}, "source": [ - "But it's not just built-in functions -- we can write functions with optional parameters, too.\n", - "For example, the following function takes two parameters, `word_counter` and `num`." + "Pero no son solo las funciones integradas -- también podemos escribir funciones con parámetros opcionales.\n", + "Por ejemplo, la siguiente función toma dos parámetros, `word_counter` y `num`." ] }, { @@ -610,9 +610,9 @@ "id": "78cb1531", "metadata": {}, "source": [ - "The second parameter looks like an assignment statement, but it's not -- it's an optional parameter.\n", + "El segundo parámetro parece una sentencia de asignación, pero no lo es -- es un parámetro opcional.\n", "\n", - "If you call this function with one argument, `num` gets the **default value**, which is `5`." + "Si llamas a esta función con un argumento, `num` recibe el **valor por defecto**, que es `5`." ] }, { @@ -630,7 +630,7 @@ "id": "29753ad6", "metadata": {}, "source": [ - "If you call this function with two arguments, the second argument gets assigned to `num` instead of the default value." + "Si llamas a esta función con dos argumentos, el segundo argumento se asigna a `num` en lugar del valor por defecto." ] }, { @@ -648,9 +648,9 @@ "id": "e9bf907b", "metadata": {}, "source": [ - "In that case, we would say the optional argument **overrides** the default value.\n", + "En ese caso, diríamos que el argumento opcional **override** el valor por defecto.\n", "\n", - "If a function has both required and optional parameters, all of the required parameters have to come first, followed by the optional ones." + "Si una función tiene parámetros requeridos y opcionales, todos los parámetros requeridos tienen que ir primero, seguidos por los opcionales." ] }, { @@ -675,14 +675,14 @@ "tags": [] }, "source": [ - "## Dictionary subtraction\n", + "## Resta de diccionarios\n", "\n", - "Suppose we want to spell-check a book -- that is, find a list of words that might be misspelled.\n", - "One way to do that is to find words in the book that don't appear in a list of valid words.\n", - "In previous chapters, we've used a list of words that are considered valid in word games like Scrabble.\n", - "Now we'll use this list to spell-check Robert Louis Stevenson.\n", + "Supongamos que queremos revisar la ortografía de un libro -- es decir, encontrar una lista de palabras que podrían estar mal escritas.\n", + "Una forma de hacerlo es encontrar palabras del libro que no aparecen en una lista de palabras válidas.\n", + "En capítulos anteriores, hemos usado una lista de palabras que se consideran válidas en juegos de palabras como Scrabble.\n", + "Ahora usaremos esta lista para revisar la ortografía de Robert Louis Stevenson.\n", "\n", - "We can think of this problem as set subtraction -- that is, we want to find all the words from one set (the words in the book) that are not in the other (the words in the list)." + "Podemos pensar en este problema como una resta de conjuntos -- es decir, queremos encontrar todas las palabras de un conjunto (las palabras del libro) que no están en el otro (las palabras de la lista)." ] }, { @@ -692,7 +692,7 @@ "tags": [] }, "source": [ - "The following cell downloads the word list." + "La siguiente celda descarga la lista de palabras." ] }, { @@ -712,7 +712,7 @@ "id": "2a46556c", "metadata": {}, "source": [ - "As we've done before, we can read the contents of `words.txt` and split it into a list of strings." + "Como hemos hecho antes, podemos leer el contenido de `words.txt` y dividirlo en una lista de strings." ] }, { @@ -730,7 +730,7 @@ "id": "22becbab", "metadata": {}, "source": [ - "Then we'll store the words as keys in a dictionary so we can use the `in` operator to check quickly whether a word is valid." + "Luego guardaremos las palabras como claves en un diccionario para poder usar el operador `in` y comprobar rápidamente si una palabra es válida." ] }, { @@ -750,7 +750,7 @@ "id": "94cc7c61", "metadata": {}, "source": [ - "Now, to identify words that appear in the book but not in the word list, we'll use `subtract`, which takes two dictionaries as parameters and returns a new dictionary that contains all the keys from one that are not in the other." + "Ahora, para identificar palabras que aparecen en el libro pero no en la lista de palabras, usaremos `subtract`, que toma dos diccionarios como parámetros y devuelve un nuevo diccionario que contiene todas las claves de uno que no están en el otro." ] }, { @@ -773,7 +773,7 @@ "id": "e70c63b4", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como lo usamos." ] }, { @@ -791,7 +791,7 @@ "id": "f8ada7bd", "metadata": {}, "source": [ - "To get a sample of words that might be misspelled, we can print the most common words in `diff`." + "Para obtener una muestra de palabras que podrían estar mal escritas, podemos imprimir las palabras más comunes en `diff`." ] }, { @@ -809,10 +809,10 @@ "id": "deeec418", "metadata": {}, "source": [ - "The most common \"misspelled\" words are mostly names and a few single-letter words (Mr. Utterson is Dr. Jekyll's friend and lawyer).\n", + "Las \"palabras mal escritas\" más comunes son en su mayoría nombres y algunas palabras de una sola letra (Mr. Utterson es el amigo y abogado del Dr. Jekyll).\n", "\n", - "If we select words that only appear once, they are more likely to be actual misspellings.\n", - "We can do that by looping through the items and making a list of words with frequency `1`." + "Si seleccionamos palabras que solo aparecen una vez, es más probable que sean errores ortográficos reales.\n", + "Podemos hacerlo haciendo un bucle por los elementos y creando una lista de palabras con frecuencia `1`." ] }, { @@ -833,7 +833,7 @@ "id": "98ae9281", "metadata": {}, "source": [ - "Here are the last few elements of the list." + "Aquí están los últimos elementos de la lista." ] }, { @@ -851,8 +851,8 @@ "id": "c5040834", "metadata": {}, "source": [ - "Most of them are valid words that are not in the word list.\n", - "But `'reindue'` appears to be a misspelling of `'reinduce'`, so at least we found one legitimate error." + "La mayoría son palabras válidas que no están en la lista de palabras.\n", + "Pero `'reindue'` parece ser un error ortográfico de `'reinduce'`, así que al menos encontramos un error legítimo." ] }, { @@ -860,22 +860,22 @@ "id": "afcbbe19", "metadata": {}, "source": [ - "## Random numbers\n", + "## Números aleatorios\n", "\n", - "As a step toward Markov text generation, next we'll choose a random sequence of words from `word_counter`.\n", - "But first let's talk about randomness.\n", + "Como paso hacia la generación de texto de Markov, a continuación elegiremos una secuencia aleatoria de palabras de `word_counter`.\n", + "Pero primero hablemos de aleatoriedad.\n", "\n", - "Given the same inputs, most computer programs are **deterministic**, which means they generate the same outputs every time.\n", - "Determinism is usually a good thing, since we expect the same calculation to yield the same result.\n", - "For some applications, though, we want the computer to be unpredictable.\n", - "Games are one example, but there are more.\n", + "Dados los mismos inputs, la mayoría de los programas de computadora son **determinista**, lo que significa que generan los mismos outputs cada vez.\n", + "El determinismo suele ser algo bueno, ya que esperamos que el mismo cálculo produzca el mismo resultado.\n", + "Para algunas aplicaciones, sin embargo, queremos que la computadora sea impredecible.\n", + "Los juegos son un ejemplo, pero hay más.\n", "\n", - "Making a program truly nondeterministic turns out to be difficult, but there are ways to fake it.\n", - "One is to use algorithms that generate **pseudorandom** numbers.\n", - "Pseudorandom numbers are not truly random because they are generated by a deterministic computation, but just by looking at the numbers it is all but impossible to distinguish them from random.\n", + "Hacer que un programa sea verdaderamente no determinista resulta ser difícil, pero hay formas de simularlo.\n", + "Una es usar algoritmos que generan números **pseudorandom**.\n", + "Los números pseudorandom no son verdaderamente aleatorios porque se generan mediante un cálculo determinista, pero con solo mirar los números es prácticamente imposible distinguirlos de números aleatorios.\n", "\n", - "The `random` module provides functions that generate pseudorandom numbers -- which I will simply call \"random\" from here on.\n", - "We can import it like this." + "El módulo `random` proporciona funciones que generan números pseudorandom -- a los que de aquí en adelante simplemente llamaré \"random\".\n", + "Podemos importarlo así." ] }, { @@ -908,7 +908,7 @@ "id": "8cbbd7f8", "metadata": {}, "source": [ - "The `random` module provides a function called `choice` that chooses an element from a list at random, with every element having the same probability of being chosen." + "El módulo `random` proporciona una función llamada `choice` que elige un elemento de una lista al azar, con la misma probabilidad de elegir cada elemento." ] }, { @@ -927,7 +927,7 @@ "id": "57c15af2", "metadata": {}, "source": [ - "If you call the function again, you might get the same element again, or a different one." + "Si llamas a la función otra vez, podrías obtener el mismo elemento de nuevo, o uno diferente." ] }, { @@ -945,9 +945,9 @@ "id": "6f0c2572", "metadata": {}, "source": [ - "In the long run, we expect to get every element about the same number of times.\n", + "A largo plazo, esperamos obtener cada elemento aproximadamente el mismo número de veces.\n", "\n", - "If you use `choice` with a dictionary, you get a `KeyError`." + "Si usas `choice` con un diccionario, obtienes un `KeyError`." ] }, { @@ -969,7 +969,7 @@ "id": "592722f3", "metadata": {}, "source": [ - "To choose a random key, you have to put the keys in a list and then call `choice`." + "Para elegir una clave aleatoria, tienes que poner las claves en una lista y luego llamar a `choice`." ] }, { @@ -988,7 +988,7 @@ "id": "172d72f6", "metadata": {}, "source": [ - "If we generate a random sequence of words, it doesn't make much sense." + "Si generamos una secuencia aleatoria de palabras, no tiene mucho sentido." ] }, { @@ -1008,10 +1008,10 @@ "id": "e0e2fbc4", "metadata": {}, "source": [ - "Part of the problem is that we are not taking into account that some words are more common than others.\n", - "The results will be better if we choose words with different \"weights\", so that some are chosen more often than others.\n", + "Parte del problema es que no estamos teniendo en cuenta que algunas palabras son más comunes que otras.\n", + "Los resultados serán mejores si elegimos palabras con distintos \"weights\", de modo que algunas se elijan más a menudo que otras.\n", "\n", - "If we use the values from `word_counter` as weights, each word is chosen with a probability that depends on its frequency." + "Si usamos los valores de `word_counter` como weights, cada palabra se elige con una probabilidad que depende de su frecuencia." ] }, { @@ -1029,7 +1029,7 @@ "id": "5098bf93", "metadata": {}, "source": [ - "The `random` module provides another function called `choices` that takes weights as an optional argument." + "El módulo `random` proporciona otra función llamada `choices` que toma weights como argumento opcional." ] }, { @@ -1047,7 +1047,7 @@ "id": "a3341e84", "metadata": {}, "source": [ - "And it takes another optional argument, `k`, that specifies the number of words to select." + "Y toma otro argumento opcional, `k`, que especifica el número de palabras a seleccionar." ] }, { @@ -1066,7 +1066,7 @@ "id": "e57e6f3d", "metadata": {}, "source": [ - "The result is a list of strings that we can join into something that's looks more like a sentence." + "El resultado es una lista de strings que podemos unir en algo que se parece más a una oración." ] }, { @@ -1084,9 +1084,9 @@ "id": "c7a35dff", "metadata": {}, "source": [ - "If you choose words from the book at random, you get a sense of the vocabulary, but a series of random words seldom makes sense because there is no relationship between successive words.\n", - "For example, in a real sentence you expect an article like \"the\" to be followed by an adjective or a noun, and probably not a verb or adverb.\n", - "So the next step is to look at these relationships between words." + "Si eliges palabras del libro al azar, obtienes una idea del vocabulario, pero una serie de palabras aleatorias rara vez tiene sentido porque no hay relación entre palabras sucesivas.\n", + "Por ejemplo, en una oración real esperas que un artículo como \"the\" vaya seguido de un adjetivo o un sustantivo, y probablemente no de un verbo o adverbio.\n", + "Así que el siguiente paso es observar estas relaciones entre palabras." ] }, { @@ -1094,19 +1094,19 @@ "id": "0921dd53", "metadata": {}, "source": [ - "## Bigrams\n", + "## Bigramas\n", "\n", - "Instead of looking at one word at a time, now we'll look at sequences of two words, which are called **bigrams**.\n", - "A sequence of three words is called a **trigram**, and a sequence with some unspecified number of words is called an **n-gram**.\n", + "En lugar de mirar una palabra cada vez, ahora miraremos secuencias de dos palabras, que se llaman **bigramas**.\n", + "Una secuencia de tres palabras se llama **trigram**, y una secuencia con un número no especificado de palabras se llama **n-gram**.\n", "\n", - "Let's write a program that finds all of the bigrams in the book and the number of times each one appears.\n", - "To store the results, we'll use a dictionary where\n", + "Escribamos un programa que encuentre todos los bigramas del libro y el número de veces que aparece cada uno.\n", + "Para guardar los resultados, usaremos un diccionario donde\n", "\n", - "* The keys are tuples of strings that represent bigrams, and \n", + "* Las claves son tuplas de strings que representan bigramas, y \n", "\n", - "* The values are integers that represent frequencies.\n", + "* Los valores son enteros que representan frecuencias.\n", "\n", - "Let's call it `bigram_counter`." + "Llamémoslo `bigram_counter`." ] }, { @@ -1124,9 +1124,9 @@ "id": "33f97a2a", "metadata": {}, "source": [ - "The following function takes a list of two strings as a parameter.\n", - "First it makes a tuple of the two strings, which can be used as a key in a dictionary.\n", - "Then it adds the key to `bigram_counter`, if it doesn't exist, or increments the frequency if it does." + "La siguiente función toma una lista de dos strings como parámetro.\n", + "Primero crea una tupla con los dos strings, que puede usarse como clave en un diccionario.\n", + "Luego añade la clave a `bigram_counter`, si no existe, o incrementa la frecuencia si existe." ] }, { @@ -1149,11 +1149,11 @@ "id": "5c30f429", "metadata": {}, "source": [ - "As we go through the book, we have to keep track of each pair of consecutive words.\n", - "So if we see the sequence \"man is not truly one\", we would add the bigrams \"man is\", \"is not\", \"not truly\", and so on.\n", + "A medida que recorremos el libro, tenemos que llevar la cuenta de cada par de palabras consecutivas.\n", + "Así que si vemos la secuencia \"man is not truly one\", añadiríamos los bigramas \"man is\", \"is not\", \"not truly\", y así sucesivamente.\n", "\n", - "To keep track of these bigrams, we'll use a list called `window`, because it is like a window that slides over the pages of the book, showing only two words at a time.\n", - "Initially, `window` is empty." + "Para llevar la cuenta de estos bigramas, usaremos una lista llamada `window`, porque es como una ventana que se desliza sobre las páginas del libro, mostrando solo dos palabras a la vez.\n", + "Inicialmente, `window` está vacía." ] }, { @@ -1171,7 +1171,7 @@ "id": "9376558c", "metadata": {}, "source": [ - "We'll use the following function to process the words one at a time." + "Usaremos la siguiente función para procesar las palabras una por una." ] }, { @@ -1194,14 +1194,14 @@ "id": "56895591", "metadata": {}, "source": [ - "The first time this function is called, it appends the given word to `window`.\n", - "Since there is only one word in the window, we don't have a bigram yet, so the function ends.\n", + "La primera vez que se llama a esta función, añade la palabra dada a `window`.\n", + "Como solo hay una palabra en la window, todavía no tenemos un bigrama, así que la función termina.\n", "\n", - "The second time it's called -- and every time thereafter -- it appends a second word to `window`.\n", - "Since there are two words in the window, it calls `count_bigram` to keep track of how many times each bigram appears.\n", - "Then it uses `pop` to remove the first word from the window.\n", + "La segunda vez que se llama -- y todas las veces después -- añade una segunda palabra a `window`.\n", + "Como hay dos palabras en la window, llama a `count_bigram` para llevar la cuenta de cuántas veces aparece cada bigrama.\n", + "Luego usa `pop` para eliminar la primera palabra de la window.\n", "\n", - "The following program loops through the words in the book and processes them one at a time." + "El siguiente programa hace un bucle por las palabras del libro y las procesa una a una." ] }, { @@ -1222,8 +1222,8 @@ "id": "20c4627a", "metadata": {}, "source": [ - "The result is a dictionary that maps from each bigram to the number of times it appears.\n", - "We can use `print_most_common` to see the most common bigrams." + "El resultado es un diccionario que asocia cada bigrama con el número de veces que aparece.\n", + "Podemos usar `print_most_common` para ver los bigramas más comunes." ] }, { @@ -1241,8 +1241,8 @@ "id": "757bd309", "metadata": {}, "source": [ - "Looking at these results, we can get a sense of which pairs of words are most likely to appear together.\n", - "We can also use the results to generate random text, like this." + "Al mirar estos resultados, podemos hacernos una idea de qué pares de palabras tienen más probabilidad de aparecer juntos.\n", + "También podemos usar los resultados para generar texto aleatorio, así." ] }, { @@ -1274,10 +1274,10 @@ "id": "eda80407", "metadata": {}, "source": [ - "`bigrams` is a list of the bigrams that appear in the books.\n", - "`weights` is a list of their frequencies, so `random_bigrams` is a sample where the probability a bigram is selected is proportional to its frequency. \n", + "`bigrams` es una lista de los bigramas que aparecen en los libros.\n", + "`weights` es una lista de sus frecuencias, así que `random_bigrams` es una muestra donde la probabilidad de que se seleccione un bigrama es proporcional a su frecuencia. \n", "\n", - "Here are the results." + "Aquí están los resultados." ] }, { @@ -1296,7 +1296,7 @@ "id": "5f24c3b6", "metadata": {}, "source": [ - "This way of generating text is better than choosing random words, but still doesn't make a lot of sense." + "Esta forma de generar texto es mejor que elegir palabras aleatorias, pero todavía no tiene mucho sentido." ] }, { @@ -1304,10 +1304,10 @@ "id": "a13d93b5", "metadata": {}, "source": [ - "## Markov analysis\n", + "## Análisis de Markov\n", "\n", - "We can do better with Markov chain text analysis, which computes, for each word in a text, the list of words that come next.\n", - "As an example, we'll analyze these lyrics from the Monty Python song *Eric, the Half a Bee*:" + "Podemos hacerlo mejor con el análisis de texto mediante cadenas de Markov, que calcula, para cada palabra de un texto, la lista de palabras que vienen después.\n", + "Como ejemplo, analizaremos esta letra de la canción de Monty Python *Eric, the Half a Bee*:" ] }, { @@ -1330,7 +1330,7 @@ "id": "583ab9f0", "metadata": {}, "source": [ - "To store the results, we'll use a dictionary that maps from each word to the list of words that follow it." + "Para guardar los resultados, usaremos un diccionario que asocia cada palabra con la lista de palabras que la siguen." ] }, { @@ -1348,7 +1348,7 @@ "id": "d5d85b09", "metadata": {}, "source": [ - "As an example, let's start with the first two words of the song." + "Como ejemplo, empecemos con las dos primeras palabras de la canción." ] }, { @@ -1367,7 +1367,7 @@ "id": "0349fe78", "metadata": {}, "source": [ - "If the first word is not in `successor_map`, we have to add a new item that maps from the first word to a list containing the second word." + "Si la primera palabra no está en `successor_map`, tenemos que añadir un nuevo elemento que asocie la primera palabra con una lista que contiene la segunda palabra." ] }, { @@ -1386,7 +1386,7 @@ "id": "55bb8df9", "metadata": {}, "source": [ - "If the first word is already in the dictionary, we can look it up to get the list of successors we've seen so far, and append the new one." + "Si la primera palabra ya está en el diccionario, podemos buscarla para obtener la lista de sucesores que hemos visto hasta ahora, y añadir el nuevo." ] }, { @@ -1408,7 +1408,7 @@ "id": "6289cc32", "metadata": {}, "source": [ - "The following function encapsulates these steps." + "La siguiente función encapsula estos pasos." ] }, { @@ -1432,11 +1432,11 @@ "id": "74a51700", "metadata": {}, "source": [ - "If the same bigram appears more that once, the second word is added to the list more than once.\n", - "In this way, `successor_map` keeps track of how many times each successor appears.\n", + "Si el mismo bigrama aparece más de una vez, la segunda palabra se añade a la lista más de una vez.\n", + "De esta manera, `successor_map` lleva la cuenta de cuántas veces aparece cada sucesor.\n", "\n", - "As we did in the previous section, we'll use a list called `window` to store pairs of consecutive words.\n", - "And we'll use the following function to process the words one at a time." + "Como hicimos en la sección anterior, usaremos una lista llamada `window` para guardar pares de palabras consecutivas.\n", + "Y usaremos la siguiente función para procesar las palabras una por una." ] }, { @@ -1459,7 +1459,7 @@ "id": "861a60d9", "metadata": {}, "source": [ - "Here's how we use it to process the words in the song." + "Así es como la usamos para procesar las palabras de la canción." ] }, { @@ -1482,7 +1482,7 @@ "id": "bf490d67", "metadata": {}, "source": [ - "And here are the results." + "Y aquí están los resultados." ] }, { @@ -1500,11 +1500,11 @@ "id": "ff7bad74", "metadata": {}, "source": [ - "The word `'half'` can be followed by `'a'`, `'not'`, or `'the'`.\n", - "The word `'a'` can be followed by `'bee'` or `'vis'`.\n", - "Most of the other words appear only once, so they are followed by only a single word.\n", + "La palabra `'half'` puede ir seguida de `'a'`, `'not'` o `'the'`.\n", + "La palabra `'a'` puede ir seguida de `'bee'` o `'vis'`.\n", + "La mayoría de las demás palabras aparecen solo una vez, así que van seguidas de una única palabra.\n", "\n", - "Now let's analyze the book." + "Ahora analicemos el libro." ] }, { @@ -1528,7 +1528,7 @@ "id": "2676e2fb", "metadata": {}, "source": [ - "We can look up any word and find the words that can follow it." + "Podemos buscar cualquier palabra y encontrar las palabras que pueden seguirla." ] }, { @@ -1566,7 +1566,7 @@ "id": "7b777a9c", "metadata": {}, "source": [ - "In this list of successors, notice that the word `'to'` appears three times -- the other successors only appear once." + "En esta lista de sucesores, observa que la palabra `'to'` aparece tres veces -- los demás sucesores aparecen solo una vez." ] }, { @@ -1574,18 +1574,18 @@ "id": "e8bf85fc", "metadata": {}, "source": [ - "## Generating text\n", + "## Generar texto\n", "\n", - "We can use the results from the previous section to generate new text with the same relationships between consecutive words as in the original.\n", - "Here's how it works:\n", + "Podemos usar los resultados de la sección anterior para generar texto nuevo con las mismas relaciones entre palabras consecutivas que en el original.\n", + "Así funciona:\n", "\n", - "* Starting with any word that appears in the text, we look up its possible successors and choose one at random.\n", + "* Empezando con cualquier palabra que aparezca en el texto, buscamos sus posibles sucesores y elegimos uno al azar.\n", "\n", - "* Then, using the chosen word, we look up its possible successors, and choose one at random.\n", + "* Luego, usando la palabra elegida, buscamos sus posibles sucesores y elegimos uno al azar.\n", "\n", - "We can repeat this process to generate as many words as we want.\n", - "As an example, let's start with the word `'although'`.\n", - "Here are the words that can follow it." + "Podemos repetir este proceso para generar tantas palabras como queramos.\n", + "Como ejemplo, empecemos con la palabra `'although'`.\n", + "Estas son las palabras que pueden seguirla." ] }, { @@ -1621,7 +1621,7 @@ "id": "b26a2ead", "metadata": {}, "source": [ - "We can use `choice` to choose from the list with equal probability." + "Podemos usar `choice` para elegir de la lista con la misma probabilidad." ] }, { @@ -1640,9 +1640,9 @@ "id": "9741beca", "metadata": {}, "source": [ - "If the same word appears more than once in the list, it is more likely to be selected.\n", + "Si la misma palabra aparece más de una vez en la lista, es más probable que sea seleccionada.\n", "\n", - "Repeating these steps, we can use the following loop to generate a longer series." + "Repitiendo estos pasos, podemos usar el siguiente bucle para generar una serie más larga." ] }, { @@ -1663,11 +1663,11 @@ "id": "38a2d79a", "metadata": {}, "source": [ - "The result sounds more like a real sentence, but it still doesn't make much sense.\n", + "El resultado suena más como una oración real, pero todavía no tiene mucho sentido.\n", "\n", - "We can do better using more than one word as a key in `successor_map`.\n", - "For example, we can make a dictionary that maps from each bigram -- or trigram -- to the list of words that come next.\n", - "As an exercise, you'll have a chance to implement this analysis and see what the results look like." + "Podemos hacerlo mejor usando más de una palabra como clave en `successor_map`.\n", + "Por ejemplo, podemos crear un diccionario que asocie cada bigrama -- o trigram -- con la lista de palabras que vienen después.\n", + "Como ejercicio, tendrás la oportunidad de implementar este análisis y ver cómo son los resultados." ] }, { @@ -1677,32 +1677,32 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "At this point we are writing more substantial programs, and you might find that you are spending more time debugging.\n", - "If you are stuck on a difficult bug, here are a few things to try:\n", + "A estas alturas estamos escribiendo programas más sustanciales, y puede que descubras que pasas más tiempo depurando.\n", + "Si estás atascado con un bug difícil, aquí tienes algunas cosas que puedes probar:\n", "\n", - "* Reading: Examine your code, read it back to yourself, and check that it says what you meant to say.\n", + "* Leer: examina tu código, léelo en voz alta para ti y comprueba que dice lo que querías decir.\n", "\n", - "* Running: Experiment by making changes and running different versions. Often if you display the right thing at the right place in the program, the problem becomes obvious, but sometimes you have to build scaffolding.\n", + "* Ejecutar: experimenta haciendo cambios y ejecutando versiones diferentes. A menudo, si muestras lo correcto en el lugar correcto del programa, el problema se vuelve obvio, pero a veces tienes que construir código de apoyo.\n", "\n", - "* Ruminating: Take some time to think! What kind of error is it: syntax, runtime,\n", - " or semantic? What information can you get from the error messages,\n", - " or from the output of the program? What kind of error could cause\n", - " the problem you're seeing? What did you change last, before the\n", - " problem appeared?\n", + "* Rumiar: ¡tómate tiempo para pensar! ¿Qué tipo de error es: de sintaxis, de runtime,\n", + " o semántico? ¿Qué información puedes obtener de los mensajes de error,\n", + " o del output del programa? ¿Qué tipo de error podría causar\n", + " el problema que estás viendo? ¿Qué cambiaste por última vez, antes de que\n", + " apareciera el problema?\n", "\n", - "* Rubberducking: If you explain the problem to someone else, you sometimes find the\n", - " answer before you finish asking the question. Often you don't need\n", - " the other person; you could just talk to a rubber duck. And that's\n", - " the origin of the well-known strategy called **rubber duck\n", - " debugging**. I am not making this up -- see\n", - " .\n", + "* Rubberducking: si explicas el problema a otra persona, a veces encuentras la\n", + " respuesta antes de terminar de hacer la pregunta. A menudo no necesitas\n", + " a la otra persona; podrías hablarle a un patito de goma. Y ese es\n", + " el origen de la estrategia conocida como **rubber duck\n", + " depuración**. No me lo estoy inventando -- ver\n", + " .\n", "\n", - "* Retreating: At some point, the best thing to do is back up -- undoing recent\n", - " changes -- until you get to a program that works. Then you can start rebuilding.\n", + "* Retirarse: en algún momento, lo mejor es retroceder -- deshacer cambios\n", + " recientes -- hasta llegar a un programa que funcione. Luego puedes empezar a reconstruir.\n", " \n", - "* Resting: If you give your brain a break, sometime it will find the problem for you." + "* Descansar: si le das un respiro a tu cerebro, a veces encontrará el problema por ti." ] }, { @@ -1710,15 +1710,15 @@ "id": "12c2cd32", "metadata": {}, "source": [ - "Beginning programmers sometimes get stuck on one of these activities and forget the others. Each activity comes with its own failure mode.\n", + "Los programadores principiantes a veces se quedan atascados en una de estas actividades y olvidan las demás. Cada actividad tiene su propio modo de fallo.\n", "\n", - "For example, reading your code works if the problem is a typographical error, but not if the problem is a conceptual misunderstanding.\n", - "If you don't understand what your program does, you can read it 100 times and never see the error, because the error is in your head.\n", + "Por ejemplo, leer tu código funciona si el problema es un error tipográfico, pero no si el problema es un malentendido conceptual.\n", + "Si no entiendes lo que hace tu programa, puedes leerlo 100 veces y nunca ver el error, porque el error está en tu cabeza.\n", "\n", - "Running experiments can work, especially if you run small, simple tests.\n", - "But if you run experiments without thinking or reading your code, it can take a long time to figure out what's happening.\n", + "Ejecutar experimentos puede funcionar, especialmente si ejecutas tests pequeños y simples.\n", + "Pero si haces experimentos sin pensar ni leer tu código, puede llevar mucho tiempo averiguar qué está pasando.\n", "\n", - "You have to take time to think. Debugging is like an experimental science. You should have at least one hypothesis about what the problem is. If there are two or more possibilities, try to think of a test that would eliminate one of them." + "Tienes que tomarte tiempo para pensar. Depurar es como una ciencia experimental. Deberías tener al menos una hipótesis sobre cuál es el problema. Si hay dos o más posibilidades, intenta pensar en un test que elimine una de ellas." ] }, { @@ -1726,18 +1726,13 @@ "id": "a55036e1", "metadata": {}, "source": [ - "But even the best debugging techniques will fail if there are too many\n", - "errors, or if the code you are trying to fix is too big and complicated.\n", - "Sometimes the best option is to retreat, simplifying the program until\n", - "you get back to something that works.\n", + "Pero incluso las mejores técnicas de depuración fallarán si hay demasiados errores, o si el código que intentas arreglar es demasiado grande y complicado.\n", + "A veces la mejor opción es retirarse, simplificando el programa hasta volver a algo que funcione.\n", "\n", - "Beginning programmers are often reluctant to retreat because they can't\n", - "stand to delete a line of code (even if it's wrong). If it makes you\n", - "feel better, copy your program into another file before you start\n", - "stripping it down. Then you can copy the pieces back one at a time.\n", + "Los programadores principiantes a menudo se resisten a retirarse porque no soportan borrar una línea de código (aunque esté mal). Si te hace sentir mejor, copia tu programa en otro archivo antes de empezar a recortarlo. Luego puedes copiar las piezas de vuelta una por una.\n", "\n", - "Finding a hard bug requires reading, running, ruminating, retreating, and sometimes resting.\n", - "If you get stuck on one of these activities, try the others." + "Encontrar un bug difícil requiere leer, ejecutar, rumiar, retirarse y a veces descansar.\n", + "Si te atascas en una de estas actividades, prueba las otras." ] }, { @@ -1745,31 +1740,31 @@ "id": "25d091af", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**default value:**\n", - "The value assigned to a parameter if no argument is provided.\n", + "**valor por defecto:**\n", + "El valor asignado a un parámetro si no se proporciona ningún argumento.\n", "\n", "**override:**\n", - " To replace a default value with an argument.\n", + " Reemplazar un valor por defecto por un argumento.\n", "\n", - "**deterministic:**\n", - " A deterministic program does the same thing each time it runs, given the same inputs.\n", + "**determinista:**\n", + " Un programa determinista hace lo mismo cada vez que se ejecuta, dados los mismos inputs.\n", "\n", "**pseudorandom:**\n", - " A pseudorandom sequence of numbers appears to be random, but is generated by a deterministic program.\n", + " Una secuencia pseudorandom de números parece aleatoria, pero es generada por un programa determinista.\n", "\n", - "**bigram:**\n", - "A sequence of two elements, often words.\n", + "**bigrama:**\n", + "Una secuencia de dos elementos, a menudo palabras.\n", "\n", "**trigram:**\n", - "A sequence of three elements.\n", + "Una secuencia de tres elementos.\n", "\n", "**n-gram:**\n", - "A sequence of an unspecified number of elements.\n", + "Una secuencia de un número no especificado de elementos.\n", "\n", - "**rubber duck debugging:**\n", - "A way of debugging by explaining a problem aloud to an inanimate object." + "**rubber duck depuración:**\n", + "Una forma de depurar explicando un problema en voz alta a un objeto inanimado." ] }, { @@ -1777,7 +1772,7 @@ "id": "cde18229", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1800,9 +1795,9 @@ "id": "9b0efab8", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "In `add_bigram`, the `if` statement creates a new list or appends an element to an existing list, depending on whether the key is already in the dictionary." + "En `add_bigram`, la sentencia `if` crea una nueva lista o añade un elemento a una lista existente, dependiendo de si la clave ya está en el diccionario." ] }, { @@ -1826,13 +1821,13 @@ "id": "30d9e549", "metadata": {}, "source": [ - "Dictionaries provide a method called `setdefault` that we can use to do the same thing more concisely.\n", - "Ask a virtual assistant how it works, or copy `add_bigram` into a virtual assistant and ask \"Can you rewrite this using `setdefault`?\"\n", + "Diccionarios proporcionan un método llamado `setdefault` que podemos usar para hacer lo mismo de forma más concisa.\n", + "Pregunta a un asistente virtual cómo funciona, o copia `add_bigram` en un asistente virtual y pregunta \"Can you rewrite this using `setdefault`?\"\n", "\n", - "In this chapter we implemented Markov chain text analysis and generation.\n", - "If you are curious, you can ask a virtual assistant for more information on the topic.\n", - "One of the things you might learn is that virtual assistants use algorithms that are similar in many ways -- but also different in important ways.\n", - "Ask a VA, \"What are the differences between large language models like GPT and Markov chain text analysis?\"" + "En este capítulo implementamos análisis y generación de texto con cadenas de Markov.\n", + "Si tienes curiosidad, puedes pedirle a un asistente virtual más información sobre el tema.\n", + "Una de las cosas que podrías aprender es que los asistentes virtuales usan algoritmos que son similares en muchos aspectos -- pero también diferentes en aspectos importantes.\n", + "Pregunta a un VA: \"What are the differences between large language models like GPT and Markov chain text analysis?" ] }, { @@ -1840,12 +1835,12 @@ "id": "060c9ef6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function that counts the number of times each trigram (sequence of three words) appears. \n", - "If you test your function with the text of _Dr. Jekyll and Mr. Hyde_, you should find that the most common trigram is \"said the lawyer\".\n", + "Escribe una función que cuente el número de veces que aparece cada trigram (secuencia de tres palabras). \n", + "Si pruebas tu función con el texto de _Dr. Jekyll and Mr. Hyde_, deberías encontrar que el trigram más común es \"said the lawyer\".\n", "\n", - "Hint: Write a function called `count_trigram` that is similar to `count_bigram`. Then write a function called `process_word_trigram` that is similar to `process_word_bigram`." + "Pista: escribe una función llamada `count_trigram` que sea similar a `count_bigram`. Luego escribe una función llamada `process_word_trigram` que sea similar a `process_word_bigram`." ] }, { @@ -1875,7 +1870,7 @@ "tags": [] }, "source": [ - "You can use the following loop to read the book and process the words." + "Puedes usar el siguiente bucle para leer el libro y procesar las palabras." ] }, { @@ -1903,7 +1898,7 @@ "tags": [] }, "source": [ - "Then use `print_most_common` to find the most common trigrams in the book." + "Luego usa `print_most_common` para encontrar los trigrams más comunes del libro." ] }, { @@ -1923,11 +1918,11 @@ "id": "4bd07bb7", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Now let's implement Markov chain text analysis with a mapping from each bigram to a list of possible successors.\n", + "Ahora implementemos análisis de texto con cadenas de Markov usando un mapeo de cada bigrama a una lista de posibles sucesores.\n", "\n", - "Starting with `add_bigram`, write a function called `add_trigram` that takes a list of three words and either adds or updates an item in `successor_map`, using the first two words as the key and the third word as a possible successor." + "Empezando con `add_bigram`, escribe una función llamada `add_trigram` que tome una lista de tres palabras y añada o actualice un elemento en `successor_map`, usando las dos primeras palabras como clave y la tercera palabra como posible sucesor." ] }, { @@ -1945,7 +1940,7 @@ "id": "94d683fe", "metadata": {}, "source": [ - "Here's a version of `process_word_trigram` that calls `add_trigram`." + "Aquí tienes una versión de `process_word_trigram` que llama a `add_trigram`." ] }, { @@ -1970,7 +1965,7 @@ "tags": [] }, "source": [ - "You can use the following loop to test your function with the lyrics of \"Eric, the Half a Bee\"." + "Puedes usar el siguiente bucle para probar tu función con la letra de \"Eric, the Half a Bee\"." ] }, { @@ -1997,8 +1992,8 @@ "tags": [] }, "source": [ - "If your function works as intended, the predecessor `('half', 'a')` should map to a list with the single element `'bee'`.\n", - "In fact, as it happens, each bigram in this song appear only once, so all of the values in `successor_map` have a single element." + "Si tu función funciona como se espera, el predecesor `('half', 'a')` debería asociarse con una lista cuyo único elemento es `'bee'`.\n", + "De hecho, resulta que cada bigrama de esta canción aparece solo una vez, así que todos los valores de `successor_map` tienen un único elemento." ] }, { @@ -2018,7 +2013,7 @@ "id": "886212b5", "metadata": {}, "source": [ - "You can use the following loop to test your function with the words from the book." + "Puedes usar el siguiente bucle para probar tu función con las palabras del libro." ] }, { @@ -2042,7 +2037,7 @@ "id": "3e1d073e", "metadata": {}, "source": [ - "In the next exercise, you'll use the results to generate new random text." + "En el siguiente ejercicio, usarás los resultados para generar nuevo texto aleatorio." ] }, { @@ -2050,9 +2045,9 @@ "id": "04d7a6ee", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "For this exercise, we'll assume that `successor_map` is a dictionary that maps from each bigram to the list of words that follow it." + "Para este ejercicio, asumiremos que `successor_map` es un diccionario que asocia cada bigrama con la lista de palabras que lo siguen." ] }, { @@ -2076,7 +2071,7 @@ "id": "fb0f8f7d", "metadata": {}, "source": [ - "To generate random text, we'll start by choosing a random key from `successor_map`." + "Para generar texto aleatorio, empezaremos eligiendo una clave aleatoria de `successor_map`." ] }, { @@ -2096,15 +2091,15 @@ "id": "83ed6c7e", "metadata": {}, "source": [ - "Now write a loop that generates 50 more words following these steps:\n", + "Ahora escribe un bucle que genere 50 palabras más siguiendo estos pasos:\n", "\n", - "1. In `successor_map`, look up the list of words that can follow `bigram`.\n", + "1. En `successor_map`, busca la lista de palabras que pueden seguir a `bigram`.\n", "\n", - "2. Choose one of them at random and print it.\n", + "2. Elige una de ellas al azar e imprímela.\n", "\n", - "3. For the next iteration, make a new bigram that contains the second word from `bigram` and the chosen successor.\n", + "3. Para la siguiente iteración, crea un nuevo bigrama que contenga la segunda palabra de `bigram` y el sucesor elegido.\n", "\n", - "For example, if we start with the bigram `('doubted', 'if')` and choose `'from'` as its successor, the next bigram is `('if', 'from')`." + "Por ejemplo, si empezamos con el bigrama `('doubted', 'if')` y elegimos `'from'` como sucesor, el siguiente bigrama es `('if', 'from')`." ] }, { @@ -2122,9 +2117,9 @@ "id": "c71d8a89", "metadata": {}, "source": [ - "If everything is working, you should find that the generated text is recognizably similar in style to the original, and some phrases make sense, but the text might wander from one topic to another.\n", + "Si todo funciona, deberías encontrar que el texto generado es reconociblemente similar en estilo al original, y algunas frases tienen sentido, pero el texto podría saltar de un tema a otro.\n", "\n", - "As a bonus exercise, modify your solution to the last two exercises to use trigrams as keys in `successor_map`, and see what effect it has on the results." + "Como ejercicio extra, modifica tu solución a los dos últimos ejercicios para usar trigrams como claves en `successor_map`, y mira qué efecto tiene en los resultados." ] }, { @@ -2146,7 +2141,9 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", + "\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" ] diff --git a/chapters/chap13.ipynb b/chapters/chap13.ipynb index fe8f516..0d594ab 100644 --- a/chapters/chap13.ipynb +++ b/chapters/chap13.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -43,8 +43,8 @@ "tags": [] }, "source": [ - "Credit: Photos downloaded from [Lorem Picsum](https://picsum.photos/), a service that provides placeholder images.\n", - "The name is a reference to \"lorem ipsum\", which is a name for placeholder text.\n" + "Crédito: las fotos se descargaron de [Lorem Picsum](https://picsum.photos/), un servicio que proporciona imágenes de marcador de posición.\n", + "El nombre es una referencia a \"lorem ipsum\", que es un nombre para texto de marcador de posición.\n" ] }, { @@ -94,19 +94,19 @@ "id": "92934cb0", "metadata": {}, "source": [ - "# Files and Databases\n", + "# Archivos y bases de datos\n", "\n", - "Most of the programs we have seen so far are **ephemeral** in the sense that they run for a short time and produce output, but when they end, their data disappears.\n", - "Each time you run an ephemeral program, it starts with a clean slate.\n", + "La mayoría de los programas que hemos visto hasta ahora son **efímeros** en el sentido de que se ejecutan durante poco tiempo y producen output, pero cuando terminan, sus datos desaparecen.\n", + "Cada vez que ejecutas un programa efímero, empieza desde cero.\n", "\n", - "Other programs are **persistent**: they run for a long time (or all the time); they keep at least some of their data in long-term storage; and if they shut down and restart, they pick up where they left off.\n", + "Otros programas son **persistentes**: se ejecutan durante mucho tiempo (o todo el tiempo); mantienen al menos parte de sus datos en almacenamiento a largo plazo; y, si se cierran y se reinician, continúan donde lo dejaron.\n", "\n", - "A simple way for programs to maintain their data is by reading and writing text files.\n", - "A more versatile alternative is to store data in a database.\n", - "Databases are specialized files that can be read and written more efficiently than text files, and they provide additional capabilities.\n", + "Una forma sencilla de que los programas mantengan sus datos es leer y escribir archivos de texto.\n", + "Una alternativa más versátil es almacenar datos en una base de datos.\n", + "Las bases de datos son archivos especializados que se pueden leer y escribir de forma más eficiente que los archivos de texto, y proporcionan capacidades adicionales.\n", "\n", - "In this chapter, we'll write programs that read and write text files and databases, and as an exercise you'll write a program that searches a collection of photos for duplicates.\n", - "But before you can work with a file, you have to find it, so we'll start with file names, paths, and directories." + "En este capítulo escribiremos programas que leen y escriben archivos de texto y bases de datos, y como ejercicio escribirás un programa que busca duplicados en una colección de fotos.\n", + "Pero antes de poder trabajar con un archivo, tienes que encontrarlo, así que empezaremos con nombres de archivo, rutas y directorios." ] }, { @@ -114,14 +114,14 @@ "id": "75cec7ca", "metadata": {}, "source": [ - "## Filenames and paths\n", + "## Nombres de archivo y rutas\n", "\n", - "Files are organized into **directories**, also called \"folders\".\n", - "Every running program has a **current working directory**, which is the default directory for most operations.\n", - "For example, when you open a file, Python looks for it in the current working directory.\n", + "Los archivos se organizan en **directorios**, también llamados \"carpetas\".\n", + "Todo programa en ejecución tiene un **directorio de trabajo actual**, que es el directorio por defecto para la mayoría de operaciones.\n", + "Por ejemplo, cuando abres un archivo, Python lo busca en el directorio de trabajo actual.\n", "\n", - "The `os` module provides functions for working with files and directories (\"os\" stands for \"operating system\"). \n", - "It provides a function called `getcwd` that gets the name of the current working directory." + "El módulo `os` proporciona funciones para trabajar con archivos y directorios (\"os\" significa \"operating system\"). \n", + "Proporciona una función llamada `getcwd` que obtiene el nombre del directorio de trabajo actual." ] }, { @@ -160,14 +160,14 @@ "id": "6c55575f", "metadata": {}, "source": [ - "The result in this example is the home directory of a user named `dinsdale`.\n", - "A string like `'/home/dinsdale'` that identifies a file or directory is called a **path**.\n", + "El resultado en este ejemplo es el directorio personal de un usuario llamado `dinsdale`.\n", + "Una string como `'/home/dinsdale'` que identifica un archivo o directorio se llama **ruta**.\n", "\n", - "A simple filename like `'memo.txt'` is also considered a path, but it is a **relative path** because it specifies a file name relative to the current directory.\n", - "In this example, the current directory is `/home/dinsdale`, so `'memo.txt'` is equivalent to the complete path `'/home/dinsdale/memo.txt'`.\n", + "Un nombre de archivo sencillo como `'memo.txt'` también se considera una ruta, pero es un **ruta relativa** porque especifica un nombre de archivo relativo al directorio actual.\n", + "En este ejemplo, el directorio actual es `/home/dinsdale`, así que `'memo.txt'` equivale a la ruta completa `'/home/dinsdale/memo.txt'`.\n", "\n", - "A path that begins with `/` does not depend on the current directory -- it is called an **absolute path**. \n", - "To find the absolute path to a file, you can use `abspath`." + "Un ruta que empieza con `/` no depende del directorio actual -- se llama **ruta absoluta**. \n", + "Para encontrar la ruta absoluta de un archivo, puedes usar `abspath`." ] }, { @@ -185,9 +185,9 @@ "id": "f1a0cf04", "metadata": {}, "source": [ - "The `os` module provides other functions for working with filenames and paths.\n", - "`listdir` returns a list of the contents of the given directory, including files and other directories.\n", - "Here's an example that lists the contents of a directory named `photos`." + "El módulo `os` proporciona otras funciones para trabajar con nombres de archivo y rutas.\n", + "`listdir` devuelve una lista con el contenido del directorio indicado, incluyendo archivos y otros directorios.\n", + "Aquí tienes un ejemplo que lista el contenido de un directorio llamado `photos`." ] }, { @@ -205,8 +205,8 @@ "id": "ab160f29", "metadata": {}, "source": [ - "This directory contains a text file named `notes.txt` and three directories.\n", - "The directories contain image files in the JPEG format." + "Este directorio contiene un archivo de texto llamado `notes.txt` y tres directorios.\n", + "Los directorios contienen archivos de imagen en formato JPEG." ] }, { @@ -224,7 +224,7 @@ "id": "06b27c85", "metadata": {}, "source": [ - "To check whether a file or directory exists, we can use `os.path.exists`." + "Para comprobar si existe un archivo o directorio, podemos usar `os.path.exists`." ] }, { @@ -252,7 +252,7 @@ "id": "d41f235c", "metadata": {}, "source": [ - "To check whether a path refers to a file or directory, we can use `isdir`, which return `True` if a path refers to a directory." + "Para comprobar si una ruta se refiere a un archivo o a un directorio, podemos usar `isdir`, que devuelve `True` si una ruta se refiere a un directorio." ] }, { @@ -270,7 +270,7 @@ "id": "4bd70cc9", "metadata": {}, "source": [ - "And `isfile` which returns `True` if a path refers to a file." + "Y `isfile`, que devuelve `True` si una ruta se refiere a un archivo." ] }, { @@ -288,12 +288,12 @@ "id": "c6933c18", "metadata": {}, "source": [ - "One challenge of working with paths is that they look different on different operating systems.\n", - "On macOS and UNIX systems like Linux, the directory and file names in a path are separated by a forward slash, `/`.\n", - "Windows uses a backward slash, `\\`.\n", - "So, if you you run these examples on Windows, you will see backward slashes in the paths, and you'll have to replace the forward slashes in the examples.\n", + "Un desafío al trabajar con rutas es que se ven distintos en diferentes sistemas operativos.\n", + "En macOS y sistemas UNIX como Linux, los nombres de directorios y archivos en una ruta se separan con una barra inclinada, `/`.\n", + "Windows usa una barra invertida, `\\`.\n", + "Así que, si ejecutas estos ejemplos en Windows, verás barras invertidas en los rutas y tendrás que reemplazar las barras inclinadas de los ejemplos.\n", "\n", - "Or, to write code that works on both systems, you can use `os.path.join`, which joins directory and filenames into a path using a forward or backward slash, depending on which operating system you are using." + "O, para escribir código que funcione en ambos sistemas, puedes usar `os.path.join`, que une nombres de directorio y de archivo en una ruta usando una barra inclinada o invertida, según el sistema operativo que estés usando." ] }, { @@ -311,7 +311,7 @@ "id": "0a665cf9", "metadata": {}, "source": [ - "Later in this chapter we'll use these functions to search a set of directories and find all of the image files." + "Más adelante en este capítulo usaremos estas funciones para buscar en un conjunto de directorios y encontrar todos los archivos de imagen." ] }, { @@ -321,10 +321,10 @@ "source": [ "## f-strings\n", "\n", - "One way for programs to store data is to write it to a text file.\n", - "For example, suppose you are a camel spotter, and you want to record the number of camels you have seen during a period of observation.\n", - "And suppose that in one and a half years, you have spotted `23` camels.\n", - "The data in your camel-spotting book might look like this." + "Una forma en que los programas almacenan datos es escribirlos en un archivo de texto.\n", + "Por ejemplo, supón que observas camellos y quieres registrar el número de camellos que has visto durante un periodo de observación.\n", + "Y supón que en un año y medio has visto `23` camellos.\n", + "Los datos de tu cuaderno de observación de camellos podrían verse así." ] }, { @@ -343,11 +343,11 @@ "id": "f652aaac", "metadata": {}, "source": [ - "To write this data to a file, you can use the `write` method, which we saw in Chapter 8.\n", - "The argument of `write` has to be a string, so if we want to put other values in a file, we have to convert them to strings.\n", - "The easiest way to do that is with the built-in function `str`.\n", + "Para escribir estos datos en un archivo, puedes usar el método `write`, que vimos en el Capítulo 8.\n", + "El argumento de `write` tiene que ser una string, así que si queremos poner otros valores en un archivo, tenemos que convertirlos a strings.\n", + "La forma más sencilla de hacerlo es con la función integrada `str`.\n", "\n", - "Here's what that looks like:" + "Así es como se ve:" ] }, { @@ -368,8 +368,8 @@ "id": "307c22d2", "metadata": {}, "source": [ - "That works, but `write` doesn't add a space or newline unless you include it explicitly.\n", - "If we read back the file, we see that the two numbers are run together." + "Eso funciona, pero `write` no añade un espacio ni una nueva línea a menos que lo incluyas explícitamente.\n", + "Si volvemos a leer el archivo, vemos que los dos números quedan pegados." ] }, { @@ -387,11 +387,11 @@ "id": "8008ecdc", "metadata": {}, "source": [ - "At the very least, we should add whitespace between the numbers.\n", - "And while we're at it, let's add some explanatory text.\n", + "Como mínimo, deberíamos añadir espacios en blanco entre los números.\n", + "Y ya que estamos, añadamos algo de texto explicativo.\n", "\n", - "To write a combination of strings and other values, we can use an **f-string**, which is a string that has the letter `f` before the opening quotation mark, and contains one or more Python expressions in curly braces.\n", - "The following f-string contains one expression, which is a variable name." + "Para escribir una combinación de strings y otros valores, podemos usar una **f-string**, que es una string que tiene la letra `f` antes de la comilla de apertura y contiene una o más expresiones de Python entre llaves.\n", + "La siguiente f-string contiene una expresión, que es el nombre de una variable." ] }, { @@ -409,8 +409,8 @@ "id": "a3fb0556", "metadata": {}, "source": [ - "The result is a string where the expression has been evaluated and replaced with the result.\n", - "There can be more than one expression." + "El resultado es una string donde la expresión se ha evaluado y se ha reemplazado por el resultado.\n", + "Puede haber más de una expresión." ] }, { @@ -428,7 +428,7 @@ "id": "bace1539", "metadata": {}, "source": [ - "And the expressions can contain operators and function calls." + "Y las expresiones pueden contener operadores y llamadas a función." ] }, { @@ -447,7 +447,7 @@ "id": "bc6fa094", "metadata": {}, "source": [ - "So we could write the data to a text file like this." + "Así que podríamos escribir los datos en un archivo de texto así." ] }, { @@ -468,9 +468,9 @@ "id": "f916d561", "metadata": {}, "source": [ - "Both f-strings end with the sequence `\\n`, which adds a newline character.\n", + "Ambas f-strings terminan con la secuencia `\\n`, que añade un carácter de nueva línea.\n", "\n", - "We can read the file back like this:" + "Podemos volver a leer el archivo así:" ] }, { @@ -489,7 +489,7 @@ "id": "c3bf6913", "metadata": {}, "source": [ - "In an f-string, an expression in curly brace is converted to a string, so you can include lists, dictionaries, and other types." + "En una f-string, una expresión entre llaves se convierte en una string, así que puedes incluir listas, diccionarios y otros tipos." ] }, { @@ -511,7 +511,7 @@ "tags": [] }, "source": [ - "If a f-string contains an invalid expression, the result is an error." + "Si una f-string contiene una expresión no válida, el resultado es un error." ] }, { @@ -535,11 +535,11 @@ "source": [ "## YAML\n", "\n", - "One of the reasons programs read and write files is to store **configuration data**, which is information that specifies what the program should do and how.\n", + "Una de las razones por las que los programas leen y escriben archivos es para almacenar **datos de configuración**, que son información que especifica qué debe hacer el programa y cómo.\n", "\n", - "For example, in a program that searches for duplicate photos, we might have a dictionary called `config` that contains the name of the directory to search, the name of another directory where it should store the results, and a list of file extensions it should use to identify image files.\n", + "Por ejemplo, en un programa que busca fotos duplicadas, podríamos tener un diccionario llamado `config` que contiene el nombre del directorio donde buscar, el nombre de otro directorio donde debería almacenar los resultados y una lista de extensiones de archivo que debería usar para identificar archivos de imagen.\n", "\n", - "Here's what it might look like:" + "Así podría verse:" ] }, { @@ -561,11 +561,11 @@ "id": "1667bb96", "metadata": {}, "source": [ - "To write this data in a text file, we could use f-strings, as in the previous section. But it is easier to use a module called `yaml` that is designed for just this sort of thing.\n", + "Para escribir estos datos en un archivo de texto, podríamos usar f-strings, como en la sección anterior. Pero es más fácil usar un módulo llamado `yaml` que está diseñado justo para este tipo de cosas.\n", "\n", - "The `yaml` module provides functions to work with YAML files, which are text files formatted to be easy for humans *and* programs to read and write.\n", + "El módulo `yaml` proporciona funciones para trabajar con archivos YAML, que son archivos de texto con un formato pensado para que sean fáciles de leer y escribir tanto para humanos *como* para programas.\n", "\n", - "Here's an example that uses the `dump` function to write the `config` dictionary to a YAML file. " + "Aquí tienes un ejemplo que usa la función `dump` para escribir el diccionario `config` en un archivo YAML. " ] }, { @@ -605,7 +605,7 @@ "id": "92d1b7ff", "metadata": {}, "source": [ - "If we read back the contents of the file, we can see what the YAML format looks like." + "Si volvemos a leer el contenido del archivo, podemos ver cómo es el formato YAML." ] }, { @@ -624,7 +624,7 @@ "id": "33cdfd2c", "metadata": {}, "source": [ - "Now, we can use `safe_load` to read back the YAML file." + "Ahora podemos usar `safe_load` para volver a leer el archivo YAML." ] }, { @@ -644,7 +644,7 @@ "id": "ca55764f", "metadata": {}, "source": [ - "The result is new dictionary that contains the same information as the original, but it is not the same dictionary." + "El resultado es un nuevo diccionario que contiene la misma información que el original, pero no es el mismo diccionario." ] }, { @@ -662,9 +662,9 @@ "id": "969ad306", "metadata": {}, "source": [ - "Converting an object like a dictionary to a string is called **serialization**.\n", - "Converting the string back to an object is called **deserialization**.\n", - "If you serialize and then deserialize an object, the result should be equivalent to the original." + "Convertir un objeto como un diccionario en una string se llama **serialización**.\n", + "Convertir la string de vuelta en un objeto se llama **deserialización**.\n", + "Si serializas y luego deserializas un objeto, el resultado debería ser equivalente al original." ] }, { @@ -674,14 +674,14 @@ "source": [ "## Shelve\n", "\n", - "So far we've been reading and writing text files -- now let's consider databases.\n", - "A **database** is a file that is organized for storing data.\n", - "Some databases are organized like a table with rows and columns of information.\n", - "Others are organized like a dictionary that maps from keys to values; they are sometimes called **key-value stores**.\n", + "Hasta ahora hemos estado leyendo y escribiendo archivos de texto -- ahora consideremos las bases de datos.\n", + "Una **base de datos** es un archivo organizado para almacenar datos.\n", + "Algunas bases de datos se organizan como una tabla con filas y columnas de información.\n", + "Otras se organizan como un diccionario que mapea claves a valores; a veces se llaman **almacenes clave-valor**.\n", "\n", - "The `shelve` module provides functions for creating and updating a key-value store called a \"shelf\".\n", - "As an example, we'll create a shelf to contain captions for the figures in the `photos` directory.\n", - "We'll use the `config` dictionary to get the name of the directory where we should put the shelf." + "El módulo `shelve` proporciona funciones para crear y actualizar un almacén clave-valor llamado \"shelf\".\n", + "Como ejemplo, crearemos un shelf para contener captions de las figuras del directorio `photos`.\n", + "Usaremos el diccionario `config` para obtener el nombre del directorio donde deberíamos poner el shelf." ] }, { @@ -699,7 +699,7 @@ "id": "3e6cfb65", "metadata": {}, "source": [ - "We can use `os.makedirs` to create this directory, if it doesn't already exist." + "Podemos usar `os.makedirs` para crear este directorio, si todavía no existe." ] }, { @@ -717,7 +717,7 @@ "id": "6352f83f", "metadata": {}, "source": [ - "And `os.path.join` to make a path that includes the name of the directory and the name of the shelf file, `captions`." + "Y `os.path.join` para crear una ruta que incluya el nombre del directorio y el nombre del archivo del shelf, `captions`." ] }, { @@ -736,8 +736,8 @@ "id": "cbb08679", "metadata": {}, "source": [ - "Now we can use `shelve.open` to open the shelf file.\n", - "The argument `c` indicates that the file should be created if necessary." + "Ahora podemos usar `shelve.open` para abrir el archivo del shelf.\n", + "El argumento `c` indica que el archivo debería crearse si es necesario." ] }, { @@ -760,9 +760,9 @@ "tags": [] }, "source": [ - "If you get an error like `db type could not be determined`, the most likely cause is that a file with the same name already exists but is not a valid shelve database (for example, it may be corrupted or created by something else).\n", + "Si obtienes un error como `db type could not be determined`, la causa más probable es que ya exista un archivo con el mismo nombre, pero que no sea una base de datos shelve válida (por ejemplo, puede estar corrupto o haber sido creado por otra cosa).\n", "\n", - "In that case, the simplest solution is to delete the existing file and run the code again so that `shelve.open` can create a new database." + "En ese caso, la solución más sencilla es eliminar el archivo existente y volver a ejecutar el código para que `shelve.open` pueda crear una base de datos nueva." ] }, { @@ -770,10 +770,10 @@ "id": "0e4a2fb3", "metadata": {}, "source": [ - "The return value is officially a `DbfilenameShelf` object, more casually called a shelf object.\n", + "El valor de retorno es oficialmente un objeto `DbfilenameShelf`, llamado de manera más informal un objeto shelf.\n", "\n", - "The shelf object behaves in many ways like a dictionary.\n", - "For example, we can use the bracket operator to add an item, which is a mapping from a key to a value." + "El objeto shelf se comporta de muchas maneras como un diccionario.\n", + "Por ejemplo, podemos usar el operador de corchetes para añadir un elemento, que es un mapeo de una clave a un valor." ] }, { @@ -792,9 +792,9 @@ "id": "36fd5e3a", "metadata": {}, "source": [ - "In this example, the key is the path to an image file and the value is a string that describes the image.\n", + "En este ejemplo, la clave es la ruta a un archivo de imagen y el valor es una string que describe la imagen.\n", "\n", - "We also use the bracket operator to look up a key and get the corresponding value." + "También usamos el operador de corchetes para buscar una clave y obtener el valor correspondiente." ] }, { @@ -813,7 +813,7 @@ "id": "e9b252a7", "metadata": {}, "source": [ - "If you make another assignment to an existing key, `shelve` replaces the old value." + "Si haces otra asignación a una clave existente, `shelve` reemplaza el valor anterior." ] }, { @@ -832,7 +832,7 @@ "id": "003eacbc", "metadata": {}, "source": [ - "Some dictionary methods, like `keys`, `values` and `items`, also work with shelf objects." + "Algunos métodos de diccionario, como `keys`, `values` e `items`, también funcionan con objetos shelf." ] }, { @@ -860,7 +860,7 @@ "id": "056e0bd9", "metadata": {}, "source": [ - "We can use the `in` operator to check whether a key appears in the shelf." + "Podemos usar el operador `in` para comprobar si una clave aparece en el shelf." ] }, { @@ -878,7 +878,7 @@ "id": "982740b4", "metadata": {}, "source": [ - "And we can use a `for` statement to loop through the keys." + "Y podemos usar una sentencia `for` para iterar sobre las claves." ] }, { @@ -897,7 +897,7 @@ "id": "b67a0ddc", "metadata": {}, "source": [ - "As with other files, you should close the database when you are done." + "Como con otros archivos, deberías cerrar la base de datos cuando termines." ] }, { @@ -915,7 +915,7 @@ "id": "a1e08b41", "metadata": {}, "source": [ - "Now if we list the contents of the data directory, we see two files." + "Ahora, si listamos el contenido del directorio de datos, vemos dos archivos." ] }, { @@ -949,9 +949,9 @@ "id": "97453006", "metadata": {}, "source": [ - "`captions.dat` contains the data we just stored.\n", - "`captions.dir` contains information about the organization of the database that makes it more efficient to access.\n", - "The suffix `dir` stands for \"directory\", but it has nothing to do with the directories we've been working with that contain files." + "`captions.dat` contiene los datos que acabamos de almacenar.\n", + "`captions.dir` contiene información sobre la organización de la base de datos que hace que el acceso sea más eficiente.\n", + "El sufijo `dir` significa \"directorio\", pero no tiene nada que ver con los directorios con los que hemos estado trabajando y que contienen archivos." ] }, { @@ -961,17 +961,17 @@ "tags": [] }, "source": [ - "## Storing data structures\n", + "## Almacenar estructuras de datos\n", "\n", - "In the previous example, the keys and values in the shelf are strings.\n", - "But we can also use a shelf to contain data structures like lists and dictionaries.\n", + "En el ejemplo anterior, las claves y valores del shelf son strings.\n", + "Pero también podemos usar un shelf para contener estructuras de datos como listas y diccionarios.\n", "\n", - "As an example, let's revisit the anagram example from an exercise in [Chapter 11](section_exercise_11).\n", - "Recall that we made a dictionary that maps from a sorted string of letters to the\n", - "list of words that can be spelled with those letters.\n", - "For example, the key `'opst'` maps to the list `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", + "Como ejemplo, volvamos al ejemplo de anagramas de un ejercicio en el [Capítulo 11](section_exercise_11).\n", + "Recuerda que hicimos un diccionario que mapea una string ordenada de letras a la\n", + "lista de palabras que se pueden formar con esas letras.\n", + "Por ejemplo, la clave `'opst'` mapea a la lista `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", "\n", - "We'll use the following function to sort the letters in a word." + "Usaremos la siguiente función para ordenar las letras de una palabra." ] }, { @@ -990,7 +990,7 @@ "id": "8c24316c", "metadata": {}, "source": [ - "And here's an example." + "Y aquí tienes un ejemplo." ] }, { @@ -1010,8 +1010,8 @@ "id": "7c5d7555", "metadata": {}, "source": [ - "Now let's open a shelf called `anagram_map`.\n", - "The argument `'n'` means we should always create a new, empty shelf, even if one already exists." + "Ahora abramos un shelf llamado `anagram_map`.\n", + "El argumento `'n'` significa que siempre deberíamos crear un shelf nuevo y vacío, aunque ya exista uno." ] }, { @@ -1029,7 +1029,7 @@ "id": "6b495e79", "metadata": {}, "source": [ - "Now we can add an item to the shelf like this." + "Ahora podemos añadir un elemento al shelf así." ] }, { @@ -1048,9 +1048,9 @@ "id": "f058dff1", "metadata": {}, "source": [ - "In this item, the key is a string and the value is a list of strings.\n", + "En este elemento, la clave es una string y el valor es una lista de strings.\n", "\n", - "Now suppose we find another word that contains the same letters, like `tops`" + "Ahora supón que encontramos otra palabra que contiene las mismas letras, como `tops`" ] }, { @@ -1070,8 +1070,8 @@ "id": "a215367d", "metadata": {}, "source": [ - "The key is the same as in the previous example, so we want to append a second word to the same list of strings.\n", - "Here's how we would do it if `db` were a dictionary." + "La clave es la misma que en el ejemplo anterior, así que queremos añadir una segunda palabra a la misma lista de strings.\n", + "Así es como lo haríamos si `db` fuera un diccionario." ] }, { @@ -1089,7 +1089,7 @@ "id": "e1a83f39", "metadata": {}, "source": [ - "But if we run that and then look up the key in the shelf, it looks like it has not been updated." + "Pero si lo ejecutamos y luego buscamos la clave en el shelf, parece que no se ha actualizado." ] }, { @@ -1107,8 +1107,8 @@ "id": "32a56de9", "metadata": {}, "source": [ - "Here's the problem: when we look up the key, we get a list of strings, but if we modify the list of strings, it does not affect the shelf.\n", - "If we want to update the shelf, we have to read the old value, update it, and then write the new value back to the shelf." + "Este es el problema: cuando buscamos la clave, obtenemos una lista de strings, pero si modificamos la lista de strings, eso no afecta al shelf.\n", + "Si queremos actualizar el shelf, tenemos que leer el valor antiguo, actualizarlo y luego escribir el nuevo valor de vuelta en el shelf." ] }, { @@ -1128,7 +1128,7 @@ "id": "a054f537", "metadata": {}, "source": [ - "Now the value in the shelf is updated." + "Ahora el valor del shelf está actualizado." ] }, { @@ -1146,7 +1146,7 @@ "id": "ca02c0d7", "metadata": {}, "source": [ - "As an exercise, you can finish this example by reading the word list and storing all of the anagrams in a shelf." + "Como ejercicio, puedes terminar este ejemplo leyendo la lista de palabras y almacenando todos los anagramas en un shelf." ] }, { @@ -1168,15 +1168,15 @@ "tags": [] }, "source": [ - "## Checking for equivalent files\n", + "## Comprobar archivos equivalentes\n", "\n", - "Now let's get back to the goal of this chapter: searching for different files that contain the same data.\n", - "One way to check is to read the contents of both files and compare.\n", + "Ahora volvamos al objetivo de este capítulo: buscar archivos diferentes que contienen los mismos datos.\n", + "Una forma de comprobarlo es leer el contenido de ambos archivos y compararlo.\n", "\n", - "If the files contain images, we have to open them with mode `'rb'`, where `'r'` means we want to read the contents and `'b'` indicates **binary mode**.\n", - "In binary mode, the contents are not interpreted as text -- they are treated as a sequence of bytes.\n", + "Si los archivos contienen imágenes, tenemos que abrirlos con el modo `'rb'`, donde `'r'` significa que queremos leer el contenido y `'b'` indica **modo binario**.\n", + "En modo binario, el contenido no se interpreta como texto -- se trata como una secuencia de bytes.\n", "\n", - "Here's an example that opens and reads an image file." + "Aquí tienes un ejemplo que abre y lee un archivo de imagen." ] }, { @@ -1196,10 +1196,10 @@ "id": "36687da2", "metadata": {}, "source": [ - "The result from `read` is a `bytes` object -- as the name suggests, it contains a sequence of bytes.\n", + "El resultado de `read` es un objeto `bytes` -- como sugiere el nombre, contiene una secuencia de bytes.\n", "\n", - "In general the contents of an image file and not human-readable.\n", - "But if we read the contents from a second file, we can use the `==` operator to compare." + "En general, el contenido de un archivo de imagen no es legible para humanos.\n", + "Pero si leemos el contenido de un segundo archivo, podemos usar el operador `==` para comparar." ] }, { @@ -1219,9 +1219,9 @@ "id": "36006cd4", "metadata": {}, "source": [ - "These two files are not equivalent.\n", + "Estos dos archivos no son equivalentes.\n", "\n", - "Let's encapsulate what we have so far in a function." + "Encapsulemos lo que tenemos hasta ahora en una función." ] }, { @@ -1242,16 +1242,16 @@ "id": "b4e08850", "metadata": {}, "source": [ - "If we have only two files, this function is a good option.\n", - "But suppose we have a large number of files and we want to know whether any two of them contain the same data.\n", - "It would be inefficient to compare every pair of files.\n", + "Si solo tenemos dos archivos, esta función es una buena opción.\n", + "Pero supón que tenemos un gran número de archivos y queremos saber si dos cualesquiera contienen los mismos datos.\n", + "Sería ineficiente comparar cada par de archivos.\n", "\n", - "An alternative is to use a **hash function**, which takes the contents of a file and computes a **digest**, which is usually a large integer.\n", - "If two files contain the same data, they will have the same digest.\n", - "If two files differ, they will *almost always* have different digests.\n", + "Una alternativa es usar una **función hash**, que toma el contenido de un archivo y calcula un **digest**, que normalmente es un entero grande.\n", + "Si dos archivos contienen los mismos datos, tendrán el mismo digest.\n", + "Si dos archivos son diferentes, *casi siempre* tendrán digests diferentes.\n", "\n", - "The `hashlib` module provides several hash functions -- the one we'll use is called `md5`.\n", - "We'll start by using `hashlib.md5` to create a `HASH` object." + "El módulo `hashlib` proporciona varias hash funciones -- la que usaremos se llama `md5`.\n", + "Empezaremos usando `hashlib.md5` para crear un objeto `HASH`." ] }, { @@ -1272,7 +1272,7 @@ "id": "a8e480f0", "metadata": {}, "source": [ - "The `HASH` object provides an `update` method that takes the contents of the file as an argument." + "El objeto `HASH` proporciona un método `update` que toma el contenido del archivo como argumento." ] }, { @@ -1290,7 +1290,7 @@ "id": "86bd6bc0", "metadata": {}, "source": [ - "Now we can use `hexdigest` to get the digest as a string of hexadecimal digits that represent an integer in base 16." + "Ahora podemos usar `hexdigest` para obtener el digest como una string de dígitos hexadecimales que representan un entero en base 16." ] }, { @@ -1309,7 +1309,7 @@ "id": "b9b4b347", "metadata": {}, "source": [ - "The following function encapsulates these steps." + "La siguiente función encapsula estos pasos." ] }, { @@ -1332,7 +1332,7 @@ "id": "914b85b2", "metadata": {}, "source": [ - "If we hash the contents of a different file, we can confirm that we get a different digest." + "Si hacemos hash del contenido de un archivo diferente, podemos confirmar que obtenemos un digest distinto." ] }, { @@ -1351,8 +1351,8 @@ "id": "deeabdde", "metadata": {}, "source": [ - "Now we have almost everything we need to find equivalent files.\n", - "The last step is to search a directory and find all of the images files." + "Ahora tenemos casi todo lo que necesitamos para encontrar archivos equivalentes.\n", + "El último paso es buscar en un directorio y encontrar todos los archivos de imagen." ] }, { @@ -1362,12 +1362,12 @@ "tags": [] }, "source": [ - "## Walking directories\n", + "## Recorrer directorios\n", "\n", - "The following function takes as an argument the directory we want to search.\n", - "It uses `listdir` to loop through the contents of the directory.\n", - "When it finds a file, it prints its complete path.\n", - "When it finds a directory, it calls itself recursively to search the subdirectory." + "La siguiente función toma como argumento el directorio donde queremos buscar.\n", + "Usa `listdir` para iterar sobre el contenido del directorio.\n", + "Cuando encuentra un archivo, imprime su ruta completa.\n", + "Cuando encuentra un directorio, se llama a sí misma recursivamente para buscar en el subdirectorio." ] }, { @@ -1392,7 +1392,7 @@ "id": "faaf5b25", "metadata": {}, "source": [ - "We can use it like this:" + "Podemos usarla así:" ] }, { @@ -1410,7 +1410,7 @@ "id": "897c66bf", "metadata": {}, "source": [ - "The order of the results depends on details of the operating system." + "El orden de los resultados depende de detalles del sistema operativo." ] }, { @@ -1418,12 +1418,12 @@ "id": "c7853f18", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "When you are reading and writing files, you might run into problems with whitespace.\n", - "These errors can be hard to debug because whitespace characters are normally invisible.\n", - "For example, here's a string that contains spaces, a tab represented by the sequence `\\t`, and a newline represented by the sequence `\\n`.\n", - "When we print it, we don't see the whitespace characters." + "Cuando lees y escribes archivos, puedes encontrarte con problemas relacionados con espacios en blanco.\n", + "Estos errores pueden ser difíciles de depurar porque los caracteres de espacio en blanco normalmente son invisibles.\n", + "Por ejemplo, aquí tienes una string que contiene espacios, un tab representado por la secuencia `\\t` y una nueva línea representada por la secuencia `\\n`.\n", + "Cuando la imprimimos, no vemos los caracteres de espacio en blanco." ] }, { @@ -1442,8 +1442,8 @@ "id": "49bbebe6", "metadata": {}, "source": [ - "The built-in function `repr` can help. It takes any object as an argument and returns a string representation of the object.\n", - "For strings, it represents whitespace characters with backslash sequences." + "La función integrada `repr` puede ayudar. Toma cualquier objeto como argumento y devuelve una representación en string del objeto.\n", + "Para strings, representa los caracteres de espacio en blanco con secuencias de barra invertida." ] }, { @@ -1461,15 +1461,15 @@ "id": "790cf8dd", "metadata": {}, "source": [ - "This can be helpful for debugging.\n", + "Esto puede ser útil para depurar.\n", "\n", - "One other problem you might run into is that different systems use different characters to indicate the end of a line. Some systems use a newline, represented `\\n`. Others use a return character, represented `\\r`. \n", - "Some use both. If you move files between different systems, these\n", - "inconsistencies can cause problems.\n", + "Otro problema que puedes encontrar es que distintos sistemas usan distintos caracteres para indicar el final de una línea. Algunos sistemas usan una nueva línea, representada como `\\n`. Otros usan un carácter de retorno, representado como `\\r`. \n", + "Algunos usan ambos. Si mueves archivos entre sistemas diferentes, estas\n", + "inconsistencias pueden causar problemas.\n", "\n", - "File name capitalization is another issue you might encounter if you work with different operating systems.\n", - "In macOS and UNIX, file names can contain lowercase and uppercase letters, digits, and most symbols.\n", - "But many Windows applications ignore the difference between lowercase and uppercase letters, and several symbols that are allowed in macOS and UNIX are not allowed in Windows." + "La capitalización de los nombres de archivo es otro problema que puedes encontrar si trabajas con distintos sistemas operativos.\n", + "En macOS y UNIX, los nombres de archivo pueden contener letras minúsculas y mayúsculas, dígitos y la mayoría de símbolos.\n", + "Pero muchas aplicaciones de Windows ignoran la diferencia entre letras minúsculas y mayúsculas, y varios símbolos que se permiten en macOS y UNIX no se permiten en Windows." ] }, { @@ -1477,55 +1477,55 @@ "id": "cf063639", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**ephemeral:**\n", - "An ephemeral program typically runs for a short time and, when it ends, its data are lost.\n", + "**efímero:**\n", + "Un programa efímero normalmente se ejecuta durante poco tiempo y, cuando termina, sus datos se pierden.\n", "\n", - "**persistent:**\n", - " A persistent program runs indefinitely and keeps at least some of its data in permanent storage.\n", + "**persistente:**\n", + " Un programa persistente se ejecuta indefinidamente y mantiene al menos parte de sus datos en almacenamiento permanente.\n", "\n", - "**directory:**\n", - "A collection of files and other directories.\n", + "**directorio:**\n", + "Una colección de archivos y otros directorios.\n", "\n", - "**current working directory:**\n", - "The default directory used by a program unless another directory is specified.\n", + "**directorio de trabajo actual:**\n", + "El directorio por defecto usado por un programa a menos que se especifique otro directorio.\n", "\n", - "**path:**\n", - " A string that specifies a sequence of directories, often leading to a file.\n", + "**ruta:**\n", + " Una string que especifica una secuencia de directorios, que a menudo conduce a un archivo.\n", "\n", - "**relative path:**\n", - "A path that starts from the current working directory, or some other specified directory.\n", + "**ruta relativa:**\n", + "Un ruta que empieza desde el directorio de trabajo actual, o desde algún otro directorio especificado.\n", "\n", - "**absolute path:**\n", - "A path that does not depend on the current directory.\n", + "**ruta absoluta:**\n", + "Un ruta que no depende del directorio actual.\n", "\n", "**f-string:**\n", - "A string that has the letter `f` before the opening quotation mark, and contains one or more expressions in curly braces.\n", + "Una string que tiene la letra `f` antes de la comilla de apertura y contiene una o más expresiones entre llaves.\n", "\n", - "**configuration data:**\n", - "Data, often stored in a file, that specifies what a program should do and how.\n", + "**datos de configuración:**\n", + "Datos, a menudo almacenados en un archivo, que especifican qué debe hacer un programa y cómo.\n", "\n", - "**serialization:**\n", - "Converting an object to a string.\n", + "**serialización:**\n", + "Convertir un objeto en una string.\n", "\n", - "**deserialization:**\n", - "Converting a string to an object.\n", + "**deserialización:**\n", + "Convertir una string en un objeto.\n", "\n", - "**database:**\n", - " A file whose contents are organized to perform certain operations efficiently.\n", + "**base de datos:**\n", + " Un archivo cuyo contenido está organizado para realizar ciertas operaciones de manera eficiente.\n", "\n", - "**key-value stores:**\n", - "A database whose contents are organized like a dictionary with keys that correspond to values.\n", + "**almacenes clave-valor:**\n", + "Una base de datos cuyo contenido está organizado como un diccionario con claves que corresponden a valores.\n", "\n", - "**binary mode:**\n", - "A way of opening a file so the contents are interpreted as sequence of bytes rather than a sequence of characters.\n", + "**modo binario:**\n", + "Una forma de abrir un archivo para que el contenido se interprete como una secuencia de bytes en lugar de como una secuencia de caracteres.\n", "\n", - "**hash function:**\n", - "A function that takes and object and computes an integer, which is sometimes called a digest.\n", + "**función hash:**\n", + "Una función que toma un objeto y calcula un entero, que a veces se llama digest.\n", "\n", "**digest:**\n", - "The result of a hash function, especially when it is used to check whether two objects are the same." + "El resultado de una función hash, especialmente cuando se usa para comprobar si dos objetos son iguales." ] }, { @@ -1533,7 +1533,7 @@ "id": "67941fdd", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1556,32 +1556,32 @@ "id": "9a537173", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are several topics that came up in this chapter that I did not explain in detail.\n", - "Here are some questions you can ask a virtual assistant to get more information. \n", + "Hay varios temas que surgieron en este capítulo que no expliqué en detalle.\n", + "Aquí tienes algunas preguntas que puedes hacerle a un asistente virtual para obtener más información. \n", "\n", - "* \"What are the differences between ephemeral and persistent programs?\"\n", + "* \"¿Cuáles son las diferencias entre programas efímeros y persistentes?\"\n", "\n", - "* \"What are some examples of persistent programs?\"\n", + "* \"¿Cuáles son algunos ejemplos de programas persistentes?\"\n", "\n", - "* \"What's the difference between a relative path and an absolute path?\"\n", + "* \"¿Cuál es la diferencia entre una ruta relativa y una ruta absoluta?\"\n", "\n", - "* \"Why does the `yaml` module have functions called `load` and `safe_load`?\"\n", + "* \"¿Por qué el módulo `yaml` tiene funciones llamadas `load` y `safe_load`?\"\n", "\n", - "* \"When I write a Python shelf, what are the files with suffixes `dat` and `dir`?\"\n", + "* \"Cuando escribo un shelf de Python, ¿qué son los archivos con sufijos `dat` y `dir`?\"\n", "\n", - "* \"Other than key-values stores, what other kinds of databases are there?\"\n", + "* \"Además de los almacenes clave-valor, ¿qué otros tipos de bases de datos existen?\"\n", "\n", - "* \"When I read a file, what's the difference between binary mode and text mode?\"\n", + "* \"Cuando leo un archivo, ¿cuál es la diferencia entre modo binario y modo texto?\"\n", "\n", - "* \"What are the differences between a bytes object and a string?\"\n", + "* \"¿Cuáles son las diferencias entre un objeto bytes y una string?\"\n", "\n", - "* \"What is a hash function?\"\n", + "* \"¿Qué es una función hash?\"\n", "\n", - "* \"What is an MD5 digest?\"\n", + "* \"¿Qué es un digest MD5?\"\n", "\n", - "As always, if you get stuck on any of the following exercises, consider asking a VA for help. Along with your question, you might want to paste in the relevant functions from this chapter." + "Como siempre, si te quedas atascado en alguno de los ejercicios siguientes, considera pedir ayuda a un AV. Junto con tu pregunta, quizá quieras pegar las funciones relevantes de este capítulo." ] }, { @@ -1589,11 +1589,11 @@ "id": "7586e1e9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `replace_all` that takes as arguments a pattern string, a replacement string, and two filenames.\n", - "It should read the first file and write the contents into the second file (creating it if necessary).\n", - "If the pattern string appears anywhere in the contents, it should be replaced with the replacement string." + "Escribe una función llamada `replace_all` que tome como argumentos una string patrón, una string de reemplazo y dos nombres de archivo.\n", + "Debería leer el primer archivo y escribir el contenido en el segundo archivo (creándolo si es necesario).\n", + "Si la string patrón aparece en cualquier parte del contenido, debería reemplazarse por la string de reemplazo." ] }, { @@ -1601,7 +1601,7 @@ "id": "85844afb", "metadata": {}, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1636,7 +1636,7 @@ "id": "7f37245c", "metadata": {}, "source": [ - "To test your function, read the file `photos/notes.txt`, replace `'photos'` with `'images'`, and write the result to the file `photos/new_notes.txt`." + "Para probar tu función, lee el archivo `photos/notes.txt`, reemplaza `'photos'` por `'images'` y escribe el resultado en el archivo `photos/new_notes.txt`." ] }, { @@ -1684,12 +1684,12 @@ "id": "7b2589a4", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In [a previous section](section_storing_data_structure), we used the `shelve` module to make a key-value store that maps from a sorted string of letters to a list of anagrams.\n", - "To finish the example, write a function called `add_word` that takes as arguments a string and a shelf object.\n", + "En [una sección anterior](section_storing_data_structure), usamos el módulo `shelve` para crear un almacén clave-valor que mapea una string ordenada de letras a una lista de anagramas.\n", + "Para terminar el ejemplo, escribe una función llamada `add_word` que tome como argumentos una string y un objeto shelf.\n", "\n", - "It should sort the letters of the word to make a key, then check whether the key is already in the shelf. If not, it should make a list that contains the new word and add it to the shelf. If so, it should append the new word to the existing value. " + "Debería ordenar las letras de la palabra para crear una clave, y luego comprobar si la clave ya está en el shelf. Si no, debería crear una lista que contenga la nueva palabra y añadirla al shelf. Si sí, debería añadir la nueva palabra al valor existente. " ] }, { @@ -1709,7 +1709,7 @@ "tags": [] }, "source": [ - "You can use this loop to test your function." + "Puedes usar este bucle para probar tu función." ] }, { @@ -1747,7 +1747,7 @@ "tags": [] }, "source": [ - "If everything is working, you should be able to look up a key like `'opst'` and get a list of words that can be spelled with those letters." + "Si todo funciona, deberías poder buscar una clave como `'opst'` y obtener una lista de palabras que se pueden formar con esas letras." ] }, { @@ -1793,23 +1793,23 @@ "id": "228e977c", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In a large collection of files, there may be more than one copy of the same file, stored in different directories or with different file names.\n", - "The goal of this exercise is to search for duplicates.\n", - "As an example, we'll work with image files in the `photos` directory.\n", + "En una colección grande de archivos, puede haber más de una copia del mismo archivo, almacenada en distintos directorios o con distintos nombres de archivo.\n", + "El objetivo de este ejercicio es buscar duplicados.\n", + "Como ejemplo, trabajaremos con archivos de imagen en el directorio `photos`.\n", "\n", - "Here's how it will work:\n", + "Así es como funcionará:\n", "\n", - "* We'll use the `walk` function from [](section_walking_directories) to search this directory for files that end with one of the extensions in `config['extensions']`.\n", + "* Usaremos la función `walk` de [](section_walking_directories) para buscar en este directorio archivos que terminen con una de las extensiones en `config['extensions']`.\n", "\n", - "* For each file, we'll use `md5_digest` from [](section_md5_digest) to compute a digest of the contents.\n", + "* Para cada archivo, usaremos `md5_digest` de [](section_md5_digest) para calcular un digest del contenido.\n", "\n", - "* Using a shelf, we'll make a mapping from each digest to a list of paths with that digest.\n", + "* Usando un shelf, haremos un mapeo de cada digest a una lista de rutas con ese digest.\n", "\n", - "* Finally, we'll search the shelf for any digests that map to multiple files.\n", + "* Finalmente, buscaremos en el shelf cualquier digest que mapee a múltiples archivos.\n", "\n", - "* If we find any, we'll use `same_contents` to confirm that the files contain the same data." + "* Si encontramos alguno, usaremos `same_contents` para confirmar que los archivos contienen los mismos datos." ] }, { @@ -1817,9 +1817,9 @@ "id": "8f5365da", "metadata": {}, "source": [ - "I'll suggest some functions to write first, then we'll bring it all together.\n", + "Voy a sugerir algunas funciones para escribir primero, y luego lo juntaremos todo.\n", "\n", - "1. To identify image files, write a function called `is_image` that takes a path and a list of file extensions, and returns `True` if the path ends with one of the extensions in the list. Hint: Use `os.path.splitext` -- or ask a virtual assistant to write this function for you." + "1. Para identificar archivos de imagen, escribe una función llamada `is_image` que tome una ruta y una lista de extensiones de archivo, y devuelva `True` si la ruta termina con una de las extensiones de la lista. Pista: usa `os.path.splitext` -- o pide a un asistente virtual que escriba esta función por ti." ] }, { @@ -1839,7 +1839,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1864,7 +1864,7 @@ "id": "1a7c8f49", "metadata": {}, "source": [ - "2. Write a function called `add_path` that takes as arguments a path and a shelf. It should use `md5_digest` to compute a digest of the file contents. Then it should update the shelf, either creating a new item that maps from the digest to a list containing the path, or appending the path to the list if it exists." + "2. Escribe una función llamada `add_path` que tome como argumentos una ruta y un shelf. Debería usar `md5_digest` para calcular un digest del contenido del archivo. Luego debería actualizar el shelf, ya sea creando un nuevo elemento que mapee el digest a una lista que contenga la ruta, o añadiendo la ruta a la lista si ya existe." ] }, { @@ -1882,7 +1882,7 @@ "id": "08223a21", "metadata": {}, "source": [ - "3. Write a version of `walk` called `walk_images` that takes a directory and walks through the files in the directory and its subdirectories. For each file, it should use `is_image` to check whether it's an image file and `add_path` to add it to the shelf." + "3. Escribe una versión de `walk` llamada `walk_images` que tome un directorio y recorra los archivos del directorio y sus subdirectorios. Para cada archivo, debería usar `is_image` para comprobar si es un archivo de imagen y `add_path` para añadirlo al shelf." ] }, { @@ -1900,7 +1900,7 @@ "id": "1ea76a52", "metadata": {}, "source": [ - "When everything is working, you can use the following program to create the shelf, search the `photos` directory and add paths to the shelf, and then check whether there are multiple files with the same digest." + "Cuando todo funcione, puedes usar el siguiente programa para crear el shelf, buscar en el directorio `photos` y añadir rutas al shelf, y luego comprobar si hay múltiples archivos con el mismo digest." ] }, { @@ -1925,8 +1925,8 @@ "id": "102d4d10", "metadata": {}, "source": [ - "You should find one pair of files that have the same digest.\n", - "Use `same_contents` to check whether they contain the same data." + "Deberías encontrar un par de archivos que tienen el mismo digest.\n", + "Usa `same_contents` para comprobar si contienen los mismos datos." ] }, { @@ -1958,9 +1958,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/chapters/chap14.ipynb b/chapters/chap14.ipynb index f0f9998..035d8ca 100644 --- a/chapters/chap14.ipynb +++ b/chapters/chap14.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,14 +41,14 @@ "id": "e826e661", "metadata": {}, "source": [ - "# Classes and Functions\n", + "# Clases y funciones\n", "\n", - "At this point you know how to use functions to organize code and how to use built-in types to organize data.\n", - "The next step is **object-oriented programming**, which uses programmer-defined types to organize both code and data.\n", + "A estas alturas sabes cómo usar funciones para organizar código y cómo usar tipos integrados para organizar datos.\n", + "El siguiente paso es la **programación orientada a objetos**, que usa tipos definidos por el programador para organizar tanto código como datos.\n", "\n", - "Object-oriented programming is a big topic, so we will proceed gradually.\n", - "In this chapter, we'll start with code that is not idiomatic -- that is, it is not the kind of code experienced programmers write -- but it is a good place to start.\n", - "In the next two chapters, we will use additional features to write more idiomatic code." + "La programación orientada a objetos es un tema amplio, así que avanzaremos gradualmente.\n", + "En este capítulo, empezaremos con código que no es idiomático -- es decir, no es el tipo de código que escriben los programadores con experiencia -- pero es un buen punto de partida.\n", + "En los dos capítulos siguientes, usaremos características adicionales para escribir código más idiomático." ] }, { @@ -56,12 +56,12 @@ "id": "6b414d4a", "metadata": {}, "source": [ - "## Programmer-defined types\n", + "## Tipos definidos por el programador\n", "\n", - "We have used many of Python's built-in types -- now we will define a new type.\n", - "As a first example, we'll create a type called `Time` that represents a time of day.\n", - "A programmer-defined type is also called a **class**.\n", - "A class definition looks like this:" + "Hemos usado muchos de los tipos integrados de Python -- ahora definiremos un tipo nuevo.\n", + "Como primer ejemplo, crearemos un tipo llamado `Time` que representa una hora del día.\n", + "Un tipo definido por el programador también se llama **clase**.\n", + "Una definición de clase se ve así:" ] }, { @@ -80,12 +80,12 @@ "id": "e2414cd2", "metadata": {}, "source": [ - "The header indicates that the new class is called `Time`.\n", - "The body is a docstring that explains what the class is for.\n", - "Defining a class creates a **class object**.\n", + "La cabecera indica que la nueva clase se llama `Time`.\n", + "El cuerpo es un docstring que explica para qué sirve la clase.\n", + "Definir una clase crea un **objeto de clase**.\n", "\n", - "The class object is like a factory for creating objects.\n", - "To create a `Time` object, you call `Time` as if it were a function." + "El objeto de clase es como una fábrica para crear objetos.\n", + "Para crear un objeto `Time`, llamas a `Time` como si fuera una función." ] }, { @@ -103,7 +103,7 @@ "id": "f63247d4", "metadata": {}, "source": [ - "The result is a new object whose type is `__main__.Time`, where `__main__` is the name of the module where `Time` is defined." + "El resultado es un objeto nuevo cuyo tipo es `__main__.Time`, donde `__main__` es el nombre del módulo donde se define `Time`." ] }, { @@ -121,7 +121,7 @@ "id": "14d0c96a", "metadata": {}, "source": [ - "When you print an object, Python tells you what type it is and where it is stored in memory (the prefix `0x` means that the following number is in hexadecimal)." + "Cuando imprimes un objeto, Python te dice de qué tipo es y dónde está almacenado en memoria (el prefijo `0x` significa que el número siguiente está en hexadecimal)." ] }, { @@ -139,7 +139,7 @@ "id": "b6445414", "metadata": {}, "source": [ - "Creating a new object is called **instantiation**, and the object is an **instance** of the class." + "Crear un objeto nuevo se llama **instanciación**, y el objeto es una **instancia** de la clase." ] }, { @@ -147,10 +147,10 @@ "id": "4c3768ec", "metadata": {}, "source": [ - "## Attributes\n", + "## Atributos\n", "\n", - "An object can contain variables, which are called **attributes** and pronounced with the emphasis on the first syllable, like \"AT-trib-ute\", rather than the second syllable, like \"a-TRIB-ute\".\n", - "We can create attributes using dot notation." + "Un objeto puede contener variables, que se llaman **atributos**.\n", + "Podemos crear atributos usando notación de punto." ] }, { @@ -170,9 +170,9 @@ "id": "b3fd8858", "metadata": {}, "source": [ - "This example creates attributes called `hour`, `minute`, and `second`, which contain the hours, minutes, and seconds of the time `11:59:01`, which is lunch time as far as I am concerned.\n", + "Este ejemplo crea atributos llamados `hour`, `minute` y `second`, que contienen las horas, minutos y segundos de la hora `11:59:01`, que es la hora de comer por lo que a mí respecta.\n", "\n", - "The following diagram shows the state of `lunch` and its attributes after these assignments. " + "El siguiente diagrama muestra el estado de `lunch` y sus atributos después de estas asignaciones. " ] }, { @@ -213,11 +213,11 @@ "id": "d9df5b48", "metadata": {}, "source": [ - "The variable `lunch` refers to a `Time` object, which contains three attributes. \n", - "Each attribute refers to an integer.\n", - "A state diagram like this -- which shows an object and its attributes -- is called an **object diagram**.\n", + "La variable `lunch` se refiere a un objeto `Time`, que contiene tres atributos. \n", + "Cada atributo se refiere a un entero.\n", + "Un diagrama de estado como este -- que muestra un objeto y sus atributos -- se llama **diagrama de objeto**.\n", "\n", - "You can read the value of an attribute using the dot operator." + "Puedes leer el valor de un atributo usando el operador de punto." ] }, { @@ -235,7 +235,7 @@ "id": "5ccfaea0", "metadata": {}, "source": [ - "You can use an attribute as part of any expression." + "Puedes usar un atributo como parte de cualquier expresión." ] }, { @@ -254,7 +254,7 @@ "id": "c5e6725b", "metadata": {}, "source": [ - "And you can use the dot operator in an expression in an f-string." + "Y puedes usar el operador de punto en una expresión dentro de una f-string." ] }, { @@ -272,10 +272,10 @@ "id": "e70671d2", "metadata": {}, "source": [ - "But notice that the previous example is not in the standard format.\n", - "To fix it, we have to print the `minute` and `second` attributes with a leading zero.\n", - "We can do that by extending the expressions in curly braces with a **format specifier**.\n", - "In the following example, the format specifiers indicate that `minute` and `second` should be displayed with at least two digits and a leading zero if needed." + "Pero observa que el ejemplo anterior no está en el formato estándar.\n", + "Para arreglarlo, tenemos que imprimir los atributos `minute` y `second` con un cero inicial.\n", + "Podemos hacerlo extendiendo las expresiones entre llaves con un **especificador de formato**.\n", + "En el siguiente ejemplo, los especificadores de formato indican que `minute` y `second` deberían mostrarse con al menos dos dígitos y un cero inicial si hace falta." ] }, { @@ -293,9 +293,9 @@ "id": "bcbea13a", "metadata": {}, "source": [ - "We'll use this f-string to write a function that displays the value of a `Time`object.\n", - "You can pass an object as an argument in the usual way.\n", - "For example, the following function takes a `Time` object as an argument. " + "Usaremos esta f-string para escribir una función que muestra el valor de un objeto `Time`.\n", + "Puedes pasar un objeto como argumento de la forma habitual.\n", + "Por ejemplo, la siguiente función toma un objeto `Time` como argumento. " ] }, { @@ -315,7 +315,7 @@ "id": "3b8ccbed", "metadata": {}, "source": [ - "When we call it, we can pass `lunch` as an argument." + "Cuando la llamamos, podemos pasar `lunch` como argumento." ] }, { @@ -333,9 +333,9 @@ "id": "18826e53", "metadata": {}, "source": [ - "## Objects as return values\n", + "## Objetos como valores de retorno\n", "\n", - "Functions can return objects. For example, `make_time` takes parameters called `hour`, `minute`, and `second`, stores them as attributes in a `Time` object, and returns the new object." + "Las funciones pueden devolver objetos. Por ejemplo, `make_time` toma parámetros llamados `hour`, `minute` y `second`, los almacena como atributos en un objeto `Time` y devuelve el objeto nuevo." ] }, { @@ -358,8 +358,8 @@ "id": "d8a6acca", "metadata": {}, "source": [ - "It might be surprising that the parameters have the same names as the attributes, but that's a common way to write a function like this.\n", - "Here's how we use `make_time` to create a `Time` object." + "Puede sorprender que los parámetros tengan los mismos nombres que los atributos, pero esa es una forma habitual de escribir una función como esta.\n", + "Así usamos `make_time` para crear un objeto `Time`." ] }, { @@ -378,12 +378,12 @@ "id": "05720bcb", "metadata": {}, "source": [ - "## Objects are mutable\n", + "## Los objetos son mutables\n", "\n", - "Suppose you are going to a screening of a movie, like *Monty Python and the Holy Grail*, which starts at `9:20 PM` and runs for `92` minutes, which is one hour `32` minutes.\n", - "What time will the movie end?\n", + "Supón que vas a una proyección de una película, como *Monty Python and the Holy Grail*, que empieza a las `9:20 PM` y dura `92` minutos, que es una hora y `32` minutos.\n", + "¿A qué hora terminará la película?\n", "\n", - "First, we'll create a `Time` object that represents the start time." + "Primero, crearemos un objeto `Time` que representa la hora de inicio." ] }, { @@ -402,7 +402,7 @@ "id": "001bcda9", "metadata": {}, "source": [ - "To find the end time, we can modify the attributes of the `Time` object, adding the duration of the movie." + "Para encontrar la hora de fin, podemos modificar los atributos del objeto `Time`, añadiendo la duración de la película." ] }, { @@ -422,9 +422,9 @@ "id": "7007ab61", "metadata": {}, "source": [ - "The movie will be over at 10:52 PM.\n", + "La película terminará a las 10:52 PM.\n", "\n", - "Let's encapsulate this computation in a function and generalize it to take the duration of the movie in three parameters: `hours`, `minutes`, and `seconds`." + "Encapsulemos este cálculo en una función y generalicémoslo para que tome la duración de la película en tres parámetros: `hours`, `minutes` y `seconds`." ] }, { @@ -445,7 +445,7 @@ "id": "a51913e2", "metadata": {}, "source": [ - "Here is an example that demonstrates the effect." + "Aquí tienes un ejemplo que demuestra el efecto." ] }, { @@ -465,7 +465,7 @@ "id": "42d7de02", "metadata": {}, "source": [ - "The following stack diagram shows the state of the program just before `increment_time` modifies the object." + "El siguiente stack diagram muestra el estado del programa justo antes de que `increment_time` modifique el objeto." ] }, { @@ -519,11 +519,11 @@ "id": "d1e27667", "metadata": {}, "source": [ - "Inside the function, `time` is an alias for `start`, so when `time` is modified, `start` changes.\n", + "Dentro de la función, `time` es un alias de `start`, así que cuando se modifica `time`, cambia `start`.\n", "\n", - "This function works, but after it runs, we're left with a variable named `start` that refers to an object that represents the *end* time, and we no longer have an object that represents the start time.\n", - "It would be better to leave `start` unchanged and make a new object to represent the end time.\n", - "We can do that by copying `start` and modifying the copy." + "Esta función funciona, pero después de ejecutarse nos quedamos con una variable llamada `start` que se refiere a un objeto que representa la hora de *fin*, y ya no tenemos un objeto que represente la hora de inicio.\n", + "Sería mejor dejar `start` sin cambios y crear un objeto nuevo para representar la hora de fin.\n", + "Podemos hacerlo copiando `start` y modificando la copia." ] }, { @@ -531,10 +531,10 @@ "id": "0128f850", "metadata": {}, "source": [ - "## Copying\n", + "## Copiar\n", "\n", - "The `copy` module provides a function called `copy` that can duplicate any object.\n", - "We can import it like this." + "El módulo `copy` proporciona una función llamada `copy` que puede duplicar cualquier objeto.\n", + "Podemos importarla así." ] }, { @@ -552,7 +552,7 @@ "id": "940adbeb", "metadata": {}, "source": [ - "To see how it works, let's start with a new `Time` object that represents the start time of the movie." + "Para ver cómo funciona, empecemos con un objeto `Time` nuevo que representa la hora de inicio de la película." ] }, { @@ -570,7 +570,7 @@ "id": "514f05b9", "metadata": {}, "source": [ - "And make a copy." + "Y hagamos una copia." ] }, { @@ -588,7 +588,7 @@ "id": "87d8956b", "metadata": {}, "source": [ - "Now `start` and `end` contain the same data." + "Ahora `start` y `end` contienen los mismos datos." ] }, { @@ -607,7 +607,7 @@ "id": "e75c1e09", "metadata": {}, "source": [ - "But the `is` operator confirms that they are not the same object." + "Pero el operador `is` confirma que no son el mismo objeto." ] }, { @@ -625,7 +625,7 @@ "id": "22b68a3f", "metadata": {}, "source": [ - "Let's see what the `==` operator does." + "Veamos qué hace el operador `==`." ] }, { @@ -643,8 +643,8 @@ "id": "78ebf931", "metadata": {}, "source": [ - "You might expect `==` to yield `True` because the objects contain the same data.\n", - "But for programmer-defined classes, the default behavior of the `==` operator is the same as the `is` operator -- it checks identity, not equivalence." + "Podrías esperar que `==` produzca `True` porque los objetos contienen los mismos datos.\n", + "Pero para clases definidas por el programador, el comportamiento por defecto del operador `==` es el mismo que el del operador `is` -- comprueba identidad, no equivalencia." ] }, { @@ -652,11 +652,11 @@ "id": "a3934fdd-d4cd-41e0-86e6-5bb78d0886a7", "metadata": {}, "source": [ - "## Pure functions\n", + "## Funciones puras\n", "\n", - "We can use `copy` to write pure functions that don't modify their parameters.\n", - "For example, here's a function that takes a `Time` object and a duration in hours, minutes and seconds.\n", - "It makes a copy of the original object, uses `increment_time` to modify the copy, and returns it." + "Podemos usar `copy` para escribir funciones puras que no modifican sus parámetros.\n", + "Por ejemplo, aquí tienes una función que toma un objeto `Time` y una duración en horas, minutos y segundos.\n", + "Hace una copia del objeto original, usa `increment_time` para modificar la copia y la devuelve." ] }, { @@ -677,7 +677,7 @@ "id": "c181af12", "metadata": {}, "source": [ - "Here's how we use it." + "Así la usamos." ] }, { @@ -696,8 +696,8 @@ "id": "54b1ca4a", "metadata": {}, "source": [ - "The return value is a new object representing the end time of the movie.\n", - "And we can confirm that `start` is unchanged." + "El valor de retorno es un objeto nuevo que representa la hora de fin de la película.\n", + "Y podemos confirmar que `start` no ha cambiado." ] }, { @@ -715,14 +715,14 @@ "id": "1233b2db", "metadata": {}, "source": [ - "`add_time` is a **pure function** because it does not modify any of the objects passed to it as arguments and its only effect is to return a value.\n", + "`add_time` es una **función pura** porque no modifica ninguno de los objetos que se le pasan como argumentos y su único efecto es devolver un valor.\n", "\n", - "Anything that can be done with impure functions can also be done with pure functions.\n", - "In fact, some programming languages only allow pure functions.\n", - "Programs that use pure functions might be less error-prone, but impure functions are sometimes convenient and can be more efficient.\n", + "Cualquier cosa que se pueda hacer con funciones impuras también se puede hacer con funciones puras.\n", + "De hecho, algunos lenguajes de programación solo permiten funciones puras.\n", + "Los programas que usan funciones puras pueden ser menos propensos a errores, pero las funciones impuras a veces son convenientes y pueden ser más eficientes.\n", "\n", - "In general, I suggest you write pure functions whenever it is reasonable and resort to impure functions only if there is a compelling advantage.\n", - "This approach might be called a **functional programming style**." + "En general, te sugiero que escribas funciones puras siempre que sea razonable y recurras a funciones impuras solo si hay una ventaja convincente.\n", + "Este enfoque podría llamarse un **estilo de programación funcional**." ] }, { @@ -732,10 +732,10 @@ "source": [ "## Prototype and patch\n", "\n", - "In the previous example, `increment_time` and `add_time` seem to work, but if we try another example, we'll see that they are not quite correct.\n", + "En el ejemplo anterior, `increment_time` y `add_time` parecen funcionar, pero si probamos otro ejemplo veremos que no son del todo correctas.\n", "\n", - "Suppose you arrive at the theater and discover that the movie starts at `9:40`, not `9:20`.\n", - "Here's what happens when we compute the updated end time." + "Supón que llegas al cine y descubres que la película empieza a las `9:40`, no a las `9:20`.\n", + "Esto es lo que ocurre cuando calculamos la hora de fin actualizada." ] }, { @@ -755,10 +755,10 @@ "id": "c712ebf7-7e52-490e-91d7-5f1c83334de0", "metadata": {}, "source": [ - "The result is not a valid time.\n", - "The problem is that `increment_time` does not deal with cases where the number of seconds or minutes adds up to more than `60`.\n", + "El resultado no es una hora válida.\n", + "El problema es que `increment_time` no trata los casos en los que el número de segundos o minutos suma más de `60`.\n", "\n", - "Here's an improved version that checks whether `second` exceeds or equals `60` -- if so, it increments `minute` -- then checks whether `minute` exceeds or equals `60` -- if so, it increments `hour`." + "Aquí tienes una versión mejorada que comprueba si `second` supera o iguala `60` -- si es así, incrementa `minute` -- y luego comprueba si `minute` supera o iguala `60` -- si es así, incrementa `hour`." ] }, { @@ -787,8 +787,8 @@ "id": "c133c5d8", "metadata": {}, "source": [ - "Fixing `increment_time` also fixes `add_time`, which uses it.\n", - "So now the previous example works correctly." + "Arreglar `increment_time` también arregla `add_time`, que la usa.\n", + "Así que ahora el ejemplo anterior funciona correctamente." ] }, { @@ -807,9 +807,9 @@ "id": "a2f644a6-ca43-494e-af14-6e845b3d7973", "metadata": {}, "source": [ - "But this function is still not correct, because the arguments might be bigger than `60`.\n", - "For example, suppose we are given the run time as `92` minutes, rather than `1` hours and `32` minutes.\n", - "We might call `add_time` like this." + "Pero esta función todavía no es correcta, porque los argumentos podrían ser mayores que `60`.\n", + "Por ejemplo, supón que recibimos la duración como `92` minutos, en lugar de `1` hora y `32` minutos.\n", + "Podríamos llamar a `add_time` así." ] }, { @@ -828,9 +828,9 @@ "id": "72e0a08b", "metadata": {}, "source": [ - "The result is not a valid time.\n", - "So let's try a different approach, using the `divmod` function.\n", - "We'll make a copy of `start` and modify it by incrementing the `minute` attribute." + "El resultado no es una hora válida.\n", + "Así que probemos un enfoque distinto, usando la función `divmod`.\n", + "Haremos una copia de `start` y la modificaremos incrementando el atributo `minute`." ] }, { @@ -850,8 +850,8 @@ "id": "c56355bc", "metadata": {}, "source": [ - "Now `minute` is `132`, which is `2` hours and `12` minutes.\n", - "We can use `divmod` to divide by `60` and return the number of whole hours and the number of minutes left over." + "Ahora `minute` es `132`, que son `2` horas y `12` minutos.\n", + "Podemos usar `divmod` para dividir por `60` y devolver el número de horas completas y el número de minutos sobrantes." ] }, { @@ -870,7 +870,7 @@ "id": "43204703", "metadata": {}, "source": [ - "Now `minute` is correct, and we can add the hours to `hour`." + "Ahora `minute` es correcto, y podemos añadir las horas a `hour`." ] }, { @@ -889,8 +889,8 @@ "id": "a68ae1cd", "metadata": {}, "source": [ - "The result is a valid time.\n", - "We can do the same thing with `hour` and `second`, and encapsulate the whole process in a function." + "El resultado es una hora válida.\n", + "Podemos hacer lo mismo con `hour` y `second`, y encapsular todo el proceso en una función." ] }, { @@ -915,7 +915,7 @@ "id": "7437113a", "metadata": {}, "source": [ - "With this version of `increment_time`, `add_time` works correctly, even if the arguments exceed `60`." + "Con esta versión de `increment_time`, `add_time` funciona correctamente, incluso si los argumentos superan `60`." ] }, { @@ -934,13 +934,13 @@ "id": "7c6329b2", "metadata": {}, "source": [ - "This section demonstrates a program development plan I call **prototype and patch**.\n", - "We started with a simple prototype that worked correctly for the first example.\n", - "Then we tested it with more difficult examples -- when we found an error, we modified the program to fix it, like putting a patch on tire with a puncture.\n", + "Esta sección demuestra un plan de desarrollo de programas que llamo **prototype and patch**.\n", + "Empezamos con un prototipo simple que funcionaba correctamente para el primer ejemplo.\n", + "Luego lo probamos con ejemplos más difíciles -- cuando encontramos un error, modificamos el programa para corregirlo, como poner un parche en un neumático pinchado.\n", "\n", - "This approach can be effective, especially if you don't yet have a deep understanding of the problem.\n", - "But incremental corrections can generate code that is unnecessarily complicated -- since it deals with many special cases -- and unreliable -- since it is hard to know if you have\n", - "found all the errors." + "Este enfoque puede ser efectivo, especialmente si todavía no tienes una comprensión profunda del problema.\n", + "Pero las correcciones incrementales pueden generar código innecesariamente complicado -- porque trata muchos casos especiales -- y poco fiable -- porque es difícil saber si has\n", + "encontrado todos los errores." ] }, { @@ -950,16 +950,16 @@ "source": [ "## Design-first development\n", "\n", - "An alternative plan is **design-first development**, which involves more planning before prototyping. In a design-first process, sometimes a high-level insight into the problem makes the programming much easier.\n", + "Un plan alternativo es **design-first development**, que implica más planificación antes de prototipar. En un proceso design-first, a veces una idea de alto nivel sobre el problema hace que la programación sea mucho más sencilla.\n", "\n", - "In this case, the insight is that we can think of a `Time` object as a three-digit number in base 60 -- also known as sexagesimal.\n", - "The `second` attribute is the \"ones column\", the `minute` attribute is the \"sixties column\",\n", - "and the `hour` attribute is the \"thirty-six hundreds column\".\n", - "When we wrote `increment_time`, we were effectively doing addition in base 60, which is why we had to carry from one column to the next.\n", + "En este caso, la idea es que podemos pensar en un objeto `Time` como un número de tres dígitos en base 60 -- también conocida como sexagesimal.\n", + "El atributo `second` es la \"columna de las unidades\", el atributo `minute` es la \"columna de los sesenta\",\n", + "y el atributo `hour` es la \"columna de los treinta y seis cientos\".\n", + "Cuando escribimos `increment_time`, en realidad estábamos haciendo suma en base 60, por eso teníamos que llevar de una columna a la siguiente.\n", "\n", - "This observation suggests another approach to the whole problem -- we can convert `Time` objects to integers and take advantage of the fact that Python knows how to do integer arithmetic.\n", + "Esta observación sugiere otro enfoque para todo el problema -- podemos convertir objetos `Time` en enteros y aprovechar que Python sabe hacer aritmética de enteros.\n", "\n", - "Here is a function that converts from a `Time` to an integer." + "Aquí tienes una función que convierte de un `Time` a un entero." ] }, { @@ -980,8 +980,8 @@ "id": "c7e7789e", "metadata": {}, "source": [ - "The result is the number of seconds since the beginning of the day.\n", - "For example, `01:01:01` is `1` hour, `1` minute and `1` second from the beginning of the day, which is the sum of `3600` seconds, `60` seconds, and `1` second." + "El resultado es el número de segundos desde el comienzo del día.\n", + "Por ejemplo, `01:01:01` es `1` hora, `1` minuto y `1` segundo desde el comienzo del día, que es la suma de `3600` segundos, `60` segundos y `1` segundo." ] }, { @@ -1001,7 +1001,7 @@ "id": "6ea525c8-4547-4bde-91c3-17f45add1bf8", "metadata": {}, "source": [ - "And here's a function that goes in the other direction -- converting an integer to a `Time` object -- using the `divmod` function." + "Y aquí tienes una función que va en la otra dirección -- convierte un entero en un objeto `Time` -- usando la función `divmod`." ] }, { @@ -1022,7 +1022,7 @@ "id": "4706b5df", "metadata": {}, "source": [ - "We can test it by converting the previous example back to a `Time`." + "Podemos probarla convirtiendo el ejemplo anterior de vuelta a un `Time`." ] }, { @@ -1041,7 +1041,7 @@ "id": "0c2b8469-d4a7-46f9-a0a1-f2a6c1595183", "metadata": {}, "source": [ - "Using these functions, we can write a more concise version of `add_time`." + "Usando estas funciones, podemos escribir una versión más concisa de `add_time`." ] }, { @@ -1062,11 +1062,11 @@ "id": "cb560257", "metadata": {}, "source": [ - "The first line converts the arguments to a `Time` object called `duration`.\n", - "The second line converts `time` and `duration` to seconds and adds them.\n", - "The third line converts the sum to a `Time` object and returns it.\n", + "La primera línea convierte los argumentos en un objeto `Time` llamado `duration`.\n", + "La segunda línea convierte `time` y `duration` a segundos y los suma.\n", + "La tercera línea convierte la suma en un objeto `Time` y lo devuelve.\n", "\n", - "Here's how it works." + "Así funciona." ] }, { @@ -1086,17 +1086,17 @@ "id": "db762aa8-4aab-4c17-a88d-72c5048f18c0", "metadata": {}, "source": [ - "In some ways, converting from base 60 to base 10 and back is harder than\n", - "just dealing with times. Base conversion is more abstract; our intuition\n", - "for dealing with time values is better.\n", + "En cierto sentido, convertir de base 60 a base 10 y de vuelta es más difícil que\n", + "simplemente tratar con horas. La conversión de base es más abstracta; nuestra intuición\n", + "para trabajar con valores de tiempo es mejor.\n", "\n", - "But if we have the insight to treat times as base 60 numbers -- and invest the effort to write the conversion functions `time_to_int` and `int_to_time` -- we get a program that is shorter, easier to read and debug, and more reliable.\n", + "Pero si tenemos la idea de tratar las horas como números en base 60 -- e invertimos el esfuerzo de escribir las funciones de conversión `time_to_int` e `int_to_time` -- obtenemos un programa más corto, más fácil de leer y depurar, y más fiable.\n", "\n", - "It is also easier to add features later. For example, imagine subtracting two `Time` objects to find the duration between them.\n", - "The naive approach is to implement subtraction with borrowing.\n", - "Using the conversion functions is easier and more likely to be correct.\n", + "También es más fácil añadir características más adelante. Por ejemplo, imagina restar dos objetos `Time` para encontrar la duración entre ellos.\n", + "El enfoque ingenuo es implementar la resta con préstamo.\n", + "Usar las funciones de conversión es más fácil y tiene más probabilidades de ser correcto.\n", "\n", - "Ironically, sometimes making a problem harder -- or more general -- makes it easier, because there are fewer special cases and fewer opportunities for error." + "Irónicamente, a veces hacer un problema más difícil -- o más general -- lo hace más fácil, porque hay menos casos especiales y menos oportunidades de error." ] }, { @@ -1106,10 +1106,10 @@ "tags": [] }, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Python provides several built-in functions that are useful for testing and debugging programs that work with objects.\n", - "For example, if you are not sure what type an object is, you can ask." + "Python proporciona varias funciones integradas que son útiles para probar y depurar programas que trabajan con objetos.\n", + "Por ejemplo, si no estás seguro de qué tipo es un objeto, puedes preguntarlo." ] }, { @@ -1127,7 +1127,7 @@ "id": "7ec0eabf", "metadata": {}, "source": [ - "You can also use `isinstance` to check whether an object is an instance of a particular class." + "También puedes usar `isinstance` para comprobar si un objeto es una instancia de una clase concreta." ] }, { @@ -1145,8 +1145,7 @@ "id": "4f453fe9", "metadata": {}, "source": [ - "If you are not sure whether an object has a particular attribute, you\n", - "can use the built-in function `hasattr`." + "Si no estás seguro de si un objeto tiene un atributo concreto, puedes usar la función integrada `hasattr`." ] }, { @@ -1164,7 +1163,7 @@ "id": "a0131d84", "metadata": {}, "source": [ - "To get all of the attributes, and their values, in a dictionary, you can use `vars`." + "Para obtener todos los atributos, y sus valores, en un diccionario, puedes usar `vars`." ] }, { @@ -1182,7 +1181,7 @@ "id": "f1a443c8", "metadata": {}, "source": [ - "The `structshape` module, which we saw in [Chapter 11](section_debugging_11), also works with programmer-defined types." + "El módulo `structshape`, que vimos en el [Capítulo 11](section_depuración_11), también funciona con tipos definidos por el programador." ] }, { @@ -1215,43 +1214,43 @@ "id": "501436c0-6634-415f-be84-2d130232b2b8", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**object-oriented programming:**\n", - "A style of programming that uses objects to organize code and data.\n", + "**programación orientada a objetos:**\n", + "Un estilo de programación que usa objetos para organizar código y datos.\n", "\n", - "**class:**\n", - " A programmer-defined type. A class definition creates a new class object.\n", + "**clase:**\n", + " Un tipo definido por el programador. Una definición de clase crea un nuevo objeto de clase.\n", "\n", - "**class object:**\n", - "An object that represents a class -- it is the result of a class definition.\n", + "**objeto de clase:**\n", + "Un objeto que representa una clase -- es el resultado de una definición de clase.\n", "\n", - "**instantiation:**\n", - "The process of creating an object that belongs to a class.\n", + "**instanciación:**\n", + "El proceso de crear un objeto que pertenece a una clase.\n", "\n", - "**instance:**\n", - " An object that belongs to a class.\n", + "**instancia:**\n", + " Un objeto que pertenece a una clase.\n", "\n", - "**attribute:**\n", - " A variable associated with an object, also called an instance variable.\n", + "**atributo:**\n", + " Una variable asociada con un objeto, también llamada variable de instancia.\n", "\n", - "**object diagram:**\n", - "A graphical representation of an object, its attributes, and their values.\n", + "**diagrama de objeto:**\n", + "Una representación gráfica de un objeto, sus atributos y sus valores.\n", "\n", - "**format specifier:**\n", - "In an f-string, a format specifier determines how a value is converted to a string.\n", + "**especificador de formato:**\n", + "En una f-string, un especificador de formato determina cómo se convierte un valor en una string.\n", "\n", - "**pure function:**\n", - "A function that does not modify its parameters or have any effect other than returning a value.\n", + "**función pura:**\n", + "Una función que no modifica sus parámetros ni tiene ningún efecto aparte de devolver un valor.\n", "\n", - "**functional programming style:**\n", - "A way of programming that uses pure functions whenever possible.\n", + "**estilo de programación funcional:**\n", + "Una forma de programar que usa funciones puras siempre que sea posible.\n", "\n", "**prototype and patch:**\n", - "A way of developing programs by starting with a rough draft and gradually adding features and fixing bugs.\n", + "Una forma de desarrollar programas empezando con un borrador aproximado y añadiendo características y corrigiendo bugs gradualmente.\n", "\n", "**design-first development:**\n", - "A way of developing programs with more careful planning that prototype and patch." + "Una forma de desarrollar programas con una planificación más cuidadosa que prototype and patch." ] }, { @@ -1259,7 +1258,7 @@ "id": "09dd41c1", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1282,29 +1281,29 @@ "id": "da0aea86", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There is a lot of new vocabulary in this chapter.\n", - "A conversation with a virtual assistant can help solidify your understanding.\n", - "Consider asking:\n", + "Hay mucho vocabulario nuevo en este capítulo.\n", + "Una conversación con un asistente virtual puede ayudarte a consolidar tu comprensión.\n", + "Considera preguntar:\n", "\n", - "* \"What is the difference between a class and a type?\"\n", + "* \"¿Cuál es la diferencia entre una clase y un tipo?\"\n", "\n", - "* \"What is the difference between an object and an instance?\"\n", + "* \"¿Cuál es la diferencia entre un objeto y una instancia?\"\n", "\n", - "* \"What is the difference between a variable and an attribute?\"\n", + "* \"¿Cuál es la diferencia entre una variable y un atributo?\"\n", "\n", - "* \"What are the pros and cons of pure functions compared to impure functions?\"\n", + "* \"¿Cuáles son los pros y los contras de funciones puras comparadas con funciones impuras?\"\n", "\n", - "Because we are just getting started with object oriented programming, the code in this chapter is not idiomatic -- it is not the kind of code experienced programmers write.\n", - "If you ask a virtual assistant for help with the exercises, you will probably see features we have not covered yet.\n", - "In particular, you are likely to see a method called `__init__` used to initialize the attributes of an instance.\n", + "Como apenas estamos empezando con la programación orientada a objetos, el código de este capítulo no es idiomático -- no es el tipo de código que escriben los programadores con experiencia.\n", + "Si pides ayuda a un asistente virtual con los ejercicios, probablemente verás características que todavía no hemos cubierto.\n", + "En particular, es probable que veas un método llamado `__init__` usado para inicializar los atributos de una instancia.\n", "\n", - "If these features make sense to you, go ahead and use them.\n", - "But if not, be patient -- we will get there soon.\n", - "In the meantime, see if you can solve the following exercises using only the features we have covered so far.\n", + "Si estas características tienen sentido para ti, adelante, úsalas.\n", + "Pero si no, ten paciencia -- llegaremos pronto.\n", + "Mientras tanto, mira si puedes resolver los siguientes ejercicios usando solo las características que hemos cubierto hasta ahora.\n", "\n", - "Also, in this chapter we saw one example of a format specifier. For more information, ask \"What format specifiers can be used in a Python f-string?\"" + "Además, en este capítulo vimos un ejemplo de especificador de formato. Para más información, pregunta \"¿Qué especificadores de formato se pueden usar en una f-string de Python?\"" ] }, { @@ -1312,9 +1311,9 @@ "id": "bcdab7d6", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `subtract_time` that takes two `Time` objects and returns the interval between them in seconds -- assuming that they are two times during the same day." + "Escribe una función llamada `subtract_time` que tome dos objetos `Time` y devuelva el intervalo entre ellos en segundos -- asumiendo que son dos horas del mismo día." ] }, { @@ -1324,7 +1323,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1366,7 +1365,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1391,9 +1390,9 @@ "id": "c3189549", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a function called `is_after` that takes two `Time` objects and returns `True` if the first time is later in the day than the second, and `False` otherwise." + "Escribe una función llamada `is_after` que tome dos objetos `Time` y devuelva `True` si la primera hora es más tarde en el día que la segunda, y `False` en caso contrario." ] }, { @@ -1403,7 +1402,7 @@ "tags": [] }, "source": [ - "Here's an outline of the function to get you started." + "Aquí tienes un esquema de la función para empezar." ] }, { @@ -1443,7 +1442,7 @@ "tags": [] }, "source": [ - "You can use `doctest` to test your function." + "Puedes usar `doctest` para probar tu función." ] }, { @@ -1463,9 +1462,9 @@ "id": "16dff862", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's a definition for a `Date` class that represents a date -- that is, a year, month, and day of the month." + "Aquí tienes una definición de una clase `Date` que representa una fecha -- es decir, un año, mes y día del mes." ] }, { @@ -1484,13 +1483,13 @@ "id": "3311fa97", "metadata": {}, "source": [ - "1. Write a function called `make_date` that takes `year`, `month`, and `day` as parameters, makes a `Date` object, assigns the parameters to attributes, and returns the result the new object. Create an object that represents June 22, 1933.\n", + "1. Escribe una función llamada `make_date` que tome `year`, `month` y `day` como parámetros, cree un objeto `Date`, asigne los parámetros a atributos y devuelva el objeto nuevo resultante. Crea un objeto que represente el 22 de junio de 1933.\n", "\n", - "2. Write a function called `print_date` that takes a `Date` object, uses an f-string to format the attributes, and prints the result. If you test it with the `Date` you created, the result should be `1933-06-22`.\n", + "2. Escribe una función llamada `print_date` que tome un objeto `Date`, use una f-string para formatear los atributos e imprima el resultado. Si la pruebas con la `Date` que creaste, el resultado debería ser `1933-06-22`.\n", "\n", - "3. Write a function called `is_after` that takes two `Date` objects as parameters and returns `True` if the first comes after the second. Create a second object that represents September 17, 1933, and check whether it comes after the first object.\n", + "3. Escribe una función llamada `is_after` que tome dos objetos `Date` como parámetros y devuelva `True` si la primera viene después de la segunda. Crea un segundo objeto que represente el 17 de septiembre de 1933 y comprueba si viene después del primer objeto.\n", "\n", - "Hint: You might find it useful to write a function called `date_to_tuple` that takes a `Date` object and returns a tuple that contains its attributes in year, month, day order." + "Pista: puede resultarte útil escribir una función llamada `date_to_tuple` que tome un objeto `Date` y devuelva una tupla que contenga sus atributos en orden año, mes, día." ] }, { @@ -1500,7 +1499,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1533,7 +1532,7 @@ "tags": [] }, "source": [ - "You can use these examples to test `make_date`." + "Puedes usar estos ejemplos para probar `make_date`." ] }, { @@ -1567,7 +1566,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1600,7 +1599,7 @@ "tags": [] }, "source": [ - "You can use this example to test `print_date`." + "Puedes usar este ejemplo para probar `print_date`." ] }, { @@ -1622,7 +1621,7 @@ "tags": [] }, "source": [ - "You can use this function outline to get started." + "Puedes usar este esquema de función para empezar." ] }, { @@ -1665,7 +1664,7 @@ "tags": [] }, "source": [ - "You can use these examples to test `is_after`." + "Puedes usar estos ejemplos para probar `is_after`." ] }, { @@ -1709,9 +1708,11 @@ "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Código license: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], diff --git a/chapters/chap15.ipynb b/chapters/chap15.ipynb index f7dfa60..72af9e3 100644 --- a/chapters/chap15.ipynb +++ b/chapters/chap15.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -41,19 +41,19 @@ "id": "fa22117f", "metadata": {}, "source": [ - "# Classes and Methods\n", + "# Clases y métodos\n", "\n", - "Python is an **object-oriented language** -- that is, it provides features that support object-oriented programming, which has these defining characteristics:\n", + "Python es un **lenguaje orientado a objetos** -- es decir, proporciona funcionalidades que dan soporte a la programación orientada a objetos, que tiene estas características definitorias:\n", "\n", - "- Most of the computation is expressed in terms of operations on objects.\n", + "- La mayor parte del cálculo se expresa en términos de operaciones sobre objetos.\n", "\n", - "- Objects often represent things in the real world, and methods often correspond to the ways things in the real world interact.\n", + "- Los objetos a menudo representan cosas del mundo real, y los métodos suelen corresponder a las formas en que las cosas del mundo real interactúan.\n", "\n", - "- Programs include class and method definitions.\n", + "- Los programas incluyen definiciones de clase y método.\n", "\n", - "For example, in the previous chapter we defined a `Time` class that corresponds to the way people record the time of day, and we defined functions that correspond to the kinds of things people do with times.\n", - "But there was no explicit connection between the definition of the `Time` class and the function definitions that follow.\n", - "We can make the connection explicit by rewriting a function as a **method**, which is defined inside a class definition." + "Por ejemplo, en el capítulo anterior definimos una clase `Time` que corresponde a la forma en que las personas registran la hora del día, y definimos funciones que corresponden a los tipos de cosas que las personas hacen con horas.\n", + "Pero no había una conexión explícita entre la definición de la clase `Time` y las definiciones de función que vienen después.\n", + "Podemos hacer explícita la conexión reescribiendo una función como un **método**, que se define dentro de una definición de clase." ] }, { @@ -61,9 +61,9 @@ "id": "9857823a", "metadata": {}, "source": [ - "## Defining methods\n", + "## Definir métodos\n", "\n", - "In the previous chapter we defined a class named `Time` and wrote a function named `print_time` that displays a time of day." + "En el capítulo anterior definimos una clase llamada `Time` y escribimos una función llamada `print_time` que muestra una hora del día." ] }, { @@ -86,12 +86,10 @@ "id": "a89ddf58", "metadata": {}, "source": [ - "To make `print_time` a method, all we have to do is move the function\n", - "definition inside the class definition. Notice the change in\n", - "indentation.\n", + "Para convertir `print_time` en un método, todo lo que tenemos que hacer es mover la definición de la función dentro de la definición de la clase. Fíjate en el cambio de indentación.\n", "\n", - "At the same time, we'll change the name of the parameter from `time` to `self`.\n", - "This change is not necessary, but it is conventional for the first parameter of a method to be named `self`." + "Al mismo tiempo, cambiaremos el nombre del parámetro de `time` a `self`.\n", + "Este cambio no es necesario, pero es convencional que el primer parámetro de un método se llame `self`." ] }, { @@ -114,8 +112,8 @@ "id": "8da4079c", "metadata": {}, "source": [ - "To call this method, you have to pass a `Time` object as an argument.\n", - "Here's the function we'll use to make a `Time` object." + "Para llamar a este método, tienes que pasar un objeto `Time` como argumento.\n", + "Aquí está la función que usaremos para crear un objeto `Time`." ] }, { @@ -138,7 +136,7 @@ "id": "c6ad4e12", "metadata": {}, "source": [ - "And here's a `Time` instance." + "Y aquí hay una instancia de `Time`." ] }, { @@ -156,8 +154,7 @@ "id": "bbbcd333", "metadata": {}, "source": [ - "Now there are two ways to call `print_time`. The first (and less common)\n", - "way is to use function syntax." + "Ahora hay dos formas de llamar a `print_time`. La primera (y menos común) es usar sintaxis de función." ] }, { @@ -175,8 +172,8 @@ "id": "2eb0847e", "metadata": {}, "source": [ - "In this version, `Time` is the name of the class, `print_time` is the name of the method, and `start` is passed as a parameter.\n", - "The second (and more idiomatic) way is to use method syntax:" + "En esta versión, `Time` es el nombre de la clase, `print_time` es el nombre del método, y `start` se pasa como parámetro.\n", + "La segunda forma (y más idiomática) es usar sintaxis de método:" ] }, { @@ -194,10 +191,10 @@ "id": "c80c40f0", "metadata": {}, "source": [ - "In this version, `start` is the object the method is invoked on, which is called the **receiver**, based on the analogy that invoking a method is like sending a message to an object.\n", + "En esta versión, `start` es el objeto sobre el que se invoca el método, que se llama **receptor**, basándonos en la analogía de que invocar un método es como enviar un mensaje a un objeto.\n", "\n", - "Regardless of the syntax, the behavior of the method is the same.\n", - "The receiver is assigned to the first parameter, so inside the method, `self` refers to the same object as `start`." + "Independientemente de la sintaxis, el comportamiento del método es el mismo.\n", + "El receptor se asigna al primer parámetro, así que dentro del método, `self` se refiere al mismo objeto que `start`." ] }, { @@ -205,9 +202,9 @@ "id": "8deb6c34", "metadata": {}, "source": [ - "## Another method\n", + "## Otro método\n", "\n", - "Here's the `time_to_int` function from the previous chapter." + "Aquí está la función `time_to_int` del capítulo anterior." ] }, { @@ -228,7 +225,7 @@ "id": "144e043f", "metadata": {}, "source": [ - "And here's a version rewritten as a method.\n" + "Y aquí hay una versión reescrita como método.\n" ] }, { @@ -251,14 +248,14 @@ "id": "e3a721ab", "metadata": {}, "source": [ - "The first line uses the special command `add_method_to`, which adds a method to a previously-defined class.\n", - "This command works in a Jupyter notebook, but it is not part of Python, so it won't work in other environments.\n", - "Normally, all methods of a class are inside the class definition, so they get defined at the same time as the class.\n", - "But for this book, it is helpful to define one method at a time.\n", + "La primera línea usa el comando especial `add_method_to`, que añade un método a una clase definida previamente.\n", + "Este comando funciona en un Jupyter notebook, pero no forma parte de Python, así que no funcionará en otros entornos.\n", + "Normalmente, todos los métodos de una clase están dentro de la definición de la clase, así que se definen al mismo tiempo que la clase.\n", + "Pero para este libro, es útil definir un método cada vez.\n", "\n", - "As in the previous example, the method definition is indented and the name of the parameter is `self`.\n", - "Other than that, the method is identical to the function.\n", - "Here's how we invoke it." + "Como en el ejemplo anterior, la definición del método está indentada y el nombre del parámetro es `self`.\n", + "Aparte de eso, el método es idéntico a la función.\n", + "Así es como lo invocamos." ] }, { @@ -276,7 +273,7 @@ "id": "14565505", "metadata": {}, "source": [ - "It is common to say that we \"call\" a function and \"invoke\" a method, but they mean the same thing." + "Es común decir que \"llamamos\" a una función e \"invocamos\" un método, pero significan lo mismo." ] }, { @@ -284,10 +281,10 @@ "id": "7bc24683", "metadata": {}, "source": [ - "## Static methods\n", + "## Métodos estáticos\n", "\n", - "As another example, let's consider the `int_to_time` function.\n", - "Here's the version from the previous chapter." + "Como otro ejemplo, consideremos la función `int_to_time`.\n", + "Aquí está la versión del capítulo anterior." ] }, { @@ -308,12 +305,12 @@ "id": "2b77c2a0", "metadata": {}, "source": [ - "This function takes `seconds` as a parameter and returns a new `Time` object.\n", - "If we transform it into a method of the `Time` class, we have to invoke it on a `Time` object.\n", - "But if we're trying to create a new `Time` object, what are we supposed to invoke it on?\n", + "Esta función toma `seconds` como parámetro y devuelve un nuevo objeto `Time`.\n", + "Si la transformamos en un método de la clase `Time`, tenemos que invocarla sobre un objeto `Time`.\n", + "Pero si estamos intentando crear un nuevo objeto `Time`, ¿sobre qué se supone que debemos invocarla?\n", "\n", - "We can solve this chicken-and-egg problem using a **static method**, which is a method that does not require an instance of the class to be invoked.\n", - "Here's how we rewrite this function as a static method." + "Podemos resolver este problema del huevo y la gallina usando un **método estático**, que es un método que no requiere una instancia de la clase para invocarse.\n", + "Así es como reescribimos esta función como un método estático." ] }, { @@ -336,8 +333,8 @@ "id": "a7e2e788", "metadata": {}, "source": [ - "Because it is a static method, it does not have `self` as a parameter.\n", - "To invoke it, we use `Time`, which is the class object." + "Como es un método estático, no tiene `self` como parámetro.\n", + "Para invocarlo, usamos `Time`, que es el objeto de clase." ] }, { @@ -355,7 +352,7 @@ "id": "d2f4fd5a", "metadata": {}, "source": [ - "The result is a new object that represents 9:40." + "El resultado es un nuevo objeto que representa las 9:40." ] }, { @@ -373,8 +370,8 @@ "id": "e6a18c76", "metadata": {}, "source": [ - "Now that we have `Time.int_to_time`, we can use it to write `add_time` as a method.\n", - "Here's the function from the previous chapter." + "Ahora que tenemos `Time.int_to_time`, podemos usarlo para escribir `add_time` como un método.\n", + "Aquí está la función del capítulo anterior." ] }, { @@ -395,7 +392,7 @@ "id": "8e56da48", "metadata": {}, "source": [ - "And here's a version rewritten as a method." + "Y aquí hay una versión reescrita como método." ] }, { @@ -418,9 +415,9 @@ "id": "b784a4ea", "metadata": {}, "source": [ - "`add_time` has `self` as a parameter because it is not a static method.\n", - "It is an ordinary method -- also called an **instance method**.\n", - "To invoke it, we need a `Time` instance." + "`add_time` tiene `self` como parámetro porque no es un método estático.\n", + "Es un método ordinario -- también llamado **método de instancia**.\n", + "Para invocarlo, necesitamos una instancia de `Time`." ] }, { @@ -439,10 +436,10 @@ "id": "f1c806a9", "metadata": {}, "source": [ - "## Comparing Time objects\n", + "## Comparar objetos Time\n", "\n", - "As one more example, let's write `is_after` as a method.\n", - "Here's the `is_after` function, which is a solution to an exercise in the previous chapter." + "Como un ejemplo más, escribamos `is_after` como método.\n", + "Aquí está la función `is_after`, que es una solución a un ejercicio del capítulo anterior." ] }, { @@ -461,7 +458,7 @@ "id": "8e7153e8", "metadata": {}, "source": [ - "And here it is as a method." + "Y aquí está como método." ] }, { @@ -482,9 +479,8 @@ "id": "50815aec", "metadata": {}, "source": [ - "Because we're comparing two objects, and the first parameter is `self`, we'll call the second parameter `other`.\n", - "To use this method, we have to invoke it on one object and pass the\n", - "other as an argument." + "Como estamos comparando dos objetos, y el primer parámetro es `self`, llamaremos al segundo parámetro `other`.\n", + "Para usar este método, tenemos que invocarlo sobre un objeto y pasar el otro como argumento." ] }, { @@ -502,8 +498,8 @@ "id": "cf97e358", "metadata": {}, "source": [ - "One nice thing about this syntax is that it almost reads like a question,\n", - "\"`end` is after `start`?\"" + "Una cosa buena de esta sintaxis es que casi se lee como una pregunta:\n", + "\"¿`end` va después de `start`?\"" ] }, { @@ -511,12 +507,12 @@ "id": "15a17fce", "metadata": {}, "source": [ - "## The `__str__` method\n", + "## El método `__str__`\n", "\n", - "When you write a method, you can choose almost any name you want.\n", - "However, some names have special meanings.\n", - "For example, if an object has a method named `__str__`, Python uses that method to convert the object to a string.\n", - "For example, here is a `__str__` method for a time object." + "Cuando escribes un método, puedes elegir casi cualquier nombre que quieras.\n", + "Sin embargo, algunos nombres tienen significados especiales.\n", + "Por ejemplo, si un objeto tiene un método llamado `__str__`, Python usa ese método para convertir el objeto a string.\n", + "Por ejemplo, aquí hay un método `__str__` para un objeto de hora." ] }, { @@ -538,9 +534,9 @@ "id": "b056b729", "metadata": {}, "source": [ - "This method is similar to `print_time`, from the previous chapter, except that it returns the string rather than printing it.\n", + "Este método es similar a `print_time`, del capítulo anterior, salvo que devuelve el string en lugar de imprimirlo.\n", "\n", - "You can invoke this method in the usual way." + "Puedes invocar este método de la forma habitual." ] }, { @@ -558,8 +554,8 @@ "id": "76092a0c", "metadata": {}, "source": [ - "But Python can also invoke it for you.\n", - "If you use the built-in function `str` to convert a `Time` object to a string, Python uses the `__str__` method in the `Time` class." + "Pero Python también puede invocarlo por ti.\n", + "Si usas la función integrada `str` para convertir un objeto `Time` a string, Python usa el método `__str__` de la clase `Time`." ] }, { @@ -577,7 +573,7 @@ "id": "8a26caa8", "metadata": {}, "source": [ - "And it does the same if you print a `Time` object." + "Y hace lo mismo si imprimes un objeto `Time`." ] }, { @@ -595,8 +591,8 @@ "id": "97eb30c2", "metadata": {}, "source": [ - "Methods like `__str__` are called **special methods**.\n", - "You can identify them because their names begin and end with two underscores." + "Los métodos como `__str__` se llaman **métodos especiales**.\n", + "Puedes identificarlos porque sus nombres empiezan y terminan con dos guiones bajos." ] }, { @@ -604,10 +600,10 @@ "id": "e01e9673", "metadata": {}, "source": [ - "## The init method\n", + "## El método init\n", "\n", - "The most special of the special methods is `__init__`, so-called because it initializes the attributes of a new object.\n", - "An `__init__` method for the `Time` class might look like this:" + "El más especial de los métodos especiales es `__init__`, llamado así porque inicializa los atributos de un nuevo objeto.\n", + "Un método `__init__` para la clase `Time` podría tener este aspecto:" ] }, { @@ -630,8 +626,8 @@ "id": "8ba624c3", "metadata": {}, "source": [ - "Now when we instantiate a `Time` object, Python invokes `__init__`, and passes along the arguments.\n", - "So we can create an object and initialize the attributes at the same time." + "Ahora, cuando instanciamos un objeto `Time`, Python invoca `__init__` y pasa los argumentos.\n", + "Así podemos crear un objeto e inicializar los atributos al mismo tiempo." ] }, { @@ -650,8 +646,8 @@ "id": "55e0e296", "metadata": {}, "source": [ - "In this example, the parameters are optional, so if you call `Time` with no arguments,\n", - "you get the default values." + "En este ejemplo, los parámetros son opcionales, así que si llamas a `Time` sin argumentos,\n", + "obtienes los valores por defecto." ] }, { @@ -670,7 +666,7 @@ "id": "bacb036d", "metadata": {}, "source": [ - "If you provide one argument, it overrides `hour`:" + "Si proporcionas un argumento, sobrescribe `hour`:" ] }, { @@ -689,7 +685,7 @@ "id": "37edb221", "metadata": {}, "source": [ - "If you provide two arguments, they override `hour` and `minute`." + "Si proporcionas dos argumentos, sobrescriben `hour` y `minute`." ] }, { @@ -708,10 +704,9 @@ "id": "277de217", "metadata": {}, "source": [ - "And if you provide three arguments, they override all three default\n", - "values.\n", + "Y si proporcionas tres argumentos, sobrescriben los tres valores por defecto.\n", "\n", - "When I write a new class, I almost always start by writing `__init__`, which makes it easier to create objects, and `__str__`, which is useful for debugging." + "Cuando escribo una clase nueva, casi siempre empiezo escribiendo `__init__`, que hace más fácil crear objetos, y `__str__`, que es útil para depurar." ] }, { @@ -719,14 +714,11 @@ "id": "94bbbd7d", "metadata": {}, "source": [ - "## Operator overloading\n", + "## Sobrecarga de operadores\n", "\n", - "By defining other special methods, you can specify the behavior of\n", - "operators on programmer-defined types. For example, if you define a\n", - "method named `__add__` for the `Time` class, you can use the `+`\n", - "operator on Time objects.\n", + "Definiendo otros métodos especiales, puedes especificar el comportamiento de los operadores sobre tipos definidos por el programador. Por ejemplo, si defines un método llamado `__add__` para la clase `Time`, puedes usar el operador `+` con objetos Time.\n", "\n", - "Here is an `__add__` method." + "Aquí hay un método `__add__`." ] }, { @@ -748,7 +740,7 @@ "id": "0221c9ad", "metadata": {}, "source": [ - "We can use it like this." + "Podemos usarlo así." ] }, { @@ -768,16 +760,16 @@ "id": "7cc7866e", "metadata": {}, "source": [ - "There is a lot happening when we run these three lines of code:\n", + "Están pasando muchas cosas cuando ejecutamos estas tres líneas de código:\n", "\n", - "* When we instantiate a `Time` object, the `__init__` method is invoked.\n", + "* Cuando instanciamos un objeto `Time`, se invoca el método `__init__`.\n", "\n", - "* When we use the `+` operator with a `Time` object, its `__add__` method is invoked.\n", + "* Cuando usamos el operador `+` con un objeto `Time`, se invoca su método `__add__`.\n", "\n", - "* And when we print a `Time` object, its `__str__` method is invoked.\n", + "* Y cuando imprimimos un objeto `Time`, se invoca su método `__str__`.\n", "\n", - "Changing the behavior of an operator so that it works with programmer-defined types is called **operator overloading**.\n", - "For every operator, like `+`, there is a corresponding special method, like `__add__`. " + "Cambiar el comportamiento de un operador para que funcione con tipos definidos por el programador se llama **sobrecarga de operadores**.\n", + "Para cada operador, como `+`, hay un método especial correspondiente, como `__add__`. " ] }, { @@ -785,15 +777,15 @@ "id": "b7299e62", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "A `Time` object is valid if the values of `minute` and `second` are between `0` and `60` -- including `0` but not `60` -- and if `hour` is positive.\n", - "Also, `hour` and `minute` should be integer values, but we might allow `second` to have a fraction part.\n", - "Requirements like these are called **invariants** because they should always be true.\n", - "To put it a different way, if they are not true, something has gone wrong.\n", + "Un objeto `Time` es válido si los valores de `minute` y `second` están entre `0` y `60` -- incluyendo `0` pero no `60` -- y si `hour` es positivo.\n", + "Además, `hour` y `minute` deberían ser valores enteros, pero podríamos permitir que `second` tenga una parte fraccionaria.\n", + "Requisitos como estos se llaman **invariantes** porque siempre deberían ser verdaderos.\n", + "Dicho de otra forma, si no son verdaderos, algo ha ido mal.\n", "\n", - "Writing code to check invariants can help detect errors and find their causes.\n", - "For example, you might have a method like `is_valid` that takes a Time object and returns `False` if it violates an invariant." + "Escribir código para comprobar invariantes puede ayudar a detectar errores y encontrar sus causas.\n", + "Por ejemplo, podrías tener un método como `is_valid` que toma un objeto Time y devuelve `False` si viola una invariante." ] }, { @@ -822,7 +814,7 @@ "id": "a10ad3db", "metadata": {}, "source": [ - "Then, at the beginning of each method you can check the arguments to make sure they are valid." + "Entonces, al principio de cada método puedes comprobar los argumentos para asegurarte de que son válidos." ] }, { @@ -845,8 +837,8 @@ "id": "e7c78e9a", "metadata": {}, "source": [ - "The `assert` statement evaluates the expression that follows. If the result is `True`, it does nothing; if the result is `False`, it causes an `AssertionError`.\n", - "Here's an example." + "La sentencia `assert` evalúa la expresión que le sigue. Si el resultado es `True`, no hace nada; si el resultado es `False`, causa un `AssertionError`.\n", + "Aquí hay un ejemplo." ] }, { @@ -879,7 +871,7 @@ "id": "18bd34ad", "metadata": {}, "source": [ - "`assert` statements are useful because they distinguish code that deals with normal conditions from code that checks for errors." + "Las sentencias `assert` son útiles porque distinguen el código que trata con condiciones normales del código que comprueba errores." ] }, { @@ -887,31 +879,31 @@ "id": "58b86fbe", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**object-oriented language:**\n", - "A language that provides features to support object-oriented programming, notably user-defined types.\n", + "**lenguaje orientado a objetos:**\n", + "Un lenguaje que proporciona funcionalidades para dar soporte a la programación orientada a objetos, especialmente tipos definidos por el usuario.\n", "\n", - "**method:**\n", - "A function that is defined inside a class definition and is invoked on instances of that class.\n", + "**método:**\n", + "Una función que se define dentro de una definición de clase y se invoca sobre instancias de esa clase.\n", "\n", - "**receiver:**\n", - "The object a method is invoked on.\n", + "**receptor (receiver):**\n", + "El objeto sobre el que se invoca un método.\n", "\n", - "**static method:**\n", - "A method that can be invoked without an object as receiver.\n", + "**método estático:**\n", + "Un método que puede invocarse sin un objeto como receptor.\n", "\n", - "**instance method:**\n", - "A method that must be invoked with an object as receiver.\n", + "**método de instancia:**\n", + "Un método que debe invocarse con un objeto como receptor.\n", "\n", - "**special method:**\n", - "A method that changes the way operators and some functions work with an object.\n", + "**método especial:**\n", + "Un método que cambia la forma en que los operadores y algunas funciones funcionan con un objeto.\n", "\n", - "**operator overloading:**\n", - "The process of using special methods to change the way operators with with user-defined types.\n", + "**sobrecarga de operadores:**\n", + "El proceso de usar métodos especiales para cambiar la forma en que los operadores funcionan con tipos definidos por el usuario.\n", "\n", - "**invariant:**\n", - " A condition that should always be true during the execution of a program." + "**invariante:**\n", + " Una condición que siempre debería ser verdadera durante la ejecución de un programa." ] }, { @@ -919,7 +911,7 @@ "id": "796adf5c", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -942,20 +934,20 @@ "id": "25cd6888", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "For more information about static methods, ask a virtual assistant:\n", + "Para obtener más información sobre métodos estáticos, pregunta a un asistente virtual:\n", "\n", - "* \"What's the difference between an instance method and a static method?\"\n", + "* \"¿Cuál es la diferencia entre un método de instancia y un método estático?\"\n", "\n", - "* \"Why are static methods called static?\"\n", + "* \"¿Por qué los métodos estáticos se llaman estáticos?\"\n", "\n", - "If you ask a virtual assistant to generate a static method, the result will probably begin with `@staticmethod`, which is a \"decorator\" that indicates that it is a static method.\n", - "Decorators are not covered in this book, but if you are curious, you can ask a VA for more information.\n", + "Si le pides a un asistente virtual que genere un método estático, el resultado probablemente empezará con `@staticmethod`, que es un \"decorator\" que indica que es un método estático.\n", + "Los decorators no se cubren en este libro, pero si tienes curiosidad, puedes pedirle más información a un AV.\n", "\n", - "In this chapter we rewrote several functions as methods.\n", - "Virtual assistants are generally good at this kind of code transformation.\n", - "As an example, paste the following function into a VA and ask it, \"Rewrite this function as a method of the `Time` class.\"" + "En este capítulo reescribimos varias funciones como métodos.\n", + "Los asistentes virtuales suelen ser buenos en este tipo de transformación de código.\n", + "Como ejemplo, pega la siguiente función en un AV y pídele: \"Reescribe esta función como un método de la clase `Time`.\"" ] }, { @@ -974,20 +966,20 @@ "id": "fc9f135b-e242-4ef6-83eb-8e028235c07b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In the previous chapter, a series of exercises asked you to write a `Date` class and several functions that work with `Date` objects.\n", - "Now let's practice rewriting those functions as methods.\n", + "En el capítulo anterior, una serie de ejercicios te pidió escribir una clase `Date` y varias funciones que trabajan con objetos `Date`.\n", + "Ahora practiquemos reescribir esas funciones como métodos.\n", "\n", - "1. Write a definition for a `Date` class that represents a date -- that is, a year, month, and day of the month.\n", + "1. Escribe una definición para una clase `Date` que represente una fecha -- es decir, un año, un mes y un día del mes.\n", "\n", - "2. Write an `__init__` method that takes `year`, `month`, and `day` as parameters and assigns the parameters to attributes. Create an object that represents June 22, 1933.\n", + "2. Escribe un método `__init__` que tome `year`, `month` y `day` como parámetros y asigne los parámetros a atributos. Crea un objeto que represente el 22 de junio de 1933.\n", "\n", - "3. Write `__str__` method that uses an f-string to format the attributes and returns the result. If you test it with the `Date` you created, the result should be `1933-06-22`.\n", + "3. Escribe un método `__str__` que use un f-string para formatear los atributos y devolver el resultado. Si lo pruebas con el `Date` que creaste, el resultado debería ser `1933-06-22`.\n", "\n", - "4. Write a method called `is_after` that takes two `Date` objects and returns `True` if the first comes after the second. Create a second object that represents September 17, 1933, and check whether it comes after the first object.\n", + "4. Escribe un método llamado `is_after` que tome dos objetos `Date` y devuelva `True` si el primero viene después del segundo. Crea un segundo objeto que represente el 17 de septiembre de 1933 y comprueba si viene después del primer objeto.\n", "\n", - "Hint: You might find it useful write a method called `to_tuple` that returns a tuple that contains the attributes of a `Date` object in year-month-day order." + "Pista: Podría resultarte útil escribir un método llamado `to_tuple` que devuelva una tupla que contiene los atributos de un objeto `Date` en orden año-mes-día." ] }, { @@ -1007,7 +999,7 @@ "tags": [] }, "source": [ - "You can use these examples to test your solution." + "Puedes usar estos ejemplos para probar tu solución." ] }, { @@ -1075,13 +1067,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -1107,4 +1101,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/chap16.ipynb b/chapters/chap16.ipynb index eb84e1c..65d636a 100644 --- a/chapters/chap16.ipynb +++ b/chapters/chap16.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -42,15 +42,15 @@ "id": "e826e661", "metadata": {}, "source": [ - "# Classes and Objects\n", + "# Clases y Objetos\n", "\n", - "At this point we have defined classes and created objects that represent the time of day and the day of the year.\n", - "And we've defined methods that create, modify, and perform computations with these objects.\n", + "Hasta este punto hemos definido clases y creado objetos que representan la hora del día y el día del año.\n", + "Y hemos definido métodos que crean, modifican y realizan cálculos con estos objetos.\n", "\n", - "In this chapter we'll continue our tour of object-oriented programming (OOP) by defining classes that represent geometric objects, including points, lines, rectangles, and circles.\n", - "We'll write methods that create and modify these objects, and we'll use the `jupyturtle` module to draw them.\n", + "En este capítulo continuaremos nuestro recorrido por la programación orientada a objetos (OOP) definiendo clases que representan objetos geométricos, incluidos puntos, líneas, rectángulos y círculos.\n", + "Escribiremos métodos que crean y modifican estos objetos, y usaremos el module `jupyturtle` para dibujarlos.\n", "\n", - "I'll use these classes to demonstrate OOP topics including object identity and equivalence, shallow and deep copying, and polymorphism." + "Usaré estas clases para demostrar temas de OOP, incluida la identidad y equivalencia de objetos, las copias superficiales y profundas, y el polimorfismo." ] }, { @@ -60,22 +60,22 @@ "tags": [] }, "source": [ - "## Creating a Point\n", + "## Crear un Point\n", "\n", - "In computer graphics a location on the screen is often represented using a pair of coordinates in an `x`-`y` plane.\n", - "By convention, the point `(0, 0)` usually represents the upper-left corner of the screen, and `(x, y)` represents the point `x` units to the right and `y` units down from the origin.\n", - "Compared to the Cartesian coordinate system you might have seen in a math class, the `y` axis is upside-down.\n", + "En gráficos por computadora, una ubicación en la pantalla a menudo se representa usando un par de coordenadas en un plano `x`-`y`.\n", + "Por convención, el punto `(0, 0)` suele representar la esquina superior izquierda de la pantalla, y `(x, y)` representa el punto que está `x` unidades a la derecha e `y` unidades hacia abajo desde el origen.\n", + "Comparado con el sistema de coordenadas cartesianas que quizá hayas visto en una clase de matemáticas, el eje `y` está al revés.\n", "\n", - "There are several ways we might represent a point in Python:\n", + "Hay varias formas en que podríamos representar un punto en Python:\n", "\n", - "- We can store the coordinates separately in two variables, `x` and `y`.\n", + "- Podemos almacenar las coordenadas por separado en dos variables, `x` e `y`.\n", "\n", - "- We can store the coordinates as elements in a list or tuple.\n", + "- Podemos almacenar las coordenadas como elementos en una lista o tupla.\n", "\n", - "- We can create a new type to represent points as objects.\n", + "- Podemos crear un nuevo tipo para representar puntos como objetos.\n", "\n", - "In object-oriented programming, it would be most idiomatic to create a new type.\n", - "To do that, we'll start with a class definition for `Point`." + "En programación orientada a objetos, lo más idiomático sería crear un nuevo tipo.\n", + "Para hacerlo, empezaremos con una definición de clase para `Point`." ] }, { @@ -101,10 +101,10 @@ "id": "3d35a095", "metadata": {}, "source": [ - "The `__init__` method takes the coordinates as parameters and assigns them to attributes `x` and `y`.\n", - "The `__str__` method returns a string representation of the `Point`.\n", + "El método `__init__` toma las coordenadas como parámetros y las asigna a los atributos `x` e `y`.\n", + "El método `__str__` devuelve una representación en string del `Point`.\n", "\n", - "Now we can instantiate and display a `Point` object like this." + "Ahora podemos instanciar y mostrar un objeto `Point` así." ] }, { @@ -123,7 +123,7 @@ "id": "b3fd8858", "metadata": {}, "source": [ - "The following diagram shows the state of the new object. " + "El siguiente diagrama muestra el estado del nuevo objeto. " ] }, { @@ -164,9 +164,9 @@ "id": "713b7410", "metadata": {}, "source": [ - "As usual, a programmer-defined type is represented by a box with the name of the type outside and the attributes inside.\n", + "Como de costumbre, un tipo definido por el programador se representa con una caja con el nombre del tipo fuera y los atributos dentro.\n", "\n", - "In general, programmer-defined types are mutable, so we can write a method like `translate` that takes two numbers, `dx` and `dy`, and adds them to the attributes `x` and `y`." + "En general, los tipos definidos por el programador son mutables, así que podemos escribir un método como `translate` que tome dos números, `dx` y `dy`, y los sume a los atributos `x` e `y`." ] }, { @@ -188,8 +188,8 @@ "id": "4d183292", "metadata": {}, "source": [ - "This function translates the `Point` from one location in the plane to another.\n", - "If we don't want to modify an existing `Point`, we can use `copy` to copy the original object and then modify the copy." + "Esta función traslada el `Point` de una ubicación del plano a otra.\n", + "Si no queremos modificar un `Point` existente, podemos usar `copy` para copiar el objeto original y luego modificar la copia." ] }, { @@ -211,7 +211,7 @@ "id": "562567c2", "metadata": {}, "source": [ - "We can encapsulate those steps in another method called `translated`." + "Podemos encapsular esos pasos en otro método llamado `translated`." ] }, { @@ -234,9 +234,9 @@ "id": "a7a635ee", "metadata": {}, "source": [ - "In the same way that the `sort` method modifies a list and the `sorted` function creates a new list, now we have a `translate` method that modifies a `Point` and a `translated` method that creates a new one.\n", + "De la misma manera que el método `sort` modifica una lista y la función `sorted` crea una lista nueva, ahora tenemos un método `translate` que modifica un `Point` y un método `translated` que crea uno nuevo.\n", "\n", - "Here's an example:" + "Aquí hay un ejemplo:" ] }, { @@ -255,7 +255,7 @@ "id": "923362d2", "metadata": {}, "source": [ - "In the next section, we'll use these points to define and draw a line." + "En la siguiente sección, usaremos estos puntos para definir y dibujar una línea." ] }, { @@ -263,10 +263,10 @@ "id": "837f98fd", "metadata": {}, "source": [ - "## Creating a Line\n", + "## Crear una Line\n", "\n", - "Now let's define a class that represents the line segment between two points.\n", - "As usual, we'll start with an `__init__` method and a `__str__` method." + "Ahora definamos una clase que representa el segmento de línea entre dos puntos.\n", + "Como de costumbre, empezaremos con un método `__init__` y un método `__str__`." ] }, { @@ -290,7 +290,7 @@ "id": "d7dad30e", "metadata": {}, "source": [ - "With those two methods, we can instantiate and display a `Line` object we'll use to represent the `x` axis." + "Con esos dos métodos, podemos instanciar y mostrar un objeto `Line` que usaremos para representar el eje `x`." ] }, { @@ -309,16 +309,16 @@ "id": "e7b5fd9a", "metadata": {}, "source": [ - "When we call `print` and pass `line` as a parameter, `print` invokes `__str__` on `line`.\n", - "The `__str__` method uses an f-string to create a string representation of the `line`. \n", + "Cuando llamamos a `print` y pasamos `line` como parámetro, `print` invoca `__str__` sobre `line`.\n", + "El método `__str__` usa un f-string para crear una representación en string de la `line`. \n", "\n", - "The f-string contains two expressions in curly braces, `self.p1` and `self.p2`.\n", - "When those expressions are evaluated, the results are `Point` objects.\n", - "Then, when they are converted to strings, the `__str__` method from the `Point` class gets invoked.\n", + "El f-string contiene dos expresiones entre llaves, `self.p1` y `self.p2`.\n", + "Cuando se evalúan esas expresiones, los resultados son objetos `Point`.\n", + "Luego, cuando se convierten a strings, se invoca el método `__str__` de la clase `Point`.\n", "\n", - "That's why, when we display a `Line`, the result contains the string representations of the `Point` objects.\n", + "Por eso, cuando mostramos una `Line`, el resultado contiene las representaciones en string de los objetos `Point`.\n", "\n", - "The following object diagram shows the state of this `Line` object." + "El siguiente diagrama de objeto muestra el estado de este objeto `Line`." ] }, { @@ -365,17 +365,17 @@ "id": "079859b5", "metadata": {}, "source": [ - "String representations and object diagrams are useful for debugging, but the point of this example is to generate graphics, not text!\n", - "So we'll use the `jupyturtle` module to draw lines on the screen.\n", + "Las representaciones en string y los diagramas de objeto son útiles para depurar, ¡pero el objetivo de este ejemplo es generar gráficos, no texto!\n", + "Así que usaremos el module `jupyturtle` para dibujar líneas en la pantalla.\n", "\n", - "As we did in [Chapter 4](section_turtle_module), we'll use `make_turtle` to create a `Turtle` object and a small canvas where it can draw.\n", - "To draw lines, we'll use two new functions from the `jupyturtle` module:\n", + "Como hicimos en el [Capítulo 4](section_turtle_module), usaremos `make_turtle` para crear un objeto `Turtle` y un canvas pequeño donde pueda dibujar.\n", + "Para dibujar líneas, usaremos dos funciones nuevas del module `jupyturtle`:\n", "\n", - "* `jumpto`, which takes two coordinates and moves the `Turtle` to the given location without drawing a line, and \n", + "* `jumpto`, que toma dos coordenadas y mueve la `Turtle` a la ubicación dada sin dibujar una línea, y \n", "\n", - "* `moveto`, which moves the `Turtle` from its current location to the given location, and draws a line segment between them.\n", + "* `moveto`, que mueve la `Turtle` desde su ubicación actual a la ubicación dada, y dibuja un segmento de línea entre ellas.\n", "\n", - "Here's how we import them." + "Así es como las importamos." ] }, { @@ -393,7 +393,7 @@ "id": "9d2dd88f", "metadata": {}, "source": [ - "And here's a method that draws a `Line`." + "Y aquí hay un método que dibuja una `Line`." ] }, { @@ -415,7 +415,7 @@ "id": "2341f0e0", "metadata": {}, "source": [ - "To show how it's used, I'll create a second line that represents the `y` axis." + "Para mostrar cómo se usa, crearé una segunda línea que representa el eje `y`." ] }, { @@ -434,7 +434,7 @@ "id": "d7450736", "metadata": {}, "source": [ - "And then draw the axes." + "Y luego dibujamos los ejes." ] }, { @@ -454,8 +454,8 @@ "id": "473c156f", "metadata": {}, "source": [ - "As we define and draw more objects, we'll use these lines again.\n", - "But first let's talk about object equivalence and identity." + "A medida que definamos y dibujemos más objetos, usaremos estas líneas otra vez.\n", + "Pero primero hablemos de equivalencia e identidad de objetos." ] }, { @@ -463,9 +463,9 @@ "id": "950da673", "metadata": {}, "source": [ - "## Equivalence and identity\n", + "## Equivalencia e identidad\n", "\n", - "Suppose we create two points with the same coordinates." + "Supongamos que creamos dos puntos con las mismas coordenadas." ] }, { @@ -484,7 +484,7 @@ "id": "82b14526", "metadata": {}, "source": [ - "If we use the `==` operator to compare them, we get the default behavior for programmer-defined types -- the result is `True` only if they are the same object, which they are not." + "Si usamos el operador `==` para compararlos, obtenemos el comportamiento por defecto para tipos definidos por el programador -- el resultado es `True` solo si son el mismo objeto, y no lo son." ] }, { @@ -502,7 +502,7 @@ "id": "96be0ff8", "metadata": {}, "source": [ - "If we want to change that behavior, we can provide a special method called `__eq__` that defines what it means for two `Point` objects to be equal." + "Si queremos cambiar ese comportamiento, podemos proporcionar un método especial llamado `__eq__` que define qué significa que dos objetos `Point` sean iguales." ] }, { @@ -523,8 +523,8 @@ "id": "7f4409de", "metadata": {}, "source": [ - "This definition considers two `Points` to be equal if their attributes are equal.\n", - "Now when we use the `==` operator, it invokes the `__eq__` method, which indicates that `p1` and `p2` are considered equal." + "Esta definición considera que dos `Points` son iguales si sus atributos son iguales.\n", + "Ahora, cuando usamos el operador `==`, invoca el método `__eq__`, que indica que `p1` y `p2` se consideran iguales." ] }, { @@ -542,7 +542,7 @@ "id": "52662e6a", "metadata": {}, "source": [ - "But the `is` operator still indicates that they are different objects." + "Pero el operador `is` todavía indica que son objetos diferentes." ] }, { @@ -560,9 +560,9 @@ "id": "c008d3dd", "metadata": {}, "source": [ - "It's not possible to override the `is` operator -- it always checks whether the objects are identical.\n", - "But for programmer-defined types, you can override the `==` operator so it checks whether the objects are equivalent.\n", - "And you can define what equivalent means." + "No es posible sobrescribir el operador `is` -- siempre comprueba si los objetos son idénticos.\n", + "Pero para tipos definidos por el programador, puedes sobrescribir el operador `==` para que compruebe si los objetos son equivalentes.\n", + "Y puedes definir qué significa equivalente." ] }, { @@ -570,20 +570,20 @@ "id": "893a8cab", "metadata": {}, "source": [ - "## Creating a Rectangle\n", + "## Crear un Rectangle\n", "\n", - "Now let's define a class that represents and draws rectangles.\n", - "To keep things simple, we'll assume that the rectangles are either vertical or horizontal, not at an angle.\n", - "What attributes do you think we should use to specify the location and size of a rectangle?\n", + "Ahora definamos una clase que representa y dibuja rectángulos.\n", + "Para simplificar las cosas, asumiremos que los rectángulos son verticales u horizontales, no inclinados.\n", + "¿Qué atributos crees que deberíamos usar para especificar la ubicación y el tamaño de un rectángulo?\n", "\n", - "There are at least two possibilities:\n", + "Hay al menos dos posibilidades:\n", "\n", - "- You could specify the width and height of the rectangle and the location of one corner.\n", + "- Podrías especificar el ancho y alto del rectángulo y la ubicación de una esquina.\n", "\n", - "- You could specify two opposing corners.\n", + "- Podrías especificar dos esquinas opuestas.\n", "\n", - "At this point it's hard to say whether either is better than the other, so let's implement the first one.\n", - "Here is the class definition." + "En este punto es difícil decir si una es mejor que la otra, así que implementemos la primera.\n", + "Aquí está la definición de la clase." ] }, { @@ -612,8 +612,8 @@ "id": "df2852f3", "metadata": {}, "source": [ - "As usual, the `__init__` method assigns the parameters to attributes and the `__str__` returns a string representation of the object.\n", - "Now we can instantiate a `Rectangle` object, using a `Point` as the location of the upper-left corner." + "Como de costumbre, el método `__init__` asigna los parámetros a atributos y `__str__` devuelve una representación en string del objeto.\n", + "Ahora podemos instanciar un objeto `Rectangle`, usando un `Point` como ubicación de la esquina superior izquierda." ] }, { @@ -633,7 +633,7 @@ "id": "a9e0b5ec", "metadata": {}, "source": [ - "The following diagram shows the state of this object." + "El siguiente diagrama muestra el estado de este objeto." ] }, { @@ -686,7 +686,7 @@ "id": "bb54e6b5", "metadata": {}, "source": [ - "To draw a rectangle, we'll use the following method to make four `Point` objects to represent the corners." + "Para dibujar un rectángulo, usaremos el siguiente método para crear cuatro objetos `Point` que representen las esquinas." ] }, { @@ -711,7 +711,7 @@ "id": "20dbe0cb", "metadata": {}, "source": [ - "Then we'll make four `Line` objects to represent the sides." + "Luego crearemos cuatro objetos `Line` para representar los lados." ] }, { @@ -733,7 +733,7 @@ "id": "30fe41cc", "metadata": {}, "source": [ - "Then we'll draw the sides." + "Luego dibujaremos los lados." ] }, { @@ -756,7 +756,7 @@ "id": "390ba3e7", "metadata": {}, "source": [ - "Here's an example." + "Aquí hay un ejemplo." ] }, { @@ -777,7 +777,7 @@ "id": "532a4f69", "metadata": {}, "source": [ - "The figure includes two lines to represent the axes." + "La figura incluye dos líneas para representar los ejes." ] }, { @@ -785,13 +785,13 @@ "id": "0e713a90", "metadata": {}, "source": [ - "## Changing rectangles\n", + "## Cambiar rectángulos\n", "\n", - "Now let's consider two methods that modify rectangles, `grow` and `translate`.\n", - "We'll see that `grow` works as expected, but `translate` has a subtle bug.\n", - "See if you can figure it out before I explain.\n", + "Ahora consideremos dos métodos que modifican rectángulos, `grow` y `translate`.\n", + "Veremos que `grow` funciona como se esperaba, pero `translate` tiene un error sutil.\n", + "A ver si puedes descubrirlo antes de que lo explique.\n", "\n", - "`grow` takes two numbers, `dwidth` and `dheight`, and adds them to the `width` and `height` attributes of the rectangle." + "`grow` toma dos números, `dwidth` y `dheight`, y los suma a los atributos `width` y `height` del rectángulo." ] }, { @@ -813,7 +813,7 @@ "id": "a51913e2", "metadata": {}, "source": [ - "Here's an example that demonstrates the effect by making a copy of `box1` and invoking `grow` on the copy." + "Aquí hay un ejemplo que demuestra el efecto creando una copia de `box1` e invocando `grow` sobre la copia." ] }, { @@ -833,7 +833,7 @@ "id": "6d74da62", "metadata": {}, "source": [ - "If we draw `box1` and `box2`, we can confirm that `grow` works as expected." + "Si dibujamos `box1` y `box2`, podemos confirmar que `grow` funciona como se esperaba." ] }, { @@ -855,8 +855,8 @@ "id": "0c940008", "metadata": {}, "source": [ - "Now let's see about `translate`.\n", - "It takes two numbers, `dx` and `dy`, and moves the rectangle the given distances in the `x` and `y` directions. " + "Ahora veamos qué pasa con `translate`.\n", + "Toma dos números, `dx` y `dy`, y mueve el rectángulo las distancias dadas en las direcciones `x` e `y`. " ] }, { @@ -877,7 +877,7 @@ "id": "c27fe91d", "metadata": {}, "source": [ - "To demonstrate the effect, we'll translate `box2` to the right and down." + "Para demostrar el efecto, trasladaremos `box2` a la derecha y hacia abajo." ] }, { @@ -896,7 +896,7 @@ "id": "e01badbc", "metadata": {}, "source": [ - "Now let's see what happens if we draw `box1` and `box2` again." + "Ahora veamos qué pasa si dibujamos `box1` y `box2` otra vez." ] }, { @@ -918,8 +918,8 @@ "id": "5310bdd7", "metadata": {}, "source": [ - "It looks like both rectangles moved, which is not what we intended!\n", - "The next section explains what went wrong." + "Parece que ambos rectángulos se movieron, ¡que no era lo que pretendíamos!\n", + "La siguiente sección explica qué salió mal." ] }, { @@ -927,10 +927,10 @@ "id": "940adbeb", "metadata": {}, "source": [ - "## Deep copy\n", + "## Copia profunda\n", "\n", - "When we use `copy` to duplicate `box1`, it copies the `Rectangle` object but not the `Point` object it contains.\n", - "So `box1` and `box2` are different objects, as intended." + "Cuando usamos `copy` para duplicar `box1`, copia el objeto `Rectangle` pero no el objeto `Point` que contiene.\n", + "Así que `box1` y `box2` son objetos diferentes, como pretendíamos." ] }, { @@ -948,7 +948,7 @@ "id": "eac5309b", "metadata": {}, "source": [ - "But their `corner` attributes refer to the same object." + "Pero sus atributos `corner` se refieren al mismo objeto." ] }, { @@ -966,7 +966,7 @@ "id": "f0cc51b5", "metadata": {}, "source": [ - "The following diagram shows the state of these objects." + "El siguiente diagrama muestra el estado de estos objetos." ] }, { @@ -1012,14 +1012,14 @@ "id": "35f3e7e1", "metadata": {}, "source": [ - "What `copy` does is called a **shallow copy** because it copies the object but not the objects it contains.\n", - "As a result, changing the `width` or `height` of one `Rectangle` does not affect the other, but changing the attributes of the shared `Point` affects both!\n", - "This behavior is confusing and error-prone.\n", + "Lo que hace `copy` se llama **copia superficial** porque copia el objeto pero no los objetos que contiene.\n", + "Como resultado, cambiar el `width` o `height` de un `Rectangle` no afecta al otro, ¡pero cambiar los atributos del `Point` compartido afecta a ambos!\n", + "Este comportamiento es confuso y propenso a errores.\n", "\n", - "Fortunately, the `copy` module provides another function, called `deepcopy`, that copies not only the object but also the objects it refers to, and the objects *they* refer to, and so on. \n", - "This operation is called a **deep copy**.\n", + "Afortunadamente, el module `copy` proporciona otra función, llamada `deepcopy`, que copia no solo el objeto sino también los objetos a los que se refiere, y los objetos a los que *ellos* se refieren, y así sucesivamente. \n", + "Esta operación se llama **copia profunda**.\n", "\n", - "To demonstrate, let's start with a new `Rectangle` that contains a new `Point`." + "Para demostrarlo, empecemos con un nuevo `Rectangle` que contiene un nuevo `Point`." ] }, { @@ -1039,7 +1039,7 @@ "id": "ff9ee872", "metadata": {}, "source": [ - "And we'll make a deep copy." + "Y haremos una copia profunda." ] }, { @@ -1059,7 +1059,7 @@ "id": "7efd0e6a", "metadata": {}, "source": [ - "We can confirm that the two `Rectangle` objects refer to different `Point` objects." + "Podemos confirmar que los dos objetos `Rectangle` se refieren a objetos `Point` diferentes." ] }, { @@ -1077,8 +1077,8 @@ "id": "ca925206", "metadata": {}, "source": [ - "Because `box3` and `box4` are completely separate objects, we can modify one without affecting the other.\n", - "To demonstrate, we'll move `box3` and grow `box4`." + "Como `box3` y `box4` son objetos completamente separados, podemos modificar uno sin afectar al otro.\n", + "Para demostrarlo, moveremos `box3` y haremos crecer `box4`." ] }, { @@ -1097,7 +1097,7 @@ "id": "3ff31c7c", "metadata": {}, "source": [ - "And we can confirm that the effect is as expected." + "Y podemos confirmar que el efecto es el esperado." ] }, { @@ -1119,10 +1119,10 @@ "id": "67051d62", "metadata": {}, "source": [ - "## Polymorphism\n", + "## Polimorfismo\n", "\n", - "In the previous example, we invoked the `draw` method on two `Line` objects and two `Rectangle` objects.\n", - "We can do the same thing more concisely by making a list of objects." + "En el ejemplo anterior, invocamos el método `draw` sobre dos objetos `Line` y dos objetos `Rectangle`.\n", + "Podemos hacer lo mismo de forma más concisa creando una lista de objetos." ] }, { @@ -1140,7 +1140,7 @@ "id": "773955dd", "metadata": {}, "source": [ - "The elements of this list are different types, but they all provide a `draw` method, so we can loop through the list and invoke `draw` on each one." + "Los elementos de esta lista son de tipos diferentes, pero todos proporcionan un método `draw`, así que podemos recorrer la lista e invocar `draw` sobre cada uno." ] }, { @@ -1161,17 +1161,17 @@ "id": "a1ae190c", "metadata": {}, "source": [ - "The first and second time through the loop, `shape` refers to a `Line` object, so when `draw` is invoked, the method that runs is the one defined in the `Line` class.\n", + "La primera y segunda vez a través del bucle, `shape` se refiere a un objeto `Line`, así que cuando se invoca `draw`, el método que se ejecuta es el definido en la clase `Line`.\n", "\n", - "The third and fourth time through the loop, `shape` refers to a `Rectangle` object, so when `draw` is invoked, the method that runs is the one defined in the `Rectangle` class.\n", + "La tercera y cuarta vez a través del bucle, `shape` se refiere a un objeto `Rectangle`, así que cuando se invoca `draw`, el método que se ejecuta es el definido en la clase `Rectangle`.\n", "\n", - "In a sense, each object knows how to draw itself.\n", - "This feature is called **polymorphism**.\n", - "The word comes from Greek roots that mean \"many shaped\".\n", - "In object-oriented programming, polymorphism is the ability of different types to provide the same methods, which makes it possible to perform many computations -- like drawing shapes -- by invoking the same method on different types of objects.\n", + "En cierto sentido, cada objeto sabe cómo dibujarse a sí mismo.\n", + "Esta característica se llama **polimorfismo**.\n", + "La palabra viene de raíces griegas que significan \"muchas formas\".\n", + "En programación orientada a objetos, el polimorfismo es la capacidad de diferentes tipos para proporcionar los mismos métodos, lo que hace posible realizar muchos cálculos -- como dibujar formas -- invocando el mismo método sobre objetos de tipos diferentes.\n", "\n", - "As an exercise at the end of this chapter, you'll define a new class that represents a circle and provides a `draw` method.\n", - "Then you can use polymorphism to draw lines, rectangles, and circles." + "Como ejercicio al final de este capítulo, definirás una nueva clase que representa un círculo y proporciona un método `draw`.\n", + "Luego puedes usar polimorfismo para dibujar líneas, rectángulos y círculos." ] }, { @@ -1179,15 +1179,15 @@ "id": "74d1b48f", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "In this chapter, we ran into a subtle bug that happened because we created a `Point` that was shared by two `Rectangle` objects, and then we modified the `Point`.\n", - "In general, there are two ways to avoid problems like this: you can avoid sharing objects or you can avoid modifying them.\n", + "En este capítulo, nos encontramos con un error sutil que ocurrió porque creamos un `Point` que era compartido por dos objetos `Rectangle`, y luego modificamos el `Point`.\n", + "En general, hay dos formas de evitar problemas como este: puedes evitar compartir objetos o puedes evitar modificarlos.\n", "\n", - "To avoid sharing objects, you can use deep copy, as we did in this chapter.\n", + "Para evitar compartir objetos, puedes usar copia profunda, como hicimos en este capítulo.\n", "\n", - "To avoid modifying objects, consider replacing impure functions like `translate` with pure functions like `translated`.\n", - "For example, here's a version of `translated` that creates a new `Point` and never modifies its attributes." + "Para evitar modificar objetos, considera reemplazar funciones impuras como `translate` por funciones puras como `translated`.\n", + "Por ejemplo, aquí hay una versión de `translated` que crea un nuevo `Point` y nunca modifica sus atributos." ] }, { @@ -1208,11 +1208,11 @@ "id": "76972167", "metadata": {}, "source": [ - "Python provides features that make it easier to avoid modifying objects.\n", - "They are beyond the scope of this book, but if you are curious, ask a virtual assistant, \"How do I make a Python object immutable?\"\n", + "Python proporciona funcionalidades que hacen más fácil evitar modificar objetos.\n", + "Están fuera del alcance de este libro, pero si tienes curiosidad, pregunta a un asistente virtual: \"¿Cómo hago que un objeto de Python sea inmutable?\"\n", "\n", - "Creating a new object takes more time than modifying an existing one, but the difference seldom matters in practice.\n", - "Programs that avoid shared objects and impure functions are often easier to develop, test, and debug -- and the best kind of debugging is the kind you don't have to do." + "Crear un objeto nuevo toma más tiempo que modificar uno existente, pero la diferencia rara vez importa en la práctica.\n", + "Los programas que evitan objetos compartidos y funciones impuras suelen ser más fáciles de desarrollar, probar y depurar -- y la mejor depuración es el que no tienes que hacer." ] }, { @@ -1220,16 +1220,16 @@ "id": "02106995", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**shallow copy:**\n", - "A copy operation that does not copy nested objects.\n", + "**copia superficial:**\n", + "Una operación de copia que no copia objetos anidados.\n", "\n", - "**deep copy:**\n", - "A copy operation that also copies nested objects.\n", + "**copia profunda:**\n", + "Una operación de copia que también copia objetos anidados.\n", "\n", - "**polymorphism:**\n", - "The ability of a method or operator to work with multiple types of objects." + "**polimorfismo:**\n", + "La capacidad de un método u operador para funcionar con múltiples tipos de objetos." ] }, { @@ -1237,7 +1237,7 @@ "id": "09dd41c1", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1260,10 +1260,10 @@ "id": "da0aea86", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "For all of the following exercises, consider asking a virtual assistant for help.\n", - "If you do, you'll want include as part of the prompt the class definitions for `Point`, `Line`, and `Rectangle` -- otherwise the VA will make a guess about their attributes and functions, and the code it generates won't work." + "Para todos los ejercicios siguientes, considera pedir ayuda a un asistente virtual.\n", + "Si lo haces, querrás incluir como parte del prompt las definiciones de clase para `Point`, `Line` y `Rectangle` -- de lo contrario el AV hará una suposición sobre sus atributos y funciones, y el código que genere no funcionará." ] }, { @@ -1271,9 +1271,9 @@ "id": "7721e47b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write an `__eq__` method for the `Line` class that returns `True` if the `Line` objects refer to `Point` objects that are equivalent, in either order." + "Escribe un método `__eq__` para la clase `Line` que devuelva `True` si los objetos `Line` se refieren a objetos `Point` que son equivalentes, en cualquier orden." ] }, { @@ -1281,7 +1281,7 @@ "id": "2e488e0f", "metadata": {}, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1314,7 +1314,7 @@ "id": "3a44e45a", "metadata": {}, "source": [ - "You can use these examples to test your code." + "Puedes usar estos ejemplos para probar tu código." ] }, { @@ -1334,7 +1334,7 @@ "id": "e825f049", "metadata": {}, "source": [ - "This example should be `True` because the `Line` objects refer to `Point` objects that are equivalent, in the same order." + "Este ejemplo debería ser `True` porque los objetos `Line` se refieren a objetos `Point` que son equivalentes, en el mismo orden." ] }, { @@ -1356,7 +1356,7 @@ "tags": [] }, "source": [ - "This example should be `True` because the `Line` objects refer to `Point` objects that are equivalent, in reverse order." + "Este ejemplo debería ser `True` porque los objetos `Line` se refieren a objetos `Point` que son equivalentes, en orden inverso." ] }, { @@ -1375,7 +1375,7 @@ "id": "8c9c787b", "metadata": {}, "source": [ - "Equivalence should always be transitive -- that is, if `line_a` and `line_b` are equivalent, and `line_a` and `line_c` are equivalent, then `line_b` and `line_c` should also be equivalent." + "La equivalencia siempre debería ser transitiva -- es decir, si `line_a` y `line_b` son equivalentes, y `line_a` y `line_c` son equivalentes, entonces `line_b` y `line_c` también deberían ser equivalentes." ] }, { @@ -1393,7 +1393,7 @@ "id": "d4f385fa", "metadata": {}, "source": [ - "This example should be `False` because the `Line` objects refer to `Point` objects that are not equivalent." + "Este ejemplo debería ser `False` porque los objetos `Line` se refieren a objetos `Point` que no son equivalentes." ] }, { @@ -1412,9 +1412,9 @@ "id": "0e629491", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Line` method called `midpoint` that computes the midpoint of a line segment and returns the result as a `Point` object." + "Escribe un método de `Line` llamado `midpoint` que calcule el punto medio de un segmento de línea y devuelva el resultado como un objeto `Point`." ] }, { @@ -1422,7 +1422,7 @@ "id": "b8c52d19", "metadata": {}, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1455,7 +1455,7 @@ "id": "4df69a9f", "metadata": {}, "source": [ - "You can use the following examples to test your code and draw the result." + "Puedes usar los siguientes ejemplos para probar tu código y dibujar el resultado." ] }, { @@ -1522,9 +1522,9 @@ "id": "0518c200", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Rectangle` method called `midpoint` that find the point in the center of a rectangle and returns the result as a `Point` object." + "Escribe un método de `Rectangle` llamado `midpoint` que encuentre el punto en el centro de un rectángulo y devuelva el resultado como un objeto `Point`." ] }, { @@ -1532,7 +1532,7 @@ "id": "c586a3ed", "metadata": {}, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1565,7 +1565,7 @@ "id": "d186c84b", "metadata": {}, "source": [ - "You can use the following example to test your code." + "Puedes usar el siguiente ejemplo para probar tu código." ] }, { @@ -1618,15 +1618,15 @@ "id": "00cbc4d9", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a `Rectangle` method called `make_cross` that:\n", + "Escribe un método de `Rectangle` llamado `make_cross` que:\n", "\n", - "1. Uses `make_lines` to get a list of `Line` objects that represent the four sides of the rectangle.\n", + "1. Use `make_lines` para obtener una lista de objetos `Line` que representan los cuatro lados del rectángulo.\n", "\n", - "2. Computes the midpoints of the four lines.\n", + "2. Calcule los puntos medios de las cuatro líneas.\n", "\n", - "3. Makes and returns a list of two `Line` objects that represent lines connecting opposite midpoints, forming a cross through the middle of the rectangle." + "3. Cree y devuelva una lista de dos objetos `Line` que representan líneas que conectan puntos medios opuestos, formando una cruz por el centro del rectángulo." ] }, { @@ -1634,7 +1634,7 @@ "id": "29e994c6", "metadata": {}, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar." ] }, { @@ -1667,7 +1667,7 @@ "id": "970fcbca", "metadata": {}, "source": [ - "You can use the following example to test your code." + "Puedes usar el siguiente ejemplo para probar tu código." ] }, { @@ -1710,10 +1710,10 @@ "id": "0f707fe3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a definition for a class named `Circle` with attributes `center` and `radius`, where `center` is a Point object and `radius` is a number.\n", - "Include special methods `__init__` and a `__str__`, and a method called `draw` that uses `jupyturtle` functions to draw the circle." + "Escribe una definición para una clase llamada `Circle` con atributos `center` y `radius`, donde `center` es un objeto Point y `radius` es un número.\n", + "Incluye los métodos especiales `__init__` y `__str__`, y un método llamado `draw` que use funciones de `jupyturtle` para dibujar el círculo." ] }, { @@ -1721,7 +1721,7 @@ "id": "cb1b24a3", "metadata": {}, "source": [ - "You can use the following function, which is a version of the `circle` function we wrote in Chapter 4." + "Puedes usar la siguiente función, que es una versión de la función `circle` que escribimos en el Capítulo 4." ] }, { @@ -1760,8 +1760,8 @@ "id": "b4325143", "metadata": {}, "source": [ - "You can use the following example to test your code.\n", - "We'll start with a square `Rectangle` with width and height `100`." + "Puedes usar el siguiente ejemplo para probar tu código.\n", + "Empezaremos con un `Rectangle` cuadrado con `width` y `height` `100`." ] }, { @@ -1780,7 +1780,7 @@ "id": "2cdecfa9", "metadata": {}, "source": [ - "The following code should create a `Circle` that fits inside the square." + "El siguiente código debería crear un `Circle` que encaje dentro del cuadrado." ] }, { @@ -1802,7 +1802,7 @@ "id": "37e94d98", "metadata": {}, "source": [ - "If everything worked correctly, the following code should draw the circle inside the square (touching on all four sides)." + "Si todo funcionó correctamente, el siguiente código debería dibujar el círculo dentro del cuadrado (tocando los cuatro lados)." ] }, { @@ -1825,13 +1825,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -1857,4 +1859,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/chap17.ipynb b/chapters/chap17.ipynb index c26b8b7..e16bc63 100644 --- a/chapters/chap17.ipynb +++ b/chapters/chap17.ipynb @@ -5,8 +5,8 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", + "Puedes pedir las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." ] }, @@ -43,12 +43,12 @@ "tags": [] }, "source": [ - "# Inheritance\n", + "# Herencia\n", "\n", - "The language feature most often associated with object-oriented programming is **inheritance**.\n", - "Inheritance is the ability to define a new class that is a modified version of an existing class.\n", - "In this chapter I demonstrate inheritance using classes that represent playing cards, decks of cards, and poker hands.\n", - "If you don't play poker, don't worry -- I'll tell you what you need to know." + "La característica del lenguaje que más a menudo se asocia con la programación orientada a objetos es la **herencia**.\n", + "La herencia es la capacidad de definir una nueva clase que es una versión modificada de una clase existente.\n", + "En este capítulo demuestro la herencia usando clases que representan cartas de juego, barajas de cartas y manos de póker.\n", + "Si no juegas al póker, no te preocupes: te diré lo que necesitas saber." ] }, { @@ -56,21 +56,21 @@ "id": "b19c4dae", "metadata": {}, "source": [ - "## Representing cards\n", + "## Representar cartas\n", "\n", - "There are 52 playing cards in a standard deck -- each of them belongs to one of four suits and one of thirteen ranks. \n", - "The suits are Spades, Hearts, Diamonds, and Clubs.\n", - "The ranks are Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, and King.\n", - "Depending on which game you are playing, an Ace can be higher than King or lower than 2.\n", + "Hay 52 cartas en una baraja estándar; cada una pertenece a uno de cuatro palos y a uno de trece rangos.\n", + "Los palos son Spades, Hearts, Diamonds y Clubs.\n", + "Los rangos son Ace, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen y King.\n", + "Dependiendo del juego al que estés jugando, un Ace puede ser más alto que King o más bajo que 2.\n", "\n", - "If we want to define a new object to represent a playing card, it is obvious what the attributes should be: `rank` and `suit`.\n", - "It is less obvious what type the attributes should be.\n", - "One possibility is to use strings like `'Spade'` for suits and `'Queen'` for ranks.\n", - "A problem with this implementation is that it would not be easy to compare cards to see which had a higher rank or suit.\n", + "Si queremos definir un nuevo objeto para representar una carta, es obvio cuáles deberían ser los atributos: `rank` y `suit`.\n", + "Es menos obvio qué tipo deberían tener los atributos.\n", + "Una posibilidad es usar strings como `'Spade'` para los palos y `'Queen'` para los rangos.\n", + "Un problema con esta implementación es que no sería fácil comparar cartas para ver cuál tiene un rango o palo más alto.\n", "\n", - "An alternative is to use integers to **encode** the ranks and suits.\n", - "In this context, \"encode\" means that we are going to define a mapping between numbers and suits, or between numbers and ranks.\n", - "This kind of encoding is not meant to be a secret (that would be \"encryption\")." + "Una alternativa es usar enteros para **codificar** los rangos y los palos.\n", + "En este contexto, \"codificar\" significa que vamos a definir una correspondencia entre números y palos, o entre números y rangos.\n", + "Este tipo de codificación no pretende ser secreta (eso sería \"cifrado\")." ] }, { @@ -78,17 +78,17 @@ "id": "a9bafecf", "metadata": {}, "source": [ - "For example, this table shows the suits and the corresponding integer codes:\n", + "Por ejemplo, esta tabla muestra los palos y los códigos enteros correspondientes:\n", "\n", "\n", - "| Suit | Code |\n", + "| Palo | Código |\n", "| --- | --- |\n", "| Spades | 3 |\n", "| Hearts | 2 |\n", "| Diamonds | 1 |\n", "| Clubs | 0 |\n", "\n", - "With this encoding, we can compare suits by comparing their codes." + "Con esta codificación, podemos comparar palos comparando sus códigos." ] }, { @@ -96,21 +96,21 @@ "id": "a1b46b1a", "metadata": {}, "source": [ - "To encode the ranks, we'll use the integer `2` to represent the rank `2`, `3` to represent `3`, and so on up to `10`.\n", - "The following table shows the codes for the face cards.\n", + "Para codificar los rangos, usaremos el entero `2` para representar el rango `2`, `3` para representar `3`, y así sucesivamente hasta `10`.\n", + "La siguiente tabla muestra los códigos para las figuras.\n", "\n", " \n", - "| Rank | Code |\n", + "| Rango | Código |\n", "| --- | --- |\n", "| Jack | 11 |\n", "| Queen | 12 |\n", "| King | 13 |\n", "\n", - "And we can use either `1` or `14` to represent an Ace, depending on whether we want it to be considered lower or higher than the other ranks.\n", + "Y podemos usar `1` o `14` para representar un Ace, dependiendo de si queremos que se considere más bajo o más alto que los demás rangos.\n", "\n", - "To represent these encodings, we will use two lists of strings, one with the names of the suits and the other with the names of the ranks.\n", + "Para representar estas codificaciones, usaremos dos listas de strings, una con los nombres de los palos y otra con los nombres de los rangos.\n", "\n", - "Here's a definition for a class that represents a playing card, with these lists of strings as **class variables**, which are variables defined inside a class definition, but not inside a method." + "Aquí tienes una definición de una clase que representa una carta, con estas listas de strings como **variables de clase**, que son variables definidas dentro de una definición de clase, pero no dentro de un método." ] }, { @@ -133,9 +133,9 @@ "id": "d63f798a", "metadata": {}, "source": [ - "The first element of `rank_names` is `None` because there is no card with rank zero. By including `None` as a place-keeper, we get a list with the nice property that the index `2` maps to the string `'2'`, and so on.\n", + "El primer elemento de `rank_names` es `None` porque no hay ninguna carta con rango cero. Al incluir `None` como marcador de posición, obtenemos una lista con la práctica propiedad de que el índice `2` se corresponde con el string `'2'`, y así sucesivamente.\n", "\n", - "Class variables are associated with the class, rather than an instance of the class, so we can access them like this." + "Las variables de clase están asociadas con la clase, en lugar de con una instancia de la clase, así que podemos acceder a ellas de esta forma." ] }, { @@ -153,7 +153,7 @@ "id": "c837fff6", "metadata": {}, "source": [ - "We can use `suit_names` to look up a suit and get the corresponding string." + "Podemos usar `suit_names` para buscar un palo y obtener el string correspondiente." ] }, { @@ -171,7 +171,7 @@ "id": "a59d905e", "metadata": {}, "source": [ - "And `rank_names` to look up a rank." + "Y `rank_names` para buscar un rango." ] }, { @@ -189,9 +189,9 @@ "id": "50dda19b", "metadata": {}, "source": [ - "## Card attributes\n", + "## Atributos de las cartas\n", "\n", - "Here's an `__init__` method for the `Card` class -- it takes `suit` and `rank` as parameters and assigns them to attributes with the same names." + "Aquí tienes un método `__init__` para la clase `Card`: toma `suit` y `rank` como parámetros y los asigna a atributos con los mismos nombres." ] }, { @@ -213,7 +213,7 @@ "id": "31a2782d", "metadata": {}, "source": [ - "Now we can create a `Card` object like this." + "Ahora podemos crear un objeto `Card` así." ] }, { @@ -231,7 +231,7 @@ "id": "85e5cf5d", "metadata": {}, "source": [ - "We can use the new instance to access the attributes." + "Podemos usar la nueva instancia para acceder a los atributos." ] }, { @@ -249,7 +249,7 @@ "id": "449225d3", "metadata": {}, "source": [ - "It is also legal to use the instance to access the class variables." + "También es válido usar la instancia para acceder a las variables de clase." ] }, { @@ -267,7 +267,7 @@ "id": "97232ffa", "metadata": {}, "source": [ - "But if you use the class, it is clearer that they are class variables, not attributes." + "Pero si usas la clase, queda más claro que son variables de clase, no atributos." ] }, { @@ -275,9 +275,9 @@ "id": "7a0a79ae", "metadata": {}, "source": [ - "## Printing cards\n", + "## Imprimir cartas\n", "\n", - "Here's a `__str__` method for `Card` objects." + "Aquí tienes un método `__str__` para objetos `Card`." ] }, { @@ -300,7 +300,7 @@ "id": "d6c51352", "metadata": {}, "source": [ - "When we print a `Card`, Python calls the `__str__` method to get a human-readable representation of the card." + "Cuando imprimimos una `Card`, Python llama al método `__str__` para obtener una representación de la carta legible para humanos." ] }, { @@ -318,10 +318,10 @@ "id": "76044b9e", "metadata": {}, "source": [ - "The following is a diagram of the `Card` class object and the Card instance.\n", - "`Card` is a class object, so its type is `type`.\n", - "`queen` is an instance of `Card`, so its type is `Card`.\n", - "To save space, I didn't draw the contents of `suit_names` and `rank_names`." + "El siguiente es un diagrama del objeto de clase `Card` y de la instancia de Carta.\n", + "`Card` es un objeto de clase, así que su tipo es `type`.\n", + "`queen` es una instancia de `Card`, así que su tipo es `Card`.\n", + "Para ahorrar espacio, no dibujé el contenido de `suit_names` y `rank_names`." ] }, { @@ -380,7 +380,7 @@ "id": "ccb8e41d", "metadata": {}, "source": [ - "Every `Card` instance has its own `suit` and `rank` attributes, but there is only one `Card` class object, and only one copy of the class variables `suit_names` and `rank_names`." + "Cada instancia de `Card` tiene sus propios atributos `suit` y `rank`, pero solo hay un objeto de clase `Card` y una sola copia de las variables de clase `suit_names` y `rank_names`." ] }, { @@ -388,9 +388,9 @@ "id": "98c6508d", "metadata": {}, "source": [ - "## Comparing cards\n", + "## Comparar cartas\n", "\n", - "Suppose we create a second `Card` object with the same suit and rank." + "Supongamos que creamos un segundo objeto `Card` con el mismo palo y rango." ] }, { @@ -409,7 +409,7 @@ "id": "3c92779c", "metadata": {}, "source": [ - "If we use the `==` operator to compare them, it checks whether `queen` and `queen2` refer to the same object." + "Si usamos el operador `==` para compararlas, comprueba si `queen` y `queen2` hacen referencia al mismo objeto." ] }, { @@ -427,8 +427,8 @@ "id": "278d8abe", "metadata": {}, "source": [ - "They don't, so it returns `False`.\n", - "We can change this behavior by defining the special method `__eq__`." + "No lo hacen, así que devuelve `False`.\n", + "Podemos cambiar este comportamiento definiendo el special método `__eq__`." ] }, { @@ -449,10 +449,10 @@ "id": "bd66a9d3", "metadata": {}, "source": [ - "`__eq__` takes two `Card` objects as parameters and returns `True` if they have the same suit and rank, even if they are not the same object.\n", - "In other words, it checks whether they are equivalent, even if they are not identical.\n", + "`__eq__` toma dos objetos `Card` como parámetros y devuelve `True` si tienen el mismo palo y rango, incluso si no son el mismo objeto.\n", + "En otras palabras, comprueba si son equivalentes, aunque no sean idénticos.\n", "\n", - "When we use the `==` operator with `Card` objects, Python calls the `__eq__` method." + "Cuando usamos el operador `==` con objetos `Card`, Python llama al método `__eq__`." ] }, { @@ -470,7 +470,7 @@ "id": "23d99d3e", "metadata": {}, "source": [ - "As a second test, let's create a card with the same suit and a different rank." + "Como segunda prueba, vamos a crear una carta con el mismo palo y un rango diferente." ] }, { @@ -489,7 +489,7 @@ "id": "c5f66404", "metadata": {}, "source": [ - "We can confirm that `queen` and `six` are not equivalent." + "Podemos confirmar que `queen` y `six` no son equivalentes." ] }, { @@ -507,8 +507,8 @@ "id": "1dcb561f", "metadata": {}, "source": [ - "If we use the `!=` operator, Python invokes a special method called `__ne__`, if it exists.\n", - "Otherwise it invokes`__eq__` and inverts the result -- so if `__eq__` returns `True`, the result of the `!=` operator is `False`." + "Si usamos el operador `!=`, Python invoca un special método llamado `__ne__`, si existe.\n", + "De lo contrario, invoca `__eq__` e invierte el resultado; así que si `__eq__` devuelve `True`, el resultado del operador `!=` es `False`." ] }, { @@ -536,8 +536,8 @@ "id": "77c48464", "metadata": {}, "source": [ - "Now suppose we want to compare two cards to see which is bigger.\n", - "If we use one of the relational operators, we get a `TypeError`." + "Ahora supongamos que queremos comparar dos cartas para ver cuál es mayor.\n", + "Si usamos uno de los operadores relacionales, obtenemos un `TypeError`." ] }, { @@ -559,11 +559,11 @@ "id": "4db0ad52", "metadata": {}, "source": [ - "To change the behavior of the `<` operator, we can define a special method called `__lt__`, which is short for \"less than\".\n", - "For the sake of this example, let's assume that suit is more important than rank -- so all Spades outrank all Hearts, which outrank all Diamonds, and so on.\n", - "If two cards have the same suit, the one with the higher rank wins.\n", + "Para cambiar el comportamiento del operador `<`, podemos definir un special método llamado `__lt__`, abreviatura de \"less than\".\n", + "Para este ejemplo, supongamos que el palo es más importante que el rango: por eso todos los Spades superan a todos los Hearts, que superan a todos los Diamonds, y así sucesivamente.\n", + "Si dos cartas tienen el mismo palo, gana la que tiene el rango más alto.\n", "\n", - "To implement this logic, we'll use the following method, which returns a tuple containing a card's suit and rank, in that order." + "Para implementar esta lógica, usaremos el siguiente método, que devuelve una tupla que contiene el palo y el rango de una carta, en ese orden." ] }, { @@ -584,7 +584,7 @@ "id": "d5062348", "metadata": {}, "source": [ - "We can use this method to write `__lt__`." + "Podemos usar este método para escribir `__lt__`." ] }, { @@ -605,10 +605,10 @@ "id": "bd9ef8f5", "metadata": {}, "source": [ - "Tuple comparison compares the first elements from each tuple, which represent the suits.\n", - "If they are the same, it compares the second elements, which represent the ranks.\n", + "La comparación de tuplas compara los primeros elementos de cada tupla, que representan los palos.\n", + "Si son iguales, compara los segundos elementos, que representan los rangos.\n", "\n", - "Now if we use the `<` operator, it invokes the `__lt__` method." + "Ahora, si usamos el operador `<`, invoca el método `__lt__`." ] }, { @@ -626,8 +626,8 @@ "id": "83289a77", "metadata": {}, "source": [ - "If we use the `>` operator, it invokes a special method called `__gt__`, if it exists.\n", - "Otherwise it invokes `__lt__` with the arguments in the opposite order." + "Si usamos el operador `>`, invoca un special método llamado `__gt__`, si existe.\n", + "De lo contrario, invoca `__lt__` con los argumentos en el orden opuesto." ] }, { @@ -655,7 +655,7 @@ "id": "5d0a91de", "metadata": {}, "source": [ - "Finally, if we use the `<=` operator, it invokes a special method called `__le__`." + "Por último, si usamos el operador `<=`, invoca un special método llamado `__le__`." ] }, { @@ -676,7 +676,7 @@ "id": "6c85ac69", "metadata": {}, "source": [ - "So we can check whether one card is less than or equal to another." + "Así que podemos comprobar si una carta es menor o igual que otra." ] }, { @@ -704,7 +704,7 @@ "id": "7af7b289", "metadata": {}, "source": [ - "If we use the `>=` operator, it uses `__ge__` if it exists. Otherwise, it invokes `__le__` with the arguments in the opposite order." + "Si usamos el operador `>=`, usa `__ge__` si existe. De lo contrario, invoca `__le__` con los argumentos en el orden opuesto." ] }, { @@ -722,9 +722,9 @@ "id": "fe2a81cc", "metadata": {}, "source": [ - "As we have defined them, these methods are complete in the sense that we can compare any two `Card` objects, and consistent in the sense that results from different operators don't contradict each other.\n", - "With these two properties, we can say that `Card` objects are **totally ordered**.\n", - "And that means, as we'll see soon, that they can be sorted." + "Tal como los hemos definido, estos métodos son completos en el sentido de que podemos comparar dos objetos `Card` cualesquiera, y consistentes en el sentido de que los resultados de distintos operadores no se contradicen entre sí.\n", + "Con estas dos propiedades, podemos decir que los objetos `Card` están **totalmente ordenados**.\n", + "Y eso significa, como veremos pronto, que se pueden ordenar." ] }, { @@ -732,11 +732,10 @@ "id": "199f8bfc", "metadata": {}, "source": [ - "## Decks\n", + "## Barajas\n", "\n", - "Now that we have objects that represent cards, let's define objects that represent decks.\n", - "The following is a class definition for `Deck` with\n", - "an `__init__` method takes a list of `Card` objects as a parameter and assigns it to an attribute called `cards`." + "Ahora que tenemos objetos que representan cartas, definamos objetos que representen barajas.\n", + "La siguiente es una definición de clase para `Deck` con un método `__init__` que toma una lista de objetos `Card` como parámetro y la asigna a un atributo llamado `cards`." ] }, { @@ -757,7 +756,7 @@ "id": "2d529789", "metadata": {}, "source": [ - "To create a list that contains the 52 cards in a standard deck, we'll use the following static method." + "Para crear una lista que contiene las 52 cartas de una baraja estándar, usaremos el siguiente método estático." ] }, { @@ -783,11 +782,11 @@ "id": "47ae8f71", "metadata": {}, "source": [ - "In `make_cards`, the outer loop enumerates the suits from `0` to `3`.\n", - "The inner loop enumerates the ranks from `2` to `14` -- where `14` represents an Ace that outranks a King.\n", - "Each iteration creates a new `Card` with the current suit and rank, and appends it to `cards`.\n", + "En `make_cards`, el bucle externo enumera los palos de `0` a `3`.\n", + "El bucle interno enumera los rangos de `2` a `14`, donde `14` representa un Ace que supera a un King.\n", + "Cada iteración crea una nueva `Card` con el palo y el rango actuales, y la añade a `cards`.\n", "\n", - "Here's how we make a list of cards and a `Deck` object that contains it." + "Así es como creamos una lista de cartas y un objeto `Deck` que la contiene." ] }, { @@ -807,7 +806,7 @@ "id": "032ec302", "metadata": {}, "source": [ - "It contains 52 cards, as intended." + "Contiene 52 cartas, tal como queríamos." ] }, { @@ -817,9 +816,9 @@ "tags": [] }, "source": [ - "## Printing the deck\n", + "## Imprimir la baraja\n", "\n", - "Here is a `__str__` method for `Deck`." + "Aquí tienes un método `__str__` para `Deck`." ] }, { @@ -843,9 +842,9 @@ "id": "660f18e6", "metadata": {}, "source": [ - "This method demonstrates an efficient way to accumulate a large string -- building a list of strings and then using the string method `join`. \n", + "Este método demuestra una forma eficiente de acumular un string grande: construir una lista de strings y luego usar el método de string `join`.\n", "\n", - "We'll test this method with a deck that only contains two cards." + "Probaremos este método con una baraja que solo contiene dos cartas." ] }, { @@ -863,7 +862,7 @@ "id": "91c7145f", "metadata": {}, "source": [ - "If we call `str`, it invokes `__str__`." + "Si llamamos a `str`, invoca `__str__`." ] }, { @@ -881,9 +880,9 @@ "id": "00270656", "metadata": {}, "source": [ - "When Jupyter displays a string, it shows the \"representational\" form of the string, which represents a newline with the sequence `\\n`.\n", + "Cuando Jupyter muestra un string, enseña la forma \"representacional\" del string, que representa un salto de línea con la secuencia `\\n`.\n", "\n", - "However, if we print the result, Jupyter shows the \"printable\" form of the string, which prints the newline as whitespace." + "Sin embargo, si imprimimos el resultado, Jupyter muestra la forma \"imprimible\" del string, que imprime el salto de línea como espacio en blanco." ] }, { @@ -901,7 +900,7 @@ "id": "e97810c4", "metadata": {}, "source": [ - "So the cards appear on separate lines." + "Así que las cartas aparecen en líneas separadas." ] }, { @@ -909,11 +908,11 @@ "id": "52d3d597", "metadata": {}, "source": [ - "## Add, remove, shuffle and sort\n", + "## Añadir, quitar, barajar y ordenar\n", "\n", - "To deal cards, we would like a method that removes a card from the deck\n", - "and returns it. The list method `pop` provides a convenient way to do\n", - "that." + "Para repartir cartas, nos gustaría tener un método que quite una carta de la baraja\n", + "y la devuelva. El método de lista `pop` proporciona una forma cómoda de\n", + "hacerlo." ] }, { @@ -934,7 +933,7 @@ "id": "1fcef47b", "metadata": {}, "source": [ - "Here's how we use it." + "Así es como lo usamos." ] }, { @@ -953,7 +952,7 @@ "id": "65427954", "metadata": {}, "source": [ - "We can confirm that there are `51` cards left in the deck." + "Podemos confirmar que quedan `51` cartas en la baraja." ] }, { @@ -971,7 +970,7 @@ "id": "7ca3614e", "metadata": {}, "source": [ - "To add a card, we can use the list method `append`." + "Para añadir una carta, podemos usar el método de lista `append`." ] }, { @@ -992,7 +991,7 @@ "id": "2ecd8703", "metadata": {}, "source": [ - "As an example, we can put back the card we just popped." + "Como ejemplo, podemos volver a poner la carta que acabamos de extraer." ] }, { @@ -1011,7 +1010,7 @@ "id": "8b5af8ce", "metadata": {}, "source": [ - "To shuffle the deck, we can use the `shuffle` function from the `random` module:" + "Para barajar la baraja, podemos usar la función `shuffle` del module `random`:" ] }, { @@ -1057,7 +1056,7 @@ "id": "a8cb1a7f", "metadata": {}, "source": [ - "If we shuffle the deck and print the first few cards, we can see that they are in no apparent order." + "Si barajamos la baraja e imprimimos las primeras cartas, podemos ver que no están en ningún orden aparente." ] }, { @@ -1077,7 +1076,7 @@ "id": "a198dde3", "metadata": {}, "source": [ - "To sort the cards, we can use the list method `sort`, which sorts the elements \"in place\" -- that is, it modifies the list rather than creating a new list." + "Para ordenar las cartas, podemos usar el método de lista `sort`, que ordena los elementos \"in place\"; es decir, modifica la lista en lugar de crear una lista nueva." ] }, { @@ -1098,7 +1097,7 @@ "id": "d4f017c7", "metadata": {}, "source": [ - "When we invoke `sort`, it uses the `__lt__` method to compare cards." + "Cuando invocamos `sort`, usa el método `__lt__` para comparar cartas." ] }, { @@ -1116,7 +1115,7 @@ "id": "2bb966fd", "metadata": {}, "source": [ - "If we print the first few cards, we can confirm that they are in increasing order." + "Si imprimimos las primeras cartas, podemos confirmar que están en orden creciente." ] }, { @@ -1135,8 +1134,8 @@ "id": "5c41ce4d", "metadata": {}, "source": [ - "In this example, `Deck.sort` doesn't do anything other than invoke `list.sort`.\n", - "Passing along responsibility like this is called **delegation**." + "En este ejemplo, `Deck.sort` no hace nada más que invocar `list.sort`.\n", + "Pasar la responsabilidad de esta forma se llama **delegación**." ] }, { @@ -1144,18 +1143,18 @@ "id": "0502961b", "metadata": {}, "source": [ - "## Parents and children\n", + "## Padres e hijos\n", "\n", - "Inheritance is the ability to define a new class that is a modified version of an existing class.\n", - "As an example, let's say we want a class to represent a \"hand\", that is, the cards held by one player.\n", + "La herencia es la capacidad de definir una nueva clase que es una versión modificada de una clase existente.\n", + "Como ejemplo, digamos que queremos una clase para representar una \"mano\", es decir, las cartas que tiene un jugador.\n", "\n", - "* A hand is similar to a deck -- both are made up of a collection of cards, and both require operations like adding and removing cards.\n", + "* Una mano es similar a una baraja: ambas están formadas por una colección de cartas, y ambas requieren operaciones como añadir y quitar cartas.\n", "\n", - "* A hand is also different from a deck -- there are operations we want for hands that don't make sense for a deck. For example, in poker we might compare two hands to see which one wins. In bridge, we might compute a score for a hand in order to make a bid.\n", + "* Una mano también es diferente de una baraja: hay operaciones que queremos para manos que no tienen sentido para una baraja. Por ejemplo, en póker podríamos comparar dos manos para ver cuál gana. En bridge, podríamos calcular la puntuación de una mano para hacer una apuesta.\n", "\n", - "This relationship between classes -- where one is a specialized version of another -- lends itself to inheritance. \n", + "Esta relación entre clases, donde una es una versión especializada de otra, se presta a la herencia.\n", "\n", - "To define a new class that is based on an existing class, we put the name of the existing class in parentheses." + "Para definir una nueva clase basada en una clase existente, ponemos el nombre de la clase existente entre paréntesis." ] }, { @@ -1174,9 +1173,9 @@ "id": "339295cd", "metadata": {}, "source": [ - "This definition indicates that `Hand` inherits from `Deck`, which means that `Hand` objects can access methods defined in `Deck`, like `take_card` and `put_card`.\n", + "Esta definición indica que `Hand` hereda de `Deck`, lo que significa que los objetos `Hand` pueden acceder a métodos definidos en `Deck`, como `take_card` y `put_card`.\n", "\n", - "`Hand` also inherits `__init__` from `Deck`, but if we define `__init__` in the `Hand` class, it overrides the one in the `Deck` class." + "`Hand` también hereda `__init__` de `Deck`, pero si definimos `__init__` en la clase `Hand`, sobrescribe el de la clase `Deck`." ] }, { @@ -1198,8 +1197,8 @@ "id": "9b6a763a", "metadata": {}, "source": [ - "This version of `__init__` takes an optional string as a parameter, and always starts with an empty list of cards.\n", - "When we create a `Hand`, Python invokes this method, not the one in `Deck` -- which we can confirm by checking that the result has a `label` attribute." + "Esta versión de `__init__` toma un string opcional como parámetro y siempre empieza con una lista vacía de cartas.\n", + "Cuando creamos una `Hand`, Python invoca este método, no el de `Deck`, lo que podemos confirmar comprobando que el resultado tiene un atributo `label`." ] }, { @@ -1218,7 +1217,7 @@ "id": "b1e2a67d", "metadata": {}, "source": [ - "To deal a card, we can use `take_card` to remove a card from a `Deck`, and `put_card` to add the card to a `Hand`." + "Para repartir una carta, podemos usar `take_card` para quitar una carta de un `Deck`, y `put_card` para añadir la carta a una `Hand`." ] }, { @@ -1239,7 +1238,7 @@ "id": "dc2ce06b", "metadata": {}, "source": [ - "Let's encapsulate this code in a `Deck` method called `move_cards`." + "Encapsulemos este código en un método de `Deck` llamado `move_cards`." ] }, { @@ -1262,8 +1261,8 @@ "id": "16e6c404", "metadata": {}, "source": [ - "This method is polymorphic -- that is, it works with more than one type: `self` and `other` can be either a `Hand` or a `Deck`.\n", - "So we can use this method to deal a card from `Deck` to a `Hand`, from one `Hand` to another, or from a `Hand` back to a `Deck`." + "Este método es polimórfico; es decir, funciona con más de un tipo: `self` y `other` pueden ser tanto una `Hand` como un `Deck`.\n", + "Así que podemos usar este método para repartir una carta de `Deck` a `Hand`, de una `Hand` a otra, o de una `Hand` de vuelta a un `Deck`." ] }, { @@ -1271,18 +1270,18 @@ "id": "e648a722", "metadata": {}, "source": [ - "When a new class inherits from an existing one, the existing one is called the **parent** and the new class is called the **child**. In general:\n", + "Cuando una nueva clase hereda de una existente, la existente se llama **padre** y la nueva clase se llama **hija**. En general:\n", "\n", - "* Instances of the child class should have all of the attributes of the parent class, but they can have additional attributes.\n", + "* Las instancias de la clase hija deberían tener todos los atributos de la clase padre, pero pueden tener atributos adicionales.\n", "\n", - "* The child class should have all of the methods of the parent class, but it can have additional methods.\n", + "* La clase hija debería tener todos los métodos de la clase padre, pero puede tener métodos adicionales.\n", "\n", - "* If a child class overrides a method from the parent class, the new method should take the same parameters and return a compatible result.\n", + "* Si una clase hija sobrescribe un método de la clase padre, el nuevo método debería tomar los mismos parámetros y devolver un resultado compatible.\n", "\n", - "This set of rules is called the \"Liskov substitution principle\" after computer scientist Barbara Liskov.\n", + "Este conjunto de reglas se llama \"principio de sustitución de Liskov\", en honor a la científica de la computación Barbara Liskov.\n", "\n", - "If you follow these rules, any function or method designed to work with an instance of a parent class, like a `Deck`, will also work with instances of a child class, like `Hand`.\n", - "If you violate these rules, your code will collapse like a house of cards (sorry)." + "Si sigues estas reglas, cualquier función o método diseñado para trabajar con una instancia de una clase padre, como un `Deck`, también funcionará con instancias de una clase hija, como `Hand`.\n", + "Si rompes estas reglas, tu código se derrumbará como un castillo de naipes (lo siento)." ] }, { @@ -1290,12 +1289,12 @@ "id": "e80873dd", "metadata": {}, "source": [ - "## Specialization\n", + "## Especialización\n", "\n", - "Let's make a class called `BridgeHand` that represents a hand in bridge -- a widely played card game.\n", - "We'll inherit from `Hand` and add a new method called `high_card_point_count` that evaluates a hand using a \"high card point\" method, which adds up points for the high cards in the hand.\n", + "Hagamos una clase llamada `BridgeHand` que representa una mano en bridge, un juego de cartas muy popular.\n", + "Heredaremos de `Hand` y añadiremos un nuevo método llamado `high_card_point_count` que evalúa una mano usando un método de \"high carta point\", que suma puntos por las cartas altas de la mano.\n", "\n", - "Here's a class definition that contains as a class variable a dictionary that maps from card names to their point values." + "Aquí tienes una definición de clase que contiene, como variable de clase, un diccionario que asigna nombres de cartas a sus valores de puntos." ] }, { @@ -1321,7 +1320,7 @@ "id": "4c038717", "metadata": {}, "source": [ - "Given the rank of a card, like `12`, we can use `Card.rank_names` to get the string representation of the rank, and then use `hcp_dict` to get its score." + "Dado el rango de una carta, como `12`, podemos usar `Card.rank_names` para obtener la representación en string del rango, y luego usar `hcp_dict` para obtener su puntuación." ] }, { @@ -1342,7 +1341,7 @@ "id": "c3a7820d", "metadata": {}, "source": [ - "The following method loops through the cards in a `BridgeHand` and adds up their scores." + "El siguiente método recorre las cartas de una `BridgeHand` y suma sus puntuaciones." ] }, { @@ -1384,7 +1383,7 @@ "id": "94535d8e", "metadata": {}, "source": [ - "To test it, we'll deal a hand with five cards -- a bridge hand usually has thirteen, but it's easier to test code with small examples." + "Para probarlo, repartiremos una mano con cinco cartas; una mano de bridge normalmente tiene trece, pero es más fácil probar código con ejemplos pequeños." ] }, { @@ -1406,7 +1405,7 @@ "id": "a1bd2521", "metadata": {}, "source": [ - "And here is the total score for the King and Queen." + "Y aquí está la puntuación total para el King y la Queen." ] }, { @@ -1424,8 +1423,8 @@ "id": "b4f5e107", "metadata": {}, "source": [ - "`BridgeHand` inherits the variables and methods of `Hand` and adds a class variable and a method that are specific to bridge.\n", - "This way of using inheritance is called **specialization** because it defines a new class that is specialized for a particular use, like playing bridge." + "`BridgeHand` hereda las variables y métodos de `Hand` y añade una variable de clase y un método que son específicos de bridge.\n", + "Esta forma de usar la herencia se llama **especialización** porque define una nueva clase especializada para un uso particular, como jugar al bridge." ] }, { @@ -1433,20 +1432,20 @@ "id": "b493622d", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "Inheritance is a useful feature.\n", - "Some programs that would be repetitive without inheritance can be written more concisely with it.\n", - "Also, inheritance can facilitate code reuse, since you can customize the behavior of a parent class without having to modify it.\n", - "In some cases, the inheritance structure reflects the natural structure of the problem, which makes the design easier to understand.\n", + "La herencia es una característica útil.\n", + "Algunos programas que serían repetitivos sin herencia se pueden escribir de forma más concisa con ella.\n", + "Además, la herencia puede facilitar la reutilización de código, ya que puedes personalizar el comportamiento de una clase padre sin tener que modificarla.\n", + "En algunos casos, la estructura de herencia refleja la estructura natural del problema, lo que hace que el diseño sea más fácil de entender.\n", "\n", - "On the other hand, inheritance can make programs difficult to read.\n", - "When a method is invoked, it is sometimes not clear where to find its definition -- the relevant code may be spread across several modules.\n", + "Por otro lado, la herencia puede hacer que los programas sean difíciles de leer.\n", + "Cuando se invoca un método, a veces no está claro dónde encontrar su definición: el código relevante puede estar repartido entre varios modules.\n", "\n", - "Any time you are unsure about the flow of execution through your program, the simplest solution is to add print statements at the beginning of the relevant methods.\n", - "If `Deck.shuffle` prints a message that says something like `Running Deck.shuffle`, then as the program runs it traces the flow of execution.\n", + "Siempre que tengas dudas sobre el flujo de ejecución de tu programa, la solución más sencilla es añadir sentencias print al principio de los métodos relevantes.\n", + "Si `Deck.shuffle` imprime un mensaje que dice algo como `Running Deck.shuffle`, entonces, a medida que el programa se ejecuta, traza el flujo de ejecución.\n", "\n", - "As an alternative, you could use the following function, which takes an object and a method name (as a string) and returns the class that provides the definition of the method." + "Como alternativa, podrías usar la siguiente función, que toma un objeto y el nombre de un método (como string) y devuelve la clase que proporciona la definición del método." ] }, { @@ -1469,10 +1468,10 @@ "id": "1ee8f2da", "metadata": {}, "source": [ - "`find_defining_class` uses the `mro` method to get the list of class objects (types) that will be searched for methods.\n", - "\"MRO\" stands for \"method resolution order\", which is the sequence of classes Python searches to \"resolve\" a method name -- that is, to find the function object the name refers to.\n", + "`find_defining_class` usa el método `mro` para obtener la lista de objetos clase (tipos) que se buscarán para encontrar métodos.\n", + "\"MRO\" significa \"método resolution order\", que es la secuencia de clases que Python busca para \"resolver\" el nombre de un método; es decir, para encontrar el objeto función al que se refiere el nombre.\n", "\n", - "As an example, let's instantiate a `BridgeHand` and then find the defining class of `shuffle`." + "Como ejemplo, vamos a instanciar una `BridgeHand` y luego encontrar la clase que define `shuffle`." ] }, { @@ -1491,7 +1490,7 @@ "id": "eeb70a14", "metadata": {}, "source": [ - "The `shuffle` method for the `BridgeHand` object is the one in `Deck`." + "El método `shuffle` para el objeto `BridgeHand` es el que está en `Deck`." ] }, { @@ -1499,31 +1498,31 @@ "id": "07f4c4bb", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**inheritance:**\n", - " The ability to define a new class that is a modified version of a previously defined class.\n", + "**herencia (herencia):**\n", + " La capacidad de definir una nueva clase que es una versión modificada de una clase definida previamente.\n", "\n", - "**encode:**\n", - " To represent one set of values using another set of values by constructing a mapping between them.\n", + "**codificar (encode):**\n", + " Representar un conjunto de valores usando otro conjunto de valores construyendo una correspondencia entre ellos.\n", "\n", - "**class variable:**\n", - "A variable defined inside a class definition, but not inside any method.\n", + "**variable de clase:**\n", + "Una variable definida dentro de una definición de clase, pero no dentro de ningún método.\n", "\n", - "**totally ordered:**\n", - "A set of objects is totally ordered if we can compare any two elements and the results are consistent.\n", + "**totalmente ordenado:**\n", + "Un conjunto de objetos está totalmente ordenado si podemos comparar dos elementos cualesquiera y los resultados son consistentes.\n", "\n", - "**delegation:**\n", - "When one method passes responsibility to another method to do most or all of the work.\n", + "**delegación:**\n", + "Cuando un método pasa la responsabilidad a otro método para que haga la mayor parte o todo el trabajo.\n", "\n", - "**parent class:**\n", - "A class that is inherited from.\n", + "**clase padre:**\n", + "Una clase de la que se hereda.\n", "\n", - "**child class:**\n", - "A class that inherits from another class.\n", + "**clase hija:**\n", + "Una clase que hereda de otra clase.\n", "\n", - "**specialization:**\n", - "A way of using inheritance to create a new class that is a specialized version of an existing class." + "**especialización:**\n", + "Una forma de usar la herencia para crear una nueva clase que es una versión especializada de una clase existente." ] }, { @@ -1531,7 +1530,7 @@ "id": "1aea9b2b", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios" ] }, { @@ -1554,25 +1553,25 @@ "id": "7913e6b1", "metadata": {}, "source": [ - "### Ask a Virtual Assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "When it goes well, object-oriented programming can make programs more readable, testable, and reusable.\n", - "But it can also make programs complicated and hard to maintain.\n", - "As a result, OOP is a topic of controversy -- some people love it, and some people don't.\n", + "Cuando sale bien, la programación orientada a objetos puede hacer que los programas sean más legibles, fáciles de probar y reutilizables.\n", + "Pero también puede hacer que los programas sean complicados y difíciles de mantener.\n", + "Como resultado, la OOP es un tema controvertido: algunas personas la adoran y a otras no les gusta.\n", "\n", - "To learn more about the topic, ask a virtual assistant:\n", + "Para aprender más sobre el tema, pregunta a un asistente virtual:\n", "\n", - "* What are some pros and cons of object-oriented programming?\n", + "* ¿Cuáles son algunas ventajas y desventajas de la programación orientada a objetos?\n", "\n", - "* What does it mean when people say \"favor composition over inheritance\"?\n", + "* ¿Qué significa cuando la gente dice \"favor composition over herencia\"?\n", "\n", - "* What is the Liskov substitution principle?\n", + "* ¿Qué es el principio de sustitución de Liskov?\n", "\n", - "* Is Python an object-oriented language?\n", + "* ¿Python es un lenguaje orientado a objetos?\n", "\n", - "* What are the requirements for a set to be totally ordered?\n", + "* ¿Cuáles son los requisitos para que un conjunto esté totalmente ordenado?\n", "\n", - "And as always, consider using a virtual assistant to help with the following exercises." + "Y, como siempre, considera usar un asistente virtual para ayudarte con los siguientes ejercicios." ] }, { @@ -1580,10 +1579,10 @@ "id": "1af81269", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In contract bridge, a \"trick\" is a round of play in which each of four players plays one card.\n", - "To represent those cards, we'll define a class that inherits from `Deck`." + "En bridge de contrato, una \"trick\" es una ronda de juego en la que cada uno de cuatro jugadores juega una carta.\n", + "Para representar esas cartas, definiremos una clase que hereda de `Deck`." ] }, { @@ -1602,10 +1601,10 @@ "id": "9916d562", "metadata": {}, "source": [ - "As an example, consider this trick, where the first player leads with the 3 of Diamonds, which means that Diamonds are the \"led suit\".\n", - "The second and third players \"follow suit\", which means they play a card with the led suit.\n", - "The fourth player plays a card of a different suit, which means they cannot win the trick.\n", - "So the winner of this trick is the third player, because they played the highest card in the led suit." + "Como ejemplo, considera esta trick, donde el primer jugador empieza con el 3 of Diamonds, lo que significa que Diamonds es el \"led suit\".\n", + "El segundo y el tercer jugador \"follow suit\", lo que significa que juegan una carta del palo que se ha iniciado.\n", + "El cuarto jugador juega una carta de un palo diferente, lo que significa que no puede ganar la trick.\n", + "Así que el ganador de esta trick es el tercer jugador, porque jugó la carta más alta del led suit." ] }, { @@ -1628,8 +1627,8 @@ "id": "c94a1337", "metadata": {}, "source": [ - "Write a `Trick` method called `find_winner` that loops through the cards in the `Trick` and returns the index of the card that wins.\n", - "In the previous example, the index of the winning card is `2`." + "Escribe un método de `Trick` llamado `find_winner` que recorra las cartas de la `Trick` y devuelva el índice de la carta ganadora.\n", + "En el ejemplo anterior, el índice de la carta ganadora es `2`." ] }, { @@ -1639,7 +1638,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1676,7 +1675,7 @@ "tags": [] }, "source": [ - "If you test your method with the previous example, the index of the winning card should be `2`." + "Si pruebas tu método con el ejemplo anterior, el índice de la carta ganadora debería ser `2`." ] }, { @@ -1696,11 +1695,11 @@ "id": "b5b9fb4b", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "The next few exercises ask to you write functions that classify poker hands.\n", - "If you are not familiar with poker, I'll explain what you need to know.\n", - "We'll use the following class to represent poker hands." + "Los siguientes ejercicios te piden escribir funciones que clasifiquen manos de póker.\n", + "Si no estás familiarizado con el póker, explicaré lo que necesitas saber.\n", + "Usaremos la siguiente clase para representar manos de póker." ] }, { @@ -1733,18 +1732,18 @@ "id": "2daecced", "metadata": {}, "source": [ - "`PokerHand` provides two methods that will help with the exercises.\n", + "`PokerHand` proporciona dos métodos que ayudarán con los ejercicios.\n", "\n", - "* `get_suit_counts` loops through the cards in the `PokerHand`, counts the number of cards in each suit, and returns a dictionary that maps from each suit code to the number of times it appears.\n", + "* `get_suit_counts` recorre las cartas de la `PokerHand`, cuenta el número de cartas de cada palo y devuelve un diccionario que asigna cada código de palo al número de veces que aparece.\n", "\n", - "* `get_rank_counts` does the same thing with the ranks of the cards, returning a dictionary that maps from each rank code to the number of times it appears.\n", + "* `get_rank_counts` hace lo mismo con los rangos de las cartas, devolviendo un diccionario que asigna cada código de rango al número de veces que aparece.\n", "\n", - "All of the exercises that follow can be done using only the Python features we have learned so far, but some of them are more difficult than most of the previous exercises.\n", - "I encourage you to ask a virtual assistant for help.\n", + "Todos los ejercicios que siguen se pueden resolver usando solo las características de Python que hemos aprendido hasta ahora, pero algunos son más difíciles que la mayoría de los ejercicios anteriores.\n", + "Te animo a pedir ayuda a un asistente virtual.\n", "\n", - "For problems like this, it often works well to ask for general advice about strategies and algorithms.\n", - "Then you can either write the code yourself or ask for code.\n", - "If you ask for code, you might want to provide the relevant class definitions as part of the prompt." + "Para problemas como este, suele funcionar bien pedir consejos generales sobre estrategias y algorithms.\n", + "Luego puedes escribir el código tú mismo o pedir código.\n", + "Si pides código, quizá quieras proporcionar las definiciones de clase relevantes como parte del prompt." ] }, { @@ -1752,10 +1751,10 @@ "id": "ccc2d8ca", "metadata": {}, "source": [ - "As a first exercise, we'll write a method called `has_flush` that checks whether a hand has a \"flush\" -- that is, whether it contains at least five cards of the same suit.\n", + "Como primer ejercicio, escribiremos un método llamado `has_flush` que comprueba si una mano tiene un \"flush\"; es decir, si contiene al menos cinco cartas del mismo palo.\n", "\n", - "In most varieties of poker, a hand contains either five or seven cards, but there are some exotic variations where a hand contains other numbers of cards.\n", - "But regardless of how many cards there are in a hand, the only ones that count are the five that make the best hand." + "En la mayoría de variedades de póker, una mano contiene cinco o siete cartas, pero hay algunas variaciones exóticas donde una mano contiene otros números de cartas.\n", + "Pero, independientemente de cuántas cartas haya en una mano, las únicas que cuentan son las cinco que forman la mejor mano." ] }, { @@ -1765,7 +1764,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -1803,7 +1802,7 @@ "tags": [] }, "source": [ - "To test this method, we'll construct a hand with five cards that are all Clubs, so it contains a flush." + "Para probar este método, construiremos una mano con cinco cartas que son todas Clubs, así que contiene un flush." ] }, { @@ -1832,7 +1831,7 @@ "tags": [] }, "source": [ - "If we invoke `get_suit_counts`, we can confirm that the rank code `0` appears `5` times." + "Si invocamos `get_suit_counts`, podemos confirmar que el código de rango `0` aparece `5` veces." ] }, { @@ -1854,7 +1853,7 @@ "tags": [] }, "source": [ - "So `has_flush` should return `True`." + "Así que `has_flush` debería devolver `True`." ] }, { @@ -1876,7 +1875,7 @@ "tags": [] }, "source": [ - "As a second test, we'll construct a hand with three Clubs and two other suits." + "Como segunda prueba, construiremos una mano con tres Clubs y otros dos palos." ] }, { @@ -1909,7 +1908,7 @@ "tags": [] }, "source": [ - "So `has_flush` should return `False`." + "Así que `has_flush` debería devolver `False`." ] }, { @@ -1929,13 +1928,13 @@ "id": "ad716880", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Write a method called `has_straight` that checks whether a hand contains a straight, which is a set of five cards with consecutive ranks.\n", - "For example, if a hand contains ranks `5`, `6`, `7`, `8`, and `9`, it contains a straight.\n", + "Escribe un método llamado `has_straight` que compruebe si una mano contiene una straight, que es un conjunto de cinco cartas con rangos consecutivos.\n", + "Por ejemplo, si una mano contiene los rangos `5`, `6`, `7`, `8` y `9`, contiene una straight.\n", "\n", - "An Ace can come before a two or after a King, so `Ace`, `2`, `3`, `4`, `5` is a straight and so is `10`, `Jack`, `Queen`, `King`, `Ace`.\n", - "But a straight cannot \"wrap around\", so `King`, `Ace`, `2`, `3`, `4` is not a straight." + "Un Ace puede ir antes de un dos o después de un King, así que `Ace`, `2`, `3`, `4`, `5` es una straight, y también lo es `10`, `Jack`, `Queen`, `King`, `Ace`.\n", + "Pero una straight no puede \"dar la vuelta\", así que `King`, `Ace`, `2`, `3`, `4` no es una straight." ] }, { @@ -1945,8 +1944,8 @@ "tags": [] }, "source": [ - "You can use the following outline to get started.\n", - "It includes a few lines of code that count the number of Aces -- represented with the code `1` or `14` -- and store the total in both locations of the counter." + "Puedes usar el siguiente esquema para empezar.\n", + "Incluye unas pocas líneas de código que cuentan el número de Aces, representados con el código `1` o `14`, y almacenan el total en ambas ubicaciones del contador." ] }, { @@ -1989,8 +1988,8 @@ "tags": [] }, "source": [ - "`good_hand`, which we created for the previous exercise, contains a straight.\n", - "If we use `get_rank_counts`, we can confirm that it has at least one card with each of five consecutive ranks." + "`good_hand`, que creamos para el ejercicio anterior, contiene una straight.\n", + "Si usamos `get_rank_counts`, podemos confirmar que tiene al menos una carta de cada uno de cinco rangos consecutivos." ] }, { @@ -2012,7 +2011,7 @@ "tags": [] }, "source": [ - "So `has_straight` should return `True`." + "Así que `has_straight` debería devolver `True`." ] }, { @@ -2034,7 +2033,7 @@ "tags": [] }, "source": [ - "`bad_hand` does not contain a straight, so `has_straight` should return `False`." + "`bad_hand` no contiene una straight, así que `has_straight` debería devolver `False`." ] }, { @@ -2054,10 +2053,10 @@ "id": "c1ecebd3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A hand has a straight flush if it contains a set of five cards that are both a straight and a flush -- that is, five cards of the same suit with consecutive ranks.\n", - "Write a `PokerHand` method that checks whether a hand has a straight flush." + "Una mano tiene una straight flush si contiene un conjunto de cinco cartas que son a la vez una straight y un flush; es decir, cinco cartas del mismo palo con rangos consecutivos.\n", + "Escribe un método de `PokerHand` que compruebe si una mano tiene una straight flush." ] }, { @@ -2067,7 +2066,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -2117,7 +2116,7 @@ "tags": [] }, "source": [ - "Use the following examples to test your method." + "Usa los siguientes ejemplos para probar tu método." ] }, { @@ -2151,8 +2150,8 @@ "tags": [] }, "source": [ - "Note that it is not enough to check whether a hand has a straight and a flush.\n", - "To see why, consider the following hand." + "Ten en cuenta que no basta con comprobar si una mano tiene una straight y un flush.\n", + "Para ver por qué, considera la siguiente mano." ] }, { @@ -2179,7 +2178,7 @@ "tags": [] }, "source": [ - "This hand contains a straight and a flush, but they are not the same five cards." + "Esta mano contiene una straight y un flush, pero no son las mismas cinco cartas." ] }, { @@ -2201,7 +2200,7 @@ "tags": [] }, "source": [ - "So it does not contain a straight flush." + "Así que no contiene una straight flush." ] }, { @@ -2221,10 +2220,10 @@ "id": "dd742401", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A poker hand has a pair if it contains two or more cards with the same rank.\n", - "Write a `PokerHand` method that checks whether a hand contains a pair." + "Una mano de póker tiene una pareja si contiene dos o más cartas con el mismo rango.\n", + "Escribe un método de `PokerHand` que compruebe si una mano contiene una pareja." ] }, { @@ -2234,7 +2233,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -2281,7 +2280,7 @@ "id": "9f001207", "metadata": {}, "source": [ - "To test your method, here's a hand that has a pair." + "Para probar tu método, aquí tienes una mano que tiene una pareja." ] }, { @@ -2331,10 +2330,10 @@ "id": "c4180a64", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "A hand has a full house if it contains three cards of one rank and two cards of another rank.\n", - "Write a `PokerHand` method that checks whether a hand has a full house." + "Una mano tiene un full house si contiene tres cartas de un rango y dos cartas de otro rango.\n", + "Escribe un método de `PokerHand` que compruebe si una mano tiene un full house." ] }, { @@ -2344,7 +2343,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar." ] }, { @@ -2381,7 +2380,7 @@ "tags": [] }, "source": [ - "You can use this hand to test your method." + "Puedes usar esta mano para probar tu método." ] }, { @@ -2440,10 +2439,10 @@ "id": "666340c1", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "This exercise is a cautionary tale about a common error that can be difficult to debug.\n", - "Consider the following class definition." + "Este ejercicio es una advertencia sobre un error común que puede ser difícil de depurar.\n", + "Considera la siguiente definición de clase." ] }, { @@ -2487,14 +2486,14 @@ "id": "1e349832", "metadata": {}, "source": [ - "`__init__` takes two parameters: `name` is required, but `contents` is optional -- if it's not provided, the default value is an empty list.\n", + "`__init__` toma dos parámetros: `name` es obligatorio, pero `contents` es opcional; si no se proporciona, el valor por defecto es una lista vacía.\n", "\n", - "`__str__` returns a string representation of the object that includes the name and the contents of the pouch.\n", + "`__str__` devuelve una representación en string del objeto que incluye el nombre y el contenido de la bolsa.\n", "\n", - "`put_in_pouch` takes any object and appends it to `contents`.\n", + "`put_in_pouch` toma cualquier objeto y lo añade a `contents`.\n", "\n", - "Now let's see how this class works.\n", - "We'll create two `Kangaroo` objects with the names `'Kanga'` and `'Roo'`." + "Ahora veamos cómo funciona esta clase.\n", + "Crearemos dos objetos `Kangaroo` con los nombres `'Kanga'` y `'Roo'`." ] }, { @@ -2513,7 +2512,7 @@ "id": "533982d1", "metadata": {}, "source": [ - "To Kanga's pouch we'll add two strings and Roo." + "A la bolsa de Kanga le añadiremos dos strings y Roo." ] }, { @@ -2533,7 +2532,7 @@ "id": "41cd6d6e", "metadata": {}, "source": [ - "If we print `kanga`, it seems like everything worked." + "Si imprimimos `kanga`, parece que todo ha funcionado." ] }, { @@ -2551,7 +2550,7 @@ "id": "0ba26163", "metadata": {}, "source": [ - "But what happens if we print `roo`?" + "Pero ¿qué pasa si imprimimos `roo`?" ] }, { @@ -2569,10 +2568,10 @@ "id": "a2aef813", "metadata": {}, "source": [ - "Roo's pouch contains the same contents as Kanga's, including a reference to `roo`!\n", + "¡La bolsa de Roo contiene el mismo contenido que la de Kanga, incluida una referencia a `roo`!\n", "\n", - "See if you can figure out what went wrong.\n", - "Then ask a virtual assistant, \"What's wrong with the following program?\" and paste in the definition of `Kangaroo`." + "A ver si puedes averiguar qué salió mal.\n", + "Luego pregunta a un asistente virtual: \"¿Qué está mal en el siguiente programa?\" y pega la definición de `Kangaroo`." ] }, { @@ -2590,13 +2589,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Licencia del código: [MIT License](https://mit-license.org/)\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] } ], @@ -2622,4 +2623,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/chap18.ipynb b/chapters/chap18.ipynb index 3027822..19c8981 100644 --- a/chapters/chap18.ipynb +++ b/chapters/chap18.ipynb @@ -5,9 +5,9 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", - "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." + "Puedes comprar las versiones impresa y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", + "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325).\n" ] }, { @@ -43,7 +43,7 @@ "tags": [] }, "source": [ - "Here are versions of the `Card`, `Deck`, and `Hand` classes from Chapter 17, which we will use in some examples in this chapter." + "Aquí tienes versiones de las clases `Card`, `Deck` y `Hand` del Capítulo 17, que usaremos en algunos ejemplos de este capítulo.\n" ] }, { @@ -129,14 +129,14 @@ "id": "27e8d827", "metadata": {}, "source": [ - "# Python Extras\n", + "# Extras de Python\n", "\n", - "One of my goals for this book has been to teach you as little Python as possible. \n", - "When there were two ways to do something, I picked one and avoided mentioning the other.\n", - "Or sometimes I put the second one into an exercise.\n", + "Uno de mis objetivos con este libro ha sido enseñarte la menor cantidad posible de Python. \n", + "Cuando había dos maneras de hacer algo, elegí una y evité mencionar la otra.\n", + "O a veces puse la segunda en un ejercicio.\n", "\n", - "Now I want to go back for some of the good bits that got left behind.\n", - "Python provides a number of features that are not really necessary -- you can write good code without them -- but with them you can write code that's more concise, readable, or efficient, and sometimes all three." + "Ahora quiero volver a algunas de las partes buenas que quedaron fuera.\n", + "Python ofrece varias características que no son realmente necesarias -- puedes escribir buen código sin ellas -- pero con ellas puedes escribir código más conciso, legible o eficiente, y a veces las tres cosas.\n" ] }, { @@ -144,10 +144,10 @@ "id": "7ddcece8", "metadata": {}, "source": [ - "## Sets\n", + "## Conjuntos\n", "\n", - "Python provides a class called `set` that represents a collection of unique elements.\n", - "To create an empty set, we can use the class object like a function." + "Python proporciona una clase llamada `set` que representa una colección de elementos únicos.\n", + "Para crear un conjunto vacío, podemos usar el objeto de clase como una función.\n" ] }, { @@ -166,7 +166,7 @@ "id": "904e2071", "metadata": {}, "source": [ - "We can use the `add` method to add elements." + "Podemos usar el método `add` para añadir elementos.\n" ] }, { @@ -186,7 +186,7 @@ "id": "beee02fc", "metadata": {}, "source": [ - "Or we can pass any kind of sequence to `set`." + "O podemos pasar cualquier tipo de secuencia a `set`.\n" ] }, { @@ -205,8 +205,8 @@ "id": "42f99153", "metadata": {}, "source": [ - "An element can only appear once in a `set`.\n", - "If you add an element that's already there, it has no effect." + "Un elemento solo puede aparecer una vez en un `set`.\n", + "Si añades un elemento que ya está, no tiene ningún efecto.\n" ] }, { @@ -225,7 +225,7 @@ "id": "9b0a82ee", "metadata": {}, "source": [ - "Or if you create a set with a sequence that contains duplicates, the result contains only unique elements." + "O, si creas un conjunto con una secuencia que contiene duplicados, el resultado contiene solo elementos únicos.\n" ] }, { @@ -243,8 +243,8 @@ "id": "328e2009", "metadata": {}, "source": [ - "Some of the exercises in this book can be done concisely and efficiently with sets. \n", - "For example, here is a solution to an exercise in Chapter 11 that uses a dictionary to check whether there are any duplicate elements in a sequence." + "Algunos de los ejercicios de este libro se pueden hacer de forma concisa y eficiente con conjuntos. \n", + "Por ejemplo, aquí tienes una solución a un ejercicio del Capítulo 11 que usa un diccionario para comprobar si hay elementos duplicados en una secuencia.\n" ] }, { @@ -266,8 +266,8 @@ "id": "0b250e58", "metadata": {}, "source": [ - "This version adds the element of `t` as keys in a dictionary, and then checks whether there are fewer keys than elements.\n", - "Using sets, we can write the same function like this." + "Esta versión añade los elementos de `t` como claves en un diccionario, y luego comprueba si hay menos claves que elementos.\n", + "Usando conjuntos, podemos escribir la misma función así.\n" ] }, { @@ -299,11 +299,11 @@ "id": "30cf3158", "metadata": {}, "source": [ - "An element can only appear in a set once, so if an element in `t` appears more than once, the set will be smaller than `t`.\n", - "If there are no duplicates, the set will be the same size as `t`.\n", + "Un elemento solo puede aparecer en un conjunto una vez, así que si un elemento de `t` aparece más de una vez, el conjunto será más pequeño que `t`.\n", + "Si no hay duplicados, el conjunto tendrá el mismo tamaño que `t`.\n", "\n", - "`set` objects provide methods that perform set operations.\n", - "For example, `union` computes the union of two sets, which is a new set that contains all elements that appear in either set." + "Los objeto `set` proporcionan métodos que realizan operaciones de conjuntos.\n", + "Por ejemplo, `union` calcula la unión de dos conjuntos, que es un nuevo conjunto que contiene todos los elementos que aparecen en cualquiera de los dos conjuntos.\n" ] }, { @@ -321,8 +321,8 @@ "id": "57b1d50c", "metadata": {}, "source": [ - "Some arithmetic operators work with sets.\n", - "For example, the `-` operator performs set subtraction -- the result is a new set that contains all elements from the first set that are _not_ in the second set." + "Algunos operadores aritméticos funcionan con conjuntos.\n", + "Por ejemplo, el operador `-` realiza la resta de conjuntos -- el resultado es un nuevo conjunto que contiene todos los elementos del primer conjunto que _no_ están en el segundo conjunto.\n" ] }, { @@ -340,8 +340,8 @@ "id": "5099226c", "metadata": {}, "source": [ - "In [Chapter 12](section_dictionary_subtraction) we used dictionaries to find the words that appear in a document but not in a word list.\n", - "We used the following function, which takes two dictionaries and returns a new dictionary that contains only the keys from the first that don't appear in the second." + "En el [Capítulo 12](section_dictionary_subtraction) usamos diccionarios para encontrar las palabras que aparecen en un documento pero no en una lista de palabras.\n", + "Usamos la siguiente función, que recibe dos diccionarios y devuelve un nuevo diccionario que contiene solo las claves del primero que no aparecen en el segundo.\n" ] }, { @@ -364,8 +364,8 @@ "id": "455c3e34", "metadata": {}, "source": [ - "With sets, we don't have to write this function ourselves.\n", - "If `word_counter` is a dictionary that contains the unique words in the document and `word_list` is a list of valid words, we can compute the set difference like this." + "Con conjuntos, no tenemos que escribir esta función nosotros mismos.\n", + "Si `word_counter` es un diccionario que contiene las palabras únicas del documento y `word_list` es una lista de palabras válidas, podemos calcular la diferencia de conjuntos así.\n" ] }, { @@ -401,10 +401,10 @@ "id": "91efe708", "metadata": {}, "source": [ - "The result is a set that contains the words in the document that don't appear in the word list.\n", + "El resultado es un conjunto que contiene las palabras del documento que no aparecen en la lista de palabras.\n", "\n", - "The relational operators work with sets.\n", - "For example, `<=` checks whether one set is a subset of another, including the possibility that they are equal." + "Los operadores relacionales funcionan con conjuntos.\n", + "Por ejemplo, `<=` comprueba si un conjunto es un subconjunto de otro, incluyendo la posibilidad de que sean iguales.\n" ] }, { @@ -422,8 +422,8 @@ "id": "74d4d824", "metadata": {}, "source": [ - "With these operators, we can use sets to do some of the exercises in Chapter 7.\n", - "For example, here's a version of `uses_only` that uses a loop." + "Con estos operadores, podemos usar conjuntos para hacer algunos de los ejercicios del Capítulo 7.\n", + "Por ejemplo, aquí tienes una versión de `uses_only` que usa un bucle.\n" ] }, { @@ -445,8 +445,8 @@ "id": "58c1da26", "metadata": {}, "source": [ - "`uses_only` checks whether all letters in `word` are in `available`.\n", - "With sets, we can rewrite it like this." + "`uses_only` comprueba si todas las letras de `word` están en `available`.\n", + "Con conjuntos, podemos reescribirla así.\n" ] }, { @@ -465,7 +465,7 @@ "id": "01ce8cff", "metadata": {}, "source": [ - "If the letters in `word` are a subset of the letters in `available`, that means that `word` uses only letters in `available`." + "Si las letras de `word` son un subconjunto de las letras de `available`, eso significa que `word` usa solo letras de `available`.\n" ] }, { @@ -475,12 +475,12 @@ "source": [ "## Counters\n", "\n", - "A `Counter` is like a set, except that if an element appears more than once, the `Counter` keeps track of how many times it appears.\n", - "If you are familiar with the mathematical idea of a \"multiset\", a `Counter` is a\n", - "natural way to represent a multiset.\n", + "Un `Counter` es como un conjunto, excepto que si un elemento aparece más de una vez, el `Counter` lleva la cuenta de cuántas veces aparece.\n", + "Si conoces la idea matemática de un \"multiset\", un `Counter` es una forma\n", + "natural de representar un multiset.\n", "\n", - "The `Counter` class is defined in a module called `collections`, so you have to import it.\n", - "Then you can use the class object as a function and pass as an argument a string, list, or any other kind of sequence." + "La clase `Counter` está definida en un module llamado `collections`, así que tienes que importarla.\n", + "Después puedes usar el objeto de clase como una función y pasar como argumento un string, una lista o cualquier otro tipo de secuencia.\n" ] }, { @@ -515,12 +515,12 @@ "id": "8da28fe5", "metadata": {}, "source": [ - "A `Counter` object is like a dictionary that maps from each key to the number of times it appears.\n", - "As in dictionaries, the keys have to be hashable.\n", + "Un objeto `Counter` es como un diccionario que asocia cada clave con el número de veces que aparece.\n", + "Como en los diccionarios, las claves tienen que ser hashable.\n", "\n", - "Unlike dictionaries, `Counter` objects don't raise an exception if you access an\n", - "element that doesn't appear.\n", - "Instead, they return `0`." + "A diferencia de los diccionarios, los objeto `Counter` no lanzan una excepción si accedes a un\n", + "elemento que no aparece.\n", + "En su lugar, devuelven `0`.\n" ] }, { @@ -538,9 +538,9 @@ "id": "9bb2b650", "metadata": {}, "source": [ - "We can use `Counter` objects to solve one of the exercises from Chapter 10, which asks for a function that takes two words and checks whether they are anagrams -- that is, whether the letters from one can be rearranged to spell the other.\n", + "Podemos usar objeto `Counter` para resolver uno de los ejercicios del Capítulo 10, que pide una función que reciba dos palabras y compruebe si son anagramas -- es decir, si las letras de una se pueden reordenar para formar la otra.\n", "\n", - "Here's a solution using `Counter` objects." + "Aquí tienes una solución usando objeto `Counter`.\n" ] }, { @@ -559,9 +559,9 @@ "id": "6907f368", "metadata": {}, "source": [ - "If two words are anagrams, they contain the same letters with the same counts, so their `Counter` objects are equivalent.\n", + "Si dos palabras son anagramas, contienen las mismas letras con los mismos recuentos, así que sus objeto `Counter` son equivalentes.\n", "\n", - "`Counter` provides a method called `most_common` that returns a list of value-frequency pairs, sorted from most common to least." + "`Counter` proporciona un método llamado `most_common` que devuelve una lista de pares valor-frecuencia, ordenados de más común a menos común.\n" ] }, { @@ -579,10 +579,10 @@ "id": "b02b7dff", "metadata": {}, "source": [ - "They also provide methods and operators to perform set-like operations, including addition, subtraction, union and intersection.\n", - "For example, the `+` operator combines two `Counter` objects and creates a new `Counter` that contains the keys from both and the sums of the counts.\n", + "También proporcionan métodos y operadores para realizar operaciones parecidas a las de conjuntos, incluyendo suma, resta, unión e intersección.\n", + "Por ejemplo, el operador `+` combina dos objeto `Counter` y crea un nuevo `Counter` que contiene las claves de ambos y las sumas de los recuentos.\n", "\n", - "We can test it by making a `Counter` with the letters from `'bans'` and adding it to the letters from `'banana'`." + "Podemos probarlo creando un `Counter` con las letras de `'bans'` y sumándolo a las letras de `'banana'`.\n" ] }, { @@ -601,7 +601,7 @@ "id": "5461328e", "metadata": {}, "source": [ - "You'll have a chance to explore other `Counter` operations in the exercises at the end of this chapter." + "Tendrás la oportunidad de explorar otras operaciones de `Counter` en los ejercicios al final de este capítulo.\n" ] }, { @@ -611,13 +611,13 @@ "source": [ "## defaultdict\n", "\n", - "The `collections` module also provides `defaultdict`, which is like a dictionary except that if you access a key that doesn't exist, it generates a new value automatically.\n", + "El module `collections` también proporciona `defaultdict`, que es como un diccionario excepto que, si accedes a una clave que no existe, genera automáticamente un nuevo valor.\n", "\n", - "When you create a `defaultdict`, you provide a function that's used to create new values.\n", - "A function that create objects is sometimes called a **factory**.\n", - "The built-in functions that create lists, sets, and other types can be used as factories.\n", + "Cuando creas un `defaultdict`, proporcionas una función que se usa para crear nuevos valores.\n", + "Una función que crea objetos a veces se llama **fábrica**.\n", + "Las funciones integradas que crean listas, conjuntos y otros tipos se pueden usar como fábricas.\n", "\n", - "For example, here's a `defaultdict` that creates a new `list` when needed. " + "Por ejemplo, aquí tienes un `defaultdict` que crea una nueva `list` cuando hace falta.\n" ] }, { @@ -638,8 +638,8 @@ "id": "9f43d537", "metadata": {}, "source": [ - "Notice that the argument is `list`, which is a class object, not `list()`, which is a function call that creates a new list.\n", - "The factory function doesn't get called unless we access a key that doesn't exist." + "Fíjate en que el argumento es `list`, que es un objeto de clase, no `list()`, que es una llamada a función que crea una nueva lista.\n", + "La fábrica función no se llama a menos que accedamos a una clave que no existe.\n" ] }, { @@ -658,8 +658,8 @@ "id": "01f87415", "metadata": {}, "source": [ - "The new list, which we're calling `t`, is also added to the dictionary.\n", - "So if we modify `t`, the change appears in `d`:" + "La nueva lista, que llamamos `t`, también se añade al diccionario.\n", + "Así que si modificamos `t`, el cambio aparece en `d`:\n" ] }, { @@ -678,12 +678,12 @@ "id": "3e5d0151", "metadata": {}, "source": [ - "If you are making a dictionary of lists, you can often write simpler\n", - "code using `defaultdict`. \n", + "Si estás creando un diccionario de listas, a menudo puedes escribir código más simple\n", + "usando `defaultdict`. \n", "\n", - "In one of the exercises in [Chapter 11](chapter_tuples), I made a dictionary that maps from a sorted string of letters to the list of words that can be spelled with those letters.\n", - "For example, the string `'opst'` maps to the list `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", - "Here's the original code." + "En uno de los ejercicios del [Capítulo 11](chapter_tuples), hice un diccionario que asocia un string de letras ordenadas con la lista de palabras que se pueden formar con esas letras.\n", + "Por ejemplo, el string `'opst'` se asocia con la lista `['opts', 'post', 'pots', 'spot', 'stop', 'tops']`.\n", + "Aquí está el código original.\n" ] }, { @@ -710,7 +710,7 @@ "id": "8e9a0a2b", "metadata": {}, "source": [ - "And here's a simpler version using a `defaultdict`." + "Y aquí tienes una versión más simple usando un `defaultdict`.\n" ] }, { @@ -734,7 +734,7 @@ "id": "cccdd46c", "metadata": {}, "source": [ - "In the exercises at the end of the chapter, you'll have a chance to practice using `defaultdict` objects." + "En los ejercicios al final del capítulo, tendrás la oportunidad de practicar usando objeto `defaultdict`.\n" ] }, { @@ -757,9 +757,9 @@ "id": "610359c1", "metadata": {}, "source": [ - "## Conditional expressions\n", + "## Expresiones condicionales\n", "\n", - "Conditional statements are often used to choose one of two values, like this:" + "Las sentencias condicionales se usan a menudo para elegir uno de dos valores, como aquí:\n" ] }, { @@ -805,11 +805,11 @@ "id": "2c5fc3dd", "metadata": {}, "source": [ - "This statement checks whether `x` is positive. If so, it computes its logarithm. \n", - "If not, `math.log` would raise a ValueError.\n", - "To avoid stopping the program, we generate a `NaN`, which is a special floating-point value that represents \"Not a Number\".\n", + "Esta sentencia comprueba si `x` es positivo. Si lo es, calcula su logaritmo. \n", + "Si no, `math.log` lanzaría un ValueError.\n", + "Para evitar detener el programa, generamos un `NaN`, que es un valor especial de punto flotante que representa \"Not a Number\".\n", "\n", - "We can write this statement more concisely using a **conditional expression**." + "Podemos escribir esta sentencia de forma más concisa usando una **conditional expression**.\n" ] }, { @@ -839,10 +839,10 @@ "id": "6a7cf27b", "metadata": {}, "source": [ - "You can almost read this line like English: \"`y` gets log-`x` if `x` is greater than 0; otherwise it gets `NaN`\".\n", + "Casi puedes leer esta línea como si fuera inglés: \"`y` recibe log-`x` si `x` es mayor que 0; de lo contrario recibe `NaN`\".\n", "\n", - "Recursive functions can sometimes be written concisely using conditional expressions. \n", - "For example, here is a version of `factorial` with a conditional _statement_." + "Las funciones recursivas a veces se pueden escribir de forma concisa usando expresiones condicionales. \n", + "Por ejemplo, aquí tienes una versión de `factorial` con una _sentencia_ condicional.\n" ] }, { @@ -864,7 +864,7 @@ "id": "56052b5c", "metadata": {}, "source": [ - "And here's a version with a conditional _expression_." + "Y aquí tienes una versión con una _expresión_ condicional.\n" ] }, { @@ -883,8 +883,8 @@ "id": "d53fbc15", "metadata": {}, "source": [ - "Another use of conditional expressions is handling optional arguments.\n", - "For example, here is class definition with an `__init__` method that uses a conditional statement to check a parameter with a default value." + "Otro uso de las expresiones condicionales es manejar argumentos opcionales.\n", + "Por ejemplo, aquí tienes una definición de clase con un método `__init__` que usa una sentencia condicional para comprobar un parámetro con un valor por defecto.\n" ] }, { @@ -907,7 +907,7 @@ "id": "655bfc46", "metadata": {}, "source": [ - "Here's a version that uses a conditional expression." + "Aquí tienes una versión que usa una expresión condicional.\n" ] }, { @@ -927,7 +927,7 @@ "id": "fef85229", "metadata": {}, "source": [ - "In general, you can replace a conditional statement with a conditional expression if both branches contain a single expression and no statements." + "En general, puedes reemplazar una sentencia condicional por una expresión condicional si ambas ramas contienen una sola expresión y ninguna sentencia.\n" ] }, { @@ -935,10 +935,10 @@ "id": "45d3b306", "metadata": {}, "source": [ - "## List comprehensions\n", + "## Comprensiones de listas\n", "\n", - "In previous chapters, we've seen a few examples where we start with an empty list and add elements, one at a time, using the `append` method.\n", - "For example, suppose we have a string that contains the title of a movie, and we want to capitalize all of the words." + "En capítulos anteriores, hemos visto algunos ejemplos donde empezamos con una lista vacía y añadimos elementos, uno por uno, usando el método `append`.\n", + "Por ejemplo, supón que tenemos un string que contiene el título de una película, y queremos poner en mayúscula la primera letra de todas las palabras.\n" ] }, { @@ -956,7 +956,7 @@ "id": "9eeb45a6", "metadata": {}, "source": [ - "We can split it into a list of strings, loop through the strings, capitalize them, and append them to a list." + "Podemos dividirlo en una lista de strings, recorrer los strings, capitalizarlos y añadirlos a una lista.\n" ] }, { @@ -978,7 +978,7 @@ "id": "b96197c2", "metadata": {}, "source": [ - "We can do the same thing more concisely using a **list comprehension**:" + "Podemos hacer lo mismo de forma más concisa usando una **comprensión de listas**:\n" ] }, { @@ -998,13 +998,13 @@ "id": "e5b565ad", "metadata": {}, "source": [ - "The bracket operators indicate that we are constructing a new list.\n", - "The expression inside the brackets specifies the elements of the list, and the `for` clause indicates what sequence we are looping through.\n", + "Los operadores de corchetes indican que estamos construyendo una nueva lista.\n", + "La expresión dentro de los corchetes especifica los elementos de la lista, y la cláusula `for` indica qué secuencia estamos recorriendo.\n", "\n", - "The syntax of a list comprehension might seem strange, because the loop variable -- `word` in this example -- appears in the expression before we get to its definition.\n", - "But you get used to it.\n", + "La sintaxis de una comprensión de listas puede parecer extraña, porque la variable del bucle -- `word` en este ejemplo -- aparece en la expresión antes de llegar a su definición.\n", + "Pero te acostumbras.\n", "\n", - "As another example, in [Chapter 9](section_word_list) we used this loop to read words from a file and append them to a list." + "Como otro ejemplo, en el [Capítulo 9](section_word_list) usamos este bucle para leer palabras de un archivo y añadirlas a una lista.\n" ] }, { @@ -1050,7 +1050,7 @@ "id": "2d1df49b", "metadata": {}, "source": [ - "Here's how we can write that as a list comprehension." + "Así es como podemos escribirlo como una comprensión de listas.\n" ] }, { @@ -1080,8 +1080,8 @@ "id": "92d856ba", "metadata": {}, "source": [ - "A list comprehension can also have an `if` clause that determines which elements are included in the list.\n", - "For example, here's a `for` loop we used in [Chapter 10](section_palindrome_list) to make a list of only the words in `word_list` that are palindromes." + "Una comprensión de listas también puede tener una cláusula `if` que determina qué elementos se incluyen en la lista.\n", + "Por ejemplo, aquí tienes un bucle `for` que usamos en el [Capítulo 10](section_palindrome_list) para crear una lista solo con las palabras de `word_list` que son palíndromos.\n" ] }, { @@ -1128,7 +1128,7 @@ "id": "151621d8", "metadata": {}, "source": [ - "Here's how we can do the same thing with an list comprehension." + "Así es como podemos hacer lo mismo con una comprensión de listas.\n" ] }, { @@ -1158,9 +1158,9 @@ "id": "5fc4eab1", "metadata": {}, "source": [ - "When a list comprehension is used as an argument to a function, we can often omit the brackets.\n", - "For example, suppose we want to add up $1 / 2^n$ for values of $n$ from 0 to 9.\n", - "We can use a list comprehension like this." + "Cuando una comprensión de listas se usa como argumento de una función, a menudo podemos omitir los corchetes.\n", + "Por ejemplo, supón que queremos sumar $1 / 2^n$ para valores de $n$ de 0 a 9.\n", + "Podemos usar una comprensión de listas así.\n" ] }, { @@ -1178,7 +1178,7 @@ "id": "2ee312e0", "metadata": {}, "source": [ - "Or we can leave out the brackets like this." + "O podemos dejar fuera los corchetes así.\n" ] }, { @@ -1196,17 +1196,17 @@ "id": "3d56d584", "metadata": {}, "source": [ - "In this example, the argument is technically a **generator expression**, not a list comprehension, and it never actually makes a list.\n", - "But other than that, the behavior is the same.\n", + "En este ejemplo, técnicamente el argumento es una **expresión generadora**, no una comprensión de listas, y en realidad nunca crea una lista.\n", + "Pero aparte de eso, el comportamiento es el mismo.\n", "\n", - "List comprehensions and generator expressions are concise and easy to read, at least for simple expressions.\n", - "And they are usually faster than the equivalent for loops, sometimes much faster.\n", - "So if you are mad at me for not mentioning them earlier, I understand.\n", + "Las comprensiones de listas y las expresiones generadoras son concisas y fáciles de leer, al menos para expresiones simples.\n", + "Y normalmente son más rápidas que los bucles `for` equivalentes, a veces mucho más rápidas.\n", + "Así que si estás enfadado conmigo por no haberlas mencionado antes, lo entiendo.\n", "\n", - "But, in my defense, list comprehensions are harder to debug because you can't put a print statement inside the loop.\n", - "I suggest you use them only if the computation is simple enough that you are likely to get it\n", - "right the first time.\n", - "Or consider writing and debugging a `for` loop and then converting it to a list comprehension." + "Pero, en mi defensa, las comprensiones de listas son más difíciles de depurar porque no puedes poner una sentencia print dentro del bucle.\n", + "Te sugiero que las uses solo si el cálculo es lo bastante simple como para que probablemente te salga\n", + "bien a la primera.\n", + "O considera escribir y depurar un bucle `for` y luego convertirlo en una comprensión de listas.\n" ] }, { @@ -1214,9 +1214,9 @@ "id": "f9fac860", "metadata": {}, "source": [ - "## `any` and `all`\n", + "## `any` y `all`\n", "\n", - "Python provides a built-in function, `any`, that takes a sequence of boolean values and returns `True` if any of the values are `True`." + "Python proporciona una función integrada, `any`, que recibe una secuencia de valores booleanos y devuelve `True` si cualquiera de los valores es `True`.\n" ] }, { @@ -1234,7 +1234,7 @@ "id": "43217186", "metadata": {}, "source": [ - "`any` is often used with generator expressions." + "`any` se usa a menudo con expresiones generadoras.\n" ] }, { @@ -1252,8 +1252,8 @@ "id": "22395487", "metadata": {}, "source": [ - "That example isn't very useful because it does the same thing as the `in` operator. \n", - "But we could use `any` to write concise solutions to some of the exercises in [Chapter 7](chapter_search). For example, we can write `uses_none` like this." + "Ese ejemplo no es muy útil porque hace lo mismo que el operador `in`. \n", + "Pero podríamos usar `any` para escribir soluciones concisas a algunos de los ejercicios del [Capítulo 7](chapter_search). Por ejemplo, podemos escribir `uses_none` así.\n" ] }, { @@ -1297,11 +1297,11 @@ "id": "fbefe3c1", "metadata": {}, "source": [ - "This function loops through the letters in `word` and checks whether any of them are in `forbidden`.\n", - "Using `any` with a generator expression is efficient because it stops immediately if it finds a `True` value, so it doesn't have to loop through the whole sequence.\n", + "Esta función recorre las letras de `word` y comprueba si alguna de ellas está en `forbidden`.\n", + "Usar `any` con una expresión generadora es eficiente porque se detiene inmediatamente si encuentra un valor `True`, así que no tiene que recorrer toda la secuencia.\n", "\n", - "Python provides another built-in function, `all`, that returns `True` if every element of the sequence is `True`.\n", - "We can use it to write a concise version of `uses_all`." + "Python proporciona otra función integrada, `all`, que devuelve `True` si todos los elementos de la secuencia son `True`.\n", + "Podemos usarla para escribir una versión concisa de `uses_all`.\n" ] }, { @@ -1345,7 +1345,7 @@ "id": "8d9f7364", "metadata": {}, "source": [ - "Expressions using `any` and `all` can be concise, efficient, and easy to read." + "Las expresiones que usan `any` y `all` pueden ser concisas, eficientes y fáciles de leer.\n" ] }, { @@ -1353,11 +1353,11 @@ "id": "911857a3", "metadata": {}, "source": [ - "## Named tuples\n", + "## Named tuplas\n", "\n", - "The `collections` module provides a function called `namedtuple` that can be used to create simple classes.\n", - "For example, the `Point` object in [Chapter 16](section_create_point) has only two attributes, `x` and `y`.\n", - "Here's how we defined it." + "El module `collections` proporciona una función llamada `namedtuple` que se puede usar para crear clases simples.\n", + "Por ejemplo, el objeto `Point` del [Capítulo 16](section_create_point) solo tiene dos atributos, `x` e `y`.\n", + "Así es como lo definimos.\n" ] }, { @@ -1383,8 +1383,8 @@ "id": "36f08927", "metadata": {}, "source": [ - "That's a lot of code to convey a small amount of information.\n", - "`namedtuple` provides a more concise way to define classes like this." + "Eso es mucho código para transmitir una pequeña cantidad de información.\n", + "`namedtuple` proporciona una forma más concisa de definir clases como esta.\n" ] }, { @@ -1404,12 +1404,12 @@ "id": "942a0877", "metadata": {}, "source": [ - "The first argument is the name of the class you want to create. The\n", - "second is a list of the attributes `Point` objects should have.\n", - "The result is a class object, which is why it is assigned to a capitalized variable name.\n", + "El primer argumento es el nombre de la clase que quieres crear. El\n", + "segundo es una lista de los atributos que deben tener los objeto `Point`.\n", + "El resultado es un objeto de clase, por eso se asigna a un nombre de variable con mayúscula inicial.\n", "\n", - "A class created with `namedtuple` provides an `__init__` method that assigns values to the attributes and a `__str__` that displays the object in a readable form.\n", - "So we can create and display a `Point` object like this." + "Una clase creada con `namedtuple` proporciona un método `__init__` que asigna valores a los atributos y un `__str__` que muestra el objeto de forma legible.\n", + "Así que podemos crear y mostrar un objeto `Point` así.\n" ] }, { @@ -1428,7 +1428,7 @@ "id": "b42ee9a2", "metadata": {}, "source": [ - "`Point` also provides an `__eq__` method that checks whether two `Point` objects are equivalent -- that is, whether their attributes are the same." + "`Point` también proporciona un método `__eq__` que comprueba si dos objeto `Point` son equivalentes -- es decir, si sus atributos son iguales.\n" ] }, { @@ -1446,7 +1446,7 @@ "id": "9bcf275a", "metadata": {}, "source": [ - "You can access the elements of a named tuple by name or by index." + "Puedes acceder a los elementos de una named tupla por nombre o por índice.\n" ] }, { @@ -1474,7 +1474,7 @@ "id": "0768ff41", "metadata": {}, "source": [ - "You can also treat a named tuple as a tuple, as in this assignment." + "También puedes tratar una named tupla como una tupla, como en esta asignación.\n" ] }, { @@ -1493,8 +1493,8 @@ "id": "964aa3bd", "metadata": {}, "source": [ - "But `namedtuple` objects are immutable.\n", - "After the attributes are initialized, they can't be changed." + "Pero los objeto `namedtuple` son inmutables.\n", + "Después de inicializar los atributos, no se pueden cambiar.\n" ] }, { @@ -1530,10 +1530,10 @@ "id": "f2db7783", "metadata": {}, "source": [ - "`namedtuple` provides a quick way to define simple classes.\n", - "The drawback is that simple classes don't always stay simple.\n", - "You might decide later that you want to add methods to a named tuple.\n", - "In that case, you can define a new class that inherits from the named tuple." + "`namedtuple` proporciona una forma rápida de definir clases simples.\n", + "La desventaja es que las clases simples no siempre siguen siendo simples.\n", + "Puede que más adelante decidas que quieres añadir métodos a una named tupla.\n", + "En ese caso, puedes definir una nueva clase que herede de la named tupla.\n" ] }, { @@ -1552,7 +1552,7 @@ "id": "805475ce", "metadata": {}, "source": [ - "Or at that point you could switch to a conventional class definition." + "O en ese punto podrías cambiar a una definición de clase convencional.\n" ] }, { @@ -1560,9 +1560,9 @@ "id": "4f3713a0", "metadata": {}, "source": [ - "## Packing keyword arguments\n", + "## Empaquetar argumentos de palabra clave\n", "\n", - "In [Chapter 11](section_argument_pack), we wrote a function that packs its arguments into a tuple." + "En el [Capítulo 11](section_argument_pack), escribimos una función que empaqueta sus argumentos en una tupla.\n" ] }, { @@ -1581,7 +1581,7 @@ "id": "71e3b049", "metadata": {}, "source": [ - "You can call this function with any number of arguments." + "Puedes llamar a esta función con cualquier número de argumentos.\n" ] }, { @@ -1599,8 +1599,8 @@ "id": "486a690f", "metadata": {}, "source": [ - "But the `*` operator doesn't pack keyword arguments.\n", - "So calling this function with a keyword argument causes an error." + "Pero el operador `*` no empaqueta argumentos de palabra clave.\n", + "Así que llamar a esta función con un argumento de palabra clave causa un error.\n" ] }, { @@ -1622,7 +1622,7 @@ "id": "eb7f9281", "metadata": {}, "source": [ - "To pack keyword arguments, we can use the `**` operator:" + "Para empaquetar argumentos de palabra clave, podemos usar el operador `**`:\n" ] }, { @@ -1642,8 +1642,8 @@ "id": "067bf7c4", "metadata": {}, "source": [ - "The keyword-packing parameter can have any name, but `kwargs` is a common choice.\n", - "The result is a dictionary that maps from keywords to values." + "El parámetro que empaqueta keywords puede tener cualquier nombre, pero `kwargs` es una elección común.\n", + "El resultado es un diccionario que asocia keywords con valores.\n" ] }, { @@ -1661,10 +1661,10 @@ "id": "07be77f3", "metadata": {}, "source": [ - "In this example, the value of `kwargs` is printed, but otherwise it has no effect.\n", + "En este ejemplo, se imprime el valor de `kwargs`, pero por lo demás no tiene ningún efecto.\n", "\n", - "But the `**` operator can also be used in an argument list to unpack a dictionary.\n", - "For example, here's a version of `mean` that packs any keyword arguments it gets and then unpacks them as keyword arguments for `sum`." + "Pero el operador `**` también se puede usar en una lista de argumentos para desempaquetar un diccionario.\n", + "Por ejemplo, aquí tienes una versión de `mean` que empaqueta cualquier argumento de palabra clave que recibe y luego los desempaqueta como argumentos de palabra clave para `sum`.\n" ] }, { @@ -1683,8 +1683,8 @@ "id": "ba00858c", "metadata": {}, "source": [ - "Now if we call `mean` with `start` as a keyword argument, it gets passed along to sum, which uses it as the starting point of the summation.\n", - "In the following example `start=3` adds `3` to the sum before computing the mean, so the sum is `6` and the result is `3`." + "Ahora, si llamamos a `mean` con `start` como argumento de palabra clave, se pasa a sum, que lo usa como punto de partida de la suma.\n", + "En el siguiente ejemplo `start=3` añade `3` a la suma antes de calcular la media, así que la suma es `6` y el resultado es `3`.\n" ] }, { @@ -1702,7 +1702,7 @@ "id": "949a2ca3", "metadata": {}, "source": [ - "As another example, if we have a dictionary with keys `x` and `y`, we can use it with the unpack operator to create a `Point` object." + "Como otro ejemplo, si tenemos un diccionario con las claves `x` e `y`, podemos usarlo con el operador de desempaquetado para crear un objeto `Point`.\n" ] }, { @@ -1721,7 +1721,7 @@ "id": "8aaf128a", "metadata": {}, "source": [ - "Without the unpack operator, `d` is treated as a single positional argument, so it gets assigned to `x`, and we get a `TypeError` because there's no second argument to assign to `y`." + "Sin el operador de desempaquetado, `d` se trata como un único argumento posicional, así que se asigna a `x`, y obtenemos un `TypeError` porque no hay un segundo argumento que asignar a `y`.\n" ] }, { @@ -1744,7 +1744,7 @@ "id": "e8acb958", "metadata": {}, "source": [ - "When you are working with functions that have a large number of keyword arguments, it is often useful to create and pass around dictionaries that specify frequently used options." + "Cuando trabajas con funciones que tienen un gran número de argumentos de palabra clave, a menudo es útil crear y pasar diccionarios que especifican opciones usadas con frecuencia.\n" ] }, { @@ -1765,11 +1765,11 @@ "id": "e046e382", "metadata": {}, "source": [ - "## Debugging\n", + "## Depuración\n", "\n", - "In previous chapters, we used `doctest` to test functions.\n", - "For example, here's a function called `add` that takes two numbers and returns their sum.\n", - "In includes a doctest that checks whether `2 + 2` is `4`." + "En capítulos anteriores, usamos `doctest` para probar funciones.\n", + "Por ejemplo, aquí tienes una función llamada `add` que recibe dos números y devuelve su suma.\n", + "Incluye un doctest que comprueba si `2 + 2` es `4`.\n" ] }, { @@ -1793,7 +1793,7 @@ "id": "a5e332d3", "metadata": {}, "source": [ - "This function takes a function object and runs its doctests." + "Esta función recibe un objeto función y ejecuta sus doctests.\n" ] }, { @@ -1814,7 +1814,7 @@ "id": "2d752a40", "metadata": {}, "source": [ - "So we can test `add` like this." + "Así que podemos probar `add` así.\n" ] }, { @@ -1832,10 +1832,10 @@ "id": "77d36e9b", "metadata": {}, "source": [ - "There's no output, which means all tests passed.\n", + "No hay salida, lo que significa que todas las pruebas pasaron.\n", "\n", - "Python provides another tool for running automated tests, called `unittest`.\n", - "It is a little more complicated to use, but here's an example." + "Python proporciona otra herramienta para ejecutar pruebas automatizadas, llamada `unittest`.\n", + "Es un poco más complicada de usar, pero aquí tienes un ejemplo.\n" ] }, { @@ -1859,15 +1859,15 @@ "id": "59b4212a", "metadata": {}, "source": [ - "First we import `TestCase`, which is a class in the `unittest` module.\n", - "To use it, we have to define a new class that inherits from `TestCase` and provides at least one test method.\n", - "The name of the test method must begin with `test` and should indicate which function it tests.\n", + "Primero importamos `TestCase`, que es una clase del module `unittest`.\n", + "Para usarla, tenemos que definir una nueva clase que herede de `TestCase` y proporcione al menos un método de test.\n", + "El nombre del método de test debe empezar con `test` y debería indicar qué función prueba.\n", "\n", - "In this example, `test_add` tests the `add` function by calling it, saving the result, and invoking `assertEqual`, which is inherited from `TestCase`.\n", - "`assertEqual` takes two arguments and checks whether they are equal.\n", + "En este ejemplo, `test_add` prueba la función `add` llamándola, guardando el resultado e invocando `assertEqual`, que se hereda de `TestCase`.\n", + "`assertEqual` recibe dos argumentos y comprueba si son iguales.\n", "\n", - "In order to run this test method, we have to run a function in `unittest` called `main` and provide several keyword arguments.\n", - "The following function shows the details -- if you are curious, you can ask a virtual assistant to explain how it works." + "Para ejecutar este método de test, tenemos que ejecutar una función de `unittest` llamada `main` y proporcionar varios argumentos de palabra clave.\n", + "La siguiente función muestra los detalles -- si tienes curiosidad, puedes pedirle a un asistente virtual que explique cómo funciona.\n" ] }, { @@ -1888,11 +1888,11 @@ "id": "5409ea0c", "metadata": {}, "source": [ - "`run_unittest` does not take `TestExample` as an argument -- instead, it searches for classes that inherit from `TestCase`.\n", - "Then it searches for methods that begin with `test` and runs them.\n", - "This process is called **test discovery**.\n", + "`run_unittest` no recibe `TestExample` como argumento -- en su lugar, busca clases que heredan de `TestCase`.\n", + "Luego busca métodos que empiezan con `test` y los ejecuta.\n", + "Este proceso se llama **test discovery**.\n", "\n", - "Here's what happens when we call `run_unittest`." + "Esto es lo que pasa cuando llamamos a `run_unittest`.\n" ] }, { @@ -1910,10 +1910,10 @@ "id": "7775304a", "metadata": {}, "source": [ - "`unittest.main` reports the number of tests it ran and the results.\n", - "In this case `OK` indicates that the tests passed.\n", + "`unittest.main` informa del número de pruebas que ejecutó y de los resultados.\n", + "En este caso `OK` indica que las pruebas pasaron.\n", "\n", - "To see what happens when a test fails, we'll add an incorrect test method to `TestExample`." + "Para ver qué pasa cuando un test falla, añadiremos un método de test incorrecto a `TestExample`.\n" ] }, { @@ -1935,7 +1935,7 @@ "id": "96810614", "metadata": {}, "source": [ - "Here's what happens when we run the tests." + "Esto es lo que pasa cuando ejecutamos las pruebas.\n" ] }, { @@ -1953,10 +1953,10 @@ "id": "64b743cb", "metadata": {}, "source": [ - "The report includes the test method that failed and an error message showing where.\n", - "The summary indicates that two tests ran and one failed.\n", + "El informe incluye el método de test que falló y un mensaje de error que muestra dónde.\n", + "El resumen indica que se ejecutaron dos pruebas y una falló.\n", "\n", - "In the exercises below, I'll suggest some prompts you can use to ask a virtual assistant for more information about `unittest`." + "En los ejercicios siguientes, sugeriré algunos prompts que puedes usar para pedir más información sobre `unittest` a un asistente virtual.\n" ] }, { @@ -1964,22 +1964,22 @@ "id": "7d0fb256", "metadata": {}, "source": [ - "## Glossary\n", + "## Glosario\n", "\n", - "**factory:**\n", - " A function used to create objects, often passed as a parameter to a function.\n", + "**fábrica:**\n", + " Una función usada para crear objetos, que a menudo se pasa como parámetro a una función.\n", "\n", "**conditional expression:**\n", - "An expression that uses a conditional to select one of two values.\n", + "Una expresión que usa un condicional para seleccionar uno de dos valores.\n", "\n", - "**list comprehension:**\n", - "A concise way to loop through a sequence and create a list.\n", + "**comprensión de listas:**\n", + "Una forma concisa de recorrer una secuencia y crear una lista.\n", "\n", - "**generator expression:**\n", - "Similar to a list comprehension except that it does not create a list.\n", + "**expresión generadora:**\n", + "Similar a una comprensión de listas, excepto que no crea una lista.\n", "\n", "**test discovery:**\n", - "A process used to find and run tests." + "Un proceso usado para encontrar y ejecutar pruebas.\n" ] }, { @@ -1987,7 +1987,7 @@ "id": "bc03f15d", "metadata": {}, "source": [ - "## Exercises" + "## Ejercicios\n" ] }, { @@ -2010,27 +2010,27 @@ "id": "fe10415e", "metadata": {}, "source": [ - "### Ask a virtual assistant\n", + "### Pregunta a un asistente virtual\n", "\n", - "There are a few topics in this chapter you might want to learn about.\n", + "Hay algunos temas de este capítulo sobre los que quizá quieras aprender más.\n", "\n", - "* \"What are the methods and operators of Python's set class?\"\n", + "* \"¿Cuáles son los métodos y operadores de la clase conjunto de Python?\"\n", "\n", - "* \"What are the methods and operators of Python's Counter class?\"\n", + "* \"¿Cuáles son los métodos y operadores de la clase Counter de Python?\"\n", "\n", - "* \"What is the difference between a Python list comprehension and a generator expression?\"\n", + "* \"¿Cuál es la diferencia entre una comprensión de listas de Python y una expresión generadora?\"\n", "\n", - "* \"When should I use Python's `namedtuple` rather than define a new class?\"\n", + "* \"¿Cuándo debería usar `namedtuple` de Python en lugar de definir una nueva clase?\"\n", "\n", - "* \"What are some uses of packing and unpacking keyword arguments?\"\n", + "* \"¿Cuáles son algunos usos de empaquetar y desempaquetar argumentos de palabra clave?\"\n", "\n", - "* \"How does `unittest` do test discovery?\"\n", + "* \"¿Cómo hace `unittest` test discovery?\"\n", "\n", - "* \"Along with `assertEqual`, what are the most commonly used methods in `unittest.TestCase`?\"\n", + "* \"Junto con `assertEqual`, ¿cuáles son los métodos más usados en `unittest.TestCase`?\"\n", "\n", - "* \"What are the pros and cons of `doctest` and `unittest`?\"\n", + "* \"¿Cuáles son los pros y los contras de `doctest` y `unittest`?\"\n", "\n", - "For the following exercises, consider asking a virtual assistant for help, but as always, remember to test the results." + "Para los siguientes ejercicios, considera pedir ayuda a un asistente virtual, pero como siempre, recuerda probar los resultados.\n" ] }, { @@ -2038,9 +2038,9 @@ "id": "c61ecde2", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "One of the exercises in Chapter 7 asks for a function called `uses_none` that takes a word and a string of forbidden letters, and returns `True` if the word does not use any of the letters. Here's a solution." + "Uno de los ejercicios del Capítulo 7 pide una función llamada `uses_none` que recibe una palabra y un string de letras prohibidas, y devuelve `True` si la palabra no usa ninguna de esas letras. Aquí tienes una solución.\n" ] }, { @@ -2062,8 +2062,8 @@ "id": "b558b8b3", "metadata": {}, "source": [ - "Write a version of this function that uses `set` operations instead of a `for` loop.\n", - "Hint: ask a VA, \"How do I compute the intersection of Python sets?\"" + "Escribe una versión de esta función que use operaciones de `set` en lugar de un bucle `for`.\n", + "Pista: pregunta a un asistente virtual: \"¿Cómo calculo la intersección de conjuntos de Python?\"\n" ] }, { @@ -2073,7 +2073,7 @@ "tags": [] }, "source": [ - "You can use this outline to get started." + "Puedes usar este esquema para empezar.\n" ] }, { @@ -2140,12 +2140,12 @@ "id": "d2d670cf", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Scrabble is a board game where the objective is to use letter tiles to spell words.\n", - "For example, if we have tiles with the letters `T`, `A`, `B`, `L`, `E`, we can spell `BELT` and `LATE` using a subset of the tiles -- but we can't spell `BEET` because we don't have two `E`s.\n", + "Scrabble es un juego de mesa donde el objetivo es usar fichas de letras para formar palabras.\n", + "Por ejemplo, si tenemos fichas con las letras `T`, `A`, `B`, `L`, `E`, podemos formar `BELT` y `LATE` usando un subconjunto de las fichas -- pero no podemos formar `BEET` porque no tenemos dos `E`.\n", "\n", - "Write a function that takes a string of letters and a word, and checks whether the letters can spell the word, taking into account how many times each letter appears." + "Escribe una función que reciba un string de letras y una palabra, y compruebe si las letras pueden formar la palabra, teniendo en cuenta cuántas veces aparece cada letra.\n" ] }, { @@ -2155,7 +2155,7 @@ "tags": [] }, "source": [ - "You can use the following outline to get started." + "Puedes usar el siguiente esquema para empezar.\n" ] }, { @@ -2207,9 +2207,9 @@ "id": "de2dc099", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "In one of the exercises from [Chapter 17](chapter_inheritance), my solution to `has_straightflush` uses the following method, which partitions a `PokerHand` into a list of four hands, where each hand contains cards of the same suit." + "En uno de los ejercicios del [Capítulo 17](chapter_inheritance), mi solución para `has_straightflush` usa el siguiente método, que particiona una `PokerHand` en una lista de cuatro manos, donde cada mano contiene cartas del mismo palo.\n" ] }, { @@ -2236,7 +2236,7 @@ "id": "cd04a7a3", "metadata": {}, "source": [ - "Write a simplified version of this function using a `defaultdict`." + "Escribe una versión simplificada de esta función usando un `defaultdict`.\n" ] }, { @@ -2246,7 +2246,7 @@ "tags": [] }, "source": [ - "Here's an outline of the `PokerHand` class and the `partition_suits` function you can use to get started." + "Aquí tienes un esquema de la clase `PokerHand` y de la función `partition_suits` que puedes usar para empezar.\n" ] }, { @@ -2281,7 +2281,7 @@ "tags": [] }, "source": [ - "To test your code, we'll make a deck and shuffle it." + "Para probar tu código, crearemos un mazo y lo barajaremos.\n" ] }, { @@ -2305,7 +2305,7 @@ "tags": [] }, "source": [ - "Then create a `PokerHand` and add seven cards to it." + "Luego crea una `PokerHand` y añádele siete cartas.\n" ] }, { @@ -2333,7 +2333,7 @@ "tags": [] }, "source": [ - "If you invoke `partition` and print the results, each hand should contain cards of one suit only." + "Si invocas `partition` e imprimes los resultados, cada mano debería contener solo cartas de un palo.\n" ] }, { @@ -2357,9 +2357,9 @@ "id": "218798e3", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's the function from Chapter 11 that computes Fibonacci numbers." + "Aquí tienes la función del Capítulo 11 que calcula números de Fibonacci.\n" ] }, { @@ -2384,7 +2384,7 @@ "id": "6acab624", "metadata": {}, "source": [ - "Write a version of this function with a single return statement that use two conditional expressions, one nested inside the other." + "Escribe una versión de esta función con una sola sentencia retorno que use dos expresiones condicionales, una anidada dentro de la otra.\n" ] }, { @@ -2426,9 +2426,9 @@ "id": "2deb0e1f", "metadata": {}, "source": [ - "### Exercise\n", - "The following is a function that computes the binomial coefficient\n", - "recursively." + "### Ejercicio\n", + "La siguiente es una función que calcula el coeficiente binomial\n", + "de forma recursiva.\n" ] }, { @@ -2460,10 +2460,10 @@ "id": "656c61f6", "metadata": {}, "source": [ - "Rewrite the body of the function using nested conditional expressions.\n", + "Reescribe el cuerpo de la función usando expresiones condicionales anidadas.\n", "\n", - "This function is not very efficient because it ends up computing the same values over and over.\n", - "Make it more efficient by memoizing it, as described in [Chapter 10](section_memos)." + "Esta función no es muy eficiente porque acaba calculando los mismos valores una y otra vez.\n", + "Hazla más eficiente memoizándola, como se describe en el [Capítulo 10](section_memos).\n" ] }, { @@ -2491,9 +2491,9 @@ "id": "921719dc", "metadata": {}, "source": [ - "### Exercise\n", + "### Ejercicio\n", "\n", - "Here's the `__str__` method from the `Deck` class in [Chapter 17](section_print_deck)." + "Aquí tienes el método `__str__` de la clase `Deck` en el [Capítulo 17](section_print_deck).\n" ] }, { @@ -2517,7 +2517,7 @@ "id": "27f189cf", "metadata": {}, "source": [ - "Write a more concise version of this method with a list comprehension or generator expression." + "Escribe una versión más concisa de este método con una comprensión de listas o una expresión generadora.\n" ] }, { @@ -2539,7 +2539,7 @@ "tags": [] }, "source": [ - "You can use this example to test your solution." + "Puedes usar este ejemplo para probar tu solución.\n" ] }, { @@ -2571,13 +2571,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n" ] } ], @@ -2603,4 +2605,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/chap19.ipynb b/chapters/chap19.ipynb index 4d86fb8..be0fc26 100644 --- a/chapters/chap19.ipynb +++ b/chapters/chap19.ipynb @@ -5,9 +5,9 @@ "id": "1331faa1", "metadata": {}, "source": [ - "You can order print and ebook versions of *Think Python 3e* from\n", - "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) and\n", - "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325)." + "Puedes encargar versiones impresas y ebook de *Think Python 3e* en\n", + "[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y\n", + "[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325).\n" ] }, { @@ -15,7 +15,7 @@ "id": "171aca73", "metadata": {}, "source": [ - "# Final thoughts" + "# Reflexiones finales\n" ] }, { @@ -23,19 +23,19 @@ "id": "4d551c99", "metadata": {}, "source": [ - "Learning to program is not easy, but if you made it this far, you are off to a good start.\n", - "Now I have some suggestions for ways you can keep learning and apply what you have learned.\n", + "Aprender a programar no es fácil, pero si has llegado hasta aquí, has empezado con buen pie.\n", + "Ahora tengo algunas sugerencias sobre cómo puedes seguir aprendiendo y aplicar lo que has aprendido.\n", "\n", - "This book is meant to be a general introduction to programming, so we have not focused on specific applications.\n", - "Depending on your interests, there are any number of areas where you can apply your new skills.\n", + "Este libro pretende ser una introducción general a la programación, así que no nos hemos centrado en aplicaciones específicas.\n", + "Según tus intereses, hay muchas áreas en las que puedes aplicar tus nuevas habilidades.\n", "\n", - "If you are interested in Data Science, there are three books of mine you might like:\n", + "Si te interesa la ciencia de datos, hay tres libros míos que podrían gustarte:\n", "\n", "* *Think Stats: Exploratory Data Analysis*, O'Reilly Media, 2014.\n", "\n", "* *Think Bayes: Bayesian Statistics in Python*, O'Reilly Media, 2021.\n", "\n", - "* *Think DSP: Digital Signal Processing in Python*, O'Reilly Media, 2016." + "* *Think DSP: Digital Signal Processing in Python*, O'Reilly Media, 2016.\n" ] }, { @@ -43,13 +43,13 @@ "id": "cceabe36", "metadata": {}, "source": [ - "If you are interested in physical modeling and complex systems, you might like:\n", + "Si te interesan el modelado físico y los sistemas complejos, quizá te gusten:\n", "\n", "* *Modeling and Simulation in Python: An Introduction for Scientists and Engineers*, No Starch Press, 2023.\n", "\n", "* *Think Complexity: Complexity Science and Computational Modeling*, O'Reilly Media, 2018.\n", "\n", - "These use NumPy, SciPy, pandas, and other Python libraries for data science and scientific computing." + "Estos libros usan NumPy, SciPy, pandas y otras librerías de Python para ciencia de datos y computación científica.\n" ] }, { @@ -57,13 +57,13 @@ "id": "54a39121", "metadata": {}, "source": [ - "This book tries to find a balance between general principles of programming and details of Python.\n", - "As a result, it does not include every feature of the Python language.\n", - "For more about Python, and good advice about how to use it, I recommend *Fluent Python: Clear, Concise, and Effective Programming*, second edition by Luciano Ramalho, O'Reilly Media, 2022.\n", + "Este libro intenta encontrar un equilibrio entre los principios generales de la programación y los detalles de Python.\n", + "Como resultado, no incluye todas las características del lenguaje Python.\n", + "Para saber más sobre Python, y para buenos consejos sobre cómo usarlo, recomiendo *Fluent Python: Clear, Concise, and Effective Programming*, segunda edición de Luciano Ramalho, O'Reilly Media, 2022.\n", "\n", - "After an introduction to programming, a common next step is to learn about data structures and algorithms.\n", - "I have a work in progress on this topic, called *Data Structures and Information Retrieval in Python*.\n", - "A free electronic version is available from Green Tea Press at ." + "Después de una introducción a la programación, un siguiente paso habitual es aprender sobre estructuras de datos y algoritmos.\n", + "Tengo una obra en curso sobre este tema, llamada *Data Structures and Information Retrieval in Python*.\n", + "Hay una versión electrónica gratuita disponible en Green Tea Press en .\n" ] }, { @@ -71,11 +71,11 @@ "id": "a1598510", "metadata": {}, "source": [ - "As you work on more complex programs, you will encounter new challenges.\n", - "You might find it helpful to review the sections in this book about debugging.\n", - "In particular, remember the Six R's of debugging from [Chapter 12](section_debugging_12): reading, running, ruminating, rubber-ducking, retreating, and resting.\n", + "A medida que trabajes en programas más complejos, encontrarás nuevos desafíos.\n", + "Puede resultarte útil repasar las secciones de este libro sobre depuración.\n", + "En particular, recuerda las seis R de la depuración del [Capítulo 12](section_deerrorging_12) (por sus nombres en inglés): leer, ejecutar, reflexionar, explicárselo a un patito de goma, tomar distancia y descansar.\n", "\n", - "This book suggests tools to help with debugging, including the `print` and `repr` functions, the `structshape` function in [Chapter 11](section_debugging_11) -- and the built-in functions `isinstance`, `hasattr`, and `vars` in [Chapter 14](section_debugging_14)." + "Este libro sugiere herramientas para ayudar con la depuración, incluidas las funciones `print` y `repr`, la función `structshape` del [Capítulo 11](section_deerrorging_11) -- y las funciones integradas `isinstance`, `hasattr` y `vars` del [Capítulo 14](section_deerrorging_14).\n" ] }, { @@ -83,12 +83,12 @@ "id": "fb4dd345", "metadata": {}, "source": [ - "It also suggests tools for testing programs, including the `assert` statement, the `doctest` module, and the `unittest` module.\n", - "Including tests in your programs is one of the best ways to prevent and detect errors, and save time debugging.\n", + "También sugiere herramientas para probar programas, incluidas la sentencia `assert`, el módulo `doctest` y el módulo `unittest`.\n", + "Incluir pruebas en tus programas es una de las mejores formas de prevenir y detectar errores, y de ahorrar tiempo en depuración.\n", "\n", - "But the best kind of debugging is the kind you don't have to do.\n", - "If you use an incremental development process as described in [Chapter 6](section_incremental) -- and test as you go -- you will make fewer errors and find them more quickly when you do.\n", - "Also, remember encapsulation and generalization from [Chapter 4](section_encapsulation), which is particularly useful when you are developing code in Jupyter notebooks." + "Pero la mejor depuración es el que no tienes que hacer.\n", + "Si usas un proceso de desarrollo incremental como se describe en el [Capítulo 6](section_incremental) -- y pruebas a medida que avanzas -- cometerás menos errores y los encontrarás más rápido cuando aparezcan.\n", + "Además, recuerda la encapsulación y la generalización del [Capítulo 4](section_encapsulation), que son especialmente útiles cuando desarrollas código en Jupyter notebooks.\n" ] }, { @@ -96,16 +96,16 @@ "id": "0d29933e", "metadata": {}, "source": [ - "Throughout this book, I've suggested ways to use virtual assistants to help you learn, program, and debug.\n", - "I hope you are finding these tools useful.\n", + "A lo largo de este libro, he sugerido formas de usar asistentes virtuales para ayudarte a aprender, programar y depurar.\n", + "Espero que estas herramientas te estén resultando útiles.\n", "\n", - "In additional to virtual assistants like ChatGPT, you might also want to use a tool like Copilot that autocompletes code as you type.\n", - "I did not recommend using these tools, initially, because they can be overwhelming for beginners.\n", - "But you might want to explore them now.\n", + "Además de asistentes virtuales como ChatGPT, quizá también quieras usar una herramienta como Copilot, que autocompleta código mientras escribes.\n", + "Al principio no recomendé usar estas herramientas porque pueden resultar abrumadoras para principiantes.\n", + "Pero quizá ahora quieras explorarlas.\n", "\n", - "Using AI tools effectively requires some experimentation and reflection to find a flow that works for you.\n", - "If you think it's a nuisance to copy code from ChatGPT to Jupyter, you might prefer something like Copilot.\n", - "But the cognitive work you do to compose a prompt and interpret the response can be as valuable as the code the tool generates, in the same vein as rubber duck debugging." + "Usar herramientas de AI de forma efectiva requiere algo de experimentación y reflexión para encontrar un flujo que funcione para ti.\n", + "Si te resulta molesto copiar código de ChatGPT a Jupyter, quizá prefieras algo como Copilot.\n", + "Pero el trabajo cognitivo que haces para componer un prompt e interpretar la respuesta puede ser tan valioso como el código que genera la herramienta, en la misma línea que la depuración con patito de goma.\n" ] }, { @@ -113,17 +113,17 @@ "id": "c28d6815", "metadata": {}, "source": [ - "As you gain programming experience, you might want to explore other development environments.\n", - "I think Jupyter notebooks are a good place to start, but they are relatively new and not as widely-used as conventional integrated development environments (IDE).\n", - "For Python, the most popular IDEs include PyCharm and Spyder -- and Thonny, which is often recommended for beginners.\n", - "Other IDEs, like Visual Studio Code and Eclipse, work with other programming languages as well.\n", - "Or, as a simpler alternative, you can write Python programs using any text editor you like.\n", - "\n", - "As you continue your programming journey, you don't have to go alone!\n", - "If you live in or near a city, there's a good chance there is a Python user group you can join.\n", - "These groups are usually friendly to beginners, so don't be afraid.\n", - "If there is no group near you, you might be able to join events remotely.\n", - "Also, keep an eye out for regional Python conferences." + "A medida que ganes experiencia programando, quizá quieras explorar otros entornos de desarrollo.\n", + "Creo que Jupyter notebooks es un buen lugar para empezar, pero son relativamente nuevos y no se usan tanto como los entornos de desarrollo integrados (IDE) convencionales.\n", + "Para Python, los IDE más populares incluyen PyCharm y Spyder -- y Thonny, que suele recomendarse para principiantes.\n", + "Otros IDE, como Visual Studio Código y Eclipse, también funcionan con otros lenguajes de programación.\n", + "O, como alternativa más sencilla, puedes escribir programas en Python usando cualquier editor de texto que te guste.\n", + "\n", + "Mientras continúas tu viaje en la programación, no tienes que hacerlo en soledad.\n", + "Si vives en una ciudad o cerca de una, es muy probable que haya un grupo de usuarios de Python al que puedas unirte.\n", + "Estos grupos suelen ser amables con principiantes, así que no tengas miedo.\n", + "Si no hay ningún grupo cerca de ti, quizá puedas unirte a eventos de forma remota.\n", + "Además, mantente atento a conferencias regionales de Python.\n" ] }, { @@ -131,12 +131,12 @@ "id": "28cb22bf", "metadata": {}, "source": [ - "One of the best ways to improve your programming skills is to learn another language.\n", - "If you are interested in statistics and data science, you might want to learn R.\n", - "But I particularly recommend learning a functional language like Racket or Elixir.\n", - "Functional programming requires a different kind of thinking, which changes the way you think about programs.\n", + "Una de las mejores formas de mejorar tus habilidades de programación es aprender otro lenguaje.\n", + "Si te interesan la estadística y ciencia de datos, quizá quieras aprender R.\n", + "Pero recomiendo especialmente aprender un lenguaje funcional como Racket o Elixir.\n", + "La programación funcional requiere una forma distinta de pensar, lo que cambia la manera en que piensas sobre los programas.\n", "\n", - "Good luck!" + "¡Buena suerte!\n" ] }, { @@ -154,13 +154,15 @@ "tags": [] }, "source": [ - "[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n", + "[Think Python: 3.ª edición](https://allendowney.github.io/ThinkPython/index.html)\n", "\n", "Copyright 2024 [Allen B. Downey](https://allendowney.com)\n", "\n", - "Code license: [MIT License](https://mit-license.org/)\n", + "Traducción al español por midudev (Miguel Ángel Durán).\n", "\n", - "Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia del código: [MIT License](https://mit-license.org/)\n", + "\n", + "Licencia del texto: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n" ] } ], @@ -185,4 +187,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/chapters/jupyter_intro.ipynb b/chapters/jupyter_intro.ipynb index 54f1042..dee8f80 100644 --- a/chapters/jupyter_intro.ipynb +++ b/chapters/jupyter_intro.ipynb @@ -7,20 +7,20 @@ "tags": [] }, "source": [ - "# *Think Python* on Jupyter\n", + "# *Think Python* en Jupyter\n", "\n", - "This is an introduction to Jupyter notebooks for people reading the third edition of [*Think Python*](https://greenteapress.com/wp/think-python-3rd-edition) by Allen B. Downey.\n", + "Esta es una introducción a los Jupyter notebooks para personas que leen la tercera edición de [*Think Python*](https://greenteapress.com/wp/think-python-3rd-edition) de Allen B. Downey.\n", "\n", - "A Jupyter notebook is a document that contains text, code, and results from running the code.\n", - "You can read a notebook like a book, but you can also run the code, modify it, and develop new programs.\n", + "Un Jupyter notebook es un documento que contiene texto, código y resultados de ejecutar el código.\n", + "Puedes leer un notebook como un libro, pero también puedes ejecutar el código, modificarlo y desarrollar nuevos programas.\n", "\n", - "Jupyter notebooks run in a web browser, so you can run them without installing any new software.\n", - "But they have to connect to a Jupyter server.\n", + "Los Jupyter notebooks se ejecutan en un navegador web, así que puedes usarlos sin instalar software nuevo.\n", + "Pero tienen que conectarse a un servidor Jupyter.\n", "\n", - "You can install and run a server yourself, but to get started it is easier to use a service like [Colab](https://colab.research.google.com/), which is operated by Google.\n", + "Puedes instalar y ejecutar un servidor tú mismo, pero para empezar es más fácil usar un servicio como [Colab](https://colab.research.google.com/), operado por Google.\n", "\n", - "[On the starting page for the book](https://allendowney.github.io/ThinkPython) you will find a link for each chapter.\n", - "If you click on one of these links, it opens a notebook on Colab." + "[En la página de inicio del libro](https://allendowney.github.io/ThinkPython) encontrarás un enlace para cada capítulo.\n", + "Si haces clic en uno de estos enlaces, se abre un notebook en Colab." ] }, { @@ -30,9 +30,9 @@ "tags": [] }, "source": [ - "If you are reading this notebook on Colab, you should see an orange logo in the upper left that looks like the letters `CO`.\n", + "Si estás leyendo este notebook en Colab, deberías ver un logotipo naranja en la esquina superior izquierda que se parece a las letras `CO`.\n", "\n", - "If you are not running this notebook on Colab, [you can click here to open it on Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." + "Si no estás ejecutando este notebook en Colab, [puedes hacer clic aquí para abrirlo en Colab](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)." ] }, { @@ -42,12 +42,12 @@ "tags": [] }, "source": [ - "## What is a notebook?\n", + "## ¿Qué es un notebook?\n", "\n", - "A Jupyter notebook is made up of cells, where each cell contains either text or code.\n", - "This cell contains text. \n", + "Un Jupyter notebook está compuesto por celdas; cada celda contiene texto o código.\n", + "Esta celda contiene texto. \n", "\n", - "The following cell contains code." + "La siguiente celda contiene código." ] }, { @@ -74,13 +74,13 @@ "tags": [] }, "source": [ - "Click on the previous cell to select it.\n", - "You should see a button on the left with a triangle inside a circle, which is the icon for \"Play\".\n", - "If you press this button, Jupyter runs the code in the cell and displays the result.\n", + "Haz clic en la celda anterior para seleccionarla.\n", + "Deberías ver un botón a la izquierda con un triángulo dentro de un círculo, que es el icono de \"Play\".\n", + "Si pulsas este botón, Jupyter ejecuta el código de la celda y muestra el resultado.\n", "\n", - "When you run code in a notebook for the first time, it might take a few seconds to start.\n", - "And if it's a notebook you didn't write, you might get a warning message.\n", - "If you are running a notebook from a source you trust, which I hope includes me, you can press \"Run Anyway\"." + "Cuando ejecutas código en un notebook por primera vez, puede tardar unos segundos en iniciar.\n", + "Y si es un notebook que no escribiste tú, puede que aparezca un mensaje de advertencia.\n", + "Si estás ejecutando un notebook de una fuente en la que confías, que espero que me incluya, puedes pulsar \"Run Anyway\"." ] }, { @@ -90,11 +90,11 @@ "tags": [] }, "source": [ - "Instead of clicking the \"Play\" button, you can also run the code in a cell by holding down `Shift` and pressing `Enter`.\n", + "En lugar de hacer clic en el botón \"Play\", también puedes ejecutar el código de una celda manteniendo pulsado `Shift` y presionando `Enter`.\n", "\n", - "If you are running this notebook on Colab, you should see buttons in the top left that say \"+ Code\" and \"+ Text\". The first one adds a code cell and the second adds a text cell.\n", - "If you want to try them out, select this cell by clicking on it, then press the \"+ Text\" button.\n", - "A new cell should appear below this one." + "Si estás ejecutando este notebook en Colab, deberías ver botones en la parte superior izquierda que dicen \"+ Código\" y \"+ Text\". El primero añade una celda de código y el segundo añade una celda de texto.\n", + "Si quieres probarlos, selecciona esta celda haciendo clic en ella y luego pulsa el botón \"+ Text\".\n", + "Debería aparecer una nueva celda debajo de esta." ] }, { @@ -104,54 +104,54 @@ "tags": [] }, "source": [ - "Add some text to the cell.\n", - "You can use the buttons to format it, or you can mark up the text using [Markdown](https://www.markdownguide.org/basic-syntax/).\n", - "When you are done, hold down `Shift` and press `Enter`, which will format the text you just typed and then move to the next cell." + "Añade algo de texto a la celda.\n", + "Puedes usar los botones para darle formato, o puedes marcar el texto usando [Markdown](https://www.markdownguide.org/basic-syntax/).\n", + "Cuando termines, mantén pulsado `Shift` y presiona `Enter`, lo que dará formato al texto que acabas de escribir y pasará a la siguiente celda." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "At any time Jupyter is in one of two modes:\n", + "En cualquier momento Jupyter está en uno de dos modos:\n", "\n", - "* In **command mode**, you can perform operations that affect cells, like adding and removing entire cells.\n", + "* En **command mode**, puedes realizar operaciones que afectan a las celdas, como añadir y eliminar celdas completas.\n", "\n", - "* In **edit mode**, you can edit the contents of a cell.\n", + "* En **edit mode**, puedes editar el contenido de una celda.\n", "\n", - "With text cells, it is obvious which mode you are in.\n", - "In edit mode, the cell is split vertically, with the text you are editing on the left and the formatted text on the right.\n", - "And you'll see text editing tools across the top.\n", - "In command mode, you see only the formatted text.\n", + "Con las celdas de texto, es evidente en qué modo estás.\n", + "En edit mode, la celda se divide verticalmente, con el texto que estás editando a la izquierda y el texto formateado a la derecha.\n", + "Y verás herramientas de edición de texto en la parte superior.\n", + "En command mode, solo ves el texto formateado.\n", "\n", - "With code cells, the difference is more subtle, but if there's a cursor in the cell, you are in edit mode.\n", + "Con las celdas de código, la diferencia es más sutil, pero si hay un cursor en la celda, estás en edit mode.\n", "\n", - "To go from edit mode to command mode, press `ESC`.\n", - "To go from command mode to edit mode, press `Enter`." + "Para pasar de edit mode a command mode, pulsa `ESC`.\n", + "Para pasar de command mode a edit mode, pulsa `Enter`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "When you are done working on a notebook, you can close the window, but any changes you made will disappear.\n", - "If you make any changes you want to keep, open the File menu in the upper left.\n", - "You'll see several ways you can save the notebook.\n", + "Cuando termines de trabajar en un notebook, puedes cerrar la ventana, pero cualquier cambio que hayas hecho desaparecerá.\n", + "Si haces cambios que quieres conservar, abre el menú File en la parte superior izquierda.\n", + "Verás varias formas de guardar el notebook.\n", "\n", - "* If you have a Google account, you can save the notebook in your Drive.\n", + "* Si tienes una cuenta de Google, puedes guardar el notebook en tu Drive.\n", "\n", - "* If you have a GitHub account, you can save it on GitHub.\n", + "* Si tienes una cuenta de GitHub, puedes guardarlo en GitHub.\n", "\n", - "* Or if you want to save the notebook on your computer, select \"Download\" and then \"Download .ipynb\" The suffix \".ipynb\" indicates that it is a notebook file, as opposed to \".py\", which indicates a file that contains Python code only." + "* O, si quieres guardar el notebook en tu ordenador, selecciona \"Download\" y luego \"Download .ipynb\". El sufijo \".ipynb\" indica que es un archivo notebook, a diferencia de \".py\", que indica un archivo que contiene solo código de Python." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Code for *Think Python*\n", + "## Código para *Think Python*\n", "\n", - "At the beginning of each notebook, you'll see a cell with code like this:" + "Al principio de cada notebook, verás una celda con código como esta:" ] }, { @@ -180,13 +180,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You don't need to know how this code works, but when you get to the end of the book, most of it will make sense.\n", - "As you might guess, it downloads a file -- specifically, it downloads `thinkpython.py`, which contains Python code provided specifically for this book.\n", - "The last line \"imports\" this code, which means we can use the code in the notebook.\n", + "No necesitas saber cómo funciona este código, pero cuando llegues al final del libro, la mayor parte tendrá sentido.\n", + "Como quizá imagines, descarga un archivo; en concreto, descarga `thinkpython.py`, que contiene código de Python proporcionado específicamente para este libro.\n", + "La última línea \"importa\" este código, lo que significa que podemos usar el código en el notebook.\n", "\n", - "In other chapters, you will see code that downloads `diagram.py`, which is used to generated the diagrams in the book, and `jupyturtle.py`, which is used in several chapters to create turtle graphics.\n", + "En otros capítulos, verás código que descarga `diagram.py`, que se usa para generar los diagramas del libro, y `jupyturtle.py`, que se usa en varios capítulos para crear turtle graphics.\n", "\n", - "In some places you will see a cell like this that begins with `%%expect`." + "En algunos lugares verás una celda como esta que empieza con `%%expect`." ] }, { @@ -213,17 +213,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`%%expect` is not part of Python -- it is a Jupyter \"magic command\" that indicates that we expect the cell to product an error.\n", - "When you see this command, it means that the error is deliberate, usually intended to warn you about a common pitfall." + "`%%expect` no forma parte de Python: es un \"magic command\" de Jupyter que indica que esperamos que la celda produzca un error.\n", + "Cuando veas este comando, significa que el error es deliberado, normalmente pensado para advertirte sobre una trampa común." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "For more about running Jupyter notebooks on Colab, [click here](https://colab.research.google.com/notebooks/basic_features_overview.ipynb).\n", + "Para saber más sobre cómo ejecutar Jupyter notebooks en Colab, [haz clic aquí](https://colab.research.google.com/notebooks/basic_features_overview.ipynb).\n", "\n", - "Or, if you are ready to get started, [click here to read Chapter 1](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." + "O, si ya estás listo para empezar, [haz clic aquí para leer el capítulo 1](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap01.ipynb)." ] }, { @@ -233,11 +233,13 @@ "tags": [] }, "source": [ - "*Think Python*, 3rd edition.\n", + "*Think Python*, 3.ª edición.\n", "\n", "Copyright 2023 [Allen B. Downey](https://allendowney.com)\n", "\n", - "License: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)" + "Licencia: [Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n", + "\n", + "Traducción al español por midudev (Miguel Ángel Durán)." ] }, { diff --git a/jb/_config.yml b/jb/_config.yml index f0b261f..65e043f 100644 --- a/jb/_config.yml +++ b/jb/_config.yml @@ -1,5 +1,5 @@ # Book settings -title: Think Python +title: Think Python en español author: Allen B. Downey latex: @@ -10,21 +10,27 @@ execute: execute_notebooks: 'off' repository: - url: https://github.com/AllenDowney/ThinkPython/tree/v3 + url: https://github.com/midudev/ThinkPython + branch: v3 html: + baseurl: https://libropython.es + favicon: extra_html/favicon.ico use_repository_button: true extra_footer: |
- Creative Commons License
- This work is licensed under a + Esta obra está bajo una - Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License + Licencia Creative Commons Atribución-NoComercial-CompartirIgual 4.0 Internacional . +
+ Traducción al español por midudev + (Miguel Ángel Durán). Obra original de Allen B. Downey.
parse: @@ -46,9 +52,23 @@ parse: - tasklist sphinx: + local_extensions: + full_book_pdf: _extensions + seo: _extensions/seo.py config: + language: es + html_title: Think Python en español + html_short_title: Libro Python + html_extra_path: + - extra_html + templates_path: + - _templates + html_static_path: + - _static + html_css_files: + - custom.css mathjax_path: https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js - mathjax_config: - tex2jax: + mathjax3_config: + tex: inlineMath: [["$","$"], ["\\(", "\\)"]] myst_update_mathjax: false diff --git a/jb/_extensions/full_book_pdf.py b/jb/_extensions/full_book_pdf.py new file mode 100644 index 0000000..8919f57 --- /dev/null +++ b/jb/_extensions/full_book_pdf.py @@ -0,0 +1,37 @@ +"""Site links for the public book build.""" + +PDF_FILENAME = "think-python-es.pdf" +PDF_TOOLTIP = "Descargar el libro completo en PDF" +SITE_HOME_URL = "https://libropython.es" + + +def update_site_links(app, pagename, templatename, context, doctree): + """Point site-level home/download links to their public targets.""" + context["theme_logo_link"] = SITE_HOME_URL + context["theme_site_home_url"] = SITE_HOME_URL + + header_buttons = context.get("header_buttons") + if not isinstance(header_buttons, list): + return + + pdf_button = { + "type": "link", + "url": context["pathto"](PDF_FILENAME, 1), + "tooltip": PDF_TOOLTIP, + "icon": "fas fa-file-pdf", + "label": "download-book-pdf-button", + } + + context["header_buttons"] = [ + pdf_button, + *( + button + for button in header_buttons + if button.get("label") != "download-buttons" + ), + ] + + +def setup(app): + app.connect("html-page-context", update_site_links, priority=700) + return {"parallel_read_safe": True, "parallel_write_safe": True} diff --git a/jb/_extensions/seo.py b/jb/_extensions/seo.py new file mode 100644 index 0000000..1678a2e --- /dev/null +++ b/jb/_extensions/seo.py @@ -0,0 +1,86 @@ +"""SEO metadata for the public book site.""" + +import html +import re + +SITE_URL = "https://libropython.es" +SITE_NAME = "Libro Python" +BOOK_TITLE = "Think Python en español" +AUTHOR = "Allen B. Downey" +TRANSLATOR = "midudev" +TWITTER_SITE = "@midudev" +THEME_COLOR = "#2d3748" +LOCALE = "es_ES" + +DEFAULT_DESCRIPTION = ( + "Think Python en español: introducción gratuita a Python de Allen B. Downey. " + "3.ª edición traducida con capítulos online, notebooks en Colab y PDF descargable." +) + +PAGE_DESCRIPTIONS = { + "index": DEFAULT_DESCRIPTION, +} + + +def _page_url(app, pagename: str) -> str: + base = SITE_URL.rstrip("/") + if pagename in {app.config.root_doc, "index"}: + return f"{base}/" + return f"{base}/{pagename}.html" + + +_TAG_RE = re.compile(r"<[^>]+>") + + +def _strip_html(value: str) -> str: + """Return *value* without HTML tags and with entities decoded. + + Sphinx feeds template titles with markup like + ``6. Valores de retorno``. Embedding + that verbatim inside ```` or ```` breaks the + HTML because of the inner double quotes, so we sanitise it before use. + """ + + text = _TAG_RE.sub("", value or "") + return html.unescape(text).strip() + + +def _page_title(app, pagename: str, title: str) -> str: + clean = _strip_html(title) + if pagename in {app.config.root_doc, "index"}: + return BOOK_TITLE + return f"{clean} — {BOOK_TITLE}" + + +def update_seo_context(app, pagename, templatename, context, doctree): + description = PAGE_DESCRIPTIONS.get(pagename, DEFAULT_DESCRIPTION) + is_home = pagename in {app.config.root_doc, "index"} + page_title = _page_title(app, pagename, context.get("title", BOOK_TITLE)) + page_url = _page_url(app, pagename) + image_url = f"{SITE_URL.rstrip('/')}/og-image.jpg" + + if is_home: + context["title"] = BOOK_TITLE + context["titlesuffix"] = "" + context["pageurl"] = page_url + + context["seo"] = { + "site_url": SITE_URL, + "site_name": SITE_NAME, + "book_title": BOOK_TITLE, + "description": description, + "page_title": page_title, + "page_url": page_url, + "image_url": image_url, + "author": AUTHOR, + "translator": TRANSLATOR, + "twitter_site": TWITTER_SITE, + "theme_color": THEME_COLOR, + "locale": LOCALE, + "is_home": is_home, + } + + +def setup(app): + app.connect("html-page-context", update_seo_context, priority=800) + return {"parallel_read_safe": True, "parallel_write_safe": True} diff --git a/jb/_static/custom.css b/jb/_static/custom.css new file mode 100644 index 0000000..cd7391c --- /dev/null +++ b/jb/_static/custom.css @@ -0,0 +1,3 @@ +.title.logo__title { + text-wrap: balance; +} diff --git a/jb/_static/think_python_3e_es.png b/jb/_static/think_python_3e_es.png new file mode 100644 index 0000000..fc543da Binary files /dev/null and b/jb/_static/think_python_3e_es.png differ diff --git a/jb/_templates/layout.html b/jb/_templates/layout.html new file mode 100644 index 0000000..5b9fba2 --- /dev/null +++ b/jb/_templates/layout.html @@ -0,0 +1,60 @@ +{% extends "!layout.html" %} + +{% block htmltitle -%} +<title>{{ seo.page_title|striptags|e }} +{%- endblock %} + +{% block extrahead %} + {{ super() }} + {%- if seo -%} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {%- endif -%} +{% endblock %} diff --git a/jb/_templates/sbt-sidebar-nav.html b/jb/_templates/sbt-sidebar-nav.html new file mode 100644 index 0000000..98dde95 --- /dev/null +++ b/jb/_templates/sbt-sidebar-nav.html @@ -0,0 +1,24 @@ + diff --git a/jb/blank.md b/jb/blank.md new file mode 100644 index 0000000..adc7aa7 --- /dev/null +++ b/jb/blank.md @@ -0,0 +1,80 @@ +# Notebooks en blanco + +Para cada capítulo hay un notebook en blanco con el texto del libro y la mayor parte del código eliminado. +Estos notebooks son útiles para ejercicios guiados donde los estudiantes completan las celdas. + +**Capítulo 1: Programar como una forma de pensar** + +* [Abrir el capítulo 1 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap01.ipynb) + +**Capítulo 2: Variables y sentencias** + +* [Abrir el capítulo 2 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap02.ipynb) + +**Capítulo 3: Funciones** + +* [Abrir el capítulo 3 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap03.ipynb) + +**Capítulo 4: Funciones e interfaces** + +* [Abrir el capítulo 4 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap04.ipynb) + +**Capítulo 5: Condicionales y recursión** + +* [Abrir el capítulo 5 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap05.ipynb) + +**Capítulo 6: Valores de retorno** + +* [Abrir el capítulo 6 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap06.ipynb) + +**Capítulo 7: Iteración y búsqueda** + +* [Abrir el capítulo 7 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap07.ipynb) + +**Capítulo 8: Cadenas y expresiones regulares** + +* [Abrir el capítulo 8 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap08.ipynb) + +**Capítulo 9: Listas** + +* [Abrir el capítulo 9 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap09.ipynb) + +**Capítulo 10: Diccionarios** + +* [Abrir el capítulo 10 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap10.ipynb) + +**Capítulo 11: Tuplas** + +* [Abrir el capítulo 11 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap11.ipynb) + +**Capítulo 12: Análisis y generación de texto** + +* [Abrir el capítulo 12 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap12.ipynb) + +**Capítulo 13: Archivos y bases de datos** + +* [Abrir el capítulo 13 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap13.ipynb) + +**Capítulo 14: Clases y funciones** + +* [Abrir el capítulo 14 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap14.ipynb) + +**Capítulo 15: Clases y métodos** + +* [Abrir el capítulo 15 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap15.ipynb) + +**Capítulo 16: Clases y objetos** + +* [Abrir el capítulo 16 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap16.ipynb) + +**Capítulo 17: Herencia** + +* [Abrir el capítulo 17 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap17.ipynb) + +**Capítulo 18: Extras de Python** + +* [Abrir el capítulo 18 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap18.ipynb) + +**Capítulo 19: Reflexiones finales** + +* [Abrir el capítulo 19 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/blank/chap19.ipynb) diff --git a/jb/build.sh b/jb/build.sh old mode 100644 new mode 100755 index d0feed6..6a6d88d --- a/jb/build.sh +++ b/jb/build.sh @@ -1,15 +1,60 @@ -# pip install jupyter-book ghp-import +#!/usr/bin/env bash +set -euo pipefail # Build the Jupyter book version +cd "$(dirname "$0")" -# copy the notebooks -cp ../ThinkPythonSolutions/soln/chap[01][0-9]*.ipynb . +# Copy the translated notebooks into the Jupyter Book source directory so +# prep_notebooks.py can add build-only metadata without modifying originals. +for notebook in ../chapters/chap[01][0-9]*.ipynb; do + target="$(basename "$notebook")" + if [ -e "$target" ] && [ ! -f "$target" ] && [ ! -L "$target" ]; then + echo "Refusing to replace existing non-file: $target" >&2 + exit 1 + fi + rm -f "$target" + cp "$notebook" "$target" +done -# add tags to hide the solutions -python prep_notebooks.py +python3 prep_notebooks.py -# build the HTML version -jb build . +if command -v jupyter-book >/dev/null 2>&1; then + jupyter_book_cmd="jupyter-book" +else + user_base="$(python3 -m site --user-base)" + jupyter_book_cmd="$user_base/bin/jupyter-book" +fi -# push it to GitHub -ghp-import -n -p -f _build/html +if [ ! -x "$(command -v "$jupyter_book_cmd" 2>/dev/null || printf '%s' "$jupyter_book_cmd")" ]; then + echo "jupyter-book was not found. Install it with: python3 -m pip install --user 'jupyter-book<2'" >&2 + exit 1 +fi + +if ! python3 -c "import playwright" >/dev/null 2>&1; then + echo "playwright was not found. Install PDF build dependencies with:" >&2 + echo " python3 -m pip install --user playwright" >&2 + echo " python3 -m playwright install chromium" >&2 + exit 1 +fi + +pdf_filename="think-python-es.pdf" +pdf_build_dir="_build/pdfhtml" +pdf_source="$pdf_build_dir/_build/pdf/book.pdf" +html_pdf="_build/html/$pdf_filename" +dist_dir="../dist" + +"$jupyter_book_cmd" build . +"$jupyter_book_cmd" build . --builder pdfhtml --path-output "$pdf_build_dir" + +if [ ! -f "$pdf_source" ]; then + echo "Expected full-book PDF was not generated: $pdf_source" >&2 + exit 1 +fi + +cp "$pdf_source" "$html_pdf" +echo "Full-book PDF copied to $html_pdf" + +rm -rf "$dist_dir" +mkdir -p "$dist_dir" +cp -R _build/html/. "$dist_dir/" +echo "Static site copied to $dist_dir" diff --git a/jb/chap00.ipynb b/jb/chap00.ipynb new file mode 120000 index 0000000..9eb8017 --- /dev/null +++ b/jb/chap00.ipynb @@ -0,0 +1 @@ +../chapters/chap00.ipynb \ No newline at end of file diff --git a/jb/chap01.ipynb b/jb/chap01.ipynb new file mode 120000 index 0000000..613d15e --- /dev/null +++ b/jb/chap01.ipynb @@ -0,0 +1 @@ +../chapters/chap01.ipynb \ No newline at end of file diff --git a/jb/chap02.ipynb b/jb/chap02.ipynb new file mode 120000 index 0000000..638630d --- /dev/null +++ b/jb/chap02.ipynb @@ -0,0 +1 @@ +../chapters/chap02.ipynb \ No newline at end of file diff --git a/jb/chap03.ipynb b/jb/chap03.ipynb new file mode 120000 index 0000000..c8ca440 --- /dev/null +++ b/jb/chap03.ipynb @@ -0,0 +1 @@ +../chapters/chap03.ipynb \ No newline at end of file diff --git a/jb/chap04.ipynb b/jb/chap04.ipynb new file mode 120000 index 0000000..14fa6c6 --- /dev/null +++ b/jb/chap04.ipynb @@ -0,0 +1 @@ +../chapters/chap04.ipynb \ No newline at end of file diff --git a/jb/chap05.ipynb b/jb/chap05.ipynb new file mode 120000 index 0000000..ca83b1a --- /dev/null +++ b/jb/chap05.ipynb @@ -0,0 +1 @@ +../chapters/chap05.ipynb \ No newline at end of file diff --git a/jb/chap06.ipynb b/jb/chap06.ipynb new file mode 120000 index 0000000..7b7de67 --- /dev/null +++ b/jb/chap06.ipynb @@ -0,0 +1 @@ +../chapters/chap06.ipynb \ No newline at end of file diff --git a/jb/chap07.ipynb b/jb/chap07.ipynb new file mode 120000 index 0000000..8b677eb --- /dev/null +++ b/jb/chap07.ipynb @@ -0,0 +1 @@ +../chapters/chap07.ipynb \ No newline at end of file diff --git a/jb/chap08.ipynb b/jb/chap08.ipynb new file mode 120000 index 0000000..c93beea --- /dev/null +++ b/jb/chap08.ipynb @@ -0,0 +1 @@ +../chapters/chap08.ipynb \ No newline at end of file diff --git a/jb/chap09.ipynb b/jb/chap09.ipynb new file mode 120000 index 0000000..9c9e15d --- /dev/null +++ b/jb/chap09.ipynb @@ -0,0 +1 @@ +../chapters/chap09.ipynb \ No newline at end of file diff --git a/jb/chap10.ipynb b/jb/chap10.ipynb new file mode 120000 index 0000000..a613d16 --- /dev/null +++ b/jb/chap10.ipynb @@ -0,0 +1 @@ +../chapters/chap10.ipynb \ No newline at end of file diff --git a/jb/chap11.ipynb b/jb/chap11.ipynb new file mode 120000 index 0000000..13c5221 --- /dev/null +++ b/jb/chap11.ipynb @@ -0,0 +1 @@ +../chapters/chap11.ipynb \ No newline at end of file diff --git a/jb/chap12.ipynb b/jb/chap12.ipynb new file mode 120000 index 0000000..5bd275a --- /dev/null +++ b/jb/chap12.ipynb @@ -0,0 +1 @@ +../chapters/chap12.ipynb \ No newline at end of file diff --git a/jb/chap13.ipynb b/jb/chap13.ipynb new file mode 120000 index 0000000..729f601 --- /dev/null +++ b/jb/chap13.ipynb @@ -0,0 +1 @@ +../chapters/chap13.ipynb \ No newline at end of file diff --git a/jb/chap14.ipynb b/jb/chap14.ipynb new file mode 120000 index 0000000..6fa2ab7 --- /dev/null +++ b/jb/chap14.ipynb @@ -0,0 +1 @@ +../chapters/chap14.ipynb \ No newline at end of file diff --git a/jb/chap15.ipynb b/jb/chap15.ipynb new file mode 120000 index 0000000..7400e2e --- /dev/null +++ b/jb/chap15.ipynb @@ -0,0 +1 @@ +../chapters/chap15.ipynb \ No newline at end of file diff --git a/jb/chap16.ipynb b/jb/chap16.ipynb new file mode 120000 index 0000000..73aaaae --- /dev/null +++ b/jb/chap16.ipynb @@ -0,0 +1 @@ +../chapters/chap16.ipynb \ No newline at end of file diff --git a/jb/chap17.ipynb b/jb/chap17.ipynb new file mode 120000 index 0000000..7f6cf7f --- /dev/null +++ b/jb/chap17.ipynb @@ -0,0 +1 @@ +../chapters/chap17.ipynb \ No newline at end of file diff --git a/jb/chap18.ipynb b/jb/chap18.ipynb new file mode 120000 index 0000000..bcb3444 --- /dev/null +++ b/jb/chap18.ipynb @@ -0,0 +1 @@ +../chapters/chap18.ipynb \ No newline at end of file diff --git a/jb/chap19.ipynb b/jb/chap19.ipynb new file mode 120000 index 0000000..dae8552 --- /dev/null +++ b/jb/chap19.ipynb @@ -0,0 +1 @@ +../chapters/chap19.ipynb \ No newline at end of file diff --git a/jb/extra_html/apple-touch-icon.png b/jb/extra_html/apple-touch-icon.png new file mode 100644 index 0000000..ade399a Binary files /dev/null and b/jb/extra_html/apple-touch-icon.png differ diff --git a/jb/extra_html/favicon-16.png b/jb/extra_html/favicon-16.png new file mode 100644 index 0000000..8b7ef2b Binary files /dev/null and b/jb/extra_html/favicon-16.png differ diff --git a/jb/extra_html/favicon-32.png b/jb/extra_html/favicon-32.png new file mode 100644 index 0000000..4f60c26 Binary files /dev/null and b/jb/extra_html/favicon-32.png differ diff --git a/jb/extra_html/favicon-32x32.png b/jb/extra_html/favicon-32x32.png new file mode 100644 index 0000000..4f60c26 Binary files /dev/null and b/jb/extra_html/favicon-32x32.png differ diff --git a/jb/extra_html/favicon.ico b/jb/extra_html/favicon.ico new file mode 100644 index 0000000..417f3f5 Binary files /dev/null and b/jb/extra_html/favicon.ico differ diff --git a/jb/extra_html/favicon.svg b/jb/extra_html/favicon.svg new file mode 100644 index 0000000..3e2a3e1 --- /dev/null +++ b/jb/extra_html/favicon.svg @@ -0,0 +1,4 @@ + + + Py + diff --git a/jb/extra_html/icon-512.png b/jb/extra_html/icon-512.png new file mode 100644 index 0000000..9fe4136 Binary files /dev/null and b/jb/extra_html/icon-512.png differ diff --git a/jb/extra_html/og-image.jpg b/jb/extra_html/og-image.jpg new file mode 100644 index 0000000..0e6ebd6 Binary files /dev/null and b/jb/extra_html/og-image.jpg differ diff --git a/jb/extra_html/site.webmanifest b/jb/extra_html/site.webmanifest new file mode 100644 index 0000000..d0ebedf --- /dev/null +++ b/jb/extra_html/site.webmanifest @@ -0,0 +1,23 @@ +{ + "name": "Think Python en español", + "short_name": "Think Python", + "description": "Think Python en español: libro gratuito para aprender Python con notebooks y PDF.", + "start_url": "/", + "display": "standalone", + "background_color": "#2d3748", + "theme_color": "#2d3748", + "lang": "es", + "icons": [ + { + "src": "/icon-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "any maskable" + }, + { + "src": "/apple-touch-icon.png", + "sizes": "180x180", + "type": "image/png" + } + ] +} diff --git a/jb/index.md b/jb/index.md new file mode 100644 index 0000000..4718a1d --- /dev/null +++ b/jb/index.md @@ -0,0 +1,104 @@ +--- +title: Think Python en español +description: Think Python en español — introducción gratuita a Python de Allen B. Downey, 3.ª edición traducida con notebooks y PDF. +--- + +# Think Python en español + +*Think Python* es una introducción a Python para personas que nunca han programado, o para quienes lo han intentado y se han encontrado con dificultades. + +Esta edición en español traduce la tercera edición de *Think Python: How to Think Like a Computer Scientist*, de Allen B. Downey, con traducción de [midudev](https://midu.dev). + +Portada en español de Think Python, 3.ª edición + +Puedes pedir las versiones impresa y electrónica de *Think Python 3e* en +[Bookshop.org](https://bookshop.org/a/98697/9781098155438) y +[Amazon](https://www.amazon.com/_/dp/1098155432?smid=ATVPDKIKX0DER&_encoding=UTF8&tag=oreilly20-20&_encoding=UTF8&tag=greenteapre01-20&linkCode=ur2&linkId=e2a529f94920295d27ec8a06e757dc7c&camp=1789&creative=9325). + +[Aquí está la página principal del libro en Green Tea Press](https://greenteapress.com/wp/think-python-3rd-edition/). + +Descargar el libro completo en PDF + +## Los notebooks + +**Capítulo 1: Programar como una forma de pensar** + +* [Abrir el capítulo 1 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap01.ipynb) + +**Capítulo 2: Variables y sentencias** + +* [Abrir el capítulo 2 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap02.ipynb) + +**Capítulo 3: Funciones** + +* [Abrir el capítulo 3 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap03.ipynb) + +**Capítulo 4: Funciones e interfaces** + +* [Abrir el capítulo 4 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap04.ipynb) + +**Capítulo 5: Condicionales y recursión** + +* [Abrir el capítulo 5 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap05.ipynb) + +**Capítulo 6: Valores de retorno** + +* [Abrir el capítulo 6 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap06.ipynb) + +**Capítulo 7: Iteración y búsqueda** + +* [Abrir el capítulo 7 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap07.ipynb) + +**Capítulo 8: Cadenas y expresiones regulares** + +* [Abrir el capítulo 8 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap08.ipynb) + +**Capítulo 9: Listas** + +* [Abrir el capítulo 9 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap09.ipynb) + +**Capítulo 10: Diccionarios** + +* [Abrir el capítulo 10 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap10.ipynb) + +**Capítulo 11: Tuplas** + +* [Abrir el capítulo 11 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap11.ipynb) + +**Capítulo 12: Análisis y generación de texto** + +* [Abrir el capítulo 12 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap12.ipynb) + +**Capítulo 13: Archivos y bases de datos** + +* [Abrir el capítulo 13 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap13.ipynb) + +**Capítulo 14: Clases y funciones** + +* [Abrir el capítulo 14 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap14.ipynb) + +**Capítulo 15: Clases y métodos** + +* [Abrir el capítulo 15 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap15.ipynb) + +**Capítulo 16: Clases y objetos** + +* [Abrir el capítulo 16 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap16.ipynb) + +**Capítulo 17: Herencia** + +* [Abrir el capítulo 17 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap17.ipynb) + +**Capítulo 18: Extras de Python** + +* [Abrir el capítulo 18 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap18.ipynb) + +**Capítulo 19: Reflexiones finales** + +* [Abrir el capítulo 19 en Colab](https://colab.research.google.com/github/midudev/ThinkPython/blob/v3/chapters/chap19.ipynb) + +## Recursos para docentes + +Cada capítulo también tiene un notebook en blanco con el texto original y la mayor parte del código eliminado. Estos notebooks sirven para hacer ejercicios guiados donde el alumnado completa los huecos. + +[Aquí están los enlaces a los notebooks en blanco](blank). diff --git a/jb/prep_notebooks.py b/jb/prep_notebooks.py index 514949d..00e1593 100644 --- a/jb/prep_notebooks.py +++ b/jb/prep_notebooks.py @@ -3,13 +3,25 @@ def process_cell(cell): - # get tags - tags = cell['metadata'].get('tags', []) + tags = cell['metadata'].setdefault('tags', []) - # add hide-cell tag to solutions if cell['cell_type'] == 'code': source = cell['source'] + # Hide the setup cells that download modules and configure autoreload. + # In most chapters both bits live in the same cell, but in some (e.g. + # chap04) they are split across two consecutive cells, so we detect + # each pattern independently to cover both layouts. + is_download_cell = 'def download(url):' in source + is_autoreload_cell = ( + 'import thinkpython' in source and '%autoreload' in source + ) + + if is_download_cell or is_autoreload_cell: + for tag in ['remove-cell', 'keep']: + if tag not in tags: + tags.append(tag) + # remove solutions if source.startswith('# Solution') or 'solution' in tags: cell['source'] = [] diff --git a/wrangler.toml b/wrangler.toml new file mode 100644 index 0000000..340fdd3 --- /dev/null +++ b/wrangler.toml @@ -0,0 +1,20 @@ +name = "think-python-es" +compatibility_date = "2026-05-19" + +[observability] +enabled = false +head_sampling_rate = 1 + +[observability.logs] +enabled = true +head_sampling_rate = 1 +persist = true +invocation_logs = true + +[observability.traces] +enabled = false +persist = true +head_sampling_rate = 1 + +[assets] +directory = "./dist"