UNIVERSIDAD DE CARABOBO

FACULTAD DE INGENIERÍA
DEPARTAMENTO DE COMPUTACIÓN
CÁTEDRA DE COMPUTACIÓN I

Fundamentos de Programación
Con aplicaciones en la Ingeniería

MSc. Ing. Alejandro Bolívar

2023
FUNDAMENTOS DE PROGRAMACIÓN
Con aplicaciones en la Ingeniería
Libro de estudio de la asignatura Computación I.
Fundamentos de Programación con Aplicaciones a la Ingeniería © 2023 by Alejandro
Bolívar is licensed under CC BY-NC 4.0
Se permite la copia, uso y distribución de este ejemplar, bajo los términos
de la licencia Creative Commons Atribución 4.0.
 Tabla de contenido
Tabla de contenido ......................................................................................................... 2
1 Unidad I. Fases en la resolución de problemas .............................................................. 6
Análisis del Problema .............................................................................................. 7
Diseño del algoritmo ................................................................................................ 9
Codificación de un programa ................................................................................... 9
Compilación y ejecución de un programa ............................................................. 10
Verificación y depuración de un programa ............................................................ 10
Documentación y mantenimiento .......................................................................... 11
Unidad II. Conceptos básicos de programación ........................................................... 13
La computadora ..................................................................................................... 13
¿Cómo maneja la información un computador? .................................................... 13
Unidades de medida de la información almacenada. ............................................. 15
Partes del computador ............................................................................................ 16
Algoritmo. .............................................................................................................. 20
Representación gráfica de los algoritmos .............................................................. 25
Programas y Programación .................................................................................... 28
Unidad III. El lenguaje de Programación ..................................................................... 32
Lenguaje de Programación Python ........................................................................ 32
Características de Python ....................................................................................... 33
Ventajas ................................................................................................................. 33
Desventajas ............................................................................................................ 34
Instalación de Python ............................................................................................. 34
Depuración ............................................................................................................. 35
Tipos de Datos ....................................................................................................... 36
Elementos Básicos del Lenguaje ........................................................................... 44
Operadores ............................................................................................................. 49
Funciones predefinidas ....................................................................................... 63
Módulos Estándar ............................................................................................... 65
Entornos de desarrollo ........................................................................................ 69
Manejo de datos ................................................................................................. 76
Glosario .............................................................................................................. 80
Ejercicios Resueltos de Estructura Secuencial ................................................... 83
Unidad IV. Estructuras de Control ............................................................................... 98
Control de flujo de datos ........................................................................................ 98
Sangría ................................................................................................................... 98
Estructuras Selectivas ............................................................................................ 99
Ejercicios Resueltos con estructuras condicionales ............................................. 103
Estructuras Repetitivas ........................................................................................ 107
Herramientas de programación ............................................................................ 115
Secuencias y Series .............................................................................................. 118
Composición y descomposición de un número. .................................................. 125
Glosario ................................................................................................................ 129
Resumen ........................................................................................................... 129
Recomendaciones para la escritura de código limpio. ..................................... 130
 Referencias ................................................................................................................. 135

3
 Introducción

Este libro es el producto de la intención de proporcionar a los estudiantes del tercer y

cuarto semestre de la Facultad de Ingeniería de la Universidad de Carabobo, en la asignatura
Computación I del Departamento de Computación una comprensión sólida y completa de los
conceptos fundamentales de la programación enfocado en la resolución de problemas
mediante el computador. Partiendo desde la lógica de programación, el estudiante aprenderá
a desarrollar algoritmos eficientes y efectivos para resolver problemas complejos en un
lenguaje de programación. Además, se abordan temas esenciales como el control de flujo,
las estructuras de datos, el diseño modular, y la depuración de código.

Este texto representa una guía detallada y accesible para desarrollar habilidades en
una de las disciplinas más relevantes e influyentes de nuestro tiempo. Espero que este libro
proporcione la base necesaria para avanzar en su formación como programador, así como
también permitirle desarrollar soluciones tecnológicas innovadoras e impactantes.

En el contenido se abarca los temas de resolución de problemas mediante el uso del

computador, la computadora y sus partes, seguidamente una introducción del lenguaje de
programación Python para poner en práctica los conocimientos de programación, y
finalmente las estructuras condicionales.

En https://github.com/alejandrobolivar/compu-I puede encontrarse el código de

algunos ejemplos.
 Unidad 1
Análisis de un problema
Los problemas se resolverán implementando tres etapas: La entrada
definida por la pregunta: ¿qué se conoce?, el proceso dándole respuesta a
¿cómo lograrlo? Y la salida especificando ¿qué se quiere?
 Objetivos de la unidad:
• Estudiar los conceptos básicos de computación.
• Conocer las unidades de medidas de almacenamiento de la información
• Estudiar las fases de resolución de problemas en computadora.

1 Unidad I. Fases en la resolución de problemas

La resolución de un problema en computadora inicia con comprender el
planteamiento del problema y luego realizar la escritura de un programa y su ejecución en la
misma.
Las características más sobresalientes de la resolución de problemas son [1]:
a) Análisis. El problema se analiza teniendo presente la especificación de los
requisitos dados por el cliente de la empresa o por la persona que encarga el
programa.
b) Diseño. Una vez analizado el problema, se diseña una solución que conducirá a
un algoritmo que resuelva el problema.
c) Codificación (implementación). La solución se escribe en la sintaxis del lenguaje
de alto nivel (por ejemplo, Pascal) y se obtiene un programa fuente que se compila
a continuación.
d) Ejecución, verificación y depuración. El programa se ejecuta, se comprueba
rigurosamente y se eliminan todos los errores (denominados “bugs”, en inglés)
que puedan aparecer.
e) Mantenimiento. El programa se actualiza y modifica, cada vez que sea necesario,
de modo que se cumplan todas las necesidades de cambio de sus usuarios.
f) Documentación. Escritura de las diferentes fases del ciclo de vida del software,
esencialmente el análisis, diseño y codificación, unidos a manuales de usuario y
de referencia, así como normas para el mantenimiento.
Las dos primeras fases conducen a un diseño detallado escrito en forma de algoritmo.
Durante la tercera fase (codificación) se implementa el algoritmo en un código escrito en un
lenguaje de programación, reflejando las ideas desarrolladas en las fases de análisis y diseño.
Las fases de compilación y ejecución traducen y ejecutan el programa. En las fases
de verificación y depuración el programador busca errores de las etapas anteriores y los
elimina (ver Figura 1-1). Comprobará que mientras más tiempo se gaste en la fase de análisis
y diseño, menos se gastará en la depuración del programa. Por último, se debe realizar la
documentación del programa.
 Figura 1-1. El proceso de resolución de problemas e implementación de un
programa que lo resuelve [2].
Antes de conocer las tareas a realizar en cada fase, se considera el concepto y
significado de la palabra algoritmo. La palabra algoritmo se deriva de la traducción al latín
de la palabra Alkhô-warîzmi2, nombre de un matemático y astrónomo árabe que escribió un
tratado sobre manipulación de números y ecuaciones en el siglo IX. Un algoritmo es un
método para resolver un problema mediante una serie de pasos precisos, definidos y finitos.
Ejemplos de algoritmos son: instrucciones para montar en una bicicleta, hacer una
receta de cocina, obtener el máximo común divisor de dos números, etc. Los algoritmos se
pueden expresar por fórmulas, diagramas de flujo o N-S y pseudocódigos. Esta última
representación es la más utilizada para su uso con lenguajes estructurados como Pascal.

Análisis del Problema

El proceso de Análisis consiste en la división de un todo en sus partes. En este caso,
el todo es el problema planteado en forma de enunciado, pero ¿en cuales partes debe dividirse
como resultado del análisis? Inicialmente, el enunciado del problema se debe dividir en dos
partes, las cuales se obtienen al responder las siguientes preguntas:
1. ¿Qué información útil se suministra dentro del enunciado?
2. ¿Qué resultados exige el enunciado?
Ejemplo: Dadas las longitudes de la base y la altura de un triángulo isósceles,
determine el área que encierra el triángulo.
1. ¿Qué información útil se suministra dentro del enunciado?
a. La longitud de la Base
b. La longitud de la altura
c. El hecho que el triángulo es isósceles IRRELEVANTE
2. ¿Qué resultados exige el enunciado?
a. El área encerrada por el triángulo

7
 La información de que el triángulo es isósceles es irrelevante para la solución del
problema, ya que, si se conoce la longitud de la base y altura de un triángulo, no importa su
forma, ya que la fórmula de cálculo requiere solamente estas longitudes.
Ejemplo: Dado las longitudes de los catetos de un triángulo rectángulo, determine la
longitud de la hipotenusa.
1. ¿Qué información útil se suministra dentro del enunciado?
a. La longitud del primer cateto
b. La longitud del segundo cateto
c. El hecho de que el triángulo es rectángulo
2. ¿Qué resultados exige el enunciado?
a. La longitud de la hipotenusa
En este caso la información de que el triángulo es rectángulo es relevante, porque en
el proceso de síntesis de la solución se usa el teorema de Pitágoras para encontrar el resultado.
Sin esa información del enunciado, no existe una solución única al problema.
Antes del Diseño del Algoritmo primero es necesario realizar una pequeña síntesis
del análisis a fin de establecer las fórmulas matemáticas, los procesos básicos de
programación o la secuencia que deberá usarse dentro del diseño del algoritmo. Como es un
paso intermedio entre el análisis y el diseño de la solución, está pequeña síntesis se colocará
dentro del análisis del problema añadiendo como tercera pregunta ¿Cómo logro obtener los
resultados a partir de la información útil suministrada en el enunciado?
Para los ejemplos dados, el análisis completo sería:
Ejemplo: Dadas las longitudes de la base y la altura de un triángulo isósceles,
determine el área que encierra el triángulo.
1. ¿Qué información útil se suministra dentro del enunciado?
a. La longitud de la Base
b. La longitud de la altura
c. El hecho que el triángulo es isósceles IRRELEVANTE
2. ¿Qué resultados exige el enunciado?
a. El área encerrada por el triángulo
3. ¿Cómo logro obtener los resultados a partir de la información útil suministrada en el
enunciado?
a. Usando la fórmula area = base * altura / 2 por lo tanto la información de la
forma del triángulo es irrelevante.
Ejemplo: Dadas las longitudes de los catetos de un triángulo rectángulo, determine
la longitud de la hipotenusa.
1. ¿Qué información útil se suministra dentro del enunciado?
a. La longitud del primer cateto

8
 b. La longitud del segundo cateto
c. El hecho de que el triángulo es rectángulo
2. ¿Qué resultados exige el enunciado?
a. La longitud de la hipotenusa
3. ¿Cómo logro obtener los resultados a partir de la información útil suministrada en el
enunciado?
a. Con el teorema de Pitágoras, donde hip2 = cat12 + cat22. El teorema de
Pitágoras sólo se aplica si el triángulo es rectángulo, por lo tanto, la
información de la forma es RELEVANTE.

Diseño del algoritmo

En la etapa de análisis del proceso de programación se determina qué hace el
programa. En la etapa de diseño se determina cómo hace el programa la tarea solicitada. Los
métodos más eficaces para el proceso de diseño se basan en el conocido divide y vencerás.
Es decir, la resolución de un problema complejo se realiza dividiendo el problema en
subproblemas y a continuación dividiendo estos subproblemas en otros de nivel más bajo,
hasta que pueda ser implementada una solución en la computadora. Este método se conoce
técnicamente como diseño descendente (top-down) o modular. El proceso de romper el
problema en cada etapa y expresar cada paso en forma más detallada se denomina
refinamiento sucesivo. Cada subprograma es resuelto mediante un módulo (subprograma)
que tiene un solo punto de entrada y un solo punto de salida [1].
Cualquier programa bien diseñado consta de un programa principal (el módulo de
nivel más alto) que llama a subprogramas (módulos de nivel más bajo) que a su vez pueden
llamar a otros subprogramas. Los programas estructurados de esta forma se dice que tienen
un diseño modular y el método de romper el programa en módulos más pequeños se llama
programación modular. Los módulos pueden ser planeados, codificados, comprobados y
depurados independientemente (incluso por diferentes programadores) y a continuación
combinarlos entre sí. El proceso implica la ejecución de los siguientes pasos hasta que el
programa se termina:
1. Programar un módulo.
2. Comprobar el módulo.
3. Si es necesario, depurar el módulo.
4. Combinar el módulo con los módulos anteriores.
El proceso que convierte los resultados del análisis del problema en un diseño
modular con refinamientos sucesivos que permitan una posterior traducción a un lenguaje se
denomina diseño del algoritmo.
El diseño del algoritmo es independiente del lenguaje de programación en el que se
vaya a codificar posteriormente, usualmente se utiliza el diagrama de flujo o el pseudocódigo
como representación alternativa del algoritmo previo a la codificación.

Codificación de un programa

9
 La codificación de un programa se realiza sustituyendo, las palabras y expresiones
del algoritmo o cualquier otra representación, por la sintaxis correspondiente en el lenguaje
de programación. En el caso de programas sencillos se puede omitir el diseño del algoritmo
para agilizar la codificación.
El programa también incluye una documentación que puede ser interna y externa. La
documentación interna es la que se incluye dentro del código del programa fuente mediante
comentarios significativos que ayudan a la comprensión del código, para ello se utiliza un
carácter determinado que indique el inicio de los comentarios. El programa no los necesita y
la computadora los ignora. Estas líneas de comentarios sólo sirven para hacer los programas
más fáciles de comprender. El objetivo del programador debe ser escribir códigos sencillos
y limpios. En cuanto a la documentación externa es la que se puede acceder externamente al
código donde se especifica principalmente el objetivo del programa y los datos que maneja,
adicionalmente del manual de usuario y de sistema.

Compilación y ejecución de un programa

Una vez que el algoritmo se ha convertido en un programa fuente, es preciso
introducirlo en memoria mediante el teclado y almacenarlo posteriormente en un dispositivo
de almacenamiento. Esta operación se realiza con un programa editor. Posteriormente el
programa fuente se convierte en un archivo de programa que se guarda (graba) en un
dispositivo de almacenamiento.
El programa fuente debe ser traducido a lenguaje máquina, este proceso se realiza
con el compilador y el sistema operativo que se encarga prácticamente de la compilación.
Si tras la compilación se presentan errores (errores de compilación) en el programa
fuente, es preciso volver a editar el programa, corregir los errores y compilar de nuevo. Este
proceso se repite hasta que no se producen errores, obteniéndose el programa objeto que
todavía no es ejecutable directamente. Suponiendo que no existen errores en el programa
fuente, se debe instruir al sistema operativo para que realice la fase de montaje o enlace
(link), carga, del programa objeto con las bibliotecas del programa del compilador. El proceso
de montaje produce un programa ejecutable.
Una vez que el programa ejecutable se ha creado, ya se puede ejecutar (correr o rodar)
desde el sistema operativo con sólo teclear su nombre (en el caso de DOS). Suponiendo que
no existen errores durante la ejecución (llamados errores en tiempo de ejecución), se
obtendrá la salida de resultados del programa.
Las instrucciones u órdenes para compilar y ejecutar un programa en C, C++, ... o
cualquier otro lenguaje dependerá de su entorno de programación y del sistema operativo en
que se ejecute Windows, Linux, Unix, etc.

Verificación y depuración de un programa

La verificación o compilación de un programa es el proceso de ejecución del
programa con una amplia variedad de datos de entrada, llamados datos de test o prueba, que
determinarán si el programa tiene o no errores (“bugs”). Para realizar la verificación se debe
desarrollar una amplia gama de datos de test: valores normales de entrada, valores extremos

10
 de entrada que comprueben los límites del programa y valores de entrada que comprueben
aspectos especiales del programa.
La depuración es el proceso de encontrar los errores del programa y corregir o
eliminar dichos errores. Cuando se ejecuta un programa, se pueden producir tres tipos de
errores:
1. Errores de compilación. Se producen normalmente por un uso incorrecto de las
reglas del lenguaje de programación y suelen ser errores de sintaxis. Si existe un error de
sintaxis, la computadora no puede comprender la instrucción, no se obtendrá el programa
objeto y el compilador imprimirá una lista de todos los errores encontrados durante la
compilación.
2. Errores de ejecución. Estos errores se producen por instrucciones que la
computadora puede comprender, pero no ejecutar. Ejemplos típicos son: división por cero y
raíces cuadradas de números negativos. En estos casos se detiene la ejecución del programa
y se imprime un mensaje de error.
3. Errores lógicos. Se producen en la lógica del programa y la fuente del error suele
ser el diseño del algoritmo. Estos errores son los más difíciles de detectar, ya que el programa
puede funcionar y no producir errores de compilación ni de ejecución, y sólo puede advertirse
el error por la obtención de resultados incorrectos. En este caso se debe volver a la fase de
diseño del algoritmo, modificar el algoritmo, cambiar el programa fuente y compilar y
ejecutar una vez más.

Documentación y mantenimiento
La documentación de un problema consta de las descripciones de los pasos a dar en
el proceso de resolución de dicho problema. La importancia de la documentación debe ser
destacada por su decisiva influencia en el producto final. Los programas pobremente
documentados son difíciles de leer, más difíciles de depurar y casi imposibles de mantener y
modificar.
La documentación de un programa puede ser interna y externa. La documentación
interna es la contenida en líneas de comentarios. La documentación externa incluye análisis,
diagramas de flujo y/o pseudocódigos, manuales de usuario con instrucciones para ejecutar
el programa y para interpretar los resultados.
La documentación es vital cuando se desea corregir posibles errores futuros o bien
cambiar el programa. Tales cambios se denominan mantenimiento del programa. Después
de cada cambio la documentación debe ser actualizada para facilitar cambios posteriores. Es
práctica frecuente numerar las sucesivas versiones de los programas 1.0, 1.1, 2.0, 2.1, etc. (Si
los cambios introducidos son importantes, se varía el primer dígito [1.0, 2.0, ...]; en caso de
pequeños cambios sólo se varía el segundo dígito [2.0, 2.1…].)

11
 Unidad 2
Conceptos básicos de
programación.
En esta unidad se presenta una introducción a los conceptos básicos
del área de la computación como el computador y sus partes, algoritmo y sus
diferentes representaciones, y finalmente los paradigmas de programación.
 Unidad II. Conceptos básicos de programación

La computadora
Una computadora es un dispositivo electrónico, utilizado para procesar información
y obtener resultados, capaz de ejecutar cálculos y tomar decisiones a una velocidad de
millones de veces más rápida en comparación a un ser humano. La computadora está
conformada por dos partes: hardware y software. El hardware es la parte tangible mientras
que el software es el conjunto de programas que indican a la computadora las tareas que debe
realizar. Las computadoras procesan datos bajo el control de un conjunto de instrucciones
denominadas programas de computadora. Estos programas controlan y dirigen a la
computadora para que realice un conjunto de acciones (instrucciones) especificadas por
personas especializadas, llamadas programadores de computadoras [1].

¿Cómo maneja la información un computador?

En vista a la naturaleza de la computadora, ella no es capaz de manejar la información
de la misma manera como lo hacen los seres humanos, es decir, en letras, palabras y números.
Se hizo necesario, entonces, establecer una relación entre la manera que maneja la
información una computadora y la manera como la maneja el ser humano. La computadora,
como dispositivo electrónico, establece dos posibles valores de información representados
simbólicamente a través de los dígitos 0 y 1; estos valores representan, dentro de la realidad,
ausencia o presencia de voltaje o corriente dentro de la computadora.
Ausencia (0) Presencia (1)

Desde el punto de vista matemático, la computadora maneja la información en un

sistema de numeración BINARIO, es decir, dos dígitos; por otro lado, los seres humanos
manejan la información numérica en un sistema de numeración DECIMAL, es decir, 10
dígitos. El dígito binario recibe el nombre de BIT en el contexto de la ciencia de la
computación. La palabra Bit es el acrónimo de BInary digiT. (Dígito binario). La Real
Academia Española (RAE) ha aceptado la palabra bit con el plural bits.
Si se toma en cuenta que la información que maneja el ser humano comprende un
abecedario, con el cual se forman palabras, un sistema de numeración Decimal, con el cual
se forman números y además, para la comprensión de la lectura, requiere de símbolos
gramaticales y de ortografía, aunado a otros símbolos incluidos por las diversas ciencias
exacta como la matemática, la física, etc., es fácil deducir que un dígito binario no puede
representar a todo este cúmulo de información que día a día manejan los seres humanos. De
la misma manera que el ser humano combina las letras para formar palabras o combina

