Apuntes de Programacion I Con Python

Apuntes de Programación I con Python
Luisantos Bonilla Mejı́a

luisantos.bm@hotmail.com
20 de octubre de 2021
BML | 2
Introducción
El presente documento está formado por mis apuntes de clase de la materia de Programación
I, las cuales fueron impartidas en la Escuela de Matemática, de la Universidad de El Salvador.
La primera unidad está formada por el contenido impartido en un minicurso de introducción

a la programación, desarrollado en tres semanas en el mes de agosto del 2020.
El resto de unidades están formadas por el contenido impartido en el ciclo I-2020, para las
carreras de Licenciatura en Matemática y Licenciatura en Estadı́stica.
Agradecimientos
Doy las gracias primeramente a Dios y a la licda. Patricia Rodrı́guez, por el tiempo que se
tomó para brindarme sugerencias en la edición y formato de este material.
Además, quiero agradecer a los alumnos que estuvieron a lo largo del curso, por haberme
permitido ser parte de su formación profesional.
Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Índice general
Unidad 1: Introducción a la programación

1.1 Conceptos básicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Representación de datos en las computadoras . . . . . . . . . . . . . . . . . . . 10
1.2.1 Representación binaria de los números naturales . . . . . . . . . . . . . . 11
1.2.2 Cambiar de un sistema a otro . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 Operaciones básicas con números binarios . . . . . . . . . . . . . . . . . . . . . 14
1.4 Pseudocódigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.5 Variables en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.5.1 Listas en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5.2 Cadenas de texto en Python . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.5.3 Constantes en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.5.4 Comparando valores en Python . . . . . . . . . . . . . . . . . . . . . . . 22
1.6 Condicionales en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.6.1 Solicitando información al usuario . . . . . . . . . . . . . . . . . . . . . . 24
Unidad 2: Ciclos, listas y funciones

2.1 Ciclos For y While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.2 Función range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.3 Sentencias pass, break y continue, Cláusula else . . . . . . . . . . . . . . . . . . 28
2.4 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.5 Funciones en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.5.1 Definiendo funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3
BML | Índice general 4
2.5.2 Parámetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5.3 Argumentos por nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.5.4 None, return y pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.6 Alcance y variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.7 Errores y excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.8 Documentación de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.9 Ejercicios - 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.10 Ejercicios - 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Unidad 3: Módulos
3.1 Módulos en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.1.1 Usando Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2 Creación de módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.1 Usando As . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Unidad 4: Secuencias en Python

4.1 Tuplas y listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.1.1 Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.1.2 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.2 Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2.1 Métodos de los diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Unidad 5: Ficheros
5.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.1.1 Matriz en Numpy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2 Archivos .txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2.1 Atributos de los archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.3 Archivos .csv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

BML | Índice general 5
5.3.1 Métodos de Pandas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

5.4 Laboratorio - 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.5 Laboratorio - 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Unidad 6: Recursividad
6.1 Funciones recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.2 Tipos de recursión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.3 Algoritmos de ordenamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.4 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Unidad 7: Programación funcional

7.1 Función lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2 filter, map, reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2.1 Filter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2.2 Map. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
7.2.3 Reduce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.3 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Capı́tulo 1
Introducción a la programación
6
BML | Conceptos básicos 7
1.1. Conceptos básicos
El beneficio que nos da la programación es la de eliminar tareas repetitivas, por ejemplo,

calcular el área de 50 triángulos, dadas las longitudes de la base y la altura de dichos triángulos.
Tareas similares se volverı́an demasiadas tediosas (no imposibles) de realizar en determinados
lapsos de tiempo, por ello la programación nos da una salida muy fácil para solventar estos
problemas.
Hoy en dı́a existen muchos algoritmos de programación para realizar diferentes tareas en
especifico, unas mejores que otras de acuerdo a la necesidad del programador. Debido a esto
los software los podemos clasificar:
Lenguaje Máquina: Es el que entienden directamente las computadoras y este consiste en

programar usando el alfabeto binario, es decir, ceros y unos (0 y 1). Con este alfabeto
formamos cadenas de ceros y unos que la máquina entiende usando el microprocesador
como nuestras instrucciones.
Dicho lenguaje de programación fue el primero en usarse para programar, sin embargo
debido a la facilidad de cometer errores se ha dejado de utilizar.
Lenguajes de programación de bajo nivel: Es el lenguaje de programación que se carac-

teriza porque influye directamente en el hardware, para poder transmitir las instrucciones
a la máquina.
La desventaja de usar este tipo de lenguaje es que depende bastante de los componentes
fı́sicos de la máquina, sin embargo su implementación es más fácil para la creación de
programas.
El lenguaje ensamblador fue el primer lenguaje de programación que trató de sustituir el
lenguaje máquina por otro lenguaje que fuese más parecido al de los seres humanos.
Lenguajes de programación de alto nivel: Son aquellos cuya caracterı́stica principal, con-
siste en una estructura sintáctica y semántica legible, acorde a las capacidades cognitivas
humanas.
A diferencia de los lenguajes de bajo nivel, son independientes de la arquitectura del
hardware, lo que significa que tienen mayor portabilidad.
En la actualidad, por su facilidad de lectura para el ser humano, existen muchos progra-
mas de alto nivel, por ello, es necesario clasificarlos. La clasificación que mostraremos a
continuación se ha hecho pensando en la utilidad para el cual fue creado el lenguaje de
programación.

1. Lenguajes de programación imperativos: entre ellos tenemos COBOL, PASCAL, C

y ADA.
2. Lenguajes de programación declarativos: LISP y PROLOG.
3. Lenguajes de programación orientados a objetos: SMALLTALK y C++.
4. Lenguajes de programación orientados al problema: Son aquellos lenguajes especı́fi-
cos para gestión.
5. Lenguajes de programación naturales: Son los nuevos lenguajes que pretender apro-
ximar el diseño y la construcción de programas al lenguaje de las personas.
Notemos que los lenguajes de programación de bajo nivel son difı́ciles de aprender; ya que al
depender del hardware, requiere que el programa sea reescrito desde el inicio cuando se quiera
utilizar en una máquina distinta a la que se utilizó para crear el programa, ya que depende de la
codificación de los procesadores de cada máquina. Por otro lado los lenguajes de programación
de alto nivel son más fáciles de aprender porque se usan palabras o comandos del lenguaje
natural, generalmente del inglés.
Existe otra forma de clasificar los lenguajes de programación de acuerdo al desarrollo de las
computadoras, dicha clasificación es la siguiente.
Lenguajes de programación de primera generación: Lenguaje de máquina y de bajo nivel.
Lenguajes de programación de segunda generación: Los primeros lenguajes de programa-

ción de alto nivel imperativo (FROTRAN, COBOL).
Lenguajes de programación de tercera generación: Son lenguajes de programación de alto

nivel imperativo (ALGOL 8, PL/I, PASCAL, MODULA).
Lenguajes de programación de cuarta generación: Usados en aplicaciones de gestión y

manejo de bases de dados (NATURAL, SQL).
Lenguajes de programación de quinta generación: Creados para la inteligencia artificial y

para el procesamiento de lenguajes naturales (LISP, PROLOG).
Durante el desarrollo de este curso nos ocuparemos de un lenguaje de alto nivel, para
ser especifico nos concentraremos en aprender el lenguaje de programación llamado Python
(Python 2.7 y Python 3). Por otra parte, de manera introductoria tengamos en cuenta el
siguiente glosario.

Glosario
Términos Definición
Lenguaje informático Es un idioma artificial, utilizado por ordenadores, cu-
yo fin es transmitir información de algo a alguien. Los
lenguajes informáticos, pueden clasificarse en: a) lengua-
jes de programación (Python, PHP, Pearl, C, etc.); b)
lenguajes de especificación (UML); c) lenguajes de con-
sulta (SQL); d) lenguajes de marcas (HTML, XML); e)
lenguajes de transformación (XSLT); f) protocolos de
comunicaciones (HTTP, FTP); entre otros.
Lenguaje de programa- Es un lenguaje informático, diseñado para expresar
ción órdenes e instrucciones precisas, que deben ser llevadas
a cabo por una computadora. El mismo puede utilizarse
para crear programas que controlen el comportamiento
fı́sico o lógico de un ordenador. Está compuesto por una
serie de sı́mbolos, reglas sintácticas y semánticas que de-
finen la estructura del lenguaje.
Lenguajes interpretados A diferencia de los lenguajes compilados, no requieren de
un compilador para ser ejecutados sino de un intérpre-
te. Un intérprete, actúa de manera casi idéntica a un
compilador, con la salvedad de que ejecuta el programa
directamente, sin necesidad de generar previamente un
ejecutable. Ejemplo de lenguajes de programación inter-
pretado son Python, PHP, Ruby, Lisp, entre otros.
Tipado dinámico Un lenguaje de tipado dinámico es aquel cuyas variables,
no requieren ser definidas asignando su tipo de datos,
sino que éste, se auto-asigna en tiempo de ejecución,
según el valor declarado.
Multiplataforma Significa que puede ser interpretado en diversos Siste-
mas Operativos como GNU/Linux, Windows, Mac OS,
Solaris, entre otros.
Multiparadigma Acepta diferentes paradigmas (técnicas) de programa-
ción, tales como la orientación a objetos, aspectos, la
programación imperativa y funcional.
Código fuente Es un conjunto de instrucciones y órdenes lógicas, com-
puestos de algoritmos que se encuentran escritos en un
determinado lenguaje de programación, las cuales deben
ser interpretadas o compiladas, para permitir la ejecu-
ción del programa informático.

BML | Representación de datos en las computadoras 10
Investiga y responde cada una de las siguientes interrogantes:
1. Escribe otras desventajas que poseen los lenguajes de bajo nivel.
2. ¿Cuáles términos se pueden aplicar a Python del glosario anterior?

Nota: Por lo descrito en la tabla sabemos que Python es un lenguaje informático, inter-
pretado, ası́ que la pregunta está dirigida al resto de términos.
3. Cuál es la definición de lenguaje de programación compilado. Además cite algunos

ejemplos.
1.2. Representación de datos en las computadoras
La computadora solo entiende dos estados, encendido o apagado, que fácilmente podemos
relacionar con las respuesta de sı́ o no de nuestro lenguaje cotidiano. Más aún, estos dos estados o
dos respuestas las podemos representar por 0 y 1, a esto se le conoce como bit o dı́gito binario
(por el ingles Binary Digit ).
Básicamente, las computadoras representan la información mediante bits, de esta forma el
lenguaje de la computadora es enteramente binario. El bit es la unidad más pequeña en que la
computadora puede almacenar información.
Está claro que con un bit no es suficiente para poder guardar información compleja, por
esta razón formamos secuencias de bits, que nos permitirán representar la información. A las
secuencias de longitud 8 (cadenas de 8 bits) son llamados Byte. A continuación mostramos
una tabla de unidades de información.
Unidades de información
Unidad Sı́mbolo Equivalencia
Bit b 0y1
Byte B 8b
Kbyte KB 1024 B
Mbyte MB 1024 KB
Gbyte GB 1024 MB
Tbyte TB 1024 GB
Observación: Con los Bytes tenemos 256 combinaciones de 0 y 1, las suficientes para
representar nuestro alfabeto y caracteres especiales.
Teniendo claro cómo la computadora entiende la información, podemos asociar a cada se-
cuencia de bits un valor, y de esta forma tener un esquema de codificación de información, esto
permitirá poder interactuar con la computadora de una manera más natural. Algunos esquemas
de codificación son:

BML | Representación binaria de los números naturales 11
1. ASCII: El código ASCII (por sus siglas en ingles American Standard Code for Informa-
tion Interchange) es el código estándar para el intercambio de información (se pronuncia
Aski).
2. EBCDIC: El código (por sus siglas en ingles EBCDIC Extended Binary Coded Decimal
Interchange Code) es un código binario que representa caracteres alfanuméricos, controles
y signos de puntuación. Cada carácter está compuesto por 8 bits.
3. Unicode: Es un código diseñado para facilitar el tratamiento informático, transmisión

y visualización de textos de numerosos idiomas y disciplinas técnicas, además de textos
clásicos de lenguas muertas. El término Unicode proviene de los tres objetivos: universa-
lidad, uniformidad y unicidad. Este código puede tratar secuencias de 8, 16 o 32 bits.
Nota: ASCII tiene 255 caracteres y EBCDIC tiene 256 caracteres.

Ejemplo: Tabla del código ASCII.
1.2.1. Representación binaria de los números naturales
Hablando un poco sobre cómo la computador entiende la información, conozcamos de ma-

nera mecánica, cómo codificar y decodificar números enteros no negativos.
Primero conozcamos el mecanismo de codificación, para ello veamos cómo codificar 5 en el
código binario.

BML | Representación binaria de los números naturales 12
Como vemos tenemos que ir dividiendo entre dos el cociente en cada nuevo paso, luego para
saber el código binario del número 5, tomamos el último cociente y tomamos los residuos de
forma ascendente como indica la flecha roja. Ası́ tenemos que 5 en código binario es 101.
Ahora para recuperar la información a partir del código binario, hacemos una multiplica-
ción de derecha a izquierda, multiplicando el dı́gito binario por una potencia de dos, donde
el exponente de dos es la posición del dı́gito binario. Las posiciones comienzan desde cero.
Implementemos lo anterior para la secuencia 101.
(1 ∗ 22 ) + (0 ∗ 21 ) + (1 ∗ 20 ) = 4 + 0 + 1 = 5
Nota: Este proceso es llamado decodificación.

Ejercicios:
1. Convertir a código binario los números: 2, 3, 8, 15 y 27

2. Decodificar las siguientes secuencias: 10, 11, 1000, 1111 y 11011
Una pregunta que puede surgir es ¿podemos hacer lo mismo pero con un número diferente
de dos?
La respuesta a la pregunta anterior es sı́, veamos un caso usando el número entero 16 para
realizar la codificación y decodificación.
Codificación:
Decodificación:
(1 ∗ 161 ) + (3 ∗ 160 ) = 16 + 3 = 19

BML | Cambiar de un sistema a otro 13
Observación: Notemos que son los mismos pasos, salvo que se ha cambiado el 2 por 16.
Teniendo esto en cuenta, tenemos la siguiente tabla de equivalencia entre un código binario
y un código hexadecimal.
Z+0 Binario Hexadecimal

0 0000 0
1 0001 1
2 0010 2
3 0011 3
4 0100 4
5 0101 5
6 0110 6
7 0111 7
8 1000 8
9 1001 9
10 1010 A
11 1011 B
12 1100 C
13 1101 D
14 1110 E
15 1111 F
Utilizando está tabla podemos codificar 27 en sistema hexadecimal.

Codificación:
Por lo tanto la codificación de 27 es 1B, donde 11 se representa por la letra B. Para verificar
hacemos una decodificación.
Decodificación:
(1 ∗ 161 ) + (B ∗ 160 ) = 16 + 11 = 27
1.2.2. Cambiar de un sistema a otro
Para cambiar de un número hexadecimal a un binario y viceversa, lo que hacemos es agrupar

en grupos de 4 lo dı́gitos binarios, de derecha a izquierda, si el último bloque tiene menos de 4

