Competencias de Programación con Python

M.Sc. Jorge Terán

19 de enero de 2024
2
 ÍNDICE GENERAL

Index 1

1. El lenguaje Python 7
1.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.1. Instalar herramientas . . . . . . . . . . . . . . . . . . . . . . . 8
1.2. El lenguaje Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.1. Sintaxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2. Tipos de lenguajes de programación . . . . . . . . . . . . . . . 13
1.2.3. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.4. Operaciones con datos escalares . . . . . . . . . . . . . . . . . 16
1.2.5. Convertir de un tipo de datos a otro . . . . . . . . . . . . . . 20
1.2.6. Operaciones con datos no escalares . . . . . . . . . . . . . . . 22
1.2.7. Corte, alı́as y mutabilidad . . . . . . . . . . . . . . . . . . . . 24
1.2.8. Entrada y salida por consola . . . . . . . . . . . . . . . . . . . 26
1.2.9. Funciones incorporadas . . . . . . . . . . . . . . . . . . . . . . 29
1.3. Librerı́as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.3.1. Librerı́a math . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.3.2. Librerı́a random . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.3.3. Librerı́a time . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3
4 ÍNDICE GENERAL

1.4. Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

1.4.1. Control de flujo - bifurcación . . . . . . . . . . . . . . . . . . . 34
1.4.2. Indentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.4.3. Operadores ternarios . . . . . . . . . . . . . . . . . . . . . . . 37
1.4.4. Operadore de pertenencia . . . . . . . . . . . . . . . . . . . . 37
1.5. Estructuras de control . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.5.1. Ciclos while . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.5.2. Ciclos for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.5.3. Instrucciones, break continue y else . . . . . . . . . . . . . . . 41
1.6. Eficiencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.6.1. Medición del tiempo de proceso . . . . . . . . . . . . . . . . . 43
1.6.2. List comprehension . . . . . . . . . . . . . . . . . . . . . . . 44
1.6.3. Entrada y salida eficiente por consola . . . . . . . . . . . . . . 45
1.7. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

2. Jueces virtuales de programación 51

2.1. Uso de los Jueces Virtuales . . . . . . . . . . . . . . . . . . . . . . . . 52
2.2. Lectura de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.2.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.3. Ejercicio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3. Funciones definidas por el usuario 59

3.1. Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.2. Argumentos y parámetros . . . . . . . . . . . . . . . . . . . . . . . . 61
3.2.1. Argumentos por posición . . . . . . . . . . . . . . . . . . . . . 61
3.2.2. Argumentos por nombre . . . . . . . . . . . . . . . . . . . . . 62
3.2.3. Sin argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.2.4. Parámetros por omisión . . . . . . . . . . . . . . . . . . . . . 62
3.2.5. Número variable de argumentos . . . . . . . . . . . . . . . . . 63
3.3. Instrucción return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4. Variables locales y globales . . . . . . . . . . . . . . . . . . . . . . . . 64
ÍNDICE GENERAL 5

3.5. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.6. Acoplamiento y Cohesión . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.7. Funciones puras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3.8. Funciones recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
3.8.1. Cálculo del factorial . . . . . . . . . . . . . . . . . . . . . . . 71
3.9. Ejemplo de un árbol binario . . . . . . . . . . . . . . . . . . . . . . . 72

4. Introducción informal a la complejidad Algorı́tmica 75

4.1. Reglas para el cálculo . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.2. Algunas complejidades comunes . . . . . . . . . . . . . . . . . . . . . 77
4.3. Estimación de la eficiencia . . . . . . . . . . . . . . . . . . . . . . . . 78

Siglas 79

Bibliografia 80

Índice alfabético 83
6 ÍNDICE GENERAL
CAPÍTULO 1
EL LENGUAJE PYTHON

1.1. Introducción

El lenguaje Python originalmente fue concebido por Guido Van Rossum. Una de
las caracterı́sticas principales de Python es un lenguaje interpretado, haciendo énfasis
en la legibilidad del código. Actualmente es administrado por la Python Software
Foundation. La licencia de uso es de código abierto y se denomina Python Software
Foundation License.
El lenguaje Python es un lenguaje muy fácil de aprender y entender. Existen va-
rias implementaciones de Python. CPython es la implementación oficial del lenguaje
de programación Python. Está escrita en C. JPython, escrita en Java y permite una
integración con el lenguaje Java. PyPy pensado en la eficiencia es un intérprete y un
compilador JIT, que significa compilar justo a tiempo con la finalidad de reducir la
cantidad de instrucciones que se interpretan.
También para los micro controladores existe una versión denominada MicroPyt-
hon.
En las áreas de inteligencia artificial, ciencia de datos, es el lenguaje preferido.
También se hace uso extensivo en matemáticas simbólicas y cálculos numéricos.

7
8 CapÍtulo 1. El lenguaje Python

1.1.1. Instalar herramientas

Para programar en tu equipo necesitas varias aplicaciones instaladas:

1. Lenguaje de programación para el desarrollo de aplicaciones.

2. Librerı́as y complementos.

3. Entorno de desarrollo de aplicaciones.

Lenguaje de Programación

El lenguaje de programación Python puede instalarse siguiendo las instruccio-

nes disponibles en: https://www.python.org/downloads/. Está disponible para los
sistemas operativos Windows, Linux, Unix, Macos y otros.
Naturalmente que todo puede hacerse manualmente o en forma automatizada.
Para simplificar el proceso manual puede utilizar Anaconda que facilita el proceso
de mantener las versiones actualizadas e instalar paquetes complementarios.
Para instalar Anaconda ingrese a la página:
https://www.anaconda.com/products/distribution
Sy descargue e instale la aplicación.
Para comprobar que nuestra instalación es correcta en la lı́nea de comandos es-
cribimos:

conda -V

y obtenemos la versión de anaconda que se instaló. Vea que la instrucción en la lı́nea

de comando es conda y no anaconda que es el nombre del programa. Luego:

python -V

y con esto verificamos la versión de Python instalada.

Para probar que Python funciona correctamente ingrese al programa escribiendo
python en la consola. Lo que obtendrá en la consola es:
1.1. Introducción 9

Python 3.9.13|packaged by conda-forge|(main, May 27 2022,16:56:21)

[GCC 10.3.0] on linux
Type "help","copyright","credits" or "license" for more information.
>>> 3+2*2
7
>>>
El escribir 3+2*2 inmediatamente obtiene el resultado que es 7. Para salir de pro-
grama puede escribir quit() o escribir un ctrl − d.
El programa no brinda ayudas para escribir programas por lo que es conveniente
utilizar un entorno de desarrollo.

Librerı́as y complementos

Para el contenido del texto no requerirá instalar librerı́as especiales, sin embargo
se explica como instalar estas.
Cuando tiene Python instalado, tendrá disponible el comando pip . A través de
este comando es posible instalar complementos, por ejemplo programas para ciencia
de datos, inteligencia artificial y otros. Esto se realiza con el siguiente comando:

pip install paquete

Si quiere administrar de forma sencilla los paquetes instalados hay que instalarlos
con anaconda.

conda install paquete

Entorno de Desarrollo

Para escribir programas Python se puede utilizar un editor de textos común, el

que viene en su sistema operativo. Un entorno de desarrollo es software que permite
escribir programas Python y brinda mucha ayuda para la escritura de los programas.
Un programa recomendado es pycharm de jetbrains y puede instalar en su siste-
ma operativo siguiento las instrucciones disponibles en: https://www.jetbrains.com/
help/pycharm/installation-guide.html.
10 CapÍtulo 1. El lenguaje Python

Otra opción es instalar jupyterlab que puede instalarse con anaconda, el comando
es:

conda install -c conda-forge jupyterlab

También existen disponibles compiladores gratuitos en la web. Uno similar a

jupyterlab es el programa colab disponible en las aplicaciones de Google.
Buscando python online compiler encontrará varios que puede utilizar.
La diferencia con tener uno en su propio equipo es el de tener el control de las
librerı́as instaladas, versiones de Python y muchas y mejores ayudas a la hora de
escribir el código.

1.2. El lenguaje Python

1.2.1. Sintaxis
Un programa es una secuencia de pasos simples que contienen el control de flujo
del proceso. El control de flujo especifica cuando cada paso es ejecutado. Finalmente
una forma de terminar la secuencia de pasos.
Las computadoras almacenan y ejecuta estas instrucciones. Las calculadoras y
otro tipo de equipos electrónicos tienen un programa fijo.
Los pasos simples están construidos de un conjunto predefinido de instrucciones
básicas que son:

1. Aritmética y lógica.

2. Pruebas simples.

3. Mover datos.

Luego un programa especial (intérprete) ejecuta cada instrucción EN ORDEN. Las

pruebas se utilizan para cambiar el flujo de ejecución de la secuencia de pasos. Se
detiene cuando acaba.
1.2. El lenguaje Python 11

Las construcciones básicas son palabras en inglés. El lenguaje de programación

consiste de: números, cadenas y operadores simples.
El lenguaje de programación tiene un sintaxis definida. La sintaxis es la forma co-
rrecta de escribir un programa. Los espacios delimitan las palabras y cada instrucción
viene en una lı́nea.
Semántica es el significado asociado con una instrucción sintácticamente correcta
de sı́mbolos sin errores de semántica.
En el lenguaje español una frase puede tener múltiples significados. En los len-
guajes de programación cada instrucción tiene un solo significado, sin embargo puede
ser diferente a lo que el programador pretende.
Cuando las cosas fallan esto puede deberse a uno de los siguiente problemas:

Errores semánticos, comunes y fácil de detectar. El compilador o intérprete los

detecta fácilmente porque no es posible comprender su significado.

Sin errores semánticos pero un significado diferente a lo que el programador

pretende, el programa deja de funcionar, no se detiene nunca, o da un resultado
diferente al esperado.

En el lenguaje de programación los programadores generalmente eligen nombres

para sus variables que tengan sentido y documenten para qué se usa esa variable. Los
nombres de las variables pueden ser arbitrariamente largos. Pueden contener tanto
letras como números, pero no pueden comenzar con un número. Se pueden usar letras
mayúsculas, pero es buena idea comenzar los nombres de las variables con una letra
minúscula.
La forma de definir una variable es la siguiente:

mi_variable = contenido_asignado_a_la_variable

Ejemplos:

a=5
incrementoSalario=1.2
area=base*altura/2
12 CapÍtulo 1. El lenguaje Python

Las constantes son nombres de variables cuyo contenido no cambia por ejemplo:

PI=3.1416

Generalmente las contantes se escriben en letras mayúsculas para ayudar a la

lectura de los programas. Las variables no pueden tener espacios. Una definición
errónea de una variable produce un error. Por ejemplo:

mi variable = 5

File "<ipython-input-4-aeea59f6618f>", line 1

mi variable = 5
^
SyntaxError: invalid syntax

Para asignar nombres a variables se debe tomar en cuenta que se deben utilizar
nombres descriptivos, si se quiere utilizar mas de una palabra se debe escribir con
guión bajo. Python reserva 33 palabras claves para su propio uso que no se pueden
usar como nombres de variables, estas son:

and as assert break class continue def del

elif else except False finally for from lobal
if import in is lambda None nonlocal not
or pass raise return True try while with
yield

En el programa se pueden incluir comentarios. Lo que está después del sı́mbolo

numeral se considera un comentario, ejemplo

#este es un comentario en una lı́nea

a=2 # este comentario esta después de una instrucción

1.2. El lenguaje Python 13

Cuando un comentario es muy largo y ocupa múltiples lı́neas utilizamos tres

apóstrofes, por ejemplo:

’’’ El programa lee datos

y luego de verificar los

números que son primos

cuenta cuantos hay ’’’

