AAAMain

Instituto Tecnológico Superior de Cajeme
Ingenierı́a en Sistemas Computacionales
Introducción a Python
Manual
Elaborado por:
José Luis Beltrán Márquez
lbeltran@itesca.edu.mx
Cd. Obregón, Sonora, México. Julio de 2017.

Índice general
Lista de Figuras i
Lista de Tablas ii
Capı́tulo Página
1. Introducción a Python 2
1.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1. Creación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2. ¿Porque Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3. The zen of Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.4. El código de inspiración Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2. Vocabulario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3. Objetivos de Aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2. Instalación 6
2.1. Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2. Linux Ubuntu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3. El Intérprete y su entorno 7
3.1. Lenguaje Interpretado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2. Python shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3. IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.4. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4. Primeros pasos! 13
4.1. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1.1. Comentarios de una sola lı́nea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1.2. Comentarios de múltiples lineas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2. Algoritmos y Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5. Variables e Identificadores 19
5.1. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.2. Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.2.1. Prueba estas asignaciones en el IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5.2.2. Ejemplos de identificadores válidos: . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
i
ÍNDICE GENERAL ii
5.2.3. Ejemplos de identificadores inválidos: . . . . . . . . . . . . . . . . . . . . . . . . . . 20

5.2.4. Ejercicios: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.3. El signo ’=’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.4. Variables vs Identificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5.5. Programa ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6. Tipos de Variables 23
6.1. Número entero o Integer (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.2. Número con punto decimal (float) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.3. String o cadenas de texto (str) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.4. Boleano (bool) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.5. Complejos (complex) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.6. Listas (list) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.6.1. Creando una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.6.2. Accediendo a los elementos de la lista . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.6.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6.7. Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6.8. Rangos (range) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.9. Conjuntos (set) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6.9.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6.10. Mutable vs Inmutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6.11. Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
6.12. Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6.12.1. Desempacado de Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
6.13. Sin tipo (None) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
7. Entradas/Salidas de usuario 36
7.1. Salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
7.1.1. Formatear una salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
7.1.2. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
7.2. Entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
7.2.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
8. Operadores 41
8.1. Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.2. Relacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.3. Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.4. Membresı́a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
8.5. Precedencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
8.6. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8.7. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
9. Control de flujo 44
9.1. condicional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.1.1. if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.2. Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.2.1. while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
ÍNDICE GENERAL iii
9.2.2. for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.2.3. break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
9.2.4. continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
9.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
10. Funciones 52
10.0.1. Documentación de la función . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
10.0.2. Tipos de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
10.1. Funciones disponibles del interprete de Python . . . . . . . . . . . . . . . . . . . . . . . . . 55
10.2. Espacios de Nombres (namespace) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
10.3. Funciones como Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
10.4. Funciones como Argumentos de Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
10.5. Función Lamda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
10.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11. Recursividad 61
11.1. Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.2. Procedimientos recursivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
11.3. Mecánica de recursión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
11.4. Transformación de algoritmos recursivos a iterativos . . . . . . . . . . . . . . . . . . . . . . 64
11.5. Recursividad en el diseño . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12. Programación Modular 67

12.1. Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
12.2. Módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13. Archivos 69
13.1. Modo de apertura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
13.2. Abrir un Archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
13.3. Escribir en un Archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
13.4. Posición en el Archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
14. Errores y Excepciones 73

14.1. Manejando Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Bibliografı́a 76
Índice de figuras
1.1. Guido van Rossum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.1. Python Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

3.2. Python IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3. Ejemplos de comandos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4. Borrar valores de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.5. Variables borradas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.1. Hola Mundo Python! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4.2. Algoritmo para bailar la canción de Macarena . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.3. Algoritmo para convertir de grados Centı́grados a Fahrenheit . . . . . . . . . . . . . . . . . . 15
4.4. Diagrama de Flujo Co −→Fo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.5. Programa en Python para convertir Co −→Fo . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.6. Co aFo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.7. Calcular Área y Perı́metro de un Rectángulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.1. Accediendo a los elementos de una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.2. Ejemplo de Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.1. Calcular Área y Perı́metro de un Cı́rculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
10.1. Pseudo-código del algoritmo InsertionSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11.1. Matrushka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.2. Recursividad lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
11.3. Recursividad múltiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
iv
Índice de tablas
1.1. Lista de Palabras Reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6.1. Indices en una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.2. Indexado en una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6.3. Indexado en un diccionario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
8.1. Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

8.2. Operadores Relacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
8.3. Operadores Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
8.4. Operadores de Membresı́a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
13.1. Modos de Apertura en Archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

13.2. Formas de leer de un archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
13.3. Métodos de posicionamiento en el Archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
1
Capı́tulo 1
Introducción a Python
1.1. Introducción
La lengua Parsel es el lenguaje de las serpientes y quienes hablan Parsel se pueden comunicar con las serpientes.
Un individuo que habla Parsel, es conocido como Parsel-hablante, y es una habilidad muy extraña, ésta habili-
dad suele ser hereditaria y generalmente son los descendientes de Salazar Slytherin. [?]
Python es el lenguaje del intérprete de Python, y quienes programan Python se pueden comunicar con el
intérprete de Python.
Un individuo que programa Python, es conocido como Pythonista, y es una habilidad muy extraña, ésta habili-
dad suele ser aprendida y generalmente son los discı́pulos de Guido Van Rossum.
Necesitamos aprender el lenguaje Python para poder comunicar nuestras instrucciones a Python.
Igual que cuando aprendemos a hablar, al principio cometeremos muchos errores y hablaremos como bebés;
pero si cometemos un error, el intérprete de Python no piensa que es una gracia tuya, solamente te comunicará:
`èrror de sintaxis´´. Como vemos, Python es cruel e insensible.
Debes recordar que los humanos son inteligentes y pueden entender instrucciones en ocasiones confusas, de
hecho eres más inteligente que la computadora, y tú puedes aprender el lenguaje Python; a diferencia de la
computadora, que se le dificulta aprender tu idioma, ya que son muy estrictas y requieren instrucciones precisas.
1.1.1. Creación
Python fue creado a principios de los 90 por Guido van Rossum en Stichting Mathematisch Centrum (CWI,
véase http://www.cwi.nl/) en los Paı́ses Bajos como sucesor de un lenguaje llamado ABC. Guido sigue siendo
el autor principal de Python, aunque incluye muchas contribuciones de otros.
2
3
Figura 1.1: Guido van Rossum
1.1.2. ¿Porque Python?

Según el autor principal (Guido van Rossum), eligió el nombre ``Python ´´porque es un gran fan de la pelı́cula
de comedia británica - ’Monty Python’s Flying Circus’. Esto es lo que el autor declaró en una entrevista:
“Hace algunos años (en diciembre de 1989), estaba buscando un proyecto de programación que me mantuviera
ocupado durante la semana de Navidad ... Elegı́ a Python como tı́tulo de trabajo para el proyecto, ya que era un
poco irreverente ... (Y un gran fan de Monty Python’s Flying Circus) ”.
1.1.3. The zen of Python

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it
1.1.4. El código de inspiración Python

Bonito es mejor que feo
Explı́cito es mejor que implı́cito
Simple es mejor que complejo
Complejo es mejor que complicado
Sencillo es mejor que anidado
Disperso es mejor que denso
4
La legibilidad cuenta
Los casos especiales no son suficientemente especiales para romper las reglas
La practicidad bate a la pureza
Los errores no deben pasar inadvertidos
A menos que sean explı́citamente silenciados
En caso de ambigüedad, rechazar la tentación de adivinar
Debe haber una - y preferiblemente única- forma obvia de hacerlo
Aunque esa única forma no sea obvia en un primer momento, a no ser que seas holandés
Ahora es mejor que nunca
Aunque nunca es mejor que *ahora* mismo
Si la implementación es difı́cil de explicar, es una mala idea
Si la implementación es fácil de explicar, debe ser una buena idea
Los espacios de nombres son una idea genial .. ¡hay que hacer más de esos!
[?]
1.2. Vocabulario
Las siguientes palabras, son palabras reservadas por Python y no pueden ser usadas por ti para nombrar cosas.
Indican comandos al intérprete de Python:
and del from not while

as elif global or with
assert else if pass yield
break except import nonlocal class
lambda in raise continue finally
is return def for print
try True False None exec
Tabla 1.1: Lista de Palabras Reservadas
1.3. Objetivos de Aprendizaje

Al completar este manual serás capaz de:
Comprender las expresiones y declaraciones de Python
Obtener datos de entrada del usuario y manipularlo.
Entender tipos de datos simples y compuestos como enteros, flotantes, strings, listas, diccionarios y
tuplas.
Implementar estructuras de control como sentencias if y ciclos
Leer y escribir en archivos de datos externos usando Python.

5
Implementar funciones y llamar a funciones integradas de Python.
Importar y usar módulos de funciones de biblioteca de la biblioteca de Python.
Gestionar errores y excepciones de programación.
Implementar programas útiles y divertidos como buscar, ordenar y resolver Sudoku y crucigramas.
Capı́tulo 2
Instalación
2.1. Windows
Vaya a www.python.org
Selecciona Downloads y da click en All Releases
Selecciona la última versión
Selecciona la versión adecuada a tu plataforma
Ejecuta el programa descargado y sigue las instrucciones del instalador.
2.2. Linux Ubuntu

Vaya a la tienda de aplicaciones (AppStore)
Busca idle
Selecciona IDLE (using Python 3.X) (La X más nueva)
Selecciona Instalar
En la barra de aplicaciones selecciona la aplicación recién instalada
NOTA: En caso de que no aparezca la aplicación en la tienda de aplicaciones, intenta buscar en synaptic,
usando el comando: sudo synaptic
6
Capı́tulo 3
El Intérprete y su entorno
3.1. Lenguaje Interpretado

A diferencia de C ó Java, u otros lenguajes, en Python no es necesario escribir un programa completo, grabarlo,
compilarlo y después ejecutarlo.
Puedes escribir las instrucciones en el intérprete, e ir ejecutando de una en una, si ası́ lo deseas. Esa capacidad
es conocida como programación interactiva.
Python es bueno para programas de 3-4 lı́neas de largo, pero la mayorı́a de los programas son mucho más
largos, ası́ que los escribimos en un archivo y decimos a python que ejecute los comandos en el archivo.
En cierto sentido estamos dando a Python un guión llamado script, como convención, agregamos .py como el
sufijo al final de estos archivos para indicar que contienen Python.
Python es un lenguaje interpretado, que puede ahorrar un tiempo considerable durante el desarrollo del progra-
ma porque no es necesario la compilación y vinculación.
El intérprete puede utilizarse interactivamente, lo que facilita la experimentación con Caracterı́sticas del len-
guaje, escribir programas de borrador o probar funciones durante el desarrollo del programa de abajo hacia
arriba.
También es una calculadora de escritorio práctica.
Python permite que los programas se escriban de forma compacta y legible. Los programas escritos en Python
suelen ser mucho más cortos que los programas equivalentes de C, C ++ o Java, por varias razones:
los tipos de datos de alto nivel permiten expresar operaciones complejas en una única sentencia;
el agrupamiento de instrucciones se realiza mediante sangrı́a en lugar de los paréntesis de inicio y fin;
no son necesarias declaraciones de variables o argumentos.
Python es extensible: si sabes programar en C, es fácil agregar una nueva función o módulo incorporado al
Intérprete, ya sea para realizar operaciones crı́ticas a la velocidad máxima, o para enlazar programas Python
a bibliotecas que sólo estarán disponible en forma binaria (como una biblioteca de gráficos especı́fica del
proveedor). Una vez que esté realmente vinculado, puede enlazar el intérprete de Python a una aplicación
escrita en C y usarla como una extensión o lenguaje de comandos para esa aplicación. [?]
Por cierto, el idioma se nombra después que la BBC mostrara ``Monty Python’s Flying Circus´ý no tiene nada
que ver con reptiles. Hacer referencias a Monty Python en la documentación no sólo está permitido, se anima!
Tienes 2 maneras de ejecutar las instrucciones o programas:
Python Shell directamente en el sı́mbolo del sistema
7
8
Python IDLE sobre un IDE para Python (IDLE), que te despliega una ventana gráfica, con ciertas opciones
que facilitan la escritura de instrucciones de Python, como por ejemplo Abrir o guardar un programa,
ası́ como opciones de edición, etc.
3.2. Python shell

Básicamente es ejecutar el intérprete de Python en la lı́nea de comandos del sistema operativo.
Figura 3.1: Python Shell
3.3. IDLE
Un IDE (Integrated Development Environment) es una aplicación de software que facilita el desarrollo a los
programadores.
Un IDE normalmente consiste de un editor de código, herramientas de edición automatizadas, y un depurador.
IDLE (Integrated DeveLopment Environment) significa básicamente lo mismo que IDE, pero con un nombre
diferente para distinguirse del resto de los IDE.
9
Figura 3.2: Python IDLE

10
3.4. Ejemplos
Figura 3.3: Ejemplos de comandos básicos

11
Figura 3.4: Borrar valores de variables
Después de escribir los comandos anteriores, ve al menú, Shell, Restart Shell, y posteriormente intenta que el
IDLE te dé el valor de las variables: x, y, z, edad.
12
Figura 3.5: Variables borradas
3.5. Ejercicios
¿Puedes cambiar el tamaño de fuente de IDLE a 16? si
¿Puedes cambiar el color de la fuente de IDLE a rojo? si
¿Puedes cambiar el color de fondo del redactor del texto al amarillo? si
Si escribes 3 + 4 en el IDLE y pulsas enter, ¿qué aparecerá en la pantalla? 7
Si escribes x= 3 + 4 en el IDLE y pulsas enter, ¿qué aparecerá en la pantalla? nada

Capı́tulo 4
Primeros pasos!
El clásico programa obligatorio en cualquier lenguaje, en Python ¡es solo una lı́nea!
Figura 4.1: Hola Mundo Python!
4.1. Comentarios
4.1.1. Comentarios de una sola lı́nea
El sı́mbolo # representa el inicio de un comentario, todo lo que esté a la derecha será ignorado por el intérprete
de Python.
# Este es el primer comentario
foo = 1 # Este es el segundo comentario
# ... y ahora un tercer comentario !
STRING = "# Este NO es un comentario ."
Listing 4.1: Descriptive Caption Text
4.1.2. Comentarios de múltiples lineas

Los sı́mbolos ”’ y ”””representan el inicio/fin de un comentario, todo lo que esté enmedio será ignorado por el
intérprete de Python.
’’’ Este es el inicio de un comentario
esta linea continua el primer comentario
y ahora una tercera linea en el mismo comentario !
13
14
’’’
bar =1
""" Este es el inicio de un comentario
esta linea continua el segundo comentario
y ahora una tercera linea en el mismo comentario !
"""
STRING = "# Este NO es un comentario ."
4.2. Algoritmos y Programas

Definiciones de Algoritmo:
Un Algoritmo es la descripción de cómo resolver un problema.
Un Algoritmo es una secuencia de instrucciones de cómo realizar una tarea, ejemplo: cocinar algo.
Los Algoritmos pueden ser escritos y analizados en cualquier lenguaje, ejemplos: español, inglés, ecua-
ciones matemáticas, o lenguaje de computación, etc.
Los Algoritmos pueden ser escritos y analizados independientemente del lenguaje de programación en
que vayan a ser programados.
Puede haber diferentes algoritmos para resolver el mismo problema.
Otra definición de Algoritmo:
Simples instrucciones o pasos
Control del flujo, que determina cuando cada paso es ejecutado
Una manera para determinar cuando parar de ejecutar los pasos y terminar.
Definiciones de Programa:
Un Programa es una implementación de un algoritmo en un lenguaje de programación especı́fico.
Un Programa es una secuencia de instrucciones a una computadora.
Macarena Un ejemplo de Algoritmo, serı́an los pasos necesarios para bailar la canción Macarena.
https://www.youtube.com/watch?v=vlzwuFkn88U
15
Entrada: La canción de Macarena

Salida: La canción de Macarena bailada
1: while Hay música do
2: Mano izquierda hacia fuera y hacia arriba
3: Mano derecha hacia fuera y hacia arriba
4: Voltear la mano izquierda
5: Voltear la mano derecha
6: Mano izquierda al hombro derecho
7: Mano derecha al hombro izquierdo
8: Mano izquierda a la parte posterior de la cabeza
9: Mano derecha a la parte posterior de la cabeza
10: Mano izquierda a cadera derecha
11: Mano derecha a cadera izquierda
12: Mano izquierda en la parte inferior izquierda
13: Derecha en la parte inferior derecha
14: Menearse
15: Saltar
16: end while
Figura 4.2: Algoritmo para bailar la canción de Macarena
Co −→Fo Otro ejemplo de Algoritmo:

Convertir un cantidad de grados Centı́grados a Faherheit.
Entrada: Una temperatura en grados centı́grados

Salida: La temperatura convertida a faherenheit
1: Solicitar temperatura en grados centı́grados
2: Multiplicar la entrada por 9
3: Dividir el resultado anterior por 5
4: Sumarle 32 al resultado anterior
5: Mostrar el resultado
Figura 4.3: Algoritmo para convertir de grados Centı́grados a Fahrenheit

16
Inicio
Solicitar grados centigrados
multiplicar centigrados por 9
Resultado anterior dividido entre 5
Sumar 32 al resultado anterior
Mostrar resultado anterior
Fin
Figura 4.4: Diagrama de Flujo Co −→Fo
Lo que debemos aprender, es que puedas convertir un algoritmo dado a un programa Python.
Enseguida mostraremos el programa en Python del ejemplo de conversión de Co a Fo .
Inicio
A=20
B=A*9
C=B/5
D=C+32
print(D)
Fin
Figura 4.5: Programa en Python para convertir Co −→Fo
En el IDLE se ejecuta igual
Figura 4.6: Co aFo

17
Pero ahora suponemos que queremos convertir 40o C en lugar de los 20o C, tendremos que volver a escribir
todas las instrucciones.
Cómo vemos es molesto, lo mejor es guardar las instrucciones como un programa, para eso nos vamos a File,
New File, y nos abre una ventana nueva.
En la nueva ventana escribimos nuestro programa, lo guardamos con extension .py, y lo ejecutamos en Run,
Run Module.
18
Listo!, ya realizaron su primer programa en Python.
4.3. Ejemplos
Ahora vamos a ver un ejemplo similar, aquı́ está nuestro algoritmo, y hay que realizar un programa en Python
que realice lo indicado en el algoritmo.
Inicio
Asigna un valor a una variable de altura
Asigna un valor a una variable de base
Calcula el área= base * altura
Calcula el perı́metro= (base + altura) * 2
imprime los valores encontrados
Fin
Figura 4.7: Calcular Área y Perı́metro de un Rectángulo

Capı́tulo 5
Variables e Identificadores
5.1. Variables
Las variables son localidades de memoria reservadas para almacenar valores, que pueden ser enteros, flotantes,
strings (cadenas de texto), etc.
5.2. Identificadores
Los identificadores son nombres que asignamos a: variables, funciones, objetos, etc.
Los identificadores son sensitivos a mayúsculas, de manera tal que X es diferente de x.
Es recomendado utilizar identificadores con nombres descriptivos, para asociar rápidamente su significado al
observar su nombre.
Un identificador sólo puede contener sı́mbolos alfanuméricos y subraya.
No puede empezar con un número
No puede ser igual que alguna palabra reservada de Python
5.2.1. Prueba estas asignaciones en el IDLE

x=3
X=5
print (x)
print (X)
x1=6
1x=7
hola_mundo =8
hola mundo =9
mi_prueba =1
mi$prueba =2
for =4
in=2
5.2.2. Ejemplos de identificadores válidos:
19
20
abc
Abc
_x5
mi_x
mi_x1
5.2.3. Ejemplos de identificadores inválidos:

2x
x.2
A-2
mi x
for
Cuando el nombre de una variable tenga varias palabras, se recomienda separar cada palabra con el sı́mbolo de
subraya `` ´´, sin usar mayúsculas.
por ejemplo: area rectangulo = base * altura
5.2.4. Ejercicios:
Respuesta: (2.3)
Y = 2.3
y = " perro "
print (Y)
Respuesta: (error)
M = 12
print (m)
Respuesta:
2x = 4
print (2x)
(error)
Respuesta: (4)
21
mi_variable = 4
print ( mi_variable )
Respuesta: (error)
mi variable = 5
print (my variable )
Respuesta: (Hola)
A_2 = "Hola"
print (A_2)
5.3. El signo ’=’

Es importante notar que en el contexto de Python, el signo = es usado para asignar un nombre a una variable.
En otras palabras significa asociar un identificador con una variable u objeto.
X=2 no significa que X sea igual a 2, es simplemente que se toma el resultado de la derecha (que en este caso
es 2), se guarda en una localidad de memoria, la cual es identificada por X.
Es mejor leer X es asociada a 2, de ésta manera puede ya tener sentido la siguiente sentencia: X=X+1 , que
en matemáticas definitivamente es extraña, pero en Python significa que el programa debe:
Ir a la localidad de memoria asociada al identificador X
Tomar el valor de la localidad y sumarle uno.
Guardar el resultado en la localidad de memoria que es identificada por X (en este caso la misma locali-
dad).
Note que para este caso, la operación sobreescribe el valor previo que habı́a en la localidad de memoria.
5.4. Variables vs Identificadores

Las variables y los identificadores no son sinónimos. El nombre de una variable es un identificador, pero una
variable tiene otros atributos como valor, tipo, ámbito, etc.
Suponemos por ejemplo un objeto de tipo Persona, que tiene un identificador (nombre del objeto), pero el
objeto tendrá posiblemente otros atributos como por ejemplo: altura, peso, color de ojos, etc.
22
5.5. Programa ejemplo

Un programa que calcule el área y el perı́metro de rectángulo, puede ser.
x=20
y=30
z=x*y
w=2*(x+y)
print (z)
print (w)
El programa esta correcto y nos da el área y el perı́metro adecuado a las dimensiones del rectángulo.
Sin embargo, algún programador puede no tener ni idea del significado de: w,x,y,z
Por lo que se recomienda usar identificadores más descriptivos, y entonces reescribimos el mismo programa,
pero con los identificadores más adecuados al problema.
altura_rectangulo =20
base_rectangulo =30
area_rectangulo = altura_rectangulo * base_rectangulo
perimetro_rectangulo = 2 * ( altura_rectangulo + base_rectangulo )
print ( area_rectangulo )
print ( perimetro_rectangulo )

Capı́tulo 6
Tipos de Variables
Python tiene un set de tipos de variables inter-construidas, que pueden usarse como ladrillos para construir
objetos más complejos, ejemplos: int, float, str, bool, complex list, dict, etc.
Python tiene una selección automática del tipo de variable del identificador.
Imagine un grupo de preguntas para una persona:
¿Cuantos hijos tiene?
¿Cuanto pesa en kg?
¿Cual es su nombre?
¿Es usted feliz?

Las respuestas podrı́an ser:
¿Cuantos hijos tiene? 3 (int)
¿Cuanto pesa en kg? 80.2 (float)
¿Cual es su nombre? Juan López (str)
¿Es usted feliz? Si (bool)
6.1. Número entero o Integer (int)

A partir de Python 3, solamente existe un solo tipo de int (64 bits) que abarca a los anteriores int y long.
¿Que pasa cuando escribes la siguiente instrucción en python?
mi_variable =7+9
Python calcula el lado derecho de la asignación
Guarda el resultado en una localidad de memoria
Asocia la localidad con el identificador mi variable
23
24
Como el resultado de la operación a la derecha de la asignación resulta ser un entero, el tipo de la variable
será entera (int).
Resumiendo lo anterior:
El identificador de la variable es mi variable
El valor de la variable es 16
El tipo de la variable es int
Podemos verificar lo anterior escribiendo la siguiente instrucción:
print (type( mi_variable ))
6.2. Número con punto decimal (float)

En python a diferencia de C, no hay distinción entre float y double. Todos son float, donde se emplea 1 bit para
el signo, 11 bits para el exponente, y 52 bits para la mantisa.
¿Que pasa cuando escribes la siguiente instrucción en python?
mi_variable =8/2
Python calcula el lado derecho de la asignación

Guarda el resultado en una localidad de memoria
Asocia la localidad con el identificador mi variable
Como el resultado de la operación a la derecha de la asignación resulta ser un número con punto decimal
flotante, el tipo de la variable será flotante (float).
Resumiendo lo anterior:
El identificador de la variable es mi variable
El valor de la variable es 4.0
El tipo de la variable es float
Podemos verificar lo anterior escribiendo la siguiente instrucción:
mi_variable =0.5e -7

25
6.3. String o cadenas de texto (str)

Los strings son secuencias inmutables de caracteres
mi_variable ="Hola"
6.4. Boleano (bool)

Las opciones para este tipo de valor son: True y False
Estas no son opciones: true, false, TRUE, FALSE, etc.
mi_variable =True
6.5. Complejos (complex)

Se utilizan para representar números complejos, están formados por dos números de tipo float
mi_variable = 3.2 + 7j
mi_variable = 5J + 3
6.6. Listas (list)

Una lista es un contenedor que contiene a otros objetos (donde cada objeto puede ser cualquier objeto, incluso
otra lista por ejemplo).
El orden de los objetos dentro de la lista importa, en otras palabras, la lista es una secuencia de objetos, no es
una bolsa de objetos.
6.6.1. Creando una lista

Para crear una lista, se ponen todos los objetos dentro de unos corchetes cuadrados, separados por comas,
ejemplo:
26
mi_lista =["hola" ,5.6 ,137 , True]

print ( mi_lista )
6.6.2. Accediendo a los elementos de la lista

Se usan los corchetes cuadrados y el ı́ndice del elemento de la lista:
El indexado positivo es de izquierda a derecha, y comienza del 0,1,...,N-1
El indexado negativo es de derecha a izquierda, y comienza del -1,-2,...-N
Indexado
0 1 2 3
Positivo
list ’Hola’ 5.6 137 True
Indexado
-4 -3 -2 -1
Negativo
Tabla 6.1: Indices en una lista
Ejemplos:
27
Figura 6.1: Accediendo a los elementos de una lista
6.6.3. Ejercicios
x = [5, ’foo ’]
y = [’bar ’, 3.5]
print (x + y)
print (3 * x)
y = [’bar ’]
print (x + 2 * y)
lista =[ ’abc ’ ,123 ,5.7 ,[1 ,2 ,3 ,4 ,5]]
lista
lista [3][0]
#Otros ejemplos
lista = []
lista = [0, 10, 20, 40, 100]
lista = list ()
lista = list( range (5))
lista = list( range (5, 10))
lista = list( range (2, 10, 2))
lista = list ((1 , 2, 3, 4))
28
lista = list(’Hola ’)
lista = list(x**2 for x in range (5))
lista = list(x**2 for x in range (10) if x**2 % 2 == 0)
6.7. Tuplas
Es igual que las listas con la diferencia que los datos son inmutables, es decir, una vez creados ya no se pueden
cambiar.
Para crear una tupla, se ponen todos los objetos separados por comas dentro de paréntesis, o bien, sólo separados
por comas, ejemplos:
mi_tupla =("hola" ,5.6 ,137 , True)
print ( mi_tupla )
mi_tupla ="hola" ,5.6 ,137 , True
print ( mi_tupla )
Para crear una tupla que tiene un valor único, debe utilizar una coma después del elemento, aunque sólo haya
un valor.
Por ejemplo, si deseas crear una tupla que sólo tiene un elemento en ella,y ese elemento es un cuatro, entonces
tienes que tener un par de paréntesis, poner el cuatro dentro, y después poner una coma. De otro modo serı́a
por ejemplo un int.
mi_tupla =(4 ,)
print ( mi_tupla )
Puedes convertir una tupla en una lista, utilizando la función de lista.

mi_tupla =("hola" ,5.6 ,137 , True)
mi_lista =list( mi_tupla )
print (’tupla ’,mi_tupla )
print (’lista ’,mi_lista )
Igualmente, puedes convertir una una lista en tupla, utilizando la función de tupla.
mi_lista =[ ’lista ’ ,2,2]
mi_tupla =tuple ( mi_lista )
print (’tupla ’,mi_tupla )
print (’lista ’,mi_lista )
Se suele usar las tuplas en el return de las funciones, ya que existe la restricción de que solo se permite regresar
un objeto, entonces se regresa una tupla con varios valores dentro, ejemplo:
29
def suma_resta_producto_division (a,b):

return (a+b, a-b, a*b, a/b)
(s,r,p,d)= suma_resta_producto_division (5 ,3)

print (5,’,’ ,3,’\ nsuma = ’,s,’\ nresta = ’,r,’\ nproducto = ’,p,’\ ndivision = ’,d)
6.8. Rangos (range)

Los Rangos son secuencias inmutables de enteros, usados comúnmente en ciclos.
a= range (0 ,10)
print (type(a))
print (list(a))
print (list(range (0 ,10)))
print (list(range (0 ,10 ,2)))
print (list(range (0 , -10)))
print (list(range (0 , -10 , -1)))
print (list(range (10)))
print (list(range (0)))
6.9. Conjuntos (set)

Los sets son collecciones desordenadas de objetos hashables (para ser hashables deben ser de tipo inmutable).
Hay 2 tipos de sets:
1. Set (mutables)
2. Frozen Set (inmutables)
Los objetos dentro de un set no pueden ser indexados, ya que no tienen locación del tipo de arreglo.
Los conjuntos matemáticos son posibles en Python, la función para crear conjuntos se llama set() y acepta una
serie de valores pasados entre comas, como si se tratara de una cadena de texto. O también puede ser definido
empleando llaves y separando los elementos por comas, ejemplo de los dos casos:
conjunto =set(’846 ’)
conjunto ={8 ,4 ,6}
print ( conjunto )
print (type( conjunto ))

30
Las operaciones posibles a los conjuntos son: unión, intersección, creación de subconjuntos, agregar y borrar
elementos.
Se debe aclarar que no se pueden repetir elementos en los conjuntos, si por error repites un elemento, no se
agregará al conjunto porque ya está incluido.
Enteros menores a 20
2,4,8,10,14,16
1,5,7,11,13,17,19 3,9,15 6,12,18
Impares MúltiplosDe3
Figura 6.2: Ejemplo de Conjuntos
6.9.1. Ejemplos
impares ={1 ,3 ,5 ,5 ,5 ,7 ,9 ,11 ,13 ,15 ,17 ,19}#5 repetido
multiplos_de_3 ={3 ,6 ,6 ,6 ,6 ,9 ,12 ,15 ,18}#6 repetido
multiplos_de_3_e_impares = impares . intersection ( multiplos_de_3 )
multiplos_de_3_o_impares = impares . union ( multiplos_de_3 )
print (" Impares :",impares )
print (" Multiplos de 3:",multiplos_de_3 )
print (" Multiplos de 3 e impares :",multiplos_de_3_e_impares )
print (" Multiplos de 3 o impares :",multiplos_de_3_o_impares )
x={1 ,2 ,3} y={2 ,3 ,4}. Obten {4} usando operaciones basicas entre x e y.
Consider again sets x={1 ,2 ,3} and y={2 ,3 ,4}. How could you get {2, 3} from x and y using
basic set operations ?
Consider again sets x={1 ,2 ,3} and y={2 ,3 ,4}. How could you get {1, 4} from x and y using
basic set operations ?
Consider again sets x={1 ,2 ,3} and y={2 ,3 ,4} . Which following lines of code will
determine if all elements of x are in y ?
x. issubset (y)
x.isin(y)
x.is_in (y)
x in y
31
6.10. Mutable vs Inmutable

Tipo Mutable Inmutable Secuencia
√
int
√
float
√
complex
√
bool
√ √
str
√ √
tuple
√ √
range
√ √
list
√
dict
√
set
√
clases definidas por usuario
6.11. Diccionarios
Los diccionarios son mapeos de objetos llaves (key) a objetos valor (value).
Los diccionarios guardan pares de datos (llave, valor), de forma tal que se necesita la llave para acceder al valor.
Caracterı́sticas de Diccionarios:
Valores :
Pueden ser inmutables o mutables

Puede haber duplicados
Pueden ser listas, o incluso otros diccionarios.
Llaves :
Deben ser de tipo inmutable (int, float, str, tuple, bool) para poder ser hashables, ya que solo los
tipos inmutables pueden ser hashables.
Deben ser únicos
Hay que tener cuidado con los tipos float.
Sin Orden Los datos no necesitan ordenarse para acceder rápido a ellos.
Para acceder a los elementos que están guardados en una lista, se usa el ı́ndice del elemento, ejemplo:
32
Indexado 0 1 2 3
Lista ’Hola’ 5.6 137 True
Tabla 6.2: Indexado en una lista
Mientras que para acceder a los elementos que están guardados en un diccionario, se usa una llave asociada al
elemento, ejemplo:
Indexado Paola Julian Juan Mireya
Diccionario 95 85 70 75
Tabla 6.3: Indexado en un diccionario
Ejemplos:
mi_diccionario ={} # diccionario vacio
calificacion ={" Paola ":95 ," Julian ":85 ,"Juan":70 ," Mireya ":75}
print (" Calificaciones ",calificacion )
print (" calificacion de Juan ",calificacion ["Juan"])
print (" calificacion de Silvia ",calificacion [" Silvia "])#esto es un error , ponlo 1 linea
abajo
calificacion [" Silvia "]=90
print ("Juan" in calificacion )
print (" Daniel " in calificacion )
del( calificacion [" Mireya "])
print (" Llaves ",calificacion .keys ())
print (" Valores ",calificacion . values ())
6.12. Secuencias
seq[i ] Regresa el ı́esimo elemento de la secuencia
seq1+seq2 Concatenación de secuencias (no rangos)
n*seq Repetición de la secuencia n veces (no rangos)
seq[start:end ] partición de la secuencia
e in seq True si e está en la secuencia
e not in seq True si e no está en la secuencia

33
for e in seq itera sobre los elementos de secuencia
len(secuencia) Regresa la longitud de la secuencia.
min(secuencia) Regresa el elemento mı́nimo de la secuencia.
max(secuencia) Regresa el elemento máximo de la secuencia.
sorted(secuencia,key=None,reverse=False) Regresa una secuencia con los elementos de secuencia ordena-

dos. secuencia no se altera. El parámetro key establece el método de comparación. El parámetro reverse
establece si el ordenamiento es en orden ascendente o descendente.
Ejemplos:
lista =[ -2 , -1 ,0 ,1 ,2]
lista2 =[4 ,5 ,6 ,7 ,8]
tupla = (-3, -2, 0, 2, 3)
tupla2 = (9 ,8 ,7 ,6 ,5)
cadena ="hola mundo python "
cadena2 =" esplendido dia!"
print (’lista ’,lista )

print (’lista2 ’,lista2 )
print (’lista [3]: ’,lista [3])
print (’lista + lista2 ’,lista + lista2 )
print (’2* lista ’ ,2* lista )
print (’lista [1:3] ’,lista [1:3])
print (’2 in lista ’ ,2 in lista )
print (’5 in lista ’ ,5 in lista )
print (’2 not in lista ’ ,2 not in lista )
print (’5 not in lista ’ ,5 not in lista )
print (’longitud de lista : ’,len( lista ))
print (’maximo de lista : ’,max( lista ))
print (’minimo de lista : ’,min( lista ))
print (’lista ordenada : ’,sorted (lista , reverse = False ))
print (’lista ordenada : ’,sorted (lista , reverse =True))
print (’lista ordenada : ’,sorted (lista ,key= lambda n: n**2 , reverse = False ))
print (’tupla ’,tupla )

print (’tupla2 ’,tupla2 )
print (’tupla [3]: ’,tupla [3])
print (’tupla + tupla2 ’,tupla + tupla2 )
print (’2* tupla ’ ,2* tupla )
print (’tupla [1:3] ’,tupla [1:3])
print (’2 in tupla ’ ,2 in tupla )
print (’5 in tupla ’ ,5 in tupla )
print (’2 not in tupla ’ ,2 not in tupla )
print (’5 not in tupla ’ ,5 not in tupla )
print (’longitud de tupla : ’,len( tupla ))
print (’maximo de tupla : ’,max( tupla ))
print (’minimo de tupla : ’,min( tupla ))
print (’tupla ordenada : ’,sorted (tupla , reverse = False ))
print (’tupla ordenada : ’,sorted (tupla , reverse =True))
print (’tupla ordenada : ’,sorted (tupla ,key= lambda n: n**2 , reverse = False ))
print (’str ’,cadena )

34
print (’str2 ’,cadena2 )

print (’str [3]: ’,cadena [3])
print (’str+str2 ’,cadena + cadena2 )
print (’2* str ’ ,2* cadena )
print (’str [1:3] ’,cadena [1:3])
print (’2 in str ’,’e’ in cadena )
print (’5 in str ’,’a’ in cadena )
print (’2 not in str ’,’e’ not in cadena )
print (’5 not in str ’,’a’ not in cadena )
print (’longitud de str: ’,len( cadena ))
print (’maximo de str: ’,max( cadena ))
print (’minimo de str: ’,min( cadena ))
print (’str ordenada : ’,sorted (cadena , reverse = False ))
print (’str ordenada : ’,sorted (cadena , reverse =True))
6.12.1. Desempacado de Secuencias

Podemos asignarle a varias variables los valores de una secuencia usando la siguiente sintaxis:
[nomVar, ]...[*nomVar[, nomVar]...] = secuencia
Solo puede haber una variable estrellada.
El número de variables no puede ser mayor que el tamaño de la secuencia.
Si no hay una variable estrellada el número de las otras variables debe ser igual al tamaño de la secuencia.
A cada variable no estrellada se le asigna un valor de la secuencia. A la variable estrellada se le asigna

una lista con el resto de los valores de secuencia. Los valores se asignan en el orden de las variables.
Ejemplos de desempacado:
lista =[ -2 , -1 ,0 ,1 ,2]
a,b,c,d,e = lista
a, b, *c = lista
a, *b, c = lista
*a, b, c = lista
6.13. Sin tipo (None)

Muchos dirı́an que la palabra null es algo esotérica. No es exactamente la palabra más amigable para los
principiantes en programación. Además, None se refiere exactamente a la funcionalidad deseada: no es nada y
no tiene ningún comportamiento.
El tipo None de Python es un objeto y se comporta como tal.
Como None es un objeto, no podemos usarlo para verificar si existe una variable. Es un valor ú objeto, no un
operador que se usa para verificar una condición.
35
my_none_variable = None
A menudo tendremos que realizar una acción que puede que sı́ o que no funcione. El uso de None es una forma
en que se puede verificar el estado de la acción más adelante. Aquı́ hay un ejemplo:
database_connection = None
try:
database = MyDatabase (db_host , db_user , db_password , db_database )
database_connection = database . connect ()
except DatabaseException :
pass
if database_connection is None:
print (’The database could not connect ’)
elsif database_connection is not None:
print (’The database could connect ’)

Capı́tulo 7
Entradas/Salidas de usuario
7.1. Salida
Para escribir una salida de usuario se usa la función print()
que tiene la siguiente sintaxis: print(arg1[,arg2,...][,sep=’ ’][,end=’n’])
sep y end, son opcionales; en caso de no incluirlos, se toma su valor predeterminado, que es el que se ve en la
sintaxis.
ejemplos:
print ("hola"," mundo "," python ",sep=’-’,end=’\n’)
iter =0
while (iter <10):
print (iter ,end=", ")
iter +=1
7.1.1. Formatear una salida

Es común tener que formatear la salida, por ejemplo cuando escribimos tablas de datos.
La función de formateo str.format() genera una cadena que contiene la salida formateada. La sintaxis de esta
expresión es: cadena.format(valores)
Donde:
cadena Es un str que contiene el formato de los valores a imprimir.
valores Puede ser uno o varios valores, cada valor debe estar especificado en un campo de reemplazo en la
cadena.
Un campo de reemplazo tiene la siguiente sintaxis:
{[ nombre del campo ][: especificador de formato ]}
Todo campo de reemplazo va encerrado entre llaves.
36
37
nombre del campo Es un entero empleado como ı́ndice del valor a formatear en la lista de valores. Si se
omiten todos los nombres de campo, se suponen que tienen los valores, 0, 1, 2, etc.
especificador de formato Establece el formato que se le aplicará al valor.
Un especificador de formato tiene la siguiente sintaxis:
:[[relleno]alineacion][signo][#][0][ancho][,][.precision]tipo
Descripción del especificador de formato:
(:) Todo especificador de conversión empieza con el carácter :
relleno Esta opción aplica solo en el caso de que se especifique una alineación. Especifica el carácter con que
se rellenarán los espacios en blanco dentro del campo. Puede ser cualquier carácter excepto ’’ o ’’. El
valor por omisión es ’ ’.
alineación Especifica como se alineará el valor dentro del campo.
(<) El valor se mostrará justificado a la izquierda. Este es el valor por omisión con la mayorı́a de los
objetos.
(>) El valor se mostrará justificado a la derecha. Este es el valor por omisión de los valores numéricos.
(=) Solo aplica a los valores numéricos. Coloca los caracteres de relleno después del signo pero antes de
los dı́gitos.
(ˆ) Centra el valor dentro del campo.
signo Aplica solo a los tipos numéricos. Especifica cómo aparecerá el signo.
(-) El signo sólo se mostrará en los números negativos. Este es el valor por omisión.
( ) (Un espacio), Deberá dejarse un espacio como prefijo de un número positivo.
(+) El valor aparecerá con el prefijo ‘+’ o ‘-’ dependiendo de su signo.
(#) Si se utiliza la opción #, los valores se formatearán usando el formato alterno de acuerdo a lo siguiente.
(b) Se agrega el prefijo ‘Ob’ al número

(o) Se agrega el prefijo ‘Oo’ al número.
(x, X) Se agrega el prefijo 0x o 0X al número.
(e, E, f, F) El resultado tendrá el punto decimal aún si no hay dı́gitos después del punto.
(g, G) El resultado tendrá el punto decimal y conservará los ceros después de él.
(0) Esta opción aplica si no se usa el especificador de alineación. Especifica que se rellene con ceros los
espacios en blanco dentro del campo.
ancho Es un entero que especifica el ancho mı́nimo del campo en que se desplegará el valor.
(,) Especifica que se separarán los miles por comas.

38
precisión Es un entero que indica cuantos dı́gitos se desplegarán después del punto decimal en los flotantes
formateados con f, F, e y E y cuántos dı́gitos se desplegarán antes y después del punto decimal en los
flotantes formateados con g o G. En el caso de valores no numéricos indica el tamaño máximo del campo.
No aplica para los enteros.
tipo Es el carácter de conversión de tipo. Especifica como se mostrarán los datos
Enteros :
(s) String
(b) binario
(c) caracter
(d) decimal
(o) octal
(x,X) hexadecimal
nada decimal
Flotantes :
(e,E) Flotante en notación cientı́fica. La precisión por omisión es 6.
(f, F) Flotante en notación de punto fija. La precisión por omisión es 6.
(g,G) Flotante en notación cientı́fica si el exponente es menor que -4 o no menor que la precisión,
en notación de punto fijo en caso contrario.
( %) Porcentaje. Multiplica el valor por 100 y despliegas u valor en notación de punto fijo, seguido
del carácter %.
nada decimal
7.1.2. Ejemplos
#{[ nombre del campo ][:[[ relleno ] alineacion ][ signo ][#][0][ ancho ][ ,][. precision ]tipo ]}
# Nombre de Campo
print ("{0} y {1}". format (’carne ’, ’huevos ’))
print ("{1} y {0}". format (’carne ’, ’huevos ’))
print ("Esta { comida } es { adjetivo }.". format ( comida =’carne ’, adjetivo =’espantosa ’))
# relleno
print ("{0: - <10} {1:+ <10}". format ("abc","123"))
# Alineacion y ancho
print ("{0: <10} {1: <10}". format ("abc","123"))
print ("{0: >10} {1: <10}". format ("abc","123"))
#signo
print ("{: -} {: } {:+}". format ( -123 , -123, -123))
print ("{: -} {: } {:+}". format (123 , 123 , 123))
##
print ("{:#b} {:#o} {:#x} {:#e} {:#g}". format (123 , 123 , 123 ,123 ,123))
#0
39
print (" {:010} {:05} {:0}". format ( -123 , -123, -123))
#ancho
for x in range (1 ,11):
print (" {0:2} {1:3} {2:4} ". format (x, x*x, x*x*x))
#,
print ("{: ,} {: ,} {: ,}". format (123 , 1234 , 123456789) )
# precision
print ("{:} {:.2} {:.4} ". format (0.12345678 , 0.12345678 , 0.12345678) )
#tipo
print ("{:d} {:f} {:g}". format (12345678 , 12345678 , 12345678) )
7.2. Entrada
Para leer una entrada de usuario se usa la función input()
que tiene la siguiente sintaxis: str input([prompt])
ejemplos:
nombre_usuario =input ("Cual es tu nombre :")
print ("Un gusto conocerte ",nombre_usuario )
El argumento prompt es opcional y lo siguiente también funciona, aunque el usuario puede no saber que es lo
que quiere el programa:
nombre_usuario =input ()
print ("Un gusto conocerte ",nombre_usuario )
La función input() siempre regresa un str, aunque el usuario escriba un número. Hay que tener cuidado con
ese detalle, ejemplo:
centigrados =40
fahrenheit = ( centigrados *9/5) +32
print ( fahrenheit )
Ahora le hacemos una modificación al programa para que pida el valor de la variable centigrados, en lugar de
usar siempre el número 40.
centigrados = input (" centigrados ? ")
40
Nos da un error, ya que la variable centigrados es de tipo str.

¿Que tenemos que hacer?, Respuesta: Convertir la variable str a float.
’’’
conversion_centigrados_faherenheit .py
Programa que convierte de centigrados a faherenheit

’’’
centigrados = float ( input (" centigrados ? "))
7.2.1. Ejemplo
Escribe un programa que pida el radio de un cı́rculo, y que calcule y muestre el área y el perı́metro.
Enseguida un diagrama de flujo del problema anterior:
Inicio
Solicita al usuario el valor del radio del cı́rculo
Calcula el área = radio * radio * 3.1416
Calcula el perı́metro= radio * 2 * 3.1416
imprime los valores encontrados
Fin
Figura 7.1: Calcular Área y Perı́metro de un Cı́rculo

Capı́tulo 8
Operadores
8.1. Aritméticos
Operación operador Ejemplo

Exponenciación ** 2**3
Positivo + +3
Negativo - -3
Multiplicación * 2*3
División / 3/2
Cociente // 5//2
Residuo % 5 %2
Suma + 5+2
Resta - 5-2
Tabla 8.1: Operadores Aritméticos
8.2. Relacionales

menor < 2<3
menor igual <= 2 <= 3
mayor > 2 >3
mayor igual >= 2>= 3
igual == 3==2
diferente != 5!=2
Tabla 8.2: Operadores Relacionales
8.3. Lógicos
Los operadores lógicos operan comparando los valores booleanos de sus operandos.
41
42
Al compararse, los siguientes valores de objetos son considerados como falsos: False, None, el cero en cual-
quier tipo numérico, cadenas, listas, tuplas, dicionarios, y conjuntos vacı́os. Los demás valores se consideran
verdaderos.
Los operandos lógicos normalmente se utilizan para construir expresiones más complejas a partir de expresio-
nes que contienen los operadores relacionales.
Evaluación en Corto Circuito: A veces, para obtener el resultado de las operaciones and y or, solo se requiere
evaluar el operando izquierdo. En estos casos no se evalúa el operando derecho.

not not not (A<0)
and and (A>0) and (A<100)
or or (A>0) or (A<100)
Tabla 8.3: Operadores Lógicos
8.4. Membresı́a

Verificar si un valor existe en una secuencia in 5 in [2,5,3,7]
Verificar si un valor no existe en una secuencia not in 5 not in [2,5,3,7]
Tabla 8.4: Operadores de Membresı́a
8.5. Precedencia
Si una expresión contiene más de un operador, el orden en que se efectúan las operaciones está dado por las
siguientes reglas:
Las expresiones encerradas entre paréntesis son evaluadas primero.
Si en una expresión hay operadores de diferente precedencia, la operación del operador de mayor prece-
dencia se realiza primero.
Si en una expresión hay operadores de igual precedencia, las operaciones se agrupan de izquierda a
derecha, excepto por la exponenciación que se agrupa de derecha a izquierda.
Operador → Descripción
(expresión...), [expresión... ,]
llave: valor..., expresión... → Tuplas, listas, diccionarios, conjuntos
x[ı́ndice , x[ı́ndice:ı́ndice],]
x(argumentos...), x.atributos → Indexamiento, “slicing”, llamada a función, referencia a atributos
await x → Expresión para suspender corutina

43
** → Exponenciación
+, -, ~ → Positivo, negativo, NOT de bits
*, /, //, % → Multiplicación, división, división piso, residuo.
+, - → Suma y resta
<<, >> → Corrimientos a la izquierda y a la derecha
& → AND de bits
ˆ → XOR de bits
| → OR de bits
in, not in, is, is not,
<, <=, >, >=, !=, == → Comparaciones, incluyendo pruebas de membresı́a y pruebas de identidad.
not x → NOT booleano
and → AND booleano
or → OR booleano
if - else → Expresión condicional
lambda → Expresión Lambda
8.6. Ejemplos
8.7. Ejercicios
Capı́tulo 9
Control de flujo
9.1. condicional
La sentencia de selección o condicional, permite que dependiendo del valor de una expresión, la computadora
ejecute (o no ejecute) un grupo de instrucciones.
En Python la sentencia condicional es la sentencia if
9.1.1. if
Sintaxis:
if expresion:
sentencia(s)
elif expresion:
sentencia(s)
elif expresion:
sentencia(s)
...
else:
sentencia(s)
Donde:
expresión es un valor boleano
sentencia son instrucciones
Operación Se selecciona exactamente una de las sentencias compuestas, evaluando cada una de las expre-
siones hasta que una de ellas sea verdadera. Entonces se ejecuta la sentencia compuesta asociada a esa
expresión y ninguna otra. Si todas las expresiones son falsas, entonces se ejecuta la sentencia compuesta
asociada a la cláusula else.
Ejemplo
print ("Este programa encuentra el mayor de 3 ")

print (" numeros enteros ")
a = int( input ("Dame el primer numero : "))
44
45
b = int( input ("Dame el segundo numero : "))

c = int( input ("Dame el tercer numero : "))
if a > b and a > c:

mayor = a
elif b > a and b > c:
mayor = b
else:
mayor = c
print ("El mayor de {}, {} y {}, es {}". format ( a, b, c, mayor ))
Ejercicios
1. Realizar un programa que pida la temperatura en grados celcius, de forma que si la temperatura es menor
a 15, que imprima ”helado”, si es mayor o igual a 15, pero menor de 28, que imprima `àgradable´´, si es
mayor o igual a 28, pero menor de 40, que imprima ``caliente´´, si es mayor, que imprima ”muy caliente”,
9.2. Ciclos
9.2.1. while
La sentencia while nos permite ejecutar una sentencia compuesta, mientras se cumpla una condición.
Sintaxis:
while expresión:
sentencia(s)
[else:
sentencia(s)]
Donde:
expresión es un valor boleano
Operación La sentencia while opera de la siguiente manera:
Se evalúa expresión. Si su valor es verdadero, se ejecuta la primera sentencia y expresión es evaluada

de nuevo, repitiéndose el ciclo.
Si expresión es falsa, incluyendo la primera vez que se evaluó, se ejecuta la sentencia asociada a la
cláusula else y el ciclo termina.
Ejemplo
46
# capital .py
# Este programa genera una tabla del capital
# acumulado de una inversion depositada a una
# tasa de interes dada.
print ("Este programa genera una tabla del")
print (" capital acumulado de una inversion ")
print (" depositada a una tasa de interes dada")
# Lee el capital inicial , tasa de interes anual
# y meses a tabular
capital = float ( input (" Capital inicial : "))
tasa = float ( input ("Tasa de interes anual : "))
meses = int( input (" Meses a tabular : "))
# Escribe el encabezado de la tabla
print ("{0: >3} {1: >12}". format ("Mes"," Capital "))
print (" ------------------")
# Inicializa el contador de meses
mes = 1
# Mientras haya meses a tabular
while mes <= meses :
# Calcula el nuevo capital
capital *= (1 + tasa /12)
# Escribe mes y capital
print (" %3d %12.2f" %(mes , capital ))
# Nuevo mes
mes += 1
9.2.2. for
La sentencia for se utiliza en 2 ocasiones:
1. Cuando se quiere iterar sobre los elementos de una secuencia (list, tuple, str)
2. Cuando quieres repetir un número de veces un grupo de instrucciones.
Caso 1,Sintaxis:
for iterador_variable in secuencia:

sentencia(s)
[else:
sentencia(s)]
Donde:
secuencia puede ser una cadena, una tupla, una lista o cualquier objeto iterable
Operación La sentencia for opera de la siguiente manera:
Se evalúa la secuencia. da como resultado un iterador

47
Cada elemento generado por el iterador, se asigna a la variable iterador variable y luego se ejecuta
sentencia(s)
Cuando ya no hay más elementos se ejecuta la sentencia asociada a la cláusula else y el ciclo
termina.
Ejemplo
Un programa que use un ciclo for para que imprima los tı́tulos de los libros que están guardados en una lista.
mis_libros =[" Python ","Java","C++","Ruby"]
i=1
for x in mis_libros :
print (’Iteracion ’,i,’: ’,x)
if(i==2):
mis_libros . append (" Ensamblador ")
i+=1
else:
print ("No hay mas libros en mi librero ..")
print ( mis_libros )
Un programa que cuente el numero de veces que aparecen las palabras en una lista
def frecuencia_de_palabras ( letra ):
miDicc = {}
for palabra in letra :
if palabra in miDicc :
miDicc [ palabra ] += 1
else:
miDicc [ palabra ] = 1
return miDicc
lista =["uno","dos","uno","tres","uno","tres"]
mi_diccionario = frecuencia_de_palabras ( lista )
print ( mi_diccionario )
Caso 2,Sintaxis:
for iterador_variable in range:

sentencia(s)
[else:
sentencia(s)]
Donde:
range Es un range
Operación La sentencia for opera de la siguiente manera:

48
Se evalúa range una sola vez. Da como resultado un iterador, un objeto que genera elementos
Cada elemento generado por el iterador, se asigna a la variable iterador variable y luego se ejecuta
sentencia(s)
Cuando ya no hay más elementos se ejecuta la sentencia asociada a la cláusula else y el ciclo
termina.
Ejemplo
Un programa que use un ciclo for para que imprima 10 veces un saludo.
for numero_actual in range (1 ,11 ,2):
print ("Hola !! en la iteracion ", numero_actual )
9.2.3. break
La sentencia break termina inmediatamente el ciclo, y se ejecuta la sentencia que está inmediatamente después
del ciclo. Si existen ciclos anidados, solo termina el ciclo más interno al que pertenece el break.
Ejemplo
for char in " computadora ":

print (char)
print ("Fin del ciclo 1")

if char == ’p’:
break
print (char)
print ("Fin del ciclo 2 ( break )")
9.2.4. continue
La sentencia continue es usada para saltar el resto del código de la actual iteración del ciclo. Sin embargo, el
ciclo no termina y continua la siguiente iteración.
Ejemplo

print (char)
print ("Fin del ciclo 1")

if char == ’p’:
continue
49
print (char)
print ("Fin del ciclo 2 ( continue )")
9.3. Ejercicios
1. Haz un programa que escriba los números primos del 1 al 100
2. Haz un programa que sume los números del 1 al 100
3. Haz un programa que pida un número entero y que lo forme de billetes de $500, $200, $100, $50, $20, y
monedas de $10, $5 y $1; usando el menor número posible de las mismas.
4. Haz un programa que diga cuales son las palabras más usadas en la canción despacito, enseguida se
proporciona la letra de la canción.
Ay
Fonsi
DY
Oh oh...
Oh no, oh no...
Oh
Yeah...
Dididiri Daddy
Go
Sı́, sabes que ya llevo un rato mirándote

Tengo que bailar contigo hoy (DY)
Vi que tu mirada ya estaba llamándome
Muéstrame el camino que yo voy (Oh)
Tú, tú eres el imán y yo soy el metal

Me voy acercando y voy armando el plan
Solo con pensarlo se acelera el pulso (Oh yeah)
Ya, ya me está gustando más de lo normal

Todos mis sentidos van pidiendo más
Esto hay que tomarlo sin ningún apuro
Despacito
Quiero respirar tu cuello despacito
Deja que te diga cosas al oido
Para que te acuerdes si no estás conmigo
50
Despacito
Quiero desnudarte a besos despacito
Firmo en las paredes de tu laberinto
Y hacer de tu cuerpo todo un manuscrito
Sube sube
Sube, sube, sube
Quiero ver bailar tu pelo

Quiero ser tu ritmo
Que le enseñes a mi boca
Tus lugares favoritos (Favorito, favorito baby)
Déjame sobrepasar tus zonas de peligro

Hasta provocar tus gritos
Y que olvides tu apellido
(Daddy Yankee)
Si te pido un beso ven dámelo

Yo sé que estás pensándolo
Llevo tiempo intentándolo
Mami esto es dando y dandolo
Sabes que tu corazón conmigo te hace bom bom
Sabes que esa beba está buscando de mi bom bom
Ven prueba de mi boca para ver como te sabe
quiero quiero quiero ver cuanto amor a ti te cabe
Yo no tengo prisa yo me quiero dar el viaje
Empecemos lento, después salvaje
Pasito a pasito, suave suavecito
Nos vamos pegando, poquito a poquito
cuando tú me besas con esa destreza
Veo que eres malicia con delicadeza

Y es que esa belleza es un rompecabezas
Pero pa montarlo aquı́ tengo la pieza, (oye)
Despacito
Quiero respirar tu cuello despacito
Deja que te diga cosas al oido
Para que te acuerdes si no estás conmigo
51
Despacito
Quiero desnudarte a besos despacito
Firmo en las paredes de tu laberinto
Y hacer de tu cuerpo todo un manuscrito
Sube, sube, sube, sube, sube
Quiero ver bailar tu pelo

Quiero ser tu ritmo
Déjame sobrepasar tus zonas de peligro

Despacito
Vamos a hacerlo en una playa en Puerto Rico
hasta que las olas griten Ay Bendito
Para que mi sello se quede contigo


Despacito

Nos vamos pegando, poquito a poquito (ehh ehhh)

Nos vamos pegando, poquito a poquito (ehh ehhh)
Capı́tulo 10
Funciones
En Python cualquier función puede llamar a cualquier otra función.

Una función es un fragmento de código con un nombre asociado que:
Opcionalmente recibe argumentos de entrada
Realiza una serie de instrucciones
Devuelve un valor, cuando el programador no especifica un valor de retorno la función devuelve el valor
None (nada)
Sintaxis de una función:
def mi_funcion(ParametrosOpcionales):
[docstring (cadena de documentación) ]
sentencia(s)
[return valorRetorno]
Donde:
def Es una palabra reservada que indica que comienza una función
mi funcion Nombre de la función
ParametrosOpcionales A su vez los parámetros opcionales tienen también una sintaxis:
[nomParOb[, nomParOb]]...[, nomParOpc = exp]...
nomParOb es un parámetro obligatorio

nomParOpc es un parámetro opcional
exp es el valor que tomará el parámetro opcional si al llamar a la función,no se le pasa su correspondiente
argumento
Los parámetros opcionales van después de los parámetros obligatorios
sentencia(s) Es el cuerpo de una función que contienen las instrucciones que se ejecutarán cuando se llame a
la función
52
53
valorRetorno Es el valor que regresa la función a quien la llamó, solo puede ser un valor; enseguida algunos
aspectos importantes a considerar del valor de retorno:
Puede haber cero, una o más sentencias return dentro de una función, pero sólo una de ellas se
ejecutará.
Si la sentencia return de una función no tiene asociada un valor de retorno, la función regresa el
valor especial None
El valor regresado por una función se puede utilizar, almacenar o descartar. El valor se descarta si
no hay variable a la que se asigne dicho valor
10.0.1. Documentación de la función

Python tiene una ingeniosa manera de documentación, a la que se conoce como docstrings.
DocStrings es una herramienta importante que debe utilizarse, ya que ayuda a documentar mejor el programa
y facilitar su comprensión.
Sorprendentemente, podemos incluso obtener la docstring de, por ejemplo, una función cuando el programa
está en ejecución!
Un comentario en la primera lı́nea de una función, es la docstring para esa función.
La convención seguida para una docstring es un comentario de varias lı́neas donde la primera lı́nea comienza
con mayúscula y termina con un punto. A continuación, la segunda lı́nea está en blanco seguida de cualquier
explicación a partir de la tercera lı́nea. Se recomienda encarecidamente seguir esta convención.
Podemos acceder a la docstring de una función usando el atributo doc (es un doble subrayado)
Si has utilizado help() en Python, entonces ya has visto el uso de docstrings!, lo que hace es sólo buscar el
atributo doc de esa función.
Ejemplo:
def print_max (x,y):
""" Imprime el maximo de 2 numeros .
Los 2 valores deben ser enteros ."""

if(x>y):
print ("{} es mayor ". format (x))
else:
print ("{} es mayor ". format (y))
print_max (3 ,6)
print ( print_max . __doc__ )
help( print_max )
10.0.2. Tipos de funciones

La mayorı́a de las veces proporcionamos algunos argumentos a una función y devuelve algo. Sin embargo,
esto puede no ser siempre el caso. Al intentar escribir una función debemos decidir si la función necesita algún
argumento o no, y si la función necesita devolver algo o no. En términos generales, podemos intentar clasificar
la combinación de parámetros de función y sus tipos de retorno de la siguiente manera:
54
1. Nada entra, nada sale.
2. Nada entra, algo sale.
3. Algo entra, nada sale.
4. Algo entra, algo sale.
Nada entra, nada sale

A veces necesitamos hacer alguna tarea repetidamente y esa tarea nunca cambia. En este caso, la función no
necesita ningún argumento (parámetros) y no necesita devolver nada.
Tenga en cuenta que los paréntesis en la llamada de función no tienen nada, lo que significa que la función no
toma ningún argumento. Tampoco se asigna el valor de retorno a nada, es decir, la llamada de función está en
una lı́nea por sı́ misma, lo que significa que no necesita devolver nada. Ası́ que, básicamente, esta función
sólo mantiene la impresión del mismo mensaje cada vez que se llama (impresión de algo no es lo mismo que
devolver algo). Aunque no hay ninguna palabra clave de retorno en esta función, devuelve un None de forma
predeterminada.
Ejemplo:
def show_mensaje ():
print ("**** PYTHON IS GENIAL ****")
# Main Programa #
radio = 5
print ("El radio del circulo es: ", radio )
show_mensaje () # Llamada a la funcion
circunferencia = 2*3.14* radio
print ("La circunferencia del circulo es:", circunferencia )
show_mensaje () # Llamada a la funcion
Nada entra, algo sale

Un buen ejemplo de una función que no recibe nada, sino que devuelve algo, es la función generadora de un
número aleatorio. Observe que esta función no recibe argumentos, pero cada vez que llamamos a esta función,
devuelve un entero aleatorio entre 20 y 100 y asigna el valor devuelto a una variable.
Ejemplo:
import random
def get_random ():

miRandom = random . randint (20 , 100)
return miRandom
# Main Programa #
a = get_random () # regresa un random int y se asigna a a
print ("a es igual a ", a)
b = get_random () # regresa un random int y se asigna a b
print ("b es igual a ", b)
55
c = get_random () # regresa un random int y se asigna a c

print ("c es igual a ", c)
Algo entra, nada sale

En este escenario, la función necesita algunos argumentos para realizar alguna tarea pero no necesita devolver
nada. Observe que esta función recibe dos argumentos de longitud y anchura y cuando llamamos a esta función,
calcula el área y el perı́metro de un rectángulo e imprime los resultados pero no devuelve nada. Y otra vez
imprimir algo no es lo mismo que devolver algún valor. El valor devuelto una vez más para esta función es
None ya que no hay ninguna palabra clave return.
Ejemplo:
def calcula_area (largo , ancho ):
area = largo * ancho
perimetro = 2* largo + 2* ancho
print ("area: ", area)
print (" perimetro : ", perimetro )
# Main Programa #
calcula_area (10 , 20)
Algo entra, algo sale

Éste es probablemente el escenario más significativo donde la función toma algunos argumentos y realiza algu-
na tarea usando esos argumentos y devuelve algún resultado también. Tenga en cuenta que podemos devolver
varias cosas en python separándolas con una coma.
Ejemplo:
def calcula_area (largo , ancho ):
area = largo * ancho
perimetro = 2* largo + 2* ancho
mi_resultado =( area , perimetro ) #pone los resultado en una tupla
return mi_resultado
# Main Programa #
mi_tupla = calcula_area (10 , 20) # son proporcionados dos argumentos
print ("Area y Perimetro :", mi_tupla )
10.1. Funciones disponibles del interprete de Python

abs() dict() help() min() setattr() all() dir() hex() next() slice() any() divmod() id() object() sorted() ascii()
enumerate() input() oct() staticmethod() bin() eval() int() open() str() bool() exec() isinstance() ord() sum() by-
tearray() filter() issubclass() pow() super() bytes() float() iter() print() tuple() callable() format() len() property()
56
type() chr() frozenset() list() range() vars() classmethod() getattr() locals() repr() zip() compile() globals() map()
reversed() import () complex() hasattr() max() round() delattr() hash() memoryview() set()
10.2. Espacios de Nombres (namespace)

En Python, cada módulo o cada función o cada clase tiene su propio espacio de nombres.
Este espacio de nombres se llama: espacio de nombres local, que básicamente significa que es local a esa
función en particular.
Cuando se llama una función e inicia su ejecución,un espacio de nombres se crea para la función, y cuando la
función termina,su espacio de nombres se elimina.
Las variables que se definen en el cuerpo principal de un programa se denominan variables globales. El espacio
de nombres global contiene todas las variables globales.
Ejemplo:
def fun1(x,a):
y=x+a
return y
#Main Programa
x=3
z=x+12
a=fun1(z ,9)
x=a+7
spacename Global spacename fun1

fun1 fun1(x,a) x 15
x 3→31 a 9
z 15 y 24
a 24 retorno 24
Local es el espacio de nombres dentro de la función o método. Por lo tanto, cualquier variable que se declare
dentro de la función, es local para la función. Se adjunta además, el espacio de nombres de la función padre
que llamó a la función. Global es el espacio de nombres del nivel más alto del código de ejecución (función
Main), o en realidad, es el espacio de nombres inter-construido para el programa principal, que son los
nombres incorporados y reservados especialmente para Python.
Por lo tanto, básicamente, cuando se intenta utilizar una variable en Python, Python primero busca en el espacio
de nombres local, si se encuentra,entonces lo usará. Si esa variable no se encuentra en el espacio de nombres
local, entonces busca en el espacio de nombres padre. Si se encuentra, entonces Python lo utilizará. De lo
contrario, va y busca en el espacio de nombres global. Una vez más, si se encuentra, lo utilizará. De lo contrario
va y mira en los nombres incorporados. Si se encuentra, entonces Python lo usa, y si no se encuentra, entonces
se genera un error por valor indefinido.
El orden de búsqueda entonces es:
1. Local (función actual)

57
2. Padre (Cuando una función está anidada dentro de otra función)
3. Global (Programa Main)
4. Python (Variables del intérprete Python)
Ejemplo 1 (usando la variable local):

def fun1 ():
x=7
print ("x de fun1",x)
#Main Programa
x=15 # variable Global
fun1 ()
print ("x de Main",x)
Ejemplo 2 (usando la variable global):

def fun1 ():
#Main Programa
fun1 ()
Ejemplo 3 (usando la variable padre):

def fun1 ():
def fun2 ():
x=7
fun2 ()
#Main Programa
fun1 ()
Ejemplo 4 (usando la variable global en lugar de la variable del espacio de nombres padre):
def fun1 ():
def fun2 ():
global x
x=7
58
fun2 ()
#Main Programa
fun1 ()
Ejemplo 5 (mostrando el peligro del uso de global indiscriminado):

def fun1 ():
global x
def fun2 ():
global x
x=7
fun2 ()
#Main Programa
print ("x de Main ",x)
fun1 ()
Ejemplo 6 (usando una variable de Python):

def fun1 ():
def fun2 ():
x=True
x=7
fun2 ()
#Main Programa
fun1 ()
10.3. Funciones como Objetos

Las funciones son objetos del tipo function
Una función puede asignársele a una variable
El nombre de la variable puede usarse para invocar a la función
59
Ejemplo
def mayor (x, y):
if (x > y ):
return x
return y
print (type( mayor ))

may = mayor
print (may (2, 7))
10.4. Funciones como Argumentos de Funciones

Una función puede recibir como argumento otra función
Dentro de la primera función, el argumento puede usarse para llamar a la segunda función
Ejemplo
def ordenar_estudiantes_por_nombre ( estudiante ):
return estudiante [0]
def ordenar_estudiantes_por_matricula ( estudiante ):

def ordenar_estudiantes_por_calificacion ( estudiante ):

estudiantes = [
(’Juan ’, ’01 ’, 8.4) ,
(’Zenia ’, ’46 ’, 7.5) ,
(’Belinda ’, ’24 ’, 9.5)]
print (’sin Ordenar :’,estudiantes )
estudiantesOrdenados = sorted ( estudiantes , key= ordenar_estudiantes_por_nombre , reverse =

False )
print (’por Nombre :’,estudiantesOrdenados )
estudiantesOrdenados = sorted ( estudiantes , key= ordenar_estudiantes_por_matricula , reverse =

False )
print (’por Matricula :’,estudiantesOrdenados )
estudiantesOrdenados = sorted ( estudiantes , key= ordenar_estudiantes_por_calificacion ,

reverse = False )
print (’por Calificacion :’,estudiantesOrdenados )

60
10.5. Función Lamda

Una expresión Lambda produce un objeto del tipo función
Una expresión Lambda puede emplearse en cualquier lugar en que se requiera una función
La sintaxis de una expresión Lambda es:
lamda [listaParametros]: expresión
listaParametros consiste de cero o más parámetros separados por coma
expresión es una expresión que emplea esos parámetros
Se utiliza para crear funciones anónimas
Ejemplo
tupla =(4,2,-7,5,8,9,-1,3,6,-2,-4)
print (’tupla ordenada : ’,sorted (tupla ,key= lambda n: n**2 , reverse = False ))
10.6. Ejercicios
Realiza Un programa que ordene una lista de acuerdo al siguiente Algoritmo:
INSERTION-SORT
Entrada: un arreglo A[n]
Salida: A[n] ordenado
1: for j ← 2 to length [A] do

2: key ← A j
3: i← j−1
4: while i > 0 and A [i] > key do
5: A [i + 1] ← A [i]
6: i←i−1
7: end while{Busca donde insertar key}
8: A [i + 1] ← key
9: end for
Figura 10.1: Pseudo-código del algoritmo InsertionSort

Capı́tulo 11
Recursividad
11.1. Definición
Una recurrencia es una ecuación o desigualdad que describe a una función en términos de sı́ misma, pero con
argumentos más pequeños [?].
Si una función recursiva se llama siempre a sı́ misma, nunca se detendrı́a y tendrı́amos un ciclo infinito; para
evitar lo anterior, una función recursiva debe contener una condición de terminación que termine la recursivi-
dad.
La recursividad es una de las formas de control más importantes en la programación. Los procedimientos
recursivos son la forma más natural de representación de muchos algoritmos.
Cuando un procedimiento incluye una llamada a sı́ mismo se conoce como recursión directa.
Cuando un procedimiento llama a otro procedimiento y éste causa que el procedimiento original sea invocado,
se conoce como recursión indirecta.
Figura 11.1: Matrushka
61
62
11.2. Procedimientos recursivos

Un procedimiento recursivo es aquél que se llama a sı́ mismo. En general, ésta no suele ser la manera más
eficaz de escribir código.
La principal ventaja de los procedimientos Recursivos es la simplicidad de comprensión y su gran potencia,
favoreciendo la resolución de problemas de manera natural, sencilla y elegante; y facilidad para comprobar y
convencerse de que la solución del problema es correcta.
El principal inconveniente es la ineficiencia tanto en tiempo como en memoria, que requiere su realización,
puede implicar que para determinados algoritmos no sea conveniente su utilización por lo que cada problema
debe ser considerado según sus propios méritos individuales.
Quizá la función recurrente más conocida sea la función factorial, definida por la fórmula:
N! = N · (N − 1)!, para N ≥ 1 con 0! = 1
Esta función se corresponde directamente con el siguiente programa recursivo simple:

def factorial (n):
if (n==0):
return 1;
return (n * factorial (n -1))
Aspectos a considerar en el ejemplo anterior:
La llamada a factorial(-1) se traduce en un ciclo infinito recursivo, es de hecho un fallo recurrente que
puede aparecer en forma más sutil en programas recursivos más complejos.
Puede parecer solo un ciclo for con adornos, y difı́cilmente resulta en un ejemplo convincente de la
recursión.
Un segundo ejemplo, también ampliamente conocido, es la recurrencia que define a los números de fibonacci:
F N = F N−1 + F N−2 para N ≥ 2 con F0 = F1 = 1
Esto define la sucesión: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, ...
De nuevo la correspondencia con un programa recursivo simple:
def fibonacci (n):
if (n <=1):
return 1;
return ( fibonacci (n -1)+ fibonacci (n -2))
Este es un excelente ejemplo de lo dramáticamente ineficaz que puede ser la recursión.

El problema aquı́ es que el número de llamadas necesarias para calcular F N es exponencial y es aproximada-
mente φN donde φ ≈ 1.61803..., φ se conoce como la razón de oro.
Por el contrario es muy fácil calcular F N en tiempo lineal, como se indica a continuación:
63
def fibonacci (n):

F=list(range (0,n+1))
F [0]=1
F [1]=1
for i in range (2,n+1):
F[i]=F[i -1]+F[i -2]
return F[n]
El programa anterior calcula los primeros n números de Fibonacci, utilizando un arreglo de tamaño n para ir
almacenando los valores previos. Como los números Fibonacci crecen exponencialmente, n debe ser pequeño.
11.3. Mecánica de recursión

Una función recursiva se compone de:
Caso Base una solución simple para un caso particular (puede haber más de un caso base).
Caso Recursivo una solución que involucra volver a utilizar la función original, con parámetros que se acercan
más al caso base. Los pasos son:
1. El procedimiento se llama a sı́ mismo.

2. El problema se resuelve, resolviendo el mismo problema pero de tamaño menor.
3. La manera en la cual el tamaño del problema disminuye asegura que eventualmente se alcanzará el
caso base.
64
11.4. Transformación de algoritmos recursivos a iterativos

El objetivo de este curso es diferente a las técnicas de complilación, sin embargo, se puede decir que la elimi-
nación mecánica de la recursión de un algoritmo para conseguir una implementación no recursiva, es la misma
operación que enfrenta un complilador para traducir un programa recursivo a lenguaje máquina.
Existen varias técnicas usadas para lograr ese objetivo, aunque solo veremos 2 de las más usadas, y dependen
del tipo de recursión: lineal o no.
n-1
...
Cuando una función realiza una sola llamada recursiva, 1

el árbol que representa su ejecución se muestra como
una cadena donde cada vértice tiene un solo hijo. Es- Figura 11.2: Recursividad lineal
te árbol puede fácilmente convertirse en un programa
iterativo que ahorra espacio y tiempo de ejecución.
Un ejemplo de la figura 11.2, es el algoritmo para calcular el factorial de un número n.
Algoritmo Recursivo Algoritmo Iterativo

def factorial (n): def factorial (n):
if (n==0): if (n <=0):
return 1; return 1;
return (n * factorial (n -1)) tmp =1
for i in range (1,n+1):
Listing 11.4: Descriptive Caption Text tmp *=i;
return tmp
n-1 n-1
... ... ...

Cuando tenemos algoritmos que no son de recursión
simple, es decir, si se dibuja su árbol de recursión, pue-
de haber vértices con más de 1 hijo. En este caso, se Figura 11.3: Recursividad múltiple
complica bastante la transformación a iterativo.
65
Sin embargo, se pueden eliminar las llamadas recursivas para asegurar que el programa se pueda ejecutar en
prácticamente cualquier entorno de programación, de la siguiente manera:
Las variables locales se introducen en la pila.
Al final del procedimiento se actualizan las variables locales al valor guardado en la pila.
Un ejemplo de la figura 11.3, es el algoritmo para calcular el fibonacci de un número n.
Algoritmo Recursivo
def fibonacci (n):
if (n <=1):
return 1;
return ( fibonacci (n -1)+ fibonacci (n -2))
Algoritmo Iterativo
def fibonacci3 (n):
pila = [n]
suma =0
while (len(pila) > 0):
numero = pila.pop (0) # Elimina el primer elemento de la pila
if ( numero <= 1):
suma +=1
else:
pila. append (numero -1) # agrega a la pila fibonacci -1
pila. append (numero -2) # agrega a la pila fibonacci -2
return suma
11.5. Recursividad en el diseño

Existe una gran variedad de técnicas para diseñar algoritmos; por ejemplo el algoritmo insertion sort usa una
técnica incremental. Esta técnica consiste en resolver un problema de tamaño j − 1 para después procesar un
dato adicional y resolver un problema de tamaño j.
Otra técnica muy utilizada es la técnica divide y vencerás. Esta técnica parte un problema en subproblemas
de las mismas caracterı́sticas pero más pequeños, luego resuelve estos subproblemas en forma recursiva, y
finalmente combina las soluciones parciales para resolver el problema original.
Dividir para vencer es una técnica natural para las estructuras de datos, ya que por definición las estructuras de
datos están compuestas por piezas. Cuando una estructura de tamaño finito se divide, las últimas piezas ya no
podrán ser divididas, y entonces se rompe la recursividad y se comienza a resolver hacia atrás.
Técnica Divide y Vencerás:
Divide Divide el problema en un subconjunto de subproblemas.
Conquista Conquista los subproblemas al resolverlos en forma recursiva.
Combina Combina las soluciones parciales de los subproblemas para obtener la solución al problema original.
66
Consideraciones sobre procedimientos recursivos:
Condiciones de limitación. Debe designar un procedimiento recursivo para probar al menos una condi-
ción que pueda poner fin a la recursividad; también debe supervisar los casos en los que no se satisface
ninguna condición dentro de un número razonable de llamadas recursivas. Si no existe al menos una
condición que pueda cumplirse sin errores, el procedimiento corre un riesgo elevado de ejecutarse en un
bucle infinito.
Uso de la memoria. La aplicación tiene una cantidad de espacio limitada para las variables locales.
Cada vez que un procedimiento se llama a sı́ mismo, utiliza más cantidad de ese espacio para las copias
adicionales de sus variables locales. Si este proceso continúa indefinidamente, se acaba produciendo un
error Stack Overflow Exception.
Eficacia. Casi siempre se puede sustituir la recursividad por un bucle. Un bucle no tiene la sobrecarga de
transferir argumentos, inicializar el almacenamiento adicional y devolver valores. El rendimiento puede
ser mucho mayor sin llamadas recursivas.
Recursividad mutua. Si dos procedimientos se llaman mutuamente, el rendimiento puede ser muy de-
ficiente o incluso puede producirse un bucle infinito. Este tipo de diseño presenta los mismos problemas
que un procedimiento recursivo único, pero puede ser más difı́cil de detectar y depurar.
Llamadas con paréntesis. Cuando un procedimiento Function se llama a sı́ mismo de manera recur-
siva, debe agregar paréntesis detrás del nombre del procedimiento, aun cuando no exista una lista de
argumentos. De lo contrario, se considerará que el nombre de la función representa al valor devuelto por
ésta.
Pruebas. Si escribe un procedimiento recursivo, debe probarlo minuciosamente para asegurarse de que
siempre cumple ciertas condiciones de limitación. También deberı́a comprobar que la memoria no resulta
insuficiente debido a la gran cantidad de llamadas recursivas.
Capı́tulo 12
Programación Modular
12.1. Definición
Una de las técnicas que nos permiten la creación, depuración, prueba y mantenimiento de programas de tamaño
mediano (unos cuantos cientos de lı́neas) se llama descomposición funcional la cual consiste en descomponer
el programa en funciones, cada una de las cuales ejecuta una tarea especı́fica del problema a resolver. Sin
embargo, a medida que los programas se hacen cada vez más complejos, su código ahora ocupa miles de
lı́neas, es conveniente que el código se divida en varios archivos para facilitar su mantenimiento, cada archivos
se conoce como Módulo. Podemos definir nuestras funciones más utilizadas en un módulo e importarlas, en
lugar de copiar sus definiciones en diferentes programas.
12.2. Módulo
Cada archivo, llamado módulo contiene definiciones y sentencias.
Cada módulo puede ser importado en otros módulos o ser ejecutados por el intérprete de Python o en
Shell de Python.
El nombre del módulo es el nombre del archivo que contiene al módulo sin la extensión “.py ”
Cada módulo tiene una variable global llamada name que contiene el nombre del módulo.
Si un módulo es ejecutado por el intérprete de Python o en un Shell de Python el valor de la variable

name cambia al valor ‘ main ’.
Lo anterior nos permite agregarle código a un módulo que sólo será ejecutado si el módulo es ejecutado
por el intérprete de Python o en un Shell de Python.
Puedes ver una lista de los módulos de python en la siguiente dirección:

https://docs.python.org/3/py-modindex.html
Creación de nuestro módulo Escribe un programa de nombre mis funciones.py, con el siguiente contenido
def sumar (a, b):
""" Esta funcion recibe 2 numeros
y regresa la suma de ambos """
67
68
resultado = a + b
return resultado
pi = 3.1416
e = 2.7183
Usar nuestro módulo En otro script, escribe lo siguiente:

import mis_funciones
a= mis_funciones . sumar (5 ,3)

print (a)
print ( mis_funciones .pi)
print ( mis_funciones .e)
Importar Renombrando
import mis_funciones as mis
a= mis. sumar (5 ,3)

print (a)
print (mis.pi)
print (mis.e)
Importar un objeto especifico solamente

from mis_funciones import pi ,e
print (pi)
print (e)
Importar todo
from mis_funciones import *
print (pi)
print (e)

Capı́tulo 13
Archivos
13.1. Modo de apertura
Modo Descripción
r Predeterminado, Lectura solamente.
rb Lectura solamente en formato binario
r+ Lectura y Escritura.
rb+ Lectura y Escritura en formato binario.
w Escritura solamente. Sobrescribe el archivo si existe. Crea un nuevo archivo si no existe.
wb Escritura solamente en formato binario.
w+ Lectura y Escritura. Sobrescribe el archivo si existe. Crea un nuevo archivo si no existe.
wb+ Lectura y Escritura en formato binario.
a Abre un archivo para Agregar. El puntero de archivo se pone al final del archivo si el archivo existe.
ab Abre un archivo para Agregar en formato binario.
a+ Agregación y Lectura.
ab+ Agregación y Lectura en formato binario.
Tabla 13.1: Modos de Apertura en Archivos
13.2. Abrir un Archivo

La función open() tiene la siguiente sintaxis:
archivo=open(nombre_archivo[,modo][,codificación])
modo De acuerdo la tabla 13.1
codificación La codificación predeterminada depende de la plataforma. En Windows, es ’cp1252’ pero en

Linux es ’utf-8’ . Por lo tanto, no debemos confiar también en la codificación predeterminada, o bien
nuestro código se comportará de manera diferente en diferentes plataformas. Por lo tanto, cuando se
trabaja con archivos en modo texto, se recomienda especificar el tipo de codificación.
69
70
Abrir y Cerrar un archivo suponiendo que tienes un archivo de nombre despacito.data

mi_archivo =open(’despacito .data ’,’r’)
letra_despacito = mi_archivo .read () #lee el archivo completo
print ( letra_despacito )
#resto del codigo
mi_archivo . close () # cierra el archivo
Método Descripción
archivo.read([tamaño]) Lee el archivo completo. Regresa un str. Si el tamaño es indicado, lee los bytes indicados.
archivo.readline([tamaño]) Lee una linea del archivo. Regresa un str. Si el tamaño es indicado, lee los bytes indicados.
archivo.readlines([tamaño]) Lee todas las lineas del archivo. Regresa una lista de lineas. Si el tamaño es indicado, lee los bytes indicados.
Tabla 13.2: Formas de leer de un archivo
Formas de leer de un archivo suponemos un archivo de texto, de nombre test.txt y con el siguiente conte-
nido
primera linea
segunda linea
tercera linea
cuarta linea
quinta linea
Modo 1 de lectura
mi_archivo = open(’test.txt ’,’r’)
mi_str = mi_archivo .read ()
print ( mi_str )
mi_archivo . close ()
Modo 2 de lectura
mi_str = mi_archivo . readline ()
print ( mi_str )
print ( mi_str )
print ( mi_str )

71
Modo 3 de lectura
mi_str = mi_archivo . readlines ()
print ( mi_str )
13.3. Escribir en un Archivo

Ejemplo 1 En este ejemplo, si el archivo no existe, lo crea; y si existe, lo reemplaza.
mi_archivo = open(’test_2 .txt ’,’w’)
mi_str = mi_archivo . write (’Hola Mundo Python ’)
Ejemplo 2 En este ejemplo, se abre el archivo para lectura y escritura

mi_archivo = open(’test.txt ’,’r+’)
print ( mi_str )
mi_archivo . write (’Hola ’)
Ejemplo 3 En este ejemplo, se abre el archivo para agregar, y no se puede leer del archivo
mi_archivo = open(’test.txt ’,’a’)
print ( mi_str )
# mi_archivo . write (’Hola ’)
Ejemplo 4 En este ejemplo, se abre el archivo para agregar, y ahora se agrega algo
mi_archivo . write (’xxxxxxxxxx ’)

72
13.4. Posición en el Archivo
Método Descripción
archivo.tell() Regresa la posición actual del puntero en el archivo.
archivo.seek(offset[,rel pos]) Cambia la posición actual del puntero en el archivo.
Tabla 13.3: Métodos de posicionamiento en el Archivo
Métodos de posicionamiento en el Archivo La posición relativa del puntero del archivo puede ser:
1. 0: (os.SEEK SET) principio del archivo
2. 1: (os.SEEK CUR) posición actual
3. 2: (os.SEEK END) final del archivo
Ejemplo 1 En este ejemplo, se abre el archivo para agregar, y ahora se agrega algo
mi_archivo . write (’xxxxxxxxxx ’)
Ejemplo 2 En este ejemplo, se mueve el puntero del archivo, aunque hay ocasiones en que hay errores
dependiendo de la plataforma
mi_archivo = open(’test.txt ’,’r+’)
mi_archivo .seek (10 ,0)
mi_archivo . write (’ZZZZZ ’)
print ( mi_str )
k = mi_archivo .tell ()
print (k)

Capı́tulo 14
Errores y Excepciones
Hay 3 tipos de posibles errores en la programación:

1. Sintaxis
2. Semántica
3. Lógicos
Sintaxis Errores de escritura, fáciles de detectar, el compilador te avisa si encuentra estos errores en tu pro-
grama. Enseguida un error tipico (olvidar poner los dos puntos al final de la definición de la función):
def funcion (x)
print (x)
Semántica Errores de la comprensión del significado de la instrucción. Generalmente el error ocurre durante
la ejecución del programa, entonces ahora se llaman Exceptions (porque puede manejarse y reponerse al error),
ejemplo:
x=5
y=’perro ’
z=x+y
Lógicos El algoritmo no está correctamente analizado.
14.1. Manejando Exceptions

Para algunos tipos de errores es posible encontrar una solución, en tales casos, se suele manejar la exception
usando el bloque:
try
except
73
74
que tiene la siguiente sintaxis:

try:
sentencia(s)
except exception_1,var:
sentencia(s)
except exception_2,var:
sentencia(s)
. . .
else:
sentencia(s)
finally:
sentencia(s)
Donde:
Las instrucciones entre try y except son ejecutadas
Si no hay excepciones, se ejecutan las instrucciones de else
Si una excepción ocurre, se ejecutan las instrucciones del except correspondiente a la excepción
Un except sin asociar a ninguna excepción en particular, maneja todo tipo de excepciones.
Las instrucciones de finally siempre son ejecutadas
Ejemplo 1 La exception NameError ocurre cuando una variable no es encontrada en ningún espacio de
nombres.
x = y+2
print (x)
Ejemplo 2 La exception ZeroDivisionError ocurre cuando un número es divido entre cero.

x = 0
z = 5/x
Ejemplo 3 Abrir un archivo.

try:
fp=open(’test.txt ’,’r’)
except IOError :
print (’No se pudo abrir el archivo ’)
else:
datos =fp. readlines ()
print ( datos )

75
Ejemplo 4
respuesta_usuario =input (’Dame un numero : ’)
try:
y= float ( respuesta_usuario )
p= 10/y
except ( ZeroDivisionError ):
print (’Division por cero ’)
except ( ValueError ):
print (’No puedo convertir el numero a float ’)
else:
print (’El valor de p es: ’,p)
finally :
print (’Terminado !’)
Ejemplo 5
try:
p= 10/y
except ( ZeroDivisionError , ValueError ):
print (’Error ’)
else:
finally :
Ejemplo 6
try:
p= 10/y
except :
print (’Error ’)
else:
finally :
Errores comunes:
FloatingPointError
OverflowError
ZeroDivisionError
IOError
76
EOFError
ImportError
IndexError
KeyError
NameError
SyntaxError
IdentationError
TabError
TypeError
Bibliografı́a
[Fernández Montoro, 2013] Fernández Montoro, A. 2013. “Python 3 al descubierto.”. Alfaomega. México.
OCLC: 946343802.
[Guido Van Rossum, 2001] Guido Van Rossum 2001. “Python/C API Reference Manual”.
[Sedgewick, 2004] Sedgewick, R. 2004. “Algoritmos en c++/ algorithms in c++”. Addison Wesley Longman.
[Wikia, ] Wikia, . “Parseltongue | Harry Potter Wiki | Fandom powered by Wikia”.
77

AAAMain

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AAAMain

Uploaded by

Copyright:

Available Formats

Instituto Tecnológico Superior de Cajeme

Ingenierı́a en Sistemas Computacionales

Cd. Obregón, Sonora, México. Julio de 2017.

5.2.3. Ejemplos de identificadores inválidos: . . . . . . . . . . . . . . . . . . . . . . . . . . 20

12. Programación Modular 67

14. Errores y Excepciones 73

1.1. Guido van Rossum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3.1. Python Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1. Hola Mundo Python! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

6.1. Accediendo a los elementos de una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

7.1. Calcular Área y Perı́metro de un Cı́rculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

10.1. Pseudo-código del algoritmo InsertionSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

1.1. Lista de Palabras Reservadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

6.1. Indices en una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

8.1. Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

13.1. Modos de Apertura en Archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Figura 1.1: Guido van Rossum

1.1.2. ¿Porque Python?

1.1.3. The zen of Python

1.1.4. El código de inspiración Python

and del from not while

Tabla 1.1: Lista de Palabras Reservadas

1.3. Objetivos de Aprendizaje

Comprender las expresiones y declaraciones de Python

Obtener datos de entrada del usuario y manipularlo.

Implementar estructuras de control como sentencias if y ciclos

Leer y escribir en archivos de datos externos usando Python.

Implementar funciones y llamar a funciones integradas de Python.

Importar y usar módulos de funciones de biblioteca de la biblioteca de Python.

Gestionar errores y excepciones de programación.

Selecciona Downloads y da click en All Releases

Selecciona la última versión

Selecciona la versión adecuada a tu plataforma

Ejecuta el programa descargado y sigue las instrucciones del instalador.

2.2. Linux Ubuntu

Selecciona IDLE (using Python 3.X) (La X más nueva)

En la barra de aplicaciones selecciona la aplicación recién instalada

3.1. Lenguaje Interpretado

no son necesarias declaraciones de variables o argumentos.

Python Shell directamente en el sı́mbolo del sistema

3.2. Python shell

Figura 3.1: Python Shell

Figura 3.2: Python IDLE

Figura 3.3: Ejemplos de comandos básicos

Figura 3.4: Borrar valores de variables

Figura 3.5: Variables borradas

¿Puedes cambiar el color de la fuente de IDLE a rojo? si

¿Puedes cambiar el color de fondo del redactor del texto al amarillo? si

Si escribes 3 + 4 en el IDLE y pulsas enter, ¿qué aparecerá en la pantalla? 7

Si escribes x= 3 + 4 en el IDLE y pulsas enter, ¿qué aparecerá en la pantalla? nada

Figura 4.1: Hola Mundo Python!

Listing 4.1: Descriptive Caption Text

4.1.2. Comentarios de múltiples lineas

STRING = "# Este NO es un comentario ."

Listing 4.2: Descriptive Caption Text

4.2. Algoritmos y Programas

Un Algoritmo es la descripción de cómo resolver un problema.

Puede haber diferentes algoritmos para resolver el mismo problema.

Otra definición de Algoritmo:

Simples instrucciones o pasos

Control del flujo, que determina cuando cada paso es ejecutado

Un Programa es una implementación de un algoritmo en un lenguaje de programación especı́fico.