BML | Operaciones básicas con números binarios 14
dı́gitos, estos se llenan con ceros hasta completar los 4. Para entender esto veamos el siguiente
ejemplo:
11011 = (1)(1011) = (0001)(1011) = 1B
1.3. Operaciones básicas con números binarios
1. Sumar. Para sumar números binarios lo hacemos de manera usual, pero teniendo en
cuenta las siguientes operaciones.
0+0=0
1+0=1
0+1=1
1 + 1 = 0, y se lleva 1 a la siguiente columna (para sumar).
Ejemplo:
101+ ⇔ 5+
11 ⇔ 3
1000 ⇔ 8
2. Restar. Para restar números binarios lo hacemos de manera usual, pero teniendo en
cuenta las siguientes operaciones.
0−0=0
1−0=1
1−1=0
0 − 1 = 1, y se lleva 1 a la siguiente columna (para restar).
Ejemplo:
101- ⇔ 5-
11 ⇔ 3
010 ⇔ 2
3. Multiplicar. Para multiplicar números binarios lo hacemos de manera usual, pero usando
las reglas de la suma binaria.

BML | Pseudocódigo 15
Ejemplo:
101 × 11 ⇔ 5×3
101 15
101
1111 ⇔ 15
4. Dividir. Para dividir números binarios lo hacemos de manera usual, pero usando las
operaciones anteriores, y teniendo en cuenta que solo podemos colocar en el cociente
ceros y unos.
Ejemplo:
Ejercicios:
1. Realizar las siguientes operaciones:
111 + 11101 + 10110

11011 − 1101
11011 × 1101
11111 ÷ 11
2. Investigar las reglas para realizas operaciones sobre los números reales codificados en el
sistema binario.
3. Investigar la manera de hacer las mismas operaciones en el sistema hexadecimal.
1.4. Pseudocódigo
Un pseudocódigo1 es la manera informal de presentar el principio o idea operativa de un

programa. Hay muchas maneras de presentar un pseudocódigo, la más fácil es mediante el uso
1
Revisando las partes que conforman la palabra pseudocódigo podemos definirlo como falso lenguaje.

de palabras claves de los lenguajes de programación, estos son: imprimir, si, sino, para y
mientras.
Nota: La idea del pseudocódigo es poder presentar los pasos que un programa debe realizar,
pero de tal manera que un ser humano lo entienda, sin necesidad que conozca o no un lenguaje
de programación.
En términos generales, un pseudocódigo tiene la siguiente estructura:
Proceso Nombre_del_Programa
acción 1
acción 2
...
acción n
FinProceso
Observación: La forma de escribir el pseudocódigo debe ser lo más apegado al lenguaje de

programación que se desea implementar o enseñar.
Una de las ventajas de usar un pseudocódigo es que será más fácil comprender las acciones
principales del programa, y por lo tanto, será más fácil su implementación. Sin embargo, un
pseudocódigo no podrá ser entendido por una computadora, ya que en general, no estará escrito
en el lenguaje de programación que deseemos utilizar.
Veamos un ejemplo de un pseudocódigo para el lenguaje de programación Python.
Ejemplo: El siguiente pseudocódigo representa un programa que puede decidir cuándo un
entero positivo n es par o impar.
Proceso Numero_par
n #un numero entero positivo.
si el residuo de n al ser dividido por 2 es igual a cero:
imprimir n es par
sino:
imprimir n es impar
FinProceso
Observación: En Python con # se puede introducir comentarios, para que el usuario

del código pueda entender mejor ciertas instrucciones. La instrucción imprimir indica que en
pantalla el usuario verá n es par o n es impar.

Ejercicios:
1. Escribir un pseudocódigo de un programa que:
Verifique si un número entero no negativo sea múltiplo de 5.

Realice la suma de dos enteros positivos, si ambos son múltiplos de 3.
Dibuje en pantalla la siguiente figura:
********
* Hola *
* Mundo*
********
Nota: En los lenguajes de programación, si escribimos varios imprimir, cada imprimir

escribirá en una nueva lı́nea en la pantalla. Por ejemplo:
imprimir Hola
imprimir Un gusto
>>> En pantalla veremos:

Hola
Un gusto

BML | Variables en Python 18
1.5. Variables en Python
Las variables son contenedores de información. La información puede ser del tipo numérico,
cadena de texto o de cualquier otro tipo que Python pueda manejar. Al ser contenedores,
requiere un edificador (nombre) para poder acceder a la información que guardan. La sintaxis2
es: mi_variable = valor. El nombres de las variables válidos en Python debe cumplir las
siguientes tres reglas:
1. Son secuencias arbitrariamente largas de letras y dı́gitos.
2. La secuencia debe empezar con una letra.
3. El guión bajo (_) es considerado una letra.
Para que Python presente en pantalla la información de una variable necesitaremos la

instrucción print(). Además, podemos saber el tipo de valor que guarda la variable usando el
comando type().
Ejemplos:
>>> a = 5 >>> c = "Hola Mundo"

>>> print(a) >>> print(c)
5 Hola Mundo
>>> print(type(a)) >>> print(type(c))
<class ’int’> <class ’str’>
>>> b = 5.5 >>> d = [1,1.1,"Hola",["xD"]]

>>> print(a) >>> print(d)
5.5 [1, 1.1, ’Hola’, [’xD’]]
>>> print(type(b)) >>> print(type(d))
<class ’float’> <class ’list’>
Observación: En los ejemplos anteriores, se han presentado los cuatro tipos básicos de
información que puede contener una variable (entero, real, cadena de texto y lista).
Además en Python podemos cambiar la información de la variable una vez creada, esto se
hace reasignando el valor, veamos un ejemplos de esto.
2
La sintaxis que se presenta, crea la variable al mismo tiempo que le asigna el valor, en dicha asignación
queda determinado su tipo.

BML | Listas en Python 19
Ejemplo:
>>> b = 5.5 >>> b = "Hola de nuevo"

>>> print(a) >>> print(b)
5.5 Hola de nuevo
>>> print(type(a)) >>> print(type(b))
<class ’float’> <class ’str’>
Observación: Notemos que basta con usar la sintaxis: mi_variable = valor, para cambiar
el valor de una variable o para crearla.
Veamos algunas caracterı́sticas básicas de las listas en Python.
1.5.1. Listas en Python
Lista: es un tipo de dato que almacena enteros (int), reales (float) y cadenas de texto
(str), internamente cada posición puede ser un tipo de datos distinto. También dentro de
pueden almacenar listas (list).
Ejemplo:
>>> mi_lista = ["cadena de texto", 15, 2.8, "otro dato", 25]

["cadena de texto", 15, 2.8, "otro dato", 25]
Las listas en Python son:
Heterogéneas: pueden estar conformadas por elementos de distintos tipo, incluidos otras
listas.
Mutables: sus elementos pueden modificarse.
Las listas pueden pensarse como una secuencia de datos ordenados por su posición dentro
de la lista; esto quiere decir que cada elemento dentro de la lista tiene una posición, estas
posiciones comienzan a enumerarse de izquierda a derecha comenzando desde cero y termina
una unidad menos a la cantidad de elementos que posea la lista (en programas como Matlab
u Octave la numeración comienza desde uno hasta el número total de elementos que posea la
lista).
A la posición de cada elemento se les llamará ı́ndice, siendo el ı́ndice cero (0) el pertene-
ciente al primer elemento.
Ejemplos:

BML | Listas en Python 20
>>> mi_lista[0]
"cadena de texto"
>>> mi_lista[3]
"otro dato"
>>> mi_lista[4]
25
En los ejemplos anteriores, podemos observar que 4 es el ı́ndice del último elemento en la
lista; es ası́, ya que la lista tiene 5 elementos, y la numeración en este caso seria desde 0 hasta
4 (desde cero hasta una unidad menos a la cantidad de elementos que posea la lista).
También, podemos extraer una parte de la lista usando los ı́ndices. Para extraer una parte
de la lista, es necesario especificar el ı́ndice desde el cuál deseamos iniciar la extracción, hasta
una unidad más del ı́ndice que queremos finalizar la extracción. Veamos a continuación dos
ejemplos, el primero extraemos desde el segundo elemento hasta el cuarto elemento, y en el
segundo desde el tercer elemento hasta el último (recuerde el último elemento tiene ı́ndice 4).
Ejemplos:
>>> mi_lista[1:4]
[15, 2.8, "otro dato"]
>>> mi_lista[2:5]
[2.8, "otro dato", 25]
Además, a través del ı́ndice, podemos cambiar los elementos de una lista en el lugar que
especifica dicho ı́ndice.
Ejemplos:
>>> mi_lista[0]
"cadena de texto"
>>> mi_lista[0] = 2 #Cambiamos "cadena de texto" por 2.
>>> mi_lista[0]
2
>>> mi_lista[2]
2.8
>>> mi_lista[2] = "¡Hola mundo!" #Cambiamos 2.8 por "¡Hola mundo!".
>>> mi_lista[2]
"¡Hola mundo!"
Como vemos en los ejemplos anteriores, podemos incluso cambiar elementos por otros to-
talmente diferentes, incluso si son de diferentes tipos (en este caso, cambiamos una cadena de
texto por un entero y un real por una cadena de texto).
Por último, podemos agregar nuevos elementos a una lista, lo que significa, hacer más grande
la lista (que tenga más elementos), esto lo podemos hacer con la función append(), la sintaxis
es: lista.append(elemento).

BML | Cadenas de texto en Python 21
Ejemplo:
>>> mi_lista
[2, 15, "¡Hola mundo!", "otro dato", 25]
>>> mi_lista.append("Nuevo Dato")
>>> mi_lista
[2, 15, "¡Hola mundo!", "otro dato", 25, "Nuevo Dato"]
Observación: append() agrega el nuevo elemento al final de la lista, además, podemos

agregar elementos de cualquier tipo, no solo cadenas de texto.
1.5.2. Cadenas de texto en Python
Las cadenas de texto son secuencias de caracteres inmutables3 encerrado entre comillas.
Al ser secuencias, la misma sintaxis de las listas se utiliza para acceder a la información de las
cadenas de texto.
Ejemplos:
>>> texto = "Hola Mundo"

>>> print(texto[3])
a
>>> print(texto[1:5])
ola
>>> print(texto[1:6])
ola M
>>> print(len(texto))
10
Observación: En las cadenas de texto, el espacio es considerado una letra. Además, len()
es una función que nos permite saber cuántos elementos tiene una lista o una cadena de carac-
teres.
También podemos agregar más caracteres a una lista, usando el operador +.
Ejemplo:

>>> nuevo_texto = "Hola otra vez"
>>> print(texto + nuevo_texto)
Hola MundoHola otra vez

3
Son como listas, solo que no se puede cambiar sus elementos una vez creada.

BML | Comparando valores en Python 22
>>> nuevo_texto = "Hola otra vez"

>>> print(texto + " " + nuevo_texto)
Hola Mundo Hola otra vez
Observación: Como vemos, al final de texto se agrega el contenido de nuevo_texto. Podemos

agregar un espacio entre cada cadena de texto, colocando una cadena de texto con un espacio
o directamente al inicio del contenido de la variable nuevo_texto. La cadena de texto formada
por la unión de ambas variables puede ser guardada en una nueva variable.
1.5.3. Constantes en Python
En Python hay valores que son únicos y que se pueden pensar como constantes, los cuales
son:
1. None: Este valor significa literalmente nada. Es muy útil para crear variables que no
queramos utilizar aún.
2. True: Este valor significa literalmente verdadero. Es de gran utilidad para denotar que
cierta condición es verdadera.
3. False: Este valor significa literalmente Falso. Es de gran utilidad para denotar que cierta
condición es falsa.
Observación: Para acceder a esta información basta escribir None, True o False. Por esa
razón son constantes, porque tienen identificador (nombre).
1.5.4. Comparando valores en Python
Para comparar valores en Python se utiliza el doble igual (==), esta instrucción devuelve
True, si ambas expresiones son equivalentes o False, si no son equivalente.
Ejemplos:
>>> print(2==2)
True
>>> print(2==5)
False
Observación: Si queremos saber si dos expresiones no son equivalentes, se utiliza la instrucción

!= (ejemplo: 2!=5, devuelve True).
Nota: De igual forma podemos utilizar <, <=, > y >=, y se entienden tal cual como en
matemática.

BML | Condicionales en Python 23
Ejercicios: Escriba en un archivo Python las siguientes instrucciones y concluya sobre los
valores que se obtienen en pantalla.
1. print(2<3)
2. print(2<=3)
3. print(2>3)
4. print(2>=3)
1.6. Condicionales en Python
Para agregar una condición, usamos la palabra if seguido de una proposición lógica y
cerrando con dos puntos (:). La sintaxis es: if condicion_logica:
Luego de escribir la condición, en una nueva lı́nea se debe colocar las instrucciones que se
ejecutarán, si se cumple la condición. Estas instrucciones deben ir indentadas (una Sangrı́a)
para indicar a Python que pertenecen al condicional.
Ejemplo:
if n%2==0:
print("Es par")
Observación: La instrucción n%2 devuelve el residuo que deja n al ser dividido por 2. La
condición del ejemplo imprimirá en pantalla Es par, si el residuo es cero al dividir por 2.
Si queremos que se ejecute cierta instrucción cuando la condición lógica no se cumpla,
debemos usar else: en una nueva lı́nea.
Ejemplos:
if n%2==0:
print("Es par")
else:
print("Es impar")
Observación: Si la condición no se cumple, automáticamente Python se dirige a ejecutar las

instrucciones del else.
Nota: En Python la instrucción else no puede ser escrita sin que antes exista la instrucción
if.
Además, si tenemos varias condiciones que se excluyen una a otra, luego de usar if en la
primera condición, en las siguientes debe escribirse elif.
Ejemplo:

BML | Solicitando información al usuario 24
if n<3==True:
print("Es menor")
elif n>3==True:
print("Es mayor")
Observación: También podemos colocar else para agregar instrucciones por si las demás
condiciones no se cumplen.
1.6.1. Solicitando información al usuario
Para solicitar información al usuario, podemos usar la instrucción: input(). La información

ingresada se guarda en formato cadena de texto.
Nota: Guardar la información ingresada por el usuario en una variable.
Ejemplo:
>>> n = input()
Observación: En el ejemplo vemos la sintaxis de cómo pedir información al usuario, y a la vez

guardarla en la variable n.
Entre los paréntesis de input() podemos agregar una cadena de texto, a modo que el usuario
entienda que se le está solicitando información.
Ejemplo:
>>> n = input("Ingrese un entero: ")
Ingrese un entero: _
Como toda la información que recolecta input() es tomada como cadena de texto4 , nosotros
podemos hacer que Python mantenga el tipo de dato ingresado, al usar la instrucción eval().
Ejemplo:
>>> n = eval(input("Ingrese un entero: "))
Ingrese un entero: _
Observación: eval() permite que cuando se ingrese el número entero, se mantenga como
información del tipo entero en Python.
4
En Python 2 la instrucción input() mantiene el tipo de información ingresada, y existe la instrucción
raw_input() que guarda todo como cadena de texto.

Capı́tulo 2
Ciclos, listas y funciones
25
BML | Ciclos For y While 26
2.1. Ciclos For y While
Ciclo While: este ciclo evalúa una condición e ingresa al ciclo mientras ésta sea verdadera.
Caso contrario, finaliza las iteraciones y continúa con el resto del programa.
Por ejemplo:
count = 0
while count < 5:
print(count, " es menor que 5")
count = count + 1
print(count, " no es menor que 5")
0 es menor que 5
1 es menor que 5
2 es menor que 5
3 es menor que 5
4 es menor que 5
5 no es menor que 5
Una caracterı́stica de los ciclos while es que la acción a repetirse puede hacerse desde 0
hasta un número indefinido de veces. Es posible que la cantidad máxima de iteraciones no
pueda conocerse una vez iniciada la ejecución del programa.
Ciclo For: este ciclo asigna a una variable contador cada uno de los datos incluidos en una
secuencia. A diferencia del ciclo while, no evalúa una condición, este ciclo finaliza cuando la
variable contador llega al final de la secuencia.
Por ejemplo:
for count in [0,1,2,3,4]:

print(count, " es menor que 5")
print(count, " no es menor que 5")
0 es menor que 5
1 es menor que 5
2 es menor que 5
3 es menor que 5
4 es menor que 5
4 no es menor que 5
Una caracterı́stica de los ciclos for es que la cantidad de iteraciones puede ir desde 0 hasta
un número determinado. Éste número puede conocerse durante la ejecución del programa y
antes de ingresar al ciclo. Es por esta razón que es posible resolver el problema utilizando una
secuencia de datos.

BML | Sentencias pass, break y continue, Cláusula else 27
Una secuencia en python es un tipo de dato que permite almacenar múltiples valores en
una misma variable. Esta caracterı́stica de las secuencias es que la hace posible iterar sobre las
mismas, recorriendo uno a uno sus elementos. Una secuencia puede estar vacı́a o tener un sólo
elemento.
Una secuencia con un solo elemento sigue siendo iterable, pero admite una sola iteración.
No ha de confundirse con una variable atómica que sólo toma un valor.
2.2. Función range
range([inicio], fin, [salto]): Esta función permite crear secuencias que contienen
progresiones aritméticas. Los argumentos deben ser enteros. La lista inicia exactamente en
“inicio” y termina antes de llegar a “fin”. La función range genera una secuencia de tipo lista
en Python 2 y en Python 3 es una clase del tipo range. En todo el curso lo consideraremos en
Python 3.
Se consideran las siguientes situaciones:
1. Si salto es omitido, asume el valor por defecto de 1.
2. Si el inicio es omitido, asume el valor por defecto 0.
3. Si el salto es negativo, entonces la lista mantendrá un crecimiento descendente.
4. Si se colocan dos de los tres argumentos, se asume que son inicio y fin.
Por ejemplo:
for count in range(10):

print(count,end=",") for count in range(0):
print(count,end=",")
0,1,2,3,4,5,6,7,8,9,
for count in range(0,-8,-1):
for count in range(1,11): print(count,end=",")
0,-1,-2,-3,-4,-5,-6,-7,
1,2,3,4,5,6,7,8,9,10,
for count in range(0,10,-1):
for count in range(0,30,5): print(count,end=",")
for count in range(10,2):
0,5,10,15,20,25, print(count,end=",")

2.3. Sentencias pass, break y continue, Cláusula else
pass: Esta sentencia hace nada. Se utiliza cuando una sentencia se requiere sintácticamente,
pero no funcionalmente.
Por ejemplo:
if x>=0:
pass
else:
x=-x
continue: Esta sentencia finaliza la iteración del ciclo en la que se encuentra y continúa
con la siguiente (si la hubiere).
Por ejemplo:
for num in range(2, 10):

if num % 2 == 0:
print("número par", num)
continue
print("número impar", num)
break: Esta sentencia finaliza abruptamente el ciclo en el que se encuentre. El flujo evita
toda instrucción asociada al ciclo roto.
Por ejemplo:
from random import randint

oculto = randint(10,100)
while True:
numero = int(input("\nadvina un número entre 10 y 100 -->"))
if numero == oculto:
print("¡Felicidades, adivinaste!")
break
print("sigue intentanto, mejor suerte a la próxima")
else: Las estructuras iterativas también pueden contener una cláusula else. Se ejecuta cuando
el ciclo termina al agotar la lista (for) o cuando la condición se evalúa falsa (while).
Por ejemplo: Generar los números primos menores de un dı́gito.
for n in range(2, 10):

for x in range(2, n):
if n % x == 0:

break
else: # el ciclo finalizó sin recurrir a break
print(n, ’es primo’)
2 es primo
3 es primo
5 es primo
7 es primo

BML | Listas 30
2.4. Listas
Un tipo de dato especial dentro de Pythones la lista, este tipo de dato puede almacenar
colecciones de datos de diversos tipos (incluyendo ellos mismos).
Lista: son variables que almacenan enteros (int), reales (float) y cadenas de texto (str),
internamente cada posición puede ser un tipo de datos distinto. También dentro de pueden
almacenar listas (list).
Ejemplo:

["cadena de texto", 15, 2.8, "otro dato", 25]
Las listas en Pythonson:
Heterogéneas: pueden estar conformadas por elementos de distintos tipo, incluidos otras
listas.
Mutables: sus elementos pueden modificarse.
Las listas pueden pensarse como una secuencia de datos ordenados por su posición dentro
de la lista; esto quiere decir que cada elemento dentro de la lista tiene una posición, estas
posiciones comienzan a enumerarse de izquierda a derecha comenzando desde cero y termina
una unidad menos a la cantidad de elementos que posea la lista (en programas como Matlab
u Octave la numeración comienza desde uno hasta el número total de elementos que posea la
lista).
A la posición de cada elemento se les llamará ı́ndice, siendo el ı́ndice cero (0) el pertene-
ciente al primer elemento.
Ejemplos:

>>> mi_lista[0]
"cadena de texto"
>>> mi_lista[3]
"otro dato"
>>> mi_lista[4]
25
En los ejemplos anteriores, podemos observar que 4 es el ı́ndice del último elemento en la
lista; es ası́, ya que la lista tiene 5 elementos, y la numeración en este caso seria desde 0 hasta
4 (desde cero hasta una unidad menos a la cantidad de elementos que posea la lista).
También, podemos extraer una parte de la lista usando los ı́ndices. Para extraer una parte
de la lista, es necesario especificar el ı́ndice desde el cuál deseamos iniciar la extracción, hasta

BML | Listas 31
una unidad más del ı́ndice que queremos finalizar la extracción. Veamos a continuación dos
ejemplos, el primero extraemos desde el segundo elemento hasta el cuarto elemento, y en el
segundo desde el tercer elemento hasta el último (recuerde el último elemento tiene ı́ndice 4).
Ejemplos:
>>> mi_lista[1:4]
[15, 2.8, "otro dato"]
>>> mi_lista[2:5]
[2.8, "otro dato", 25]
Además, a través del ı́ndice, podemos cambiar los elementos de una lista en el lugar que
especifica dicho ı́ndice.
Ejemplos:
>>> mi_lista[0]
"cadena de texto"
>>> mi_lista[0] = 2 #Cambiamos "cadena de texto" por 2.
>>> mi_lista[0]
2
>>> mi_lista[2]
2.8
>>> mi_lista[2] = "¡Hola mundo!" #Cambiamos 2.8 por "¡Hola mundo!".
>>> mi_lista[2]
"¡Hola mundo!"
Como vemos en los ejemplos anteriores, podemos incluso cambiar elementos por otros to-
talmente diferentes, incluso si son de diferentes tipos (en este caso, cambiamos una cadena de
texto por un entero y un real por una cadena de texto).
Por último, podemos agregar nuevos elementos a una lista, lo que significa, hacer más grande
la lista (que tenga más elementos), esto lo podemos hacer con la función append(), la sintaxis
es: lista.append(elemento).
Ejemplo:
>>> mi_lista
[2, 15, "¡Hola mundo!", "otro dato", 25]
>>> mi_lista.append("Nuevo Dato")
>>> mi_lista
[2, 15, "¡Hola mundo!", "otro dato", 25, "Nuevo Dato"]
Observación: append() agrega el nuevo elemento al final de la lista, además, podemos

agregar elementos de cualquier tipo, no solo cadenas de texto.

BML | Listas 32
len(): esta función devuelve la longitud de la lista (su cantidad de elementos). La sintaxis
para usar esta función es: len(lista).
Ejemplos:
>>> len([2, 1, "hola"]) #La lista tiene 3 elementos (2, 1 y "hola").

3
>>> len(mi_lista)
5
Concatenar listas: es la acción de unir o enlazar listas. Las listas se pueden concatenar
con el sı́mbolo de la suma (+). La sintaxis es: lista_1 + lista_2.
Ejemplo:
>>> lista1 = [1,2,3]

>>> lista2 = ["hola", "saludos"]
>>> lista1 + lista2 #Concatenamos la lista1 con la lista2.
[1, 2, 3, "hola", "saludos"]
Observación:al concatenar dos listas, el resultado es una nueva lista que contiene en las
primeras posiciones los elementos de la lista a la izquierda del sı́mbolo +, y luego van los
elementos de la segunda lista a la derecha del sı́mbolo +.
También, podemos usar la concatenación para agregar un elemento de cualquier tipo a una
lista. La sintaxis es la siguiente: lista += [elemento_nuevo] o lista = lista + [elemento_nuevo].
Nota:el operador suma (+) necesita que los dos operandos sean listas.
Ejemplo:
>>> lista1 = [1,2,3]

>>> lista1 += ["Nuevo dato"]
>>> lista1
[1, 2, 3, "Nuevo dato"]
Observación:el nuevo elemento a agregar debe estar siempre entre corchetes, esto es ası́,
ya que + necesita dos elementos del tipo lista. También, notemos que el resultado es el mismo
si usáramos append() en la lista1.

BML | Definiendo funciones 33
2.5. Funciones en Python
Una función es una agrupación de expresiones y sentencias (algoritmos) que realizan deter-
minadas acciones, pero que éstas, solo se ejecutan cuando son llamadas. Es decir, si se coloca
un algoritmo dentro de una función y luego éste se corre, el algoritmo no será ejecutado, dado
que no se ha hecho una referencia a la función que lo contiene.
El uso de funciones es un componente muy importante del paradigma de la programación
llamada estructurada 1 , y tiene varias ventajas:
Modularización: permite segmentar un programa complejo en una serie de partes o

módulos más simples, facilitando ası́ la programación y el depurado.
Reutilización: permite reutilizar una misma función en distintos programas.
Python dispone de una serie de funciones integradas al lenguaje (ejemplos: range() y

len()), y también permite crear funciones definidas por el usuario para ser usadas en su propios
programas. En esta sección, nos ocuparemos de cómo crear tus propias funciones.
2.5.1. Definiendo funciones
En Python, la definición de funciones se realiza mediante la instrucción def más un nombre

de función descriptivo (se recomienda que el nombre de la función haga alusión a la acción
que realiza) seguido de paréntesis de apertura y cierre. Como toda estructura de control en
Python, la definición de la función finaliza con dos puntos (:) y el algoritmo que la compone
irá indentado:
La sintaxis para crear una función en Python es:
def mi_funcion():
instrucciones
Donde:
mi_funcion: es el nombre de la función.
instrucciones: es el bloque de sentencias en lenguaje Python que realizar cierta ope-

ración dada.
Una vez creada la función, podemos llamarla de la siguiente manera: mi_funcion()
1
La programación estructurada es un paradigma de programación basado en utilizar funciones o subpro-
gramas, y únicamente tres estructuras de control: secuencia (sentencias), selección o condicional (if) e
iteración (ciclo o bucle)

BML | Parámetros 34
Ejemplo:
def texto():
print("¡Hola mundo!")
>>> texto()
¡Hola mundo!
2.5.2. Parámetros
Un parámetro es un valor que la función espera recibir cuando sea llamada, a fin de
ejecutar acciones en base al mismo. Una función puede esperar uno o más parámetros (que irán
separados por una coma, entre los paréntesis que van seguidos después del nombre de la
función) o ninguno2 .
La sintaxis para crear una función con parámetros en Python es:
def mi_funcion(lista_de_parametros):
instrucciones
Donde:
mi_funcion: es el nombre de la función.
lista_de_parametros: es la lista de parámetros que puede recibir una función.
instrucciones: es el bloque de sentencias en lenguaje Python que realizar cierta ope-

ración dada.
La manera para llamar una función con parámetros es: mi_funcion(lista_de_parametros).

Nota: Al definir una función, los valores que se recibe se denominan parámetros, pero
durante la llamada los valores que se envı́an se denominan argumentos.
Ejemplo:
def mi_funcion(a,b):
print(a-b) #Esta función resta al primer parámetro, el segundo parámetro.
>>> mi_funcion(5,3)
2
2
Como vimos en la sección anterior, para crear una función no es necesario que tenga parámetros.

BML | Parámetros por defecto u omisión 35
Observación: La función del ejemplo anterior tiene dos argumentos, y estos deben ser del
tipo entero o real, entonces, si esta misma función es llamada con parámetros de otro tipo para
los cuales el operador − no esté definido, generará un error en su ejecución (lo mismo sucederá,
si se mezclan diferentes tipos de variable, por ejemplo int con str).
Además, si el operador soportara otros tipos de variable, el resultado ya no serı́a lo que
esperamos (la resta de dos números), por esto será necesario validar cada una de las variables,
antes de la ejecución de las instrucciones que definirán la finalidad de la función.
Parámetros por defecto u omisión
Si una función fue creada con parámetros y es llamada (o invocada) sin argumentos, generará
un error de ejecución. Para solucionar este problema, podemos crear los parámetros con ciertos
valores para que la función se ejecute con los valores establecidos en caso que sea llamada sin
argumentos.
La sintaxis para los parámetros serı́a:
mi_funcion(a_1 = valor_1, a_2 = valor_2, ... , a_n = valor_n):
Ejemplo:
def mi_funcion(a = 1,b = 3):

print(a-b)
>>> mi_funcion(5,3)
2
>>> mi_funcion()
-2
>>> mi_funcion(6)
3
Como podemos observar, al parámetro a se le ha asignado 1 y a b, 2, en caso que la función

sea llamada sin argumentos, por esta razón cuándo ejecutamos mi_funcion(), el resultado3 en
pantalla es −2.
Además, note se que en el caso de la instrucción mi_funcion(6), la función toma como
valor para a el número 6 (en el caso de a ver más parámetros y menos argumentos, Python
irá asignando en orden de izquierda a derecha, argumento con parámetro).
Veamos otro ejemplo donde la función es definida con parámetros de diferentes tipos.
3
a − b = 1 − 3 = −2

BML | None, return y pass 36
Ejemplo:
def funcion_2(numero,texto):
print(2**numero)
print("El texto ingresado es: ", texto)
>>> funcion_2(3,"Hola")
8
El texto ingresado es: Hola
En el ejemplo anterior, notese que el primer argumento debe ser un número, y el segundo
una cadena de texto. Ası́, si ingresáramos argumentos de otro tipo, por ejemplo, escribiéramos
la instrucción funcion_2("Hola",3), esto causarı́a un error de ejecución ya que 2 no se puede
elevar a una cadena de texto, por lo tanto, el orden con que creamos los parámetros y el tipo
que variable que le “asociemos” en las instrucciones de la función, deben ser respetados por los
argumentos a la hora de llamar a la función.
Nota: Tenga en cuenta que al momento de llamar una función que fue definida con paráme-
tros, los siguientes casos pueden generar un error de ejecución:
1. Si tiene más argumentos que parámetros.
2. Si el número de argumentos es igual al de parámetros, pero no se colocan correctamente

(en el orden que fueron creados).
2.5.3. Argumentos por nombre
Una forma de evadir el segundo problema de ejecución, presentado al final del apartado
anterior, es llamar a la función utilizando el nombre de cada parámetro y especificando su
valor.
Ejemplo:
def funcion_2(numero,texto):
print(2**numero)
print("El texto ingresado es: ", texto)
>>> funcion_2(texto = "Hola", numero = 3)