1.2.2. Tipos de lenguajes de programación

Los lenguajes de programación pueden clasificarse de varias formas:

1. Bajo nivel y alto nivel.- Se refiere a si el programa usa programas y objetos al

nivel de máquina. (pj. mover datos de 64 bits de un lugar a otro), o si realiza
operaciones más abstractas por ejemplo desplegar un menú.

2. General versus orientado a un dominio. Se refiere a que si las instrucciones son

para uso general o están orientadas a un dominio especı́fico. Por ejemplo SQL
que es un conjunto de instrucciones para facilitar el acceso a información en
las bases de datos.

3. Interpretado versus Compilado. Interpretado se refiere a que las instrucciones

escritas por el programador (código fuente)si se ejecuta directamente (por el
intérprete) o se convierte (por un compilador) a secuencias de instrucciones de
máquina.

1.2.3. Tipos de datos

Las instrucciones manipulan objetos (datos), cada objeto tienen un tipo que
definen las cosas que se pueden hacer con el. Se subdividen en dos tipos:
14 CapÍtulo 1. El lenguaje Python

Escalares que no pueden ser subdivididos.

No escalares tienen una estructura interna que puede ser accedida.

Todos los datos tienen un tipo:

Los tipos de datos para objetos escalares son: enteros, booleanos, punto flotante,
caracteres.

Para los datos no escalares son: cadenas, listas, tuplas.

Para averiguar de que tipo de dato es un dato se utiliza la instrucción type() Veamos
algunos ejemplos:

python
>>> type(2)
<class ’int’>

>>> type(42.0)
<class ’float’>

>>> type(False)
<class ’bool’>

La salida consiste de la palabra class que representa una clase (tipo) de datos y
luego sigue sigue el tipo de dato.

int representa a los números enteros

float representa los números con decimales que se denominan de punto flotante

bool son los datos que tienen solo dos valores, verdadero o falso en programación
se denominan boleanos o lógicos.
1.2. El lenguaje Python 15

Los datos no escalares también se denominan estructuras de datos que son or-
ganizaciones de datos que permiten realizar tareas con menores recursos y más efi-
cientemente. Como ejemplo tenemos cadenas (str), diccionarios(dict), listas(list), y
tuplas(tuple), que se explicaran más adelante. Claro esta que también tienen un tipo.
Veamos los ejemplos:

python
>>> a={’a’:1,’b’:2}
>>> b=[1,’a’,1,2,3]
>>> c=(1,2,3)
>>> d=’abc’

>>> type(a)
<class ’dict’>

>>> type(b)
<class ’list’>

>>> type(c)
<class ’tuple’>

>>> type(d)
<class ’str’>

Las listas son similares a las tuplas pueden almacenar datos escalares como datos
compuestos. La diferencia está en que las tuplas no se pueden modificar y las listas
si se pueden modificar. Para definir una lista los datos se escriben entre corchetes
cuadrados y separados por comas. Las tuplas se escribe entre paréntesis.
Por ejemplo si quiere escribir las notas de los estudiantes en una lista se escribe
como sigue:

notas=[60,70,50,75]
16 CapÍtulo 1. El lenguaje Python

Es deseable registrar el nombre conjuntamente con las notas, para esto se tiene
dos opciones:

nombreNota=[’Juan’,60,’Maria’,70,’Jose’,50,’Juana’,75]
nombreNota=[[’Juan’,60],[’Maria’,70],[’Jose’,50],[’Juana’,75]]

En el primer caso se ha construido una lista en la cual se ha colocado la nota

inmediatamente después del nombre. Es más deseable asociar el nombre y la nota
en una sola estructura. Esto facilita agregar más datos asociados a una persona tal
como la cédula, teléfono, etc. Para lograr este objetivo dentro de la lista nombreNota
se ha definido una lista conteniendo el nombre y la nota para cada estudiante.
Las cadenas o secuencias de caracteres se escriben entre dos apóstrofes o dos
comillas. Las siguientes son cadenas válidas:

’abc’
"Estoy aprendiendo a programar"

En cambio las siguientes son cadenas inválidas:

’abc
’Estoy aprendiendo a programar"

La primera comienza con apóstrofe y no termina con apóstrofe. La segunda co-

mienza con apóstrofe y termina con comillas. Si comienza con apóstrofe debe terminar
con apóstrofe.

1.2.4. Operaciones con datos escalares

Los operadores son sı́mbolos especiales que representan cálculos, como la suma
o la multiplicación. Los valores a los cuales se aplican esos operadores reciben el
nombre de operandos.
Los operadores +, -, * , /,// y ** realizan sumas, restas, multiplicaciones, divi-
siones, divisiones enteras y exponenciación (elevar un número a una potencia), como
se muestra en los ejemplos siguientes:
1.2. El lenguaje Python 17

hora-1
hora*60+minutos
minutos/60
5**2
(5+9)*(15-7)+32

Existen dos operadores de división, / y //. El primero es la división de punto

flotante por ejemplo: 7/2 = 3,5
En cambio el segundo es la división entera 7//2 = 3
Por ejemplo para calcular cuantas horas caben en 573 minutos, la división entera
da el resultado horas = 573//60
Para hallar el resto de una división se utiliza el operador denominado módulo que
es el sı́mbolo % . Por ejemplo para hallar el resto de 7/3 una forma de resolver es:

a=7//3
b=3*a
resto=7-b

Para simplificar esto se utiliza el operador módulo que es la forma abreviada de

hacer lo mismo. La sintaxis es: resto = 7 %3. Por ejemplo si se quiere obtener el
último dı́gito de 1234 es decir el dı́gito de las unidades es suficiente hallar el resto
después de dividir por 10.
Una expresión es una combinación de valores, variables y operadores. Un valor
por si mismo se considera una expresión, y también lo es una variable, ası́ que las
siguientes expresiones son todas válidas:

x=5
x+1
y=2*(x+2)

La evaluación de expresiones tiene un orden especı́fico. Cuando en una expre-

sión aparece más de un operador, el orden de evaluación depende de las reglas de
18 CapÍtulo 1. El lenguaje Python

precedencia. Para los operadores matemáticos, Python sigue las convenciones ma-
temáticas.
Los paréntesis tienen el nivel superior de precedencia, y pueden usarse para forzar
a que una expresión sea evaluada en el orden que se quiera. Dado que las expresiones
entre paréntesis son evaluadas primero, por ejemplo 2 ∗ (3 − 1) primero evaluará 3 − 1
y luego se multiplica por 2.
Se pueden usar también paréntesis para hacer una expresión más sencilla de leer,
incluso si el resultado de la misma no varı́a por ello.
La exponenciación (elevar un número a una potencia) tiene el siguiente nivel más
alto de precedencia, de modo que 2 ∗ ∗1 + 1 es 3, no 4, y 3 ∗ 1 ∗ ∗3 es 3 y no 27.
La multiplicación y la División tienen la misma precedencia, que es superior a la
de la Suma y la Resta, que también tienen entre si el mismo nivel de precedencia.
Ası́ que 2 ∗ 3 − 1 es 5, no 4, y 6 + 4//2 es 8, no 5.
Los operadores con igual precedencia son evaluados de izquierda a derecha. Ası́
que la expresión 5 − 3 − 1 es 1 y no 3, ya que 5 − 3 se evalúa antes, y después se
resta 1 de 2.
En caso de duda, añada siempre paréntesis a sus expresiones para asegurarse de
que las operaciones se realizan en el orden que quiere.
Para hacer los valores más legibles podemos utilizar un guion bajo:

a=1_000_000
b=1_000_000_000
total=a+b

Formas simplificadas de escribir

Existen formas simplificadas de escritura. Por ejemplo para sumar 1 a una variable
de puede escribir de dos formas:
Escritura regular Escritura simplificada
i=i+1 i+=1
El sı́mbolo de suma indica que hay que sumar 1 y el sı́mbolo igual que se se debe
almacenar en la variable i. Ası́ se obtienen las siguientes expresiones simplificadas:
1.2. El lenguaje Python 19

+=
-=
*=
/=
//=

Precisión de las operaciones numéricas

Las operaciones con números enteros son exactas. Se puede trabajar con números
de cualquier magnitud. En cambio la precisión de los nos números de punto flotante
esta limitada por la representación que tiene en la computadora. Los número de con
decimales se almacenan en el formato IEEE 754 que son números binarios de doble
precisión.
Doble Precisión significa que son números binarios de 64 bits. El valor máximo
que puede tener cualquier número de punto flotante es aproximadamente 1,8103 .
Cualquier número mayor que este se indicará mediante la cadena inf en Python.
Están divididos como sigue:

1. 1 bit para el signo.

2. 11 bits para el exponente.

3. 52 bits para la fracción.

Como ve al trabajar con números decimales los resultados no son exactos. Vea el
siguiente ejemplo:

10/3=0.3333333333333333
10/3+10/3=3.3333333333333333+3.3333333333333333=6.666666666666666

Sin embargo por el redondeo se tiene el siguiente error:

10/3+10/3=20/3
20/3=6.6666......7
20 CapÍtulo 1. El lenguaje Python

Por lo consiguiente hay que tener en cuenta este problema.

Los números de punto flotante se representan en el hardware de la computadora
como fracciones base 2 (binarias). Por ejemplo, la fracción decimal 0.125 tiene valor
1/10 + 2/100 + 5/1000, y de la misma manera la fracción binaria tiene valor 0/2 +
0/4 + 1/8. Estas dos fracciones tienen valores idénticos, la única diferencia real es
que la primera está escrita en notación fraccional de base 10 y la segunda en base 2.
La mayorı́a de las fracciones decimales no se pueden representar exactamente como
fracciones binarias. Una consecuencia es que, en general, los números decimales solo
se aproximan por los números realmente almacenados en la máquina.

1.2.5. Convertir de un tipo de datos a otro

Es posible convertir de un tipo de datos a otro. Por ejemplo convertir de cadena
a entero:

>>> a=’123’
>>> b=int(a)
>>> type(a)
<class ’str’>
>>> type(b)
<class ’int’>
>>>

Inicialmente la variable a tiene un número escrito como una cadena. Este número
se convierte a entero con la función int. Que pasa si la variable a convertir no contiene
un número entero:

>>>
>>> a=’12.3’
>>> b=int(a)

Se obtiene un error.
Para convertir los datos a otros formatos se utilizan las siguiente funciones:
1.2. El lenguaje Python 21

int: convertir a entero.

str: convertir a cadena.

float: convertir a punto flotante.

list: convertir de cadena o tupla a lista.

tuple: convertir de cadena o lista a tupla.

Cuando se convierte de cadena a lista se obtiene una lista con todos los caracteres
separados por un espacio.

>>> a=’hola’
>>> list(a)
[’h’, ’o’, ’l’, ’a’]
>>>

Para convertir esta lista otra vez a una cadena se debe utilizar la función join.
La forma de codificar es:

>>> ’’.join(a)
’hola’
>>> ’-’.join(a)
’h-o-l-a’
>>>

Se coloca entre apóstrofes el caracter que sirve como separador seguido de la

palabra join y entre paréntesis la lista. Hay que hacer notar que todos los elementos
a ser concatenados deben ser de tipo cadena.
22 CapÍtulo 1. El lenguaje Python

1.2.6. Operaciones con datos no escalares

Operaciones con cadenas

El operador + funciona con las cadenas, pero no realiza una suma en el sentido
matemático. En vez de eso, realiza una concatenación, que quiere decir que une
ambas cadenas, enlazando el final de la primera con el principio de la segunda. Por
ejemplo:
Operación aritmética Operación con cadenas
a=10 a=’10’
b=20 b=’20’
a+b a+b
resultado resultado
30 1020
El operador * también trabaja con cadenas multiplicando el contenido de una
cadena por un entero, que significa repetir la cadena. Por ejemplo:

