PYTHON DESDE EL LABORATORIO. ESTRUCTURAS DE CONTROL

Prólogo ............................................................................................................................................................................7
Introducción ...................................................................................................................................................................9
CAPÍTULO 1: Lenguajes compilados e interpretados 11
1.1. Características del lenguaje computacional Python...............................................................................11
1.2. Carga e instalación de Python .......................................................................................................................12
1.3. Interfaz de edición de Python .......................................................................................................................12
1.4. Ejecutar el programa fuente............................................................................................................................12
1.5. Carga de editores.................................................................................................................................................12
1.5.1. Brackets.................................................................................................................................................................12
1.5.2. Spyder...................................................................................................................................................................13
1.6. Desarrollo de interfaces gráficas con Tkinter (labels, buttons y entries).......................................13
1.7. Elementos básicos para editar programas.................................................................................................13
1.8. Variables o identificadores...............................................................................................................................13
1.9. Operadores............................................................................................................................................................14
1.9.1. Operadores aritméticos..................................................................................................................................14
1.9.2. Operadores relacionales................................................................................................................................14
1.9.3. Conectores lógicos..........................................................................................................................................14
1.9.4. Precedencia de operadores.........................................................................................................................14
1.9.5. Operador especial ...........................................................................................................................................15
1.10. Comentarios .......................................................................................................................................................15
1.10.1. Comentarios en línea....................................................................................................................................15
1.10.2. Comentario en bloque.................................................................................................................................15
1.11. Operador de concatenación..........................................................................................................................15
1.12. Desarrollo de programas................................................................................................................................15
1.13. Conversión de tipos de datos......................................................................................................................17
1.14. Formatos para salida/reportes.....................................................................................................................18
1.15. Uso de módulos: librerías .............................................................................................................................19
1.16. Funciones del módulo math ........................................................................................................................20
1.17. Lectura y salida de datos ...............................................................................................................................20
1.17.1. Lectura de datos..............................................................................................................................................20
1.17.2. Informes o salida ...........................................................................................................................................20
1.18. Documentación de los programas: comentarios..................................................................................22
1.19. Encolumnamiento de programas/instrucciones...................................................................................22
1.20. Funciones parte entera y resto....................................................................................................................23
1.20.1. Función parte entera (//) ...........................................................................................................................23
1.20.2. Función resto (%)..........................................................................................................................................23
1.20.3. La función divmod........................................................................................................................................24
1.21. Números aleatorios .........................................................................................................................................25
1.22. Comportamiento de los sistemas usando contador y acumulador..............................................27
1.22.1. Contador............................................................................................................................................................27
1.22.2. Acumulador.....................................................................................................................................................29
CAPÍTULO 2: Estructuras de control 35
2.1. Estructuras condicionales: decisiones .........................................................................................................35
2.1.1. Estructura condicional simple .....................................................................................................................35
2.1.2. Estructura condicional compuesta ...........................................................................................................39
2.1.3. Estructura condicional anidada: anidamiento......................................................................................41
2.1.4. Estructura múltiple...........................................................................................................................................44
2.2. Estructuras repetitivas.......................................................................................................................................62
2.2.1. Estructura repetitiva con pretest: while...................................................................................................63
2.3. Estructura repetitiva cuando se conoce el número de iteraciones ................................................72
2.3.1. Secuencia definida mediante una lista....................................................................................................73
2.3.2. Secuencia definida mediante un rango.................................................................................................74
2.3.3. Formato de salida mejorado: str(), repr() .............................................................................................76
2.3.4. Anidamiento de la estructura for ............................................................................................................81
2.4. La instrucción exit...............................................................................................................................................100
2.5. Ejecución repetida de un bloque mediante una condición al final: repetir..................................101
CAPÍTULO 3: Programación modular: funciones 153
3.1. Conceptualización ..............................................................................................................................................153
3.2. Funciones no recursivas....................................................................................................................................157
3.3. Declaración de variables globales................................................................................................................161
3.4. Funciones recursivas..........................................................................................................................................173
3.4.1. Caso base.............................................................................................................................................................173
3.4.2. Caso recursivo...................................................................................................................................................173
3.4.3. Procedimientos.................................................................................................................................................173
3.5. Funciones externas.............................................................................................................................................176

Iníciese en el universo de Python y domine las estructuras de control Python es el lenguaje de programación que ha revolucionado el mundo tecnológico. Su simplicidad, gratuidad y versatilidad hacen de él una herramienta imprescindible en el campo de la informática, por lo que es utilizado por las principales compañías globales. Este libro le ofrece la oportunidad de introducirse en el lenguaje Python a través de una serie de ejercicios prácticos. Gracias a su lectura, explorará el vasto mundo de Python, abarcando desde las estructuras de control hasta la programación modular (funciones). Cada tema se desarrolla con claridad, asegurando que no solo aprenda la teoría, sino también que aplique lo aprendido con éxito. A lo largo de sus páginas encontrará ejemplos detallados y ejercicios que le guiarán hacia una comprensión integral de conceptos como funciones y estructuras condicionales y repetitivas. ' Lenguajes compilados e interpretados ' Estructuras de control ' Programación modular: funciones No espere más para dar el primer paso en el mundo de la programación. Indicado para estudiantes, profesionales en in