8
El texto ingresado es: Hola
Observación: El inconveniente de esta forma de llamar a una función, es que necesitamos

saber cuál es el nombre de cada parámetro de la función.

2.5.4. None, return y pass
None: Es el único valor del tipo NoneType. None se usa con frecuencia para representar la
ausencia de un valor, como cuando los argumentos predeterminados no se pasan a una función.
Como se mencionado anteriormente, si no deseamos colocar valores por defecto a los paráme-
tros de una función, podemos usar None, y mostrar un mensaje en pantalla, indicando que no
se colocaron argumentos.
Ejemplo:
def mi_funcion(a = None,b = None):

if a == None or b == None:
print("Error, se necesitan dos números como argumentos para
ejecutar la función")
else:
print(a-b)
>>> mi_funcion()
Error, se necesitan dos números como argumentos para ejecutar la función
>>> mi_funcion(6)
Error, se necesitan dos números como argumentos para ejecutar la función
>>> mi_funcion(5,3)
2
return: Esta instrucción “devuelve” el resultado o valor de la expresión que le sigue a

return en la misma lı́nea de código. return es usado en funciones para finalizar, y devolver
un valor o expresión en concreto, las instrucciones posteriores a return no se ejecutan. Si la
sentencia return no tiene ninguna expresión, por defecto devolverá None.
Nota: return no se puede usar fuera de una función.
Ejemplo:

else:
return(a-b)
>>> mi_funcion(5,3)
>>> print(mi_funcion(5,3))
2
>>> x = mi_funcion(5,3)
>>> print(x)
2

Observación: Como podemos observar en el ejemplo anterior, solo usar la instrucción:

mi_funcion(5,3), esta no muestra nada en pantalla, sin embargo, si la colocamos ahora dentro
de un print(), podremos ver el valor que está devolviendo la función.
La ventaja más grande de usar return, es la de poder guardar los resultados de las funciones
en variables y ası́ poder reutilizar estos valores en otros programas o funciones (como en el
ejemplo anterior, podemos observar que se le asigna a la variable x, el valor que devuelve la
función, con la instrucción x = mi_funcion(5,3)).
Una caracterı́stica muy importante de return, es la posibilidad de devolver valores múltiples
separados por comas.
Nota: En el caso de devolver múltiples valores una función, return las devuelve en un
tipo muy especial de elemento, conocido como tuplas, más adelante estudiaremos este tipo de
elemento.
Ejemplo:

else:
return(a-b,a,b,[a,b])
>>> print(mi_funcion(5,3))
(2, 5, 3, [5, 3])
pass: es una operación nula, cuando se ejecuta, no sucede nada. Es útil como marcador de
posición cuando se requiere una declaración, pero no es necesario ejecutar ningún código. A
veces en la elaboración de programas, tenemos claro desde un inicio cuántas funciones llevará,
pero no ası́ el código de ellas, ası́ podemos usar pass para declarar las funciones y posteriormente
crear sus algoritmos.
Ejemplo:
def funcion_3():
pass #Esta función no hace nada.
>>> funcion_3()

BML | Alcance y variables globales 39
2.6. Alcance y variables globales
Las variables por defecto son locales en Python, esto quiere decir que las variables definidas
dentro de una función no podrán ser utilizadas fuera de ellas. Para entender mejor lo descrito
antes, veamos un ejemplo.
Ejemplo:
def suma(x,y):
a=1
return x+y
>>> print(a)
NameError: name ’a’ is not defined
Notemos que en el ejemplo anterior dentro de la función nos encontramos a la variable a,

la cual tiene asignado el valor de 1. Podrı́amos pensar que luego de haber creado la función
podemos reutilizar la variable a, pero no es ası́, ya que al intentar imprimir en pantalla la
variable a, Python nos dice que no está definida.
Ahora, veamos un caso diferente, donde fuera de la función se define una variable y se intenta
usar dentro de la función.
Ejemplo:
b=2
def suma(x,y):
print(b)
return x+y
>>> print(suma(2,3))
2
5
En este caso, sı́, es posible reutilizar la variable b dentro de la función (ya se muestra el valor
de b en pantalla). El carácter local o global de la variable dependerá desde qué estructura veamos
la variable, ya que si tenemos un programa principal, y definimos variables (pero no dentro de
una función u otra estructura que contenga el programa principal), entonces tendremos una
variable global. La razón de porqué llamarla global, es porque se podrán usar en todas las
estructuras que el programa principal contenga. Por otro lado una variable local, solo es
posible usarla en la estructura donde fue definida y no fuera de ella.
Observación: La variable b recibe el nombre de variable global, porque podemos usarla
dentro de la función, por otro lado a la variable a se le llamará variable local, porque no es
posible usarla fuera de la función.

BML | Errores y excepciones 40
A pesar del carácter local de las variables definidas en una función, podemos cambiar el
carácter local de la variable con global. La sintaxis para global seria: global variable,
ahora veamos un ejemplo de esto.
Ejemplo:
def suma(x,y):
global a
a=1
return x+y
>>> print(a)
1
Observación: Como vemos la variable a ha dejado de ser local, ya que ahora ya se puede
usar fuera de la función. En este caso la instrucción que transforma la variable a a global es
global a.
2.7. Errores y excepciones
En la medida que interactuamos con Python, nos podemos encontrar con algunos errores,
estos los podemos clasificar como errores de sintaxis y errores de excepción. El primer
tipo, es quizás el más conocido, ya que este aparece en pantalla cuando escribimos algo que no
está dentro del lenguaje de Python.
Ejemplo:
>>> if x
SyntaxError: invalid syntax
Observación: Como vemos no se ha escrito correctamente la sentencia del condicional, ni

las instrucciones que deben ejecutarse de cumplirse if, por ende no lo entiende Python, y por
lo tanto, genera un error de sintaxis.
El segundo tipo de errores que podemos encontrar en Python son los errores de excepción,
este tipo son el resultado de un error lógico o de operación no válida, en otras palabras está
bien escrito en el lenguaje Python, pero no tiene sentido. Veamos algunos ejemplos:
Ejemplos:
>>> 1/0
ZeroDivisionError: division by zero
>>> "2"+[2]
TypeError: can only concatenate str (not "list") to str

BML | Errores y excepciones 41
Nota: Estos tipos de errores hacen que se detenga la ejecución del programa.
Como vemos, los errores producidos son errores donde no está definida la operación, sin
embargo están correctamente bien definida en el lenguaje de Python.
Los errores de excepción podemos de alguna manera controlarlos, y hacer que nuestro pro-
grama no pare su ejecución, esto lo logramos con try y except. La partı́cula try nos permite
buscar errores en un bloque de código. Por otro lado except, te permite manejar los erro-
res encontrados, especificando en pantalla que ha sucedido un error, pero permitiendo que el
programa continué su ejecución con normalidad.
Ejemplo:
try:
1/0
except:
print("No se puede dividir por cero")
>>> No se puede dividir por cero
En los primeros ejemplos vimos como Python ya clasifica estos tipos4 de errores, por ejemplo
1/0, es un error del tipo ZeroDivisionError, entonces nosotros podemos ir buscando un tipo
de error en especı́fico en nuestros códigos por medio de except.
Ejemplo:
try:
1/0
except ZeroDivisionError:
>>> No se puede dividir por cero
Observación: En el ejemplo podemos ver que estamos buscando el error de dividir por
cero, sin embargo es probable que nuestros códigos presenten otros tipos de error, por ello se
sugiere agregar otro except, pero sin especificar el tipo de error.
Ejemplo:
try:
"2"+[2]
except ZeroDivisionError:
except:
print("Hay otro error")
>>> Hay otro error
4
Una lista completa de los diferentes tipos de excepciones que podemos usar en Python 3, lo podemos en-
contrar en el enlace siguiente: https://docs.python.org/3/library/exceptions.html#bltin-exceptions

BML | Documentación de funciones 42
Observación: Como vemos podemos tener más de un except. Sin embargo no puede existir
más de un try sin un except.
Normalmente try y except son utilizados para validar el funcionamiento de una función.
Veamos un ejemplo de esto:
Ejemplo:
def suma(x,y):
try:
r = x+y
return r
except:
print("Operación incorrecta.")
5
2.8. Documentación de funciones
La documentación de una función es muy importante, ya que con esto dejamos claro qué
valores espera recibir la función, ası́ como el tipo que deben ser y qué hace la función con ellos.
Además de especificar qué valor o valores devolverá, si es que devuelve algo la función. También,
se colocan ejemplos de implementación de la función creada, y datos del creador si es necesario.
Todo esto con el objetivo que el usuario sepa cómo trabajar con la función creada.
Ejemplo:
def suma(x,y):
"""
Esta función suma dos números reales
Valores de entrada: x, y (deben ser números reales)
Valores de salida: r (este es el resultado de sumar x con y)
Ejemplo:
>>> suma(2,3)
5
Creador: Luisantos Bonilla (09/05/2020)

"""
r = x+ y
return r
7

BML | Documentación de funciones 43
Nota: La documentación de una función debe colocarse siempre entre las triples comillas,
o sea la sintaxis es """texto""".
La documentación nunca se despliega en pantalla mientras se ejecuta la función, ya que es
un recurso de carácter informativo, ası́ para que podamos ver dicha documentación es necesario
usar help.
Ejemplo:
def suma(x,y):
"""
Ejemplo:
>>> suma(2,3)
5

"""
r = x+ y
return r
>>> help(suma)
Help on function suma in module __main__:
suma(x, y)
Ejemplo:
>>> suma(2,3)
5
Observación: Notese que para usar help, solo es necesario colocar entre paréntesis el
nombre de la función (ejemplo: help(suma)).

BML | Ejercicios - 1 44
2.9. Ejercicios - 1
1. Escriba un programa que genere y guarde los primeros n números de Fibonacci en una
lista.
2. Dadas dos listas, hacer un programa que imprima los elementos de la primera lista en
orden normal (respecto a su ı́ndice), y la segunda en orden inverso, como por ejemplo:
>>> lista = [1, 24, 5]

1, 24, 5
>>> lista2 = [2, 4, 45, 6, 7, 89]
89, 7, 6, 45, 4, 2
3. Escribir un programa que sume dos listas, elemento por elemento (las listas solo deben
tener elementos enteros o reales). Además, considere el hecho que pueden ser listas de
diferentes tamaños.
4. Considere el polinomio P (x) = x3 − x + 1 y la lista [3, 6, 8, 9]. Escribir un programa

que evalúe cada elemento de la lista anterior en P (x) y cada resultado se guarde en una
nueva lista (no olvide mostrar la nueva lista en pantalla).
5. Escribe un programa que concatene dos listas, pero sin usar +.
6. Escribir un programa que tome dos listas y las concatene, pero que el resultado sea una
lista con elementos alternados de las dos listas dadas, por ejemplo:
[1,2,3], ["a","b"] -> [1, "a", 2, "b", 3]
7. Escribe un programa que dado un número entero n positivo, genere en pantalla el triángulo
de Pascal. Por ejemplo, si n = 5, el resultado que se espera es:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

BML | Ejercicios - 2 45
2.10. Ejercicios - 2
Indicaciones: Crea un archivo .py para cada ejercicio. Además, valida los parámetros de cada
función teniendo en cuenta el tipo de valor a usar. También, en el archivo debes implementar
los ejemplos necesarios para corroborar el buen funcionamiento de la función.
1. Cree una función que devuelva el área de un triángulo dadas las coordenadas de sus
vértices. Nota: El área de un triángulo se puede calcular con la siguiente formula:
1
A = |x2 y3 − x3 y2 − x1 y3 + x3 y1 + x1 y2 − x2 y1 |
2
Donde (x1 , y1 ), (x2 , y2 ) y (x3 , y3 ) son los vértices del triángulo.
2. Cree un función que dada una lista de números devuelva la moda de la lista de números
presentado.
3. Escribir una función que dado un número entero, devuelva otro con sus dı́gitos invertidos.
4. Escriba una función que devuelva el elemento más grande y el más pequeño en una lista..
5. Escribir una función que reciba un número entero y devuelva una cadena con una repre-
sentación como esta: 1569 = 1*10^3+5*10^2+6*10^1+9*10^0
6. Escribir una función que resuelva un sistema de ecuaciones lineales de dos incógnitas.
7. Diseña una función que reciba una lista de cadenas y devuelva el prefijo común más largo.
Por ejemplo, la cadena "pol" es el prefijo común más largo de esta lista:
["poliedro", "policı́a", "polı́fona", "polinizar", "polaridad", "polı́tica"]
8. Escribir una función que calcule la cantidad de dı́as que han transcurrido en un año hasta
una fecha dada.
9. Diseña una función que devuelva el valor absoluto de la máxima diferencia entre cualquier
par de elementos de una lista. Por ejemplo, el valor devuelto para la lista [1, 10, 2, 6, 8, 2]
es 9, pues es la diferencia entre el valor 10 y el valor 1.
10. Escriba una función que rote una lista (sin hacer copias de la lista dada) n espacios a la
izquierda cada elemento.
11. Escribir una función que tome una ecuación de primer grado como texto, y que calcule la
solución.

Capı́tulo 3
Módulos
46
BML | From e Import 47
3.1. Módulos en Python
Un módulo es una agrupación de funciones, constantes y clases1 en un solo script .py, en

otras palabras, un módulo es un programa donde se encuentran definidas funciones, constantes
y clases.
Un ejemplo de módulo es el script hermite.py que podemos encontrar en la biblioteca o
librerı́a llamada Numpy2 , el módulo hermite tiene muchas funciones definidas para trabajar
con polinomios, una de ellas poly2herm que convierte un polinomio a una serie de Hermite.
Como se puede intuir del ejemplo anterior un módulo no es otra cosa que un archivo con
extensión .py.
3.1.1. Usando Módulos
Import
Para usar un módulo en otro programa, debe usarse la sentencia import, al inicio de nuestro
programa o antes de usar alguna función del módulo. La sintaxis es: import nombre_del_modulo
Una vez importado el módulo, la sintaxis para usar una función del módulo debe ser:
nombre_del_modulo.nombre_de_la_funcion(argumentos)
Lo mismo aplica si queremos usar las constantes del módulo, solo debemos cambiar el nombre
de la función por el nombre de la constante.
Ejemplos:
import numpy
a=4 a=4
print(a) print(a)
import numpy
print(numpy.cos(1)) print(numpy.cos(1))
>>> >>>
4 4
0.5403023058681398 0.5403023058681398
Observación: Notemos que para usar las funciones que las librerı́as3 contienen, se usa la
misma sintaxis que para los módulos, por está razón los trataremos como módulos especiales.
1
Las clases son estructuras más complejas que las funciones en Python. las clases serán estudiadas en el
curso de Programación II.
2
Al inicio del curso se abusó del término módulo especial, sin embargo, debe quedar claro que Numpy es una
librerı́a. Las librerı́as serán tratadas como módulo, ya que la sintaxis para usar sus funciones es similar.
3
Las librerı́as son un conjunto de módulos que se interrelacionan entre sı́.

BML | Creación de módulos 48
From e Import
Otra forma de usar import es usándolo junto a from, esto permite usar las funciones y
constantes de manera usual, solo usando sus nombres, sin hacer referencia al módulo al que
pertenece. La sintaxis es: from nombre_del_modulo import *
El asterisco que aparece en la instrucción import, hace que todas las funciones y constantes
del módulo estén disponibles para el programa.
Ejemplos:
from numpy import *

a=4 a=4
print(a) print(a)
from numpy import *
print(cos(1)) print(cos(1))
>>> >>>
4 4
0.5403023058681398 0.5403023058681398
A veces solo estamos interesados en usar ciertas funciones de un módulo, para esto solo
debemos cambiar el asterisco por el nombre de la función que necesitamos. La sintaxis es:
from nombre_del_modulo import nombre_de_la_funcion
Nota: La instrucción anterior solo hará que el programa reconozca la función que hayamos
especificado, ası́ será imposible usar otra función distinta a las que hayamos importado del
módulo.
Ejemplos:
from numpy import cos

a=4 a=4
print(a) print(a)
from numpy import cos
print(cos(1)) print(cos(1))
>>> >>>
4 4
0.5403023058681398 0.5403023058681398
Observación: En este ejemplo será imposible usar otra función del módulo especial numpy,
porque se especificó que la función cos sea la única que se importe, si quisiéramos otra función
deberı́amos agregarla después de cos, separándolos por comas, por ejemplo import cos, sin,
ası́ tendremos a disposición la función cos y sin.

BML | Usando As 49
3.2. Creación de módulos
A lo largo del curso hemos estado creando módulos inconscientemente (de alguna manera
claro), ahora para crear un módulo estrictamente debemos crear un archivo con extensión .py,
y dicho archivo debe contener solo funciones y constates (si fuese necesario). Nuestros módulos
no deben contener pruebas de las funciones, porque serán cargadas por defecto a la hora de
importar el módulo.
Ejemplo: Considere el módulo llamado aritmética.py, que contenga la siguientes funciones:
def sumar(x,y):
return x+y
def restar(x,y):
return x-y
Observación: Este archivo que solo contiene dos funciones es un módulo con nombre
aritmética.
Una pregunta valida serı́a: ¿cómo puedo hacer pruebas para saber si las funciones del módulo
están bien hechas? Para ello debemos usar la siguiente instrucción: if __name__==’__main__’:
al final del archivo (módulo).
Ejemplo: Retomemos el módulo aritmética.
def sumar(x,y):
return x+y
def restar(x,y):
return x-y
if __name__==’__main__’:
print("Ejemplos:")
print(sumar(3,4))
print(resta(7,3))
Observación: La instrucción if __name__==’__main__’:, permite que cuando se importe

el módulo las pruebas no se ejecuten, porque literalmente pregunta si el archivo que se está
ejecutando es el principal. En el caso que se esté importando el módulo esta instrucción es
falsa, porque el nombre del archivo principal es otro, no es el del módulo, ya que este último se
está usando por otro archivo.
Agregando if __name__==’__main__’: a los módulos, permite que el módulo se comporte
como un programa (cuando se desee actualizar o corregir algún error) y posteriormente como
un módulo cuando se importe.

BML | Paquetes y módulos 50
3.2.1. Usando As
A veces los nombres que colocamos a nuestro módulos son muy largos, y si estamos usando
solamente import para impórtalos, resultarı́a un poco incómodo de escribir siempre el nombre
del módulo cuando usamos sus funciones. Para una mayor comodidad, podemos usar la instruc-
ción as, esta instrucción nos permite renombrar el nombre de los módulos en nuestro programa,
para un mejor manejo de la escritura del programa donde estamos usándolos.
Ejemplo:
import numpy as npy

a=4
print(a)
print(npy.cos(1))
>>>
4
0.5403023058681398
Paquetes y módulos
Un paquete es una carpeta que contiene módulos, y posiblemente otros paquetes y un archivo
__init__.py4 . En la siguiente imagen mostramos la relación entre paquete y módulo:
Para poder usar un paquete en nuestros programas, debemos usar las sentencias from y
import de la siguiente manera:
from nombre_del_paquete import nombre_del_modulo
Ejemplo: Consideremos que el módulo aritmética.py está en un paquete llamado matemáti-

ca, ası́ consideré el siguiente programa donde importamos el módulo aritmética del paquete
matemática.
4
El archivo __init__.py es lo que permite que se considere una carpeta como paquete o no, ya que en un
paquete, dicho archivo siempre está (puede incluso ser un archivo vacı́o).

BML | Paquetes y módulos 51
from matemática import aritmética

a=4
print(a)
print(aritmética.sumar(1,2))
>>>
4
3
Observación: Notemos que el módulo es llamado por la instrucción import, en ese caso
será necesario escribir el nombre del módulo, seguido de un punto y finalizando con el nombre
de la función que deseamos usar.

BML | Ejercicios 52
3.3. Ejercicios
Indicaciones: En cada uno de los siguiente problema debe crearse un programa modular5
(que funcione como módulo y programa), que facilite la creación de un segundo programa (este
no debe ser un módulo) importando el programa modular creado previamente.
1. Un programa que desarrolle (x + y)n , donde el único parámetro es n.
2. Escribir un programa interactivo, que le permita al usuario convertir una temperatura de

grados Fahrenheit a grado Celsius y viceversa.
3. Escribir un programa que devuelva la suma de los múltiplos de 3 y 5 que están entre 0 y
n (parámetro).
4. Escribir un programa que imprima en pantalla los números primos entre 1 y n (parámetro).
5. Escribir un programa que verifique la velocidad de los conductores. Dada una velocidad
(en kilómetros por hora) se verifique y aplique lo siguiente:
Si la velocidad es a lo sumo 60 km/h, imprimir en pantalla “ok”.

Si la velocidad es mayor a 60, por cada 5 km por encima del lı́mite de velocidad
(60), se le asignará al conductor un punto de penalización e imprimir el número
total de puntos de penalización. Por ejemplo, si la velocidad es 80, deberı́a imprimir
en pantalla: “Puntos de penalización: 4”.
Si el conductor obtiene más de 12 puntos, la función deberı́a imprimir: “Licencia
suspendida”.
5
Este módulo debe contener todas las funciones auxiliares que se requieran para la creación del programa o
programas que se solicitan en cada literal.

Capı́tulo 4
Secuencias en Python
53
BML | Métodos 54
4.1. Tuplas y listas
Ya hemos estudiado al inicio del curso las listas, en este apartado no solo retomamos el
estudio de las listas, sino también conoceremos un tipo de dato de Python muy parecido a las
listas, las cuales llamaremos tuplas.
4.1.1. Tuplas
Tuplas: Las tuplas son secuencias al igual que las listas, con la diferencia que son inmutables
una vez creadas. Significa que una vez hechas, ya no se podrán modificar de ninguna manera.
La sintaxis de las tuplas es: nombre_tupla =(elementos).
Ejemplo:
>>> mi_tupla = (1,2,"hola",[1,(2,3)],(5))
Observación: Al igual que las listas, las tuplas pueden contener una combinación de los
diferentes tipos de datos, incluso puede contener otra tupla como elementos.
El tipo de datos para las tuplas es tuple, además por ser una secuencia, sus elementos están
indexados, y su numeración es de cero hasta una unidad menos a la cantidad de elementos que
contenga la tupla. Como podemos observar las tuplas son básicamente listas que no podemos
modificar.
Ejemplos:
>>> mi_tupla[1]
2
>>> mi_tupla[0]
1
>>> mi_tupla[3]
[1, (2, 3)]
>>> len(mi_tupla)
5
Observación: También podemos usar len() en las tuplas para saber cuántos elementos
posee. No debe olvidarse que al igual que las listas, el ı́ndice del primer elemento es 0 y del
último elemento es len(mi_tupla)-1.
4.1.2. Métodos
De manera informal los métodos1 son funciones que son exclusivamente para tipos de datos
que pueden contener otros elementos2 dentro de Python. En este curso solo hablaremos de
1
La definición correcta será presentada en el curso de programación II.
2
Estos elementos pueden ser de los tipos que conocemos, por ejemplo int, float o list.

BML | Métodos para cadenas de texto. 55
métodos para cadenas de texto, listas y tuplas.

La sintaxis para usar métodos es: nombre_dato.nombre_metodo(argumentos). A continua-
ción presentamos los métodos más usados para cadenas de texto, listas y tuplas.
Métodos para cadenas de texto.
1. capitalize (): Devuelve una copia de la cadena con el primer carácter en mayúscula.
Ejemplo:
>>> mi_texto="hola mundo"

>>> mi_texto.capitalize()
"Hola mundo"
2. count(elemento,inicio,final): Devuelve cuántas veces aparece elemento en la cadena

desde el ı́ndice inicio hasta el ı́ndice final.
Nota: Los argumentos inicio y final son opcionales y se interpretan según la notación
de corte, es decir, si solo se coloca uno, se entenderá que se busca desde el ı́ndice cero
hasta el que se le ha escrito.
Ejemplos:
>>> mi_texto="hola mundo" >>> mi_texto.count("o",2)

>>> mi_texto.count("o",2,4) 1
0 >>> mi_texto.count("o")
2
Observación: En el último ejemplo, ya que no se indica el intervalo para buscar dentro

de la lista, simplemente busca en toda la cadena de texto.
3. find(elemento,inicio,final): Devuelve el menor ı́ndice de la cadena para el que

elemento se encuentre, de tal modo que elemento quede contenido en el rango desde
inicio hasta antes de final.
Nota: Los argumentos inicio y final son opcionales y se interpretan exactamente igual
que en el caso de verb. Devuelve −1 si no se halla elemento.
Ejemplos:
>>> mi_texto="hola mundo" >>> mi_texto.find("o")

>>> mi_texto.find("o",1,3) 1
1 >>> mi_texto.find("w")
-1

BML | Métodos para las listas. 56
4. isalnum(): Devuelve verdadero si todos los caracteres de la cadena son alfanuméricos.

En caso contrario, devuelve falso.
Ejemplos:
>>> mi_texto="hola mundo" >>> texto3 = "HolaMundo2"

>>> mi_texto.isalnum() >>> texto3.isalnum()
False True
>>> texto2 = "HolaMundo" >>> texto4 = "HolaMundo%"
>>> texto2.isalnum() >>> texto4.isalnum()
True False
5. isalpha(): Devuelve verdadero si todos los caracteres de la cadena son alfabéticos. En

caso contrario, devuelve falso.
Ejemplos:
>>> mi_texto="hola mundo" >>> texto3 = "HolaMundo2"

>>> mi_texto.isalpha() >>> texto3.isalpha()
False False
>>> texto2 = "HolaMundo" >>> texto4 = "HolaMundo%"
>>> texto2.isalpha() >>> texto4.isalpha()
True False
6. isdigit(): Devuelve verdadero si todos los caracteres de la cadena son dı́gitos. En caso
contrario, devuelve falso.
Ejemplos:
>>> texto="hola mundo" >>> texto3="HolaMundo2" >>> texto5 = "123"

>>> texto.isdigit() >>> texto3.isdigit() >>> texto5.isdigit()
False False True
>>> texto2="HolaMundo" >>> texto4="HolaMundo%"
>>> texto2.isdigit() >>> texto4.isdigit()
False False
Una lista con el resto de métodos para cadenas de texto, lo podrán encontrar en el siguiente
enlace: https://docs.python.org/2.5/lib/string-methods.html
Métodos para las listas.
1. append(elemento): Este método agrega elemento al final de una lista.

Ejemplo:
>>> lista = [1,2,3]

>>> lista.append("xD")
>>> print(lista)
[1, 2, 3, "xD"]
2. count(elemento): Devuelve el número de veces que elemento aparece en la lista.

Ejemplo:
>>> lista = [1,2,3,4,5,1,2,1]

>>> lista.count(1)
3
3. extend(argumento_lista): Este método extiende una lista agregando uno a uno los
elementos de argumento_lista al final.
Ejemplos:
>>> lista = [1,2,3] >>> lista = [1,2,3]

>>> lista.extend(["x","D"]) >>> lista.extend(range(2))
>>> print(lista) >>> print(lista)
[1, 2, 3, "x", "D"] [1, 2, 3, 0, 1]
4. index(elemento,inicio,final): Este método recibe un elemento como argumento y

devuelve el ı́ndice de su primera aparición en la lista, de tal modo que elemento esté
contenido en el rango desde inicio hasta final.
Nota: Los argumentos inicio y final son opcionales y si solo se coloca uno, se entenderá
que se busca en ese ı́ndice el elemento. Si el elemento no se encuentra en la lista dará
ValueError.
Ejemplos:
>>> lista = [1,2,3,4,5] >>> lista = [1,2,3,4,5]

>>> lista.index(2,1,4) >>> lista.index(2)
1 1
5. insert(i,elemento): Este método inserta el elemento en la lista, en el ı́ndice i.

Ejemplo:
>>> lista = [1,2,3,4,5]

>>> lista.insert(3,0)
>>> print(lista)
[1, 2, 3, 0, 4, 5]
6. remove(elemento): Este método recibe como argumento un elemento, y borra su primera

aparición en la lista.
Nota: Si el elemento no se encuentra en la lista dará ValueError.
Ejemplo:
>>> lista = [1, 2, 3, 0, 4, 5]

>>> lista.remove(0)
>>> print(lista)
[1, 2, 3, 4, 5]
7. pop(i): Este método elimina el elemento en el ı́ndice i y lo devuelve.

Nota: El argumento i es opcional, y si no se coloca eliminará y devolverá el último
elemento de la lista.
Ejemplos:
>>> lista = [1,2,3,4,5] >>> lista = [1,2,3,4,5]

>>> lista.pop(3) >>> lista.pop()
4 5
>>> print(lista) >>> print(lista)
[1, 2, 3, 5] [1, 2, 3, 4]
8. clear(): Elimina todos los elementos de la lista.

Ejemplo:
>>> lista = [1,2,3,4,5]

>>> lista.clear()
>>> print(lista)
[]
9. sort()3 : Este método ordena los elementos de una lista de menor a mayor.
3
En el enlace para los métodos de una lista podrán encontrar que este método tiene argumentos y cómo
usarlos.

BML | Diccionarios 59
Ejemplo:
>>> lista = [1,25,76,8,9]

>>> lista.sort()
>>> print(lista)
[1, 8, 9, 25, 76]
Una lista con el resto de métodos para listas, lo podrán encontrar en el siguiente enlace:
https://docs.python.org/3/tutorial/datastructures.html
Métodos para tuplas
Las tuplas al ser muy similares a las listas comparten los mismos métodos salvo que estos
no modifiquen sus valores y estructura de como fueron creados. Por ejemplos los siguientes
métodos se pueden usar en las tuplas, y se usan de igual forma que con las listas.
1. index(elemento,inicio,final)
2. count(elemento)
Nota: Los métodos para las cadenas de texto y listas modifican directamente al objeto al
que se le aplica, y no a una copia de ellos como se ha podido observar en los ejemplos anteriores.
4.2. Diccionarios
Hasta el momento, hemos visto estructuras en Python que nos permiten guardar diferentes
tipos de datos, estas son las listas y tuplas. Una caracterı́stica en común entre las listas y tuplas
es que sus elementos están ordenados por un ı́ndice, sin embargo, a veces no es necesario tener
ningún orden con los datos que guardamos, en esos casos, es necesario usar un tipo de estructura
de datos que en Python es llamada diccionario.
Diccionario: Es un tipo de datos que nos permite guardar valores de diferentes tipos (como
las listas y tuplas), incluso otros diccionarios. El tipo de datos para los diccionario es dict.
La diferencia más importante entre las listas y tuplas, con respecto a los diccionarios, es que
sus elementos son identificados por una clave, dicha clave no tiene necesariamente un orden o
relación dentro de las demás claves4 , solo sirve para poder acceder al valor al cual está asociado
dentro del diccionario.
La sintaxis para un diccionario es:
mi_diccionario = {clave1 : valor1, clave2 : valor2,...,claven : valorn}

4
Esta caracterı́stica hace que muchas veces los diccionarios sean vistos como estructuras de datos tipo mapa.

BML | Diccionarios 60
Nota: Las claves pueden ser de tipo: int, float, str y tuple. Por otro lado los valores
puede ser del tipo: int, float, str, list, tuple y dict.
Ejemplo:
>>> mi_diccionario ={"Nombre":"Lazaro", "Edad":23, (2,2):"xD",33:5,2:[1,2]}

>>> print(mi_diccionario)
{"Nombre": "Lazaro", "Edad": 23, (2, 2): "xD", 33: 5, 2: [1, 2]}
Observación: En el ejemplo anterior, podemos notar que las claves no son necesariamente
del mismo tipo (lo mismo sucede con los valores), más aún, el tipo de dato usado para la clave,
no es necesariamente el mismo tipo de dato usado para el valor que está asociado.
Para acceder a los valores del diccionario, lo haremos usando la clave asociado al valor que
necesitemos, para ello seguiremos la sintaxis siguiente: mi_diccionario[clave].
Ejemplo:
>>> mi_diccionario ={"Nombre":"Lazaro", "Edad":23, (2,2):"xD",33:5, 2:[1,2]}

>>> mi_diccionario["Nombre"]
"Lazaro"
>>> mi_diccionario[2]
[1, 2]
Observación: Para acceder al valor "Lazaro", usamos la clave "Nombre" (de igual forma
para [1, 2], que en este caso su clave es 2).
Una caracterı́stica que comparten los diccionarios con las listas, es que podemos cambiar
sus valores (más precisamente podemos cambiar el valor a una clave), la forma de hacerlo es la
misma que se hace con las listas, solo que usando la clave, en vez de un ı́ndice.
Ejemplo:

>>> mi_diccionario[(2,2)] = ":D"
{"Nombre": "Lazaro", "Edad": 23, (2, 2): ":D", 33: 5, 2: [1, 2]}
Observación: A la clave (2,2), le cambiamos su valor "xD" por ":D".

Hacer el proceso anterior genera un efecto muy interesante, si la clave no existe dentro del
diccionario, el efecto que resulta es de agregar un nuevo valor dentro del diccionario, al final de
la secuencia, con la clave colocada y el valor asignado. Veamos un ejemplo de lo anterior.
Ejemplo:

BML | Métodos de los diccionarios 61
>>> mi_diccionario["Apellido"] = "López"

{"Nombre": "Lazaro", "Edad": 23, (2, 2): ":D", 33: 5, 2: [1, 2],
"Apellido": "López"}
Observación: Como se observa en el ejemplo anterior, la clave "Apellido" no existe den-

tro del diccionario, por lo que Python lo agrega al final como nuevo elemento, con la clave
"Apellido" y el valor asociado "López".
4.2.1. Métodos de los diccionarios
Al igual que las listas y las tuplas, los diccionarios tienen métodos, y la forma de usarlos es
la misma. A continuación presentamos los más usados.
1. update(otro_diccionario): Este método agrega al final de la secuencia del diccionario

los elementos de otro_diccionario.
Ejemplo:
>>> diccionario = {"Australia":"Canberra","El Salvador":"San Salvador"}

>>> diccionario.update({"Italia":"Roma", "Japón":"Tokio"})
>>> print(diccionario)
{"Australia": "Canberra", "El Salvador": "San Salvador", "Italia": "Roma",
"Japón": "Tokio"}
Observación: Si el diccionario a agregar solo tiene un elemento, entonces el efecto es de

agregar un elemento al diccionario, muy parecido al método append() de las listas.
2. keys(): Devuelve la lista de claves del diccionario.

Nota: La lista que devuelve este método es del tipo dict_keys, ası́ que para convertirla
enteramente a una lista debemos usar list().
Ejemplo:

>>> lista_claves = list(diccionario.keys())
>>> print(lista_claves)
["Australia", "El Salvador"]
3. values(): Devuelve la lista de valores del diccionario.

Nota: La lista que devuelve este método es del tipo dict_values, ası́ que para convertirla
enteramente a una lista debemos usar list().

BML | Métodos de los diccionarios 62
Ejemplo:

>>> lista_valores = list(diccionario.values())
>>> print(lista_valores)
["Canberra", "San Salvador"]
Una lista con el resto de métodos para diccionarios, lo podrán encontrar en el siguiente
enlace: https://www.tutorialspoint.com/python3/python_dictionary.htm

BML | Ejercicios 63
4.3. Ejercicios
Indicaciones: En cada uno de los siguiente problema debe crearse un programa o programa
modular5 (que funcione como módulo y programa).
1. Escribir funciones para realizar las siguientes conversiones:

a. De entero decimal a:
binario entero sin signo (64 bits de precisión)
binario entero con signo (63 bits de precisión)
octal sin signo (64 bits)
hexadecimal sin signo (64 bits)
b. de decimal no entero a:
binario entero sin signo (32 bits de precisión entera, 8 bits de precisión no entera)
binario entero con signo (31 bits de precisión entera, 8 bits de precisión no entera)
c. de binario entero sin signo a:
octal
hexadecimal
2. Escribir funciones para:
a. Generar conjuntos a partir de datos almacenados en una lista.
b. Determinar la pertenencia de un elemento en un conjunto.
c. Determinar si un conjunto es subconjunto de otro.
d. Determinar la unión de dos conjuntos.
e. Determinar la intersección de dos conjuntos.
f. Determinar la diferencia entre dos conjuntos.
3. Escribir funciones para:
a. Leer y formar una matriz A de dimensiones m y n.
b. Calcular la potencia x de una matriz cuadrada A.
c. Calcular el determinante de una matriz cuadrada A.
4. Determine si una frase es palı́ndromo o no. Ignore signos de puntuación. Por ejemplo, “se
van sus naves” es palı́ndromo pues se lee igual de izquierda a derecha que de derecha a
izquierda.
5. Recibir los nombres completos de diez compañeros de clase e imprimirlos con formato
centrado, y asegurando inicial mayúscula. Intente hacer dos versiones: una con lo métodos
de “str” y otra sin ellos.
5

BML | Ejercicios 64
6. Utilizando cadenas, descomponer un número real con no más de tres espacios decimales
en suma de potencias de 10.
7. Usando listas y tuplas, reciba dos listas de datos enteros y luego cree el producto cartesiano
de dichas listas.
8. Dado un conjunto de enteros ingresados por el usuario, cree una lista de pares ordenados
que corresponda a las siguientes relaciones:
a. R en A, R = {(x, y) : x2 + y 2 = 102 }
b. R en A, R = {(x, y) : ∃k, x = y × k}
c. R en A, R = {(x, y) : x ≡ y mód 5}
d. R en A, R = {(x, y) : x < y}
e. R en A, R = {(x, y) : x + y = 10}
9. Para algún par de conjuntos del problema anterior, genere las siguientes relaciones:

x z
a. R en A × A, R = (x, y, z, w) : =
y w
10. Para una lista de pares de enteros menores que 50, grafı́quelos en el plano cartesiano.

Capı́tulo 5
Ficheros
65
BML | Matriz en Numpy. 66
5.1. Matrices
Una matriz en Python es simplemente una lista de listas, donde cada sublista es la repre-
sentación de cada fila de la matriz.
Ejemplo: Consideremos la matriz A de la siguiente manera:
 
2 1 2
A = 3 3 3 
1 3 0
La representación en Python de A es:
>>> A = [[2,1,2],[3,3,3],[1,3,0]]
[[2, 1, 2], [3, 3, 3], [1, 3, 0]]
Observación: Notemos que por cada fila de la matriz A se tiene una sublista. Además en
este curso usaremos las letras mayúsculas para denotar variables del tipo matriz.
Todo lo que se puede hacer con lista, se puede hacer con las matrices creadas de la siguiente
forma.
5.1.1. Matriz en Numpy.
Hay dos formas de ver matrices en Numpy, una es usando el módulo array1 y la otra es
usando el módulo matrix. Nos ocuparemos del segundo2 , ya que este implementa de manera
natural las operaciones de matrices en los operadores usuales (suma, resta y multiplicación).
Nota: Para usar matrix en nuestros programas, debemos importar la libreria Numpy.
La sintaxis para crear una matriz usando matrix es: A = numpy.matrix(lista_de_datos).
Ejemplo: Consideremos la matriz A de la siguiente manera:
 
2 1 2
A = 3 3 3 
1 3 0
La representación en Python de A usando matrix es:
>>> import numpy as np

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
>>> A = np.matrix(a)
[[2 1 2]
[3 3 3]
[1 3 0]]
1
Se deja al estudiante investigar el uso y diferencia entre usar array y matrix.
2
Investigar las ventajas y desventajas entre usar array y matrix.

BML | Atributos de las matrices. 67
Observación: Es de resaltar que de esta forma, la presentación en pantalla de la matriz,

es más parecida a la forma usual.
Atributos de las matrices.
Por la forma que hemos creado las matrices, estas guardan información importante para
nosotros, estos datos son conocidos atributos3 . La sintaxis para acceder a los atributos de
una matriz es: mi_matriz.variable_atributo. Los atributos más importantes que podemos
encontrar son:
a) A.H: Devuelve la matriz transpuesta conjugada (si sus elementos son números complejos,
tendremos la matriz transpuesta conjugada, sino es la matriz transpuesta) de la matriz A.
b) A.T: Devuelve la matriz transpuesta de la matriz A.
Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.T
matrix([[2, 3, 1],
[1, 3, 3],
[2, 3, 0]])
c) A.I: Devuelve la matriz inversa de la matriz A (si tiene).

Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.I
matrix([[ 3.0 , -2.0 , 1.0 ],
[-1.0 , 0.66666667, 0.0 ],
[-2.0 , 1.66666667, -1.0 ]])
3
Los atributos son variables creadas con información importante del objeto (esto se estudia en programación
II).