primero = ’Test ’
n = 3
print(primero * n)

El resultado es repetir test 3 veces que es: Test Test Test

Operaciones con listas

De manera similar a las cadenas se pueden utilizar los operadores de suma y

multiplicación con un significado diferente. El operador de suma agrega una lista a
la otra. Ejemplo:

a=[1,2,3]
b=[5,7]
c=a+b
resultado
[1, 2, 3, 5, 7]
1.2. El lenguaje Python 23

El operador de multiplicación repite una lista la cantidad de veces:

a=[0]*5
resultado
[0,0,0,0,0]

Como ve el contenido se repitió 5 veces.

Funciones para manipular datos compuestos

Para manipular datos compuestos existen funciones tanto para cadenas como
listas.
Funciones para cadenas Funciones para listas
lower(): convierte la cadena a le-
tras minúsculas.

upper(): convierte la cadena a le- append(dato): agrega al final de

tras mayúsculas. la lista el dato que se encuentra
entre los paréntesis.
split(): separa la cadena por pa-
labras, si se incluye un caracter reverse(): Devuelve una lista en
entre los paréntesis se utiliza este orden reverso
caracter como separador en lu-
clear(): Borra el contenido de la
gar del espacio. Por ejemplo pa-
lista.
ra usar de separador una coma
split(’,’). extend(): agrega otra lista al fi-
nal.
strip(): quita los espacios del ini-
cio y final de una cadena y el fin
de lı́nea.
Como ejemplo veamos

a=’aBc’
b=a.lower()
# el resultado en b
24 CapÍtulo 1. El lenguaje Python

abc

#lista
l=[1,2]
l.append(5)
# el resultado es
[1,2,5]

1.2.7. Corte, alı́as y mutabilidad

En los tipos de datos compuestos, vale decir cadenas, tuplas y listas se pueden
aplicar cortes para separar una parte de los mismos. Para esto se utilizan corchetes
colocando los parámetros separados por dos puntos. La sintaxis es como sigue:

variable[inicio:fin:paso]

donde variable es la lista, cadena o tupla luego vienen los datos desde donde se
comienza, hasta donde y si es secuencial o con algún incremento. Cuando no se espe-
cifica el valor de inicio se considera el primer elemento y de la misma forma cuando
no se especifica el valor final se considera que es hasta el final. Para comprender
mejor veamos algunos ejemplos:

a=’abcdefghij’
b=a[:3]

Acá de la cadena a =′ abcdef ghij ′ se separan los tres primeros caracteres o sea
abc. Siempre se comienza a contar desde 0 y el carácter 3 no se toma en cuenta. Por
esta razón solo se extraen tres elementos y no cuatro.

a=’abcdefghij’
b=a[3:5]

En este caso se extrae a partir del caracter 3 y el 5 no lo copia el resultado es de.

1.2. El lenguaje Python 25

a=’abcdefghij’
b=a[0:6:2]

La copia comienza con el caracter 0 de dos en dos o sea que se copia el primero
luego se salta uno, continúa con el siguiente salto uno y ası́ sucesivamente, hasta
llegar al a elemento 6, dando como resultado ace.
De manera similar se hace lo mismo en una tupla o lista:

a=[0,1,2,3,4,5,6,7,8,9]
b=a[3:5]

En esta caso el resultado es [3, 4].

Mutabilidad

Mutabilidad se refiere a la posibilidad de cambiar los valores un elemento de un

tipo de datos compuestos. Las cadena y tuplas no se pueden cambiar. Lo que se hace
es crear una cadena o tupla con los cambios requeridos.
Para acceder a un elemento especı́fico de un tipo de datos compuesto se utilizan
corchetes encerrando el número de elemento que se quiere acceder. Por ejemplo

a=’hola’

Las posicione de los elementos son:

0 1 2 3
h o l a
De esto se ve que a[0] = h, a[3] = a. Ahora si quiero cambiar la primera letra de
minúscula a mayúscula la instrucción a[0] =′ H ′ es un error porque las cadenas no
inmutables. La forma de hacer esto es separar la parte que quiero mantener y crear
una nueva cadena, vea el ejemplo:

a=’hola’
a=’H’+a[1:]
26 CapÍtulo 1. El lenguaje Python

Las listas son mutables por lo que el código siguiente es válido:

a=[0,1,2,3,4,5,6,7,8,9]
a[3]=99

Alı́as

Alı́as significa dar un nombre sinónimo a un tipo de dato compuesto. Por ejemplo:

lista=[1,2,3,4]
alias=lista

En el ejemplo alı́as y lista son exactamente lo mismo por lo que si cambio un

valor en alı́as se habrá cambiado en lista.
Si requiero que alias y lista no sean lo mismo es necesario hacer una copia (clonar)
de lista en alias con alias = lista[:]. Hay que tener cuidado con esto pues pueden
existir efectos que no se ven a simple vista considere:

a=[0]*3
b=[a,a,a]
b[1][1]=1

En la primera instrucción se crea la lista a = [0, 0, 0]. En la segunda instrucción

b = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]. Ahora en la tercera instrucción se cambia el elemento 1
de la sublista 1, se tiene [[0, 1, 0], [0, 1, 0], [0, 1, 0]] esto dado que las tres sublistas son
sinónimos.

1.2.8. Entrada y salida por consola

Ingreso de datos

Para ingresar datos por teclado se utiliza la instrucción input() Por ejemplo:
a=input(’Ingrese su nombre’)
1.2. El lenguaje Python 27

Muy importante: Cuando Python lee datos del teclados lo ingresa (lee) siempre
como TEXTO. Siempre lee lı́nea por lı́nea, el fin de lı́nea se da cuando presiona
retorno de carro.
El texto entre apóstrofes es opcional.
Cuando queremos ingresar números enteros es necesario convertir de texto a
número. Para esto utilizamos la función int().
Por ejemplo a=int(input()).
Cuando hay que leer múltiples datos en una lı́nea hay que utilizar la función de
cadenas split().
Para leer por ejemplo tres palabras(textos sin espacios) en una lı́nea, es necesario
separar los datos de entrada en múltiples variables, o nombres.
Por ejemplo si se quiere ingresar en una lı́nea: primer nombre, apellido paterno
y apellido materno. Tenemos que definir tres variables digamos a,b,c.

a,b,c=input().split()

Ahora si no ingresa tres palabras separadas por un espacio dará error. Siempre
debe igualar el lado izquierdo con el derecho.
Para ingresar múltiples números en una lı́nea una vez ingresados es necesario
convertirlos a números enteros. Si se ingresa dos números el código serı́a:

a,b=input().split()
a=int(a)
b=int(b)

Una forma simplificada es la siguiente:

a,b=map(int,input().split())

Esto significa: leer y separar en el espacio, luego usar la función int en cada uno
de los textos obtenidos. La función map se utiliza para que todos los valores pasen
por una función en este caso la función es int. Indica que se asigne el primer valor
para a y el segundo valor para b.
28 CapÍtulo 1. El lenguaje Python

Salida de datos

Para salida de datos por consola se utiliza la función print. Ejemplo:

print(’hola a todos’)
a=10
print(a)

Cada instrucción imprime una cadena de texto y automáticamente salta a la

siguiente lı́nea. Para indicar cual es el caracter de fin de lı́nea se utiliza la opción end
seguido de la cadena que remplaza el de fin de lı́nea. Ejemplo:

a=10
print(a, end=’-’)

Esto imprimirá la variable a seguido de un ’-’ sin saltar de lı́nea.

Para imprimir con formatos especı́ficos es necesario construir una cadena que se
denominada f- strings. Se construyen colocando un letra f delante de la cadena y en
el interior los caracteres de formato y los textos asociados. Vea el siguiente ejemplo:

a=10
print(f’El resultado es: {a}’)

La variable a imprimir se coloca entre llaves. Ahora lo que se quiere, es dar formato
a la variable que se va a imprimir. Para poner los resultados con un formato especifico,
existen diferentes caracteres que permiten alinear, definir el número decimales, etc.
Descripción Caracter de formato
Alineación a la derecha >
Alineación a la izquierda <
Centrado ˆ
Especificar el número de caracteres (n) que ocupará :n
Imprimir un número en n espacios rellenando con ceros :0n
Especificar el número de decimales(n) :.nf
Especificar el espacio (a) y el número de decimales(n) :a.nf
1.2. El lenguaje Python 29

Algunos caracteres especialesespeciales son son:

\t tabulador
\r retorno de carro
\n nueva lı́nea
\’ un apóstrofe
\’ ’ comillas
En cada sistema operativo los caracteres de salto de lı́nea pueden ser diferentes,
por lo que se recomienda utilizar \ n.
Para mostrar listas se pueden utilizar los siguientes opciones:
Anteponer un asterisco (*) quita los corchetes en la impresión
Incluir la opción , sep=’-’ cambia la coma por el caracter especificado.
Si se tiene la lista l = [1, 2, 3] la instrucción print(*l,sep=’-¿’) muestra 1− >
2− > 3.
Ejercicio:
Lea dos números en una lı́nea que corresponden a la base y la altura de un
triángulo rectángulo, imprima el área con dos decimales. Utilice las funciones de
formato descritas para incluir el texto El área es en la misma instrucción.

#Ingresa la base y la altura de un triangulo rectangulo

base,altura=map(int,input().split())
area=base*altura/2
resultado=f’El area es {area:.2f}’ #f indica variable de tipo float
print(resultado)

En la cadena se pueden incluir caracteres especiales tabulador y fin de lı́nea:

#poner un tabulador antes del resultado

resultado=f’El area es \t {area:.2f}’
#poner el resultado en la siguiente linea
resultado=f’El area es \n {area:.2f}’

1.2.9. Funciones incorporadas

En el lenguaje existe varias funciones incorporadas:
30 CapÍtulo 1. El lenguaje Python

Función Descripción
round(numero[, ndigitos]) redondea el número numero al
número determinado en ndigitos.
abs(x) regresa el valor absoluto del número x, utilizado
para asegurar que el resultado deseado sea positivo.
bin(x) convierte el número x en binario.
oct(x) convierte el número x en Octagonal.
hex(x) convierte el número x en Hexadecimal.
max(arg1, arg2, ...) regresa el argumento que tenga mayor
valor definido con respecto al resto de los argumentos.
min(arg1, arg2, ...) regresa el argumento que tenga menor
valor definido con respecto al resto de los argumentos.

1.3. Librerı́as
El lenguaje Python tiene múltiples librerı́as para realizar diversas tareas de forma
más simple. Un librerı́a que también se denomina módulo contiene una serie de
métodos para realizar diferentes acciones. La forma de invocar librerı́as es utilizando
la instrucción import seguida del nombre de la librerı́a. Por ejemplo para las funciones
trigonométricas se requiere la librerı́a math y la instrucción para incluir en nuestro
programa es:

import math

Para utilizar una función importada se escribe el nombre de la librerı́a seguido

de un punto y la función. Por ejemplo si queremos hallar el seno de 20:

math.sin(20)

En muchos casos no se requieren todas las funciones de la librerı́a. Para importar

solo una por ejemplo la función seno se escribe:

from math import sin

1.3. LibrerÍas 31

en este caso se puede utilizar directamente la función importada sin anteceder el

nombre de la librerı́a.
También es posible asignar un nombre alterno al módulo:

import math as mate

En este caso en lugar de anteceder math al nombre de la función se debe colocar

mate.

1.3.1. Librerı́a math

Python tiene un módulo matemático (math) , que proporciona la mayorı́a de
las funciones matemáticas habituales. Antes de que podamos utilizar el módulo,
deberemos importarlo:

