Descripción
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 informática, programadores y entusiastas del tema, este es el recurso ideal para iniciarse en Python y aplicarlo en sus proyectos y desafíos profesionales.
Si quiere profundizar en Python, los autores Teodoro Córdova y Sara Arana han preparado tres libros más sobre el tema. ¡Hágase con ellos y complete su camino hacia la excelencia en Python!
Índice
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