BML | Operaciones con matrices. 68
d) A.shape: Devuelve una tupla con las dimensiones de la matriz A.

Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.shape
(3, 3)
e) A.size: Devuelve el número de entradas de la matriz A.

Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.size
9
Operaciones con matrices.
Las operaciones se pueden realizar de manera natural con los operadores de suma, resta y
multiplicación en las matrices.
Ejemplos:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> b = [[2,3,4],[0,1,0],[5,6,8]]
>>> B = np.matrix(b)
[[2 3 4]
[0 1 0]
[5 6 8]]

BML | Métodos de las matrices. 69
>>> A+B
matrix([[4, 4, 6],
[3, 4, 3],
[6, 9, 8]])
>>> A-B
matrix([[ 0, -2, -2],
[ 3, 2, 3],
[-4, -3, -8]])
>>> A*B
matrix([[14, 19, 24],
[21, 30, 36],
[ 2, 6, 4]])
Métodos de las matrices.
Las matrices tienen métodos integrados. A continuación se presentan dos métodos muy
usados:
a) A.trace(): Devuelve la suma de los elementos de la diagonal de la matriz A.

Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.trace()
matrix([[5]])
b) A.var(): Devuelve la varianza de los elementos de la matriz A.

Ejemplo:

>>> a = [[2,1,2],[3,3,3],[1,3,0]]
[[2 1 2]
[3 3 3]
[1 3 0]]
>>> A.var()
1.1111111111111112