import math

Esta sentencia crea un objeto módulo llamado math. Si se imprime el objeto

módulo, se obtiene la información del módulo que se esta utilizando. Con dir(math)
se puede obtener todas las funciones disponibles en el módulo.
El objeto módulo contiene la función y variables definidas en el módulo. Para
acceder a una de esas funciones, es necesario especificar el nombre del módulo y el
nombre de la función, separados por un punto. Este formato recibe el nombre de
notación de punto. Ejemplo:

radianes = 0.7
altura = math.sin(radianes)

El ejemplo calcula el seno de la variable radianes. El nombre de la variable es

una pista de que sin y las otras funciones trigonométricas (cos, tan,etc.) toman
argumentos en radianes. Para convertir de grados a radianes, hay que dividir por 360
y multiplicar por 2π:
32 CapÍtulo 1. El lenguaje Python

grados = 45
radianes = grados / 360.0 * 2 * math.pi
math.sin(radianes)

La expresión math.pi toma la variable pi del módulo math. El valor de esa variable
es una aproximación de π, con una precisión de unos 15 dı́gitos.
Función Código Ejemplo
Valor absoluto abs math.abs(-3)
Funcion exponencial exp math.exp(1)
Potencia pow(a,b) math.pow(3,4)
Raiz Cuadrada sqrt math.sqrt(2)
Coseno cos math.cos(0.7)
Seno sin math.sim(0.7)
Tangente tan math.tan(1)
Conversión de radianes a grados degree math.degree(0.7)
Valor de pi pi math.pi
Valor de e e math.e
Arco seno asin math.asin(0.56)
Arco coseno acos math.acos(0.7)
MUY IMPORTANTE los resultados del módulo math son de punto flotante
(float) que implica solo 15 decimales de precisión.
La diferencia entre utilizar la función pow y doble asterisco es que pow devuelve
un número de tipo float y la operación potencia un número entero.

1.3.2. Librerı́a random

Para generar números al azar o aletorios se utiliza la librerı́a random. Algunos de
los métodos más comúnmente utilizados son:

random(): devuelve un número entre 0 y 1.

randint(a,b): devuelve un numero entero entre a y b

1.4. Operadores lógicos 33

1.3.3. Librerı́a time

La librerı́a time permite tomar una medida de tiempo en un momento dado. Los
métodos que más se usan son:

time ns(): anota el tiempo en nano segundos

time(): anota el tiempo en segundos

Por ejemplo si se quiere medir cuanto tiempo demora una secuencia de código:

import time
inicio=time.time()
#las instrucciones del codigo a medir
.....
fin=time.time()
demora=fin-inicio

1.4. Operadores lógicos

Los operadores lógicos son operadores cuyo resultado es verdadero o falso. Esto
se puede almacenar en una variable de tipo boolean (bool). Los operadores para
comparar son;

i y j son nombres de variables

Las comparaciones siguientes se evalúan a boolean

i > j i es mayor que j

i >= j i es mayor igual que j
i < j i es menor que j
i <= j i es menor o igual que j
i == j prueba de igualdad, verdadero si i es lo mismo que j
i! = j prueba de desigualdad, verdadero si i no es lo mismo que j
34 CapÍtulo 1. El lenguaje Python

Los operadores lógicos son:

a y b son nombres de variables de tipo boolean

not a ⇒ True si a es falso, False si a es verdadero

a and b ⇒ True si ambos son verdaderos

a or b ⇒ True si alguno de los dos es verdadero

La siguiente tabla muestra como funcionan los operadores:

a b a and b a or b
True True True True
True False False True
False True False True
False False False False
Consideremos el siguiente ejemplo, un conductor no puede manejar un vehı́culo
si toma una bebida alcohólicas, si se quiere verificar si está en infracción usaremos
dos variables maneja, y toma que pueden ser verdadero o falso, cuando ambas son
verdaderas esta en infracción, el código es el siguiente:

maneja = True
toma = False
ambos = maneja and toma
print(ambos)

1.4.1. Control de flujo - bifurcación

El control de flujo se refiere a decidir cuando se ejecuta una instrucción. Existen
tres formas de hacer el control de flujo. En los ejemplos de código que se muestra
a continuación condición es el resultado de una expresión lógica cuyo resultado es
verdadero o falso. Las instrucciones que se quieren ejecutar vienen a continuación:
1.4. Operadores lógicos 35

i f condicion :
instruccion
i f condicion : instruccion
instruccion ...
instruccion else :
... instruccion
instruccion
...

i f condicion :
instruccion
instruccion
...
e l i f condicion :
instruccion
instruccion
...
else :
instruccion
instruccion
...
En la primera columna cuando expresión es verdadera se ejecutan las instruccio-
nes que siguen. La instrucción Python para esto es if.
En la la segunda columna las instrucciones que siguen al if se ejecutan cuando
la expresión da un resultado verdadero. La instrucción else indica las instrucciones
que hay que ejecutar cuando el resultado de evaluar la expresión es falso.
La sintaxis es colocar dos puntos después de la condición ası́ como después del
else.
La instrucción elif se utiliza cuando en los que la expresión se evalúe como falso
se quiere preguntar por otra condición.
36 CapÍtulo 1. El lenguaje Python

1.4.2. Indentación
Indentar significa dejar espacios o tabuladores al margen izquierdo. Indentar es
muy importante porque permite definir bloques de código. En las instrucciones que
hacen referencia a las operaciones que dependen de ellas se las identifican por la
indentación. Vea el siguiente ejemplo:
# La segunda
# mal i n d e n t a d o
#b i e n i n d e n t a d o # instruccion esta
# da e r r o r
i f condicion : # fuera del bloque
i f condicion :
instruccion i f condicion :
instruccion
instruccion instruccion
instruccion
... instruccion
...
...
Como ve en el ejemplo de la izquierda todas las instrucciones después de la ins-
trucción if se encuentran perfectamente alineadas con una a indentación. El segundo
caso está mal indentado dado que no todas las instrucciones esta alineadas en forma
irregular. Tampoco se deben mezclar espacios con tabuladores. En el tercer caso la
segunda instrucción ya no pertenece al bloque de instrucciones del if porque esta
escrita a la altura de la instrucción if.
El ejemplo muestra la comparación de dos números:
x = f l o a t ( input ( ’ I n g r e s e un numero x : ’ ) )
y = f l o a t ( input ( ’ I n g r e s e un numero y : ’ ) )
i f x == y :
print ( ’ x e s i g u a l a y ’ )
i f y != 0 :
print ( ’ por l o que , x / y e s ’ , x/y )
elif x < y:
print ( ’ x e s menor ’ )
else :
print ( ”y e s menor” )
print ( ” g r a c i a s ! ” )
1.4. Operadores lógicos 37

Suponga que quiere comparar tres valores a, b, c, esto se puede hacer de tres
formas:
#forma 2
#forma 3
#forma 1 i f a>b :
i f a>b>c :
i f a>b and b > c : if b > c :
.....
....

1.4.3. Operadores ternarios

Se denominan operadores ternarios porque tienen tres operadores. Para ejempli-
ficar vea el programa siguiente, que halla el máximo entre a, b.
if a > b:
max = a
else :
max = b
Utilizando el operador ternario puede simplificar la escritura como sigue;
max = a i f ( a > b ) e l s e b
La sintaxis como ve es escribir la respuesta en el caso de que la instrucción if
sea verdadera luego la condición, el else indica que poner cuando la condición no se
cumple. Vea que la instrucción if en este caso termina con dos puntos.
Ejemplo: imprima si x es par o impar utilizando operador ternario:
#forma 1
print ( ’ par ’ ) i f x %2==0 e l s e print ( ’ impar ’ )

#forma 2
print ( ’ par ’ i f x %2==0 e l s e ’ impar ’ )

1.4.4. Operadore de pertenencia

El operador de pertenencia permite consultar si un dato pertenece a un conjunto
de datos. Este operador se denomina in. Vea los siguiente ejemplos:
38 CapÍtulo 1. El lenguaje Python

v o c a l e s= ’ a e i o u ’
x= ’ e ’
a=x in v o c a l e s
Se tiene una cadena con todas las vocales. La instrucción a=x in vocales dará el
verdadero si el contenido de x se encuentra en vocales. El mismo ejemplo se podrı́a
definir en una lista:
v o c a l e s =[ ’ a ’ , ’ e ’ , ’ i ’ , ’ o ’ , ’ u ’ ]
x= ’ e ’
a=x in v o c a l e s
El operador de pertenencia puede utilizarse en cadenas, listas, tuplas y dicciona-
rios.

1.5. Estructuras de control

Las instrucciones iterativas son las que permiten repetir varias instrucciones.
Existen 2 instrucciones que son for y while.

1.5.1. Ciclos while

La instrucción while significa mientras, es decir repetir mientras la condición sea
verdadera. La sintaxis se muestra en el ejemplo:
while <c o n d i c i o n >:
<e x p r e s i o n >
<e x p r e s i o n >
La forma en que funciona es:

Evalúa condición a True o False.

Si la condición es True realiza todas las instrucciones en el bloque while. Re-

cuerde que el bloque es todo lo que esta indentado debajo de la instrucción
while.
1.5. Estructuras de control 39

Verifica la condición otra vez.

Repite hasta que la condición sea False.

EL siguiente ejemplo imprime en pantalla todos los números y sus cuadrados que
sean menores a 100:
i =1
while i ∗ i < 1 0 0 : #su cuadrado e s menor que 100
print ( i , i ∗ i )
i+=1
Hay que tomar en cuenta, primero se ha definido una variable que sirve para
controlar la finalización del ciclo. Al final del mismo se incrementa la misma en uno.
Un error frecuente es que la variable que controla el ciclo no se modifica y el programa
nunca termina.

1.5.2. Ciclos for

El ciclo for permite repetir un código sobre los valores de un conjunto utilizando
el operador de pertenencia in. Por ejemplo si tenemos una lista de nombres y se
quieren procesar uno a uno cada uno de ellos la forma de escribir el código es:
nombres =[ ’ Juan ’ , ’ J o s e ’ , ’ Maria ’ , ’ J o s e ’ ]
f or nombre in nombres :
print ( nombre )
Ahora si se quiere recorrer letra por letra cada uno de los nombres el código es
como sigue:
nombres =[ ’ Juan ’ , ’ J o s e ’ , ’ Maria ’ , ’ J o s e ’ ]
f or nombre in nombres :
f or l e t r a in nombre :
print ( l e t r a )
El conjunto range permite definir un conjunto de números especificando el número
inicial, el número final y el incremento.
40 CapÍtulo 1. El lenguaje Python

range(inicio,fin,incremento)

los valores por omisión son inicio=0, el último elemento, incremento 1

Vea los siguiente ejemplos:

Definir los números del 0 al 100: range(100).

Definir los números pares del 10 al 100: range(10,100,2).

Definir los números del 100 al 0: range(100,-1,-1).

Hay que aclarar que al igual que en los cortes el ultimo valor no se procesa. El
ejemplo de los números cuadrados escrito con un for es como sigue:
f or i in range ( 1 , 1 0 ) :
print ( i , i ∗ i )
Este programa lista los número cuadrados hasta 9 ∗ 9 los primeros 9 desde el 1
hasta el 9 inclusive. el 10 ya no lo toma en cuenta.
Existen dos funciones que se puede aplicar a los ciclos for, estas son: reversed y
enumerate. La función reversed significa en orden inverso y la instrucción enume-
rate indicando el orden. En el ejemplo de los nombres enumerate adicionalmente
enumerarı́a los nombre que se listan, el código es como sigue:
nombres =[ ’ Juan ’ , ’ J o s e ’ , ’ Maria ’ , ’ J o s e ’ ]
f or numero , nombre in enumerate ( nombres ) :
print ( numero , nombre )
Al recorrer devuelve dos valores el número y el nombre. El número comienza con
0.
nombres =[ ’ Juan ’ , ’ J o s e ’ , ’ Maria ’ , ’ J o s e ’ ]
f or numero , nombre in enumerate ( reversed ( nombres ) ) :
print ( numero , nombre )
En el ejemplo devuelve los nombres comenzando desde el último, y el úumero que
coloca comienza siempre en 0.
1.5. Estructuras de control 41

