Búsqueda avanzada
(por colaborador, editorial, año de edición, formatos)
En las disciplinas relacionadas con la ingeniería resulta necesario resolver problemas con la ayuda de una computadora. Sin embargo, también es imprescindible conocer técnicas de programación y aplicarlas mediante un lenguaje de programación de muy alto nivel, con el propósito de dar solución a los problemas. Uno de los más utilizados es Python, pues ofrece muchas ventajas para los estudiantes universitarios que inician en el campo de la programación de computadoras.
A diferencia de otras publicaciones, este libro resume las experiencias del autor al impartir cursos de programación de computadoras. La nueva edición de la obra Introducción a la programación en Python presenta una serie de mejoras que han sido detectadas en los cursos de programación de computadoras; entre ellas, se modificó el orden de los capítulos para darle mayor énfasis a la Programación Orientada a Objetos (POO), se incorporaron nuevos temas, se agregaron varios ejercicios resueltos en cada capítulo y se amplió la cantidad de enunciados de ejercicios por capítulo.
1.1 Algoritmo........................................................................................... 15
1.2 Diagrama de flujo.............................................................................. 17
1.3 Programa.......................................................................................... 19
1.4 Programas y modelos....................................................................... 19
1.5 Lenguajes de programación ............................................................ 20
1.6 El lenguaje de programación Python................................................ 21
1.7 Las ventajas de usar el lenguaje de programación Python............... 24
1.8 Estructura básica de un programa ................................................... 24
1.9 La depuración................................................................................... 25
2.1 Tipos de datos y valores................................................................... 27
2.2. Palabras clave o reservadas............................................................. 28
2.3. Variables............................................................................................ 28
2.4. Instrucciones.......................................................................................... 30
2.4.1. La función print ...................................................................... 30
2.4.2. La función input ..................................................................... 31
2.4.3. La función int ......................................................................... 31
2.4.4. La función help....................................................................... 32
2.5. Estatuto de asignación...................................................................... 32
2.6. Operadores matemáticos................................................................. 33
2.7 Expresiones....................................................................................... 34
2.7.1. Composición de expresiones................................................. 35
8 Introducción a la programación en Phyton
2.7.2. Evaluación de expresiones..................................................... 35
2.8 La ejecución secuencial ................................................................... 36
2.9. Ejercicios........................................................................................... 37
2.9.1. Identificación de conceptos.................................................... 37
2.9.2. Respuesta corta..................................................................... 38
2.9.3. Python como calculadora ...................................................... 39
3. Funciones ................................................................................................... 41
3.1 Funciones de conversión de tipos.................................................... 41
3.2. Funciones matemáticas.................................................................... 42
3.3. Composición de funciones............................................................... 43
3.4. La indentación................................................................................... 44
3.5. Encapsular y generalizar................................................................... 44
3.6. Creación de funciones...................................................................... 45
3.7. Flujo de ejecución............................................................................. 46
3.8. Parámetros y argumentos................................................................. 46
3.9. Variables locales, variables globales y parámetros............................ 48
3.10. El estatuto return............................................................................... 49
3.11. Funciones booleanas........................................................................ 51
3.12. Funciones “lambda”.......................................................................... 52
3.13. Desarrollo de programas................................................................... 52
3.14. Las ventajas de las funciones........................................................... 54
3.15. Ejercicios ............................................................................................. 55
3.15.1. Identificación de conceptos.................................................. 55
3.15.2. Respuesta corta................................................................... 56
3.15.3. Programas............................................................................ 56
4. La programación orientada a objetos......................................................... 63
4.1. La clase............................................................................................. 63
4.2. Los objetos....................................................................................... 65
4.3. Instanciar objetos.............................................................................. 66
4.4. Atributos............................................................................................ 67
4.5. Métodos............................................................................................ 68
4.5.1. Referencia al objeto................................................................ 69
4.5.2. El método __init__................................................................... 69
4.6. Ejemplos de clases........................................................................... 70
4.7. Encapsulamiento.............................................................................. 74
4.8. Ejercicios........................................................................................... 75
4.8.1. Identificación de conceptos.................................................... 75
4.8.2. Respuesta corta..................................................................... 75
4.8.3. Programas.............................................................................. 76
5.1. Expresiones booleanas..................................................................... 81
5.2. Operadores de asignación y de comparación.................................. 82
5.3. La instrucción if................................................................................. 82
5.4. La ejecución alternativa “if-else”........................................................ 84
5.5. La instrucción if… elif … else ........................................................... 85
5.6. Sentencias condicionales anidadas.................................................. 85
5.7. Operadores lógicos........................................................................... 87
5.8. Ejemplo de condicionales................................................................. 88
5.9. El manejo de excepciones................................................................ 89
5.10. Ejercicios .......................................................................................... 91
5.10.1. Identificación de conceptos.................................................. 91
5.10.2. Respuesta corta................................................................... 92
5.10.3. Programas............................................................................ 92
6.1. El estatuto “while”............................................................................. 97
6.2. El estatuto “break”............................................................................ 99
6.3. Ejemplos........................................................................................... 99
6.3.1. Impresión de una tabla de valores........................................ 100
6.3.2. Ejemplo de encapsulamiento y generalización..................... 100
6.3.3. Ejemplo de contar hacia atrás.............................................. 102
6.3.4. Ejemplo de cómo sumar números pares.............................. 102
6.4. Ejercicios ........................................................................................ 103
6.4.1. Identificación de conceptos.................................................. 103
6.4.2. Respuesta corta................................................................... 104
6.4.3. Programas............................................................................ 104
7.1. Operaciones comunes de las secuencias...................................... 111
7.1.1. La indexación........................................................................ 111
7.1.2. La membresía....................................................................... 112
7.1.3. Segmento............................................................................. 112
7.1.4. La longitud, el mínimo y el máximo....................................... 113
7.1.5. La función “range”................................................................ 114
7.1.6. El estatuto “for-in”................................................................. 115
7.1.7. Secuencias y objetos............................................................ 115
7.2. Las listas......................................................................................... 115
7.2.1. Cómo crear una lista............................................................. 116
7.2.2. Cómo acceder a los elementos de una lista......................... 117
7.2.3. Segmentos de listas............................................................. 118
7.2.4. La longitud, el mínimo y el máximo de una lista.................... 118
7.2.5. El recorrido de las listas........................................................ 118
7.2.6. La mutabilidad de las listas................................................... 119
7.2.7. Las listas como argumentos................................................. 120
7.2.8. Las operaciones con listas.................................................... 121
7.2.9. Los métodos de las listas..................................................... 121
7.2.10. Ejemplos de listas............................................................... 123
7.2.10.1. Ejemplo de una lista de números aleatorios............. 123
7.2.10.2. Ejemplo de conteo................................................... 124
7.2.10.3. Ejemplo de una lista de compras............................. 125
7.2.11. Ejercicios ............................................................................ 126
7.3. Matrices.......................................................................................... 130
7.3.1. Algunos tipos de matrices ................................................... 131
7.3.2. Matrices como listas anidadas.............................................. 132
7.3.3. Cómo llenar listas anidadas.................................................. 133
7.3.4. Impresión de listas anidadas................................................. 134
7.3.5. Objetos y listas...................................................................... 135
7.3.6. Alias...................................................................................... 135
7.3.7. Clonación de listas................................................................ 135
7.3.8. Ejercicios ................................................................................. 136
7.3.8.1. Identificación de conceptos............................................... 136
7.3.8.2. Respuesta corta................................................................ 136
7.3.8.3. Programas......................................................................... 138
7.4. Tuplas.............................................................................................. 140
7.4.1. Cómo crear tuplas....................................................................... 140
7.4.2. Las tuplas son inmutables........................................................... 142
7.4.3. Asignación de tuplas................................................................... 142
7.4.4. Tuplas y valores de retorno...................................................... 142
7.4.5. Ejemplo de tuplas.................................................................... 143
7.4.5.1. Ejemplo del zoológico........................................................ 143
7.4.6. Ejercicios ................................................................................. 144
7.4.6.1. Identificación de conceptos............................................... 144
7.4.6.2. Programas......................................................................... 144
7.5. Las cadenas.................................................................................... 147
7.5.1. Indexación............................................................................... 147
7.5.2. Membresía .............................................................................. 148
7.5.3. Segmentos de cadenas ......................................................... 149
7.5.4. La longitud, el mínimo y el máximo de una cadena ................ 149
7.5.5. Operadores para cadenas....................................................... 150
Concatenación (+)........................................................................... 150
Repetición (*)................................................................................... 150
7.5.6. Recorrido de cadenas............................................................. 150
7.5.7. Objetos y cadenas................................................................... 151
7.5.8. Las cadenas son inmutables................................................... 152
7.5.9. Comparación de cadenas....................................................... 152
7.5.10. Ejemplo de cadena.................................................................. 153
7.5.10.1. Ejemplo de un palíndromo............................................... 153
7.5.11. Métodos para manipular objetos de tipo cadena...................... 153
7.5.12. Ejercicios.................................................................................. 156
7.5.12.1. Identificación de conceptos............................................. 156
7.5.12.2. Respuesta corta.............................................................. 157
7.5.12.3. Programas....................................................................... 157
8.1. Módulo os...................................................................................... 161
8.2. Los archivos como objetos ........................................................... 163
8.3. Operaciones básicas con archivos................................................. 163
8.4. Ejemplos de clases y archivos........................................................ 168
8.6. Ejercicios ........................................................................................ 175
8.6.1. Identificación de conceptos.................................................. 175
8.6.2. Respuesta corta................................................................... 176
8.6.3. Programas............................................................................ 176
9.1. Cómo crear diccionarios................................................................. 180
9.2. Cómo recorrer un diccionario.......................................................... 181
9.3. Métodos de diccionarios................................................................. 181
9.4. Operaciones con diccionarios......................................................... 183
9.5. Ejemplos de diccionarios................................................................ 183
9.5.1. Ejemplo de un libro de direcciones....................................... 183
9.5.2. Ejemplo de una lista y un diccionario.................................... 184
9.6. Ejercicios ........................................................................................ 186
9.6.1. Identificación de conceptos.................................................. 186
9.6.2. Respuesta corta................................................................... 186
9.6.3. Programas............................................................................ 186
10.1. La llamada recursiva....................................................................... 191
10.2. El caso base.................................................................................... 192
10.3. El diagrama de pilas ....................................................................... 192
10.4. La recursión infinita......................................................................... 193
10.5. El salto de fe ................................................................................... 193
10.6. Ejemplos de recursividad................................................................ 193
10.6.1. La función factorial.............................................................. 193
10.6.2. La sucesión de Fibonacci................................................... 194
10.7. Verificación de tipos........................................................................ 195
10.8. Ejemplos......................................................................................... 196
10.9. Ejercicios ........................................................................................ 197
10.9.1. Identificación de conceptos................................................ 197
10.9.2. Respuesta corta................................................................. 197
10.9.3. Programas.......................................................................... 197
11.1. Herencia.......................................................................................... 201
11.2. Clases abstractas y clases concretas............................................. 202
11.3. Relaciones entre clases................................................................... 202
11.4. Herencia múltiple............................................................................. 207
11.5. Enmascaramiento de variables....................................................... 207
11.6. Sobre escritura de los métodos...................................................... 208
11.7. Ventajas y desventajas de la herencia............................................. 209
11.8. Sobrecarga..................................................................................... 209
11.9. Polimorfismo................................................................................... 210
11.10. Las instancias como parámetros.................................................... 211
11.11. Las instancias como valor de retorno.............................................. 211
11.12. Ejemplos.......................................................................................... 212
11.12.1. Ejemplo ImpTiempo.......................................................... 212
11.12.2. Ejemplo de incremento..................................................... 213
11.13. Ejercicios ......................................................................................... 214
11.13.1. Identificación de conceptos.............................................. 214
11.13.2. Respuesta corta............................................................... 215
11.13.3. Programas........................................................................ 215