BML | Archivos .txt 70
Nota: Ambos métodos tienen argumentos opcionales, estos sirven para acotar los elementos,
a los que se les desea aplicar el efecto del método.
La documentación completa de atributos y métodos, de las matrices en formato ma-
trix, la podrán encontrar en el siguiente enlace: https://numpy.org/doc/1.18/reference/
generated/numpy.matrix.html
5.2. Archivos .txt
Python nos permite manipular archivos de escritura poco complejas, uno de ellos son los
archivos .txt, estos archivos básicos de escritura podemos usarlos en la elaboración de nuestros
programas, extrayendo su información y escribiendo en ellos resultados relacionados con la
finalidad del programa principal.
A continuación, trataremos algunas funciones que nos permiten crear, abrir y modificar
archivos .txt.
Nota: Los archivos creados o usados .txt, deben estar siempre en la misma carpeta de
trabajo4 .
a) open(nombre_archivo,modo_abrir): Esta función permite abrir un archivo de escritura, y

devuelve un objeto5 que guarda toda la información en el archivo en formato de tipo str.
Los argumentos de open() son:
nombre_archivo: Debe ser una cadena de texto que indique el nombre del archivo
(incluso su extensión).
modo_abrir: Este argumento nos permite indicarle a Python cómo vamos a abrir el
archivo, si es crearlo, leerlo o modificarlo. A continuación, presentamos una tabla donde
están los distintos modos.
Modo Descripción
El archivo se abre en modo de solo lectura, no se puede escribir
r
(argumento por defecto).
Se crea un nuevo archivo y se abre en modo de lectura (si existe un
w
archivo con el mismo nombre, se borra).
El archivo se abre en modo de agregar, los datos escritos se agregan
a
al final del archivo.
r+ El archivo se abre para lectura y escritura al mismo tiempo.
El archivo se abre en modo binario, para almacenar cualquier cosa
b
que no sea texto.
El archivo se abre con soporte a nueva linea universal, cualquier fin
U
de linea ingresada sera como un \n en Python.
4
Esto permite mayor comodidad, porque si estuvieran en otra carpeta, tendrı́amos que especificar la ruta de
acceso a dichos archivos.
5
Este tipo de dato en Python 3 es una clase, se deja al estudiante investigar sobre las diferencias entre
Python 2 y Python 3.

BML | Archivos .txt 71
Ejemplo:
>>> archivo = open("datos.txt","r")

... Sea abierto el archivo datos.txt en modo de solo lectura ...
Observación: Hay un tercer argumento, pero no es opcional, se motiva al estudiante inves-

tigar el funcionamiento de este tercer argumento.
b) read(): Este método permite leer todo el documento y devuelve una cadena de texto con
el contenido del archivo.
Nota: Este método tiene un argumento del tipo entero, el cual nos permite indicarle cuántos
caracteres del archivo queremos leer.
Ejemplo:
>>> archivo = open("datos.txt","r")
>>> contenido = archivo.read()

... En la variable contenido sea guardado toda la información del
archivo datos.txt, está variable es del tipo str ...
Observación: Si ya se ha leı́do todo el contenido del archivo, aplicar una vez más este
método, hará que devuelva una cadena de texto vacı́a.
c) write(texto): Este método permite escribir el contenido de una cadena de texto al archivo.
El argumento texto debe ser una cadena de texto con la información que deseamos agregar
al archivo.
Ejemplo:
>>> archivo = open("datos.txt","a")
>>> texto = "\nHola de nuevo"

>>> archivo.write(texto)
... Se agrega la cadena de texto "Hola de nuevo"
al final del archivo datos.txt ...
Observación: La instrucción \n le dice a Python que haga un salto de linea.

Nota: Si se abre el archivo en el modo "r+", debe usarse el método seek(0,2) antes de
usar write() (ejemplo: archivo.seek(0,2)), este método con esos argumentos le indica a
Python que escriba al final del documento.