1.5.3. Instrucciones, break continue y else

La instrucción break permite terminar un ciclo for o while en forma anticipada.
Esto es antes de que llegue a su condición de finalización. Un ejemplo hará más claro
éste concepto. Suponga que se tienen una lista de números y se quiere conocer si in
número es divisible por alguno de los números de la lista:

l i s t a =[2 ,5 ,7 ,11 ,13 ,17 ,19]

x=int ( input ( ’ I n g r e s e un numero ’ ) )
f or i in l i s t a :
i f ( x %i )==0:
print ( ’ Es d i v i s i b l e por ’ , i )
break

La instrucción break en el código anterior:

Inmediatamente termina el ciclo cuando encuentra un número con el cual es

divisible.

Salta todas las instrucciones en bloque de código.

Termina el ciclo.

Ahora suponga que se quiere colocar un mensaje cuando no es divisible por ningún
número de la lista.
Una forma de hacer esto es:

l i s t a =[2 ,5 ,7 ,11 ,13 ,17 ,19]

e s d i v i b l e=F a l s e
x=int ( input ( ’ I n g r e s e un numero ’ ) )
f or i in l i s t a :
i f ( x %i )==0:
print ( ’ Es d i v i s i b l e por ’ , i )
e s d i v i s i b l e=True
break
42 CapÍtulo 1. El lenguaje Python

if esdivisible :
print ( ’ no e s d i v i s i b l e por l o s numeros de l a l i s t a ’ )

Para eliminar la variable de control esdivisible la forma más simple y más fácil de
entender es utilizando la instrucción else, que se ejecuta cuando el ciclo no termina
normalmente. El código es como sigue:

l i s t a =[2 ,5 ,7 ,11 ,13 ,17 ,19]

x=int ( input ( ’ I n g r e s e un numero ’ ) )
f or i in l i s t a :
i f ( x %i )==0:
print ( ’ Es d i v i s i b l e por ’ , i )
break
else :
print ( ’ no e s d i v i s i b l e por l o s numeros de l a l i s t a ’ )

La instrucción continue a diferencia del break no termina el ciclo, si no salta todas

las instrucciones y retorna al ciclo. Por ejemplo sumar todos los números del 1 al 10
excluyendo el 4 y el 7:

suma = 0
f or i in range ( 1 0 ) :
i f i ==4:
continue
i f i ==7:
continue
suma+=i

print ( f ’Suma = {suma} ’ )

Comparando los ciclos se tiene:

1.6. Eficiencia 43

Ciclos For Ciclos while

Numero de iteraciones Numero de iteraciones
conocido desconocido.
Puede terminar antes Puede terminar antes
vı́a break vı́a break.
Usa un contador Puede utilizar un
contador, pero hay que
inicializar antes del ciclo e incrementar
dentro del ciclo.
Se puede reescribir No siempre es posible
un for como un while escribir un ciclo while
como un ciclo for.

1.6. Eficiencia

1.6.1. Medición del tiempo de proceso

El tiempo de proceso se mide con la librerı́a time . Ahora es necesario comparar
el tiempo que demora el ciclo while con relación al ciclo for para un mismo proceso.
Como ejemplo de comparación consideremos un programa que cuente hasta 100
millones:
Programa con while Programa con for
import time
import time
i n i c i o=time . time ( )
i n i c i o=time . time ( )
i =0
f or i in range ( 1 0 0 0 0 0 0 0 0 ) :
while i <100 0 0 0 0 0 0 :
continue
i+=1
f i n=time . time ( )
f i n=time . time ( )
print ( f i n −i n i c i o )
print ( f i n −i n i c i o )
Tiempo de proceso 10.55 Tiempo de proceso 4.419
Como se ve para iterar es mucho más eficiente el ciclo for, por lo que debe preferir
44 CapÍtulo 1. El lenguaje Python

éste a un ciclo while.

1.6.2. List comprehension

Las List comprehension son una forma de crear listas de forma mas simple. La
sintaxis es como sigue:
l i s t a = [ e x p r e s i o n ( i ) f or i in u n a E s t r u c t u r a i f c o n d i c i o n ]
Suponga que se quiere hacer una lista de los n primeros números cuadrados, en el
lado izquierdo se muestra la forma tradicional de crear esta lista y en el lado derecho
utilizando list comprehension:
Programa con tradicional Programa con List comprehension
import time
import time
i n i c i o=time . time ( )
i n i c i o=time . time ( )
n=100 0 0 0 0 0 0
n=100 0 0 0 0 0 0
cuadrados = [ ]
cuadrados =[ i ∗ i
f or i in range ( n ) :
f or i in range ( n ) ]
cuadrados . append ( i ∗ i )
f i n=time . time ( )
f i n=time . time ( )
print ( f i n −i n i c i o )
print ( f i n −i n i c i o )
Tiempo de proceso 33.96 Tiempo de proceso 18.96
Como ve el tiempo de proceso también es mucho más rápido. Ahora veamos el
mismo problema tomando en cuenta solo los cuadrados de los números impares.
n=20
cuadrados =[ i ∗ i f or i in range ( n ) i f i %2==1]
print ( cuadrados )
El resultado es [1, 9, 25, 49, 81, 121, 169, 225, 289, 361].
Vea que también es posible utilizar ciclos anidados. Suponga que quiere hacer la
siguiente lista de tuplas: (0, 0)(0, 1)(1, 0)(1, 1)
l i s t a =[( i , j ) f or i in range ( 2 ) f or j in range ( 2 ) ]
print ( l i s t a )
1.6. Eficiencia 45

Tome en cuenta que la instrucción for e if no llevan dos puntos.

1.6.3. Entrada y salida eficiente por consola

Cuando se leen datos por medio de la instrucción input lee los datos desde el
teclado (stdin) y se realizan diversos procesos sobre los datos de entrada. Para una
lectura más eficiente desde stdin se utiliza la función stdin de la librerı́a sys. El
ejemplo muestra como leer una lı́nea del teclado:

import s y s
entrada = sys . stdin . r e a d l i n e ( )
print ( e n t r a d a )

Cuando se leen los datos de esta forma no se quita el fin de lı́nea por lo que es
conveniente agregar el método strip() si es necesario.
La salida de datos se hace por medio del método stdout.write. Hay que hacer
notar que solo puede escribir cadenas de texto y es necesario que uno agregue el fin
de lı́nea. El ejemplo siguiente solicita el nombre y luego lo muestra por pantalla.

import s y s
s y s . s t d o u t . w r i t e ( ’ I n g r e s e su nombre : \n ’ )
nombre = s y s . s t d i n . r e a d l i n e ( )
s y s . s t d o u t . w r i t e ( ’ Hola ’ +nombre+ ’ \n ’ )

Ejemplos:

Para imprimir un entero en lugar de print(n) utilice:

s y s . s t d o u t . w r i t e ( s t r ( n ) + ’ \n ’ )

para imprimir una lista de enteros en lugar de print(*lista) utilice:

s y s . s t d o u t . w r i t e ( ’ ’ . j o i n (map( str , l i s t a ) ) + ’ \n ’ )
46 CapÍtulo 1. El lenguaje Python

1.7. Ejercicios
1. Hallar la distancia entre dos puntos del plano cartesiano. La entrada consisten
en dos lı́neas cada una con dos números que representan las coordenadas (x, y).
Solución:

p1x,p1y=map(int,input().split()) #Primer punto

p2x,p2y=map(int,input().split()) #Segundo punto
distancia=((p1x-p2x)**2+(p1y-p2y)**2)**0.5
print(distancia)

2. Los números cuadrados son los que se obtiene de elevar un número entero al
cuadrado. Se quiere hacer una lista de los últimos dos dı́gitos en los que pueden
terminar.
Solución:

conjunto=set()
for i in range(100):
conjunto.add((i*i)%100)
print(conjunto)

Se ha creado una variable que es un conjunto que almacena los dos últi-
mos dı́gitos. Los conjuntos no admiten números repetidos. el resultado es
:{0, 1, 4, 9, 16, 21, 24, 25, 29, 36, 41, 44, 49, 56, 61, 64, 69, 76, 81, 84, 89, 96}

3. Para hallar el último dı́gito de una potencia de 3, esto es 3x %10, no es necesario

hallar 3x para luego ver el último dı́gito. Es suficiente tener una lista con la
secuencia del último dı́gito de las potencias de 3.
Solución

terminaciones=[]
1.7. Ejercicios 47

p=1
for i in range(10):
p*=3
if (p%10) in terminaciones:
continue
terminaciones.append(p%10)
print(terminaciones)

En este caso en lugar de un conjunto se ha utilizado una lista para mantener el

orden de los números obtenidos. El resultado es: [3, 9, 7, 1]. Para hallar el último
dı́gito de 3x es suficiente hallar x %4. Por ejemplo para x21 se halla 21 %3 = 1
y ası́ se conoce que el último dı́gito es 3.

4. Se tiene el tiempo en segundos y se quiere imprimir el mismo como horas,

minutos y segundos. Por ejemplo sea t = 123456789 segundos. Para conocer
cuantas horas son hay que dividir por 3600 el resto son los segundos que quedan.
Estos segundo hay que dividir por 60 para tener la cantidad de minutos. El
resto son los segundos.

Solución:

t=123456789
horas=t//3600
segundos_restantes=t%3600
minutos=segundos_restantes//60
segundos=segundos_restantes%60
print(f’Horas:{horas},Minutos:{minutos},Segundos:{segundos}’)

5. Dada una cadena obtenga una lista ordenada de todos los caracteres de la
cadena.

Solución
48 CapÍtulo 1. El lenguaje Python

cadena=’esta es una cadena de texto’

conjunto=set()
for i in cadena:
conjunto.add(i)
print(sorted(conjunto))

6. Un acrónimo es una palabra formada por la primera letra de una frase. Por
ejemplo el acrónimo de: memoria de solo lectura es MDSL. Escriba un programa
para hallar el acrónimo de un texto.
Solución:

texto=’memoria de solo lectura’

lista=texto.split()
for i in lista:
print(i[0].upper(),end =’’)

7. Clasifique los objetos en tres grupos, menor a 15, entre 15 y 20, mayor a 20.
Son 10 datos que se ingresan en un ciclo for. Luego se imprimen en tres filas
los datos ingresados. La primera fila son los datos menores a 15. La segunda
los que están entre 15 y 20. Finalmente la tercera con los mayores a 20.

l1=[]
l2=[]
l3=[]
for i in range(10):
n=int(input())
if n<15:
l1.append(n)
elif n>20:
l3.append(n)
else:
1.7. Ejercicios 49

l2.append(n)
print(l1)
print(l2)
print(l3)

8. Escriba un programa que verifique la siguiente identidad para n=15: 2

X (1 + n) ∗ n
in =
i=1
2

n=15
s=0
for i in range(15+1):
s+=i
#por la formula
f=(n+1)*n//2
if s==f:
print(’Iguales’)
else:
print(’No iguales’)
50 CapÍtulo 1. El lenguaje Python
CAPÍTULO 2

JUECES VIRTUALES DE PROGRAMACIÓN