13
dígitos para formar números, los diseñadores iniciales de las computadoras decidieron formar
números binarios como resultado de la combinación de dígitos binarios.
A diferencia de la forma como el ser humano crea
sus palabras y números, la computadora se diseñó para
trabajar con palabras de igual cantidad de dígitos binarios.
Esta cantidad fue definida por Werner Buchholz en 1957
como números binarios de 8 dígitos y lo bautizó con el
nombre de BYTE. La relación entre la computadora y el ser
humano fue definida dentro de lo que se conoce como
Tabla ASCII (American Standard Code for Information
Interchange) que fue publicada como estándar por primera
vez en 1967 y fue actualizado por última vez en 1986 (ver
Tabla 2-1). En la actualidad define códigos para 33
caracteres no imprimibles, de los cuales la mayoría son
caracteres de control obsoletos que tienen efecto sobre
cómo se procesa el texto, más otros 95 caracteres imprimibles que les siguen en la
numeración (empezando por el carácter espacio).
Tabla 2-1 ASCII de caracteres imprimibles.
Dec Hex Car Dec Hex Car Dec Hex Car Dec Hex Car Dec Hex Car Dec Hex Car
32 20 espacio 48 30 0 64 40 @ 80 50 P 96 60 ` 112 70 p
33 21 ! 49 31 1 65 41 A 81 51 Q 97 61 a 113 71 q
34 22 " 50 32 2 66 42 B 82 52 R 98 62 b 114 72 r
35 23 # 51 33 3 67 43 C 83 53 S 99 63 c 115 73 s
36 24 $ 52 34 4 68 44 D 84 54 T 100 64 d 116 74 t
37 25 % 53 35 5 69 45 E 85 55 U 101 65 e 117 75 u
38 26 & 54 36 6 70 46 F 86 56 V 102 66 f 118 76 v
39 27 ' 55 37 7 71 47 G 87 57 W 103 67 g 119 77 w
40 28 ( 56 38 8 72 48 H 88 58 X 104 68 h 120 78 x
41 29 ) 57 39 9 73 49 I 89 59 Y 105 69 i 121 79 y
42 2A * 58 3A : 74 4A J 90 5A Z 106 6A j 122 7A z
43 2B + 59 3B ; 75 4B K 91 5B [ 107 6B k 123 7B {
44 2C , 60 3C < 76 4C L 92 5C \ 108 6C l 124 7C |
45 2D - 61 3D = 77 4D M 93 5D ] 109 6D m 125 7D }
46 2E . 62 3E > 78 4E N 94 5E ^ 110 6E n 126 7E ~
47 2F / 63 3F ? 79 4F O 95 5F _ 111 6F o

Observe en la Tabla 2-1 la relación que existe entre los Byte y las letras del alfabeto.
Desde el punto de vista del sistema numérico binario, la letra A mayúscula es menor que la
letra B mayúscula y así sucesivamente; es decir que estas relaciones le permitirán a la
computadora ordenar alfabéticamente una serie de nombres, ya que los conjuntos de Byte
que las componen poseen la misma relación que el alfabeto.
A medida que la tecnología informática se difundió a lo largo del mundo, se
desarrollaron diferentes estándares y las empresas desarrollaron muchas variaciones del
código ASCII para facilitar la escritura de lenguas diferentes al inglés que usaran alfabetos
latinos. Se pueden encontrar algunas de esas variaciones clasificadas como "ASCII
Extendido". Estos nuevos símbolos corresponden a los bytes cuyo valor decimal está en el
rango de 128 a 255. Dentro de estos nuevos símbolos está la eñe mayúscula y minúscula, las
vocales acentuadas, símbolos gramaticales y símbolos de otras lenguas diferentes al
castellano.

14
 La Real Academia Española (RAE) define la palabra Byte, como la unidad de
información compuesta generalmente de ocho bits

Unidades de medida de la información almacenada.

La memoria principal es uno de los componentes más importantes de una
computadora y sirve para almacenamiento de información (datos y programas). Existen dos
tipos de memoria y de almacenamiento: Almacenamiento principal (memoria principal o
memoria central) y almacenamiento secundario o almacenamiento masivo (discos, cintas,
etc.).
La memoria central de una computadora es una zona de almacenamiento organizada
en centenares o millares de unidades de almacenamiento individual o celdas. La memoria
central consta de un conjunto de celdas de memoria (estas celdas o posiciones de memoria
se denominan también palabras, aunque no “guardan” analogía con las palabras del lenguaje).
Cada palabra puede ser un grupo de 8 bits, 16 bits, 32 bits o incluso 64 bits, en las
computadoras más modernas y potentes. Si la palabra es de 8 bits se conoce como byte. El
término bit (dígito binario)10 se deriva de las palabras inglesas “binary digit” y es la unidad
de información más pequeña que puede tratar una computadora. El término byte es muy
utilizado en la jerga informática y, normalmente, las palabras de 16 bits se suelen conocer
como palabras de 2 bytes, y las palabras de 32 bits como palabras de 4 bytes.
La memoria central de una computadora puede tener desde unos centenares de
millares de bytes hasta millones de bytes. Como el byte es una unidad elemental de
almacenamiento, se utilizan múltiplos para definir el tamaño de la memoria central: kilobyte
(kB) igual a 1.024 bytes11 (210), Megabyte (MB) igual a 1.024 × 1.024 bytes (220 =
1.048.576), Gigabyte (GB) igual a 1.024 MB (230 = 1.073.741.824). Las abreviaturas MB,
GB y TB se han vuelto muy populares como unidades de medida de la potencia de una
computadora.
La aplicación de estos prefijos representa un mal uso de la terminología de medidas,
ya que en otros campos las referencias a las unidades son potencias de 10. Por ejemplo, las
medidas en distancias, kilómetro (km) se refiere a 1.000 metros, las medidas de frecuencias,
Megahercio (MHz) se refieren a 1.000.000 de hercios. En la jerga informática popular para
igualar terminología, se suele hablar de 1 kB como 1.000 bytes y 1 MB como 1.000.000 de
bytes y un 1 GB como 1.000 millones de bytes, sobre todo para correspondencia y fáciles
cálculos mentales, aunque como se observa en la Tabla 2-2 estos valores son sólo
aproximaciones prácticas [1].
Tabla 2-2. Unidades de medida de almacenamiento
Byte Byte (B) equivale a 8 bits
Kilobyte Kbyte (kB) equivale a 1.024 bytes (103)
Megabyte Mbyte (MB) equivale a 1.024 Kbytes (106)
Gigabyte Gbyte (GB) equivale a 1.024 Mbytes (109)
Terabyte Tbyte (TB) equivale a 1.024 Gbytes (1012)
Petabyte Pbyte (PB) equivale a 1.024 Tbytes (1015)
Exabyte Ebyte (EB) equivale a 1.024 Pbytes (1018)
Zettabyte Zbyte (ZB) equivale a 1.024 Ebytes (1021)
Yotta Ybyte (YB) equivale a 1.024 Zbytes (1024)

15
 1 Tb = 1.024 Gb; 1 GB = 1.024 Mb = 1.048.576 kb = 1.073.741.824 b

Partes del computador

Hardware de una computadora
El hardware se refiere a todos los componentes físicos (que se pueden tocar), en el
caso de una computadora personal serían el monitor, teclado, la placa base, el
microprocesador, la tarjeta de memoria etc. Hardware es un neologismo proveniente del
inglés definido por la Real Academia Española como el conjunto de elementos materiales
que conforman una computadora; no tiene equivalente en el castellano.
De manera muy general, el Hardware de una computadora se puede clasificar según
la función que elabora, en tres grandes grupos:
1) Microprocesador:
a. Unidad Central de Proceso: es la encargada de ejecutar las órdenes dadas a la
computadora.
b. Unidad Aritmética y Lógica: es la encargada de realizar las operaciones aritméticas
elementales, así como determinar la relación entre dos valores escalares.
c. Partes misceláneas que sirven para el manejo de la información que entra y sale del
microprocesador.
2) Memoria:
a. Random Access Memory (RAM): es el lugar donde la computadora coloca la
información y los procesos que la están manipulando a fin de obtener resultados. Su
contenido se pierde al apagar la computadora, por eso se dice que esta memoria es
volátil.
b. Read Only Memory (ROM): contiene las órdenes iniciales que ejecuta la
computadora al encenderse. Contiene, también, los procesos básicos para manejar y
controlar todos las partes electrónicas y dispositivos que acompañan al
microprocesador. Hoy en día se están sustituyendo por memorias flash para facilitar
su actualización.
3) Periféricos:
Se denominan periféricos tanto a las unidades o dispositivos a través de los cuales la
computadora se comunica con el mundo exterior, como a los sistemas que almacenan o
archivan la información, sirviendo de memoria auxiliar de la memoria principal (RAM).
a. Unidades de Entrada: Captan y envían los datos al dispositivo que los procesará,
según las ordenes ejecutadas por la Unidad Central de proceso. A través de estas
unidades el ser humano introduce información en la computadora. Ejemplos de
unidades de entrada: Teclado, Mouse, Escáner, Cámara Web, Micrófono, Joystick,
entre otros.
b. Unidades de Salida: Son dispositivos que muestran o proyectan información hacia
el exterior de la computadora. La mayoría son para informar, alertar, comunicar,

16
 proyectar o dar al ser humano cierta información. Ejemplos de unidades de salida:
Monitor, Impresora, Altavoces, Auriculares, entre otros.
c. Unidades de comunicación: Son los dispositivos que se encargan de comunicarse
con otras máquinas o computadoras, ya sea para trabajar en conjunto, o para enviar y
recibir información. Ejemplos de unidades de comunicación: Fax-Modem, Tarjetas
de Red, Wireless y Bluetooth, Controladores USB e Infrarrojos, entre otros.
d. Unidades de almacenamiento: Son los dispositivos que almacenan información por
bastante tiempo. La memoria RAM no puede ser considerada un periférico de
almacenamiento, ya que su memoria es volátil y temporal. Ejemplos de unidades de
almacenamiento: Disco Duro, Grabador o lector de CD, DVD, HD-DVD y Blu-ray,
Memoria Flash, Memoria portátil, entre otros.

Software
Se denomina software (palabra de origen ánglico), programática, equipamiento
lógico o soporte lógico a todos los componentes intangibles de una computadora, es decir,
al conjunto de programas y procedimientos necesarios para hacer posible la realización de
una tarea específica, en contraposición a los componentes físicos del sistema (hardware).
El software es quién al ejecutar una tarea da un ambiente de inteligencia similar a la
del ser humano (y a veces hasta sorprendente) por parte de la computadora, a la que se le
conoce como inteligencia aparente. Según su función, el software se clasifica en tres grandes
grupos:
a) Software de sistema: El software del sistema coordina las diferentes partes de un
sistema de computadora y conecta e interactúa entre el software de aplicación y el
hardware de la computadora. Otro tipo de software del sistema que gestiona, controla
las actividades de la computadora y realiza tareas de proceso comunes, se denomina
utility o utilidades (en algunas partes de Latinoamérica, utilerías). El software del
sistema que gestiona y controla las actividades de la computadora se denomina
sistema operativo. Otro software del sistema son los programas traductores o de
traducción de lenguajes de computadora que convierten los lenguajes de
programación, entendibles por los programadores, en lenguaje máquina que
entienden las computadoras.
El software del sistema es el conjunto de programas indispensables para que la
máquina funcione; se denominan también programas del sistema. Estos programas son,
básicamente, el sistema operativo, los editores de texto, los compiladores/intérpretes
(lenguajes de programación) y los programas de utilidad [1].
b) Software de programación: proporciona herramientas para ayudar al programador
a escribir programas informáticos y a usar diferentes lenguajes de programación de
forma práctica. Incluye entre otros: Editores de Texto, compiladores, intérpretes,
enlazadores, depuradores.
c) Software de aplicación: permite a los seres humanos llevar a cabo una o varias tareas
más específicas, en cualquier campo de actividad susceptible de ser automatizado o
asistido, con especial énfasis en los negocios.

17
 Por otro lado, el software puede existir dentro de una computadora en tres formas
diferentes:
a) Código fuente: escrito por programadores. Contiene el conjunto de instrucciones
destinadas a la computadora. El conjunto de instrucciones no está escrito en un
lenguaje que la computadora pueda entender directamente, ya que está escrito en
lenguaje del ser humano.
b) Código objeto: resultado del uso de un compilador sobre el código fuente. Consiste
en una traducción de este último hacía el lenguaje nativo de la computadora (byte).
El código objeto no es directamente inteligible por el ser humano, pero tampoco es
puede ser ejecutado por la computadora ya que le falta añadir fragmentos de código
objeto para ser directamente funcional en la computadora donde quiere colocarse a
trabajar.
c) Código ejecutable: resultado de enlazar uno o varios fragmentos de código objeto.
Constituye un archivo binario con un formato tal que el sistema operativo es capaz
de cargarlo en la memoria de una computadora, y proceder a su ejecución.

Traductores de lenguaje: el proceso de traducción de un programa.

El proceso de traducción de un programa fuente escrito en un lenguaje de alto nivel
a un lenguaje máquina comprensible por la computadora, se realiza mediante programas
llamados “traductores”. Los traductores de lenguaje son programas que traducen a su vez los
programas fuente escritos en lenguajes de alto nivel a código máquina. Los traductores se
dividen en compiladores e intérpretes [1].
2.4.3.1 Intérpretes
Un intérprete es un traductor que toma un programa fuente, lo traduce y, a
continuación, lo ejecuta. Los programas intérpretes clásicos como BASIC, prácticamente ya
no se utilizan, más que en circunstancias especiales. Sin embargo, está muy extendida la
versión interpretada del lenguaje Smalltalk, un lenguaje orientado a objetos puro. El sistema
de traducción consiste en: traducir la primera sentencia del programa a lenguaje máquina, se
detiene la traducción, se ejecuta la sentencia; a continuación, se traduce la siguiente
sentencia, se detiene la traducción, se ejecuta la sentencia y así sucesivamente hasta terminar
el programa (Figura 2-1).

Figura 2-1. Interprete

2.4.3.2 Compiladores
Un compilador es un programa que traduce los programas fuente escritos en lenguaje
de alto nivel a lenguaje máquina. La traducción del programa completo se realiza en una sola
operación denominada compilación del programa; es decir, se traducen todas las
instrucciones del programa en un solo bloque. El programa compilado y depurado

18
 (eliminados los errores del código fuente) se denomina programa ejecutable porque ya se
puede ejecutar directamente y cuantas veces se desee; sólo deberá volver a compilarse de
nuevo en el caso de que se modifique alguna instrucción del programa. De este modo el
programa ejecutable no necesita del compilador para su ejecución. Los traductores de
lenguajes típicos más utilizados son: C, C++, Java, C#, Pascal, FORTRAN y COBOL
(Figura 2-2).

Figura 2-2. Compilación

Programa y dato
Los términos programa y dato se han utilizado sin que se definieran previamente, ya
que son ambos son términos conocidos dentro de otros contextos. Antes de seguir avanzando
en nuevos temas, es necesario dar una definición formal de estos términos dentro del contexto
de estudio: La Computación.
Un Programa es una secuencia de pasos, órdenes o instrucciones que al ejecutarse
logran cumplir una tarea específica. Un Dato es la información del ser humano representada
simbólicamente a través de letras y dígitos en la computadora. De esta manera, la
Programación de Computadoras es el proceso de crear programas que permitan
automatizar los procesos de cálculo manual, así como también la automatización de procesos
que incluyan la obtención de información para su posterior procesamiento.
La asignatura Computación I comprende la enseñanza de las técnicas básicas de
programación para la resolución de problemas matemáticos o no, que generen en los
estudiantes las habilidades de razonamiento para la automatización de los procesos de cálculo
en asignaturas de ingeniería.

Resumen
Una computadora es una máquina para procesar información y obtener resultados en
función de unos datos de entrada.
Hardware: parte física de una computadora (dispositivos electrónicos).
Software: parte lógica de una computadora (programas).
Las computadoras se componen de:
• Dispositivos de Entrada/Salida (E/S).
• Unidad Central de Proceso (Unidad de Control y Unidad Lógica y Aritmética).
• Memoria central.
• Dispositivos de almacenamiento masivo de información (memoria auxiliar o
externa).

19
 El software del sistema comprende, entre otros, el sistema operativo Windows,
Linux, en computadoras personales y los lenguajes de programación. Los lenguajes de
programación de alto nivel están diseñados para hacer más fácil la escritura de programas
que los lenguajes de bajo nivel. Existen numerosos lenguajes de programación cada uno de
los cuales tiene sus propias características y funcionalidades, y normalmente son más fáciles
de transportar a máquinas diferentes que los escritos en lenguajes de bajo nivel. Los
programas escritos en lenguaje de alto nivel deben ser traducidos por un compilador antes de
que se puedan ejecutar en una máquina específica. En la mayoría de los lenguajes de
programación se requiere un compilador para cada máquina en la que se desea ejecutar
programas escritos en un lenguaje específico.
Los lenguajes de programación se clasifican en:
• Alto nivel: Pascal, FORTRAN, Visual Basic, C, Ada, Modula-2, C++, Java, Delphi,
C#, etc.
• Bajo nivel: Ensamblador.
• Máquina: Código máquina.
• Diseño de Web: SMGL, HTML, XML, PHP.
Los programas traductores de lenguajes son:
• Compiladores.
• Intérpretes.
Un método general para la resolución de un problema con computadora tiene las
siguientes fases:
1. Análisis del programa.
2. Diseño del algoritmo.
3. Codificación.
4. Compilación y ejecución.
5. Verificación.
6. Documentación y mantenimiento.
El sistema más idóneo para resolver un problema es descomponerlo en módulos más
sencillos y luego, mediante diseños descendentes y refinamiento sucesivo, llegar a módulos
fácilmente codificables. Estos módulos se deben codificar con las estructuras de control de
programación estructurada.
1. Secuenciales: las instrucciones se ejecutan sucesivamente una después de otra.
2. Repetitivas: una serie de instrucciones se repiten una y otra vez hasta que se cumple
una cierta condición.
3. Selectivas: permite elegir entre dos alternativas (dos conjuntos de instrucciones)
dependiendo de una condición determinada)

Algoritmo.

20
 Concepto y propiedades
El objetivo fundamental de este texto es enseñar a resolver problemas mediante una
computadora. El programador de computadora es una persona que resuelve problemas, por
lo que para llegar a ser un programador eficaz se necesita aprender a resolver problemas de
un modo riguroso y sistemático.
Un algoritmo es un método para resolver un problema. Aunque la popularización del
término ha llegado con el advenimiento de la era informática, algoritmo proviene, de
Mohammed Al-Khôwârizmi, matemático persa que vivió durante el siglo IX y alcanzó gran
reputación por el enunciado de las reglas paso a paso para sumar, restar, multiplicar y dividir
números decimales; la traducción al latín del apellido en la palabra algorismus derivó
posteriormente en algoritmo. Euclides, el gran matemático griego (del siglo IV a. C.), quien
inventó un método para encontrar el máximo común divisor de dos números, se considera
junto con Al-Khôwârizmi el otro gran padre de la algoritmia (ciencia que trata de los
algoritmos).
El profesor NiklausWirth, inventor de Pascal, Modula-2 y Oberon, tituló uno de sus
más famosos libros, Algoritmos + Estructuras de datos = Programas, significándonos que
solo se puede llegar a realizar un buen programa con el diseño de un algoritmo y una correcta
estructura de datos. Esta ecuación será una de las hipótesis fundamentales consideradas para
el inicio del aprendizaje de la programación.
La resolución de un problema exige el diseño de un algoritmo que resuelva el
problema propuesto.
Los pasos para la resolución de un problema son:
1. Diseño del algoritmo, que describe la secuencia ordenada de pasos, sin
ambigüedades, que conducen a la solución de un problema dado. (Análisis del
problema y desarrollo del algoritmo.)
2. Expresar el algoritmo como un programa en un lenguaje de programación adecuado.
(Fase de codificación.)
3. Ejecución y validación del programa por la computadora.

Problema Diseño de algoritmo Programa de computadora

Resolución de un problema.

Para llegar a la realización de un programa es necesario el diseño previo de un

algoritmo, de modo que sin algoritmo no puede existir un programa.
Los algoritmos son independientes tanto del lenguaje de programación en que se
expresan como de la computadora que los ejecuta. En cada problema el algoritmo se puede
expresar en un lenguaje diferente de programación y ejecutarse en una computadora distinta;
sin embargo, el algoritmo será siempre el mismo. Así, por ejemplo, en una analogía con la
vida diaria, una receta de un plato de cocina se puede expresar en español, inglés o francés,
pero cualquiera que sea el lenguaje, los pasos para la elaboración del plato se realizarán sin
importar el idioma del cocinero.

21
 En la ciencia de la computación y en la programación, los algoritmos son más
importantes que los lenguajes de programación o las computadoras. Un lenguaje de
programación es tan solo un medio para expresar un algoritmo y una computadora es solo un
procesador para ejecutarlo. Tanto el lenguaje de programación como la computadora son los
medios para obtener un fin: conseguir que el algoritmo se ejecute y se efectúe el proceso
correspondiente.

Características de los algoritmos

Las características fundamentales que debe cumplir todo algoritmo son:
• Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.
• Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe obtener
el mismo resultado cada vez.
• Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en algún
momento; o sea, debe tener un número finito de pasos.
• Asimismo, un algoritmo tiene que ser legible. Esto significa que el texto que
describe debe ser claro y conciso, de una manera tal que permita su comprensión
inmediata, es decir sin procedimientos rebuscados o poco claros.
• Por último, un algoritmo debe estar definido en tres partes fundamentales, las
cuales son: Entrada, Proceso y Salida.

Componentes de un algoritmo
Conceptualmente, un algoritmo tiene tres componentes:
1. la entrada: son los datos sobre los que el algoritmo opera;
2. el proceso: son los pasos que hay que seguir, utilizando la entrada;
3. la salida: es el resultado que entrega el algoritmo.

Entrada Proceso Salida

Retroalimentación
Nota: En programación. el proceso es una secuencia de sentencias, que debe ser realizada en orden.
El proceso también puede tener ciclos (grupos de sentencias que son ejecutadas varias veces)
y condicionales (grupos de sentencias que sólo son ejecutadas bajo ciertas condiciones).

Como hacer un algoritmo.

En el caso que se necesite realizar un algoritmo para resolver problemas o mejorar
algún proceso en nuestra actividad, se lleva a cabo de manera bastante sencilla, ya que lo
único que se tiene que hacer es poner claro lo que se necesita y como se puede resolver.

22
 Para ello se debe realizar la serie de pasos necesarios y sus derivaciones para poder
llegar al resultado esperado del problema. Los pasos para definir y concretar un algoritmo
son los siguientes:
• Primer paso: Análisis previo del problema o necesidad. Lo primero que se tiene que
hacer, antes de comenzar con el desarrollo de cualquier algoritmo es llevar a cabo un
análisis pormenorizado de la situación o problema.
• Segundo paso: Definir los requerimientos. En este paso se debe definir exactamente
el problema que se tiene que solucionar y desglosarlo, incluyendo todas las
derivaciones que puedan surgir.
• Tercer paso: La identificación de los módulos. En este paso, identificar claramente
los módulos es tan importante como la identificación de los requerimientos. Esto es
así debido a que identificar correctamente los módulos nos va servir para simplificar
considerablemente la puesta en marcha de los pasos del algoritmo correcto para
nuestro problema, y que se identificó en el paso anterior.
• Cuarto paso: La creación del algoritmo. En este punto debe asegurarse que el
algoritmo cumpla con todos los requerimientos adecuados para llevar a cabo la
función encomendad. Esto es similar tanto para los algoritmos no computacionales
como para los algoritmos computacionales. En el caso de tratarse de un algoritmo
computacional, además deberá cumplir con ciertas características para poder luego
implementarse en cualquier lenguaje de programación.
• Quinto paso: La implementación del algoritmo. En el caso de los algoritmos
computacionales, la implementación de los mismos se realiza traduciendo el mismo
a un lenguaje de programación con el propósito de que cualquier computadora pueda
interpretar sus instrucciones y enviar a su hardware la información necesaria para
completar los pasos correspondientes y así obtener el resultado esperado.
• Sexto paso: Creación de las herramientas para llevar a cabo el algoritmo. En este
último, y cumplidos correctamente los pasos anteriores, se procede a crear las
herramientas necesarias para ejecutar el algoritmo desarrollado. En el caso de un
algoritmo computacional, se puede desarrollar mediante cualquier lenguaje de
programación una aplicación para poder llevarlo a cabo, la cual contará con una serie
de instrucciones ordenadas con el fin de representar el algoritmo diseñado y poder
ofrecer una solución a los requerimientos identificados. En los casos en que se trate
de un algoritmo no computacional, se puede desarrollar lo necesario teniendo en
cuenta los pasos que debe seguir el algoritmo, como por ejemplo una línea de
producción.
(Extraído de: https://www.tecnologia-informatica.com/algoritmo-definicion/)
Un ejemplo de Algoritmo de la vida diaria podría ser:
Preparación de una masa para pan:
1. cuente con manteca, harina, agua, levadura, y sal
2. mezcle los ingredientes
3. amase hasta formar un bolo
4. espere hasta leudar

23
 5. caliente el horno
6. lleve el bolo al horno
7. retire del horno luego de X minutos
Observación: En este algoritmo no quedan claras muchas instrucciones, como por
ejemplo la cantidad de los ingredientes, temperatura del horno, tiempo de cocción, etc. Es
decir, se requiere mayor precisión. También se puede decir que el lenguaje no es muy claro
y no podrá ser interpretado por una persona que hable otro idioma, por ejemplo. Entonces es
necesario definir ciertos acuerdos tanto en la forma de expresar un algoritmo sintaxis y en las
palabras (o símbolos) que se utilizan para expresarlo.
Ejemplo: calcular la media de dos números
Algoritmo
1. Ingrese dos números, llamados a y b
2. Calcule la media de acuerdo a la fórmula (a+b)/2 y deje el resultado en m
3. Mostrar el valor de m
Observación: este algoritmo es más preciso y puede llevarse a un “programa” que
obtenga la solución.
Para expresar un algoritmo se utilizan variadas técnicas como: textual mediante
pseudocódigo, o gráfica mediante “diagramas de flujo”, u otras técnicas como UML
(lenguaje de modelamiento Unificado). A continuación, se le presentan varios ejemplos
adicionales de algoritmo:
Ejemplo 2-1
Un cliente ejecuta un pedido a una fábrica. La fábrica examina en su banco de
datos la ficha del cliente, si el cliente es solvente entonces la empresa acepta el pedido;
en caso contrario, lo rechazará. Redactar el algoritmo correspondiente.
Los pasos del algoritmo son:
1. Inicio.
2. Leer el pedido.
3. Examinar la ficha del cliente.
4. Si el cliente es solvente, aceptar pedido;
5. en caso contrario, rechazar pedido.
6. Fin.

Ejemplo 2-2
Se desea diseñar un algoritmo para saber si un número es primo o no.
Un número es primo si solo puede dividirse entre sí mismo y entre la unidad (es
decir, no tiene más divisores que él mismo y la unidad). Por ejemplo, 9, 8, 6, 4, 12, 16,
20, etc., no son primos, ya que son divisibles entre números distintos a ellos mismos y a
la unidad. Así, 9 es divisible entre 3, 8 lo es entre 2, etc. El algoritmo de resolución del
problema pasa por dividir sucesivamente el número entre 2, 3, 4..., etcétera.
1. Inicio.

24
 2. Poner X igual a 2 (X ← 2, X variable que representa a los divisores del número que
se busca N).
3. Dividir N entre X (N/X).
4. Si el resultado de N/X es entero, entonces N no es número primo y se bifurca al
punto 7; en caso contrario continuar el proceso.
5. Suma 1 a X (X ← X + 1).
6. Si X es igual a N, entonces N es primo; en caso contrario bifurcar al punto 3.
7. Fin.
Por ejemplo, si N es 131, los pasos anteriores serían:
1. Inicio.
2. X = 2.
3. 131/X. Como el resultado no es entero, se continúa el proceso.
4. X ← 2 + 1, luego X = 3.
5. Como X no es 131, se continúa el proceso.
6. 131/X resultado no es entero.
7. X ← 3 + 1, X = 4.
8. Como X no es 131 se continúa el proceso.
9. 131/X ..., etc.
10. Fin.

Ejemplo 2-3
Realizar la suma de todos los números pares entre 2 y 1000.
El problema consiste en sumar 2 + 4 + 6 + 8 ... + 1 000. Se utilizará las palabras
SUMA y NÚMERO para representar las sumas sucesivas (2 + 4), (2 + 4 + 6), (2 + 4 + 6
+ 8), etc. La solución se puede escribir con el siguiente algoritmo:
1. Inicio.
2. Establecer SUMA a 0.
3. Establecer NÚMERO a 2.
4. Sumar NÚMERO a SUMA. El resultado será el nuevo valor de la
5. suma (SUMA).
6. Incrementar NÚMERO en 2 unidades.
7. Si NÚMERO <= 1000 bifurcar al paso 4; en caso contrario, escribir el último
valor de SUMA y terminar el proceso.
8. Fin.

Representación gráfica de los algoritmos

Para representar un algoritmo se debe utilizar algún método que permita independizar
dicho algoritmo del lenguaje de programación elegido. Ello permitirá que un algoritmo pueda
ser codificado de manera indistinta en cualquier lenguaje. Para conseguir este objetivo se
precisa que el algoritmo sea representado gráfica o numéricamente, de modo que las
sucesivas acciones no dependan de la sintaxis de ningún lenguaje de programación, sino que

25
la descripción pueda servir fácilmente para su transformación en un programa, es decir, su
codificación.
Los métodos usuales para representar un algoritmo son:
1. diagrama de flujo,
2. lenguaje de especificación de algoritmos: pseudocódigo,
3. lenguaje español, inglés...
4. fórmulas.
Los métodos anteriores no suelen ser fáciles de transformar en programas. Una
descripción en español narrativo no es satisfactoria, ya que es demasiado prolija y
generalmente ambigua. Una fórmula, sin embargo, es un buen sistema de representación. Por
ejemplo, las fórmulas para la solución de una ecuación cuadrática (de segundo grado: ax2 +
bx + c = 0) son un medio sucinto de expresar el procedimiento algorítmico que se debe
ejecutar para obtener las raíces de dicha ecuación.
1. Elevar al cuadrado b.
2. Tomar a; multiplicar por c; multiplicar por 4.
3. Restar el resultado obtenido de 2 del resultado de 1, etcétera.
Sin embargo, no es frecuente que un algoritmo pueda ser expresado por medio de una
simple fórmula.

Pseudocódigo
El pseudocódigo es una forma de escribir algoritmos de manera informal y sin utilizar
un lenguaje de programación específico. El objetivo es describir la secuencia de pasos
necesarios para resolver un problema de manera clara y concisa, utilizando una serie de
convenciones y símbolos que permiten representar estructuras comunes como bucles,
condicionales, asignaciones de variables, entre otras operaciones.
El pseudocódigo original utiliza para representar las acciones sucesivas palabras
reservadas en inglés, similares a sus homónimas en los lenguajes de programación, como
start, end, stop, if-then-else, while-end, repeat-until, etc. seguidos de expresiones
matemáticas y/o lógicas que definen la acción a ejecutar. La escritura de pseudocódigo exige
normalmente la indentación (sangría en el margen izquierdo) de diferentes líneas. El objetivo
es que otras personas puedan entender el algoritmo sin necesidad de conocer un lenguaje de
programación específico. La ventaja del pseudocódigo es que, en su uso, en la planificación
de un programa, el programador se puede concentrar en la lógica y en las estructuras de
control y no preocuparse de las reglas de un lenguaje específico.
Por fortuna, aunque el pseudocódigo nació como un sustituto del lenguaje de
programación y, por consiguiente, sus palabras reservadas se conservaron o fueron muy
similares a las del idioma inglés, el uso del pseudocódigo se ha extendido en la comunidad
hispana con términos en español como: inicio, fin, parada, leer, escribir, si-
entonces-si_no, mientras, fin_mientras, repetir, hasta_ que, etc. Sin duda, el uso
de la terminología del pseudocódigo en español ha facilitado y facilitará considerablemente
el aprendizaje y uso diario de la programación.

26
 Diagramas de Flujo
Un diagrama de flujo (flowchart) es una de
las técnicas de representación de algoritmos más
antigua y a la vez más utilizada, aunque su empleo
ha disminuido considerablemente, sobre todo,
desde la aparición de lenguajes de programación
estructurados. Un diagrama de flujo es un diagrama
que utiliza los símbolos estándar mostrados en la
Tabla 2-3 y que tiene los pasos de algoritmo escritos
en esas cajas unidas por flechas, denominadas líneas de flujo, que indican la secuencia en
que se debe ejecutar.
Los símbolos estándar normalizados por ANSI (American National Standard
Institute) son muy variados. En la Tabla 2-3 se representa una plantilla de dibujo típica donde
se contemplan los símbolos principales utilizados en el diagrama.
Tabla 2-3. Símbolos de diagrama de flujo.

Símbolos principales Función

Terminador: regresa el inicio y fin de un programa

Lineas de conexión y dirección de flujo: indica el

sentido de ejecución de las operaciones.

Entrada: Cualquier tipo de introducción de datos desde

los periféricos.

Salida: es utilizado para mostrar datos o resultados.

Proceso general: permite realizar cálculos matemáticos

y asignación de valores a las variables.

No Si Toma de decisiones: indica la evaluación de

expresiones lógicas para decidir cual camino seguir.

Bloque de procedimiento: Ciclo que repite un conjunto

de instrucciones.

27
 Conector dentro de la página.

Conexión fuera de la página.

Programas y Programación
La Programación es un proceso de resolución de problemas. Las técnicas más
comunes incluyen análisis del problema, definición de los requerimientos del problema y
diseño, que, en la práctica es la realización de un algoritmo, que es un método para resolver
dicho problema.
Las computadoras procesan datos con el control de un conjunto de instrucciones
denominadas programa de computadora. Los programas señalan a la computadora las tareas
o acciones a realizar en función de un conjunto de instrucciones (acciones) especificadas por
el constructor del programa llamado programador.
Un programa de computadora o programa es una secuencia de sentencias diseñadas
para ejecutar una tarea. La Programación es un proceso de planeación y creación de un
programa. Desde un punto de vista práctico, un programa se escribe primero con un algoritmo
en pseudocódigo o en otra herramienta de programación y luego se traduce a un lenguaje de
programación tal como Python, C, C++ o Java.

Paradigmas de Programación
Uno de los elementos básicos a la hora de realizar un programa es la modelización
del problema que pretende resolver. Es preciso localizar las variables y los aspectos
relevantes, así como comprender los pasos necesarios para obtener el resultado a partir de los
datos iniciales, etc. Es decir, abstraer el problema, reduciendo sus detalles de forma que se
pueda trabajar con pocos elementos cada vez.
La algoritmia plantea la forma óptima de resolver problemas concretos, tales como la
ordenación de una lista de elementos, la búsqueda de un elemento en un conjunto, la
manipulación de conjuntos de datos, etc. Sin embargo, no proporcionan un marco general,
un enfoque, que nos permita plantear y formular las soluciones a un problema de forma
coherente.
Los paradigmas de programación llenan ese hueco, proporcionando guías tanto sobre
cómo realizar la abstracción de los datos como sobre el control de la ejecución. Es decir, los
paradigmas de programación son herramientas conceptuales para
analizar, representar y abordar los problemas, presentando sistematizaciones
alternativas o complementarias para pasar del espacio de los problemas al de las
implementaciones de una solución.
Es muy recomendable y productivo comprender el enfoque de distintos paradigmas,
puesto que presentan estrategias alternativas, incrementando nuestras herramientas
disponibles y reflexionar sobre muchas de las tareas que se realizan al crear un programa.
Además, a menudo ocurre que unos problemas se formulan de forma muy clara si se los

28
 analiza según una perspectiva determinada, mientras que producen una gran complejidad
vistos de otra manera.
2.7.1.1 Algunos paradigmas habituales
Algunas de las formas de pensar los problemas que ha llegado a sistematizarse como
paradigmas de programación son:
1. La programación modular: Los programas se forman por partes separadas llamadas
módulos. Estos funcionan de forma independiente entre sí, se relacionan a través de
interfaces bien definidas.
2. La programación procedural: Un programa se compone de procedimientos
(subrutinas, métodos o funciones) que son fragmentos de código que pueden llamarse
desde cualquier punto de la ejecución de un programa, incluidos otros procedimientos
o él mismo. (ej. ALGOL)
3. La programación estructurada: Se puede expresar cualquier programa utilizando
únicamente tres estructuras de control: secuencial, condicional e iterativa. Los
programas se componen de partes menores con un único punto de entrada, y se trata
de aislarlos para evitar la complejidad que introducen los efectos colaterales. (ej.
Pascal, C, Ada)
4. La programación imperativa: Un programa se puede definir en términos de estado,
y de instrucciones secuenciales que modifican dicho estado. (ej. C, BASIC)
5. La programación declarativa: Es posible expresar un programa a través de
condiciones, proposiciones o restricciones, a partir de los que se obtiene la solución
mediante reglas internas de control. (ej. PROLOG)
6. La programación funcional: Se puede expresar un programa como una
secuencia de aplicación de funciones. Elude el concepto de estado del
cómputo y no precisa de las estructuras de control de la programación
estructurada. (ej. LISP, Haskell)
7. La programación orientada a objetos: Los programas se definen en
términos de “clases de objetos” que se comunican entre sí mediante el
envío de mensajes. Es una evolución de los paradigmas de la programación
procedural, estructurada y modular, y se implementa en lenguajes como
Java, Smalltalk, Python o C++.
2.7.1.2 Programación multiparadigma
Los paradigmas de programación son idealizaciones, y, como tales, no siempre se
presentan de forma totalmente ‘pura’, ni siempre resultan incompatibles entre sí. Cuando se
utilizan diversos paradigmas se produce lo que se conoce como programación
multiparadigma.
El uso de distintos modelos, según se adapten mejor a las diversas partes de un
problema o a nuestra forma de pensamiento, resulta también más natural y permite expresar
de forma más clara y concisa nuestras ideas.

29
 Algunos lenguajes, como Haskell o Prolog están diseñados para encajar
perfectamente en la visión de un paradigma particular, mientras que otros, como Python, se
adaptan especialmente bien a la programación multiparadigma y dan gran libertad a la hora
de resolver un problema, al no imponen un mismo patrón para todos los casos.

30
 Unidad 3. Conceptos
básicos de
programación

Esta unidad es fundamental para el inicio en la programación, se

presentan los tipos de datos a utilizar, los operadores y como escribir
expresiones aritméticas y lógicas.
 Unidad III. El lenguaje de Programación
Objetivos de la unidad:
• Aprender a asignar el identificador adecuado a las variables y constantes.
• Identificar las palabras reservadas del lenguaje de programación.
• Asignar valores a variables y constantes.
• Aprender a escribir comentarios en el código.
• Identificar los diferentes tipos de errores durante la elaboración de un programa.
• Conocer los diferentes tipos de datos primitivos y derivados.
• Utilizar los operadores aritméticos, relacionales, de texto y lógicos.
• Realizar expresiones de tipo aritméticas y lógicas.
• Evaluar expresiones utilizando la jerarquía de operadores.
• Utilizar las funciones incorporadas en el lenguaje de programación.
• Importar módulos de terceros.
• Solicitar información del módulo.
• Utilizar funciones incorporadas en los módulos.
• Conocer los entornos de desarrollo integrado (IDE) y los entornos interactivos de
desarrollo (IDLE (por sus siglas en inglés Integrated DeveLopment Environment for
Python))
• Utilizar la función de impresión en pantalla para mostrar datos, incluyendo caracteres
especiales y formatos.
• Utilizar la función de entrada de datos para la asignación de valores a las variables
que utilizará el programa.
• Realizar ejercicios de estructura secuencial o lineal para la práctica de entrada de
datos, elaboración de expresiones e impresión de resultados.

Lenguaje de Programación Python

Dentro de los lenguajes informáticos, Python,
pertenece al grupo de los lenguajes de programación y es
clasificado como un lenguaje interpretado, de alto nivel,
multiplataforma, de tipado dinámico, multiparadigma
y orientado a objeto.
Lenguaje interpretado o de script: Un lenguaje interpretado o de script es aquel
que se ejecuta utilizando un programa intermedio llamado intérprete, en lugar de compilar el
código a lenguaje máquina que pueda comprender y ejecutar directamente una computadora
(lenguajes compilados).
La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin
embargo, los lenguajes interpretados son más flexibles y más portables.
Python tiene, no obstante, muchas de las características de los lenguajes compilados,
por lo que se podría decir que es semi interpretado. En Python, como en Java y muchos otros

32
 lenguajes, el código fuente se traduce a un pseudocódigo máquina intermedio llamado
bytecode la primera vez que se ejecuta, generando archivos .pyc o .pyo (bytecode
optimizado), que son los que se ejecutarán en sucesivas ocasiones.
Tipado dinámico: La característica de tipado dinámico se refiere a que no es
necesario declarar el tipo de dato que va a contener una determinada variable, sino que su
tipo se determinará en tiempo de ejecución según el tipo del valor al que se asigne, y el tipo
de esta variable puede cambiar si se le asigna un valor de otro tipo.
Fuertemente tipado: No se permite tratar a una variable como si fuera de un tipo
distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo
previamente. Por ejemplo, si se tiene una variable que contiene un texto (variable de tipo
cadena o string) no se tratará como un número (sumar la cadena "9" y el número 8). En otros
lenguajes el tipo de la variable cambiaría para adaptarse al comportamiento esperado, aunque
esto es más propenso a errores.
Multiplataforma: El intérprete de Python está disponible en multitud de plataformas
(UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que si no se utiliza
bibliotecas específicas de cada plataforma nuestro programa podrá correr en todos estos
sistemas sin grandes cambios.
Orientado a objetos: La orientación a objetos es un paradigma de programación en
el que los conceptos del mundo real relevantes para nuestro problema se trasladan a clases y
objetos en nuestro programa. La ejecución del programa consiste en una serie de
interacciones entre los objetos.
Python también permite la programación imperativa, programación funcional y
programación orientada a aspectos.
A diferencia de la mayoría de los lenguajes de programación, Python provee reglas
de estilos, a fin de poder escribir código fuente más legible y de manera estandarizada. Estas
reglas de estilo, son definidas a través de la Python Enhancement Proposal Nº 8 (PEP 8
https://www.python.org/dev/peps/pep-0008/).

Características de Python
Algunas características en la que se destaca Python son las siguientes:
a. Fácil de aprender y de programar
b. Fácil de leer (similar a pseudocódigo)
c. Interpretado (rápido para programar)
d. Datos de alto nivel (listas, diccionarios, sets, etc.)
e. Libre y gratuito
f. Multiplataforma (Windows, Linux y Mac)
g. Pilas incluidas (biblioteca estándar incluida en el paquete)
h. Cantidad de bibliotecas con funciones extras
i. Comunidad

Ventajas
Las ventajas del lenguaje Python son las siguientes:

33
 1. Simplificado y rápido: Este lenguaje simplifica mucho la programación “hace que
te adaptes a un modo de lenguaje de programación, Python te propone un patrón”. Es
un gran lenguaje para scripting, si usted requiere algo rápido (en el sentido de la
ejecución del lenguaje), con unas cuantas líneas ya está resuelto.
2. Elegante y flexible: El lenguaje le da muchas herramientas, si usted quiere listas de
varios tipos de datos, no hace falta que declares cada tipo de datos. Es un lenguaje tan
flexible usted no se preocupa tanto por los detalles.
3. Programación sana y productiva: Programar en Python se convierte en un estilo
muy sano de programar: es sencillo de aprender, direccionado a las reglas perfectas,
le hace como dependiente de mejorar, cumplir las reglas, el uso de las líneas, de
variables”. Además, es un lenguaje que fue hecho con productividad en mente, es
decir, Python le hace ser más productivo, le permite entregar en los tiempos que me
requieren.
4. Ordenado y limpio: El orden que mantiene Python, es de lo que más les gusta a sus
usuarios, es muy legible, cualquier otro programador lo puede leer y trabajar sobre el
programa escrito en Python. Los módulos están bien organizados, a diferencia de
otros lenguajes.
5. Portable: Es un lenguaje muy portable (ya sea en Mac, Linux o Windows) en
comparación con otros lenguajes. La filosofía de baterías incluidas, son las
bibliotecas que más usted necesita al día a día de programación, ya están dentro del
interprete, no tiene la necesidad de instalarlas adicionalmente con en otros lenguajes.
6. Comunidad: Algo muy importante para el desarrollo de un lenguaje es la comunidad,
la misma comunidad de Python cuida el lenguaje y casi todas las actualizaciones se
hacen de manera democrática.

Desventajas
Las desventajas del lenguaje Python son las siguientes:
1. Curva de aprendizaje: La “curva de aprendizaje cuando ya estás en la parte web no
es tan sencilla”.
2. Hosting: La mayoría de los servidores no tienen soporte a Python, y si lo soportan,
la configuración es un poco difícil.
3. Bibliotecas incluidas: Algunas bibliotecas que trae por defecto no son del gusto de
amplio de la comunidad, y optan a usar bibliotecas de terceros.

Instalación de Python
Para la descarga del lenguaje Python se ingresa al sitio: python.org (descargar la
versión más actual 3.X). Se ejecuta el programa descargado y se procede a instalarlo
(seleccionar 'Add Python 3.X to PATH').

34
 Luego de haberse instalado se puede ejecutar desde el menú de opciones de Windows.

Depuración
La programación es un proceso complejo y, por ser realizado por humanos, a menudo
desemboca en errores. Por razones caprichosas, esos errores se llaman bugs y el proceso de
buscarlos y corregirlos se llama depuración (en inglés “debugging”).
Hay tres tipos de errores que pueden ocurrir en un programa: de sintaxis, en tiempo
de ejecución y semánticos. Es muy útil distinguirlos para encontrarlos más rápido.

Errores sintácticos
Python sólo puede ejecutar un programa si el programa es correcto sintácticamente.
En caso contrario, es decir si el programa no es correcto sintácticamente, el proceso falla y
devuelve un mensaje de error. El término sintaxis se refiere a la estructura de cualquier
programa y a las reglas de esa estructura.
Para la mayoría de lectores, unos pocos errores sintácticos no son significativos, y
por eso puede leerse el código sin anunciar errores de sintaxis. Python no es tan permisivo.
Si hay, aunque sea un solo error sintáctico en el programa, Python mostrará un mensaje de
error y abortará la ejecución del programa. Durante las primeras semanas de su carrera como
programador pasará, seguramente, mucho tiempo buscando errores sintácticos. Sin embargo,
tal como adquiera experiencia tendrá menos errores y los encontrará más rápido.
>>> 4/*8SyntaxError: invalid syntax
>>> pirnt('Hola mundo!')
Traceback (most recent call last):
File "<pyshell#85>", line 1, in <module>
pirnt('Hola mundo!')
NameError: name 'pirnt' is not defined

Errores en tiempo de ejecución

El segundo tipo de error es un error en tiempo de ejecución. Este error no aparece
hasta que se ejecuta el programa. Estos errores también se llaman excepciones porque indican
que algo excepcional (y malo) ha ocurrido.

35
 Con los programas iniciales los errores en tiempo de ejecución ocurrirán con poca
frecuencia, así que puede pasar bastante tiempo hasta que vea uno.
>>> alumnos =56
>>> grupos =0
>>> alum_grupo =alumnos/grupos
Traceback (most recent call last):
File "<pyshell#90>", line 1, in <module>
alum_grupo = alumnos/grupos
ZeroDivisionError: division by zero

Errores semánticos
El tercer tipo de error es el error semántico. Si hay un error de lógica en su programa,
el programa se ejecutará sin ningún mensaje de error, pero el resultado no será el deseado.
Será cualquier otra cosa. Concretamente, el programa hará lo que usted le dijo.
A veces ocurre que el programa escrito no es el programa que se tenía en mente. El
sentido o significado del programa (su semántica) no es correcto. Es difícil detectar los
errores de lógica, porque requiere trabajar al revés, observando el resultado del programa
para averiguar lo que hace.
# dada la base y la altura de un triángulo rectángulo,
# determine el área.
>>> base = 4
>>> altura = 2
>>> area = base / altura
>>> print(area)
2.0

Depuración experimental
Una de las técnicas más importantes que usted aprenderá es la depuración. Aunque a
veces es frustrante, la depuración es una de las partes más intelectualmente ricas, interesantes
y estimulantes de la programación.
La depuración es una actividad parecida a la tarea de un investigador: se tienen que
estudiar las claves para inducir los procesos y eventos que llevaron a los resultados que tiene
a la vista.
La depuración también es una ciencia experimental. Una vez que se tiene la idea de
cuál es el error, se modifica el programa y se intenta nuevamente. Si su hipótesis fue la
correcta se pueden predecir los resultados de la modificación y estará más cerca de un
programa correcto. Si su hipótesis fue errónea tendrá que idearse otra hipótesis.
Para algunas personas, la programación y la depuración son lo mismo: la pro-
gramación es el proceso de depurar un programa gradualmente hasta que haga lo que usted
quiera. La idea es que debería usted comenzar con un programa que haga algo y hacer
pequeñas modificaciones, depurándolas sobre la marcha, de modo que siempre tenga un
programa que funcione.

Tipos de Datos
Una característica de Python es la cantidad y versatilidad de sus tipos de datos.
Conocerlos en profundidad sirve para tener un buen criterio a la hora de elegir como modelar

36
 nuestros datos. En líneas generales los tipos de datos (ver Figura 3-1) se dividen en primarios
o simple y compuesto o derivados:

*El tipo de dato carácter no existe en Python, un

carácter simple se representa como cadena de
caracteres (string).
** Estructuras compuestas de lenguajes como C,
FORTRAN, Pascal, Matlab, etc. Py: Estructuras
compuestas en Python.

Figura 3-1. Tipos de Datos [3].

Primarios (o primitivos):
Los datos elementales son los datos simples, llamados también escalares por ser
objetos indivisibles. Los datos simples se caracterizan por tener asociado un solo valor y son
de tipo entero, real o de coma/punto flotante (float), booleano y carácter. En Python no existe
el tipo de dato simple carácter. Aunque el dato conste de solo una letra o carácter ASCII se
representa como un dato compuesto de cadena de caracteres (string).
3.7.1.1 Números Enteros
En matemáticas los números enteros (integer) son los números naturales, sus
negativos y el cero. Ejemplos de enteros: 5, -20, 0, -104. En Python los enteros se definen
con la palabra int y dispone de una función interna type que devuelve el tipo de dato dado:
>>> type(7)
<class 'int'>
>>> a = 45
>>> type(a)
<class 'int'>

37
 En Python los datos de tipo entero se almacenan con “precisión arbitraria”, es decir
se utiliza el número de bytes necesarios para representar el número entero. Por ejemplo, los
números 5 (binario: 101) y 200 (27+26+23, binario: 11001000) se representan:
>>> bin(5)
'0b101'
>>> bin(200)
'0b11001000'

La función interna de Python bin(N) convierte un número entero a string con el binario
equivalente (0b+binario). Para comprobar el amplio rango de valores en Python, pruebe con
un valor mayor que 263, como 2220:
>>> 2**220
1684996666696914987166688442938726917102321526408785780068975640576

3.7.1.2 Números Reales

A diferencia de los enteros que son valores discretos de un número natural a otro, los
números de valores continuos del conjunto de los números reales en Matemáticas son los
llamados reales o de coma/punto flotante8, o simplemente float. No todos los números reales
se pueden representar de forma exacta en informática, debido a que muchos tienen infinitas
cifras decimales. Sin embargo, de acuerdo al nivel de precisión deseado se pueden aproximar
lo suficientemente bien estos números. Desde hace varias décadas se ha convenido el uso de
la norma IEEE 754 para representar los números reales o de punto flotante, usando la
notación científica.
Esta notación permite representar los números con una mantisa (dígitos
significativos) y un exponente separado por la letra ‘e’ o ‘E’. Por ejemplo, el número 4000
se representa por la mantisa 4 y el exponente 3, 4E3. Se lee 4 veces 10 elevado a la 3. El
número 0.25 se representa también como 25E-2. También se permite omitir el cero inicial,
.25 y el número real 4.0 se puede introducir como 4. (sin el cero después del punto).
La representación en computadores de los números reales o de punto flotante,
siguiendo la norma IEEE 754, usa la notación científica con base binaria. Python usa esta
norma en doble precisión (binary64), con 8 bytes (64 bits):
Signo Exponente Mantisa
1 bit 11 bits 52 bits

Valor = (-1)Signo * 1.Mantisa * 2(Exponente – 1023)

Así, con 64 bits se pueden representar los números (decimales) del ±5.0*10–324
(precisión) hasta ±1.7 * 10308 (rango). La norma IEEE 754 actualizada en 2008 incorpora el
formato decimal64 que utiliza la base decimal para mejorar los errores de representación
binaria (IEEE Standards Committee, 2008). Python incorpora la función Decimal del módulo
decimal con este fin.
A continuación, se muestran varios ejemplos de números reales, el tipo real (float) y
un error típico con representación de punto flotante con base binaria, en el caso del valor 0.1.
>>> 25e-2
0.25
>>> 4e3
4000.0
>>> type(4.)

38
 <class 'float'>
>>> .2e2
20.0
>>> 1.1 + 2.2 # se representa con error en punto flotante binario
3.3000000000000003

El "problema" de los números flotantes

El resultado de las operaciones con números flotantes puede ser inesperado:
>>> 0.1 + 0.1 + 0.1 - 0.3
5.5511151231257827e-17

La causa de este problema es que Python no esconde el hecho que las operaciones
que involucran números de punto flotante no son exactas debido a que hay un error inherente
al pasar internamente los números de la base 2 (la que usa realmente el hardware) a la base
10. Este error ocurre con todos los lenguajes, la diferencia es que la mayoría de los lenguajes
oculta este hecho usando algún tipo de redondeo. En Python este redondeo hay que hacerlo
de manera explícita (si hace falta para la aplicación que se está haciendo). Una manera de
contrarrestar esto es con la función incorporada (built-in) round(). Esta función requiere 2
parámetros. El primero es el número que se quiere redondear y el segundo es la precisión con
la que se quiere mostrar dicho valor. En el siguiente ejemplo se redondea el resultado de la
suma a un solo decimal:
>>> round(0.1 + 0.1 + 0.1 - 0.3,1)
0.0

Alternativamente, para no perder precisión, existe el módulo decimal. A diferencia

de las operaciones de punto flotante, con este módulo las operaciones se realizan
directamente en base 10. Si bien el resultado en este caso es exacto, la operación es más lenta
debido a que se resuelve por software mientras que las de punto flotante aprovechan mejor
el hardware. Uso del módulo decimal:
>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') -
Decimal('0.3')
Decimal('0.0')
Más información: http://docs.python.org/library/decimal.html y http://floating-point-gui.de
También, se pueden expresar números complejos o imaginarios, por ejemplo:
>>> type(5 + 5.0)
<type 'float'>
>>> 5 + 5.0
10.0
>>> type(2+3j)
<type 'complex'>
>>> (2+3j).real
2.0
>>> (2+3j).imag
3.0

39
3.7.1.3 Cadenas.
Los textos se llaman cadena de caracteres (en inglés string). Los caracteres están
ordenados de acuerdo a la tabla ASCII. Por ejemplo, los caracteres ASCII ordenados del
valor decimal 20 al 127 son:
! " # $ % & ' ( ) * +, -. / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d
e f g h i j k l m n o p q r s t u v w x y z { | } ~

El orden en que se representan sirve para evaluar cuál es mayor que otro, de acuerdo
al valor numérico en que figuran en el código ASCII. Por ejemplo 'b' es mayor que 'a'. El tipo
carácter no está definido en Python. Los caracteres simples se definen igual que un texto con
una sola letra, es decir como una cadena de caracteres(string).
>>> type('a')
<class 'str'>

Se puede observar que el carácter 'a' en Python es de tipo string (str).

3.7.1.4 Valores booleanos.
Los datos booleanos toman el valor True (1 lógico) o False (0 lógico). El nombre
booleano se usa luego que George Boole, matemático inglés, propusiera en el siglo XIX un
sistema algebraico basado en estos dos valores lógicos y tres operaciones lógicas: “y lógico”,
“o lógico” y la negación. Ejemplos:
>>> a = 3 > 2
>>> a
True
>>> type(a)
<class 'bool'>
>>> 4 > 5
False

Derivados
a) Los datos compuestos o estructurados comprenden aquellos datos con elementos
de valores de un mismo tipo o de diferentes tipos, que se representan unificados
para ser guardados o procesados. Las listas, diccionarios, tuplas, entre otros serán
tratados en temas posteriores. Estos datos se pueden subclasificar según distintos
parámetros: Ordenados (o secuenciales) / Desordenados y Mutables / Inmutables.
Los tipos de datos en Python se pueden resumir en la Tabla 3-1
Tabla 3-1. Tipos de datos en Python
Tipo Clase Notas Ejemplo
int Número Precisión fija, convertido en 42
entero long en caso de overflow.
long Número Precisión arbitraria 42L ó
entero 456966786151987643L
float Número Coma flotante de doble 3.1415927
decimal precisión
complex Número Parte real y parte imaginaria (4.5 + 3j)
complejo j.
bool Booleano Valor booleano verdadero o True o False
falso

40
 str Cadena Inmutable ‘Cadena’
list Secuencia Mutable, puede contener [4.0, ‘Cadena’,
objetos de diversos tipos True]
tuple Secuencia Inmutable, puede contener (4.0, ‘Cadena’,
objetos de diversos tipos True)
set Conjunto Mutable, sin orden, no set([4.0, ‘Cadena’,
contiene duplicados True])
frozen Conjunto Inmutable, sin orden, no frozenset([4.0,
set contiene duplicados ‘Cadena’,
True])
dict Mapping Grupo de pares clave:valor {‘key1’: 1.0,
‘key2’: False}
Mutable: si su contenido (o dicho valor) puede cambiarse en tiempo de ejecución.
Inmutable: si su contenido (o dicho valor) no puede cambiarse en tiempo de ejecución.

Datos compuestos de cadena de caracteres: string

El tipo de dato string es la estructura básica para manejar texto, que incluye caracteres
alfanuméricos y demás caracteres de la codificación ASCII o UTF-8. Los string en Python
se definen entre comillas simples (' ') o dobles (" "). También se pueden definir entre comillas
triples (""") cuando se tengan múltiples líneas. Por ejemplo,
>>> 'Hola'
'Hola'
>>> b = "Casa de madera"
>>> type(b)
<class 'str'>
>>> type(15)
<class 'int'>
>>> type('15')
<class 'str'>

Los textos 'Hola' o "Casa de madera" son de tipo string en general en todos los lenguajes.
El valor 15 es un número de tipo entero (int), sin embargo, el valor '15' es un string (str). Si
se incluyen comillas (") o comillas simples (') dentro de un string pueden dar resultados
erróneos cuando estos caracteres se usan para delimitar el string. Se puede emplear dentro
del texto aquel carácter que no se ha usado de delimitador:
>>> 'Ella dijo "Qué lindo"'
'Ella dijo "Qué lindo"'
>>> "He doesn't know"
"He doesn't know"

Sin embargo, en estos casos se puede también usar el carácter barra invertida (\) que
sirve de escape para agregar comillas u otras acciones dentro del string:
>>> print('He doesn\'t know I \"will come\"')
He doesn't know I "will come"

El carácter barra invertida (llamado carácter de escape) seguido de n (\n) indica salto
a nueva línea. Se pueden incluir múltiples líneas en un string usando triples comillas """ ...
"""".
En este caso los fines de línea están incluidos. Los salto a nueva línea se aprecian
cuando se presenten en pantalla con la función interna print():
>>> print('Cambiamos de línea \nNueva línea')

41
 Cambiamos de línea
Nueva línea
>>> """
Programa:
Autor:
Fecha:
"""
'\n Programa:\n Autor:\n Fecha:\n '

A continuación, algunos ejemplos del tipo de dato cadena:

>>> # Comillas simples
>>> cadenaa = 'Texto entre comillas simples'
>>> cadena
>>> type(cadenaa)
>>>
>>> # Comillas dobles
>>> cadenab = "Texto entre comillas dobles"
>>> cadenab
>>> type(cadenab)
>>> # Repetición de cadena
>>> cadrep = "Cadena" * 3
>>> cadrep
>>> type (cadrep)

>>> # Concatenación de cadena

>>> nombre = "Leonardo"
>>> apellido = "Caballero"
>>> nombre_completo = nombre + " " + apellido
>>> nombre_completo
>>> type (nombre_completo)

>>> "Tamaño de cadena '", nombre_completo, "' es:",

len(nombre_completo)

>>> # Acceder a rango de la cadena

>>> nombre_completo[3:13]

>>> # Cadena con código escapes

>>> cadenaesc = 'Texto entre \n\tcomillas simples'
>>> cadenaesc
>>> type(cadenaesc)

No pueden mezclarse valores numéricos con cadenas:

>>> 'hola' + 2
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
'hola' + 2
TypeError: cannot concatenate 'str' and 'int' objects
>>> 'hola' + str(2)
'hola2'

Este error se debe a que Python es un lenguaje de tipado dinámico pero fuerte. Es
dinámico porque en cualquier momento se puede definir una variable con un tipo de dato
distinto. En los lenguajes de tipado estático una vez que se crea un dato de un tipo particular,
esto no puede alterarse. Python es de tipado fuerte porque una vez definido, este no puede
convertirse automáticamente en otro tipo de datos. Por ejemplo, en PHP '1' + 1 es igual a 2.
En Python sumar un string con un int es imposible, porque Python no presupone nada con
respecto a cómo hacer esta operación no definida. Lo que sí es posible es "convertir" el '1' en
1 y obtener 2 (o convertir el 1 en '1' y obtener '11').

42
 Listas
Se trata de conjuntos ordenados de elementos, encerrados por corchetes y separados
por comas. El orden comienza con el índice 0 para el primer lugar de la Lista. Pueden
agruparse valores de distintos tipos de datos básicos, y es posible agregar, eliminar o
modificar elementos de las listas en cualquier momento (las listas son mutables en Python).
In [7]:
# Definición de una lista y referencia a un índice
lista = [10,20,30,40]
print(lista)
print(lista[0])
print(lista[3])
[10, 20, 30, 40]
10
40

In [8]:
# Modificación de una lista
lista[1] = 25
print(lista)
[10, 25, 30, 40]

In [9]:
# Generación de porciones a partir de una lista
sublista = lista[1:3]
print(lista)
print(sublista)
print(lista[:-1])
print(lista[:])
[10, 25, 30, 40]
[25, 30]
[10, 25, 30]
[10, 25, 30, 40]

Tuplas
Las Tuplas son básicamente listas de elementos estáticas, es decir, que no pueden
modificarse (las Tuplas son inmutables en Python). Para su definición, en lugar de corchetes
se encierran valores separados por comas entre paréntesis.
In [10]:
# Definición de una tupla y referencia a un índice
tupla = (6, 7, 8,9)
print(tupla)
print(tupla[0])
print(tupla[3])
(6, 7, 8, 9)
6
9
In [11]:
# Generación de porciones a partir de una tupla
subtupla = tupla[1:3]
print(tupla)
print(subtupla)
print(tupla[:-1])
print(tupla[:])

43
 (6, 7, 8, 9)
(7, 8)
(6, 7, 8)
(6, 7, 8, 9)

La similitud entre listas y tuplas es tan explícita que se puede bloquear una lista
transformándola en una tupla con la función tuple() o bien desbloquear una tupla para
transformarla en una lista con la función list()
In [12]:
print(tuple(lista))
print(list(tupla))
(10, 25, 30, 40)
[6, 7, 8, 9]

Diccionarios
En los Diccionarios cada elemento se compone de un par clave-valor, y para su
definición es necesario encerrar los elementos entre llaves. Es posible acceder a un valor
utilizando su clave, pero no al revés. Por este motivo, no se pueden repetir las claves para
elementos distintos, pero sí es posible agregar, eliminar o modificar valores (Los diccionarios
son mutables).
In [13]:
# Definición de un diccionario
diccionario = {"Codigo":7512,"Materia":"Análisis Numérico I"}
print(diccionario)
{'Codigo': 7512, 'Materia': 'Análisis Numérico I'}
In [14]:
# Referencia a un índice
print(diccionario["Codigo"])
print(diccionario["Materia"])
7512
Análisis Numérico I

Elementos Básicos del Lenguaje

Identificador
El identificador es el nombre que se le asigna a una variable, constante y otros
elementos (función, clase, módulo u otro objeto) para referenciarlos en el código. Para crearlo
se debe tomar en cuenta las siguientes convenciones:
a. Debe comenzar por una letra preferiblemente en minúscula, seguida de letras y
números.
b. No puede contener caracteres especiales, excepto el subrayado.
c. No deben tener más de 255 caracteres.
d. No deben existir dos iguales en el mismo ámbito
e. Python distingue entre mayúsculas y minúsculas. Es decir, que A y a son para
Python variables distintas.

44
 f. Las palabras reservadas del lenguaje están prohibidas. En caso de que intente dar
un nombre incorrecto a una variable, Python mostrará un mensaje de error al
ejecutar el programa.
g. Python permite identificadores con vocales acentuadas, como área, incluso la ñ y
las letras griegas. Aunque no es recomendable esta práctica por si se cambia de
lenguaje de programación.
Aunque no es obligatorio, normalmente conviene que el nombre de la variable esté
relacionado con la información que se almacena en ella, para que sea más fácil entender el
programa. Mientras se escribe un programa, esto no parece muy importante, pero si consulta
un programa que ha escrito hace tiempo (o que ha escrito otra persona), te resultará mucho
más fácil entender el programa si los nombres están bien elegidos.
En el caso de definir una cadena, es decir una variable que contiene valores
alfanuméricos (letras, números y caracteres especiales), debe escribir su valor entre comillas
(") o apóstrofes ('), como prefiera.
Hay que tener cuidado también con las funciones internas o predefinidas del lenguaje
(built-in functions), se pueden consultar la lista actual de funciones internas en:
https://docs.python.org/3.3/library/functions.html. Si se identifica una variable con el
nombre de una función predefinida, ésta luego no podrá ser llamada pues su identificador se
ha sobrescrito con la variable. Por ejemplo, la función type se utiliza para saber el tipo de
dato, si a una variable se le identifica con el nombre type, se pierde esta función en el
programa.

Palabras reservadas en Python

Los lenguajes de programación, contienen un conjunto de palabras reservadas que no
pueden usarse como nombre de variable. Una lista parcial de palabras reservadas en Python
es la siguiente:
>>> help("keywords")
and as assert break class continue def del elif
else except exec finally for from global if import
in is lambda not or pass print raise return
try while with yield

Indique si los siguientes identificadores son válidos.

a)Identificador g)desviación m)UnaVariable s)área
b)Indice\dos h)año n)a(b) t)area-rect
c)Dos palabras i)from o)12 u)x______
d)__ j)var! p)uno.dos v)_ 1
e)12horas k)’var’ q)x w)________ 1
f)hora12 l)import_from r)π x)_x_x_x
Anote sus observaciones.

45
 Variables
Una variable es un objeto o tipo de datos cuyo valor puede cambiar durante el
desarrollo del algoritmo o ejecución del programa. Dependiendo del lenguaje, hay diferentes
tipos de variables, tales como enteras, reales, carácter, lógicas y de cadena. Una variable
que es de un cierto tipo puede tomar únicamente valores de ese tipo. Una variable de carácter,
por ejemplo, puede tomar como valor sólo caracteres, mientras que una variable entera puede
tomar sólo valores enteros [1].
Si se intenta asignar un valor de un tipo a una variable de otro tipo se producirá un
error de tipo. Una variable se identifica por los siguientes atributos: nombre que lo asigna y
tipo que describe el uso de la variable.
En Python, una variable se define con la sintaxis:
>>> identificador = valor_de_la_variable

Cada variable, tiene un nombre y un valor, el

cual define a la vez, el tipo de datos de la variable. Soy la
variable x,
Las variables en Python se crean cuando se y estoy
apuntando a
definen, es decir, cuando se les asigna un valor. Para un objeto
crear una variable, se escribe la variable, el signo Int.

igual y el valor que se asignará a la variable. A

continuación, se tiene algunos ejemplos de
definiciones de variables:
>>> x = 42
>>> nombre = 'Pedro Pérez'
>>> cantidad = 10 + 5
>>> importe = 2.5
>>> caracter = 'p'
>>> edad = 23
>>> encontrado=True
Profundizando un poco más con la referencia de la variable, véase el siguiente código:
>>> x = 42 Soy la variable
>>> y = x x y estoy
Soy la variable
apuntando a un
Se asigna a la variable x el objeto Int. y también estoy
apuntando a un
número 42. Luego, se asigna x a la objeto Int.
variable y. Esto significa que ambas
variables hacen referencia al mismo
número.
¿Qué sucederá si se le asigna a la
variable y un nuevo valor?
y = 78

46
 Python creará un nuevo número
entero con el valor 78 y luego la variable y
hará referencia a este número recién creado. Ahora
Todavía
apunto al
En resumen: en Python una variable apunto al
valor 78
valor 42
no se guarda directamente en la memoria; se
crea un objeto (cuya posición en la memoria
se llama identidad); y se asocia el
identificador de la variable a la identidad de
ese objeto. La Figura 3-2 muestra un ejemplo
del uso de variables de un mismo valor en
Python, comparado con otros lenguajes de programación [3].

Figura 3-2. Identificador de variable y su identidad.

Constante
Una constante es un dato que permanece sin cambios durante todo el desarrollo del algoritmo
o durante la ejecución del programa [1].
En Python no se puede utilizar constantes, para no modificar su valor en el código, se
debe utilizar como norma nombres descriptivos y en mayúsculas separando las palabras por
guiones bajos, antes y después del signo igual “=”, coloque un espacio en blanco, por
ejemplo:
>>> ACELERACION_GRAVEDAD = 10

Variables no inicializadas
En Python, la primera operación sobre una variable debe ser la asignación de un valor.
No se puede usar una variable a la que no se ha asignado previamente un valor:
>>> a + 2
Traceback (most recent call last)
File "<stdin>", line 1, in ?
NameError: name ’a’ is not defined

Como puedes ver, se genera una excepción NameError, es decir, de “error de

nombre”. El texto explicativo precisa aún más lo sucedido: “name ’a’ is not defined”, es
decir, “el nombre a no está definido”. La asignación de un valor inicial a una variable se
denomina inicialización de la variable. En Python no es posible utilizar variables no
inicializadas.

47
 Asignación múltiple
Otra de las ventajas que Python provee, es la de poder asignar en una sola instrucción,
múltiples variables:
nombre, cedula, edad = 'José', 35125569, 25

En una sola instrucción, se declaran tres variables: nombre, cédula y edad a las cuales
se le asigna un valor determinado a cada una.

Comentarios
La documentación de un programa es el conjunto de información interna y externa al
programa, que facilitará su posterior mantenimiento y puesta a punto. La documentación
puede ser interna y externa. La documentación externa es aquella que se realiza
externamente al programa y con fines de mantenimiento y actualización; es muy importante
en las fases posteriores a la puesta en marcha inicial de un programa. La documentación
interna es la que se acompaña en el código o programa fuente y se realiza a base de
comentarios significativos. Estos comentarios se representan con diferentes notaciones,
según el tipo de lenguaje de programación.
En Python, los comentarios comienzan con el signo numeral (#) seguido de un
espacio. La siguiente línea representa un comentario y, por lo tanto, sería ignorada por el
intérprete de Python:
>>> # Esto es un comentario

Un comentario también puede estar a continuación de código interpretable, en la

misma línea, de este modo:
>>> GRAVEDAD = 9.8 # Aceleración de gravedad, en m/s^2

A continuación, se muestra un ejemplo típico de comentarios en un programa en

Python denominado cabecera.
# Nombre: ejemplo_estructura_programa.py
# Propósito: Ejemplo de archivo con la estructura de un programa
#
# Origen: Propio
# Autor: José María Herrera-Fernández y Luis Miguel Sánchez Brea
#
# Creación: 12 de septiembre de 2013
# Historia:
#
# Dependencias: scipy, matplotlib
# Licencia: GPL

Esta sección es estrictamente voluntaria, sin embargo, es muy útil cuando varios
usuarios programan en el mismo archivo.
Nombre El nombre del archivo al guardar por primera vez. En este caso de
ejemplo_programa.py.

48
 Propósito La finalidad que se persigue al crear el programa, * Crear gráfica del
seno*, * Calcular los coeficientes de un polinomio*, etc.
Origen Si el origen del programa no es propio conviene saber su procedencia
por si se debe consultar de nuevo la fuente original en un futuro.
Autor(es) Los nombres de los creadores del programa.
Creación Fecha de creación del programa.
Historia En caso de modificaciones posteriores, es en esta sección donde se
indica la modificación, la fecha de la realización y el autor de la
misma.
Dependencias Módulos necesarios para la ejecución del programa. Por ejemplo:
scipy, matplotlib.
Licencia Apartado correspondiente a los derechos de autor.
PEP 8: comentarios, Comentarios en la misma línea del código deben separarse con
dos espacios en blanco. Luego del símbolo # debe ir un solo espacio en blanco.

Punto py

Hay un convenio por el que los archivos que contienen programas Python tienen
extensión py en su nombre. La extensión de un nombre de archivo son los caracteres del
mismo que suceden al (último) punto. Un archivo llamado ejemplo.py tiene extensión py.
La idea de las extensiones viene de antiguo y es un mero convenio. Puedes prescindir de
él, pero no es conveniente. En entornos gráficos (como KDE, Gnome o Microsoft
Windows) la extensión se utiliza para determinar qué icono va asociado al archivo y qué
aplicación debe arrancarse para abrir el archivo al hacer clic (o doble clic) en el mismo.

Operadores
Los operadores son aquellos elementos del lenguaje que combinan variables,
constantes, valores literales, instrucciones, etc., para obtener un valor numérico, lógico, de
cadena, etc., como resultado.
La combinación de operadores con variables, instrucciones, etc., se denomina
expresión, mientras que a los elementos integrantes de una expresión y que no son
operadores, se les denomina operandos.
En función de la complejidad de la operación a realizar, o del tipo de operador
utilizado, una expresión puede ser manipulada a su vez como un operando dentro de otra
expresión de mayor nivel.
Los operadores se clasifican en las categorías detalladas a continuación, según el tipo
de expresión a construir.
a) aritméticas,
b) relaciónales,
c) lógicas,
d) carácter.

49
 El resultado de la expresión aritmética es de tipo numérico; el resultado de la
expresión relacional y de una expresión lógica es de tipo lógico, el resultado de una expresión
de cadena es de tipo cadena.

Operadores Aritméticos
Un operador aritmético (Tabla 3-2) toma dos operandos como entrada, realiza un
cálculo y devuelve el resultado.
Considera la expresión, “a = 2 + 3”. Aquí, 2 y 3 son los operandos y + es el operador
aritmético. El resultado de la operación se almacena en la variable a.
Tabla 3-2. Operadores Aritméticos.
Nombre Símbolo Ejemplo Resultado Resultado tipo
Suma + a = 10 + 5 a es 15 Entero si a y b
enteros; real si
alguno es real
Resta - a = 12 - 7 a es 5 Entero si a y b
enteros; real si
alguno es real
Negación a = -5 a es -5 De igual tipo, con
signo contrario
Multiplicación * a = 7 * 5 a es 35 Entero si a y b
enteros; real si
alguno es real
División / a = 12.5 / 2 a es 6.25 Siempre es real
División // a = 12.5 // 2 a es 6.0 Devuelve la parte
entera entera del cociente
a÷b
Módulo % a = 27 % 4 a es 3 Devuelve el resto de
la división a÷b
Exponente ** a = 2 ** 3 a es 8 Entero si a y b
enteros; real si
alguno es real

PEP 8: operadores Siempre colocar un espacio en blanco, antes y después de un operador

Operadores aritméticos

Todos los operadores aritméticos no existen en todos los lenguajes de

programación; por ejemplo, en Visual Basic y en Pascal no se utiliza // y % para la
división entera y el residuo. El operador exponenciación es diferente según sea el
tipo de lenguaje de programación clásico elegido (^ en Visual Basic, en Pascal para
calcular la potencia z=xn se calcula aplicando propiedades de logaritmo como la
siguiente: z:=Exp(n*Ln(x))).

Los operadores se evalúan en una expresión siguiendo la tabla de jerarquías (Tabla

3-3) que se presenta a continuación:
Tabla 3-3. Prioridad de los operadores aritméticos.

50
 Prioridad de operadores aritméticos
Potenciación ( ** )
Negación ( - )
Multiplicación y división real ( * , /)
División entera ( // )
Resto de división ( % )
Suma y resta ( + , - ) Nota: La potenciación es
asociativa por la derecha. La expresión
2
2 ** 3 ** 2 equivale a 2(3 ) = 29 = 512, y no a (23 )2 = 82 = 64
3.9.1.1 División Entera
En Python 2 el resultado de dividir dos números enteros se redondea al entero más
cercano. Como resultado de dividir 3/2 se obtendrá 1. Para obtener una división con punto
flotante tanto el numerador como el denominador deben ser explícitamente float. Por tanto,
3.0/2 o 3/2.0 o 3.0/2.0 su resultado es 1.5; Python 3 evalúa 3 / 2 como 1.5 por defecto, lo cual
es más intuitivo para los programadores.
3.9.1.2 Ejemplo de operadores numéricos
>>> a = 26
>>> b = 11.3
>>> c = 5
>>> d = 3.5

>>> # +, Añade valores a cada lado del operador

>>> a + b

>>> # -, Le resta el operando de la derecha al de la izquierda

>>> c – a

>>> # *, Multiplica los valores de ambos lados del operador

>>> d * c

>>> # **, Multiplica el operando de la izquierda tantas veces el

operador de la derecha.
>>> c ** 2
>>> # /, División real
>>> float(c) / a
>>> 7 / 3

>>> # %, Divide el operando de la izquierda por el operador del lado

derecho y devuelve el resto o residuo.
>>> 7 % 3

3.9.1.3 Evaluación de expresiones aritméticas.

¿Evalúe las siguientes expresiones? Presta especial atención al tipo de datos que
resulta de cada operación individual. Realiza los cálculos paso a paso y comprueba el
resultado con el computador.

51
 a) 1 / 2 / 4.0 g) 4.0 ** (1 / 2) + 1 / 2
b) 1 / 2.0 / 4.0 h) 4.0 ** (1.0 / 2) + 1 / 2.0
c) 1 / 2.0 / 4 i) 3e3 / 10
d) 1.0 / 2 / 4 j) 10 / 5e-3
e) 4 ** .5 k) 10 / 5e-3 + 1
f) 4.0 ** (1 / 2) l) 3 / 2 + 1

Operadores de Relación o Comparación

Los operadores de relación o de comparación permiten comparar valores de tipo
numérico o cadena. Los operadores de relación sirven para expresar las condiciones en los
programas.
Los operadores de relación se muestran en la Tabla 3-4. El formato general para las
comparaciones es:
Expresión1 operador de relación Expresión2
y el resultado de la operación será True o False. Así, por ejemplo, si a =
4 y b = 3, entonces
a > b el resultado es True
mientras que
(a - 2) < (b - 4) el resultado es False
Los operadores de relación (Tabla 3-4) se pueden aplicar a cualquiera de los cuatro
tipos de datos estándar: enteros, real, lógico, cadena. La aplicación a valores numéricos es
evidente.
Tabla 3-4. Operadores de Relación o Comparación.
Símbolo Significado Ejemplo Resultado
== Igual que 5 == 7 Falso
!= Distinto que rojo != verde Verdadero
< Menor que 8 < 12 Verdadero
> Mayor que 12 > 7 Falso
<= Menor o igual que 12 <= 12 Verdadero
>= Mayor o igual que 4 >= 5 Falso

Todos los operadores tienen el mismo nivel de jerarquía.

En Python los operadores relacionales pueden ser encadenados, tal como se
acostumbra en matemáticas, de la siguiente manera:
>>> x = 4
>>> 0 < x <= 10
True
>>> 5 <= x <= 20
False

La expresión 0 < x <= 10 es equivalente a (0 < x) and (x <= 10).

3.9.2.1 Ejemplo de operadores relacionales
>>> a = 5
>>> b = 5
>>> a1 = 7

52
 >>> b1 = 3
>>> c1 = 3

>>> cadena1 = 'Hola'

>>> cadena2 = 'Adiós'

>>> # igual
>>> c = a == b
>>> c

>>> cadenas = cadena1 == cadena2

>>> cadenas

>>> # diferente
>>> d = a1 != b
>>> d

>>> cadena0 = cadena1 != cadena2

>>> cadena0

>>> # mayor que

>>> e = a1 > b1
>>> e

>>> # menor que

>>> f = b1 < a1
>>> f

>>> # mayor o igual que

>>> g = b1 >= c1
>>> g

>>> # menor o igual que

>>> h = b1 <= c1
>>> h

Operaciones de texto
Los operadores + y * tienen otras interpretaciones cuando sus operandos son strings.
+ es el operador de concatenación de strings: une dos strings uno después del otro:
>>> 'perro' + 'gato'
'perrogato'

La concatenación no es una suma ni una operación conmutativa.

* es el operador de repetición de strings. Recibe un operando string y otro entero, y
entrega como resultado el string repetido tantas veces como indica el entero:
>>> 'waka' * 2
'wakawaka'

Otras operaciones que pueden ser útiles son: obtener el i-ésimo carácter de un string
(partiendo desde cero) usando los corchetes:
>>> nombre = 'Pedro'
>>> nombre[0]
'P'
>>> nombre[1]
'e'
>>> nombre[2]
'd'

53
 Comparar strings alfabéticamente con los operadores relacionales (lamentablemente
no funciona con acentos y eñes):
>>> 'a' < 'abad' < 'abeja'
True
>>> 'zapato' <= 'alpargata'
False

Obtener el largo de un string con la función len:

>>> len('paralelepípedo')
14
>>> len('')
0

Verificar si un string está dentro de otro con el operador in:

>>> 'pollo' in 'repollos'
True
>>> 'pollo' in 'gallinero'
False

Operadores Lógicos
Hay tres operadores lógicos en Python: la y lógica o conjunción (and, ver Tabla 3-5),
la o lógica o disyunción (or, ver Tabla 3-6) y el no lógico o negación (not, ver Tabla 3-7).
El operador and devuelve como resultado el valor verdadero si y sólo si son ciertos
sus dos operandos. Esta es su tabla de verdad:
Tabla 3-5. Operador lógico and.
and
operando resultado
izquierdo derecho
True True True
True False False
False True False
False False False

El operador or proporciona True si cualquiera de sus operandos es True, y False sólo

cuando ambos operandos son False. Esta es su tabla de verdad:
Tabla 3-6. Operador lógico or.
or
operando resultado
izquierdo derecho
True True True
True False True
False True True
False False False

El operador not es unario, y proporciona el valor True si su operando es False y

viceversa. He aquí su tabla de verdad:
Tabla 3-7. Operador lógico not.
not
Operando Resultado

54
 True False
False True

La precedencia está dada por la siguiente lista (Tabla 3-8), en que los operadores
lógicos han sido listados en orden de mayor a menor precedencia:
Tabla 3-8. Prioridad de operadores lógicos.
Prioridad de operadores Lógicos
not
and
or

Evaluación en cortocircuito de expresiones lógicas

Cuando Python está procesando una expresión lógica, como x >= 2 and (x/y) >2,
evalúa la expresión de izquierda a derecha. Debido a la definición de and, si x es menor de
2, la expresión x >= 2 resulta ser falsa, de modo que la expresión completa ya va a resultar
falsa, independientemente de si (x/y) > 2 se evalúa como verdadera o falsa.
Cuando Python detecta que no se gana nada evaluando el resto de una expresión
lógica, detiene su evaluación y no realiza el cálculo del resto de la expresión. Cuando la
evaluación de una expresión lógica se detiene debido a que ya se conoce el valor final, eso
es conocido como cortocircuitar la evaluación.
El funcionamiento en cortocircuito nos descubre una ingeniosa técnica conocida
como patrón guardián. Examina la siguiente secuencia de código en el intérprete de Python:
>>> x = 6
>>> y = 2
>>> x >= 2 and (x/y) > 2
True
>>> x = 1
>>> y = 0
>>> x >= 2 and (x/y) > 2
False
>>> x = 6
>>> y = 0
>>> x >= 2 and (x/y) > 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>>

La tercera operación ha fallado porque Python intento evaluar (x/y) e y era cero, lo
cual provoca un runtime error (error en tiempo de ejecución). Pero el segundo ejemplo no
falló, porque la primera parte de la expresión x >= 2 fue evaluada como falsa, así que (x / y)
no se ejecutó debido a la regla del cortocircuito, y no se produjo ningún error.
Es posible construir las expresiones lógicas colocando estratégicamente una
evaluación para validar justo antes de la evaluación que podría causar un error, como se
muestra a continuación:
>>> x = 1
>>> y = 0
>>> x >= 2 and y != 0 and (x/y) > 2
False
>>> x = 6
>>> y = 0

55
 >>> x >= 2 and y != 0 and (x/y) > 2
False
>>> x >= 2 and (x/y) > 2 and y != 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>>

En la primera expresión lógica, x >= 2 es falsa, así que la evaluación se detiene en el

and. En la segunda expresión lógica, x >= 2 es verdadera, pero y != 0 es falsa, de modo que
nunca se alcanza (x / y).
En la tercera expresión lógica, y != 0 va después del cálculo de (x / y) de modo que
la expresión falla con un error.
En la segunda expresión, se dice que y != 0 actúa como validación para garantizar
que solo se ejecute (x / y) en el caso de que y no sea cero.

El valor None

Existe un valor especial en Python para representar aquellos casos en los que “no
hay valor”; es el valor None. Este valor es el único de su tipo. Se interpreta como falso en
las expresiones lógicas y es el devuelto por las funciones que no devuelven ningún valor
explícitamente. Cuando el resultado de una expresión es None, el intérprete no lo muestra:
>>> None
>>>

Ejercicios de Operadores Lógicos

1) Determinar el valor de las expresiones lógicas siguientes (y luego comprobar el resultado
en el intérprete de Python):
a) True and not False or False
b) False or False or True
c) not (False or False) and True
d) not False and not False and True
2) Obtener las expresiones booleanas equivalentes de los enunciados siguientes:
a) a no está entre –1 y 1 ni entre 2 y 3.
b) a y b no son mayores a 5.
c) a es un múltiplo de 10 ubicado entre 3000 y 4000.
d) a está entre [5.0 y 10.0) o entre (15.0 y 20.0].
e) a es un número impar múltiplo de 5, o par acabado en 0.
f) a no es el mayor ni el menor número entre a, b, y c.
g) a, b, y c son todas ciertas o todas falsas.
h) El cociente de a entre b es igual a su resto (residuo).

56
 i) Los números a, b, y c están incluidos en un intervalo menor a la unidad.
j) El menor de a y b está entre 0 y 1.
3) Dadas dos variables reales x e y, escribir una expresión booleana que valide que x está
fuera del intervalo [100, 200] e y está dentro del intervalo (20,40].
4) Sean A, B y C tres variables enteras que representan las ventas de tres productos
respectivamente, escribir expresiones lógicas (booleanas) que representen las siguientes
afirmaciones:
a) Las ventas del producto A son las más elevadas.
b) Ningún producto tiene unas ventas inferiores a 300.
c) Algún producto tiene unas ventas superiores a 1000.
d) La media de ventas es superior a 700.
e) El producto C no es el más vendido
5) Las edades de tres primos se guardan en las variables a, b, c. Escribir una expresión
booleana que evalúe True si solamente 2 de los 3 primos tienen la misma edad y, además,
la suma de las 3 edades sea múltiplo de 3.
6) Obtener las expresiones booleanas equivalentes a los enunciados siguientes:
a) No se cumple z de tipo booleano o que x e y sean positivas y su suma múltiplo de 7.
b) La suma de a y b, de tipo entero, es múltiplo de 5 y al menos una de ellas es par.
c) x no es la más grande ni la más pequeña de entre x, y, z de tipo real.
d) La suma de a y b, de tipo entero, es múltiplo de 5 y ambas son impares.
e) Exactamente dos de entre x, y, z son positivas.
f) La más pequeña de las variables a y b de tipo real está entre 0 y 1.
g) Una variable a de tipo entero pertenece al conjunto de los números menores de 100 o
mayores de 200 y además es un impar múltiplo de 3.
h) x, y, z de tipo entero son todas impares o todas pares.
i) ξ de tipo real es mayor que la distancia entre x e y de tipo real. xi**2 > (x-y)**2 #
Debe usarse un identificador válido (xi), no ξ
j) Alguno de los valores absolutos de a, b o c de tipo real es menor que 1.
k) Alguno de los valores de a, b o c de tipo real está en medio del intervalo formado por
los otros dos.
l) x, y, z de tipo real pueden ser los lados de un triángulo. Los valores podrán ser un
triángulo cuando el valor más grande sea menor que la suma de los otros dos.
m) No se cumple una persona trabaja (trabaja de tipo booleano) o sueldo de tipo entero
está entre 1000 y 2000.

57
 Prioridad de evaluación de expresiones con diferentes operadores
Cuando una expresión tiene operadores de diferentes grupos, se evaluarán de acuerdo
a la Tabla 3-9 [4]:
Tabla 3-9: Características de los operadores Python. El nivel de precedencia 1 es
el de mayor prioridad.
Operadores Operación Operador Paridad Asociatividad Precedencia
Aritméticos Exponenciación ** Binario Por la 1
derecha
Identidad + Unario — 2
Cambio de - Unario — 2
signo
Multiplicación * Binario Por la 3
izquierda
División / Binario Por la 3
izquierda
Módulo (o % Binario Por la 3
resto) izquierda
Suma + Binario Por la 4
izquierda
Resta - Binario Por la 4
izquierda
Comparación Igual que == Binario — 5
Distinto de != Binario — 5
Menor que < Binario — 5
Menor o igual <= Binario — 5
que
Mayor que > Binario — 5
Mayor o Igual >= Binario — 5
que
Lógicos Negación not Unario — 6
Conjunción and Binario Por la 7
izquierda
Disyunción or Binario Por la 8
izquierda

Esto significa, por ejemplo, que las multiplicaciones se evalúan antes que las sumas,
y que las comparaciones se evalúan antes que las operaciones lógicas:
>>> 2 + 3 * 4
14
>>> 1 < 2 and 3 < 4
True

Operaciones dentro de un mismo nivel son evaluadas en el orden en que aparecen en

la expresión, de izquierda a derecha:
>>> 15 * 12 % 7 # es igual a (15 * 12) % 7
5

La única excepción a la regla anterior son las potencias, que son evaluadas de
derecha a izquierda:
>>> 2 ** 3 ** 2 # es igual a 2 ** (3 ** 2)
512

58
 Uso de paréntesis para alterar la prioridad de operadores
Se Puede alterar el orden natural de prioridades entre operadores utilizando los
paréntesis, encerrando entre ellos los elementos que se resuelven en primer lugar dentro de
una expresión. De esta forma, se resolverán en primer lugar las operaciones que se encuentren
en los paréntesis más interiores, finalizando por las de los paréntesis exteriores. Es importante
tener en cuenta, que dentro de los paréntesis se seguirá manteniendo la prioridad explicada
anteriormente.

Operadores abreviados de asignación

Estos operadores simplifican la escritura de expresiones, facilitando la creación del
código. El resultado empleando operadores abreviados (Tabla 3-10) en una expresión, es el
mismo que utilizando la sintaxis normal, pero con un pequeño ahorro en la escritura de
código. Se utilizan en Python a partir de la versión 2.0, cuando la variable aparece a la
derecha e izquierda de la instrucción de asignación.
Tabla 3-10. Operadores abreviados
Operación Expresión Normal Expresión Abreviada
Suma a = a + b a += b
Resta a = a - b a -= b
Multiplicación a = a * b a *= b
División a = a / b a /= b
División Entera a = a \ b a //= b
Potencia a= a ** b a **= b
Resto o residuo a= a % b a %= b

Por ejemplo:
>>> c = c + 1 # la variable c se incrementa en 1
>>> d = d - 1 # la variable d se decrementa en 1
>>> c += 1 # equivale a: c = c + 1
>>> x += 0.01 # equivale a: x = x + 0.01
>>> d -= 2 # equivale a: d = d – 2
>>> y *= d+1 # equivale a: y = y * (d+1)
>>> n = 7
>>> n //= 2 # equivale a: n = n // 2
>>> n
3
>>> n **= 2 # equivale a: n = n**2
>>> n
9

Evaluación de expresiones.
Sin usar el computador, evalúe las siguientes expresiones, y para cada una de ellas
indique el resultado y su tipo (si la expresión es válida) o qué error ocurre (si no lo es):
>>> 2 + 3 # Respuesta: tipo int, valor 5
>>> 4 / 0 # Respuesta: error de división por cero
>>> 5 + 3 * 2
>>> '5' + '3' * 2
>>> 2 ** 10 == 1000 or 2 ** 7 == 100
>>> int('cuarenta')
>>> 70/16 + 100/24
>>> 200 + 19 %
>>> 3 < (1024 % 10) < 6

59
 >>> 'six' + 'eight'
>>> 'six' * 'eight'
>>> float(-int('5') + int('10'))
>>> abs(len('ocho') - len('cinco'))
>>> bool(14) or bool(-20)
>>> float(str(int('5' * 4) / 3)[2])

Compruebe sus respuestas en el computador.

Ejercicios Propuestos de expresiones aritméticas y lógicas.

1. Determinar el valor de las expresiones aritméticas siguientes (y luego comprobar el
resultado en el intérprete de Python):
a. 2 + 7 // 3 * 2 –15
b. 32 % 4 + 12 –4 * 3
c. 42 // 8 –3 * 14 + 6
d. 24/5**2 –0.96
e. 3 * 5 % 4 + 11 // 4 * 3
2. Ejercicios sobre prioridad de operadores aritméticos
Determinar el valor de las expresiones aritméticas siguientes (y luego comprobar el resultado en
el intérprete de Python):
a) 2 + 7 // 3 * 2 – 15
b) 32 % 4 + 12 – 4 * 3
c) 42 // 8 – 3 * 14 + 6
d) 24/5**2 – 0.96
e) 3 * 5 % 4 + 11 // 4 * 3

3. Ejercicios sobre prioridad de operadores lógicos

Determinar el valor de las expresiones lógicas siguientes (y luego comprobar el resultado en el
intérprete de Python):
a) True and not False or False
b) False or False or True
c) not (False or False) and True
d) not False and not False and True

4. Ejercicios de revisión de expresiones

Determinar si las expresiones tienen sintaxis correcta. En caso de que sea válida la sintaxis,
determinar su valor, y en el caso contrario justificar el error:
a) 1 + 2 * 3 % 2 – 1
b) 1 >= 7 % 2
c) 1 % 2 > 0.5

60
 d) True or not and (2 > 1)
e) (7.5 – 3) // 3 == 1.5
f) (3 // 2) > (3 % 2) and not True
g) (3 // 3 > 3 % 3) or not True
h) p == (4 % 3 + 1 > 0) and not p

5. Ejercicios para crear expresiones lógicas

Obtener las expresiones lógicas equivalentes de los siguientes enunciados:
a) a no está entre –1 y 1 ni entre 2 y 3.
b) a y b no son mayores a 5.
c) a es un múltiplo de 10 ubicado entre 3000 y 4000.
d) a está entre [5.0 y 10.0) o entre (15.0 y 20.0].
e) a es un número impar múltiplo de 5, o par acabado en 0.
f) a no el mayor ni el menor número entre a, b, y c.
g) a, b, y c son todas ciertas o todas falsas.
h) El cociente de a entre b es igual a su resto (residuo).
i) Los números a, b, y c están incluidos en un intervalo menor a la unidad.
j) El menor de a y b está entre 0 y 1.

6. De las expresiones aritméticas siguientes, escribir expresiones algorítmicas equivalentes

en lenguaje Python. Intentar usar el mínimo de paréntesis posible

a)

b)

c)

d)

e)

f)

61
 g)

h)

i)

j)
7. Dadas dos variables reales x e y, escribir una expresión booleana que valide que x está
fuera del intervalo [25, 35] y está dentro del intervalo (20,40].
8. Sean A, B y C tres variables enteras que representan las ventas de tres productos
respectivamente, escribir expresiones lógicas (booleanas) que representen las siguientes
afirmaciones:
a) Las ventas del producto A son las más elevadas.
b) Ningún producto tiene unas ventas inferiores a 300.
c) Algún producto tiene unas ventas superiores a 1000.
d) La media de ventas es superior a 700.
e) El producto C no es el más vendido.
9. Las edades de tres primos se guardan en las variables a, b, c. Escribir una expresión
booleana que evalúe True si solamente 2 de los 3 primos tienen la misma edad y, además,
la suma de las 3 edades sea múltiplo de 3.
10. Obtener las expresiones booleanas equivalentes a los enunciados siguientes:
a) No se cumple z de tipo booleano o que x e y sean positivas y su suma múltiplo
de 7.
b) La suma de a y b, de tipo entero, es múltiplo de 5 y al menos una de ellas es par.
c) x no es la más grande ni la más pequeña de entre x, y, z de tipo real.
d) La suma de a y b, de tipo entero, es múltiplo de 5 y ambas son impares.
e) Exactamente dos de entre x, y, z son positivas.
f) La más pequeña de las variables a y b de tipo real está entre 0 y 1.
g) a de tipo entero pertenece al conjunto de los números menores de 100 o mayores
de 200 y además es un impar múltiplo de 3.
h) x, y, z de tipo entero son todas impares o todas pares.
i) ξ de tipo real es mayor que la distancia entre x e y de tipo real. xi**2 > (x-y)**2
# Debe utilizarse un identificador válido (xi), no ξ
j) Alguno de los valores absolutos de a, b o c de tipo real es menor que 1.

62
 k) Alguno de los valores de a, b o c de tipo real está en medio del intervalo formado
por los otros dos.
l) x, y, z de tipo real pueden ser los lados de un triángulo. Los valores podrán ser un
triángulo cuando el valor más grande sea menor que la suma de los otros dos.
m) No se cumple una persona trabaja (trabaja de tipo booleano) o sueldo de tipo
entero está entre 1000 y 2000.
11. Un valor entero x es positivo e impar.
12. El peso se encuentra entre 50,5 y 75 kg.
13. El sexo es masculino.
14. La edad es múltiplo de 10.
15. Puede votar si el sexo es masculino y tiene edad para votar. Considere edad superior o
igual a 21 años para votar.
16. Puede pagar si la tarjeta es de débito y el monto es superior a 20 Bs o si la tarjeta es de
crédito y el monto es superior a 50 Bs. Considere Tipo de tarjeta 1: débito, 2: crédito.
17. Un punto (x, y) pertenece a una circunferencia de radio r con centro en (xc, yc). Ecuación
de una circunferencia (x -xc )2+(y - yc)2= r2
18. Dada la fecha actual (da, ma, aa) y una fecha de vencimiento (dv, mv, av) el producto
está vencido.
19. Dado un cuadrado de lado a su área es superior a 100. área = lado2

Funciones predefinidas
Python proporciona funciones (ver Tabla 3-11) para utilizar en las expresiones. Estas
funciones se dice que están predefinidas.
Tabla 3-11. Simple Python Built-in Functions
Función Descripción Ejemplo
abs(x) Devuelve el valor abs(-2) es 2
absoluto de x.
max(x1, x2, ...) Devuelve el mayor max(1, 5, 2) es 5
valor de x1, x2, ...
min(x1, x2, ...) Devuelve el menor min(1, 5, 2) es 1
valor de x1, x2, ...
pow(a, b) Devuelve ab. Same as a pow(2, 3) es 8
** b.
round(x) Devuelve un número round(5.4) es 5
entero más cercano a round(5.5) es 6
x. Si x es igualmente round(4.5) es 4
cercano a dos enteros,
se devuelve el valor
par.
round(x, n) Devuelve el valor round(5.466, 2) es 5.47
flotante redondeado a round(5.463, 2) es 5.46

63
 n dígitos después del
punto decimal.

El argumento de la función debe ir encerrado entre paréntesis, por ejemplo:

>>> abs(0)
0
>>> abs 0
SyntaxError: invalid syntax

A continuación, se presentan algunas funciones predefinidas:

float: conversión a flotante. Si recibe un número entero como argumento, devuelve
el mismo número convertido en un flotante equivalente.
>>> float(3)
3.0

La función float también acepta argumentos de tipo cadena. Cuando se le pasa una
cadena, float la convierte en el número flotante que esta representa:
>>> float('3.2')
3.2
>>> float('3.2e10')
32000000000.0

Pero si la cadena no representa un flotante, se produce un error de tipo ValueError,

es decir, ˂˂error de valor˃˃:
>>> float('un texto')
Traceback (innermost last):
File "<stdin>", line 1, in ?
ValueError: invalid literal for float(): un texto

Si float recibe un argumento flotante, devuelve el mismo valor que se suministra

como argumento.
int: conversión a entero. Si recibe un número flotante como argumento, devuelve el
entero que se obtiene eliminando la parte fraccionaria.
>>> int(2.1)
2
>>> int(-2.9)
-2

También la función int acepta como argumento una cadena:

>>> int('2')
2

Si int recibe un argumento entero, devuelve el argumento tal cual.

str: conversión a cadena. Recibe un número y devuelve una representación de este
como cadena.
>>> str(2.1)
'2.1'
>>> str(234E47)
'2.34e+49'

La función str también puede recibir como argumento una cadena, pero en ese caso
devuelve como resultado la misma cadena.

64
 ord: acepta una cadena compuesta por un único carácter y devuelve su código ASCII
(un entero).
chr: recibe un entero (entre 0 y 255) y devuelve una cadena con el carácter que tiene
a dicho entero como código ASCII.
round: redondeo. Puede usarse con uno o dos argumentos. Si se usa con un sólo
argumento, redondea el número al flotante más próximo cuya parte decimal sea nula.
>>> round(2.1)
2.0
>>> round(2.9)
3.0
>>> round(-2.9)
-3.0
>>> round(2)
2.0

(¡Observa que el resultado siempre es de tipo flotante!) Si round recibe dos

argumentos, estos deben ir separados por una coma y el segundo indica el número de
decimales que se desea conservar tras el redondeo.
>>> round(2.1451, 2)
2.15
>>> round(2.1451, 3)
2.145
>>> round(2.1451, 0)
2.0

Las funciones pueden formar parte de expresiones y sus argumentos pueden, a su vez,
ser expresiones. Observa los siguientes ejemplos:
>>> abs(-23) % int(7.3)
2
>>> abs(round(-34.2765,1))
34.3
>>> str(float(str(2) * 3 + '.123')) + '321'
'222.123321'

Módulos Estándar
En Python, un módulo es una pequeña parte de un gran programa. Este módulo es un
archivo dentro de una unidad de almacenamiento.
Motivos por los que usar módulos:
• Se crean archivos pequeños, donde es más fácil de localizar elementos de tu
código.
• Un módulo se puede usar en todos los programas que desees. Sin necesidad de
repetir código fuente.
Para un nuevo módulo se crea un archivo y se nombra como mi_modulo.py en este
archivo se incluye el código que se necesita, por ejemplo, funciones.
Para utilizar las funciones del módulo se escribe import mi_modulo, una vez incluido
el módulo ya se dispone de todas las funciones que se utilizarán en el nuevo programa.

65
 Al importar un módulo Python recorre todos los directorios indicados en la variable
de entorno PYTHONPATH en busca de un archivo con el nombre adecuado. El valor de la
variable PYTHONPATH se puede consultar desde Python mediante sys.path incluida en el
módulo sys. A continuación, se presentan los módulos estándar de Python y las funciones
más utilizadas dentro de cada módulo.

Obtener Ayuda sobre un Módulo

A continuación, practicarás con comandos que ofrecen información necesaria para
hacer un buen uso de los módulos de Python.
El comando dir(nombre_modulo) imprime un listado con las funciones disponibles
para ese módulo.
Para obtener información específica de una función incluida en un módulo, se ejecuta
el comando help(nombre_modulo.nombre_funcion).
Prueba las siguientes órdenes en el intérprete de Python:
>>> import os
>>> dir(os)
>>> help(os)
>>> help(os.getcwd)

Funciones definidas en módulos

Python también proporciona funciones trigonométricas, logaritmos, entre otras, pero
no están directamente disponibles cuando se inicia una sesión, se debe importar el módulo
respectivo antes de utilizarlo.
3.11.2.1 El módulo math
Importar la función seno (sin, del inglés “sinus”) del módulo matemático (math):
>>> from math import sin

Ahora se puede utilizar la función en los cálculos:

>>> sin(0)
0.0
>>> sin(1)
0.841470984808

Observa que el argumento de la función seno debe expresarse en radianes.

Inicialmente Python desconoce la función seno. Cuando se importa la función,
Python carga su definición y permite utilizarla. Las definiciones de funciones residen en
módulos. Las funciones trigonométricas residen en el módulo matemático. Por ejemplo, la
función coseno, en este momento, es desconocida para Python.
>>> cos(0)
Traceback (innermost last):
File "<stdin>", line 1, in ?
NameError: cos

Antes de utilizarla, es necesario importarla del módulo matemático:

>>> from math import cos
>>> cos(0)

66
 1.0

En una misma sentencia se puede importar más de una función. Basta con separar sus
nombres con comas:
>>> from math import sin, cos

Puede resultar tedioso importar un gran número de funciones y variables de un

módulo.
Python ofrece un atajo: si se utiliza un asterisco, se importan todos los elementos de
un módulo. Para importar todas las funciones del módulo math se escribe:
>>> from math import *

Esto no resulta muy aconsejable por dos razones:

1) Al importar elemento a elemento, el programa gana en legibilidad, pues se sabe de
dónde proviene cada identificador.
2) Si se ha definido una variable con un nombre determinado y dicho nombre
coincide con el de una función definida en un módulo, la variable será sustituida
por la función.
Si no conoce todos los elementos que define un módulo, es posible que esta
coincidencia de nombre tenga lugar, pase inadvertido inicialmente y ocurra un error cuando
se intente utilizar la variable. He aquí un ejemplo del segundo de los problemas indicados:
>>> pow = 1
>>> from math import *
>>> pow += 1
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unsupported operand type(s) for +=:
’builtin_function_or_method’ and ’int’

A continuación, se muestra algunas de las funciones del módulo math:

Conversión angular
degrees (x) Transforma radianes a grados
radians (x) Transforma g

Funciones trigonométricas
math.acos(x) devuelve el coseno del arco 'x' (en radianes)
math.asin(x) Seno del arco ‘x’
math.atan(x) arcotangente
math.sin(x) devuelve en seno de 'x'. ('x' en radianes)
math.cos(x) devuelve en coseno de 'x'. ('x' en radianes)
math.tan(x) Tangente

Funciones hiperbólicas
math.acosh(x) Devuelve el coseno hiperbólico del arco ‘x’ (en rad)
math.asinh(x) Seno del arco hiperbólico ‘x’
math.atanh(x) Arcotangente hiperbólica
math.cosh(x) Devuelve el coseno hiperbólico de x.
math.sinh(x) Seno hiperbólico

67
 Exponenciales y logarítmicas
math.exp(x) exponencial en base e
math.log(x[, base]) si no se le da una base, toma e (neperiano)
math.log1p(x) devuelve el logaritmo de 1+x (base e)
math.log10(x) logaritmo decimal
math.pow(x, y) eleva la base 'x' al exponente 'y'
math.sqrt(x) raíz cuadrada de 'x'
math.hypot(x, y) devuelve la norma euclídea (sqrt(x ** 2 + y **
2))

Funciones de redondeo y caracterización

math.fabs(x) valor absoluto de x
math.factorial(x) factorial. Lanza ValueError si x no es entero o <
0
math.floor() devuelve el mayor entero <= x
math.ceil(x) devuelve el menor entero >= x
math.fmod(x) resto de la división entera (de acuerdo a C)

En el módulo math se definen, además, algunas constantes de interés (observe que

debe escribirse en minúscula):
>>> from math import pi, e
>>> pi
3.1415926535897931
>>> e
2.7182818284590451

Ejemplos del módulo math.

>>> import math >>> math.ceil(3.5)
>>> math.degrees(math.pi) 4.0
180.0 >>> math.ceil(3.4)
>>> math.radians(360) 4.0
6.2831853071795862 >>> math.fmod(5,2)
>>> math.exp(1) 1.0
2.7182818284590451 >>> math.fmod(5.4,2)
>>> math.log(4,2) 1.4000000000000004
2.0 >>> math.ceil(3.5)
>>> math.log10(1000) 4.0
3.0 >>> math.ceil(3.4)
>>> math.pow(3,2.5) 4.0
15.588457268119896 >>> math.fmod(5,2)
>>> math.hypot(1,1) 1.0
1.4142135623730951 >>> math.fmod(5.4,2)
>>> math.fabs(3.5) 1.4000000000000004
3.5

Evitando las coincidencias

Python ofrece un modo de evitar el problema de las coincidencias: importar sólo el
módulo.
>>> import math

De esta forma, todas las funciones del módulo math están disponibles, pero usando
el nombre del módulo y un punto como prefijo:
>>> import math
>>> print (math.sin(0))

68
 0.0

Python muestra un error al intentar sumar un entero y una función. Efectivamente,

hay una función pow en el módulo math. Al importar todo el contenido de math, la variable
ha sido reemplazada por la función.

Evaluación de expresiones con funciones.

¿Qué resultados se obtendrán al evaluar las siguientes expresiones Python? Calcula
primero a mano el valor resultante de cada expresión y comprueba, con la ayuda del
ordenador, si tu resultado es correcto.
a) int(exp(2 * log(3)))
b) round(4*sin(3 * pi / 2))
c) abs(log10(.01) * sqrt(25))
d) round(3.21123 * log10(1000), 3)

Entornos de desarrollo
El código puede editarse con un simple editor de texto o utilizando el IDLE que hace
más fácil la tarea de escribir programas. Python viene con su propio IDLE conformado por
una consola y un editor de texto.
Además, hay otros buenos entornos de desarrollo más avanzados para Python: Stani’s
Python Editor, Eric IDE, NinJa IDE, PyScripter, WingIDE 101 o Spyder, entre otros.

Algunos IDE para Python

(http://www.pythondiario.com/2016/11/los-5-mejores-ide-para-python.html)
Para programar en Python solo basta con instalar Python y utilizar el IDLE que viene
con la instalación o cualquier IDE que proporcionan diferentes características de apoyo para
escribir y ejecutar el código.
Decir que un IDE en Python es mejor que otro es subjetivo, lo importante es que el
IDE que utilice resulte cómodo y satisfaga sus necesidades. Este tema sobre IDEs en Python
pretende mostrar entornos de trabajos completos a la hora de escribir código en Python.
3.12.1.1 Pycharm IDE
El IDE Pycharm es muy completo, creado por JetBrains. Este IDE es profesional y
viene en dos modalidades: una edición Free y otra muy completa privada que apunta a
empresas de desarrollo de software. La popularidad del IDE Pycharm se puede medir a
partir de que grandes empresas como Twitter, Groupon, Spotify, Ebay y Telefónica, han
utilizado éste para su trabajo.

69
 La mayoría de sus características están disponibles en la versión gratuita, se integra
con IPython, soporta Anaconda, así como otros paquetes científicos como matplotlib y
NumPy.
Características como desarrollo remoto, soporte de bases de datos, soporte de
frameworks de desarrollo web, etc., están disponibles solo para la edición profesional de
PyCharm.
Algo muy útil de Pycharm es su compatibilidad con múltiples marcos de desarrollo
web de terceros como Django, Pyramid, web2py, motor de aplicaciones Google y Flask,
lo que lo convierte en un competo IDE de desarrollo de aplicaciones rápidas.
Se encuentra disponible para Windows y Linux, puedes descargarlo desde la
siguiente URL: http://www.jetbrains.com/pycharm/
Como instalar PyCharm en Windows
1 - Una vez finalizada la descarga, ejecute el archivo descargado, debe aparecer el
asistente de instalación.
2 - Haga clic en siguiente y marque las 2 casillas.
Como instalar Pycharm en Linux
1 - Descomprima el archivo descargado en un directorio.
2 - Para ejecutar PyCharm, ejecute pycharm.sh desde el subdirectorio bin.

3.12.1.2 PyDev IDE

PyDev: es libre de costo y está lleno de características poderosas para programar de
manera eficiente en Python. Es un plugin de código abierto y se ejecuta en Eclipse. Tiene
integración con Django, completa el código de manera automática, soporte multilenguaje,
plantillas de código, análisis de código, marcado de errores y mucho más.
Se mantiene siempre actualizado y contiene una gran comunidad de usuarios y
empresas de patrocinio como Liclipse, Squish, TraceTronic y algunas más.

70
 Aunque PyDev califica como uno de los mejores IDE de Python de código abierto,
también viene empaquetado junto con otro producto llamado Liclipse, un producto comercial
construido sobre Eclipse que proporciona mejoras en la usabilidad y temas adicionales.

3.12.1.3 Sublime Text 3 IDE

Este IDE es uno de los más livianos y potentes. Con el uso de plugins, Sublime Text
3 puede utilizarse como un IDE completo. En un solo lugar se puede ver la elegancia del
código y el poder de Python para hacer magia.
La interfaz de usuario es muy rápida y fácil de configurar. Contiene muchos paquetes
para darle diferentes características. Anaconda es un complemento que convierte Sublime
Text 3 en un excelente IDE Python; aumenta su productividad y le ayuda a garantizar la
calidad y estilo del código. Para más información en su página oficial:
https://www.sublimetext.com/

71
3.12.1.4 Wing IDE
Wing IDE es comercial y apunta a desarrolladores profesionales. Fue lanzado hace
15 años atrás y es un producto muy maduro, con un montón de herramientas y características
para programar en Python.
Wing IDE es soportado por Windows, OS X Linux. Como Pycharm, tiene una
versión básica gratuita, una edición personal y una profesional muy potente.
En el Debugging es donde Wing IDE brilla más e incluye funciones como
depuración de procesos múltiples, depuración de subprocesos, depuración automática de
procesos secundarios, puntos de interrupción, inspección de código, etc. También ofrece
funciones para depurar remotamente el código que se ejecuta en Raspberry PI.
Wing IDE también soporta una gran cantidad de frameworks Python como: Maya,
MotionBbuilder, Zope, PyQt, PySide, pyGTK, Django, matplotib entre otros. Más
información en la página oficial: https://wingware.com/

3.12.1.5 Vim IDE

Vim IDE es uno de los editores más avanzados y populares dentro de la comunidad
de desarrolladores Python. Es de código abierto y se encuentra disponible gratuitamente
bajo licencia GPL.
Sin embargo, Vim es más conocido como editor, aunque nos ofrece un entorno
completo de desarrollo para Python cuando está configurado correctamente. Vim es ligero,
modular y el más adecuado para los amantes del teclado, para los que no utilizan el mouse
mientras se escribe código. La configuración inicial puede llevarnos un poco de tiempo ya
que es necesario utilizar varios complementos VIM para que funcione de la manera que se

72
 quiera, pero lo que se obtiene al final vale la pena el esfuerzo. Si buscas un IDE Python para
Linux, Vim puede ser tu mejor opción. Mas información: http://www.vim.org/

3.12.1.6 Spyder – Anaconda (opción recomendada)

Es una distribución de código abierto de los lenguajes de programación Python y R.
Se utiliza mucho para procesamiento de datos a gran escala, análisis predictivo y
computación científica. Tiene como objetivo simplificar la administración y el despliegue de
paquetes. Las versiones de paquetes son gestionadas por el sistema de gestión de paquetes
conda.
Las características de Spyder “Scientific Python Development EnviRonment”
incluyen:

• Provisión de la consola IPython (Qt) como un mensaje interactivo, que puede mostrar
gráficos en línea
• Capacidad de ejecutar fragmentos de código desde el editor de la consola
• Análisis continuo de archivos en el editor y provisión de advertencias visuales sobre
posibles errores
• Ejecución paso a paso
• Explorador de variables

73
3.12.1.7 Atom
La forma más básica de crear y ejecutar un programa
Python es crear un archivo vacío con extensión .py, y apuntar a
ese archivo desde la línea de comandos con nombre de
archivo.py.
Alternativamente, puedes usar el IDLE de Python por
defecto que viene instalado con Python. Puedes escribir y ejecutar
tu código dentro de IDLE. Sin embargo, si desea ser productivo,
las dos primeras opciones no serán las mejores. Querrías usar algo
como el editor Atom.
Atom fue construido por GitHub con el lema “Un editor de texto hackeable para el
siglo XXI”. Y es realmente flexible y tiene un gran soporte de paquetes externos que lo
convierten en un poderoso Entorno de Desarrollo Interactivo (IDE).
Estos son los pasos que le permitirán empezar a trabajar con Atom:
Descargue e instale Atom desde https://atom.io/ Una vez que instale atom, puede
lanzarlo escribiendo atom en la línea de comandos. Si esto no funciona, asegúrese de que el
átomo ha sido añadido a sus variables de trayectoria/entorno de búsqueda. El átomo debería
verse así:

74
 Una forma más conveniente de abrir Atom podría ser hacer clic con el botón derecho
del ratón en la carpeta donde se encuentran los archivos y luego ir a Abrir con Atom. Esto
añadirá todos los archivos de esa carpeta a la vista de árbol tal y como se ve en la captura de
pantalla anterior. Esto es estupendo cuando el programa o la aplicación web que estás
desarrollando consta de varios archivos. Puedes saltar de archivo en archivo y editarlos desde
dentro de Atom.
Para ejecutar un archivo Python en Atom, se abre la línea de comandos y apuntar a
las rutas de los archivos o utilizar un gran paquete Atom llamado plataforma-ide-terminal.
que se integra con Atom para poder ejecutar los archivos en Atom.
Para instalar un paquete, seleccione File -> Settings y luego Install and search for the
name of the package (i.e., platformio-ide-terminal). Una vez instalado el paquete terminal-
plus puede encontrar la herramienta y abrir una instancia de terminal seleccionado Paquetes.
Una forma más rápida de abrir un terminal es hacer clic en el signo “+” que se ha añadido en
la parte inferior de la ventana de Atom. Eso debería abrir la terminal:

75
 Como se puede observar, el terminal apunta al directorio principal de sus archivos.
Ahora se pueden ejecutar scripts Python desde allí como se muestra en la captura de pantalla
anterior.
Se puede dividir el editor en varias ventanas. Cuando se tiene más de un archivo
abierto dentro de Atom, puedes ir a View -> Panes -> Split Right para enviar el archivo actual
a la mitad derecha de la ventana. Esto puede aumentar su productividad cuando trabaja con
varios archivos.

Manejo de datos
Salida estándar
El cambio más notable y ampliamente conocido en Python 3 es como la función print
es utilizada. El uso del paréntesis () es obligatorio en la versión 3, el mismo fue opcional en
la versión 2.
print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()

La función print() por defecto inserta al final un salto de línea. Este se puede eliminar
en Python 2 escribiendo ',' al final de la función. En Python 3 "end=' '" agrega un espacio en
vez de un salto de línea.
print x, # La coma al final suprime el salto de línea en Python 2
print(x, end=" ") # Agrega un espacio en lugar de una nueva línea en
# Python 3

Los argumentos de la función print son los siguientes:

print(value1, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

La forma más sencilla de mostrar algo en la salida estándar es mediante el uso de la

sentencia print. En su forma más básica a la palabra clave print le sigue una cadena, que se
mostrará en la salida estándar al ejecutarse el estamento.
>>> print ('Hola mundo')
Hola mundo

La siguiente sentencia, por ejemplo, imprimiría la palabra “Hola”, seguida de una

línea vacía (dos caracteres de nueva línea, ‘\n’), y a continuación la palabra “mundo” con
sangría (un carácter tabulador, ‘\t’).
>>> print ('Hola\n\n\tmundo')
Hola

mundo

Para que la siguiente impresión se realice en la misma línea se escribe una coma al
final de la sentencia.
>>> print ('Hola', 'mundo')
Hola mundo

Esto se diferencia del uso del operador + para concatenar las cadenas en que al utilizar
las comas print introduce automáticamente un espacio para separar cada una de las cadenas.

76
 Este no es el caso al utilizar el operador +, ya que lo que le llega a print es un solo argumento:
una cadena ya concatenada.
>>> print ('Hola' + 'mundo')
Holamundo

Además, al utilizar el operador + se tiene que convertir previamente cada argumento

en una cadena de no serlo ya, ya que no es posible concatenar cadenas y otros tipos, mientras
que al usar el primer método no es necesaria la conversión.
>>> print ('Cuesta', 3, 'euros')
Cuesta 3 euros
>>> print ('Cuesta' + 3 + 'euros')
<type ‘exceptions.TypeError’>: cannot concatenate ‘str’ and
‘int’ objects

3.13.1.1 Formato de salida

Se puede introducir un número entre el % y el carácter que indica el tipo al que
formatear, indicando el número mínimo de caracteres que queremos que ocupe la cadena. Si
el tamaño de la cadena resultante es menor que este número, se añadirán espacios a la
izquierda de la cadena. En el caso de que el número sea negativo, ocurrirá exactamente lo
mismo, sólo que los espacios se añadirán a la derecha de la cadena [5].
>>> print ('%10s mundo' % 'Hola')
______Hola mundo
>>> print ('%-10s mundo' % 'Hola')
Hola_______mundo

Lo que hace la primera línea es introducir los valores a la derecha del símbolo % (la
cadena 'Hola') en las posiciones indicadas por los especificadores de conversión de la cadena
a la izquierda del símbolo % (ver Tabla 3-12), tras convertirlos al tipo adecuado.
Los especificadores más sencillos están formados por el símbolo % seguido de una
letra que indica el tipo con el que se formatea el valor. Por ejemplo:
Tabla 3-12. Códigos de % y su conversión
% Código Conversión
%c Convierte a un carácter
%s Convierte a una cadena y aplica la función str() a la cadena
antes de formatear
%i Convierte a un entero decimal con signo
%d Convierte a un entero decimal con signo
%u Convierte a un entero decimal sin signo
%o Convierte a un entero octal
%x Convierte a un entero hexadecimal con letras minúsculas
%X Convierte a un entero hexadecimal con letras mayúsculas
%e Convierte a una notación exponencial con minúscula "e"
%E Convierte a una notación exponencial con mayúscula "e"
%f Convierte a un número real de coma flotante
%g Convierte al valor más corto de% f y% e
%G Convierte al valor más bajo de% f y% E

Se puede introducir un número entre el % y el carácter que indica el tipo al que

formatear, indicando el número mínimo de caracteres que ocupará la cadena. Si el tamaño de
la cadena resultante es menor que este número, se añadirán espacios a la izquierda de la

77
cadena. En el caso de que el número sea negativo, ocurrirá exactamente lo mismo, sólo que
los espacios se añadirán a la derecha de la cadena.
En el caso de los números reales, es posible indicar la precisión a utilizar precediendo
la letra “f” de un punto seguido del número de decimales a mostrar:
>>> from math import pi
>>> print ('%.4f' % pi)
3.1416

La misma sintaxis se puede utilizar para indicar el número de caracteres de la cadena

a mostrar.
>>> print ('%.4s' % 'hola mundo')
hola

Caracteres especiales
Es posible que desee que las cadenas incluyan caracteres, como tabulaciones y
comillas. Para hacer esto, utiliza una barra invertida “\” seguido de algún carácter único.
Estos caracteres individuales junto con una barra invertida indican la presencia de un carácter
especial.
La Tabla 3-13 enumera varios caracteres de escape de barra invertida junto con sus
equivalentes octales, decimales y hexadecimales.
Tabla 3-13. Caracteres de escape para cadenas
ESCAPE NAME CHARACTER DECIMAL OCTAL HEXADECIMAL
CHARACTER
\n Newline\ LF 10 012 0x0A
Linefeed
\t Horizontal HT 9 01l 0x09
Tab
\b Backspace BS 8 010 0x08
\0 Null NUL 0 000 0x00
character
\a Bell BEL 7 007 0x07
\v Vertical VT 11 013 0x0B
tab
\r Carriage CR 13 015 0x0D
return
\e Escape ESC 27 033 0xlB
\" Double “ 34 042 0x22
quote
V Single ' 39 047 0x27
quote
\f Form FF 12 014 0x0C
feed
\\ Backslash \ 92 134 0x5C

Considere un ejemplo del carácter NEWLINE (\n).

>>> print ('Hello \nworld')
Hello
world!!!

78
 Tenga en cuenta que \n no se imprime en la salida. También hay una nueva línea antes
del comienzo de la segunda palabra. Además, cuando tiene una declaración larga que excede
una sola línea, puede usar una barra diagonal inversa “\” para escapar de NEWLINE y
continuar la instrucción. Por ejemplo,
>>> print ('The name for the registration number %s is %s' \
... % ('A002','Steve'))
The name for the registration number A002 is Steve

Para imprimir caracteres especiales, no solo usa los caracteres con una barra diagonal
inversa, sino también sus valores decimales, octales y hexadecimales. Por ejemplo,
>>> print ("Hello \012world)
Hello
world!! !

Lectura de Datos por Teclado

Python 2 tiene dos versiones de función de entrada, input() y raw_input(). La función
input() trata los datos recibidos como string sí está encerrado entre comillas '' o "", sino el
dato es considerado como un número.
In Python 2
>>> x = input('something:')
something:10 #entered data is treated as number
>>> x
10
>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'
>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'
>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"

En Python 3 la función raw_input() es obsoleta. Además, que el dato recibido era

siempre tratado como un string.
La función input() permite obtener texto escrito por teclado. Al llegar a la función, el
programa se detiene esperando que se escriba algo y se pulse la tecla Enter, como muestra
en los siguientes ejemplos:
In Python 3
>>> x = input("something:")
something:10
>>> x
'10'
>>> x = input("something:")
something:'10' #entered data treated as string with or
without ''
>>> x
"'10'"
>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
File "", line 1, in
X = raw_input("something:")

79
 NameError: name 'raw_input' is not defined

Para incluir la pregunta en la solicitud de la respuesta, se utiliza la concatenación

(operador +):
nombre = input('Introduzca el nombre: ')
apellido = input('Introduzca el apellido, ' + nombre + ': ')
print('Me alegro de conocerle,', nombre, apellido)
Otra solución es utilizar las cadenas "f" introducidas en Python 3.6:
nombre = input('Introduzca el nombre: ')
apellido = input(f'Introduzca el apellido, {nombre}: ')
print(f'Me alegro de conocerle, {nombre} {apellido}')
Otro ejemplo:
numero1 = int(input('Introduzca un número: '))
numero2 = int(input(f'Introduzca un número mayor que {numero1}: '))
print(f'La diferencia entre ellos es {numero2 - numero1}')

Glosario
Algoritmo: Un proceso general para resolver una clase completa de problemas.
Análisis sintáctico: La exanimación de un programa y el análisis de su estructura
sintáctica.
Asignación: sentencia que asigna un valor a una variable.
Código de objeto: La salida del compilador una vez que ha traducido el programa.
Código fuente: es un conjunto de instrucciones y órdenes lógicas, compuestos de
algoritmos que se encuentran escritos en un determinado lenguaje de programación, las
cuales deben ser interpretadas o compiladas, para permitir la ejecución del programa
informático.
Código fuente: Un programa escrito en un lenguaje de alto nivel antes de ser
compilado.
Coma flotante: un formato para representar números con decimales.
Comentario: un segmento de información en un programa, destinado a otros
programadores (o cualquiera que lea el código fuente) y que no tiene efecto sobre la ejecución
del programa.
Compilar: Traducir un programa escrito en un lenguaje de alto nivel a un lenguaje
de bajo nivel todo al mismo tiempo, en preparación para la ejecución posterior.
Composición: la capacidad de combinar expresiones sencillas y sentencias hasta
crear sentencias y expresiones compuestas, con el fin de representar cálculos complejos de
forma concisa.
Concatenar: Unir dos operandos, extremo con extremo.
Depuración: El proceso de hallazgo y eliminación de los tres tipos de errores de
programación.

80
 Diagrama de estado: representación gráfica de un conjunto de variables y de los
valores a los que se refiere.
División de enteros: es una operación que divide un entero entre otro y devuelve un
entero. La división de enteros devuelve sólo el número entero de veces que el numerador es
divisible por el denominador, y descarta el resto.
Error (bug): Un error en un programa.
Error en tiempo de ejecución: Un error que no ocurre hasta que el programa ha
comenzado a ejecutarse e impide que el programa continúe.
Error semántico: Un error en un programa que hace que ejecute algo que no era lo
deseado.
Error sintáctico: Un error en un programa que hace que el programa sea imposible
de analizar sintácticamente (e imposible de interpretar).
Evaluar: simplificar una expresión ejecutando las operaciones para entregar un valor
único.
Excepción: Otro nombre para un error en tiempo de ejecución.
Expresión: una combinación de variables, operadores y valores. Dicha combinación
representa un único valor como resultado.
Guion: Un programa archivado (que va a ser interpretado).
Interpretar: Ejecutar un programa escrito en un lenguaje de alto nivel traduciéndolo
línea por línea
Lenguaje de alto nivel: Un lenguaje como Python diseñado para ser fácil de leer y
escribir para la gente.
Lenguaje de bajo nivel: Un lenguaje de programación diseñado para ser fácil de
ejecutar para un computador; también se lo llama “lenguaje de máquina” o “lenguaje
ensamblador”.
Lenguaje de programación: es un lenguaje informático, diseñado para expresar
ó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 lógico
de un ordenador. Está compuesto por una serie de símbolos, reglas sintácticas y semánticas
que definen la estructura del lenguaje.
Lenguaje formal: Cualquier lenguaje diseñado por humanos que tiene un propósito
específico, como la representación de ideas matemáticas o programas de computadores:
todos los lenguajes de programación son lenguajes formales.
Lenguaje informático: Es un idioma artificial, utilizado por ordenadores, cuyo fin
es transmitir información de algo a alguien. Los lenguajes informáticos, pueden clasificarse
en: a) lenguajes de programación (Python, PHP, Pearl, C, etc.); b) lenguajes de especificación
(UML); c) lenguajes de consulta (SQL); d) lenguajes de marcas (HTML, XML); e) lenguajes
de transformación (XSLT); f) protocolos de comunicaciones (HTTP, FTP); entre otros.
Lenguaje natural: Cualquier lenguaje hablado que evolucionó de forma natural.

81
 Lenguajes de alto nivel: son aquellos cuya característica principal, consiste en una
estructura sintáctica y semántica legible, acorde a las capacidades cognitivas humanas. A
diferencia de los lenguajes de bajo nivel, son independientes de la arquitectura del hardware,
motivo por el cual, asumen mayor portabilidad.
Lenguajes interpretados: a diferencia de los compilados, no requieren de un
compilador para ser ejecutados sino de un intérprete. Un intérprete, actúa de manera casi
idéntica a un compilador, con la salvedad de que ejecuta el programa directamente, sin
necesidad de generar previamente un ejecutable. Ejemplo de lenguajes de programación
interpretado son Python, PHP, Ruby, Lisp, entre otros.
Multiparadigma: acepta diferentes paradigmas (técnicas) de programación, tales
como la orientación a objetos, aspectos, la programación imperativa y funcional.
Multiplataforma: significa que puede ser interpretado en diversos Sistemas
Operativos como GNU/Linux, Windows, Mac OS, Solaris, entre otros.
Operador: un símbolo especial que representa un cálculo sencillo, como la suma. La
multiplicación o la concatenación de cadenas.
Operando: uno de los valores sobre los que actúa un operador.
Palabra reservada: es una palabra clave que usa el compilador para analizar
sintácticamente los programas. No pueden usarse palabras reseñadas, por ejemplo, if, def y
while como nombres de variables.
Portabilidad: La cualidad de un programa que le permite ser ejecutado en más de un
tipo de computador.
Programa ejecutable: Otro nombre para el código de objeto que está listo para
ejecutarse.
Programa: Un conjunto de instrucciones que especifica una computación.
Reglas de precedencia: la serie de reglas que especifican el orden en el que las
expresiones con múltiples operadores han de evaluarse.
Semántica: El significado de un programa.
Sentencia print: Una instrucción que causa que el intérprete Python muestre un valor
en el monitor.
Sentencia: es una porción de código que representa una orden o acción. Hasta ahora,
las sentencias vistas son las asignaciones y las sentencias print.
Sintaxis: La estructura de un programa.
Solución de problemas: El proceso de formular un problema, hallar la solución y
expresar esa solución.
Tipado dinámico: un lenguaje de tipado dinámico es aquel cuyas variables, no
requieren ser definidas asignando su tipo de datos, sino que éste, se auto-asigna en tiempo de
ejecución, según el valor declarado.

82
 Tipo: un conjunto de valores. El tipo de un valor determina cómo puede usarse en las
expresiones. Hasta ahora, los tipos vistos son enteros (tipo int), números de coma flotante
(tipo float) y cadenas (tipo string).
Unidad: Uno de los elementos básicos de la estructura sintáctica de un programa,
análogo a una palabra en un lenguaje natural.
Valor: un número o cadena (o cualquier otra cosa que se especifique posteriormente)
que puede almacenarse en una variable o calcularse en una expresión.
Variable: nombre que hace referencia a un valor.

Ejercicios Resueltos de Estructura Secuencial

Ejercicio 3-1: Realiza un programa que lea 2 números por teclado y determine los
siguientes aspectos (es suficiente con mostrar True o False).
Si los dos números son iguales
Si los dos números son diferentes
Si el primero es mayor que el segundo
Si el segundo es mayor o igual que el primero
Código 3-1. comp_num.py
# Propósito: Comparar dos números
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
n1 = float(input("Introduce el primer número: "))
n2 = float(input("Introduce el segundo número: "))

print("¿Son iguales? ", n1 == n2)

print("¿Son diferentes?", n1 != n2)
print("¿El primero es mayor que el segundo?", n1 > n2)
print("¿El segundo es mayor o igual que el primero?", n1 <= n2)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Introduce el primer número: 10
Introduce el segundo número: 10
¿Son iguales? True
¿Son diferentes? False
¿El primero es mayor que el segundo? False
¿El segundo es mayor o igual que el primero? True

Ejercicio 3-2: Utilizando operadores lógicos, determina si una cadena de texto

introducida por el usuario tiene una longitud mayor o igual que 3 y a su vez es menor que
10 (es suficiente con mostrar True o False).

83
 Código 3-2. tam_cad.py
# Propósito: Determinar tamaño de una cadena
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
cadena = input("Escribe una cadena: ")

print("¿La longitud de la cadena es mayor o igual que 3 y menor que 10?",

len(cadena) >= 3 and len(cadena) < 10)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Escribe una cadena: Hola
¿La longitud de la cadena es mayor o igual que 3 y menor que 10? True

Ejercicio 3-3: Realiza un programa que cumpla el siguiente algoritmo utilizando

siempre que sea posible operadores en asignación:
a) Lee por pantalla otro numero_usuario, especifica que sea entre 1 y 9
b) Multiplica el numero_usuario por 9 en sí mismo
c) Guarda en una variable numero_magico el valor 12345679 (sin el 8)
d) Multiplica el numero_magico por el numero_usuario en sí mismo
e) Finalmente muestra el valor final del numero_magico por pantalla
Código 3-3. num_mag.py
# Propósito: Determinar el número mágico
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
numero_usuario = int(input("Introduce un número del 1 al 9: "))

numero_usuario *= 9
numero_magico = 12345679
numero_magico *= numero_usuario
print("El número mágico es:", numero_magico)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Introduce un número del 1 al 9: 5
El número mágico es: 555555555

84
 Ejercicio 3-4: En el siguiente ejemplo se convierte grados Celsius a Fahrenheit; al
ejecutarlo e introducir por ejemplo el valor 27, se muestra el resultado en la consola:

¿Qué información está ¿Cómo lo

¿Qué resultados exige?
presente? logro?
Valor de una temperatura en El valor de dicha temperatura
°F=9/5*°C+32
grados Centígrados en grados Fahrenheit

Código 3-4. conv_temp.py

# Propósito: Conversión de temperatura
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Programa que convierte ºC a ºF

# Entrada de datos
c = float(input("Entra temperatura en ºC: "))

# Procesamiento de datos
f = 9 / 5 * c + 32

# Salida de datos
print(c, " ºC equivale a ", f, " ºF")

Ejecución:
Entra temperatura en ºC: 27
27.0 ºC equivale a 80.6 ºF

Ejercicio 3-5: El programa siguiente calcula el área y el perímetro de un círculo a

partir de su radio. Como se requiere el uso del valor ϖ (pi) se importará del módulo de
funciones y constantes matemáticas de Python (math). Se introducirá del teclado el radio
de valor 1.2.
Código 3-5. área_per_cir.py
# Propósito: Determinar el área y el perímetro de un círculo
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Programa que calcula perímetro y área de un círculo

from math import pi

# Entrada de datos
r = float(input('Introduce el radio del círculo: '))

# Procesamiento de datos
per = 2 * pi * r
area = pi * r ** 2

#Salida de datos
print('Perímetro =', per)
print('Área = ', area)

85
# Fin del programa
input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Introduce el radio del círculo: 1.2
Perímetro = 7.5398223686155035
Área = 4.523893421169302

Los decimales de los números reales (float) del perímetro y área se pueden reducir,
por ejemplo, a dos dígitos decimales utilizando el estilo adaptado printf de otros lenguajes
(%.2f) o usando la función interna de Python round(x, 2). Puede cambiarse el argumento 2
por el número de decimales que se requiera.
print('Perímetro = ', round(per, 2)) # función interna round()
print('Área = %.2f', % area) # funcionalidad de printf en Python

Ejecución:
Introduce el radio del círculo: 1.2
Perímetro = 7.54
Área = 4.52

Ejercicio 3-6: Ejercicio de conversión de segundos. Diseña un programa que lea

una cantidad de segundos (valor entero) y calcule el número de días, horas, minutos y
segundos equivalentes.
Código 3-6. conv_tiempo.py
# Propósito: Conversión de tiempo
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Programa para convertir segundos a días, horas, minutos, y segundos

# Entrada de datos
s = int(input("Entra segundos: "))
auxs = s
# Procesamiento de datos
m = s // 60
s = s % 60
h = m // 60
m = m % 60
d = h // 24
h = h % 24

#Salida de datos
print(auxs, 'segundos son:')
print(d, "días,", h, "horas,", m, "minutos y", s, "segundos")

86
 Ejecución 1:
Entra segundos: 3676
3676 segundos son:
0 días, 1 horas, 1 minutos y 16 segundos

Ejecución 2:
Entra segundos: 400000
400000 segundos son:
4 días, 15 horas, 6 minutos y 40 segundos

Ejercicio 3-7: Ejercicios de cambio de monedas. Diseña un programa que reciba

una cierta cantidad de céntimos (c) y retorne su equivalente en el mínimo número de
monedas de curso legal (2 euros, 1 euro, 50 céntimos, 20 céntimos, 10 céntimos, 5
céntimos, 2 céntimos y 1 céntimo).
Código 3-7. convertirmonedas.py
# Propósito: Conversión de denominación de monedas
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Programa céntimos a monedas de curso legal

# Entrada de datos
c = int(input("Entra céntimos: "))
auxc = c
# Procesamiento de datos
e2 = c // 200
c = c % 200
e = c // 100
c = c % 100
c50 = c // 50
c = c % 50
c20 = c // 20
c = c % 20
c10 = c // 10
c = c % 10
c5 = c // 5
c = c % 5
c2 = c // 2
c = c % 2

#Salida de datos
print(auxc,'céntimos equivalen a:')
print(e2,'monedas de 2 €,',e,'de 1 €,',c50,'de 50 cts,',c20,'de 20 cts,')
print(c10,'monedas de 10 cts,',c5,'de 5 cts,',c2,'de 2 cts y',c,'de 1
céntimo')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

87
 Ejecución 1:
Entra céntimos: 589
589 céntimos equivalen a:
2 monedas de 2 €, 1 de 1 €, 1 de 50 cts, 1 de 20 cts,
1 monedas de 10 cts, 1 de 5 cts, 2 de 2 cts y 0 de 1 céntimo
Pulse una tecla para finalizar...

Ejecución 2:
Entra céntimos: 399
399 céntimos equivalen a:
1 monedas de 2 €, 1 de 1 €, 1 de 50 cts, 2 de 20 cts,
0 monedas de 10 cts, 1 de 5 cts, 2 de 2 cts y 0 de 1 céntimo
Pulse una tecla para finalizar...
Ejercicio 3-8: Dada la longitud de los catetos de un triángulo rectángulo,
utilizando el teorema de Pitágoras (H2=C12+C22), desarrolle un programa que determine
el valor de la longitud de la hipotenusa.
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Longitud Cateto 1 (C1) Usando el teorema de
Longitud Cateto 2 (C2) Pitágoras
La longitud de la
El hecho que el
hipotenusa (H)
triángulo es
rectángulo

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
O Entero ® Real O Lógico
Longitud del Cateto 1 c1
O Cadena
O Entero ® Real O Lógico
Longitud del Cateto 2 c2
O Cadena
Longitud de la O Entero ® Real O Lógico
h
Hipotenusa O Cadena

Código 3-8. hipotenusa.py

# Propósito: Determinar la hipotenusa.
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
c1 = float(input("Longitud del primer cateto:"))
c2 = float(input("Longitud del segundo cateto:"))

# Procesamiento de datos
h = (c1 ** 2 + c2**2)**0.5

#Salida de datos

88
 print("Longitud de la hipotenusa= ", h)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución 1:
Longitud del primer cateto:3
Longitud del segundo cateto:4
Longitud de la hipotenusa= 5.0
Pulse una tecla para finalizar...
Ejercicio 3-9: Dado el valor de un ángulo, expresado en radianes, desarrolle un
programa que determine e imprima el valor de dicho ángulo en grados, sabiendo que
180°=n radianes.
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Valor del ángulo
La unidad de medida El valor de ángulo medido Ángulo en ° = ángulo en
del ángulo es en en grado radianes * 180/n
radianes

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
Valor del ángulo en O Entero ® Real O Lógico
angulo1
Grados O Cadena
Valor del ángulo en O Entero ® Real O Lógico
angulo2
Radianes O Cadena

Código 3-9. convierteangulo.py

# Propósito: Determinar el ángulo
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
angulo1 = float(input("Valor en Radianes:"))

# Procesamiento de datos
angulo2 = angulo1 * 180 / 3.141516

#Salida de datos
print("Valor en Grados es= ", angulo2)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución 1:
Valor en Radianes:3.14
Valor en Grados es= 179.9131374788478

89
 Pulse una tecla para finalizar...

Ejercicio 3-10: Dada la longitud de la base y la altura de triángulo cualesquiera,

desarrolle un programa que determine el área del triángulo, sabiendo que el
área=base*altura/2
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Longitud de la base
Longitud de la altura El valor del área que
base*altura área= 2
Cualquier forma de encierra el triángulo
triángulo

Tabla de Variables:
Nombre de la
Descripción del dato Tipo de Dato
Variable
O Entero ® Real O Lógico O
Longitud de la Base base
Cadena
Longitud de la O Entero ® Real O Lógico O
altura
altura Cadena
O Entero ® Real O Lógico O
Área del Triángulo area
Cadena

Código 3-10. área_triang.py

# Propósito: Determinar el área de un triángulo rectángulo
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
base = float(input('Longitud de la Base:'))
altura = float(input('Longitud de la altura:'))

# Procesamiento de datos
area = base * altura / 2

#Salida de datos
print("Área del Triángulo= ", area)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Longitud de la Base:3
Longitud de la altura:4
Área del Triángulo= 6.0
Pulse una tecla para finalizar...

90
 Ejercicio 3-11: Dado el largo y ancho de un rectángulo, desarrolle un programa
que determine e imprima el área y el perímetro del rectángulo, sabiendo que el
área=largo*ancho y el perímetro=2*Largo + 2*ancho.
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Longitud del largo El valor del área que
Área=largo*ancho
del rectángulo encierra el rectángulo
Perímetro=2*Largo +
Longitud del ancho El valor del perímetro
2*ancho
del rectángulo del rectángulo

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
O Entero ® Real O Lógico
Longitud del Largo largo
O Cadena
O Entero ® Real O Lógico
Longitud del Ancho ancho
O Cadena
O Entero ® Real O Lógico
Área del Rectángulo area
O Cadena
Perímetro del O Entero ® Real O Lógico
perim
Rectángulo O Cadena

Código 3-11. área_per_rect.py

# Propósito: Determinar el área y el perímetro de un rectángulo

# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
largo = float(input('Longitud del Largo del rectángulo:'))
ancho = float(input('Longitud del Ancho del rectángulo:'))

# Procesamiento de datos
area = largo * ancho
perim = 2 * largo + 2 * ancho

#Salida de datos
print(f'Área del Rectángulo= {area}')
print(f'Perímetro del rectángulo= {perim}')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejercicio 3-12: Dadas las longitudes de los lados de un triángulo (l1, l2 y l3),
desarrolle un programa que determine el área que encierra el triángulo utilizando el
método del semiperímetro, donde el semiperímetro se calcula como s= (l1+l2+l3) / 2 y
el área como (s*(s-l1)*(s-l2)*(s-l3))**0.5

91
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Longitud del Lado L1 1. El valor del área por s=(l1+l2+l3)/2
Longitud del Lado L2 el método del area=(s*(s-l1) *(s-l2)
Longitud del Lado L3 semiperímetro *(s-l3))**0.5

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
O Entero ® Real O Lógico
Longitud del Lado L1 l1
O Cadena
O Entero ® Real O Lógico
Longitud del Lado L2 l2
O Cadena
O Entero ® Real O Lógico
Longitud del Lado L3 l3
O Cadena
O Entero ® Real O Lógico
Área del Triángulo area
O Cadena
Valor del O Entero ® Real O Lógico
s
Semiperímetro O Cadena

Código 3-12. área_triang.py

# Propósito: Determinar el área de un triángulo

# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
l1 = float(input('Longitud del Lado 1:'))
l2 = float(input('Longitud del Lado 2:'))
l3 = float(input('Longitud del Lado 3:'))

# Procesamiento de datos
s = (l1 + l2 + l3) / 2
area = ((s - l1) * (s - l2) * (s - l3)) ** 0.5

# Salida de datos
print(f'Área del Rectángulo: {área}')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejercicio 3-13: Dadas las longitudes del radio de la base y la altura de un cilindro,
determine el área y el volumen del cilindro, sabiendo que el área = 2*PI*Radio*Altura y
el volumen = (PI * Radio2) * Altura.
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?
Longitud del radio de El valor del área del Area = pi * Radio2
la base cilindro

92
 Longitud de la altura El valor del volumen del Volumen = (2 * pi *
cilindro Radio) * altura

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
O Entero ® Real O Lógico
Radio de la base radio
O Cadena
O Entero ® Real O Lógico
Altura del Cilindro altura
O Cadena
O Entero ® Real O Lógico
Área del Cilindro area
O Cadena
O Entero ® Real O Lógico
Volumen del Cilindro volumen
O Cadena

Código 3-13. area_vol_cil.py

# Propósito: Determinar el área y el volumen de un cilindro
# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Módulos Importados
from math import pi

# Entrada de datos
radio = float(input('Radio de la base [cm]: '))
altura = float(input('Altura del cilindro [cm]: '))

# Procesamiento de datos
area = (2 * pi * radio) * altura
volumen= pi * radio * radio * altura

# Salida de datos
print('Área del Cilindro= %.2f' % area, ' [cm²]')
print('Volumen del Cilindro= %.2f' % volumen, ' [cm³]')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Radio de la base [cm]: 2
Altura del cilindro [cm]: 10
Área del Cilindro= 125.66 [cm²]
Volumen del Cilindro= 125.66 [cm³]
Pulse una tecla para finalizar...
Ejercicio 3-14: Dadas las longitudes de los catetos de un triángulo, desarrolle un
programa que determine la hipotenusa y para el ángulo que forma uno de los catetos con
la hipotenusa, el valor del seno, coseno y tangente de dicho ángulo.
¿Qué información está
¿Qué resultados exige? ¿Cómo lo logro?
presente?

93
Longitud de un Longitud de la hipotenusa.
cateto. Seno del ángulo de la hipotenusa hip = (co2 +ca2)2
Longitud del otro con uno de los catetos. seno = co / hip
cateto. Coseno del ángulo de la hipotenusa cos = ca / hip
con el mismo cateto anterior tan = co / ca
Tangente del ángulo de los catetos
anteriores

Tabla de Variables:
Descripción del dato Nombre de la Variable Tipo de Dato
Longitud del cateto O Entero ® Real O Lógico O
ca
adyacente Cadena
Longitud del cateto O Entero ® Real O Lógico O
co
opuesto Cadena
Longitud de la O Entero ® Real O Lógico O
h
hipotenusa Cadena
O Entero ® Real O Lógico O
Seno del ángulo seno
Cadena
O Entero ® Real O Lógico O
Coseno del ángulo Cos
Cadena
O Entero ® Real O Lógico O
Tangente del ángulo tan
Cadena

Código 3-14. func_trigon.py

# Propósito: Determinar las funciones trigonométricas

# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos

ca = float(input('Longitud del cateto adyacente:'))

co = float(input('Longitud del cateto opuesto:'))

# Procesamiento de datos
hip = (co**2 + ca**2) ** 0.5
seno = co / hip
coseno = ca / hip
tangente = co / ca

#Salida de datos
print("Longitud de la Hipotenusa=", hip)
print("Seno del ángulo= ", seno)
print("Coseno del ángulo= ", coseno)
print("Tangente del ángulo= ", tangente)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:
Longitud del cateto adyacente:3

94
 Longitud del cateto opuesto:4
Longitud de la Hipotenusa= 5.0
Seno del ángulo= 0.8
Coseno del ángulo= 0.6
Tangente del ángulo= 1.3333333333333333
Pulse una tecla para finalizar...
Ejercicio 3-15: Debido a que aún en Norteamérica no se utilizan el sistema métrico
decimal en la medición de longitudes, desarrolle un programa que, dada la longitud en
pies de una pieza cualquiera, determine e imprima su equivalente en a) yardas; b)
pulgadas; c) centímetros, y d) metros, sabiendo que 1 yarda=3 pies, 1 pie=12 pulgadas,
1 pulgada=2.54 centímetros, 1 metro=100 centímetros.
¿Qué información está ¿Cómo lo
¿Qué resultados exige?
presente? logro?
Longitud en pies Longitud equivalente en yardas yarda = longitud / 3
Longitud equivalente en pulgadas pulgada = longitud * 12
Longitud equivalente en centímetros cm = pulgada * 2.54
Longitud equivalente en metros mts = cm / 100

Tabla de Variables:
Nombre de la
Descripción del dato Tipo de Dato
Variable
O Entero ® Real O Lógico O
Longitud en pies longitud
Cadena
O Entero ® Real O Lógico O
Longitud en Yardas yarda
Cadena
O Entero ® Real O Lógico O
Longitud en Pulgadas pulgada
Cadena
Longitud en O Entero ® Real O Lógico O
cm
Centímetros Cadena
O Entero ® Real O Lógico O
Longitud en Metros mts
Cadena

Código 3-15. conv_pie.py

# Propósito: Convertir de pie a otras unidades de longitud

# Autor: Alejandro Bolívar
# Fecha: 30/01/2020

# Entrada de datos
longitud= float(input('Longitud de la pieza [pie]:’)

# Procesamiento de datos
yarda = longitud / 3
pulgada = longitud * 12
cm = pulgada * 2.54

95
mts = cm / 100

#Salida de datos
print("Longitud de la pieza en Metro:", mts)
print("Longitud de la pieza en Pie:", longitud)
print("Longitud de la pieza en Yardas:", yarda)
print("Longitud de la pieza en Pulgada:", pulgada)
print("Longitud de la pieza en Centimetro:", cm)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

96
 Unidad 4

Estructuras de
Control
Estructuras Selectivas

Las estructuras selectivas permiten seleccionar o decidir la

ejecución de un conjunto de instrucciones, según un valor o
expresión lógica.

97
 Unidad IV. Estructuras de Control
Objetivos de la unidad:
• En esta unidad aprenderá a utilizar las estructuras condicionales, con el fin de
dirigir el flujo del programa de acuerdo a la necesidad de ejecutar las
instrucciones necesarias para resolver un problema.
• Se presenta una recopilación y adaptación de ejercicios relacionados con el
desarrollo de series numéricas.

Control de flujo de datos

Todos los lenguajes de programación disponen de instrucciones de control de flujo.
Estas instrucciones permiten al programador decidir el orden de ejecución del código con el
fin de permitir ejecutar diferentes órdenes en función de una serie de condiciones sobre el
estado. Python ofrece los dos tipos básicos de sentencias de control de flujo: las sentencias
condicionales y los ciclos (o repeticiones).

Sangría
La sangría es la sangría que se asigna a las instrucciones que se ejecutarán dentro de
una estructura de control.
No todos los lenguajes de programación,
necesitan de una sangría, aunque sí, se estila
implementarla, a fin de otorgar mayor legibilidad
al código fuente. Pero en el caso de Python, la
sangría es obligatoria, ya que, de ella, dependerá
su estructura.
PEP 8: sangría
Una sangría de 4 (cuatro) espacios en blanco, indicará que las instrucciones
sangradas, forman parte de una misma estructura de control.
Una estructura de control, entonces, se define de la siguiente forma:
inicio de la estructura de control:
expresiones

Una excepción a la regla de sangría

Cada vez que una sentencia acaba con dos puntos (:), Python espera que la sentencia
o sentencias que le siguen aparezcan con una mayor sangría. Es la forma de marcar el inicio
y el fin de una serie de sentencias que ˂˂dependen˃˃ de otra. Hay una excepción: si solo hay
una sentencia que ˂˂depende˃˃ de otra, puedes escribir ambas en la misma línea como se
aprecia en el código parimpar1.py,
a = int(input('Dame un entero positivo: '))

98
 if a % 2 == 0:
print ('El número es par ')
else:
print ('El número es impar ')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa
y este otro, parimpar2.py,
a = int(input('Dame un entero positivo: '))

if a % 2 == 0: print ('El número es par ')

else: print ('El número es impar ')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa
son equivalentes.

Atención
Todas las instrucciones que describen el cuerpo de la estructura deben tener una
sangría mayor que el encabezado de la estructura. Esta sangría puede ingresarse mediante
4 espacios preferiblemente o un tabulador, pero es importante que sea la misma para todas
las instrucciones de la estructura.

Estructuras Selectivas
Las estructuras de selección o decisión permiten ejecutar un bloque de código entre
varios disponibles, según el resultado de la evaluación de una expresión lógica situada en la
cabecera de la estructura.

Estructura Condicional Simple

if expresión_lógica_a_evaluar:
ejecutar_si_cierto

99
 Esta forma del condicional if
se interpreta como Si
(expresión_lógica) es verdadera, el
flujo del programa continúa
ejecutando las instrucciones que
estén dentro del bloque if, las cuales se especifican y se
reconocen por estar debidamente sangradas respecto al
inicio de la palabra if. Recuerde que la sangría se establece
dejando espacios en blanco, pasando la instrucción
(palabra) if. Si la (expresión_lógica) es falsa, el flujo del
programa se continúa ignorando las instrucciones del
bloque if.
Por ejemplo, el siguiente código mayoredad.py
verifica si una persona es mayor de edad.
edad = int(input('Ingrese su edad: '))
if edad >= 18:
print ('Es mayor de edad')
# Fin del programa
input('Pulse una tecla para finalizar... ') # Pausa
Ejecute este programa, probando varias veces con valores diferentes.

Estructura Condicional Doble

La forma del if
estudiada en la sección
anterior presenta la
posibilidad de hacer un
desvío en el flujo de
ejecución de un programa
cuando la condición o
expresión lógica que
determina al if es verdadera (True). Si la expresión
lógica no se cumple, es falsa (False), el flujo del
programa continúa su secuencia como si la
instrucción if no estuviese en el programa. La
construcción if–else ofrece la alternativa de ejecutar
otras instrucciones en caso que la expresión lógica
que determina la instrucción if sea falsa. Su forma
general es como sigue:
if expresion_a_evaluar:
ejecutar_si_cierto
else:
ejecutar_en_caso_contrario

En otras palabras, esta forma del condicional if se interpreta como Si la (expresión

lógica) es verdadera, el flujo del programa se continúa ejecutando las instrucciones que estén

100
 dentro del bloque if (las cuales se especifican y se reconocen por estar debidamente sangradas
respecto al inicio de la palabra if). Si la (expresión lógica) es falsa, el flujo del programa
continúa ejecutando las instrucciones que estén dentro del bloque else (las cuales se
especifican y se reconocen por estar debidamente sangradas respecto al inicio de la palabra
else). En este caso, se garantiza que una de las dos bifurcaciones del flujo del programa se
ejecuta. Debe notarse que las instrucciones if: y else: NO están sangradas una de la otra. Es
decir, ambas instrucciones comienzan al mismo nivel en el programa (solo se sangra el
bloque de instrucciones que debe ejecutarse en caso que alguna de las condiciones se
cumpla). Cabe mencionar que mientras la instrucción if puede tener significado por sí sola,
la instrucción else NO puede aparecer de forma aislada. Siempre debe ir precedida por un if.
Por ejemplo, el siguiente código (parimpar3.py) realiza acciones distintas dependiendo de si
el número de entrada es par o impar:
edad = int(input('Ingrese su edad: '))
if edad >= 18:
print ('Es mayor de edad')
else:
print ('Es menor de edad')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa
La última sentencia no está sangrada, por lo que no es parte de la estructura
condicional, y será ejecutada siempre.

Estructura Condicional Múltiple

Como el lector puede haber anticipado, se puede tener situaciones
en las que se tenga que seleccionar entre más de dos condiciones. Para
estos casos Python ofrece la estructura condicionada if–elif–else, cuya
forma general es como sigue:
if expresion_lógica_1:
ejecutar_si_verdadero_1
elif expresion_lógica_2:
ejecutar_si_ verdadero_2
elif expresion_lógica_3:
ejecutar_si_ verdadero_3
else:
ejecutar_si_ninguna

En palabras, esta forma del condicional if se interpreta como Si la

(expresion_lógica_1) es verdadera, el flujo del programa se continúa
ejecutando las instrucciones que estén dentro del bloque if (las cuales se
especifican y se reconocen por estar debidamente sangradas respecto al
inicio de la palabra if). Si la (expresion_lógica_1) es falsa, entonces el flujo
del programa pasa a verificar la primera instrucción elif cuyo bloque de
instrucciones se ejecutan Si la (expresion_lógica_2) es verdadera. En caso contrario, el flujo
del programa continúa con la verificación de la siguiente instrucción elif cuyo bloque de
instrucciones se ejecutan Si la (expresion_lógica_3) es verdadera. En caso que ninguna de
las condiciones previas a la instrucción else: sea ejecutada, el flujo del programa hace que se

101
ejecuten las instrucciones de ese bloque. A continuación, se presentan ejemplos de la
aplicación de una estructura condicional.
Ejercicio 4-1: Dado un valor real x, determine sí es positivo, negativo o cero.
Código 4-1. posneg.py
# Lectura de datos
x = float(input('Ingrese un valor x: '))

# Procesamiento de datos
if x < 0.0:
msg = 'negativo'
elif x > 0.0:
msg = 'positivo'
else:
msg = 'cero'

# Salida de datos
print ('x es ', msg)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa
Ejercicio 4-2: La tasa de impuesto a pagar por una persona según su sueldo es la
siguiente.
Tabla 4-1. Tasa de impuesto en función del sueldo recibido
Sueldo Tasa de impuesto
menos de 1000 0%
1000 ≤ sueldo < 2000 5%
2000 ≤ sueldo < 4000 10%
4000 o más 12% ´
Entonces, el programa que calcula el impuesto a pagar es el siguiente:
Código 4-2. impuesto.py
# Lectura de datos
sueldo = float(input('Ingrese su sueldo: '))

# Procesamiento de datos
if sueldo < 1000:
tasa = 0.00
elif sueldo < 2000:
tasa = 0.05
elif sueldo < 4000:
tasa = 0.10
else:
tasa = 0.12

# Salida de datos
print ('Usted debe pagar ', tasa * sueldo, ' de impuesto')

# Fin del programa

102
 input('Pulse una tecla para finalizar... ') # Pausa
Siempre sólo una de las alternativas será ejecutada. Tan pronto alguna de las
condiciones es verdadera, el resto de ellas no se evalúan.

Ejercicios Resueltos con estructuras condicionales

a∗x + b∗y = c
1) Un sistema de ecuaciones lineales {
d∗x + e∗y = f
Se puede resolver con las siguientes fórmulas: x = (c*e - b*f) / (a*e - b*d); y = (a*f -
c*d) / (a*e - b*d). Desarrolle un programa (sistema.py) que lea los coeficientes de ambas
ecuaciones (a, b, c, d, e y f) y determine los valores de x e y. Nota: evite la división por cero
e imprima el mensaje adecuado.
Código 4-3. sistema.py
# Lectura de datos
print('Introduzca los coeficientes: ')
a = float(input('a:'))
b = float(input('b:'))
c = float(input('c:'))
d = float(input('d:'))
e = float(input('e:'))
f = float(input('f:'))

# Procesamiento de datos
deno = a * e - b * d
if deno == 0:
# Sí el denominador es cero, no existe solución
print('No tiene solución el sistema de ecuaciones')
else:
x = (c * e - b * f) / deno
y = (a * f - c * d) / deno

# Salida de datos
print('La solución del sistema de ecuaciones planteado es')
print('X=', x)
print('Y=', y)
input('Pulse una tecla para finalizar... ') # Pausa
2) Dado un valor numérico entero, desarrolle un programa (paroimpar.py) que determine si
es par o impar.

Código 4-4. paroimpar.py

# Entrada del dato
n = int(input('De un valor entero: '))
# Procesamiento y salida de datos
if n == 0:
print(n, ' No es par ni impar')
elif n % 2 != 0:
print(n, ' Es Impar')

103
else:
print(n, ' Es Par')

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

3) Dada la el valor numérico con que una persona indica el agrado por un determinado
producto, un valor entre 0 y 100, elabore un programa (calificación.py) que determine la
calificación del producto en base a la siguiente tabla y empleando if anidados.
Rango Calificación
0-20 Muy Malo
21-40 Deficiente
41-60 Regular
61-80 Bueno
81-100 Muy Bueno

Para plantear la solución se empieza con una decisión considerando el límite superior
del rango, si es menor o igual a ese valor está en esa calificación sino en alguna de las otras,
así se descartan una a una las posibilidades, quedando en el diagrama de flujo algo como lo
siguiente:

Código 4-5. calificación.py

# Lectura de datos
agrado = float(input('Ingrese el valor de agrado: '))

# Procesamiento de datos
if agrado <= 20:
msg = 'Muy Malo'
elif agrado <= 40:
msg = 'Deficiente'
elif agrado <= 60:
msg = 'Regular'
elif agrado <= 80:
msg = 'Bueno'

else: # Observe que no es necesario hacer la última pregunta

msg = 'Muy Bueno'

104
 # Salida de datos
print ('La Calificación es ' + msg)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

105
 Unidad 4

Estructuras de Control
Estructuras Repetitivas

Las estructuras repetitivas, permiten ejecutar un conjunto

de instrucciones un número determinado de veces o mientras
una condición se cumpla. Las estructuras repetitivas son muy
utilizadas para la resolución de problemas, prácticamente todo
programa utiliza estas estructuras.

106
 Objetivos de la Unidad:
• En esta unidad se aprenderá a utilizar las estructuras repetitivas for y while,
así como también las herramientas de programación para resolver la
diversidad de problemas que se pueden presentar en programación.
• Realizar el desglose y composición de números enteros

Estructuras Repetitivas
Estas estructuras, también denominadas ciclos o bucles, ejecutan un bloque de código
de forma repetitiva mientras se cumpla una condición asociada a la estructura. A cada una de
las ocasiones en que se ejecuta el código contenido en estas estructuras se le denomina
iteración.
Instrucción Python
Ciclo Repetitivo con while condición:
condición al inicio Instrucción(es)
Ciclo de Repetición for elemento in secuencia:
Automática Instrucción(es)

Ciclo while
La estructura repetitiva mientras (en inglés while) es
aquella en que el cuerpo del bucle o ciclo (en inglés block) se
repite mientras se cumple una determinada condición. Cuando se
ejecuta la instrucción mientras, la primera cosa que sucede es que
se evalúa la condición (una expresión booleana). Si se evalúa falsa,
no se toma ninguna acción y el programa prosigue en la siguiente instrucción del bucle. Si la
expresión booleana es verdadera, entonces se ejecuta el cuerpo del bucle, después de lo cual
se evalúa de nuevo la expresión booleana. Este proceso se repite una y otra vez mientras la
expresión booleana (condición) sea verdadera [1].

while <Condicion y/o variable booleana >:

# Instrucciones sangradas que serán ejecutadas

• La palabra reservada while encabeza la estructura repetitiva.

• La condición determina sí el cuerpo del ciclo se ejecuta (o se continua) ejecutando.
Seguidamente se escriben dos puntos después de la condición.
• El bloque o cuerpo de la estructura repetitiva son una o varias instrucciones a ejecutar
mientras la condición sea verdadera. Todas las instrucciones que conforman el bloque,
se deben colocar con una sangría a partir de la posición que ocupa el inicio de la palabra
while.
Es importante notar que se puede escribir un while dentro de otro while (ciclo
anidado) respetando el sangrado y también es posible escribir dentro del ciclo las entidades
 Estructuras Repetitivas

condicionales if, elif, else. Al momento de usar un ciclo while en un programa se debe ser
cuidadoso, puesto que si la expresión booleana nunca llega a ser falsa el programa puede
quedar en un ciclo infinito y no terminar el programa.
En la estructura while el bloque de la secuencia de instrucciones se repite siempre que
la condición dada por el valor de una variable o expresión booleana sea cierta (True). Hay
que recordar que en Python la secuencia de instrucciones dentro de la estructura algorítmica
debe estar sangrada.
A continuación, se presenta un ejercicio que muestra la tabla de multiplicar (Código
4-6) del número introducido por el usuario. Esto es un esquema típico de recorrido:
Código 4-6. Tabla_de_multiplicar.py
# Tabla de multiplicar (del 1 al 10) del número introducido
n = int(input('Tabla: '))
k = 1
while k <= 10:
print(n, ' * ', k, ' = ', n * k)
k = k + 1
print('Tabla de multiplicar del', n)
El programa pide al usuario un número n, se inicializa la variable k en 1 y luego se
ejecuta la iteración while 10 veces, mientras la condición k <= 10 es True. En la décima
iteración la variable k toma el valor 11 y entonces la expresión booleana k <= 10 es False y
sale del while, pasando el programa a la instrucción siguiente print().
Tabla: 7
7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70
Tabla de multiplicar del 7

El siguiente código (Código 4-7) muestra los primeros n números naturales en forma
decreciente:
Código 4-7. decreciente.py
# Mostrar los N primeros números naturales en forma descendente
n = int(input('Entra un número natural: '))
i = n
while i >= 1:
print(i, end =' ')
i = i - 1
print('\nHemos mostrado', n,'números naturales decreciendo')
Entra un número natural: 7
7 6 5 4 3 2 1
Hemos mostrado 7 números naturales decreciendo

108
 Unidad IV. Estructuras de Control
Estructuras Repetitivas

A continuación, se muestra un programa (Código 4-8) que calcula la suma de los n

primeros números naturales.
Código 4-8. suma_n_primeros.py
# Cálculo de la suma de los primeros n números
n = int(input('Entra un número natural: '))
i = 1
suma = 0
while i <= n:
suma = suma + i
i = i + 1
print('La suma de los números naturales hasta', n,'es', suma)

Entra un número natural: 100

La suma de los números naturales hasta 100 es 5050

El programa siguiente (Código 4-9) sigue un esquema típico de búsqueda. Se requiere

saber si un número natural es primo o no. Un número primo solo es divisible por 1 y por sí
mismo, por lo que se prueba con los números desde 2 hasta el anterior a él mismo. Si es
divisible por alguno entonces se tiene un divisor y se detiene la búsqueda, el número no será
primo. Si llega al final y no se ha encontrado divisores, entonces es primo.
Código 4-9. número_primo.py.
# Programa que determina si un número es primo o no
n = int(input('Entra un número natural: '))
d = 2
un_divisor = True # Si hay un divisor el número NO es primo
while d < n and un_divisor:
if n % d == 0:
un_divisor = False # Se encontró un divisor
d = d + 1
print('¿Es primo? ', un_divisor)

Entra un número natural: 29

Es primo? True

Este programa no requiere buscar todos los divisores desde 2 hasta n-1. El lector
puede averiguar hasta dónde hace falta buscar posibles divisores del número que se desea
saber si es primo o no. La condición d < n del ciclo while puede cambiarse para detener la
búsqueda antes y obtener el mismo resultado.
El algoritmo de Euclides para calcular el máximo común divisor de dos números n y
m, según los siguientes pasos.

1. Teniendo n y m, se obtiene r, el resto de la división entera de m / n.

2. Si r es cero, n es el MCD de los valores iniciales.
3. Se reemplaza m = n, n = r, y se vuelve al primer paso.
El algoritmo de Euclides (Código 4-10) para hallar el MCD de dos números naturales
se puede programar en Python como:

109
 Estructuras Repetitivas

Código 4-10. Algoritmo_de_Euclides.py.

# Algoritmo de Euclides
print('Cálculo del MCD de 2 números usando el algoritmo de Euclides')
a = int(input('Entra un número natural: '))
b = int(input('Entra otro: '))
aa, bb = a, b
while a != b:
if a > b:
a = a-b
else:
b = b-a
print('El MCD entre', aa, 'y', bb, 'es', a)

Cálculo del MCD de 2 números usando el algoritmo de Euclides

Entra un número natural: 28
Entra otro: 12
El MCD entre 28 y 12 es 4

En el programa de Euclides se utilizó la asignación múltiple para guardar los valores

de las variables a y b en aa y bb, de forma que no se pierdan y mostrarlos en el print()
final.
4.5.1.1 Estructura while para asegurar condiciones de entrada de datos
Durante el proceso de entrada de datos en programas informáticos se puede validar
los valores de una variable. En este caso se debe cerciorar que el número introducido por el
usuario sea positivo. El siguiente código, hace que la estructura while capte un valor
erróneo (negativo) y no salga del bucle hasta que se introduzca uno correcto (positivo). Este
esquema puede ampliarse a múltiples casos, cambiando la condición lógica del while.
x = float(input('Entra un número para hallar su raíz cuadrada: '))
while x < 0:
x = float(input('El número debe ser positivo!!: '))

Ciclo for
Un for es una entidad que recorre de manera determinada los elementos de una lista
y ejecuta las instrucciones que tenga sangradas [5]. Posee la siguiente sintaxis:

for <variable local > in <lista >:

# Grupo de instrucciones a ejecutar
# Pueden usar o no a la variable local

En muchos cálculos se incluye el proceso de una cadena carácter a carácter. A

menudo empiezan por el principio, seleccionan cada carácter por turno, hacen algo con él y
siguen hasta el final. Este patrón de proceso se llama recorrido. Una forma de codificar un
recorrido es una sentencia while:

110
 Unidad IV. Estructuras de Control
Estructuras Repetitivas

indice = 0
while indice < len(fruta):
letra = fruta[indice]
print (letra)
indice = indice + 1

Este ciclo recorre la cadena y muestra cada letra en una línea distinta. La condición
del ciclo es indice < len(fruta), de modo que cuando indice es igual a la longitud de la cadena,
la condición es falsa y no se ejecuta el cuerpo del ciclo. El último carácter al que se accede
es el que tiene el índice len(fruta)-1, que es el último carácter de la cadena.
Es tan habitual usar un índice para recorrer un conjunto de valores, que Python facilita
una sintaxis alternativa más simple: el ciclo for:
for car in fruta:
print (car)

Cada vez que se recorre el ciclo, se le asigna a la variable car el siguiente carácter de
la cadena. El ciclo continúa hasta que no quedan caracteres.

La Función range()
Si se necesita iterar sobre una secuencia de números, es apropiado utilizar la función
incorporada range() la cual genera una lista que contiene progresiones aritméticas:
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

El valor final dado nunca es parte de la lista; range(10)genera una lista de 10

valores, los índices correspondientes para los elementos de una secuencia de longitud 10. Es
posible hacer que el rango empiece con otro número, o especificar un incremento diferente
(incluso negativo; algunas veces se le llama 'paso'), en la Tabla 4-2 se muestra diferentes usos
de la función range:
Tabla 4-2. Ejemplos de Usos de la función range
Uso Descripción Ejemplo
range(vf) Retorna la lista desde 0 hasta vf-1 >>> range(3)
[0,1,2]
range(vi, vf) Retorna la lista desde vi hasta vf-1 >>> range(1,4)
[1,2,3]
range(vi, vf, inc) Retorna la lista desde vi hasta vf-1 pero sumando >>> range(1,5,2)
inc valores [1,3]

for i in range(1, 6):

print (i)
Al ejecutar el programa, se visualiza lo siguiente por pantalla:

Ejecución:
1
2
3
4
5
O también,

111
 Estructuras Repetitivas

for i in range(4):
print(i,end=" ")

Ejecución:
0123

Obi Wan

Puede resultar sorprendente que range(a, b) incluya todos los números enteros
comprendidos entre a y b, pero sin incluir b. En realidad, la forma “natural” o más
frecuente de usar range es con un sólo parámetro: range(n) que devuelve una lista con los
n primeros números enteros incluyendo al cero (hay razones para que esto sea lo
conveniente). Como incluye al cero y hay n números, no puede incluir al propio número
n. Al extenderse el uso de range a dos argumentos, se ha mantenido la “compatibilidad”
eliminando el último elemento. Una primera ventaja es que resulta fácil calcular cuántas
iteraciones realizará un ciclo range(a, b): exactamente b - a. (Si el valor b estuviera
incluido, el número de elementos sería b - a + 1.)
Hay que ir con cuidado, pues es fácil equivocarse “por uno”. De hecho, equivocarse
“por uno” es tan frecuente al programar (y no sólo con range) que hay una expresión para
este tipo de error: un error Obi Wan (Kenobi), que es más o menos como suena en inglés
“off by one” (pasarse o quedarse corto por uno).

Índice de ciclo for-in: ¡prohibido asignar!

Hemos aprendido que el ciclo for-in utiliza una variable índice a la que se van
asignando los diferentes valores del rango. En muchos ejemplos se utiliza la variable i,
pero sólo porque también en matemáticas las sumatorias y productorias suelen utilizar la
letra i para indicar el nombre de su variable índice. Puedes usar cualquier nombre de
variable válido.
Pero que el índice sea una variable cualquiera no te da libertad absoluta para hacer
con ella lo que quieras. En un ciclo, las variables de índice sólo deben usarse para consultar
su valor, nunca para asignarles uno nuevo. Por ejemplo, este fragmento de programa es
incorrecto:
for i in range(0, 5):
i += 2 # Error

Y ahora qué sabes que los ciclos pueden anidarse, también has de tener mucho
cuidado con sus índices. Un error frecuente entre primerizos de la programación es utilizar
el mismo índice para dos ciclos anidados. Por ejemplo, estos ciclos anidados están mal:
for i in range(0, 5):
for i in range(0, 3): # Error
print (i)

112
 Unidad IV. Estructuras de Control
Estructuras Repetitivas

En el fondo, este problema es una variante del anterior, pues de algún modo se está
asignando nuevos valores a la variable i en el ciclo interior, pero i es la variable del ciclo
exterior y asignarle cualquier valor está prohibido.
Recuerda: nunca debes asignar un valor a un índice de ciclo ni usar la misma
variable índice en ciclos anidados.

Ejercicios de Estructuras Repetitivas

Ejercicio 4-3: Elabore un programa (promvalores.py) que lea n valores de tipo
entero y devuelva el promedio de los n valores.
Código 4-11. promvalores.py
# Determinar el promedio de n números de un conjunto

# Lectura de datos
n = int(input('Indique la cantidad de elementos: '))

# Inicialización de variables
suma = 0

# Procesamiento de datos
for k in range(n):
# Lectura de datos
num = int(input('Indique un valor: '))
suma = suma + num
prom = suma / n

# Salida de datos
print ('El promedio es: ', prom)

# Fin del programa

input('Pulse una tecla para finalizar... ') # Pausa

Ejecución:

======= RESTART: G:/Ejercicios Python/promvalores.py =========

Indique la cantidad de elementos: 5
Indique un valor: 1
Indique un valor: 2
Indique un valor: 3
Indique un valor: 4
Indique un valor: 5
El promedio es: 3.0
Pulse una tecla para finalizar...

Ejercicio 4-4: Una simulación de Monte Carlo usa números aleatorios y

probabilidad para resolver problemas. Tiene una amplia gama de aplicaciones en

113
 Estructuras Repetitivas

matemática computacional, física, química y finanzas. Véase un ejemplo de usar una

simulación Monte Carlo para estimar el valor de .
Primero, dibuja un círculo con su cuadrado delimitador.
Suponga que el radio del círculo es 1. Entonces, el área del círculo
es  y el área cuadrada es 4. Genere aleatoriamente un punto en el
cuadrado. La probabilidad de que el punto esté en el círculo es circleArea
/ squareArea =  / 4.
Escribe un programa (MonteCarloSimulation.py) que genere al
azar 1000000 puntos que caen en el cuadrado y deja que numberOfHits denote la cantidad
de puntos que caen en el círculo. Entonces, numberOfHits es aproximadamente 1000000 *
( / 4). El valor de  puede aproximarse a 4 * numberOfHits / 1000000. El programa
completo se muestra en el Código 4-12.
Código 4-12. MonteCarloSimulation.py
import random

NUMBER_OF_TRIALS = 1000000 # Constante

numberOfHits = 0

for i in range(NUMBER_OF_TRIALS):
x = random.random() * 2 – 1
y = random.random() * 2 – 1

if x * x + y * y <= 1:
numberOfHits += 1

pi = 4 * numberOfHits / NUMBER_OF_TRIALS

print("PI es", pi)

El resultado es PI es 3.14124.
Ejercicio 4-5: Mostrar un menú (menú.py) con tres opciones: 1- comenzar
programa, 2- imprimir listado, 3-finalizar programa. A continuación, el usuario debe
poder seleccionar una opción (1, 2 ó 3). Si elige una opción incorrecta, informarle del
error. El menú se debe volver a mostrar luego de ejecutada cada opción, permitiendo
volver a elegir. Si elige las opciones 1 ó 2 se imprimirá un texto. Si elige la opción 3, se
interrumpirá la impresión del menú y el programa finalizará.
Código 4-13. menú.py.
while True:
print("Opción 1 - comenzar programa")
print("Opción 2 - imprimir listado")
print("Opción 3 - finalizar programa")
opcion = int(input("Opción elegida: "))
if opcion == 1:
print("¡Comenzamos!")
elif opcion == 2:
print("Listado:")
print("Nadia, Esteban, Mariela, Fernanda")

114
 Unidad IV. Estructuras de Control
Herramientas de programación

elif opcion == 3:
print("Hasta la próxima")
break
else:
print("Opción incorrecta. Debe ingresar 1, 2 o 3")

Herramientas de programación
Hasta este momento de la lectura los programas son una combinación de
asignaciones, condicionales y ciclos, organizados de tal manera que describan el algoritmo a
ejecutar.
Existen algunas tareas comunes y que casi siempre se resuelven de la misma manera.
Por lo tanto, es conveniente conocerlas.
En programación, se llama patrón a una solución que es aplicable a un problema que
ocurre a menudo. A continuación, se presneta algunos patrones comunes que ocurren en
programación.

Sumar y multiplicar valores

La suma y la multiplicación son operaciones binarias: operan sobre dos valores.
Para sumar y multiplicar más valores, generalmente dentro de un ciclo que los vaya
generando, hay que usar una variable para ir guardando el resultado parcial de la operación.
Esta variable se llama acumulador.
En el caso de la suma, el acumulador debe partir con el valor cero. Para la
multiplicación, con el valor uno. En general, el acumulador debe ser inicializado con el
elemento neutro de la operación que será aplicada.
Por ejemplo, el siguiente programa entrega el producto de los mil primeros números
naturales:
producto = 1
for i in range(1, 1001):
producto = producto * i
print (producto)
El siguiente programa entrega la suma de los cubos de los números naturales cuyo
cuadrado es menor que 1000:
i = 1
suma = 0
while i ** 2 < 1000:
valor = i ** 3
i = i + 1
suma = suma + valor
print (suma)

En todos los casos, el patrón a seguir es algo como esto:

acumulador = valor_inicial

115
 Herramientas de programación

ciclo:
valor = ...
...
acumulador = acumulador operación valor

El cómo adaptar esta plantilla a cada situación de modo que entregue el resultado
correcto es responsabilidad del programador.

Contar sucesos
Para contar cuántas veces ocurre algo, hay que usar un acumulador, al que se le suele
llamar contador.
Tal como en el caso de la suma, debe ser inicializado en cero, y cada vez que aparezca
lo que se quiere contar, hay que incrementarlo en uno.
Por ejemplo, el siguiente programa cuenta cuántos de los números naturales menores
que mil tienen un cubo terminado en siete:
c = 0
for i in range(1000):
ultimo_digito = (i ** 3) % 10
if ultimo_digito == 7:
c = c + 1
print (c)

Encontrar el mínimo y el máximo

Para encontrar el máximo de una secuencia de valores, hay que usar una variable
auxiliar para recordar cuál es el mayor valor visto hasta el momento. En cada iteración, hay
que examinar cuál es el valor actual, y si es mayor que el máximo, actualizar la variable
auxiliar.
La variable auxiliar debe ser inicializado con un valor que sea menor a todos los
valores que vayan a ser examinados.
Por ejemplo, el siguiente programa pide al usuario que ingrese diez números enteros
positivos, e indica cuál es el mayor de ellos:
print ('Ingrese diez números positivos')

mayor = -1
for i in range(10):
n = int(input())
if n > mayor:
mayor = n

print ('El mayor es ', mayor)

Otra manera de hacerlo es reemplazando esta parte:
if n > mayor:
mayor = n
por ésta:
mayor = max(mayor, n)

116
 Unidad IV. Estructuras de Control
Herramientas de programación

En este caso, como todos los números ingresados son positivos, se inicializa la
variable auxiliar en -1, que es menor que todos los valores posibles, por lo que el que sea el
mayor eventualmente lo reemplazará.
¿Qué hacer cuando no exista un valor inicial que sea menor a todas las entradas
posibles? Una solución es poner un número «pequeño negativo», de tal manera que el usuario
no ingrese uno menor que él. Esta no es la mejor solución, ya que no cubre todos los casos
posibles:
mayor = -999999999

for i in range(10):
n = int(input())
mayor = max(mayor, n)
Una opción más robusta es usar el primero de los valores por examinar:
mayor = int(input()) # preguntar el primer valor

for i in range(9): # preguntar los nueve siguientes

n = int(input())
mayor = max(mayor, n)

La otra buena solución es usar explícitamente el valor −∞, que en Python puede
representarse usando el tipo float de la siguiente manera:
mayor = -float('inf') # Así se asigna "infinito" en Python
for i in range(10):
n = int(input())
mayor = max(mayor, n)

Si se sabe de antemano que todos los números por revisar son positivos, simplemente
se inicializa la variable mayor en 1.
Por supuesto, para obtener el menor valor se hace de la misma manera, pero
inicializando el acumulador con un número muy grande, y actualizándolo al encontrar un
valor menor.

Generar pares
Para generar pares de elementos en un programa, es necesario usar dos ciclos
anidados (es decir, uno dentro del otro).
Ambos ciclos, el exterior y el interior, van asignando valores a sus variables de
control, y ambas son accesibles desde dentro del doble ciclo.
Por ejemplo, todas las casillas de un tablero de ajedrez pueden ser identificadas
mediante un par (fila, columna). Para recorrer todas las casillas del tablero, se puede hacer
de la siguiente manera:
for i in range(1, 9):
for j in range(1, 9):
print ('Casilla', i, j)

117
 Secuencias y Series

Cuando los pares son desordenados (es decir, el par (a,b) es el mismo que el par
(b,a)), el ciclo interior no debe partir desde cero, sino desde el valor que tiene la variable de
control del ciclo interior.
Por ejemplo, el siguiente programa muestra todas las piezas de un juego de dominó:
for i in range(7):
for j in range(i, 7):
print (i, j)
Además, otros tipos de restricciones pueden ser necesarias. Por ejemplo, en un
campeonato de fútbol, todos los equipos deben jugar entre ellos dos veces, una como local y
una como visita. Por supuesto, no pueden jugar consigo mismos, por lo que es necesario
excluir los pares compuestos por dos valores iguales. El siguiente programa muestra todos
los partidos que se deben jugar en un campeonato con 6 equipos, suponiendo que los equipos
están numerados del 0 al 5:
for i in range(6):
for j in range(6):
if i != j:
print (i, j)
Otra manera de escribir el mismo código es:
for i in range(6):
for j in range(6):
if i == j:
continue
print (i, j)

Secuencias y Series
Para los estudiantes de programación, es interesante la aplicación de las técnicas de
resolución de ejercicios relacionados al cálculo de los términos de una serie o secuencia,
porque en ellas se utilizan todas las técnicas elementales de programación, tales como
acumuladores, ciclos de diferentes tipos, banderas y por supuesto expresiones de diferentes
tipos.
SUCESIÓN Y SECUENCIA: Una sucesión matemática es una función definida
sobre los enteros naturales. Una secuencia es una concatenación de símbolos obtenidos a
partir de una sucesión. Son semejantes a las sucesiones y se pueden derivar fácilmente de
éstas. Por ejemplo, la definición matemática de la secuencia de Fibonacci es:
𝑓𝑖𝑏(1) = 0 𝑃𝑎𝑟𝑎 𝑛 = 1
𝑓𝑖𝑏(𝑛) { 𝑓𝑖𝑏(2) = 1 𝑃𝑎𝑟𝑎 𝑛 = 2
𝑓𝑖𝑏 (𝑛) = 𝑓𝑖𝑏 (𝑛 − 2) + 𝑓𝑖𝑏 (𝑛 − 1) ∀𝑛 > 2
Los primeros 10 términos de esta secuencia son: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . . Así,
si se toma como base la secuencia de Fibonacci, es sencillo definir una nueva secuencia para
el alfabeto A = {0,1} según el siguiente método:

118
 Unidad IV. Estructuras de Control
Secuencias y Series

𝑆(𝑛) {1 𝑆𝑖 𝑛 𝑒𝑠𝑡á 𝑒𝑛 𝑙𝑎 𝑠𝑢𝑐𝑒𝑠𝑖ó𝑛 𝑑𝑒 𝐹𝑖𝑏𝑜𝑛𝑎𝑐𝑐𝑖

0 𝐸𝑛 𝑜𝑡𝑟𝑜 𝑐𝑎𝑠𝑜
que obtendría como resultado un 1 para el numero natural 1, ya que éste está en la
secuencia de Fibonacci; 1 para los números naturales 2 y 3; pero 0 para el numero natural 4,
ya que él no pertenece a la secuencia de Fibonacci. Obteniéndose, entonces, la siguiente
secuencia de dígitos binarios: 1 1 1 1 0 1 0 0 1 0 0 0 0 1 0 . . .
Observe la relación entre la secuencia de los dígitos binarios generada, la secuencia
de Fibonacci: y los números naturales:
N 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
S(n) 1 1 1 1 0 1 0 0 1 0 0 0 0 1 0

• Los ejercicios típicos para estos casos corresponden a: [1] Determinar los primeros N
términos de la secuencia, [2] Determinar los términos de la secuencia menores que
N, [3] Determinar los términos comprendidos en el rango abierto de N y M. El
problema podría referirse a sumar los términos calculados, o determinar
promedios/porcentajes, etc.
• Para calcular, desde el segundo término en adelante, la secuencia de Fibonacci, se
requiere recordar los dos últimos términos calculados. El concepto de recordar
valores obtenidos de cálculos anteriores, se conoce como un historial y es interesante
desde el punto de vista de programación, porque requiere el uso de variables
auxiliares, asignaciones o cambios de valores adecuados.
• SERIES: Una serie es la suma de los términos de una sucesión. Se representa una
serie con términos an como se muestra a continuación:
𝑁

∑ 𝑎𝑛
𝑖=!

donde N es el índice final de la serie.

A continuación, se presenta, como ejemplo, la serie para el cálculo de: seno de x
y ex
𝑥3 𝑥5 𝑥7
𝑆𝑖𝑛(𝑥) = 𝑥 + − + …, −∞ < 𝑥 < ∞
3! 5! 7!
𝑥 𝑥2 𝑥3
𝑒𝑥 = 1 + + + +⋯ , −∞ < 𝑥 < ∞
1! 2! 3!
En el desarrollo de programas para el cálculo de series es muy importante hacer un
análisis previo, detallado y preciso de [1] cómo el programa generara el término en sí y [2]
cómo se conforman los términos de la serie.
Para la generación de los términos, el programador puede diseñar el programa de tal
manera que se trabaje:

a. CON EL TÉRMINO COMO UN TODO, en cuyo caso la transición de los elementos se

realiza sobre una sola variable. Esta variable se comporta como una productoria del

119
 Secuencias y Series

término anterior por la transición para generar el nuevo termino. Esta técnica no es
apropiada para aquellos casos en que el término de la serie conlleva una sumatoria.
b. CON LOS ELEMENTOS QUE CONFORMAN EL TÉRMINO, en este caso se descompone
el termino en elementos básicos como sumatorias, productorias, signos alternos,
cálculos previos o internos.
Entre los elementos de programación más usados en los programas de series, se
encuentran:

• CONTADORES: Se usan típicamente para contar el número de términos a calcular,

para calcular pares/impares y definir paridad
• SUMATORIAS: Variables que almacenan el valor de la serie, o de porciones de los
términos
• PRODUCTORIAS: Variables apropiadas para el cálculo de factoriales y potencias
• BANDERAS: Variables necesarias para detectar cuando debe cambiarse el signo o
invertir los términos, o para cálculos especiales que requieran la determinación de un
evento
• CÁLCULOS PREVIOS: Se refiere a los cálculos necesarios para obtener el primer
término de la serie a partir del cual se generarán los siguientes. Tal como el caso de
un factorial decreciente o potencias decrecientes
• CALCULOS INTERNOS: Caso que se presenta cuando no es posible determinar el
término a generare a partir del anterior. Como por ejemplo el caso de una potencia
donde la base cambia entre términos.
Ejercicio 4-6: Dados N y X, desarrollar el Diagrama de Flujo de un programa que
calcule y escriba cada término de la serie y la suma de los N primeros términos.

Análisis del ejercicio:

¿QUE SE TIENE? Valores N y X leídos. Se asume que N > 0
¿QUE SE PIDE? Imprimir los primeros N términos y sumarlos, al final imprimir la
suma
¿CÓMO LOGRARLO?

120
 Unidad IV. Estructuras de Control
Secuencias y Series

Algoritmo serie1
Variables diagrama de flujo
; entrada
N : entero
X : real
; proceso
A : real
P : real
F : entero
; salida
S : real
Inicio
Imprimir “# de Términos:”
Leer N
Imprimir “Valor de X:”
Leer x
; inicio contadores y acumuladores
S<-0
P<-1
A<-0
F<-1
; Ciclo para generar los términos
Para I<- 1 hasta N hacer
; elementos del término
P <- p * x
A <- A + P
F <- F * (2 * i)*(2 * i -1)
; TÉRMINO
Termino <- A/F
; Uso EL TÉRMINO
S <- S + termino
Finpara
Imprimirln” La suma de los primeros “, N,
“términos de la
serie es “, S
Fin
Ejercicio 4-7: Dados los valores de X y R, elabore el Diagrama de Flujo de un
𝒙𝟐
−( )
programa que determine el valor aproximado de 𝒆 𝟐 según el desarrollo de los primeros
R términos, empleando el método de Taylor, el cual se muestra a continuación,
𝑥2 𝑥2 𝑥4 𝑥6 𝑥8
−( )
𝑒 2 = 1− + − + −⋯
2 ∗ 1! 4 ∗ 2! 6 ∗ 3! 8 ∗ 4!
Análisis del Problema:

121
 Secuencias y Series

| ELEMENTO: 1 FORMULA |lNICIO

i: 1 2 3 4 5
signo: + — + — + signo <- - signo signo <- 1
potX: 1 x2 x4 x6 x8 potX <- potX * x * x potX <- 1
fact: 1 1! 2! 3! 4! fact <- fact * i| i>1 fact <- 1
par: 1 2 4 6 8 par 2 * i |i>1 par 1

Algoritmo serie2
Variables
; entrada
N : entero
R : real
; proceso
Signo : real
Par : real
Potx : real
; salida
S : real
Inicio
Imprimir “# de Términos:”
Leer N
Imprimir “Valor de X:”
Leer x
S<-0
signo <-1
par <-0
potx <-1
fact <- 1
Para i <- 1 hasta N hacer
termino <- potx /(par*
fact)
S<-s + termino
signo <- - signo
potx <- potx * x * x
fact <- fact * i
Finpara
Imprimirln ” La suma de los
primeros “, N, “terminos de la
serie es “, S
Fin

Código 4-14. serie2.py

'''
Declarar variables de entrada
n
x
Declarar variables de salida
suma
Declarar variables de proceso
termino
signo
numerador

122
 Unidad IV. Estructuras de Control
Secuencias y Series

denominador
fact
par
i
'''

# lectura de la cantidad de términos y de la variable de la serie

n = int(input("n: "))
x = float(input("x: "))

# Inicializar las variables

suma = 0
signo = 1
fact = 1
par = 1

# Proceso
for i in range(n):
# Calcular cada elemento del termino
if i == 0:
termino = 1
else:
signo = (-1) ** i
numerador = x ** (2 * i)
fact *= i
par = 2 * i
denominador = par * fact
# Calcular el termino
termino = signo * numerador / denominador

# Sumar el termino
suma += termino
print("Termino (" , i , ") = ", termino)

# Impresión de resultado
print("Suma=", suma)

Ejecución del programa serie1.py:

123
 Secuencias y Series

Ejercicio 4-8: Dados H y M, desarrolle un programa que imprima y sume los M

primeros términos de la siguiente serie y el resultado de la sumatoria:

Elemento: Términos Fórmula Inicializar

i: 0 1 2
signo: - + + Signo = -1
suma_impares += (2 * i suma_impares
suma_impares 1 1+3 1+3+5
+ 1) = 0
suma_pares += (2 * i + suma_pares =
suma_pares 2 2+4 2+4+6
2) 0
numerador = signo * H ^
+𝐻 2 +𝐻 3 ∗ (1 + 3 +
numerador −𝐻 ∗ (1)𝑀 (i + 1) * suma_impares
∗ (1 + 3)𝑀 5)𝑀 ** M
denominador_par =
suma_pares!
denominador 2! 2+4 (2+4+6)!
denominador_impar =
suma_pares
𝐻 ∗ (1)𝑀 𝐻 2 ∗ (1 + 3)𝑀 𝐻 3 ∗ (1 + 3 + 5)𝑀 término =
término −
2! 2+4 (2 + 4 + 6)! numerador/denominador

Código 4-15. serie2.py

'''
Declaración de Variables:
Variables de entrada (Qué tengo?)
h: float, es el Número de variable de la serie
m: int, es la cantidad de Términos
Variables de salida (Qué quiero?)
Suma: float, es la suma de los términos
Termino: float, es el valor de cada término
Variables de proceso (Cómo lo logro?)
I: int, es el contador del ciclo
Signo: int, es el signo del termino
suma_impares: int, es el números del numerador
suma_pares: int, es el número del denominador
numerador: float, es el valor de todo el numerador
denominador: float, es el valor de todo el denominador
'''

124
 Unidad IV. Estructuras de Control
Composición y descomposición de un número.

# Lecturas correspondientes
# Se leen los valores de número de variable de la serie (h) y términos (m)

h = float(input("Introduzca el valor de la variable de la serie (h): "))

m = int(input("Introduzca el valor del número de términos (m): "))

# Inicializaciones correspondientes
suma = 0
signo = -1
suma_impares = 0
suma_pares = 0

# Determinación de los términos de la serie

for i in range(m): # Para los primeros m términos
# Cálculo de cada elemento del término
suma_impares += (2 * i + 1)
suma_pares += (2 * i + 2)
numerador = signo * h ** (i + 1) * suma_impares ** m
if i % 2 != 0: # Los términos pares no tienen factorial
denominador = suma_pares
else: # Los términos impares tienen factorial
factorial = 1
for j in range(suma_pares):
factorial *= j + 1

denominador = factorial

termino = numerador / denominador # Determinación del término e

impresión
print("Término: ", i + 1, " = ", termino)
signo = 1 # El resto de los términos son positivos
suma += termino # Se acumula la suma

# Se imprime la suma
print("La suma de los ", m, " primeros términos es: ", suma)
Ejecución del programa serie1.py:

Composición y descomposición de un número.

Un sistema de numeración es un conjunto de símbolos y reglas que se utilizan para
representar y operar con cantidades. En los sistemas de numeración existe un elemento
característico que define el sistema y se denomina base, siendo ésta el número de símbolos
que se utilizan para la representación. Así, un sistema de base diez utiliza 10 símbolos (0, 1,

125
 Composición y descomposición de un número.

2, 3, 4, 5, 6, 7, 8, 9), un sistema de base dos utiliza 2 símbolos (0, 1), un sistema de base
cuatro utiliza 4 símbolos (0, 1, 2, 3). Desde hace años, el hombre utiliza como sistema de
numeración el sistema decimal, derivado del sistema numérico indo-arábigo y muy
posiblemente fundamentado en los diez dedos de las manos.
Los sistemas de numeración actuales son sistemas posiciónales, en los que el valor
que representa cada símbolo o cifra depende de su valor absoluto y de la posición relativa
que ocupa la cifra con respecto al resto. Siendo entonces el digito menos significativo aquel
ubicado en la posición relativa de menor valor; y el digito más significativo aquel ubicado en
la posición relativa de mayor valor. Para un número entero de cinco dígitos: el digito menos
significativo es el digito ubicado en la posición relativa: unidad y el dígito más significativo
es el digito en la posición relativo: decena de miles. Por ejemplo: para el numero: 1 2 3 4 5
el dígito menos significativo es: 5 y el digito más significativo es: 1
Las tareas más comunes para la manipulación de dígitos que conforman un número
son: (1) Componer un número a partir de sus dígitos; (2) Determinar la cantidad de dígitos
que conforman un número; (3) Desglosar un número en sus dígitos; entre otras.

Algoritmos para Determinar la Cantidad de dígitos de un número

Entero
Para determinar la cantidad de dígitos de un número hay que ir comparando el número
con la Unidad seguida de ceros hasta encontrar el valor de la unidad seguida de tantos ceros
que supere a nuestro número, la cantidad de veces que se compara es la cantidad de dígitos
del número. Ejemplo:
UNIDAD
NUMERO
SEGUIDA n>=u cd CÓDIGO
(n)
DE CEROS (u) Observe que al
45897 1 Si 1 u=1 finalizar el proceso
cd = 0 u contiene un
1 * 10 Si 2
mientras n >= u dígito más que el
10 * 10 Si 3
u = u * 10 número original
100 * 10 Si 4
1000 * 10 Si 5 cd = cd + 1
10000 * 10 No

Otro Forma es partir de la unidad, pero considerando que el número tiene por lo
menos un dígito, se compara con el valor de la Unidad *10:
UNIDAD
NUMERO Observe que al
SEGUIDA n>=u*10 cd CÓDIGO
(n)
DE CEROS (u ) finalizar el proceso
58975 1 Si 2 u=1 u contiene la
1 * 10 Si 3 cd = 1 misma cantidad
10 * 10 Si 4 mientras n >= u * 10 de dígitos que el
100 * 10 Si 5 u = u * 10 número original
1000 * 10 No cd = cd + 1

126
 Unidad IV. Estructuras de Control
Composición y descomposición de un número.

Descomposición de un número en sus dígitos, del menos significativo

al más significativo o de derecha a izquierda
El proceso consiste en determinar el digito como el residuo de dividir el número por
10 y repetir el proceso con un nuevo número formado por el residuo de la división por 10,
mientras existan dígitos.
Por ejemplo: Considere el número: |45897|
NUMERO DÍGITO NUEVO NUMERO PROCESO
45897 45897 % 10 = 7 45897 // 10 = 4589
4589 4589 % 10 = 9 4589 // 10 = 458 mientras n > 0
458 458 % 10 = 8 458 // 10 = 45 dig = n % 10
45 45 % 10 = 5 45 // 10 = 4 n = n // 10
4 4 % 10 = 4 4 // 10 = 0

Note que este algoritmo descompone el número desde el digito menos significativo al digito más
significativo: 7 9 8 5 4

Descomposición de un número en sus dígitos, del más significativo al

menos significativo o de izquierda a derecha
El proceso consiste en determinar el digito como el cociente de dividir el número por
la unidad seguida de tantos ceros como la posición del dígito dentro del número original y
repetir el proceso con un nuevo número formado de quitar el dígito obtenido, mientras existan
dígitos.
Por ejemplo: Considere el número: |45897|
NÚMERO DÍGITO NUEVO NÚMERO PROCESO
45897 45897 // 10000 = 4 45897 % 10000 = 5897 1. Determinar la Potencia
5897 5897 // 1000 = 5 5897 % 1000 = 897 para obtener el primer
897 897 // 100 = 8 897 % 100 = 97 dígito (P)
97 97 // 10 = 9 97 % 10 = 7 2. Determinar cada dígito
mientras P > 0
7 7 // 1 = 7 7 % 1 = 0 dig = n // p
n = n % p
p = p // 10
Note que este algoritmo descompone el número desde el dígito más significativo al dígito menos
significativo: 4 5 8 9 7

Determinar la Potencia para obtener el primer dígito (P)

Usando el algoritmo para determinar la cantidad de dígitos.
p = u // 10 {Para quitarle el dígito de más}
Usando el algoritmo 1, para determinar la cantidad de dígitos.
p=u
Los procesos de descomposición de números son destructivos, lo que implica que los
valores originales de la variable se pierden en el proceso de descomposición, si requiere de
estos valores una vez efectuado el proceso de descomposición, debe guardar una copia antes
de iniciar el proceso de descomposición.

127
 Composición y descomposición de un número.

Composición de números a partir de sus dígitos, del más al menos

significativo o de izquierda a derecha
El proceso consiste en acumular cada digito, en el número multiplicado por 10.
Por ejemplo: Considere los dígitos: 7 9 8 5 4 [siendo 7 el digito más significativo y
4 el digito menos significativo]
AGREGANDO EL NUEVO
DIGITO CÓDIGO
DIGITO NUMERO
7 0 * 10 + 7 = 7 0 + 7 = 7 cent = 0
9 7 * 10 + 9 = 79 70 + 9 = 79 n = 0
8 79 * 10 + 8 = 798 790 + 8 = 798 mientras cent == 0
5 798 * 10 + 5 = 7985 7980 + 5 = 7985 leer(dig, cent)
4 7985 * 10 + 4 = 79854 79850 + 4 = 79854 n = n *10 + dig

Note que este algoritmo compone el número a partir del digito menos significativo al digito más
significativo: 79854.
Nota: Para el ejemplo se leen los dígitos, pero pueden provenir
de otro proceso, en cuyo caso no se leerían.

Composición de números a partir de sus dígitos, del menos al más

significativo o de derecha a izquierda
El proceso consiste en acumular el producto de cada digito por una potencia de 10,
que indicará la posición del dígito dentro del número, es decir, si ocupa la decena se
multiplica por 10, si ocupa la centena por 100 y así sucesivamente.
Por ejemplo: Considere los dígitos: 7 9 8 5 4 [siendo 7 el digito menos significativo
y 4 el digito más significativo]
AGREGANDO NUEVO
DIGITO CÓDIGO
EL DIGITO NUMERO
7 7 * 1 = 7 0 + 7 = 7 cent = 0
9 9 * 10 = 90 7 + 90 = 97 p = 1
8 8 * 100 = 800 97 + 800 = 897 n = 0
5 5 * 1000 = 5000 897 + 5000 = 5897 mientras cent = 0
leer(dig, cent)
4 4 * 10000 = 40000 5897 + 40000 = 45897 n = n + dig * p
p = p * 10

Note que este algoritmo compone el número a partir del digito menos significativo al digito más
significativo: 45897.
Nota: Para el ejemplo se leen los dígitos, pero pueden provenir
de otro proceso, en cuyo caso no se leerían.
Ejercicio 4-9: Escribir un programa que solicite números positivos al usuario.
Mostrar el número cuya sumatoria de dígitos fue mayor y la cantidad de números cuya
sumatoria de dígitos fue menor que 10.
Código 4-16. dígitos_suma_cant.py

cantidad = 0
mayor = -1
numero = int(input("Número positivo: "))

128
 Unidad IV. Estructuras de Control
Glosario

while numero >= 0:

suma = 0
while numero != 0:
digito = numero % 10
suma += digito
numero //= 10

if suma > mayor:

mayor = suma
n_mayorsuma = numero

if suma < 10:

cantidad += 1

numero=int(input("Número positivo: "))

print("Sumatoria de dígitos de ",n_mayorsuma,":",mayor)
print("Cantidad con sumatoria menor a 10: ",cantidad)

Glosario
anidamiento: Una estructura de programa dentro de otra; por ejemplo, una sentencia
condicional dentro de una o ambas ramas de otra sentencia condicional.
bloque: Grupo de sentencias consecutivas con el mismo sangrado.
condición: La expresión booleana de una sentencia condicional que determina qué
rama se ejecutará.
cuerpo: En una sentencia compuesta, el bloque de sentencias que sigue a la cabecera
de la sentencia.
expresión booleana: Una expresión que es cierta o falsa.
operador de comparación: Uno de los operadores que comparan dos valores: ==.
!=, >, <. >= y <=.
operador lógico: Uno de los operadores que combinan expresiones booleanas: and,
or y not.
operador módulo: Operador, señalado con un signo de tanto por ciento (que trabaja
sobre enteros y devuelve el resto cuando un número se divide entre otro.
sentencia compuesta: Estructura de Python que está formado por una cabecera y un
cuerpo. La cabecera termina en dos puntos (:). El cuerpo tiene una sangría con respecto a la
cabecera.
sentencia condicional: Sentencia que controla el flujo de ejecución de un programa
dependiendo de cierta condición.

Resumen

129
 Recomendaciones para la escritura de código limpio.

Para poder tomar decisiones en los programas y ejecutar una acción u otra, es
necesario contar con una estructura condicional.
Las condiciones son expresiones booleanas, es decir, cuyos valores pueden ser
verdadero o falso, y se escriben mediante operadores entre distintos valores.
Mediante expresiones lógicas es posible modificar o combinar expresiones
booleanas.
La estructura condicional puede contener, opcionalmente, un bloque de código que
se ejecuta si no se cumplió la condición.
Es posible anidar estructuras condicionales, colocando una dentro de otra.
También es posible encadenar las condiciones, es decir, colocar una lista de posibles
condiciones, de las cuales se ejecuta la primera que sea verdadera.
En esta unidad también se ha utilizado las dos estructuras de control que permiten
repetir instrucciones.
Además de los ciclos definidos, en los que se sabe cuáles son los posibles valores que
tomará una determinada variable, existen los ciclos indefinidos, que se terminan cuando no
se cumple una determinada condición.
Se utiliza la función range() para generar una lista de valores automática que nos
facilitó el uso de for, aunque su uso no es exclusivo de este contexto.
La condición que termina el ciclo puede estar relacionada con una entrada de usuario
o depender del procesamiento de los datos.
Se utiliza el método del centinela cuando se quiere que un ciclo se repita hasta que el
usuario indique que no quiere continuar.
Además de la condición que hace que el ciclo se termine, es posible interrumpir su
ejecución con código específico dentro del ciclo.

Recomendaciones para la escritura de código limpio.

Las presentes recomendaciones son el resultado de la observación directa en
ejercicios de diferentes evaluaciones, y que el estudiante debe procurar evitar para tener un
código limpio y con un mejor estilo. También, se agregan algunas normas básicas de escritura
de código (Adaptado del Manual básico, iniciación a Python 3 por José Miguel Ruiz Torres
[6]). Estas buenas prácticas de programación tienen el fin de mejorar las tareas de revisión,
intercambio y escalabilidad del código.
1. Los nombres de los archivos deben escribirse en minúscula. Ejemplo: hola.py,
calculadora.py
2. La llamada a una función se escribe en minúscula. Ejemplo: print(), input()
3. Dejar un espacio en blanco después de cada coma. Ejemplo:
print('Tienes', num_zapatos, 'zapatos y', num_blusas, 'blusas.')
4. Dejar un espacio antes y después de cada operador. Ejemplo:
velocidad = distancia / tiempo

130
 Unidad IV. Estructuras de Control
Recomendaciones para la escritura de código limpio.

total += 6
5. Dejar la sangría con 4 espacios; evita usar la tecla tabuladora. Ejemplo:
if nombre == 'Ángel':
print('Hola', nombre)
input()
6. Escriba la expresión lógica de forma clara, sencilla y de forma positiva, es decir, que se
debe cumplir para ejecutar el bloque de instrucciones.
7. No escriba condiciones innecesarias, en algunos casos puede hacer analogía con
inecuaciones o conjuntos, evalúe la posibilidad de utilizar el descarte como parte de la
condición.
8. Si la expresión lógica es muy compleja, puede utilizar una variable para almacenar dicha
expresión.
9. Las variables se escriben en minúscula y en caso de estar formadas por varias palabras,
éstas van unidas por guiones bajos. Ejemplo: velocidad, altura_inicial
10. Declarar las variables con el tipo de dato adecuado, escribiendo en minúscula dicho tipo
de dato. Ejemplo:
nombre: str
contador_alumnos: int
11. Declarar las variables mediante identificadores adecuados. No utilizar identificadores
que carezca de significado descriptivo. Con un código legible y nombres significativos,
el código se va auto documentado.
12. Ser consistente al momento de utilizar un estándar para nombres largos, por ejemplo,
para una variable que almacena cantidad de alumnos 'contador_alumnos'
13. Declarar variables en líneas separadas, posibilitando agregar una descripción de cada
variable mediante comentarios.
14. Declare las variables en orden, recomendablemente: primero las variables de entrada,
luego las variables de salida y finalmente las variables de proceso. Para realizar esto:
a. Identifique las variables de entrada en el enunciado o planteamiento del
problema.
b. Identifique las variables de salida, las cuales corresponden a las preguntas en el
enunciado.
c. Para identificar las variables de proceso, lógicamente tendrá que analizar cómo
obtener las variables de salida, entonces debe ir pregunta por pregunta
analizando como resolver, por ejemplo: si se le solicita determinar el promedio
de estudiantes aprobados, como es el cálculo de un promedio, necesitará un
acumulador y un contador, estas son dos variables que debe declarar en la
sección de variables de proceso. Otro ejemplo: para determinar el alumno con
la mayor nota, requerirá de una bandera, una variable para comparar la mayor
nota y al menos una variable que guarde el nombre del estudiante, esto
dependerá de la pregunta del enunciado que indicará cuáles datos se requerirán
de ese estudiante.
15. Inicializar las variables que así lo requieren, en especial: variables de tipo cadena (str),
contadores, acumuladores, productorias, entre otras.

131
 Recomendaciones para la escritura de código limpio.

Opcionalmente puede iniciar la variable al declararla, por ejemplo:

nombre: str = ‘’
16. Escribir los programas lo más simple posible.
17. Escribe los comentarios necesarios en tu código, describiendo cada detalle, para hacer
que sea lo más claro y legible posible.
18. Comentar los programas, explicando el propósito, funcionamiento completo y el
resultado esperado.
19. Evitar la incorporación de más de una instrucción por línea. Esto reduce notoriamente
la legibilidad del código, ya que el programador habitualmente está acostumbrado a
leer una instrucción por línea.
20. Realizar la sangría necesaria, si una instrucción abarca más de una línea. Por ejemplo:
a = (1 + 2
+ 3 + 4)
21. Utilice los operadores aritméticos adecuadamente, especialmente para la potencia, el
producto y para la división, debe escribirla tal cual lo haría de forma digital respetando
la sintaxis del lenguaje de programación, por ejemplo:
t = i * x**(i + 1) / (2 * i + 1)
22. Los operadores lógicos tienen su jerarquía, realice la corrida en frío del siguiente
ejercicio, después escriba y ejecute este código en Python para que compare sus
resultados:
a:bool
b:bool
c:bool
d:bool

a = True
b = False
c = False
d = False

print(a or b and c or d) # True primero se evalua and y luego or

23. Utilizar la estructura condicional adecuadamente, por ejemplo:
En vez de escribir:
if condición1:
...
else
if condición2:
...
Escriba:
if condición1:
...

132
 Unidad IV. Estructuras de Control
Recomendaciones para la escritura de código limpio.

elif condición2:
...
24. No Repita Instrucciones Innecesariamente dentro de los bloques de la estructura
condicional, sí esto sucede evalúe la posibilidad de que dicha instrucción se escriba fuera
de la estructura, por ejemplo:
En vez de escribir está estructura:
if condición:
...
num = a + b
den = a * b
t = num / den
else:
...
num = c + d
den = c * d
t = num / den
Escríbalo de esta manera:
if condición:
...
num = a + b
den = a * b
else:
...
num = c + d
den = c * d
t = num / den # Esta instrucción estaba repetida en la estructura
# condicional anterior, por lo tanto,
# se escribe fuera de la estructura.
25. Utilice los operadores lógicos adecuadamente; por ejemplo, si se requiere la condición
para los valores de x entre 0 y 5:
cond = 0 < x < 5

26. Con el fin de evitar errores de ejecución, realice la validación de las fórmulas o
ecuaciones en los casos de que exista la posibilidad de una indeterminación, como es el
caso de promedio, porcentaje, o en series numéricas. Por ejemplo, si se calcula el
promedio de notas de aprobados como: prom_aprob = suma_notas_aprob / cant_prob,
resultaría infinito si cant_aprob es cero, es una posibilidad remota; pero puede suceder,
para ello se debe programar de la siguiente manera:
if cant_prob == 0:
print("No hubo aprobados")
else:
prom_aprob = suma_notas_aprob / cant_prob
print(f"El Promedio de Aprobados es = {prom_aprob:.2f}")
De esta manera, se captura un posible error de ejecución en caso de que no haya
estudiantes aprobados.
27. Utilice la estructura repetitiva adecuada, sí conoce la cantidad de veces a ejecutar el
ciclo, utilice for, si las iteraciones dependen de una condición determinada, utilice while.

133
Recomendaciones para la escritura de código limpio.

134
 Referencias

L. Joyanes Aguilar, Fundamentos de programación:

[1]
Algoritmos, estructura de datos y objetos, 4a. ed.,
Madrid: McGraw-Hill, 2008.
A. Dasso y A. Funes, Introducción a la Programación,
[2]
Universidad Nacional de San Luis, 2014.
P. Gomis, Fundamentos de Programación en Python,
[3]
Catalunya: Universitat Politècnica de Catalunya, 2018.
A. Marzal Varó, I. Gracia Luengo y P. García Sevilla,
[4]
Introducción a la Programación con python 3, Castellón
de la Plana: Publicacions de la Universitat Jaume I,
2014.
A. Soto Suarez y M. Arriagada Benítez, Introducción a
[5]
la Programación con Python, Pontificia Universidad
Catolica de Chile, 2015.
J. M. R. Torres, Manual básico, iniciación a Python 3,
[6]
2020.
M. J. Mathieu, Introducción a la programación, PRIMERA
[7]
EDICIÓN EBOOK ed., México: Grupo Editorial Patria, S.A.
de C.V, 2014.
E. Bahit, Python para Principiantes, Buenos Aires,
[8]
2012.
E. Bahit, Introduccion al Lenguaje Python, Buenos
[9]
Aires, 2018.