BML | Archivos .csv 72
d) close(): Este método permite cerrar la manipulación del archivo. No es posible escribir ni
leer en un archivo cerrado.
Ejemplo:

>>> archivo.close()
... Se ha cerrado el archivo ...
Hay más métodos para trabajar con archivos, el resto los podrán encontrar en el siguiente en-
lace: https://python-para-impacientes.blogspot.com/2014/02/operaciones-con-archivos.
html
5.2.1. Atributos de los archivos.
Los siguientes atributos tienen información útil de una variable, que guarda el contenido de
un documento de escritura.
a) closed: Devuelve False, si el documento está cerrado, True, si está abierto.

Ejemplos:

>>> archivo.closed
False

>>> archivo.close()
>>> archivo.closed
True
b) mode: Devuelve el modo en que fue abierto el documento.

Ejemplo:

>>> archivo.mode
"a"
c) name: Devuelve el nombre del documento abierto.

Ejemplo:

>>> archivo.name
"datos.txt"

BML | Métodos de Pandas. 73
5.3. Archivos .csv
Un archivo .csv puede ser tratado en Python de una manera bastante parecida al de los
archivos .txt, sin embargo, en este curso veremos cómo usar Pandas para trabajar archivos
.csv. Recordemos que para usar Pandas hay que importarlo, además de abreviarlo como pd
para mayor comodidad.
5.3.1. Métodos de Pandas.
Para manipular la información guardada en un archivo .csv, debemos usar ciertos métodos
de la librerı́a de Pandas, a continuación mostramos los más usados:
a) read_csv(nombre_archivo,name,header), este método permite leer archivos .csv y guar-

dar está información en una variable en forma de matriz.
Los parámetros significan:
nombre_archivo: Debe ser una cadena de texto que tenga el nombre del archivo .csv
a abrir (debe escribirse con la extensión).
names: Este argumento es opcional y debe ser una lista que contenga los encabezados
que queramos colocar a cada columna.
header: Este argumento es opcional, debe ser un entero, que significa desde cuál fila
será leı́do el documento (la primera fila leida la toma como los encabezados de la tabla).
Si deseamos que todo el contenido sean valores a usar, debemos colocar header=None.
Ejemplos:
>>> import pandas as pd

>>> datos = pd.read_csv("datos.csv")
Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10

>>> datos = pd.read_csv("datos.csv", names=["nombres","notas"])
nombres notas
0 Nombres Notas
1 Jorge 7
2 Carlos 6
3 Sofia 10

BML | Métodos de los DataFrame de Pandas. 74

>>> datos = pd.read_csv("datos.csv", header = 2)
Carlos 6
0 Sofia 10

>>> datos = pd.read_csv("datos.csv", header = None)
0 1
0 Nombres Notas
1 Jorge 7
2 Carlos 6
3 Sofia 10
b) DataFrame(diccionario): Este método de Pandas crea un DataFrame de Pandas, el

argumento debe ser un diccionario, y cada elemento representa una columna de la tabla,
además las claves serán tomadas como los encabezados de las columnas.
Ejemplo:

>>> nuevos_datos = pd.DataFrame({"Nombres":["Juan Carlos",
"Policarpo"],"Notas":[7,5]})
Nombres Notas
0 Juan Carlos 7
1 Policarpo 5
Métodos de los DataFrame de Pandas.
Una vez leı́do o creado un archivo DataFrame de Pandas, podremos acceder a la información
de manera similar a una matriz, más aún, podremos escribir sobre un archivo .csv o crear un
nuevo archivo .csv. A continuación, mostraremos algunos atributos más usados:
a) to_csv(nombre_archivo,mode,index,header): Este método permite escribir sobre un ar-

chivo .csv, la información que se encuentra en el DataFrame.
nombre_archivo: Este argumento debe ser una cadena de texto, y debe contener el
nombre completo del archivo.csv, si no existe tal archivo se crea de manera automática.
mode: Este argumento es igual que el de la función open() (es opcional).
index: Este argumento es booleano, y si es True, agrega la numeración de cada fila, y
si es False, no agrega la numeración de las filas (es opcional).

header: Este argumento es igual que el de read_csv() (es opcional).
Ejemplos: Para crear un archivo .csv nuevo, los valores de los argumentos opcionales deben
ser.

>>> nuevos_datos.to_csv("datos3.csv")
... En este caso se agrega la numeración de las filas ...
>>> nuevos_datos.to_csv("datos3.csv",index=False)
... En este caso no se agrega la numeración de las filas ...
Ejemplo: Para escribir en un archivo .csv (ya existente), los valores de los argumentos
opcionales deben ser.

>>> nuevos_datos.to_csv("datos.csv",mode="a",index=False,header=False)
... Agrega al final toda la información de nuevos_datos

al archivo llamado datos.csv ...
Observación: El modo "a"6 indica que agregue al final7 del archivo la información. Por otro
lado, index=False y header=False, le indican a Python que no agregue, ni numeración ni
encabezados.
b) iloc[]: Este método permite acceder a uno o varios elementos guardados en el DataFrame
de Pandas (como si fuera una matriz). Dependiendo del argumento que coloquemos ası́
podremos obtener cierta información. A continuación veamos algunos de ellos:
Si se ingresa solo un entero positivo o cero, devuelve la fila correspondiente al entero

ingresado.
Si se ingresan dos enteros positivos de la siguiente forma a:b (a puede ser cero), devol-
verá un DataFrame con los mismos encabezados del original, pero con las filas desde a
hasta b-1.
Si se ingresan dos enteros positivos de la siguiente forma a,b (ambos pueden ser cero),
devolverá el elemento en la fila a y columna b (los encabezados no se cuentan como
datos).
6
El modo a deja preparado el curso de escritura en la siguiente lı́nea.
7
Normalmente cuando se usa Excel para crear un archivo .csv, automáticamente deja el curso de escritura en
la siguiente linea, si por alguna razón esto no es ası́, agregue manualmente el curso de escritura en la siguiente
lı́nea.

Ejemplo:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos.iloc[1]
Nombres Carlos
Notas 6
Name: 1, dtype: object
>>> lista = list(datos.iloc[1])

["Carlos", 6]
Observación: Como podemos ver, hemos extraı́do la fila dos (que es la númerada como 1)
del DataFrame, y esta es presentada como columna, indicando a qué encabezado le corres-
ponde cada valor. Además vemos que podemos convertir la fila seleccionada en una lista.
Ejemplos:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos.iloc[1:3]
Nombres Notas
1 Carlos 6
2 Sofia 10
>>> datos.iloc[2,1]
10
c) sort_values(by,ascending): Este método devuelve un DataFrame de Pandas con la in-

formación ordena del DataFrame original. El orden es de acuerdo a los valores de la columna
indicada en by, para seleccionar la columna debemos colocar el encabezado, correspondiente

a la columna a ordenar (si el encabezado es texto, debe colocarse como cadena de texto,
para el valor del argumento).
El argumento ascending es opcional. Si ascending = True, entonces se ordenan de forma
ascendente, sino ascending = False se ordenan de forma descendente.
Ejemplo:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos.sort_values(by = "Notas")
Nombres Notas
1 Carlos 6
0 Jorge 7
2 Sofia 10
Observación: Notemos que si no se especifica ascending = True, por defecto toma ese
valor para el parámetro opcional.
Ejemplo:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos.sort_values(by = "Notas", ascending = False)
Nombres Notas
2 Sofia 10
0 Jorge 7
1 Carlos 6
Además de los métodos descritos anteriormente, existen otras formas de acceder a la infor-
mación de nuestros DataFrame, por ejemplo, si queremos acceder a una columna de nuestra
base de datos, lo podemos hacer de la siguiente manera mis_datos[Encabezado].

Ejemplo:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos["Nombres"]
0 Jorge
1 Carlos
2 Sofia
Name: Nombres, dtype: object
>>> lista = list(datos["Nombres"])

["Jorge", "Carlos", "Sofia"]
Observación: Lo que hemos hecho en el ejemplo anterior, es poder extraer la columna

Nombres. Además el encabezado al ser cadena de texto, se ingresa de esa forma. También
podemos convertir esta columna en una lista.
Finalmente, podemos extraer partes del DataFrame, de una manera parecida al ejemplo
anterior (en este caso usando la numeración de la filas).
Ejemplo:

Nombres Notas
0 Jorge 7
1 Carlos 6
2 Sofia 10
>>> datos[1:3]
Nombres Notas
1 Carlos 6
2 Sofia 10
Observación: En el ejemplo anterior, se he extraido desde la fila 1 hasta 2, la sintaxis

en este caso es mis_datos[a:b], donde se extrae desde la fila numerada con a hasta la fila
numerada con b-1. Además note que se devuelve otro objeto del tipo DataFrame de Pandas.

La documentación completa8 de la librerı́a Pandas, la podrán encontrar en el siguiente

enlace: https://pandas.pydata.org/pandas-docs/stable/reference/io.html
En este documento se usan archivos .csv con Pandas, sin embargo existe una librerı́a des-
tinada al manejo de estos archivos, la cual es csv. En el siguiente enlace podrán ver cómo
usar ciertos aspectos básicos de esa librerı́a: https://code.tutsplus.com/es/tutorials/
how-to-read-and-write-csv-files-in-python--cms-29907
8
Los métodos presentados, solo abarcan los argumentos opciones más utilizados, sin embargo, como podrán
ver en el enlace, cada método tiene más argumentos opciones, estos permiten manipular otros aspectos de los
datos del DataFrame.

BML | Laboratorio - 1 80
5.4. Laboratorio - 1
Indicaciones:
Debe crearse un programa o programa modular9 (que funcione como módulo y programa).
Las funciones auxiliares deben tener documentación, especificando qué variable está de-
volviendo, y de qué tipo son, y lo mismo para los argumentos.
El programa principal y funciones auxiliares deben tener una documentación apropiada,

explicando procesos no tan obvios.
Crear un archivo .csv que contenga la tabla de datos iniciales que se muestra en cada
problema (esta pueden hacerla usando Excel).
El programa principal debe crear un archivo .txt respondiendo las siguientes interrogantes:
a) ¿Cuántas clases recomendarı́a?

b) ¿Qué intervalo de clase sugerirı́a?
c) ¿Qué lı́mite inferior recomendarı́a para la primera clase?
d) ¿Dónde tienden a acumularse los datos?
El programa principal debe organizar los datos en una distribución de frecuencia y distri-
bución de frecuencia relativa. Ambas tablas deben ser presentadas en pantalla y generar
un nuevo archivo .csv que las contenga (no debe usarse Excel en esta parte).
Problemas:
1. El director de asuntos escolares de la Universidad de Nápoles Federico II tiene 16 solicitu-

des de la inscripción para el año próximo. Las puntaciones en el examen de conocimientos
de los solicitantes son:
27 27 27 28 27 25 25 28
26 28 26 28 31 30 26 26
2. El Pollo Campestre tiene varias sucursales en el área metropolitana. El número de cambios

de aceite en la sucursal de la 29 Calle Poniente en los pasados 20 dı́as fue:
65 98 55 62 79 59 51 90 72 56
70 62 66 80 94 79 63 73 71 85
3. Al gerente local de Urbana pizza le interesa el número de veces que un cliente visita su
restaurante durante un periodo de dos semanas. Las respuestas de 51 clientes fueron:
9
programas que se necesiten en cada numeral.

5 3 3 1 4 4 5 6 4 2 5 6 6 7 1
1 14 1 2 4 4 4 5 6 3 5 3 4 5 6
8 4 7 6 5 9 11 3 12 4 7 6 5 15 1
1 10 8 9 2 2
4. Cleveland, una agencia de viajes ofrece tarifas especiales en ciertos creceros para personas
de la tercera edad. El presidente de Cleveland quiere información adicional sobre las
edades de las personas que toman cruceros. Una muestra aleatoria de 40 clientes que
tomaron un crucero el año pasado revela estas edades.
77 18 63 84 38 54 50 59 54 56 36 26 50 34 44
41 58 58 53 51 62 43 52 53 63 62 62 65 61 52
60 60 45 66 83 71 63 58 51 71

5.5. Laboratorio - 2
Indicaciones:
Debe crearse un programa o programa modular10 (que funcione como módulo y programa).
Las funciones auxiliares deben tener documentación, especificando qué variable está de-
volviendo, y de qué tipo son, y lo mismo para los argumentos.
El programa principal y funciones auxiliares deben tener una documentación apropiada,
explicando procesos no tan obvios.
El programa principal debe crear un archivo .txt que contenga la siguiente información.
a) Indicar la elección del usuario.

b) Media, mediana y moda de los datos.
c) Indicar los cuartiles, deciles o percentiles, de acuerdo a lo elegido por el usuario.
El programa principal debe desplegar un menú en la pantalla, donde le permita elegir

al usuario, si quiere calcular cuartiles, deciles o percentiles. Además, el programa
principal debe generar el diagrama de cajas de los datos proporcionados y guardarlo.
Problemas:
1. El director de asuntos escolares de la Universidad de Nápoles Federico II tiene 16 solicitu-

des de la inscripción para el año próximo. Las puntaciones en el examen de conocimientos
de los solicitantes son:
27 27 27 28 27 25 25 28
26 28 26 28 31 30 26 26
2. El Pollo Campestre tiene varias sucursales en el área metropolitana. El número de cambios

de aceite en la sucursal de la 29 Calle Poniente en los pasados 20 dı́as fue:
65 98 55 62 79 59 51 90 72 56
70 62 66 80 94 79 63 73 71 85
3. Al gerente local de Urbana pizza le interesa el número de veces que un cliente visita su
restaurante durante un periodo de dos semanas. Las respuestas de 51 clientes fueron:
5 3 3 1 4 4 5 6 4 2 5 6 6 7 1
1 14 1 2 4 4 4 5 6 3 5 3 4 5 6
8 4 7 6 5 9 11 3 12 4 7 6 5 15 1
1 10 8 9 2 2
10
programas que se necesiten en cada numeral.

4. Cleveland, una agencia de viajes ofrece tarifas especiales en ciertos cruceros para personas
de la tercera edad. El presidente de Cleveland quiere información adicional sobre las edades
de las personas que toman cruceros. Una muestra aleatoria de 40 clientes que tomaron un
crucero el año pasado revela estas edades.
77 18 63 84 38 54 50 59 54 56 36 26 50 34 44
41 58 58 53 51 62 43 52 53 63 62 62 65 61 52
60 60 45 66 83 71 63 58 51 71

Capı́tulo 6
Recursividad
84
BML | Funciones recursivas 85
6.1. Funciones recursivas
Las funciones recursivas son funciones que se llaman a sı́ mismas durante su propia ejecución.
Estas funciones se comportan de alguna manera como los ciclos, ya que estas repiten una y otra
vez sus instrucciones hasta finalizar el proceso.
Como mı́nimo una función recursiva tiene dos partes, las cuales son:
1. Caso base o de fin de recursión: Es un caso donde el problema puede resolverse sin
tener que hacer uso de una nueva llamada a sı́ mismo. Evita la continuación indefinida
de las partes recursivas.
2. Parte recursiva: Relaciona el resultado del algoritmo con resultados de casos más sim-
ples. Se hacen nuevas llamadas a la función, hasta llegar al caso base.
Observación: Debemos conocer bien el momento en que la función deberá dejar de llamarse
a sı́ mismas o tendremos una función recursiva infinita.
Veamos a continuación dos ejemplos de funciones recursivas, una donde no retorne nada y
otra donde sı́ retorne un valor.
Ejemplo:
def tabla2(n):
if n>0:
print("2 *",n," = ",2*n)
tabla2(n-1)
else:
print("2 *",n," = ",2*n)
>>> tabla2(5)
2 * 5 = 10
2 * 4 = 8
2 * 3 = 6
2 * 2 = 4
2 * 1 = 2
2 * 0 = 0
Observación: El ejemplo anterior nos muestra una función que despliega en pantalla la
tabla del 2 hasta un cierto número n. En esta función hemos sustituido un ciclo for por la
acción de llamarse a sı́ misma a la función, para lograr el efecto iterativo del ciclo y poder
diseñar en pantalla la tabla del 2.
Ejemplo:
def factorial(n):