Los jueces virtuales son programas que se utilizan para verificar sin un programa
funciona correctamente. Existen múltiples jueces virtuales donde se puede practicar
la programación y solución de problemas. Algunos de ellos son:

EL juez OnlineJudge (de Valladolid, 2022) es uno de los programas más co-
nocidos y contiene todos los problemas de las competencias mundiales de pro-
gramación. Muchos libros tales como: Competitive Programming 3: The New
Lower Bound of Programming Contests (Halim y Halim, 2013) hacen referencia
a los problemas de este juez.

Topcoder y Codeforces (TopCoder, 2022,Codeforces, 2022) son jueces que tie-

nen mucho apoyo de empresas privadas. Si busca oportunidades más allá de
las competencias de programación esta es una buena opción.

EL juez de la Universidad Mayor de San Andrés es mayormente utilizado en la

enseñanza de la programación (Umsa, 2022).

El juez Juki (Carvajal, 2022) es otro juez construı́do en Bolivia y se utiliza

principalmente para la preparación de competidores tanto de colegio como de
universidad.

51
52 CapÍtulo 2. Jueces virtuales de programación

2.1. Uso de los Jueces Virtuales

Cuando está registrado en un juez virtual ya está en condiciones de enviar solu-

ciones a problemas publicados. La verificación se hace comparando que los resultados
que da su programa son idénticos a los que el juez tiene. Los mensajes comunes que
uno puede obtener son:
Mensaje Significado
Cuando el resultado es diferente al re-
Wrong Answer (WA) sultado que se espera. Significa res-
puesta equivocada.
Este representa un error de formato y
da cuando se quitan todos los espacios
Presentation Error (PE) y la respuesta iguala. Por ejemplo si
se tiene espacios al final del texto o de
cada lı́nea.
Las soluciones algorı́tmicas deben re-
solverse en un tiempo lı́mite dado. Si
su programa demora más de lo estipu-
lado se produce este mensaje de error. Data limit excee
Time Limit Exceeded (TLE)
La solución a este problema general-
mente consiste en buscar un algoritmo
más eficiente. También es necesario ve-
rificar si su programa termina.
Al ejecutarse un programa pueden
darse diversos errores en su ejecución.
Por ejemplo división por cero, tratar
de acceder a una lista más allá de su
Runtime Error (RTE)
tamaño, etc. Estos errores que no se
puede detectar hasta que el programa
ejecute reciben el nombre de errores en
tiempo de corrida.
2.2. Lectura de datos 53

2.2. Lectura de datos

Los datos que su programa debe procesar están almacenados en el servidor donde
se ejecuta el juez. Estos datos no se muestran a los usuarios y deben ser leı́dos por
su programa. Las formas más comunes en las que se presentan los datos son:

La entrada consiste de un número entero.

Ejemplo de datos Programa

4 n=int ( input ( ) )

La entrada consiste de dos números enteros.

Ejemplo de datos Programa

4 5 x , y=map( int , input ( ) . s p l i t ( ) )

La entrada consiste de múltiples casos de prueba. La primera lı́nea contiene

un número que indica el número de casos de prueba. Luego por cada caso de
prueba hay una lı́nea con dos números.
Ejemplo de datos Programa

3 f or c a s o s in
1 2 range ( int ( input ( ) ) ) :
3 4 x , y=map( int , input ( )
5 6 . split ())

La entrada consiste de múltiples casos de prueba. En cada caso de prueba hay

una lı́nea con dos números. La entrada termina cuando lee dos ceros en una
lı́nea.
54 CapÍtulo 2. Jueces virtuales de programación

Ejemplo de datos Programa

import s y s
1 2 f or c a s o s in s y s . s t d i n :
3 4 x , y=map( int , c a s o s . s p l i t ( ) )
5 6 i f x==y==0:
0 0 print ( ’ f i n de d a t o s ’ )
break

La entrada consiste de múltiples casos de prueba. En cada caso de prueba hay

una lı́nea con dos números. La entrada termina cuando no hay más datos. Esto
significa final del archivo.

Ejemplo de datos Programa

import s y s
1 2
f or c a s o s in s y s . s t d i n :
3 4
x , y=map( int , c a s o s . s p l i t ( ) )
5 6
print ( ’ f i n de d a t o s ’ )

En el caso de la lectura de listas se aplica todo lo anterior. Normalmente primero

se pone el número de elementos de la lista y en la siguiente lı́nea la misma.
En Python no se requiere tener primero el número de elementos de la lista, sin
embargo existe porque en otros lenguajes de programación es necesario.

Ejemplo de datos Programa

n=int ( input ( ) )
5
l i s t a =l i s t (map( int ,
1 2 3 4 5
input ( ) . s p l i t ( ) ) )

Una aclaración importante: en los ejemplos se ha considerado que las entradas

son numéricas por eso se incluyó la conversión a variable entera. En caso de
que las entradas son textos no es necesario hacer conversiones.
2.3. Ejercicio 55

Con relación al proceso por cada caso de prueba se debe escribir el resultado
solicitado. No se guardan los resultados para imprimir al final.

2.2.1. Ejemplo
Los casos de prueba consisten de un número y una lista terminan cuando no hay
más datos, es decir fin de archivo.
Ejemplo de datos Programa

from s y s import s t d i n
5
f or l i n e a in s t d i n :
1 2 3 4 5
n=int ( l i n e a )
4
l i s t a =l i s t (map( int ,
1 2 3 4
stdin . readline ( ) . s p l i t ()))
Cuando realizamos el ciclo for se lee el número n, para leer la lista es necesario
leer la lı́nea siguiente de stdin. No debe mezclarse flujos de entrada estandard con
instrucciones input. En un proceso interactivo con el teclado puede funcionar pero
no ası́ cuando la lectura viene de otro lugar tal como puede ser un archivo de disco.

2.3. Ejercicio
Un ejercicio tı́pico tiene la siguiente estructura:

Enunciado

Le dan una lista de números y se pide que imprima el promedio con dos decimales

Entrada

La primera lı́nea tiene un número (1 ≤ n ≤ 100) que representa cuantos casos de

prueba hay.
Cada caso de prueba comienza con un número (1 ≤ k ≤ 103 ) que indica la
cantidad de números que tiene el caso de prueba.
56 CapÍtulo 2. Jueces virtuales de programación

Luego sigue una lı́nea con k números separados por un espacio.

Salida

Por cada caso de prueba escriba en la salida una lı́nea con el promedio con dos
decimales

Ejemplo de entrada

2
3
10 15 7
4
6 2 8 6

Ejemplo de salida

10.67
5.50

Explicación del problema

Las partes de las que consiste el problema son:

Enunciado.- Describe lo que se debe programar.

Entrada.- Describe como se presentan los datos que hay que leer. Los rangos
de los números que se dan tiene la finalidad de que usted pueda escoger una
solución que para el número máximo de datos a procesar resuelva el problema
en un tiempo razonable.

Salida.- Describe como se mostrará la salida

Ejemplo de entrada.- Es un ejemplo de como están los datos de entrada. Nos

ayuda a comprender mejor la descripción de la entrada
2.3. Ejercicio 57

Ejemplo de Salida.- Muestra como debe mostrarse los resultado.

Los problemas se resuelven caso por caso. Se lee un caso de prueba y se imprime
el resultado del mismo.
Para ejemplo, primero hay que leer el número de casos de prueba. Por cada caso
de prueba leer, procesar y mostrar los resultados.

casos =int(input())
for i in range(casos):
#procesar los casos de prueba
#mostrar los resultados

Para cada caso de prueba nos indican que hay que leer una lı́nea con la cantidad
de números que tiene el caso de prueba. Luego una segunda lı́nea con los números
separados por un espacio.

casos =int(input())
for i in range(casos):
#procesar los casos de prueba
#mostrar los resultados

El resultado, que es el promedio, se halla con dividir la suma entre la cantidad

de números.

casos =int(input())
for i in range(casos):
#procesar los casos de prueba
k=int(input())
numeros=list(map(int,input().split()))
#mostrar los resultados
print(f’{sum(numeros)/k:.2f}’)
58 CapÍtulo 2. Jueces virtuales de programación
CAPÍTULO 3
FUNCIONES DEFINIDAS POR EL USUARIO

Una función es un bloque de código con un nombre asociado, que recibe cero o
más argumentos como entrada, sigue una secuencia de instrucciones, la cuales ejecuta
y devuelve un valor y/o realiza una tarea. Este bloque puede ser llamado cuando se
necesite.
Las de funciones tienen los siguientes propósitos

Modularización: permite segmentar un programa complejo en una serie de par-

tes o módulos más simples, facilitando ası́ la programación y la depuración del
código.

Reutilización: permite crear funciones definidas por el usuario para reutilizar

una misma función en distintos programas.

Eliminar el código repetido

3.1. Definición
La sentencia def es una definición de función usada para crear funciones definidas
por el usuario.

59
60 CapÍtulo 3. Funciones definidas por el usuario

Una definición de función es una sentencia ejecutable. Su ejecución enlaza el

nombre de la función y queda definida para ser usado cuando la función es llamada.
La definición de función no ejecuta el cuerpo de la función; esto es ejecutado
solamente cuando la función es llamada.
La sintaxis para una definición de función en Python es:

def Nombre ( parametros ) :

’ ’ ’DOCSTRING ’ ’ ’
instrucciones
return e x p r e s i o n

Donde:

Nombre, es el nombre de la función.

Parámetros, es la lista de parámetros que puede recibir una función.

DOCSTRING, es la cadena de caracteres usada para documentar la función.

Instrucciones, es el bloque de instrucciones en código fuente Python para rea-

lizar cierta operación.

return, es la instrucción para devolver resultados.

Expresión, es la expresión o variable que devuelve la sentencia return.

Como ejemplo se muestra una función que devuelve la parte entera después de
hallar la raı́z cuadrada.

def r a i z E n t e r a ( x ) :
’ ’ ’ Funcion que h a l l a l a r a i z cuadrada
y d e v u e l v e l a p a r t e e n t r a redondeada
al entero superior ’ ’ ’
r=int ( x ∗∗0.5)+1
return r
3.2. Argumentos y parámetros 61

Advertencia: Los bloques de función deben estar indentados como otros bloques
estructuras de control. En esta función:

raizEntera, es el nombre de la función.

x, es el parámetro que puede recibir la función.

La cadena de caracteres usada para documentar la función está entre tres

apóstrofes.

Sigue las instrucciones para realizar lo especificado.

return devuelve el resultado.

El uso de esta función se hace invocando el nombre:

raizEntera (10)
#e l r e s u l t a d o e s 4
Las variables definidas en las funciones se consideran variables locales. No es
posible asignar valores directamente a variables definidas fuera de la función. Los
parámetros (argumentos) se definen como variables locales.

3.2. Argumentos y parámetros

3.2.1. Argumentos por posición
Cuando envı́a argumentos a una función , estos se reciben por orden en los
parámetros definidos. Se dice por tanto que son argumentos por posición, como ejem-
plo vea la función que devuelve el resultado de restar dos números:
def r e s t a ( a , b ) :
return a − b
Al invocar la función resta(30, 10) se envı́an los valores 30 y 10, el argumento 30
es la posición 0 por consiguiente es el parámetro de la función a, seguidamente el
argumento 10 es la posición 1 por consiguiente es el parámetro de la función b.
62 CapÍtulo 3. Funciones definidas por el usuario

3.2.2. Argumentos por nombre

Sin embargo es posible evadir el orden de los parámetros si indica durante la
llamada que valor tiene cada parámetro a partir de su nombre. En el ejemplo se
puede llamar resta(b=10,a=30). En este caso hace igualar los nombres indicados en
la definición.