BML | Tipos de recursión 86
if n>0:
return n*factorial(n-1)
else:
return 1
>>> factorial(0)
1
>>> factorial(1)
1
>>> factorial(5)
120
Observación: En el caso anterior tenemos una función que retorna el factorial de un número
entero positivo n o cero, nótese que una vez más no hemos implementado un ciclo para encontrar
el factorial (como podrı́a pensarse en un principio), sino que sea ha hecho que la función se
llame a sı́ misma, para crear el efecto de multiplicar n con todos los número enteros positivos
anteriores a él.
En ambos ejemplos, podemos notar que hemos dejado claro que cuando n = 0 la función
debe parar de llamarse, provocando que la acción iterativa de llamarse tenga un fin. Debe
estar claro bajo qué instancia la función dejará de llamarse, porque si hay ambigüedad, podrı́a
resultar en una función iterativa infinita (nunca pararı́a).
6.2. Tipos de recursión
Dependiendo de la forma que las funciones recursivas pueden relacionarse entre sı́, podemos
tener diversos tipos de recursión. A continuación, presentaremos estos tipos de recursión.
a) Recursividad simple: Son las funciones que sólo hacen una llamada recursiva (a sı́ mis-
mas). Se puede transformar con facilidad en algoritmos iterativos (ciclos).
Ejemplo:
def factorial(n):
if n>0:
return n*factorial(n-1)
else:
return 1
>>> factorial(5)
120
b) Recursividad múltiple: Se da cuando hay más de una llamada a sı́ misma dentro del
cuerpo de la función, resultando más difı́cil de hacer de forma iterativa.

BML | Tipos de recursión 87
Ejemplo:
def fibonacci(n):
if n<=1:
return 1
else:
return fibonacci(n-1)+fibonacci(n-2)
>>> fibonacci(5)
8
c) Recursividad anidada: Una función recursiva es anidada cuando entre los parámetros que
se pasan a la función se incluye una invocación a la misma.
Ejemplo: 1
def Ackermann(m,n):
if m==0:
return n+1
elif m>0 and n==0:
return Ackermann(m-1,1)
else:
return Ackermann(m-1,Ackermann(m,n-1))
>>> Ackermann(3,2)
29
d) Recursividad cruzada o indirecta: Son algoritmos donde una función provoca una lla-
mada a sı́ misma de forma indirecta, a través de otras funciones.
Ejemplo:
def par(n):
if n==0:
return True
else:
return impar(n-1)
def impar(n):
if n==0:
return False
else:
1
Esta es la implementación en Python de la función de Ackermann, en el siguiente enlace, podrán encontrar
un poco de información sobre esta función: https://es.wikipedia.org/wiki/Funci%C3%B3n_de_Ackermann

BML | Algoritmos de ordenamiento 88
return par(n-1)
>>> par(5)
False
>>> impar(5)
True
6.3. Algoritmos de ordenamiento
Una tarea muy habitual en programación, es la de ordenar ciertos datos bajo cierto criterio2 ,
por esta razón, han surgido ciertas técnicas, que permiten ordenar datos de manera eficiente.
A estas técnicas se les conoce como ✭✭algoritmos de ordenamiento✮✮.
A continuación, presentamos los principales algoritmos de ordenamiento:
Ordenamiento de Batcher.
Ordenamiento de burbuja.
Ordenamiento de burbuja bidireccional.
Ordenamiento por inserción.
Ordenamiento por montı́culos.
Ordenamiento de peine.
Ordenamiento rápido.
Ordenamiento por selección.
Ordenamiento de Shell.
2
Las relaciones de orden más usadas son el orden numérico y el orden lexicográfico. Estas relaciones
de orden son muy útiles en materias como topologı́a.

BML | Ejercicios 89
6.4. Ejercicios
1. Para cada literal, hacer un programa que dada un número entero positivo calcule el n-ési-
mo termino de la sucesión aritmética, definida por los primeros términos de la progresión.
a) 42, 39, 36, . . .

b) 3, 8, 13, . . .
c) 1/2, 5/8, 3/4, . . .
2. Hacer una función que reciba el primer termino de la sucesión aritmética, la diferencia d
y un entero positivo n, y devuelva la suma de los primeros n términos de la sucesión.
3. Hacer un programa que dada un número entero positivo calcule el n-ésimo termino de la
sucesión geométrica, definida por los primeros términos de la progresión. Los cuales son:
3, 1, 1/3, 1/9, . . .
4. Hacer una función que reciba el primer termino de la sucesión geométrica, la razón r y
un entero positivo n, y devuelva la suma de los primeros n términos de la sucesión.
5. Hacer una función que reciba un entero n ≥ 0, y devuelva el n-ésimo termino de la

sucesión definida como:
an = 5an−1 + 6an−2 , n ≥ 2, a0 = 1, a1 = 3
6. Hacer un programa que dado un entero n ≥ 0, de vuelva el n-ésimo termino del siguiente
sistema de relación de recurrencia.

an+1 = 2an − bn + 2
n ≥ 0, a0 = 0, b0 = 1
bn+1 = −an + 2bn − 1
Nota: En todos los ejercicios solo usar funciones recursivas.
3

Capı́tulo 7
Programación funcional
90
BML | Filter. 91
7.1. Función lambda
De manera informal una función lambda es una pequeña función, en el sentido que las
instrucciones dentro de la función lambda son sencillas y cortas (a veces llamadas subrutinas).
Las funciones lambda a menudo son usadas como argumentos que pasan a ser funciones de
orden superior 1 , o se usan para construir el resultado de una función de orden superior que
necesita devolver.
La comodidad de usar este tipo de funciones es que son funciones que se declaran en una
lı́nea. Los estudiantes encontrarán la primera utilidad de este tipo de funciones en los cursos
de análisis numérico.
Sintaxis de las funciones lambda es:
nombre_funcion = lambda arg1, arg2, arg3, ...: instrucciones
Ejemplos:
>>> por2 = lambda numero: numero*2 >>> f = lambda x,y: x+y

>>> por2(3) >>> f(2,3)
6 5
Nota: Las funciones lambda por defecto devuelven un resultado, por ende no es necesario
escribir return cuando se usa Python, sin embargo, hay lenguajes de programación donde sı́
es necesario especificar qué se devolverá.
7.2. filter, map, reduce
En esta última sección, estudiaremos tres tipos de funciones, que toman como parámetro
otras funciones. Estas permiten expandir la utilidad de las funciones existentes, o las que se
puedan crear.
7.2.1. Filter.
Esta función toma como argumentos una función booleana2 y una lista, y devuelve otra lista,
con los valores de la lista ingresada que cumplen la función booleana. La lista que devuelve
1
En matemáticas y ciencias de la computación, funciones de orden superior son funciones que cumplen al
menos una de las siguientes condiciones:
1. Tomar una o más funciones como entrada.
2. Devolver una función como salida.
En matemática estas funciones se llaman operadores o funcionales. Ejemplos: la derivada y la antiderivada.
2
El término función booleana se refiere que devuelve True o False.

BML | Map. 92
la función Filter es del tipo filter, ası́ que debe usarse list(), para que tengamos una lista
propiamente.
La sintaxis es: filter(mi_funcion, mi_lista)
Nota: Debe ingresarse solamente el nombre de la función booleana3 , sin paréntesis y sin
argumentos.
Ejemplo:
def multiplo_2(n):
if n%2==0:
return True
else:
return False
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> list(filter(multiplo_2,x))
[2, 4, 6, 8, 10]
Observación: La función multiplo_2(n), devuelve True, si n es par, y False, si n es

impar. Además, para la función filter, solo se ingresó el nombre de la función booleana, que
en este caso es multiplo_2.
7.2.2. Map.
Esta función toma como argumentos una función, y una o varias listas, y devuelve otra lista
con los valores que la función devuelve por cada elemento de la lista ingresada. La lista que
devuelve la función Map es del tipo map, ası́ que debe usarse list() para que tengamos una
lista propiamente.
La sintaxis es: map(mi_funcion, lista_1, lista_2, ..., lista_n)
Nota: Debe ingresarse solamente el nombre de la función, sin paréntesis y sin argumentos.
Además, debe ponerse tantas listas como argumentos tenga la función.
Ejemplos:
def multiplicar_2(n):
return n*2
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> list(map(multiplicar_2,x))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> list(map(lambda n: n*2,x))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
3
Si la función no es booleana, ¿cuál serı́a el resulta?

BML | Reduce. 93
Observación: En ambos ejemplos, map() recorre la lista x, y devuelve una lista, con los
valores de x evaluados en la función multiplicar_2 y lambda.
7.2.3. Reduce.
Esta función toma como argumentos una función y una lista, y devuelve un valor, el cual es
el resultado de aplicar iteradamente los valores de la lista a la función. Al comienzo toma los
primeros dos elementos de la lista ingresada, y evalúa en la función, usa este resultado como
valor para el primer argumento de la función, y toma el siguiente valor de la lista para el valor
del segundo argumento. Este último paso se aplica iteradamente hasta agotar la lista.
La sintaxis es: reduce(mi_funcion, lista)
Nota: Debe ingresarse solamente el nombre de la función, sin paréntesis y sin argumentos.
Además, el efecto de Reduce sobre los elementos de la lista es de agrupamiento, por ejemplo,
si queremos sumar los números 1, 2, 3, 4 y 5, Reduce aplicarı́a la función suma de la siguiente
manera: ((((1 + 2) + 3) + 4) + 5) = (((3 + 3) + 4) + 5) = ((6 + 4) + 5) = (10 + 5) = 15.
Ejemplos:
from functools import reduce
def sumar(n,m):
return n+m
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> reduce(sumar,x)
55
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> reduce(lambda n,m:n+m,x)
55
Observación: Para poder usar Reduce, es necesario importarlo de la librerı́a functools. La

función debe poder recibir dos valores (no ser una función de un argumento). Además, si la
función tiene más de dos argumentos, el resto de argumentos deben tener valores predetermi-
nados.

BML | Ejercicios 94
7.3. Ejercicios
1. Para cada literal, Hacer un programa que dado un entero positivo, calcule la suma parcial
hasta el termino n-ésimo.
n
X
a) (4k − 3)
k=1
n
X 1
b)
k=1
2k
n
X 3k − 6
c)
k=1
2
2. Para cada literal, Hacer un programa que dado un entero positivo, calcule el producto
hasta el termino n-ésimo.
n
Y k
a)
k=2
k−1
n
Y
b) (k + 1)2
k=0
n
Y (−1)k
c)
k=0
2k + 1
3. Hacer un programa verifique si un carácter es alfanumérico (es decir, minúsculas, mayúscu-

las o numérico) de una lista.
4. Hacer un programa que decida en una lista de animales y vegetales qué se puede producir
con ellos. Por ejemplo de una vaca podemos obtener leche, del maı́z tenemos tortillas.
Haga que su programa pueda decidir entre tres animales y tres vegetales.
5. Hacer un programa que decida por el nombre de una comida si esté es de origen vegetal o
animal. Su programa debe poder decidir entre tres comidas de origen animal (por ejemplo
hamburguesa) y tres de origen vegetal (por ejemplo carne de soya).
6. Hacer un programa que dada una lista de cadenas de texto, devuelva la lista pero sin
palabras que tengan menos de 4 letras.
7. Hacer un programa que dada dos lista de números, haga el producto cartesiano y devuelva
una lista con pares ordenados donde la segunda coordenada es menor a la primera.
Nota: En todos los ejercicios debe usarse Filter, Map y Reduce.

4

Apuntes de Programacion I Con Python

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes de Programacion I Con Python

Cargado por

Copyright:

Formatos disponibles

Apuntes de Programación I con Python

Luisantos Bonilla Mejı́a

La primera unidad está formada por el contenido impartido en un minicurso de introducción

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Unidad 1: Introducción a la programación

Unidad 2: Ciclos, listas y funciones

Unidad 4: Secuencias en Python

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

5.3.1 Métodos de Pandas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Unidad 7: Programación funcional

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

1.1. Conceptos básicos

El beneficio que nos da la programación es la de eliminar tareas repetitivas, por ejemplo,

Lenguaje Máquina: Es el que entienden directamente las computadoras y este consiste en

Lenguajes de programación de bajo nivel: Es el lenguaje de programación que se carac-

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

1. Lenguajes de programación imperativos: entre ellos tenemos COBOL, PASCAL, C

Lenguajes de programación de primera generación: Lenguaje de máquina y de bajo nivel.

Lenguajes de programación de segunda generación: Los primeros lenguajes de programa-

Lenguajes de programación de tercera generación: Son lenguajes de programación de alto

Lenguajes de programación de cuarta generación: Usados en aplicaciones de gestión y

Lenguajes de programación de quinta generación: Creados para la inteligencia artificial y

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Investiga y responde cada una de las siguientes interrogantes:

1. Escribe otras desventajas que poseen los lenguajes de bajo nivel.

2. ¿Cuáles términos se pueden aplicar a Python del glosario anterior?

3. Cuál es la definición de lenguaje de programación compilado. Además cite algunos

1.2. Representación de datos en las computadoras

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

3. Unicode: Es un código diseñado para facilitar el tratamiento informático, transmisión

Nota: ASCII tiene 255 caracteres y EBCDIC tiene 256 caracteres.

1.2.1. Representación binaria de los números naturales

Hablando un poco sobre cómo la computador entiende la información, conozcamos de ma-

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Nota: Este proceso es llamado decodificación.

1. Convertir a código binario los números: 2, 3, 8, 15 y 27

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Z+0 Binario Hexadecimal

Utilizando está tabla podemos codificar 27 en sistema hexadecimal.

1.2.2. Cambiar de un sistema a otro

Para cambiar de un número hexadecimal a un binario y viceversa, lo que hacemos es agrupar

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

11011 = (1)(1011) = (0001)(1011) = 1B

1.3. Operaciones básicas con números binarios

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

1. Realizar las siguientes operaciones:

111 + 11101 + 10110

3. Investigar la manera de hacer las mismas operaciones en el sistema hexadecimal.

Un pseudocódigo1 es la manera informal de presentar el principio o idea operativa de un

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

Observación: La forma de escribir el pseudocódigo debe ser lo más apegado al lenguaje de

Observación: En Python con # se puede introducir comentarios, para que el usuario

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

1. Escribir un pseudocódigo de un programa que:

Verifique si un número entero no negativo sea múltiplo de 5.

Nota: En los lenguajes de programación, si escribimos varios imprimir, cada imprimir

>>> En pantalla veremos:

Luisantos Bonilla Mejı́a | UES | Escuela de Matemática

1.5. Variables en Python

1. Son secuencias arbitrariamente largas de letras y dı́gitos.

2. La secuencia debe empezar con una letra.

3. El guión bajo (_) es considerado una letra.