3.2.3. Sin argumentos

Una función puede no tener argumentos, sin embargo, al momento de llamar una
función la cual tiene definidos unos parámetros, si no pasa los argumentos correcta-
mente provocará una excepción de tipo TypeError:

>>> resta()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: resta() takes exactly 2 arguments (0 given)

EL error indica que se invocó una función con el número de argumentos equivo-
cados, y que requiere exactamente 2.

3.2.4. Parámetros por omisión

Para solucionar la excepción TypeError ejecutada al momento de la llamada a
una función sin argumentos, entonces usted puede asignar unos valores por omisión
a los parámetros, de esa forma puede hacer una comprobación antes de ejecutar el
código de la función:

def r e s t a ( a=0, b =0):

return a−b

En este ejemplo si no se pone un argumento tomará el valor por omisión, por ejemplo
si se invoca resta(10) los valores que toma la función son a = 10, b = 0. También es
posible poner llamar con resta(b=10), en este caso a toma el valor de 0.
3.3. Instrucción return 63

3.2.5. Número variable de argumentos

En algunos casos es necesario que la función pueda recibir un número variable de
argumentos. Para estos casos se coloca un asterisco en el nombre del parámetro. Por
convención se utiliza el nombre args.

def f(*args):
return sum(args)

En éste ejemplo se tiene una función que recibe múltiples argumentos e imprime
la suma de los mismos. El llamado a la función con f (1, 2, 3, 4) devuelve 10.
Los parámetros son pasados a la función como una tupla. El siguiente código
muestra como recibe una lista pasada como un parámetro:

def f(*args):
print(args)
return None
l=[1,2,3,4]
f(l)

El resultado es:

([1, 2, 3,4],)

Para que la lista se pase como elementos individuales es necesario colocar un

asterisco delante de la variable como sigue:

f(*l)

3.3. Instrucción return

Las funciones pueden comunicarse con el exterior de las mismas, al proceso prin-
cipal del programa usando la sentencia return. El proceso de comunicación con el
exterior se hace devolviendo valores.
64 CapÍtulo 3. Funciones definidas por el usuario

La instrucción return es opcional. Si no se devuelve un resultado el valor por

omisión es None.
Para devolver múltiples valores, por ejemplo en una división devolver resto y
cociente, los valores a devolver deben recibirse en una estructura de datos apropiada.
def d i v i d e ( a , b ) :
r e s t o=a %b
c o c i e n t e=a //b
return c o c i e n t e , r e s t o
La llamada debe tener 2 parámetros divide(10,3) y el resultado debe almacenarse
en dos variables dado que devuelve dos variables.
a , b=d i v i d e ( 1 0 , 3 )

3.4. Variables locales y globales

Las variable que se definen en un función solo son visibles en el ámbito de la
función, por ejemplo:
def f (x ) :
y=x+a
return y
a=3
print ( f (5))
La variable a no es directamente accesible en la función f (x) porque ha sido
definida fuera de la función y la variable y no puede accederse fuera de la función
porque ha sido definida en la función.
Para hacer visible la variable en la función se utiliza la instrucción global :
def f (x ) :
global a
y=x+a
return y
3.5. Ejemplo 65

a=3
print ( f (5))

En ningún caso la variable local y definida en la función se puede hacer visible

en el resto del código.
Para invocar una función definida por el usuario es suficiente llamarla de la misma
forma que las funciones del sistema. Vea en el ejemplo anterior como se llamó a la
función f en la instrucción print.

3.5. Ejemplo
Escriba una función para hallar la suma de una serie aritmética entre 1 y n.
Primero debemos recordar la fórmula de la suma:

n(1 + n)
suma =
2

Ahora es posible escribir la función:

def f (x ) :
r e t u r n n∗(1+n ) / / 2

3.6. Acoplamiento y Cohesión

Estos son parte de los principios de diseño. Cuando se habla de acoplamiento se
quiere decir que trata de reducir las dependencias entre diferentes partes del código.
Cohesión se refiere a cuantas cosas realiza el código. Aún cuando este término se
utiliza en programación orientada a objetos también se utiliza en funciones porque
es necesario pensar cuales son las responsabilidades de una función. Lo que se quiere
es reducir el número de cosas que hace una función porque hace más difı́cil probar
que sea correcta.
Como recomendación para comenzar puede aplicar estos principios separando el
código en múltiples funciones y escribir pruebas para cada una de ellas. Dividir el
66 CapÍtulo 3. Funciones definidas por el usuario

código hará siempre más fácil probar que funcione correctamente.

3.7. Funciones puras

Cuando la función no depende de valores externos tales como, números aleatorios,
la fecha, etc. se llama función pura . Una función que no cumple esta caracterı́stica
puede tener efectos colaterales. Analice el siguiente programa:

from d a t e t i m e import d a t e t i m e

def s a l u d a r ( nombre ) :
h o r a A c t u a l = d a t e t i m e . now ( )
i f h o r a A c t u a l . hour < 1 2 :
s a l u d o = ”Buen d i a ”
e l i f 12 <= h o r a A c t u a l . hour < 1 8 :
s a l u d o = ” Buenas t a r d e s ”
else :
s a l u d o = ” Buenas noches ”
print ( f ’ { s a l u d o } {nombre} ’ )

def s a l u d o L i s t a ( nombres ) :
f or nombre in nombres :
s a l u d a r ( nombre )

def leerNonmbre ( ) −> s t r :

return input ( ” I n g r e s e su nombre : ” )

def main ( ) :
s a l u d a r ( leerNonmbre ( ) )
s a l u d o L i s t a ( [ ” Juan ” , ” Maria ” , ” J o s e ” ] )
3.7. Funciones puras 67

main ( )

Este programa pide un nombre por pantalla y luego imprime un mensaje que
depende de la hora. Luego Hace lo mismo con una lista de nombres. ¿Que problemas
podemos encontrar en este programa?
Primero la función armar saludos no depende exclusivamente del parámetro nom-
bre, también depende de la hora. Esto causa dificultades a la hora de probar el código
dado que para un mismo parámetro la respuesta puede ser diferente. Lo que se busca
siempre es:

MISMOS PARAMETROS DE ENTRADA MISMO RESULTADO

El primer arreglo que se debe hacer es quitar esta dependencia en la función

armarSaludo. Para lograr esto quitamos la parte que utiliza la fecha y la llevaremos
a la función main.

from d a t e t i m e import d a t e t i m e

def s a l u d a r ( s a l u d o , nombre ) :
print ( f ’ { s a l u d o } {nombre} ’ )

def s a l u d o L i s t a ( s a l u d o , nombres ) :
f or nombre in nombres :
s a l u d a r ( s a l u d o , nombre )

def leerNonmbre ( ) −> s t r :

return input ( ” I n g r e s e su nombre : ” )

def main ( ) :
h o r a A c t u a l = d a t e t i m e . now ( )
i f h o r a A c t u a l . hour < 1 2 :
s a l u d o = ”Buen d i a ”
e l i f 12 <= h o r a A c t u a l . hour < 1 8 :
68 CapÍtulo 3. Funciones definidas por el usuario

s a l u d o = ” Buenas t a r d e s ”
else :
s a l u d o = ” Buenas noches ”
s a l u d a r ( s a l u d o , leerNonmbre ( ) )
s a l u d o L i s t a ( s a l u d o , [ ” Juan ” , ” Maria ” , ” J o s e ” ] )

main ( )

Una segunda dependencia que se va ha quitar es la función de imprimir. Esto

para facilitar la modificación de la salida, por ejemplo si fuera un archivo, salida a
Internet, base de datos, etc. Como la función saludoLista tiene una dependencia con
saludar para imprimir el saludo es necesario cambiar la misma para retornar todos
los saludos. La impresión está en la función main.

from d a t e t i m e import d a t e t i m e

def s a l u d a r ( s a l u d o , nombre ) :
return f ’ { s a l u d o } {nombre} ’

def s a l u d o L i s t a ( s a l u d o , nombres ) :
return [ s a l u d a r ( s a l u d o , nombre ) f or nombre in nombres ]

def leerNonmbre ( ) −> s t r :

return input ( ” I n g r e s e su nombre : ” )

def main ( ) :
h o r a A c t u a l = d a t e t i m e . now ( )
i f h o r a A c t u a l . hour < 1 2 :
s a l u d o = ”Buen d i a ”
e l i f 12 <= h o r a A c t u a l . hour < 1 8 :
s a l u d o = ” Buenas t a r d e s ”
else :
3.7. Funciones puras 69

s a l u d o = ” Buenas noches ”
nombres =[” Juan ” , ” Maria ” , ” J o s e ” ]
print ( s a l u d a r ( s a l u d o , leerNonmbre ( ) ) )
print ( ”\n” . j o i n ( s a l u d o L i s t a ( s a l u d o , nombres ) ) )

main ( )

Aún hay varias deficiencias, primero no es posible probar el saludo en forma

independiente, por lo que es necesario llevar el saludo a una función separada

from d a t e t i m e import d a t e t i m e

def s a l u d a r ( s a l u d o , nombre ) :
return f ’ { s a l u d o } {nombre} ’

def s a l u d o L i s t a ( s a l u d o , nombres ) :
return [ s a l u d a r ( s a l u d o , nombre ) f or nombre in nombres ]

def leerNonmbre ( ) −> s t r :

return input ( ” I n g r e s e su nombre : ” )

def armarSaludo ( ) :
h o r a A c t u a l = d a t e t i m e . now ( )
i f h o r a A c t u a l . hour < 1 2 :
s a l u d o = ”Buen d i a ”
e l i f 12 <= h o r a A c t u a l . hour < 1 8 :
s a l u d o = ” Buenas t a r d e s ”
else :
s a l u d o = ” Buenas noches ”
return s a l u d o
def main ( ) :
nombres =[” Juan ” , ” Maria ” , ” J o s e ” ]
70 CapÍtulo 3. Funciones definidas por el usuario

s a l u d o=armarSaludo ( )
print ( s a l u d a r ( s a l u d o , leerNonmbre ( ) ) )
print ( ”\n” . j o i n ( s a l u d o L i s t a ( s a l u d o , nombres ) ) )
main ( )
A diferencia de funciones con efectos colaterales la funciones puras son fáciles de
probar y más fáciles de utilizar en diferentes partes del programa. Un principio es
colocar todos los efectos colaterales en un solo lugar. Esto hace que cualquier efecto
este en un solo lugar.

3.8. Funciones recursivas

Las técnicas de programación basadas en ciclos se denominan programas itera-
tivos. Los programas que describen acciones repetitivas basadas en llamarse a si
mismo, se denominan programas recursivos .
Los problemas recursivos los representamos con ecuaciones de recurrencia, y los
programas recursivos deben tener dos partes:

Caso base El caso base debe ser tan simple que puede ser resuelto sin
una llamada recursiva.
Caso recursivo El caso recursivo involucra convertir el problema a otro
más simple que puede ser resuelto por una llamada recursiva, es decir
llamándose a si mismo.

El caso base es el que termina el proceso recursivo. Algunos problemas involucran

múltiples casos base y recursivos, sin embargo, debe existir al menos uno de cada
caso. Para escribir programas recursivos existe un modelo general, que se muestra en
el algoritmo:

def funcion(parametros):
if (parametros = algunValor):
caso base que termina la recursión
.........
3.8. Funciones recursivas 71

else
caso recursivo \
.........

Las funciones recursivas son similares a la inducción matemática. Primero necesita

conocer como resolver un caso base, para n = 0, n = 1. Luego asumiendo que conoce
como construir un problema de tamaño n−1, se busca un modo de obtener la solución
de tamaño n a partir de la solución de tamaño n − 1.
Para resolver un problema recursivo se sugiere:

Definir un problema en base a un problema similar y más pequeño.

Describir como cada recursión reduce el tamaño del problema.

Definir la instancia del problema que puede servir como caso base.

Verificar que, a medida que el problema disminuye se puede llegar al caso base.

3.8.1. Cálculo del factorial

Utilizando éste ejemplo sencillo se muestra como se construye un programa recur-
sivo. Consideremos el problema de hallar el factorial. Matemáticamente se lo escribe
con una ecuación de recurrencia como sigue:
(
1 si n = 0
f actorial(n) = (3.1)
n ∗ f actorial(n − 1) si n > 0

Como se ve en la definición existe un caso base, que es cuando n = 0. El caso

recursivo simplifica el problema reduciendo el tamaño, esto es, reducir n en uno. El
código es básicamente una copia de la definición matemática.
def f a c t o r i a l ( n ) : #d e f i n i c i o n de l a f u n c i o n
i f n==0: return 1 # Caso b a s e
return n∗ f a c t o r i a l ( n−1) #c aso r e c u r s i v o
72 CapÍtulo 3. Funciones definidas por el usuario

Para probar esta función calcule el factorial de 5 con el siguiente código:

a=f a c t o r i a l ( 5 )
print ( a )

3.9. Ejemplo de un árbol binario

Un árbol binario es una estructura donde se crea un nodo denominado raı́z. Los
demás elementos se denominan hijos de la raı́z. La caracterı́stica es que cada nodo
solo tiene dos nodos dependientes denominados hijos. Un ejemplo es el siguiente:
15

7 20

4 9 18 25

24 27
EL nodo raı́z es 15, y tiene dos hijos el 7 a la izquierda y el 20 a la derecha. La
caracterı́stica es que el nodo de la izquierda es menor que el de la derecha. Lo mismo
se repite a medida que se desciende en el árbol. El 7 tiene dos hijos el 4 a la izquierda
y el 9 a la derecha.
Para construir este árbol primero se creará una función que permita crear un
árbol vacı́o:
def arbol():
return None
Ahora es necesario crear una función para insertar valores al árbol. El árbol se
divide en tres partes. La raı́z, también llamado nodo padre, el hijo izquierdo y el hijo
derecho. Cuando está vacı́o el valor a insertar es la raı́z y debe estar al centro y los
hijos izquierdo y derecho quedan en blanco, representados por None.
La representación es una tupla con tres valores: (N one, valorInsertar, N one) que
formará el nuevo árbol. Ahora si no es el primer nodo es necesario preguntar si se
colocará a la derecha o a la izquierda para devolver un nuevo árbol.
3.9. Ejemplo de un árbol binario 73

def insertar(arbol, valorInsertar):

if arbol==None: # arbol vacio
return (None, valorInsertar, None)
elif valorInsertar<arbol[1]: # Es el hijo izquierdo
return (insertar(arbol[0],valorInsertar),arbol[1],arbol[2])
elif valorInsertar>arbol[1]: # Es el hijo derecha
return (arbol[0],arbol[1],insertar(arbol[2],valorInsertar))
else:
return arbol

Insertando los valores del ejemplo veamos como va cambiando el árbol:

A=arbol()
A=insertar(A, 15)
A=insertar(A, 7)
A=insertar(A, 4)
A=insertar(A, 9)
A= insertar(A, 20)
A= insertar(A, 18)
A= insertar(A, 25)
A= insertar(A, 24)
A= insertar(A, 27)

El resultado después de insertar el 15 es:

(None, 15, None)

Cuando se inserte el 7 se crea una nueva tupla al lado izquierdo:

((None, 7, None), 15, None)

Cuando se inserta una nueva tupla al 20 al lado derecho. Esto se repite hasta
tener todos los valores ingresados. El estado final de la variable A es:
74 CapÍtulo 3. Funciones definidas por el usuario

(((None,4,None),7,(None,9,None)),15,((None,18,None),20,
((None,24,None),25,(None,27,None))))

Ahora lo que queda es buscar si un valor existe o no. Para esto se utilice la
misma estrategia que para insertar. Cuando es vacı́o es no existe, y en los otros casos
se repite recursivamente para el hijo izquierdo o para el hijo derecho. El código es
como sigue:

def buscar(A, valorBuscar):

if A==None:
return False
elif valorBuscar==A[1]:
return True
elif valorBuscar<A[1]:
return buscar(A[0], valorBuscar)
else:
return buscar(A[2], valorBuscar)

Las siguientes búsquedas dan los resultados True y False respectivamente:

print (buscar(A, 18))

print (buscar(A, 3))
CAPÍTULO 4

INTRODUCCIÓN INFORMAL A LA COMPLEJIDAD

ALGORÍTMICA

La eficiencia de los algoritmos juega un rol importante en el análisis de los al-

goritmo. La complejidad del tiempo estima cuanto va ha demorar un algoritmos en
función de un conjunto de tamaños n en los datos de entrada. Esta complejidad se
representa con una O(. . .). Se denomina notación O grande.

4.1. Reglas para el cálculo

1. Si un programa consiste de comandos simples su tiempo de proceso se considera
O(1)
a=2
b=3
c=a+b

Esto significa que el tiempo es constante.

2. La complejidad de un ciclo es el número de veces que el código que se encuentra

en el interior del ciclo se ejecuta. Para el siguiente ejemplo considere que ′ . . .′

75
76 CapÍtulo 4. Introducción informal a la complejidad AlgorÍtmica

es el código que se ejecuta en el interior del ciclo toma un tiempo O(1), es decir
constante. Su tiempo de proceso se considera O(n).
f or i in range ( n ) :
......

3. La complejidad del siguiente código es O(n2 )

f or i in range ( n ) :
f or j in range ( n ) :
......

El primer ciclo toma un tiempo O(n) el segundo depende del primero y también
toma un tiempo O(n)dando un tiempo total de n∗n = n2 En general si tenemos
k ciclos anidados la complejidad es O(nk ).

4. Si el código consiste de diferentes fases, por ejemplo en el código siguiente la

primera fase es O(n) la segunda O(n2 ) y la tercera O(n) solo se considera la
fase que tiene una complejidad mayor.
f or i in range ( n ) :
......

f or i in range ( n ) :
f or j in range ( n ) :
......

f or i in range ( n ) :
......

5. A veces el código depende de diferentes factores, en el ejemplo la complejidad

es O(nm).
f or i in range ( n ) :
f or j in range (m) :
4.2. Algunas complejidades comunes 77

......

6. Considere el siguiente programa:

def g ( n ) :
i f n==1: return
g ( n−1)
g ( n−1)

Cuando la función se llama la primera vez con el parámetro n hay 2 con el

parámetro g(n − 1), después 4 y ası́ sucesivamente. La complejidad viene dada
como:
1 + 2 + 4 + . . . + 2n−1 = 2n − 1 = O(2n )

7. En el caso de que el tamaño se reduce a la mitad en cada iteración, por ejemplo:

def g ( n ) :
i f n==1: return
g (n//2)

se tiene:
n n n
n+ + + · · · + k = log(n) = O(log(n)
2 4 2
En este caso k es el número de iteraciones para llegar al caso base.

4.2. Algunas complejidades comunes

Las siguientes son algunas complejidades que se presentan con más frecuencia:

Funciones constantes, f (n) = 1, por ejemplo miden el costo de sumar dos

números, y en general no dependen del tamaño de n.

Funciones logarı́tmicas, f (n) = log n, aparece por ejemplo en la búsqueda bi-

naria.
78 CapÍtulo 4. Introducción informal a la complejidad AlgorÍtmica

Funciones lineales,f (n) = n, estas funciones aparecen cuando en un vector

accedemos a un mismo elemento solo una o dos veces, por ejemplo hallar el
mı́nimo, máximo, promedio, etc.

Funciones superlineales,f (n) = n log n, estas funciones aparecen en mergesort,

qsort y otros. Crecen un poco más rápido que las lineales.

Funciones cuadráticas,f (n) = n2 , aparecen por ejemplo en ver todos los pares
de ı́tems de un vector.

Funciones cúbicas,f (n) = n3

Funciones exponenciales,f (n) = cn , estas funciones aparecen por ejemplo al

enumerar todos los subconjuntos de n elementos.

Funciones factoriales,f (n) = n!, Considere hallar todas las permutaciones de

n elementos.

4.3. Estimación de la eficiencia

Para estimar la eficiencia puede suponer que en Python en 1 segundo puede
ejecutar 107 operaciones elementales. Esto significa que si n = 108 y la complejidad
es O(n) demorará cerca de 10 segundos. La siguiente tabla muestra la complejidad
del programa que hay que buscar en función del tamaño de n.
Tamaño de n Complejidad máxima esperada
n ≤ 10 O(n!)
n ≤ 20 O(2n )
n ≤ 500 O(n3 )
n ≤ 5000 O(n3 )
n ≤ 106 O(n) o O(n(log n))
n es grande O(1) o O(log n)
 SIGLAS

IMO International Mathematics Olympiad 76

IOI International Olympiad in Informatics 76

JIT Compilar justo a tiempo 76

mcd Máximo común divisor 76

mcm Mı́nimo común múltiplo 76

79
80 Siglas
 BIBLIOGRAFÍA

Carvajal, O. G. (2022). Juki Judge. Recuperado desde https://judge.juki.app/

Codeforces. (2022). Codeforces. Recuperado desde https://codeforces.com/
de Valladolid, U. (2022). Online judge. Recuperado desde https://onlinejudge.org/
Halim, S. & Halim, F. (2013). Competitive Programming 3: The New Lower Bound
of Programming Contests (3rd). Lulu.
TopCoder. (2022). Top Coder. Recuperado desde https://www.topcoder.com/home
Umsa. (2022). Juez de Informtica. Recuperado desde https://jv.umsa.bo/

81
82 BibliografÍa
 ÍNDICE ALFABÉTICO

acoplamiento, 63 eficiencia, 73
alı́as, 22, 24 cuadrático, 74
Anaconda, 7 estimación, 76
and, 32 logarı́tmica, 75
reglas de cálculo, 73
break, 39 tiempo constante, 73
entorno de desarrollo, 7
cadenas, 14
entrada de datos, 24
ciclo
entrada eficiente, 43
else, 40
for, 37 factorial, 69
while, 36 ecuación de recurrencia, 69
cohesión, 63 función, 57
comentarios, 10 argumentos, 59
complejidades comunes, 75 argumentos variables, 61
constantes, 10 return, 61
continue, 40 sintaxis, 58
control de flujo, 32 valores por omisión, 60
convertir de un tipo a otro, 18 función pura, 64
corte, 22 función recursiva, 68
funciones incorporadas, 27
datos no escalares, 13 funciones para datos compuestos, 21

83
84 Índice alfabético

funciones trigonométricas, 30 precisión de operaciones numéricas, 17

Pycharm, 7
herramientas, 6
Python, 5
if, 32
salida de datos
else, 32
formato, 26
indentación, 34
salida de datos por consola, 26
jueces virtuales, 49 salida eficiente, 43
lectura de datos, 51 semántica, 9
uso, 50
tiempo de proceso, 41
Jupyter lab, 8
tipos datos, 11
librerı́a time, 31 tipos de lenguajes, 11
librerı́as, 28 tuplas, 13
math, 29
variables, 9
list comprehension, 42
variables globales, 62
listas, 13
variables locales, 62
mutabilidad, 23

not, 32

operaciones con datos escalares , 14

operaciones con datos no escalares, 20
operaciones con listas, 20
operador de pertinencia, 35
operador ternario, 35
operadores de comparación, 34
operadores lógicos, 31
operadores para cadenas, 20
or, 32

palabras reservadas, 10
pip, 7