Contenido

Elementos y conceptos fundamentales de la informática ....................................................... 3

Brecha digital ................................................................................................................................ 3
NTICS .............................................................................................................................................. 3
Historia de la Computación ........................................................................................................ 5
¿Qué son las aplicaciones? ......................................................................................................... 7
Clasificación de las aplicaciones ................................................................................................ 7
Impacto de la informática en la sociedad actual ...................................................................... 8
Programación .................................................................................................................................... 9
Distintas tecnologías ................................................................................................................... 9
Proyecto informático ..................................................................................................................... 10
Pasos para la solución de problemas ..................................................................................... 10
Diseño de un programa ............................................................................................................ 11
Técnicas para la formulación de algoritmos ......................................................................... 14
Concepto de algoritmo ................................................................................................................. 14
Proceso general de resolución de problemas con la computadora ................................. 15
Condiciones con las que debe de cumplir un algoritmo .................................................... 16
Estructura de un algoritmo ...................................................................................................... 16
Terminología en el manejo de algoritmos ............................................................................ 20
Identificadores ............................................................................................................................ 20
Variables ...................................................................................................................................... 20
Asignación de datos ................................................................................................................... 21
Operadores .................................................................................................................................. 22
Ejemplos de algoritmos: ........................................................................................................... 24
Estructura general de un programa ....................................................................................... 25
Programación estructurada ...................................................................................................... 25
Diagramas de flujo ........................................................................................................................ 27
Simbología básica ...................................................................................................................... 27
Estructuras de programación ...................................................................................................... 30
Estructura secuencial ................................................................................................................ 30
Estructuras de selección ........................................................................................................... 30
Estructura de selección simple ............................................................................................ 31
Estructura de selección múltiple(según) ........................................................................... 35
Estructuras de repetición o bucles o ciclos ........................................................................... 38
Estructura mientras-hacer .................................................................................................... 38
Estructura repetir – hasta .................................................................................................... 41

1
 Estructura desde / para(for) ................................................................................................ 44
Instrucciones básicas en Python ................................................................................................ 54
¿Qué es Python? ......................................................................................................................... 54
Características de Python ......................................................................................................... 56
Ventajas de Python .................................................................................................................... 56
Tipos de Datos ............................................................................................................................ 57
Tipos de datos básicos .............................................................................................................. 58
Funciones de conversión de tipos de datos en Python ...................................................... 58
Operadores en Python............................................................................................................... 59
Declaración y asignación de variables ................................................................................... 63
Instrucciones básicas ................................................................................................................ 65
Estructuras de control ............................................................................................................... 66
Estructuras condicionales ......................................................................................................... 66
if, if-else ................................................................................................................................... 66
Estructuras repetitivas .............................................................................................................. 69
Ciclo while en Python ............................................................................................................. 69
Ciclo for en Python ................................................................................................................. 71
Introducción a las funciones ........................................................................................................ 72
Cómo usar o llamar a una función ......................................................................................... 74
Diseño modular de programas: Descomposición modular ................................................ 75
Importar módulos en Python ................................................................................................... 75
Arreglos ............................................................................................................................................ 78
Tipo listas ..................................................................................................................................... 79
Métodos que se pueden usar en las listas ........................................................................ 81
Generar números aleatorios entre dos valores en Python ................................................ 84
Obtener elementos aleatorios de una secuencia................................................................. 86
Matrices ........................................................................................................................................ 88
Software para calculo científico .................................................................................................. 96
¿Qué es Scilab? .......................................................................................................................... 96
Instrucciones básicas ................................................................................................................ 98
Definición de funciones ........................................................................................................... 100
Estructuras de selección ......................................................................................................... 103
Estructura select....................................................................................................................... 103
Estructura while ........................................................................................................................ 104
Estructura for ............................................................................................................................ 104
Construcción de arreglos en Scilab ...................................................................................... 108
Gráficos en Scilab..................................................................................................................... 115

2
Elementos y conceptos fundamentales de la informática
El conjunto de órdenes que se dan a una computadora para realizar un proceso
determinado se denomina programa, mientras que el conjunto de uno o varios
programas más la documentación correspondiente para realizar un determinado
trabajo, se denomina aplicación informática. La información es el elemento que
hay que tratar y procesar cuando en una computadora ejecutamos un programa,
y se define como todo aquello que permite adquirir cualquier tipo de
conocimiento. El tratamiento de la información se denomina al conjunto de
operaciones que se realizan sobre una información.

Brecha digital
Brecha digital hace referencia a una totalidad socioeconómica entre aquellas
comunidades que tienen accesibilidad a Internet y aquellas que no, aunque tales
desigualdades también se pueden referir a todas las nuevas tecnologías de la
información y la comunicación (TIC), como el computador personal, la telefonía
móvil, la banda ancha y otros dispositivos. Como tal, la brecha digital se basa
en diferencias previas al acceso a las tecnologías.

De acuerdo con Eurostat, la brecha digital consiste en la "distinción entre

aquellos que tienen acceso a Internet y pueden hacer uso de los nuevos servicios
ofrecidos por la WWW, y aquellos que están excluidos de estos servicios". Este
término también hace referencia a las diferencias que hay entre grupos según
su capacidad para utilizar las TIC de forma eficaz, debido a los distintos niveles
de alfabetización, carencias, y problemas de accesibilidad a la tecnología.
También se utiliza en ocasiones para señalar las diferencias entre aquellos
grupos que tienen acceso a contenidos digitales de calidad y aquellos que no. El
término opuesto que se emplea con más frecuencia es el de inclusión digital y el
de inclusión digital genuina. De aquí se extrae también el concepto de
"infoexclusión" para designar los efectos discriminatorios de la brecha digital.

NTICS
Las tecnologías de la información y la comunicación (TIC) son un conjunto de
servicios, redes, software y dispositivos que tienen como fin la mejora de la
calidad de vida de las personas dentro de un entorno, y que se integran a un
sistema de información interconectado y complementario.

Las nuevas tecnologías de la información se refieren a todos los nuevos medios

que, en los últimos años, han facilitado el flujo de información (internet, el
videodisco digital [DVD], los computadores portátiles y todos los aparatos
tecnológicos que sirven para producir, desarrollar y llevar a cabo la
comunicación). En lo que se refiere a los medios de comunicación, las nuevas
tecnologías han posibilitado la existencia de periódicos digitales, de publicidad
en Internet, de la emisión de música y videos sin necesidad de aparatos de radio
o equipos de sonido, así como de la comunicación instantánea entre personas
de diversos países con un costo económico mucho menor que el que implican
los servicios telefónicos convencionales. Un efecto notable que han tenido las
nuevas tecnologías en el ámbito de los medios de comunicación ha sido el de
hacer que los medios manuscritos de comunicación (es decir, las cartas y

3
mensajes que se enviaban de un lado a otro por medio del servicio postal) hayan
menguado enormemente.

Las Tecnologías de la Información y Comunicaciones ofrecen una oportunidad

única para que los países en vía de desarrollo den un salto en su evolución
económica, política, social y cultural, disminuyendo la brecha que los separa de
los países desarrollados. Estas tecnologías, y en especial Internet, han
trascendido los campos tecnológico y científico, constituyéndose hoy en día en
herramientas que se encuentran al alcance y servicio de toda la comunidad en
los ámbitos económico, educativo y de salud, entre otros.

4
Historia de la Computación
La historia de la computación, debido a las características de las invenciones y
el orden cronológico, se clasifica en cuatro eras: pre mecánica, mecánica,
electrónica mecánica y electrónica.

Era pre mecánica

En el periodo comprendido entre 3000 a. C y 1450 d.C el hombre se enfrentó a
necesidades básicas, dos de las cuales fueron comunicarse y contar objetos;
para satisfacerlas invento la escritura y los sistemas de numeración y se
apoyó en tecnologías que hoy utilizamos: papel, plumas y Abaco.
Un ejemplo de esto son los romanos que usan piedras llamas Calculus para
contar y luego el ábaco usado por los chinos.

Era mecánica
En esta era, comprendida entre 1450 y 1840, los inventores comenzaron a
utilizar técnicas y herramientas (el tratamiento de los metales, la rueda, el poder
de transmisión mecánico) para crear máquinas que realizaran algunas tareas.
Alrededor de 1642, el matemático francés Blaise Pascal, construyo la primera
calculadora automática la pascalina.

En 1792 Charles Babbage, al notar que los matemáticos tenían problemas por
la falta de cálculos precisos y exactos, comenzó a diseñar y a
construir la maquina diferencial.

El diseño de Babbage incluyo los componentes que se encuentran en la

computadora moderna tales como:
• Tenía dispositivos de entrada basados en las tarjetas perforadas.
• Un procesador aritmético para calcular números.
• Una unidad de control para determinar la tarea que debía realizarse

5
 • Un mecanismo de salida.
• Una memoria donde se almacenaban los números hasta procesarse.

Era electromecánica
En 1886, Hollerith, quien trabajo como estadístico en la oficina de censos de
Estados unidos, crea la máquina electromecánica de Hollerith se redujo un largo
proceso de 10 años a dos años para analizar los datos del censo.

De 1937 a 1944, el profesor Howard Aiken, de la Universidad de Harvad y con

financiamiento de IBM, trato de combinar la tecnología de Hollerith y las ideas
de Babbage para construir una máquina conocida como Mark I: media 15.5 cm
de longitud y 2.4 m de altura, contenía 750.000 partes, 800 kilómetros de
cable y 3 millones de conexiones eléctricas. Algunos científicos consideran
la Mark I la precursora de las computadoras electrónicas.

La era electrónica
Esta era inicio en 1940 y aún continúa; se caracteriza por el desarrollo de
tecnologías más rápidas, poderosas y confiables.

En 1943, el matemático británico Alan Turíng ayudo a construir la

maquina Colossus para descifrar códigos alemanes.

El Departamento de Defensa de Estados Unidos contrato a los doctores en

ingeniera John Mauchly y Jonh Presper Eckert en la construcción de una máquina
para el cálculo de tablas de artillera. El ensamblado de esta máquina, Llamada
ENIAC, ( Electronic Numerical Integrator and Computer) termino en 1946 y
requirió 18 000 tubos de vacío. La ENIAC, aunque no se utilizó para la guerra,
pudo sumar, restar, multiplicar y dividir en milisegundos y calcular la trayectoria
completa de una artillera en más o menos de 20 segundos.

6
¿Qué son las aplicaciones?
Una aplicación es un programa informático diseñado como una herramienta para
realizar operaciones o funciones específicas. Generalmente, son diseñadas para
facilitar ciertas tareas complejas y hacer más sencilla la experiencia informática
de las personas.

Las aplicaciones son programas totalmente distintos a los sistemas operativos o

lenguajes de programación, ya que estas cumplen una función puntual y es
pensada para que sea de uso común como por ejemplo manejar finanzas o
contabilidad desde hojas de cálculo.

Los equipos tecnológicos (celular, computador, tableta, relojes inteligentes,

entre otros) tienen la facilidad de traer ya aplicaciones o la posibilidad de
instalarlas. Una de las formas de conseguir una aplicación es por medio de las
tiendas de aplicaciones. Según el dispositivo que tengas encontrarás una tienda
para descargarlas e instalarlas. Por ejemplo, existe la Tienda Microsoft, para
equipos con sistema operativo de esa compañía; la AppStore para equipos con
sistema operativo diseñado por Apple; o PlayStore, si el dispositivo usa el
sistema operativo Android, entre otros.

Además, existen cientos de empresas dedicadas a crear aplicaciones y venderlas

en forma de paquete, también conocido como suites, como por ejemplo Microsoft
Office o Adobe CS.

Con el avance de la tecnología, es común que ahora escuchar el término

aplicaciones móviles. Estas hacen referencia a las aplicaciones diseñadas para
dispositivos como el celular o la tableta. A las aplicaciones de su computador se
les conoce como aplicaciones de escritorio.

Clasificación de las aplicaciones

En el mundo informático, existen distintos tipos de aplicaciones que cumplen con
tareas y funciones distintas. Unas almacenan información ,otras la publican,
otras permiten su edición. Por ello, el siguiente esquema muestra la clasificación
más sencilla con respecto a aplicaciones en dispositivos móviles.

7
Impacto de la informática en la sociedad actual
La informática ha puesto para el hombre una mejora del nivel de vida, puesto
que permiten, la realización de actividades de una forma más simple, sencilla y
pragmática. El impacto de la informática en la sociedad se aplica a la
concientización de la realidad, las nuevas costumbres, el desuso de tecnologías
obsoletas, y el posible remplazo de nuevas formas de interacción social.

En forma cultural se integra en los nuevos conocimientos clásicos ya sea para

un mejor aprendizaje como para el fomento de la actividad cultural a nivel global.

Comunicar la progresiva y continua escasez de recursos necesarios para la vida

(el aire, la contaminación ambiental) con el fin de alertar a las autoridades y
más que nada a las personas en general cuidar lo verde.

Toda la tecnología informática en la aplicación misma del método científico y su

posterior aplicación a todas las ciencias.

Muchas personas necesitan operar sistemas de computación en organizaciones,

estas personas disfrutan de importantes oportunidades en el campo de la
computación, pero todos los miembros de la sociedad son beneficiarios del uso
de las computadoras en las organizaciones.
Las aprovechamos en el trabajo, aunque no seamos especialistas en
computación; las aprovechamos como consumidores de los bienes y los servicios
que nos proporcionan las organizaciones que las utilizan, y el hogar nos sirve
como computadoras personales para el entretenimiento.

8
Sin duda la mayor ventaja que nos ha ofrecido es el poder comunicarnos más
fácilmente y el poder compartir toda la información que queramos con todo el
mundo.

Hoy se usa la informática hasta para abrir las puertas, encender las luces,
controlar los semáforos.

Programación
A menudo nos hacemos la pregunta del por qué los programadores escriben un
programa. Esto es para resolver un problema por lo que el propósito de nuestro
estudio será el enseñar y aprender un método de solución de problemas con
programas de computadora mediante el estudio de la programación.

Lenguajes de programación
Permite expresar un algoritmo comprensible para un ordenador

¿Qué es un algoritmo?
• Fórmula para resolver un problema
• Consta de una serie de pasos
• Se aplica de forma mecánica
• Se aplica en un tiempo finito

Se definirá un algoritmo como un conjunto finito de instrucciones que especifican

la secuencia ordenada de operaciones a realizar para resolver un problema. En
base a lo anterior, si el procesador del algoritmo es una computadora, el algoritmo
debe estar expresado en forma de un programa, el cual se escribe en un lenguaje
de programación. A la actividad de expresar un algoritmo en un lenguaje de
programación determinado se le denomina programar

Distintas tecnologías
Lenguaje de programación: refleja un paradigma

9
Proyecto informático
Ordenadores e informática son términos que van unidos y se complementan. La
informática estudia el tratamiento automático de la información a través de
medios electrónicos. Y estos son los ordenadores.

El ordenador es la máquina electrónica que trata la información mediante el

programa almacenado en su memoria.

El proceso de datos con ordenador mecaniza y automatiza la realización de

tareas rutinarias.

Pasos para la solución de problemas

Cada paso deberá seguirse cuidadosamente. Intentar abreviar el proceso
pasando demasiado aprisa por los primeros pasos aumenta la posibilidad de
errores en la solución.

1. Comprender el problema
Primero debemos analizar cuidadosamente los requerimientos del problema.
Debemos insistir en que los requerimientos del problema sean claramente
especificados en términos de los resultados esperados. Se debe de determinar:
• La fuente y el tipo de datos para la entrada: la interacción de los datos
y su transformación
• El destino y el formato de la salida

2. Diseñar una solución

Los pasos preliminares de una solución pueden escribirse como una
secuenciación sin tomar mucho en cuenta la necesidad de comunicar nuestra
solución a otros. Además, necesitamos organizar la información para que sea
comprensible para nosotros y los demás. Utilizaremos un lenguaje de definición
del programa. Ejemplo:
CompararParDeNumeros

ImprimirEncabezado ProcesarNumeros

PedirParDeNumeros LeerParDeNumeros CompararNumerosEImpri

mirMensaje

3. Probar el diseño
Debemos estar convencidos de que la lógica descrita en el diseño resuelve de
hecho el problema planteado. ¿Sí realizamos la secuenciación obtendremos la
salida que esperamos a partir de la entrada suministrada? Si no, debemos
regresar al paso 2, corregir el diseño y luego probar otra vez.

10
4. Traducir el diseño a un lenguaje de programación
Este paso también se lo llama codificación, o sea traducir un diseño a un lenguaje
de programación. Ahora debemos considerar todas las reglas de organización y
puntuación del lenguaje de programación.

5. Preparar el problema en el lenguaje seleccionado (C++, C#, Python.

etc.)
Capturar en la computadora con la ayuda de un editor el programa traducido.
Este paso requiere la edición (creación o modificación) del texto. Aquí es donde
comenzamos a utilizar el IDE o ambiente integrado de desarrollo del sistema por
ejemplo lenguaje C++, visual studio, Python etc.

6. Compilación del programa

El traductor del lenguaje seleccionado, o también llamado compilador, nos
indicará si hemos empleado correctamente la organización y la puntuación. Si
existen errores hay que regresar al paso 5.

7. Correr el programa y comprobar los resultados

Debemos probar nuestra lógica para determinar si es correcta, probar el
programa con datos que estén al límite, números grandes o pequeños.

Si existen problemas es necesario descubrir qué pudo haber causado los

resultados erróneos podemos usar diversas técnicas para eliminar el error.

8. Depurar si es necesario (debug)

La eliminación de errores se conoce como depuración (debugging). Aquí se
determina si el error es causado por:
• Mal entendido del lenguaje de programación (regresar al paso 4).
• Por el diseño defectuoso (regresar al paso 2)
• O por falta de comprensión del problema (regresar al paso 1).

Diseño de un programa
A menudo nos hacemos la pregunta del por qué los programadores escriben un
programa. Esto es para resolver un problema por lo que el propósito de nuestro
estudio será el enseñar y aprender un método de solución de problemas con
programas de computadora mediante el uso de algoritmos y diagramas que
faciliten la programación estructurada.

Normalmente para la construcción de un programa los ingenieros de sistemas o

de software siguen una secuencia de pasos descritos como metodologías de
desarrollo de software, cada una de las cuales contempla una serie de pasos y
productos hasta la misma prueba y verificación de que el software resuelve el
problema planteado en un inicio, pero en resumen las etapas son las siguientes:

1. Análisis
2. Diseño
3. Implementación y
4. Evaluación

11
A continuación, se muestran algunos ejemplos:

Ciclo de desarrollo de software clásico

Modelo de desarrollo en espiral

12
Metodología scrum

Los pasos que se siguen generalmente a la hora de desarrollar un programa

son los siguientes:
• Análisis de requerimientos: Se define el problema a resolver y todos
los objetivos que se pretenden, pero sin indicar la forma en la que se
resuelve.
• Especificación: Se determina la forma en la que se resolverá el
problema, pero sin entrar aún en su implementación informática. Se
determina asimismo la interfaz con el usuario.
• Diseño del programa: Se divide el problema en módulos, se especifica
lo que hace cada módulo, así como las interfaces de cada uno de ellos.
• Diseño detallado de los módulos: Para cada módulo se diseñan
detalladamente las estructuras de datos y los algoritmos a emplear,
normalmente descritos mediante pseudocódigo.
• Codificación: Se escribe el programa en el lenguaje de programación
elegido.
• Pruebas de módulos: Se prueban los módulos del programa
aisladamente y se corrigen los fallos hasta conseguir un funcionamiento
correcto.
• Integración y Prueba de sistema: Se unen todos los módulos, y se
prueba el funcionamiento del programa completo.

Distribución del esfuerzo de la actividad software (sin tener en cuenta

el mantenimiento):
✓ Análisis y Diseño: 38%
✓ Codificación: 20%
✓ Test e integración: 42%.

13
Técnicas para la formulación de algoritmos
Las dos herramientas utilizadas comúnmente para diseñar algoritmos son:
• Pseuducodigo o algoritmos
• Diagrama de Flujo

Concepto de algoritmo
• Como algoritmo denominamos un conjunto ordenado y finito de
operaciones simples a través del cual podemos hallar la solución a un
problema. La palabra algoritmo proviene del latín tardío alborarismus,
y este a su vez es una abreviación del árabe clásico ḥisābu lḡubār, que
significa ‘cálculo mediante cifras arábigas’.

• En informática o programación, el algoritmo es la secuencia de

instrucciones mediante la cual podemos resolver un problema o
cuestión. De hecho, todas las tareas ejecutadas por la computadora se
basan en algoritmos. Un software o programa informático está
diseñado a base de algoritmos, de modo que podemos introducir una
tarea en él y resolverla.

• En términos generales puede definirse un algoritmo como el método

para resolver un determinado problema. El ejecutor de las
instrucciones que realiza la tarea correspondiente se llama
procesador. Existen algoritmos que describen toda clase de procesos,
por ejemplo: las recetas de cocina, las partituras musicales, etc. Un
procesador realiza un proceso siguiendo o ejecutando el algoritmo
correspondiente

• Un algoritmo debe estar expresado de tal forma que el procesador lo

entienda para poder ejecutarlo. Se dice que el procesador es capaz de
interpretar el algoritmo, si el procesador puede realizar lo siguiente:
1. Entender lo que significa cada paso
2. Llevar a cabo la sentencia correspondiente

Esto significa que para que un algoritmo pueda ser correctamente

ejecutado, cada uno de sus pasos debe estar expresado de tal forma
que el procesador sea capaz de entenderlos y ejecutarlos
adecuadamente

• Se definirá un algoritmo como un conjunto finito de instrucciones que

especifican la secuencia ordenada de operaciones a realizar para
resolver un problema. En base a lo anterior, si el procesador del
algoritmo es una computadora, el algoritmo debe estar expresado en
forma de un programa, el cual se escribe en un lenguaje de
programación. A la actividad de expresar un algoritmo en un lenguaje
de programación determinado se le denomina programar

14
 • Un algoritmo es una secuencia finita de instrucciones, cada una de
ellas con un claro significado, que puede ser realizada con un esfuerzo
finito y en un tiempo finito

• A un algoritmo que suministra una solución buena, pero no

necesariamente óptima, se le denomina algoritmo heurístico

• Un algoritmo es una secuencia finita de instrucciones, cada una de

ellas con un claro significado, que puede ser realizada con un esfuerzo
y un tiempo finitos. Por ejemplo, una asignación como x= y+z es una
instrucción con estas características

Un algoritmo se puede especificar mediante la utilización de un lenguaje de

programación. Sin embargo, generalmente se suelen utilizar técnicas de
descripción de algoritmos más o menos independientes del lenguaje de
programación.

¿Qué es un algoritmo?
• Fórmula para resolver un problema
• Consta de una serie de pasos
• Se aplica de forma mecánica
• Se aplica en un tiempo finito

Uso de la computadora en la resolución de problemas

En general, se escriben algoritmos para resolver problemas que no son tan
fáciles de resolver a primera vista, y de los que necesitamos especificar el
conjunto de acciones que se llevarán a cabo para su resolución. Además,
como lo que interesa es resolver problemas utilizando la computadora, los
algoritmos tendrán como finalidad ser traducidos en programas, por lo que
es conveniente mencionar el proceso general de resolución de problemas,
desde que se dispone de un algoritmo, hasta que la computadora lo ejecuta.

Proceso general de resolución de problemas con la computadora

15
Condiciones con las que debe de cumplir un algoritmo

Estructura de un algoritmo
Aunque no existe una única forma de representar un algoritmo, la estructura
general de un algoritmo debería ser como la mostrada a continuación:

16
Definición del problema
Construir un modelo de solución que resuelva el problema de calcular el área
de un triángulo con la fórmula área igual a base por altura sobre dos.

AREA = BASE * ALTURA

2
Lo básico es resolver la pregunta ¿Qué vamos a hacer? y ¿Cómo lo vamos a
hacer? y para resolverlas es indispensable identificar:

Variable(s) Entrada Proceso u operación Variable(s) salida

BASE AREA = BASE * ALTURA AREA

ALTURA 2

Entrada: Dos números positivos: BASE y ALTURA.

Salida: Un número que representa el AREA donde se reemplace según la
formula los valores de BASE y ALTURA.
Proceso: La solución está basada multiplicar BASE por ALTURA y esa
multiplicación dividirla para 2.

El ejemplo anterior ilustra el proceso de resolución que se debería seguir para

resolver un problema, ya que, partiendo de este análisis inicial, la idea será
entonces ir particularizando cada parte en un refinamiento progresivo, hasta
llegar a un algoritmo más refinado y funcional.

17
 El algoritmo hecho en PSEINT sería:
Algoritmo Area_t
Definir area, base, altura Como real;
Escribir "Ingrese la base: ";
leer base;
Escribir "Ingrese la altura: ";
leer altura;
area<-(base*altura)/2;
Escribir "El area es = ",area;
FinAlgoritmo

Y su respectivo diagrama de flujo es:

Pruebas de algoritmos
Una vez que se ha generado un algoritmo que parece correcto, una de las
partes más importantes dentro de su diseño es la referente a las pruebas. La
parte de la validación de los datos de entrada al algoritmo es también un
aspecto importante.

Una vez que se tiene una solución algorítmica de un problema, no se debería

suponer o creer que funcionará bien siempre. En el diseño del algoritmo se
deben considerar al menos algunos casos de prueba. Es habitual que el
domino de trabajo de un algoritmo sea un conjunto de elementos y entonces
sería bueno saber por ejemplo ¿Cómo se comporta el algoritmo en los límites

18
del conjunto? ¿Dado un mismo dato de entrada obtengo siempre la salida
esperada? entre otras preguntas.

La fase de prueba de los algoritmos es una parte fundamental dentro del

diseño de este, y se recomienda ampliamente adoptarlo como práctica
habitual, ya que es una importante técnica de programación.

La prueba del algoritmo para el cálculo del área del triángulo sería:

Que al ser ejecutado sería como en la siguiente imagen:

19
Terminología en el manejo de algoritmos
• Nivel descripcional: Grado de detalle (mientras más bajo, más
detallado es).
• Secuencia: Orden de las instrucciones en un algoritmo.
• Bifurcación: Tipo de instrucción como pregunta y cuya respuesta
lleva a efectuar una operación.
• Iteración: Paso a la ejecución de una instrucción (ciclo, bucle, loop,
lazo).
• Variable: Elemento de almacenamiento de los datos que se van a
utilizar en el desarrollo del algoritmo. El contenido puede variar
durante el proceso.
• Asignación: Conferir el valor a cierta variable "=",”<-”.
• Programación estructurada: Técnicas que permiten desarrollar
programas que sean fáciles de depurar y poner a punto, legibles. etc.

Identificadores
Los identificadores son nombres creados para designar constantes, variables,
tipos, funciones, procedimientos etc., que forman parte de un programa.

Un identificador consta de uno o más caracteres (letras, dígitos y caracteres

de subrayado); el primero debe ser una letra. El número de caracteres no
debe superar una longitud máxima dependiendo del lenguaje de
programación que se utilice.

En algunos de los lenguajes se diferencia entre mayúsculas y minúsculas

mientras que en otros no. Por ejemplo: “A” equivale a “a” en Pascal; pero
en C equivalen “A” y “a” es decir variables distintas.

Ejemplo: Algoritmo Nombre_del_del_algoritmo.

Fin_algoritmo.

Diagrama de sintaxis de un identificador valido

Letra
Identificador
Letra

Dígito

Subrayado

Variables
Una variable es el elemento de almacenamiento de los datos que se van a
utilizar en el desarrollo del algoritmo. Estos resultados se corresponden con
los datos iniciales como los resultados de operaciones efectuadas durante la
ejecución de un algoritmo. Las variables representan un lugar de
almacenamiento, cuyo contenido podrá variar durante el proceso y

20
 finalmente se obtendrán los resultados con los datos contenidos en las
variables.

Las características de una variable son:

o Nombre: Para referenciar los datos almacenados en una variable se debe
antes asignar un nombre a esta. Para mayor claridad el nombre debe
coincidir con la información almacenada en esta. El nombre empieza con
una letra, no tiene espacios en blanco y no contiene caracteres especiales,
sólo se utiliza el carácter de separación (_).
o Contenido: Es el valor del dato almacenado en ella, al contenido se
accede por medio del nombre de la variable. La información almacenada
en una variable puede ser de tres tipos:
✓ Carácter: Nombres, direcciones o características y símbolos
alfanuméricos
✓ Tipo numérico: Utilizada para calcular resultados
✓ Información de tipo lógico para el control de procesos

Durante la elaboración de un algoritmo la misma variable debe almacenar

datos de un solo tipo.

o Ubicación: Está dada por el nombre de la variable, en el computador el

contenido de una variable ocupa un lugar en la memoria RAM. Para
acceder a este contenido se utiliza el nombre de la variable.

Asignación de datos

Asignaciones
Una variable puede tomar valores de dos formas:
• Por operación de asignación: (a= b+1);
• Por lectura (Leer a).

Está operación de asignación es de carácter destructiva porque el valor

anterior de la asignación se pierde y es reemplazado por el nuevo valor.

La variable puede aparecer a ambos lados de una operación de asignación y

es la forma como se trabaja con los contadores y acumuladores.

Contadores
Son variables cuyo objetivo es ir contando cuántas veces se ha realizado un
proceso, se las utiliza como elemento ordenador que da como resultado el
número de veces que se ha realizado una acción. Es una variable entera.
Ejemplo:
Contador = Contador +1;

Acumuladores
También son variables las cuales tienen como objeto sumarizar un conjunto
de valores en una variable. Son fundamentales en problemas que requieren
totalizar un dato para obtener un resultado.

21
 Ejemplo:
Suma= Suma+2;
Total= salario + beneficios_de_ley;

EJEMPLO DE MODELO DE SOLUCION

Construir un modelo de solución que resuelva el problema de calcular el área
de un triángulo con la fórmula área igual a base por altura sobre dos.

Variable(s) Entrada Proceso u operación Variable(s) salida

BASE AREA = BASE * ALTURA AREA

ALTURA 2

Una variable se define como un identificador que se utiliza para almacenar todos los
datos generados durante la ejecución de un programa.
Existen ciertas reglas en cuanto a variables:
• Claras y con referencia directa al problema
• No espacios en blanco, ni símbolos extraños en ellas
• Se pueden usar abreviaturas, pero solo de carácter general
• No deben ser palabras reservadas del lenguaje

Ejemplos de buenas variables:

Nombre, Edad, SdoDiario, IngMensual, Perimetro, Calif1, etc.

Operadores
Operadores aritméticos
Un operador es un símbolo especial que indica al compilador que debe
efectuar una operación matemática o lógica.
Se reconoce los siguientes operadores aritméticos:

Operador Operación

+ Suma

- Resta

* Multiplicación

/ División

Div División entera

Mod Modulo o residuo

Operadores lógicos
Los resultados se ven en la tabla:

22
 Variables lógicas Cond1 OR Cond1 AND
NOT (Cond2)
Cond1 Cond2 Cond2 Cond2
Falso Falso Falso Falso Verdadero
Falso Verdadero Verdadero Falso Falso
Verdadero Falso Verdadero Falso Verdadero
Verdadero Verdadero Verdadero Verdadero Falso

Operadores relacionales
Se utilizan siempre en operaciones de comparación, su resultado siempre es
un valor lógico (Verdadero o Falso), requiere de dos operados y pueden
trabajar cualquier tipo de dato.

Los operadores relaciónales que reconocen en muchos lenguajes como:

Operador Significado

= Igual que

> Mayor que

< Menor que

>= Mayor o igual que

<= Menor o igual que

<> No es igual o es diferente que

IN Pertenece A

Ejemplo:
5>10 Falso
-15.3<6 Verdadero
'D'>'M' Falso

Expresiones
Pueden estar compuestas por una variable (numérica o de caracter),
constantes, una cadena de caracteres encerrada entre comillas dobles
("cadena") o una expresión matemática.

Jerarquía de operaciones
El problema de no tomar en cuenta la jerarquía de los operadores al plantear
y resolver una operación casi siempre conduce a resultados muchas veces
equivocados como estos:

Ejemplos:
2+ 3* 4 = 20(incorrecto)
Variable = 14 (correcto)

23
 Si calif1=60 y calif2=80 y si entonces en programa se usa
Promedio = calif1 + calif2/2
Daría como resultado promedio = 100

Recordar siempre, que antes de plantear una fórmula en un programa se

deberá evaluar contra el siguiente:

Orden de operaciones:
1. Paréntesis
2. Potencias y raíces
3. Multiplicaciones y divisiones
4. Sumas y restas
5. Dos o más de la misma jerarquía u orden, entonces resolver de
izquierda a derecha

Nota: Si se quiere alterar el orden normal de operaciones, entonces usar

paréntesis.

Ejemplos de algoritmos:
1. Algoritmo para lavar la ropa blanca

2. Algoritmo para decidir si coger el paraguas

3. Algoritmo para clasificar libros

24
Estructura general de un programa
• Un programa se especifica por:
• Entradas
• Proceso
• Salida

Aplicación práctica
• Aplicación de las herramientas y de los pasos para la solución de problemas
computacionales

Programación estructurada
Introducción. Teorema de la programación estructurada
El principio fundamental de la programación estructurada es que en todo
momento el programador pueda mantener el programa “dentro” de la cabeza.

Esto se consigue con:

a) Un diseño descendente del programa,
b) Unas estructuras de control limitadas y
c) Un ámbito limitado de las estructuras de datos del programa

Entre sus ventajas está el que: hace más fácil la escritura y verificación de
programas. Se adapta perfectamente al diseño descendente.

Para realizar un programa estructurado existen tres tipos básicos de estructuras

de control:
1. Secuencial: Ejecuta una sentencia detrás de otra
2. Condicional: Se evalúa una expresión y, dependiendo del resultado, se
decide la siguiente sentencia a ejecutar
3. Iterativa: Repetimos un bloque de sentencias hasta que sea verdadera una
determinada condición

25
 Ejemplo de un algoritmo de simple secuencia

Proceso Saludo
definir nom como caracter;
Escribir 'Bienvenido a PSeint';
Escribir 'Fundamentos de programación';
Escribir "Ingrese un nombre: ";
Leer nom;
Escribir "Hola, ",nom;
FinProceso

Y su salida en la ejecución será:

26
Diagramas de flujo

Definición de diagramas de flujo

• Los diagramas de flujo (Flujogramas u ordinogramas) son gráficos que
permiten la representación simbólica de la lógica de un algoritmo. Con ello
se consigue ordenar un problema en una sucesión de pasos de manera clara
y concisa. Las operaciones a ejecutarse se representan mediante figuras.
Para establecer el orden de ejecución de las instrucciones utilizamos
DIRECCIONES DE FLUJO, es decir conectamos las figuras mediante líneas
que sirven para indicar la secuencia de ejecución de las instrucciones

• Es un gráfico que muestra el orden en el que se van ejecutando las diferentes

instrucciones

• El diagrama de flujo es un gráfico en el que se representa el orden en el que

se van ejecutando las diferentes instrucciones que forman el algoritmo

• Herramienta que constituye el fundamento de programación convencional

siendo muy útil en los programas de pequeño y mediana complejidad

• Un diagrama de flujo es un tipo de notación gráfica algorítmica

• Un diagrama de flujo es una herramienta gráfica de descripción de algoritmos

que se caracteriza por utilizar un conjunto de símbolos gráficos y expresar
de forma clara los flujos de control o el orden lógico en el que se realizan las
acciones de un algoritmo.

Simbología básica
Aunque existe en la literatura una amplia variedad de representaciones para los
símbolos utilizados en los diagramas de flujo, en este texto se adoptaran los
mismos que se presentan en la ilustración:

27
Esta representación gráfica se da cuando varios símbolos (que indican diferentes
procesos en la computadora), se relacionan entre sí mediante líneas que indican
el orden en que se deben ejecutar los procesos.

Los símbolos utilizados han sido normalizados por el instituto norteamericano de

normalización (ANSI).

28
RECOMENDACIONES PARA EL DISEÑO DE DIAGRAMAS DE FLUJO
• Se deben de usar solamente líneas de flujo horizontales y/o verticales
• Se debe evitar el cruce de líneas utilizando los conectores
• No deben quedar líneas de flujo sin conectar
• Se deben usar conectores solo cuando sea necesario
• Se deben trazar los símbolos de manera que se puedan leer de arriba hacia abajo
y de izquierda a derecha
• Todo texto escrito dentro de un símbolo deberá ser escrito claramente, evitando el
uso de muchas palabras

29
Estructuras de programación

Estructura secuencial
La ilustración muestra el diagrama de flujo que representa a la estructura de
control secuencial.

Ejemplo: Calculo de la suma y producto de dos números. Hallar su algoritmo:

Estructuras de selección
En programación tenemos dos estructuras de selección que son:
• Estructura de selección simple
• Estructura de selección múltiple

30
Estructura de selección simple
La gran mayoría de problemas de la vida real tiene una serie de condiciones
que determinan cuál es la solución requerida. Esta solución está
condicionada a diferentes posibilidades dependiendo de una u otra
particularidad. Para poder resolver estos problemas los algoritmos ofrecen
las siguientes instrucciones.

SI (CONDICIÓN) ENTONCES
Instrucciones1
SINO
Instrucciones2

FinSi

En diagrama de flujo y en PSEINT se mira como la siguiente imagen:

La condición es una comparación de dos expresiones que siempre arroja un

resultado, verdadero o falso. Si el resultado de la condición es verdadera se
ejecutan las Instrucciones1, y si es falsa se ejecutan las Instrucciones2.

Ejemplo de algoritmo

Ejemplo: Dados los 3 lados de un triángulo: L1, L2 y L3 verificar si el

triángulo es Isósceles (dos lados iguales), Equilátero (tres lados iguales) o
Escaleno (tres lados distintos).

Proceso triangulo
definir L1, L2, L3 como entero;

escribir"ALGORITMO PARA VERIFICAR SI ES O NO UN TRIANGULO";

repetir
Escribir "Ingrese el lado 1: ";
leer L1;
Escribir "Ingrese el lado 2: ";
leer L2;
Escribir "Ingrese el lado 3: ";
leer L3;
hasta que(L1<>0)Y (L2<>0)Y (L3<>0);

Escribir "TIPO DE TRIANGULO";

Si (L1=L2) Y (L2=L3) Entonces
Escribir "Es triangulo equilatero";

31
 SiNo
Si (L1=L2)O(L2=L3) O(L1=L3) Entonces
Escribir "Es triangulo isósceles";
SiNo
Escribir "Es triangulo ESCALENO";
Fin Si

Fin Si

FinProceso

En diagrama de flujo:

Y su ejecución es:

32
Ejemplo: Diseñar un algoritmo en el que dada la siguiente ecuación:
AX 2 + BX + C = 0
Encontrar:

Considere los casos:

• Si el discriminante es mayor a 0 la respuesta será dos números
reales distintos
• Si el discriminante es igual a 0 la respuesta será dos números reales
iguales
• Si el discriminante es menor a 0 la respuesta será dos números
imaginarios

33
Proceso ecuacion
Definir A,B,C,X1,X2,disc Como Real;

Escribir 'solucion de ecuacion AX^2+BX+C=0';

Escribir 'INGRESE EL VALOR DE A: ';
Leer A;
Escribir 'INGRESE EL VALOR DE B: ';
Leer B;
Escribir 'INGRESE EL VALOR DE C: ';
Leer C;

disc<- (B^2)-(4*A*C);
Escribir 'El Discriminante es: ',disc;
Si disc>0 Entonces
Escribir 'RESPUESTA: DOS NUMEROS REALES DISTINTOS: ';
X1 <- (((B*(-1))+RC(disc)))/(2*A);
X2 <- (((B*(-1))-RC(disc)))/(2*A);
Escribir 'X1: ',X1;
Escribir 'X2: ',X2;
SiNo
Si disc=0 Entonces
Escribir 'RESPUESTA: DOS NUMEROS REALES IGUALES: ';
X1 <- (B*(-1))/(2*A);
X2 <- X1;
Escribir 'X1: ',X1;
Escribir 'X2: ',X2;
SiNo
Escribir 'RESPUESTA: DOS NUMEROS REALES
IMAGINARIOS: ';
FinSi
FinSi

FinProceso

• Deber:
1. Probar si los tres lados L1, L2, L3 pertenecen o no a un triángulo: es
un triángulo si la suma de sus dos lados menores es mayor al lado
mayor. Si es triángulo identificar qué tipo de triángulo
2. ¿Cómo se realiza un cobro de una planilla eléctrica?
3. Cómo se realiza la compra de distintos productos en un almacén
4. Realizar un algoritmo que lea dos números y realice el cálculo de suma,
resta multiplicación y división entre dichos números
5. Diseñar un algoritmo que permita obtener el promedio de 4 notas
6. Diseñar un algoritmo que permita determinar si un año es bisiesto. Un
año es bisiesto si es múltiplo de 4. Los años múltiplos de 100 no son
bisiestos salvo si ellos son también múltiplos de 400 (Ejemplo: 2000
es bisiesto, 1800 no lo es)

34
 7. Diseñar un algoritmo que permita ingresar una letra y decir si es no
vocal
8. Diseñar un algoritmo que permita encontrar el mayor de 3 números
9. Diseñar un algoritmo que permita encontrar el mayor, menor y el
número intermedio entre 3 números considere también los casos en
los que exista más de un número igual

Estructura de selección múltiple(según)

La estructura condicional SEGÚN se utiliza cuando queremos evitarnos las

llamadas escaleras de decisiones. La estructura selección simple nos puede
proporcionar, únicamente, dos resultados, uno para verdadero y otro para falso.
Una estructura Según...Hacer...opción N, por su parte, nos permite elegir entre
muchas opciones.

Esta estructura permite seleccionar una opción, dentro de un conjunto de

alternativas, con base en el valor almacenado en un campo variable denominado
selector o campo controlador de la estructura. Es una estructura selectiva
múltiple donde, de acuerdo con el valor que tenga el selector, se realiza una
determinada tarea una sola vez, es decir, no repite la ejecución de la tarea o
secuencia. De acuerdo al valor que tenga el selector el control de ejecución del
programa pasa a uno de varios puntos de éste, evitando así una serie de
preguntas.

En PSEINT

Conviene tener presente que esta estructura puede contener también una
sección opcional o parte si- no

Reglas:
1. La expresión <selector> se evalúa y se compara con las constantes;
las constantes son listas de uno o más posibles valores de <selector>
que en algunos casos pueden ir separados por comas. Ejecutadas la(s)
<instrucciones>, el control se pasa a la primera instrucción a
continuación del case
2. La cláusula si-no es opcional
3. Si el valor de <selector> no está comprendido en ninguna lista de
constantes y no existe la cláusula si-no, no sucede nada y sigue el flujo
del programa; si existe la cláusula si-no se ejecutan la(s)
<instrucciones> a continuación de la cláusula si-no
4. El selector debe ser un tipo ordinal (entero, caracter, booleano). Los
números reales no pueden ser utilizados ya que no son ordinales

35
 5. Todas las constantes del case deben ser únicas y de un tipo ordinal
compatible con el tipo del selector

Ejemplo de algoritmo

Ejemplo: Ingrese un carácter desde el teclado y probar si es o no una vocal

Proceso vocal
Definir c Como Caracter;
Escribir "ALGORITMO PARA VERIFICAR VOCALES";
Escribir "INGRESE UN CARACTER: ";
Leer c;

Segun c Hacer
'a','A':
Escribir "es una letra a";
'e','E':
Escribir "es una letra e";
'i','I':
Escribir "es una letra i";
'o','O':
Escribir "es una letra O";
'u','U':
Escribir "es una letra U";

De Otro Modo:
Escribir "es otro caracter distinto a una vocal";
Fin Segun

FinProceso

En diagrama de flujo:

Y su ejecución es:

36
Deber:
1. Diseñar un diagrama de flujo que permita ingresar 5 notas valoradas cada
una de ellas sobre una nota de 20 puntos. Obtener su promedio e imprimir
uno de los siguientes mensajes:
20-19 Sobresaliente
18-16 Muy buena
15-13 Buena
12-10 Regular
09-0 Insuficiente
2. Diseñar un diagrama de flujo que permita ingresar un caracter e imprimir un
mensaje que diga si es vocal, consonante, cifra o carácter especial
3. Diseñar un diagrama de flujo que permita ingresar un número que se
encuentre entre 1 y 31 y decir si es un número primo o no primo
4. Diseñar un diagrama de flujo que permita simular el trabajo de una
calculadora en la que se sume, reste, multiplique y divida siempre con un
número fijo cualesquiera
5. Diseñar un diagrama de flujo que permita calcular las funciones
trigonométricas

37
Estructuras de repetición o bucles o ciclos

Un bucle no es más que una serie de instrucciones que se repiten.

Podemos tener 3 tipos de bucles según lo que nos interese comprobar.
Tenemos un bucle que se repite mientras se cumple una condición
determinada, otro que se realiza hasta que se cumple la condición que
marcamos y un tercero para cuantas veces ya definidas hay que repetir.

RESUMEN:
ESTRUCTURAS DE REPETICIÓN:
• Mientras- hacer
• Repetir- hasta
• Desde/Para (for)

A la hora de utilizar un bucle, sea del tipo que sea, debemos ir con cuidado
y pensar cuando debe acabar ya que si no tuviéramos en cuenta esto
podríamos entrar en un bucle sin fin, o sea que iríamos repitiendo las mismas
líneas teniendo que abortar la aplicación, para poderla finalizar.

Por esto es de suma importancia que pensemos, antes de hacer nada, en qué
momento, como, donde y porque debe acabar el bucle.

Estructura mientras-hacer
En nuestro curso esta estructura básica de un bucle Mientras se
representará de la siguiente manera:

Mientras (Condición) Hacer

Instrucción 1
Instrucción 2
Fin del Mientras

Explicaremos línea a línea este bucle:

• Primera línea: En esta línea pondremos la <condición> que se debe
dar para que se ejecute el bucle. En el momento que la condición sea
Falsa se terminará el bucle y se continuará con las siguientes
instrucciones.

• Segunda línea: Línea o líneas donde pondremos las instrucciones a

efectuar en caso de que la condición sea VERDADERA.

• Tercera línea: Fin del bucle Mientras.

De aquí se pasa a la primera línea del bucle para volver a mirar la condición.

Su icono en PSEINT es:

38
Ejemplo: Escriba un algoritmo que permita calcular la operación de
potenciación usando una estructura mientras hacer:

Proceso POTENCIA
Definir b,e,i,p como Entero;
Escribir "ALGORTMO PARA CALCULAR LA POTENCIACIÓN";
Escribir "INGRESE LA BASE: ";
leer b;
Escribir "INGRESE EL EXPONENTE: ";
leer e;
i<-1;
p<-1;
Mientras i<=e Hacer
p<-p*b;
i<-i+1;
Fin Mientras
Escribir "La base: ",b," elevado al exponente: ",e," es: ",p;
FinProceso

En diagrama de flujo se vería como:

39
En su ejecución:

40
Diagrama de flujo del algoritmo de Euclides para encontrar el máximo
común divisor
La solución al problema está determinada por el algoritmo de Euclides.

Deber
1. Verificar si un número ingresado por teclado es o no un número primo
2. Verificar si un número ingresado por teclado es o no un número perfecto
3. Escriba el algoritmo que permita obtener los n primeros números impares
y su suma
4. Algoritmo de la multiplicación
5. Algoritmo de la multiplicación por sumas sucesivas
6. Algoritmo que permita imprimir el nombre de 2 personas
7. Algoritmo que permita imprimir el nombre de N personas
8. Algoritmo para calcular Y como una función de X de acuerdo a la expresión
2 3
Y= 1.5x+2.5x -9.8x para cada paso imprimir X y Y para valores entre 1
y 9.9 con un incremento de 0.1.

Estructura repetir – hasta

Esta es otra estructura de bucle pero tiene un pequeño matiz que la hace
diferente a la ya estudiada anteriormente. Tanto una como la otra se utilizan,
pero cada una de ellas va bien para según qué caso ya que ese matiz puede
hacer su uso muy diferente.

Repetir
Instrucción 1
Instrucción 2
HASTA (condición)

41
Observe que esta estructura primero ejecutaría las instrucciones y
después miraría si se cumple o no la condición, con lo que tenemos que
tener mucho cuidado ya que las instrucciones como mínimo se ejecutarán
una vez (las veces restantes ya dependerán de la condición). La condición se
evalúa después de realizar las instrucciones y no antes como pasaba en el
caso del Mientras.

Su icono en PSEINT es:

Ejemplo: Escriba un algoritmo que permita calcular la operación de

potenciación usando una estructura repetir hasta:

Proceso POTENCIA
Definir b,e,i,p como Entero;
Escribir "ALGORTMO PARA CALCULAR LA POTENCIACIÓN";
Escribir "INGRESE LA BASE: ";
leer b;
Escribir "INGRESE EL EXPONENTE: ";
leer e;
i<-1;
p<-1;
Si e<> 0 entonces
Repetir
p<-p*b;
i<-i+1;
Hasta Que (i>e);

finsi;
Escribir "La base: ",b," elevado al exponente: ",e," es: ",p;
FinProceso

En diagrama de flujo se vería como:

42
En su ejecución:

43
 Características del bucle repetir hasta
Se ejecutan siempre una vez, por lo menos, y la terminación del bucle se
produce cuando el valor de la expresión lógica o condición de salida es
verdadera. Se ejecuta hasta que la expresión es verdadera, es decir, se
ejecuta mientras la expresión sea falsa.
REGLAS DE FUNCIONAMIENTO DEL REPETIR HASTA
1. La condición se evalúa al final del bucle, después de ejecutarse todas las
sentencias
2. Si la condición es falsa, se vuelve a repetir el bucle y se ejecutan todas sus
instrucciones
3. Si la condición es verdadera, se sale del bucle y se ejecuta la siguiente
instrucción después de la estructura

Deber:
1. Diseñar un algoritmo que permita encontrar la sumatoria de los n primeros
números primos
2. Diseñar un algoritmo que permita encontrar la sumatoria de los n primeros
números perfectos. Un número es perfecto cuando es igual a la suma de
todos los números para los cuales es divisible excepto el mismo número. (6
= 1+2+3)
3. Diseñar un algoritmo que permita realizar la operación de multiplicación de
dos números utilizando sumas sucesivas
4. Diseñar un algoritmo que permita realizar la operación de potenciación
utilizando sumas sucesivas
5. Diseñar un algoritmo que permita encontrar el factorial de un número

Estructura desde / para(for)

Son el número total de veces que se desea ejecutar las acciones del bucle
(número de interacciones fijo), este ejecuta las acciones del cuerpo o del bucle
un número específico de veces y de modo automático controla el número de
interacciones o pasos a través del cuerpo del bucle.

La estructura For posee las siguientes partes:

For variable de control, valor inicial, valor final, incremento/decremento

Instrucción 1
Instrucción 2
Fin del For

El funcionamiento del for:

• El for es una estructura muy parecida a un mientras hacer con la diferencia
de que no requiere incrementar o decrementar el contador obligatoriamente
como una más de las instrucciones del bucle ya que se realiza
automáticamente.

• En el caso de que se conozca con anticipación el número de veces a repetir

un bucle, se podrá utilizar el for.

44
• Entre las reglas básicas de su funcionamiento hay que tener en cuenta que
el for requiere de una variable de control que actuará como un contador, su
primera interacción se realiza cuando la variable de control toma el valor
inicial, y la última interacción del bucle es cuando la variable de control toma
el valor final. Además, en cada interacción la variable de control se
decrementa o incrementa de acuerdo con el valor señalado en la declaración.

• Tanto la variable de control, como el valor inicial y el valor final deben ser del
mismo tipo y el for solo admite trabajar con valores ordinales tales como
enteros o caracter, los números reales no son ordinales.

Su icono en PSEINT es:

Ejemplo: Escriba un algoritmo que permita calcular el factorial de un número

usando una estructura for:

Proceso factorial
Escribir "ALGORTMO PARA CALCULAR EL FACTORIAL DE UN NUMERO";
Definir f,j,i,p como Entero;
Escribir "INGRESE EL NUMERO: ";
leer f;

p<-1;
j<-1;
Para i<-j Hasta f Con Paso 1 Hacer
p<-p*i;
Fin Para

Escribir "EL FACTORIAL DE: ",f," es: ",p;

FinProceso

En diagrama de flujo se vería como:

45
En su ejecución:

46
Características del bucle FOR:
Aunque a primera vista pueda resultar más atractivo FOR, en algunos
lenguajes de programación existen limitaciones en su aplicación ya que en el
bucle FOR siempre se incrementa o decrementa (de uno en uno) los valores
de la variable de control de bucle y no de dos en dos o de tres en tres, como
en otros lenguajes.

El número de iteraciones de un bucle FOR siempre es fijo y se conoce de

antemano:

Valor final - Valor inicial +1.

CUÁNDO UTILIZAR MIENTRAS HACER/REPETIR HASTA/FOR?

• Utilizar la sentencia o estructura FOR cuando se conozca el número de
iteraciones, y siempre que la variable de control de bucle sea de tipo ordinal
• Utilizar la estructura REPETIR HASTA cuando el bucle se realice por lo menos
una vez
• En todos los demás casos utilizar la sentencia MIENTRAS HACER.

Deber
1. Construir un algoritmo que despliegue los números del 20 al 30
2. Desplegar los enteros entre 30 y 50 acompañados de su potencia
cuadrada y raíz cúbica respectiva
3. Desplegar una tabla de multiplicar que el usuario indique

Bucles anidados
Los bucles, al igual que las sentencias condicionales, también se pueden
anidar. Esto es especialmente útil para el manejo de matrices, como veremos
en los temas posteriores

Deber:
1. Diseñar un diagrama de flujo que permita generar la sumatoria de la serie:
a ( a −1)! − a ( a−2)! + a ( a−3)! − .......
2. Diseñar un diagrama de flujo que permita generar la sumatoria de la serie:
2 4 4 6 6
+2+ − − + + ......
3 3 5 5 7
3. Diseñar un diagrama de flujo que permita generar las tablas de
multiplicación
4. Imprimir todos los caracteres en minúsculas que existen entre un
intervalo de mayúsculas ejemplo: A b c d e f g H

Manejo de cadenas
En PSEINT se permite manejar las cadenas que no son sino una secuencia de
caracteres ascii en el que se visualizan las secciones de:
• Letras mayúsculas
• Letras minúsculas
• Dígitos y
• Caracteres especiales

47
Ejemplo: Diseñar un algoritmo que permita contar en una frase cuantas letras
mayúsculas, minúsculas, dígitos y caracteres especiales existen

Proceso contar_caracteres
Definir cad, cad1 Como Cadenas;
Definir i,n, ma, mi,di,ca como entero;
Dimension cad1[25];
Escribir "Ingrese una cadena";
Leer cad;
n<-Longitud(cad);
Escribir "La longitud de la cadena es: ",n;
ma<-0;
mi<-0;
di<-0;
ca<-0;
Para i<-1 Hasta n Con Paso 1 Hacer
cad1[i]<- SubCadena(cad,i,i);
Si cad1[i]>='A' y cad1[i]<='Z' Entonces
ma<-ma+1;
siNo
Si cad1[i]>='a' y cad1[i]<='z' Entonces
mi<-mi+1;
SiNo
Si cad1[i]>='0' y cad1[i]<='9' Entonces
di<-di+1;
SiNo
ca<-ca+1

fin si

fin si
Fin Si

Fin Para
escribir"Mayúsculas= ",ma;
escribir"Minúsculas= ",mi;
escribir"Dígitos= ",di;
escribir"Carácteres especiales= ",ca;
FinProceso

En diagrama de flujo:

48
Y su ejecución:

49
Aplicación práctica
• Uso del MIENTRAS HACER/ REPETIR HASTA / For
Ejemplo:
• Diseñar un diagrama de flujo que permita calcular cuántas palabras
existen en una frase
• Probar si una palabra ingresada por el usuario es o no palíndromo.
Una palabra es palíndroma cuando se lee igual de derecha a izquierda
que de izquierda a derecha ejemplo Ana, Radar, Oso

50
Ejemplo: Diseñar un diagrama de flujo para cambiar a mayúsculas todas las
letras de una frase

INICIO

Escribir(‘ingrese la frase’)

Leer(cad)

cad=concatenar(cad, ‘ ‘)

n= longitud(cad)

For i,o,(n-1),+1

Cad[i]= mayuscula(cad[i])

Escribir(cad)

FIN

51
Ejemplo: Diseñar un diagrama de flujo para contar las palabras en una frase

INICIO

Escribir(‘ingrese la frase’)

Leer(cad)

Cad= concatenar(cad, ‘ ‘)

n= longitud(cad)

cont= 0

For i,o,(n-1),+1

V F
cad[i]=’ ‘

Cont=cont+1

Escribir(cont,’palabras’)

FIN

52
Deber:
1. Diseñar un diagrama de flujo que permita calcular cuántas vocales existen
en una frase
2. Contar la incidencia de las letras, en una palabra. Es decir, cuántas veces
se repiten
3. En una frase contar palabras de longitud par y las de longitud impar que
existan en ella
4. Reemplazar las palabras de longitud par en una frase por asteriscos
5. Visualizar las palabras de longitud impar en una frase al revés
6. Dados tres números imprimir o escribir cuál es el mayor
7. Diseñe un algoritmo que permita generar los 5 primeros números pares
utilizando la estructura Mientras-Hacer
8. Diseñe un algoritmo que permita generar los N primeros números pares
utilizando la estructura Mientras-Hacer.
9. Imprimir todos los números del 1 al 100 que sean múltiplos de 3 utilizando
la estructura MIENTRAS-HACER
10.Imprimir todos los números del 1 al 100 que sean múltiplos de 3 utilizando
la estructura REPETIR – HASTA
11.Imprimir todos los números del 1 al 100 que sean múltiplos de 3 utilizando
la estructura FOR (Decrementos)

53
Instrucciones básicas en Python
Python es un lenguaje de programación de propósito general, que es otra forma
de decir que puede ser usado para casi todo. Lo más importante es que se trata
de un lenguaje interpretado, lo que significa que el código escrito no se traduce
realmente a un formato legible por el ordenador en tiempo de ejecución.

Este tipo de lenguaje también se conoce como «lenguaje de scripting» porque

inicialmente fue pensado para ser usado en proyectos sencillos.

El concepto de «lenguaje de scripting» ha cambiado considerablemente desde

su creación, porque ahora se utiliza Python para programar grandes aplicaciones
de estilo comercial, en lugar de sólo las simples aplicaciones comunes.

Una encuesta realizada en 2019 entre los usuarios de Python indicó que los usos
más populares eran para el desarrollo web y el análisis de datos. Sólo alrededor
del 6% de los encuestados lo utilizaron para el desarrollo de juegos o el
desarrollo de aplicaciones.

Esta dependencia de Python ha crecido aún más a medida que Internet se ha

hecho más popular. Una gran mayoría de las aplicaciones y plataformas web
dependen de su lenguaje, incluido el motor de búsqueda de Google, YouTube, y
el sistema de transacciones orientado a la web de la Bolsa de Nueva York (NYSE).

¿Qué es Python?
En términos técnicos, Python es un lenguaje de programación de alto nivel,
orientado a objetos, con una semántica dinámica integrada, principalmente para
el desarrollo web y de aplicaciones informáticas.

Es muy atractivo en el campo del Desarrollo Rápido de Aplicaciones (RAD)

porque ofrece tipificación dinámica.

Python es relativamente simple, por lo que es fácil de aprender, ya que requiere

una sintaxis única que se centra en la legibilidad. Los desarrolladores pueden
leer y traducir el código Python mucho más fácilmente que otros lenguajes.

Por tanto, esto reduce el costo de mantenimiento y de desarrollo del programa

porque permite que los equipos trabajen en colaboración sin barreras
significativas de lenguaje y experimentación.

Además, soporta el uso de módulos y paquetes, lo que significa que los

programas pueden ser diseñados en un estilo modular y el código puede ser
reutilizado en varios proyectos. Una vez se ha desarrollado un módulo o paquete,
se puede escalar para su uso en otros proyectos, y es fácil de importar o
exportar.

Por otro lado, uno de los beneficios más importantes de Python es que tanto
la librería estándar como el intérprete están disponibles gratuitamente, tanto
en forma binaria como en forma de fuente.

54
Tampoco hay exclusividad, ya que Python y todas las herramientas necesarias
están disponibles en todas las plataformas principales. Por lo tanto, es una
opción multiplataforma, bastante tentadora para los desarrolladores que no
quieren preocuparse por pagar altos costos de desarrollo.

En definitiva, es un lenguaje de programación relativamente fácil de aprender,

y las herramientas necesarias están disponibles para todos de forma gratuita.
Esto hace que sea accesible para casi todo el mundo.

Que se corresponde al siguiente código:

import math
print ("Hola Mundo")
mensaje ="Prueba"
pi=3.14
a=10
b=5
#c=a+b
print("La suma es",a+b)
tipo=type(mensaje)
print("Mensaje es de tipo: ",tipo)
#x=float(math.sqrt(a));
x=(math.sqrt(a))
print("La raiz de a es: ",x)
print("ingrese un valor para a: ")
a=int(input())
print("el valor es : ",a)
def sumar(x1,x2):
total=x1+x2
return(total)

55
respuesta=sumar(a,b)
print("funcion sumar debe ser 15: ",respuesta)

Características de Python
Ahora que sabemos los inicios de Python entremos en materia:
1. Lenguaje de programación de alto nivel: Esto se refiere a que es un
lenguaje que expresa sus algoritmos teniendo en cuenta las capacidades
cognitivas de los seres humanos. Está hecho para que las personas lo
entendamos sin dificultad.
2. Es un lenguaje interpretado: Se ejecuta en tiempo real en cualquier
plataforma que tenga un intérprete, una gran ventaja cuando hacemos
pequeñas modificaciones en una aplicación y no tenemos que recompilarla
toda cada vez que realicemos un cambio, lo cual permite ser más eficaces
a la hora de programar.
3. Es multiparadigma: Se puede crear más de un programa con varios
estilos de desarrollo diferentes. Python permite usar programación
modular, estructurada, orientada a objetos dependiendo de lo que sea
más eficiente para crear nuestra necesidad.
4. Es libre: Se tiene a disposición el código fuente disponible para conocerlo,
analizarlo y estudiarlo a fondo. También, Python tiene una gran
comunidad en su portal para cualquier tipo de ayuda. Adicional cuenta
con una documentación realmente buena disponible gratuitamente.
https://www.python.org/community/

Ventajas de Python
1. Python es fácil y sencillo de aprender. Si usted entiende Python, podrá
entender más fácilmente otros lenguajes de programación. Esto quiere
decir que es una excelente opción si apenas incursiona en el mundo de
los desarrolladores.
2. Python hace referencia a su limpieza y legibilidad. Se puede visualizar en
los siguientes 3 ejemplos que muestran por pantalla Hola Mundo. El
primer ejemplo está en C++, el segundo en Java y el tercero en Python.

Ejemplo en C++
<include conio.h>
<include stdio.h>
int main(){
printf("Hola Mundo");
getch();
}
Ejemplo en Java
public class HolaMundo {

public static void main(String[] args) {

System.out.println("Hola Mundo");
}

56
Ejemplo Hola Mundo en Python
print("Hola mundo")

3. Está desarrollado bajo una licencia de código abierto, por lo que es de

libre uso y distribución, incluso para uso comercial.
4. Este lenguaje de programación permite una diversidad de desarrollos de
una manera fácil, ágil y rápida.
5. Su característica multiplataforma permite que este pueda ser usado en
diferentes sistemas operativos.
6. Gracias a su popularidad, cuenta con una amplia comunidad que organiza
eventos, conferencias, reuniones y colabora en materia de códigos e
información.

Python es ideal para cualquiera persona que desee adentrarse en el desarrollo

sin tener conocimientos previos. Además, está en el top 5 de los lenguajes para
programar más usados y cada vez aumenta más su uso y su demanda laboral.

Tipos de Datos

Una variable contiene datos de un tipo específico. Cuando declaramos una

variable para almacenar los datos en una aplicación, debemos elegir un tipo de
dato adecuado para los datos.

57
Tipos de datos básicos
Los tipos de datos básicos en Python son los siguientes:
• Número Entero (int): Este tipo de dato se corresponde con números
enteros, es decir, sin parte decimal.
• Número Decimal (float): Este tipo de dato se corresponde con números
reales con parte decimal. Cabe destacar que el separador decimal en
Python es el punto (.) y no la coma (,).
• Caracter (chr): Este tipo de dato se corresponde con un símbolo
tipográfico, es decir, una letra, número, coma, espacio, signo de
puntuación, etc.
• Cadena de Texto (str): Este tipo de datos se corresponde con una
cadena de caracteres.
• Booleano (bool): Este tipo de dato reconoce solamente dos valores:
Verdadero (True) y Falso (False)

Funciones de conversión de tipos de datos en Python

Existen algunas funciones predeterminadas en Python que permiten transformar
un tipo de dato en otro:

entero = 80
decimal = 6.14159
caracter = 'Q'
cadena = 'Análisis Numérico'
booleano = True

Tanto los valores Decimales como los Booleanos pueden ser convertidos en
Enteros con la función int():

print(int(decimal))
print(int(True))
print(int(False))

6
1
0

Algo similar ocurre al intentar convertir Enteros o Booleanos en Decimales con

la función float():

print(float(entero))
print(float(True))
print(float(False))

80.0
1.0
0.0

58
Es posible también, a partir de la tabla de caracteres ASCII, obtener el caracter
correspondiente a un entero con chr() o viceversa con ord():

print(chr(entero))
print(ord(caracter))

P
81

Mucho más interesante que esto último resulta la conversión de cualquiera de

los tipos de datos presentados en cadenas de texto, algo de vital importancia a
la hora de presentar resultados combinándolos con texto.
print(str(entero))
print(str(decimal))
print(str(booleano))

80
6.14159
True

Operadores en Python
La siguiente tabla muestra los operadores más comunes que podemos utilizar
en Python:

59
60
61
62
Declaración y asignación de variables
Variables: Es un nombre que se refiere a un objeto que reside en la memoria.
El objeto puede ser de alguno de los tipos vistos (número o cadena de texto), o
alguno de los otros tipos existentes en Python.

Cada variable debe tener un nombre único llamado identificador. Eso es muy de
ayuda pensar las variables como contenedores que contienen data el cual puede
ser cambiado después a través de técnicas de programación.

Alcance de las variables: Las variables en Python son locales por defecto. Esto
quiere decir que las variables definidas y utilizadas en el bloque de código de
una función, sólo tienen existencia dentro de la misma, y no interfieren con otras
variables del resto del código.

A su vez, las variables existentes fuera de una función, no son visibles dentro
de la misma.

En caso de que sea conveniente o necesario, una variable local puede convertirse
en una variable global declarándola explícitamente como tal con la sentencia
global.

Ejemplos de variables

A continuación, se presentan algunos ejemplos del uso de variables:

Ejemplo de asignar valor a variable

A continuación, se creará un par de variables a modo de ejemplo. Una de tipo

cadenas de caracteres y una de tipo entero:

c = "Hola Mundo" # cadenas de caracteres

print(type(c)) # comprobar tipo de dato
e = 23 # número entero
print(type(e)) # comprobar tipo de dato

y su ejecución:

También nos ha servido el pequeño ejemplo para presentar los comentarios en

linea en Python: cadenas de caracteres que comienzan con el carácter # y que
Python ignora totalmente

63
A continuación, se cambiará el valor para una variable de tipo cadenas de
caracteres a modo de ejemplo:

c = "Hola ESPOCH" # cadenas de caracteres

print(c)

Y su ejecución:

Ejemplo de asignar múltiples valores a múltiples variables

A continuación, se creará múltiples variables (entero, coma flotante, cadenas de

caracteres) asignando múltiples valores:

a, b, c = 5, 3.2, "Hola"
print (a)
print (b)
print (c)

y su ejecución:

Si usted quiere asignar el mismo valor a múltiples variables al mismo tiempo,

usted puede hacer lo siguiente:

x = y = z = 10
print (x)
print (y)
print (z)

y su ejecución:

64
Instrucciones básicas

import math
print ("Hola Mundo")
mensaje ="Prueba"
pi=3.14
a=10
b=5
#c=a+b
print("La suma es",a+b)
tipo=type(mensaje)
print("Mensaje es de tipo: ",tipo)
#x=float(math.sqrt(a));
x=(math.sqrt(a))
print("La raiz de a es: ",x)
print("ingrese un valor para a: ")
a=int(input())
print("el valor es : ",a)
def sumar(x1,x2):
total=x1+x2
return(total)
respuesta=sumar(a,b)
print("funcion sumar debe ser 15: ",respuesta)

La instrucción import es la forma más común de invocar la importación de

funciones declaradas print es el comando para imprimir en la consola sea un
mensaje que se acostumbra a colocar entre comillas “” o expresiones o las
mismas variables para que sus valores fueran visualizados type es la palabra
reservada para obtener el tipo de la clase de la variable o del objeto
x=(math.sqrt(a)) en esta línea estamos utilizando la función matemática para
obtener la raíz cuadrada de la variable a y se asigna a x su respuesta
a=int(input()) en esta instrucción estamos leyendo desde la consola un valor
ingresado por el usuario pero si es un valor que se escribe o lee en consola en
del tipo cadena por eso usamos la función int para transformar dicha cadena a
un número entero que será asignado a la variable a

def sumar(x1,x2):
total=x1+x2
return(total)

Es la definición de la función sumar que tiene por argumentos x1 y x2 serán

sumados y su resultado será almacenado en la variable local total que antes de
finalizar la función deberá ser retornado al lugar donde se lo llame

65
Estructuras de control

Las estructuras de control de python son similares a otros lenguajes de

programación. La diferencia más notable radica en que la instrucción condicional
if y los ciclos while están controlados por una expresión lógica (tipo Boolean).

Esta restricción hace que las instrucciones sean más seguras al evitar posibles
fuentes de error, o al menos, facilitan la legibilidad del código.

Estructuras condicionales
if, if-else

La sentencia condicional if se usa para tomar decisiones, este evalúa

básicamente una operación lógica, es decir una expresión que dé como resultado
True o False, y ejecuta la pieza de código siguiente siempre y cuando el resultado
sea verdadero.

Si sólo se actúa cuando la condición es cierta:

print("Ingresa un número: ")

numero = int(input())
if numero % 2 == 0:
print("El número es par");

y su ejecución cuando ingresamos un número par es:

Si se actúa cuando la condición es falsa se emplea la palabra reservada else:

print("Ingresa un número: ")

66
numero = int(input())
if numero % 2 == 0:
print("El número es par")
else:
print("El número es impar")

Al ejecutar este programa e ingresando un valor impar tenemos la siguiente

ejecución:

Puede escribirse una instrucción condicional dentro de otra instrucción

condicional, lógicamente:

Ejemplo de un condicional anidado en Python

En este ejemplo, vamos a anidar un if al interior de otro y luego un if al interior

de un else. De ese modo, cubrimos varios casos:

password = input("Ingrese la contraseña: ")

if (len(password) >= 8):

print('Tu contraseña es suficientemente larga.')

if(password == 'miClaveSegura'):
print("Además es la contraseña correcta.")
else:
print("Pero es incorrecta.")
else:
print('Tu contraseña es muy corta e insegura.')

67
 if (password != 'miClaveSegura'):
print("Además, es incorrecta (por supuesto).")

Al ejecutar el programa:

En esencia, en el ejemplo anterior, además estamos verificando la longitud del

valor ingresado, de modo que indicamos si es un poco más segura o no. Los
condicionales anidados, nos permiten reaccionar a cada caso, pues mostramos
un mensaje acorde a cada condición que se cumple.

Ahora veamos cómo simplificar un poco este programa en Python con un elif
Ejemplo de uso de elif en Python para simplificas un condicional anidado en
Python
Ahora veamos cómo simplificar un poco este programa en Python con un elif:
password = input("Ingrese la contraseña: ")

if (len(password) >= 8):

print('Tu contraseña es suficientemente larga.')

if(password == 'miClaveSegura'):
print("Además es la contraseña correcta.")
else:
print("Pero es incorrecta.")
elif (password != 'miClaveSegura'):
print('Tu contraseña es muy corta e insegura.')
print("Además, es incorrecta (por supuesto).")

Como se observa, al usar elif, hemos puesto el else y el if de su interior en una

sola línea y funciona de manera equivalente.

Notar que, en este caso, tiene completo sentido usar el elif, pues la contraseña
siempre será incorrecta si su longitud es inferior a 8 caracteres.

Ejemplo:

68
a=5
b=6
c=4
if (a>b and a>c):
print ("a es mayor que b y que c")
elif (a>b and a<c):
print ("a es mayor que b pero no es mayor que c")
elif (a<b and a>c):
print ("a es mayor que c pero no es mayor que b")
else:
print ("a no es mayor que b ni mayor que c")

Y su ejecución:

Estructuras repetitivas
Los ciclos, también conocidos como bucles o estructuras de control repetitivas,
son de total importancia para el proceso de creación de un programa. Un ciclo
en Python o bucle en Python permite repetir una o varias instrucciones cuantas
veces lo necesitemos, por ejemplo, si quisiéramos escribir los números del uno
al cien no tendría sentido escribir cien líneas de código mostrando un número en
cada una, para eso y para varias cosas más, es útil un ciclo. Un ciclo nos ayuda
a llevar a cabo una tarea repetitiva en una cantidad de líneas muy pequeña y de
forma prácticamente automática.

Existen diferentes tipos de ciclos o bucles en Python, cada uno tiene una utilidad
para casos específicos y depende de nuestra habilidad y conocimientos poder
determinar en qué momento es bueno usar alguno de ellos. Tenemos entonces
a nuestra disposición los siguientes tipos de ciclos en Python:

• Ciclo while en Python

• Ciclo for en Python

Ciclo while en Python

Los bucles while son similares a los bucles for el cual se usa para repetir un
bloque de instrucciones dentro de nuestro programa, la gran diferencia con el
FOR es la forma en que PYTHON decide cuántas veces repetir el bucle. Los bucles
while continúan hasta que se satisface algún criterio.

La estructura del ciclo while debe respetar la siguiente sintaxis, la cual siempre
en Python debe respetar la identación, dado que una vez la identación vuelve a
la misma linea del comando while, esto le indica el cierre del ciclo While a Python.

69
A continuación, se presenta un ejemplo del uso del bucle while el cual contiene
un acumulador número que irá incrementando hasta que la suma acumulada
sea mayor que 100:
numero = 0
suma=0
while numero <= 100:
suma = numero + suma
numero = numero + 1
print("La suma es " + str(suma))

Al ejecutarse tenemos:

Ejemplo para calcular la función de exponenciación:

print("Ingrese la base")
a=int(input())
print("Ingrese el exponente")
b=int(input())
i=1
p=1
while i<=b:
p=p*a
i+=1
print("La base: ",a," elevado a ",b," es = ",p)

La ejecución es:

70
Ciclo for en Python
La estructura del bucle for es simple. La primera línea identifica el bucle y define
un índice, que es un número que cambia en cada paso a través del bucle.
Después de la línea de identificación viene el grupo de comandos que se quiere
ejecutar de forma IDENTADA.

Función range()
La función de python range() es muy útil principalmente cuando usamos bucles
for en nuestros códigos ya que dicha función devuelve una secuencia de
números, comenzando desde 0 de forma predeterminada, se incrementa en 1
(de forma predeterminada) y se detiene antes de un número especificado, es
decir el último número no es inclusivo.

De manera de ejemplo, usamos el siguiente ciclo for en python para crear una
secuencia de números del 0 al 5 e imprima cada elemento en la secuencia:

x = range(5)
for n in x:
print(n)

y al ejecutarse:

La sintaxis de la función range es:

range(start, stop, step)

start es el número donde comienza la secuencia, stop es hasta donde la

secuencia llega sin incluir dicho número y step indica cada cuando se va
incrementando la secuencia.

Veamos el siguiente ejemplo con ciclo for en python mostrando una secuencia
de números de 10 hasta 50 con incrementos de 10 en 10.

71
x = range(10, 50, 10)
for n in x:
print(n)

Con su ejecución:

Ciclo for en Python para recorrer cadenas

Los bucles for dentro de Python también son muy usados para recorrer cada uno
de los índices dentro de una cadena de caracteres o str.

frase = "Curso"
for caracter in frase:
print(caracter)

Y su ejecución:

El código anterior, se usa un índice llamado caracter dentro del loop FOR con
Python, para recorrer e imprimir cada una de las letras que componen el str
frase.

Introducción a las funciones

Como decía en la introducción, las funciones en Python constituyen unidades
lógicas de un programa y tienen un doble objetivo:
• Dividir y organizar el código en partes más sencillas.
• Encapsular el código que se repite a lo largo de un programa para ser
reutilizado.

Python ya define de serie un conjunto de funciones que podemos utilizar

directamente en nuestras aplicaciones. Por ejemplo, la función len(), que obtiene
el número de elementos de un objeto contenedor como una lista, una tupla, un
diccionario o un conjunto. También hemos visto la función print(), que muestra
por consola un texto.

Sin embargo, como programador, se pueden definir funciones propias para

estructurar el código de manera que sea más legible y para reutilizar aquellas
partes que se repiten a lo largo de una aplicación. Esto es una tarea fundamental
a medida que va creciendo el número de líneas de un programa.

72
La idea esta descrita en la siguiente imagen:

En principio, un programa es una secuencia ordenada de instrucciones que se

ejecutan una a continuación de la otra. Sin embargo, cuando se utilizan
funciones, se pueden agrupar parte de esas instrucciones como una unidad más
pequeña que ejecuta dichas instrucciones y suele devolver un resultado.

La siguiente imagen muestra el esquema de una función en Python:

Para definir una función en Python se utiliza la palabra reservada def. A

continuación, viene el nombre o identificador de la función que es el que se
utiliza para invocarla. Después del nombre hay que incluir los paréntesis y una

73
lista opcional de parámetros. Por último, la cabecera o definición de la función
termina con dos puntos.

Tras los dos puntos se incluye el cuerpo de la función (con un sangrado mayor,
generalmente cuatro espacios) que no es más que el conjunto de instrucciones
que se encapsulan en dicha función y que le dan significado.

En último lugar y de manera opcional, se añade la instrucción con la palabra

reservada return para devolver un resultado.

Cómo usar o llamar a una función

Para usar o invocar a una función, simplemente hay que escribir su nombre como
si de una instrucción más se tratara. Eso sí, pasando los argumentos necesarios
según los parámetros que defina la función.

Veámoslo con un ejemplo. Vamos a crear una función que muestra por pantalla
el resultado de multiplicar un número por cinco:

def multiplica_por_5(numero):
print(f'{numero} * 5 = {numero * 5}')

print('Comienzo del programa')

multiplica_por_5(7)
print('Siguiente')
multiplica_por_5(113)
print('Fin')

La función multiplica_por_5() define un parámetro llamado numero que es el

que se utiliza para multiplicar por 5. El resultado del programa anterior sería el
siguiente:

Comienzo del programa

7 * 5 = 35
Siguiente
113 * 5 = 565
Fin

Nota:
Cadenas "f": A partir de la versión 3.6 de Python, se añadió (PEP 498), una
nueva notación para cadenas llamada cadenas "f", que hace más sencillo
introducir variables y expresiones en las cadenas. Una cadena "f" contiene
variables y expresiones entre llaves "{}" que se sustituyen directamente por su
valor. Las cadenas "f" se reconocen porque comienzan por una letra f antes de
las comillas de apertura.

74
Como se puede observar, el programa comienza su ejecución en la línea 4 y va
ejecutando las instrucciones una a una de manera ordenada. Cuando se
encuentra el nombre de la función multiplica_por_5(), el flujo de ejecución pasa
a la primera instrucción de la función. Cuando se llega a la última instrucción de
la función, el flujo del programa sigue por la instrucción que hay a continuación
de la llamada de la función.

Diseño modular de programas: Descomposición modular

La programación modular es un paradigma o estilo de programación que consiste
en dividir un programa muy grande en programas de menor tamaño o
subprogramas con la finalidad de hacerlo más legible y manejable ya que,
durante el desarrollo de un programa, el mismo puede tornarse muy largo. Para
esto se implementa el uso de clases, funciones y módulos.

Un módulo es un objeto que sirve como unidad para organizar el código de un

proyecto desarrollado en Python. Los módulos tienen en su contenido los objetos
(funciones, clases, definiciones, etc) que se definan en él. Para utilizar el
contenido de un módulo es necesario importarlo.

Importar módulos en Python

Para que el contenido de un módulo esté disponible en otro, es necesario

importarlo. La forma más utilizada para importar en Python es con la palabra
reservada import.

Para este ejemplo utilizaremos la definición de la siguiente función:

def sumar(a,b):
c=a+b
return(c)

La que será guardada en un archivo con el nombre de modularsuma.py y podrá

ser llamada luego en otro programa como:

import modularsuma

Es importante que el archivo en este caso modularsuma este en el mismo

directorio de trabajo.

Un Paquete es una estructura de organización de Python que contiene módulos

y otros paquetes.

Ahora creamos un nuevo archivo en el que conste este código:

import modularsuma
w=5
x=3
y=modularsuma.sumar(w,x)
print("La suma es:",y)

75
y lo compilamos o usamos F5:

Hemos importado el archivo modularsuma en el que consta la función sumar que

permite tomar el valor de a y b y sumarlos en c que será el valor a devolver
Cuando importamos modularsuma estamos autorizando al segundo archivo a
usar las funciones declaradas en el primer archivo y eso se observa en la línea
y=modularsuma.sumar(w,x) en el que llamamos a la función sumar que
pertenece a modularsuma y enviamos los valores de w y x que serán recibidos
como a y b. El valor devuelto por la función es 8 y se corresponde a la suma de
5+3 respectivamente

La ejecución es:

La suma es: 8

from

‘from’ es una palabra reservada que es utilizada en conjunto con ‘import’ para
importar partes específicas de un paquete o módulo.

from modularsuma import sumar

w=5
x=3
y=sumar(w,x)
print("La suma es:",y)

y su ejecución sería:

La suma es: 8

Ejemplo 1
Desarrollar un programa que permita ingresar los lados de un triángulo e
implemente los siguientes métodos: imprimir el lado mayor y otro método que
muestre si es equilátero o no.

def ladomayor(uno, dos, tres):

if uno>dos and uno>tres:
print("Lado mayor Lado 1")
else:
if dos>uno and dos>tres:
print("Lado mayor Lado 2")
else:
print("Lado mayor Lado 3")

def equilatero(a,b,c):
if(a==b and b==c):

76
 print("Es triángulo equilátero")
else:
print("No es triángulo equilátero")

lado1=int(input("Ingrese el lado 1: "))

lado2=int(input("Ingrese el lado 2: "))
lado3=int(input("Ingrese el lado 3: "))
ladomayor(lado1,lado2,lado3)
equilatero(lado1,lado2,lado3)

Al ejecutar el código muestra el siguiente resultado

Ingrese el lado 1: 6
Ingrese el lado 2: 10
Ingrese el lado 3: 2
Lado mayor Lado 2
No es triángulo equilátero

En este programa hemos usado la declaración de 2 funciones la función

ladomayor y equilatero.

En el programa principal se ha solicitado al usuario ingresar los 3 lados del

triángulo como valores de tipo entero, hemos llamado a la función ladomayor en
la que hemos enviado como parámetros los valores de las variables que fueron
leídas como son lado1, lado2 y lado3.

Estos valores fueron enviados como parámetros uno, dos y tres en la respectiva
declaración de la función y mediante una estructura de selección hallamos el
lado mayor.

Y para finalizar hemos llamado a la función equilatero en la que también hemos

enviado los valores de las variables lado1, lado2 y lado3 y que han sido recibidos
como los parámetros a,b y c respectivamente en la función equilatero para
imprimir la respuesta si son o no 3 lados iguales.

Ejemplo 2: Implementar un programa que permita realizar las operaciones

básicas. Se deben ingresar los dos valores enteros, calcular su suma, resta,
multiplicación y división, cada una en una función, e imprimir dichos resultados.

def sumar(num1,num2):
c=num1+num2
return(c)
def restar(num1,num2):
c=num1-num2
return(c)

77
def multiplicar(num1,num2):
c=num1*num2
return(c)
def dividir(num1,num2):
c=num1//num2
return(c)

print("Ingrese el primer número: ")

primer=int(input())
print("Ingrese el segundo número: ")
segundo=int(input())
s=sumar(primer,segundo)
print("La suma es: ",s)
r=restar(primer,segundo)
print("La resta es: ",r)
m=multiplicar(primer,segundo)
print("La multiplicación es: ",m)
d=dividir(primer,segundo)
print("La división es: ",d)

Al ejecutar el código muestra el siguiente resultado

Ingrese el primer número:

5
Ingrese el segundo número:
3
La suma es: 8
La resta es: 2
La multiplicación es: 15
La división es: 1

Arreglos
Las listas en Python forman parte de lo que se conoce como estructuras de datos
que nos ofrece Python (son un tipo de array). En otros lenguajes de
programación, se los conoce como vectores.

78
 • Un arreglo se compone de elementos almacenados linealmente en
posiciones de memoria consecutiva

• Un arreglo es un conjunto finito de posiciones de memoria

consecutivas que tienen el mismo nombre. Los arreglos de una
dimensión (unidimensionales) se llaman vectores. Los arreglos de dos
dimensiones (bidimensionales) se llaman matrices

• Un vector o array -arreglos en algunas traducciones- es una secuencia

de objetos almacenados consecutivamente en memoria

En Python se les conoce a los arreglos como array o las listas

Tipo listas
En Python tiene varios tipos de datos compuestos y dentro de las secuencias,
están los tipos de cadenas de caracteres. Otro tipo muy importante de secuencia
son las listas.

Entre las secuencias, el más versátil, es la lista, para definir una, usted debe
escribir es entre corchetes, separando sus elementos con comas cada uno.
La lista en Python son variables que almacenan arrays, internamente cada
posición puede ser un tipo de datos distinto.

Ejemplo de una lista definida en Python

79
factura = ['pan', 'huevos', 100, 1234]
factura
['pan', 'huevos', 100, 1234]

Las listas en Python son:

• Heterogéneas: pueden estar conformadas por elementos de distintos
tipos, incluidos otras listas.
• Mutables: sus elementos pueden modificarse.

Una lista en Python es una estructura de datos formada por una secuencia
ordenada de objetos.

Los elementos de una lista pueden accederse mediante su índice, siendo 0 el

índice del primer elemento.

factura[0]
'pan'
factura[3]
1234

La función len() devuelve la longitud de la lista (su cantidad de elementos).

len(factura)
4
Los índices de una lista inician entonces de 0 hasta el tamaño de la lista menos
uno (len(factura) - 1):
len(factura) - 1
3

Los índices negativos van entonces de -1 (último elemento) a -len(factura)

(primer elemento).

factura[-len(factura)]
'pan'

80
A través de los índices, pueden cambiarse los elementos de una lista en el lugar.
factura[1] = "carne"

factura
['pan', 'carne', 100, 1234]

De esta forma se cambia el valor inicial de un elemento de la lista lo cual hacen

una lista mutable

Métodos que se pueden usar en las listas

El objeto de tipo lista integra una serie de métodos integrados a continuación:

append()

Este método agrega un elemento al final de una lista.

versiones_plone = [2.5, 3.6, 4, 5]

print (versiones_plone)
[2.5, 3.6, 4, 5]
versiones_plone.append(6)
print (versiones_plone)
[2.5, 3.6, 4, 5, 6]

count()

Este método recibe un elemento como argumento, y cuenta la cantidad de veces

que aparece en la lista.

versiones_plone = [2.5, 3.6, 4, 5]

print (versiones_plone)
versiones_plone.append(6)
print (versiones_plone)
print("6->", versiones_plone.count(6))
print("5->", versiones_plone.count(5))
print ("2.5 ->", versiones_plone.count(2.5))

y la salida es:
[2.5, 3.6, 4, 5]
[2.5, 3.6, 4, 5, 6]
6-> 1
5-> 1
2.5 -> 1

extend()

Este método extiende una lista agregando un iterable al final.

81
lista= [2,4,6,8]
lista
[2, 4, 6, 8]
lista.extend([10])
lista
[2, 4, 6, 8, 10]
lista.extend(range(15,20))
lista
[2, 4, 6, 8, 10, 15, 16, 17, 18, 19]

En un programa sería:
lista= [2,4,6,8]
lista.extend([10])
lista.extend(range(15,20))
lista
print(lista)

y su salida es:
[2, 4, 6, 8, 10, 15, 16, 17, 18, 19]

index()

Este método recibe un elemento como argumento, y devuelve el índice de su

primera aparición en la lista.

lista= [2,4,6,8]
lista
[2, 4, 6, 8]
lista.index(6)
2

El método admite como argumento adicional un índice inicial a partir de donde

comenzar la búsqueda, opcionalmente también el índice final.

lista
[2, 4, 6, 8]
lista.index(8,2)
3

El método devuelve una excepción ValueError si el elemento no se encuentra en

la lista, o en el entorno definido.

lista
[2, 4, 6, 8]
lista.index(9)
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>

82
 lista.index(9)
ValueError: 9 is not in list

insert()

Este método inserta el elemento x en la lista, en el índice i.

lista
[2, 4, 6, 8]
lista.insert(2,5)
lista
[2, 4, 5, 6, 8]

pop()

Este método devuelve el último elemento de la lista, y lo borra de la misma.

lista
[2, 4, 5, 6, 8]
lista.pop()
8
lista
[2, 4, 5, 6]

Opcionalmente puede recibir un argumento numérico, que funciona como índice

del elemento (por defecto, -1)

lista
[2, 4, 5, 6]
lista.pop(2)
5
lista
[2, 4, 6]

remove()

Este método recibe como argumento un elemento, y borra su primera aparición

en la lista.

lista
[2, 4, 6]
lista.remove(4)
lista
[2, 6]

El método devuelve un excepción ValueError si el elemento no se encuentra en

la lista.

83
lista
[2, 6]
lista.remove(10)
Traceback (most recent call last):
File "<pyshell#46>", line 1, in <module>
lista.remove(10)
ValueError: list.remove(x): x not in list

reverse()

Este método invierte el orden de los elementos de una lista.

lista=[1,3,4,5,6]
lista
[1, 3, 4, 5, 6]
lista.reverse()
lista
[6, 5, 4, 3, 1]

sort()

Este método ordena los elementos de una lista.

lista
[6, 5, 4, 3, 1]
lista.sort()
lista
[1, 3, 4, 5, 6]

El método sort() admite la opción reverse, por defecto, con valor False. De tener
valor True, el ordenamiento se hace en sentido inverso.

lista
[1, 3, 4, 5, 6]
lista.sort(reverse=True)
lista
[6, 5, 4, 3, 1]

Generar números aleatorios entre dos valores en Python

randint(a, b)
Para generar números aleatorios en Python de valor entero, se suele utilizar la
función randint(). La función randint(a, b) devuelve un número entero
comprendido entre a y b (ambos inclusive) de forma aleatoria. Ejemplos útiles
de esta función: determinar quién comienza una partida (jugador/PC); simular
el dado del parchís, etc:

84
import random
# ¿Quién comienza?
comienza = random.randint(0, 1)
if comienza == 0:
print('Comienza el jugador')
else:
print('Comienza el PC')
# Número aleatorio del parchís
numero = random.randint(1, 6)
print(numero)

Y se produce la siguiente ejecución.

Comienza el PC
3

randrange(a, b, salto)
La función randrange(a, b, salto) genera números enteros aleatorios
comprendidos entre a y b separados entre sí con un salto. Por ejemplo,
randrange(5, 27, 4) obtendría un valor aleatorio de entre los siguientes posibles:
5, 9, 13, 17, 21, 25.
import random
for i in range(10):
print(random.randrange(5, 27, 4))

y la salida es:

13
9
13
5
9
21
9
13
25
9

random()

La función random() devuelve un float comprendido entre [0.0 y 1.0]

import random
for i in range(5):
print(random.random())

y se obtiene las siguientes salidas:

0.386848814518047

85
0.848279099161922
0.33484848526004074
0.3889550268426558
0.19334419798917024

uniform(a, b)

La función uniform(a, b) devuelve un float aleatorio comprendido entre a y b

(ambos inclusive).

import random
for i in range(5):
print(random.uniform(100,200))

y su ejecución es:

164.56189613805066
104.49738641269194
114.00465783506694
185.3252793866647
192.10767956685766

Obtener elementos aleatorios de una secuencia

Hasta ahora hemos visto cómo obtener números aleatorios en Python. A

continuación, veremos que también es posible obtener elementos aleatorios de
una secuencia.

choice()

La función choice(sec) devuelve un elemento aleatorio de una secuencia. Es muy

útil cuando hay que elegir al azar un elemento de entre un conjunto.

import random
frutas = ['peras', 'manzanas', 'plátanos', 'ciruelas']
for i in range(3):
print(random.choice(frutas))

Que al ejecutarse:
manzanas
manzanas
peras

shuffle()

La función shuffle(sec) modifica el orden de los elementos de una lista. Esta

función se asemeja a la acción de mezclar una baraja.

86
import random
baraja = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12]
for i in range(3):
random.shuffle(baraja)
print(baraja)

y al ejecutarse tenemos:

[2, 10, 12, 5, 3, 7, 6, 1, 11, 4]

[6, 5, 7, 2, 1, 10, 11, 3, 12, 4]
[10, 3, 5, 2, 6, 4, 11, 1, 7, 12]

sample()

Esta función sample(sec, num) devuelve num elementos aleatorios de la

secuencia sec. Siguiendo con el ejemplo de la baraja, sería similar a la acción de
repartir num cartas a un jugador.

import random
baraja = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12]
print(random.sample(baraja, 5))

y su ejecución es:

[5, 7, 10, 6, 1]

Ejemplo: Diseñar un programa usando funciones para llenar un vector con

números aleatorios, visualizar su contenido y sumar sus posiciones:

import random
n=0
lista=[]
def leer():
n=int(input("Ingrese la dimensión del vector: "))
return(n)

def llenar(n1):
for i in range(n1):
lista.append(int((random.uniform(0,20))))

def visualiza(n2):
for i in range(n2):
print(lista[i])

def sumavector(n3):
s=0
for i in range(n3):

87
 s=s+lista[i]
return(s)

t=leer()
llenar(t)
visualiza(t)
sum=sumavector(t)
print("La suma de las posiciones del vector es: ",sum)

al ejecutarse tenemos lo siguiente:

Ingrese la dimensión del vector: 5

17
14
12
5
18
La suma de las posiciones del vector es: 66

Matrices
Las matrices no son una estructura propia de Python. Simplemente, una matriz
es una lista de listas que nosotros interpretamos desde el punto de vista
matemático. Es decir, la estructura m = [[1,2],[3,4]] la interpretamos como la
matriz 2x2 cuya primera fila es (1,2) y cuya segunda fila es (3,4), pero esto no
deja de ser una interpretación

En Python, las matrices se representan mediante el tipo de datos de lista.

Creamos una matriz de 3x3 haciendo uso de la lista.

La matriz está compuesta por tres filas y tres columnas.

• La fila número uno dentro del formato de lista tendrá los siguientes
datos: [8,14, -6]
• La fila número dos será: [12,7,4]
• La fila número tres será: [-11,3,21]

88
 La matriz dentro de una lista con todas las filas y columnas puede verse de la
siguiente manera:

Ejemplo: Llenar una matriz de números enteros aleatorios de 0 al 10 y mostrar

la matriz llena y la suma de todos sus valores

import random
matriz=[]
def llenarmatriz(f1,c1):
for i in range(f1):
fila=[]
for j in range (c1):
a=int(random.uniform(0,10))
fila.append(a)
matriz.append(fila)

def visualiza(f2,c2):
for i in range(f2):
for j in range (c2):
print(matriz[i][j])

def sumamatriz(f3,c3):
s=0
for i in range(f3):
for j in range (c3):
s=s+matriz[i][j]
return(s)

f=int(input("Ingrese el número de filas: "))

c=int(input("Ingrese el número de columnas: "))
llenarmatriz(f,c)
visualiza(f,c)
total= sumamatriz(f,c)
print("La suma de la matriz es: ",total)

89
La ejecución es la siguiente:

Ingrese el número de filas: 4

Ingrese el número de columnas: 3
1
5
6
6
2
1
2
1
3
6
2
1
La suma de la matriz es: 36

Solución 2 llenar manualmente la matriz y visualizarla en forma de matriz:

import random
matriz=[]
def llenarmatriz(f1,c1):
for i in range(f1):
fila=[]
for j in range (c1):
a=int(random.uniform(0,10))
fila.append(a)
matriz.append(fila)

def visualiza(f2,c2):
for i in range(f2):
for j in range (c2):
print(matriz[i][j],end=" ")
print("")

def sumamatriz(f3,c3):
s=0
for i in range(f3):
for j in range (c3):
s=s+matriz[i][j]
return(s)

f=int(input("Ingrese el número de filas: "))

c=int(input("Ingrese el número de columnas: "))
llenarmatriz(f,c)
visualiza(f,c)
total= sumamatriz(f,c)

90
print("La suma de la matriz es: ",total)

La salida en la ejecución es:

Ingrese el número de filas: 4

Ingrese el número de columnas: 3
6 6 1
5 9 2
1 2 3
4 2 1
La suma de la matriz es: 42

Las cadenas o frases por ser una secuencia de caracteres se le puede considerar
como un vector o arreglo de una dimensión pero que en cada posición guarda
un solo carácter a la vez.

Diseñar un programa usando programación modular que permita contar y

visualizar las palabras de longitud 5 que existan en una frase ingresada por el
usuario

frase=[]
def leer():
print("Ingrese una frase: ")
frase1=str(input())
return(frase1)

def visualiza(cadena,n1):
for i in range(n1):
print(cadena[i])

def contar(frase1,n2):
pi=0
cl=0
cont5=0
for x in range(n2):
if(frase1[x]==' '):
pf=x-1
if(cl==5):
cont5=cont5+1
for j in range(pi,pf+1,+1):
print(frase1[j],end="")
print("")
cl=0
pi=x+1
else:
cl=cl+1
print("El número de palabras de 5 caracteres es: ",cont5)

91
frase=leer()
n=len(frase)
print("Imprime la frase directamente: ",frase)
print("Por visualización")
visualiza(frase,n)
contar(frase,n)

Ejecución:

Ingrese una frase:

El campo bravo de chimborazo
Imprime la frase directamente: El campo bravo de chimborazo
Por visualización
E
l

c
a
m
p
o

b
r
a
v
o

d
e

c
h
i
m
b
o
r
a
z
o

campo
bravo
El número de palabras de 5 caracteres es: 2

92
Diseñar un programa usando programación modular que permita contar y
visualizar al revés las palabras de longitud 5 que existan en una frase ingresada
por el usuario:

frase=[]
def leer():
print("Ingrese una frase: ")
frase1=str(input())
return(frase1)

def visualiza(cadena,n1):
for i in range(n1):
print(cadena[i])

def contar(frase1,n2):
pi=0
cl=0
cont5=0
for x in range(n2):
if(frase1[x]==' '):
pf=x-1
if(cl==5):
cont5=cont5+1
for j in range(pf,(pi-1),-1):
print(frase1[j],end="")
print("")
cl=0
pi=x+1
else:
cl=cl+1
print("El número de palabras de 5 caracteres es: ",cont5)

frase=leer()
n=len(frase)
print("Imprime la frase directamente: ",frase)
print("Por visualización")
visualiza(frase,n)
contar(frase,n)

Ejecución:

Ingrese una frase:

El campo bravo de Chimborazo
Imprime la frase directamente: El campo bravo de Chimborazo
Por visualización
E
l

93
c
a
m
p
o

b
r
a
v
o

d
e

C
h
i
m
b
o
r
a
z
o

opmac
ovarb
El número de palabras de 5 caracteres es: 2

• Deber:
1. Diseñar un programa que permita sumar dos vectores de igual longitud
2. Diseñar un programa que permita sumar dos vectores de distinta
longitud
3. Diseñar un programa que permita buscar el mayor y menor número
que se encuentran almacenados en un vector
4. Diseñar un programa que permita ordenar un vector de forma
ascendente y descendente
5. Diseñar un programa que permita reemplazar en un vector todos los
números repetidos por un -5
6. Diseñar un programa que permita sumar el contenido de una matriz
7. Diseñar un programa que permita generar una matriz traspuesta
8. Dada una matriz en la que guarden las notas de n estudiantes en sus
m asignaturas. Calcular:
• El promedio de notas de cada uno de los n estudiantes
• El promedio de notas de cada una de las m asignaturas

94
9. Diseñar un programa que permita sumar dos matrices de igual
dimensión
10.Diseñar un programa que permita sumar dos matrices de distinta
longitud
11.Diseñar un programa que permita realizar la multiplicación de matrices

95
Software para calculo científico

¿Qué es Scilab?
Scilab es un software de código abierto, multiplataforma y orientado a cálculo
numérico y con un lenguaje de programación de alto nivel, por ello puede
utilizarse en problemas de simulación para aplicaciones de ingeniería y
científicas. Scilab cubre un amplio espectro de áreas, tales como las siguientes:

• Aeroespacial,
• Automoción,
• Energía,
• Defensa,
• Finanzas,
• Química,
• Biología,
• Medicina ...

Scilab es actualmente desarrollado por Scilab Enterprises, bajo la licencia

CeCILL, compatible con la GNU General Public License. Se puede descargar
gratis en la página web: www.scilab.org

Scilab está disponible para sistemas operativos Microsoft Windows y GNU/Linux,

tanto plataformas de 32 como de 64 bits, y Mac OS X.

Los requerimientos del sistema para Microsoft Windows XP, 7, 8, con procesador
Pentium IV o equivalente, 1 GB RAM (2 GB recomendado), y 600 MB de espacio
en disco duro.

Scilab fue desarrollado inicialmente por INRIA (Institut National de Recherche

en Informatique et Automatique) y la ENPC (École Nationale des Ponts et
Chaussées) desde 1990. El Consorcio Scilab (Scilab Consortium) fue creado
en mayo de 2003 para ampliar y promover Scilab como software de referencia
en todo el mundo en el mundo académico y la industria. Scilab Consortium
está compuesto actualmente por 18 miembros, INRIA, DIGITEO, ECOLE
CENTRALE DE PARIS, ECOLE POLYTECHNIQUE, ENGINSOFT France, PSA,
PEUGEOT, CITROËN y RENAULT entre otros. Desde julio de 2012, Scilab
Enterprises desarrolla y publica Scilab.

96
Scilab Integra un gran número de funcionalidades:
• Matemáticas y de simulación: Scilab proporciona alrededor de 1.700
funciones matemáticas para aplicaciones de ingeniería y ciencias
habituales incluyendo operaciones matemáticas y análisis de datos.
• Visualización 2D y 3D: Funciones de gráficos para visualizar, anotar y
exportación de datos y muchas maneras de crear y personalizar diferentes
tipos de gráficos y tablas.
• Optimización: Algoritmos para resolver problemas de optimización con
restricciones continuas y discretas y sin restricciones.
• Estadísticas: Herramientas para realizar análisis de datos y modelización
• Diseño de Sistemas de Control y Análisis: Algoritmos y herramientas
para el estudio del sistema de control
• Procesamiento de Señales: Visualizar, analizar y filtrar las señales en
los dominios de tiempo y frecuencia.
• Desarrollo de aplicaciones: Funcionalidades nativas Aumentar Scilab y
gestionar intercambios de datos con herramientas externas.
• Xcos – sistemas modelador y simulador: Sistemas de modelado
mecánico, circuitos hidráulicos, sistemas de control, etc.

Ejemplo básico en Scilab para calcular la función de factorial y realizar el gráfico

debido.

// Make a table of factorial

n = (0:30)';
[n factorial(n)]

// See the limits of factorial: f(171)=%inf

factorial(170) // 7.257415615307998967e306
factorial(171) // %inf

// Plot the function on all its range.

scf();
plot ( 1:170 , factorial , "b-o" )
h = gcf();
h.children.log_flags="nln";

--> x = -1:0.1:1;

--> [X, Y] = meshgrid(x);

--> Z = sinc(2*%pi * X.*Y);

--> surf(X, Y, Z)
ans =

97
ans =

Instrucciones básicas
Para asignar un valor a las variables se puede usar:

a=10,T=5; x=a+T;

la salida es
a =

10.

Limpiar la pantalla clc

Comentario: //

Vectores
--> A=[1,2,5];

--> A

Salida
A =

1. 2. 5.

Matrices
Una matriz se declara como un arreglo bidimensional separando cada fila por un
;
--> B=[1,2,3;4,5,6];

--> B

Salida
B =

1. 2. 3.
4. 5. 6.

→a=[1,2,3;4,5,6]
a =

1. 2. 3.
4. 5. 6.
--> sum(a)

98
ans =

21.
→x=sum(A);

--> y=length(A);

--> prom=x/y
prom =

8.5

→mean(A)//promedio
A=[1,2,3,4;5,6,7,8;9,10,11,12;13,14,15,16]
s=0;
for i = 1:4
for j=1:4
s=s+A(i,j)
end
end
prom=s/(4*4)
printf('El promedio es:%d\n', prom);

También, podemos programar en un scrip las instrucciones necesarias en las

que se pueden incluir las estructuras de programación como un lenguaje de
programación, pero respetando la sintaxis de cada estructura.

printf("filas");
f=input('.');
printf("columnas");
c=input('.');
s=0;
for i=1:f
for j=1:c
printf("Ingrese el valor [%d,%d]: ",i,j)
matriz(i,j)=input('.');
s=s+matriz(i,j);
end
end
p=s/(f*c);
printf('El promedio es:'),disp(p);

99
Se puede crear un scrip con instrucciones usando las notas

Se cambia al directorio de trabajo sino se debe de copiar todo el directorio y se

guarda el archivo con extensión.sce

exec('facto.sce')

Dentro del entorno se puede ejecutar o con el comando exec desde fuera

Definición de funciones

Se puede definir funcione en la línea de comandos:

El formato de una función es:

function [argumentos de salida] = nombre(argumentos de entrada)
// comentarios
//

100
...
instrucciones (normalmente terminadas por ; para evitar eco en pantalla)
...
Endfunction

-->function [y]=fun1(x), y=2*x+1, endfunction

Y se le puede llamar como:

-->sqrt(fun1(4))
Y la respuesta es:
ans =

3.

Función 2:
--> deff('[s]=fun2(x,y)','s=sqrt(x^2+y^2)')

--> fun2(3,4)
ans =

5.

Para crear un archivo con funciones se debe ir a las notas y copiar las funciones
function [z]=fun3(x)
z=sin(x);
endfunction

guardarla con la extensión. Sci

ir al entorno y colocar
exec('misfunciones.sci',-1)

--> t=5;

-->fun3(t)
ans =

-0.9589243
Equivale a calcular la función sin(5)

Y si utilizamos la función max entre (-0.958 y 0);

-->max(fun3(t),0)
ans =

0.

101
Para le ejecución si va sin ; la respuesta toma la variable ans
7*exp(5/4)+3.54
ans =

27.972401

Si va ; no me muestra la respuesta y esto se usa en programas

7*exp(5/4)+3.54;
-->

Crea un vector V1 desde 1 a 4 y automáticamente se incrementa en 1

--> v1=1:4
v1 =

1. 2. 3. 4.

Crea una matriz donde copia todos los valores de V1 del 1 al 4 aumenta el valor
de 5 en la última columna de la fila 1

En la fila 2 desde 0.1 hasta 0.5 pero con incrementos de 0.1 en cada valor

--> v2=[v1,5;0.1:0.1:0.5]
v2 =

1. 2. 3. 4. 5.
0.1 0.2 0.3 0.4 0.5

Se puede ir viendo los valores en el explorador de variables

102
Para generar la matriz traspuesta ‘
-->v3=[v2',[11,12,13,14,15]']
v3 =

1. 0.1 11.
2. 0.2 12.
3. 0.3 13.
4. 0.4 14.
5. 0.5 15.

La fila 1y dos se traspone como columnas y se suma la tercera columna también

traspuesta de 11 al 15

Para sacar la diagonal de la matriz

--> diag(v3)
ans =

1.
0.2
13.

Estructuras de selección
If

if rand(1,1) > 0.5 then

disp("True");
else
disp("False");
end

Para ingresar un valor desde el teclado:

printf("Ingrese un numero: "),
numero=input('.');
if(modulo(numero,2)==0) then
printf("es par")
else
printf("es impar")
end

Estructura select
printf("Ingrese el primer número: ")
a=input('.')
printf("Ingrese el segundo número: ")
b=input('.')
printf("MENÚ DE OPCIONES\n")

103
printf("1. Sumar\n")
printf("2. Restar\n")
printf("3. Multiplicar\n")
printf("4. Dividir\n")
printf("Escoja una opción: \n")
op=input('.')
select op
case 1 then
res=a+b
printf("La suma es: %d",res)
case 2 then
res=a-b
printf("La resta es: %d",res)
case 3 then
res=a*b
printf("La multiplicación es: %d",res)
case 4 then
res=a/b
printf("La división es: %.2f",res)
else
printf("Opción no valida....")

end

Estructura while
i = 0;
while i<5
disp(i);
i = i + 1;
end

no hay do while

Estructura for
for i = 1:5
disp(i);
end

gráficos en 2D

// Default abscissae = indices

subplot(1,2,1)
plot(sin(0:0.1:2*%pi))
xlabel("x indices")

104
subplot establece el área de dibujo
si probamos solo
sin(0:1:2)
ans =

0. 0.841471 0.9092974

Se obtiene el seno de 0 el seno de 1 y el de 2

// Default abscissae = indices

subplot(1,2,1)
plot(sin(0:0.1:2*%pi))
xlabel("x indices")

105
// With explicit abscissae:
x = [0:0.1:2*%pi]';
subplot(1,2,2)
plot(x, sin(x))
xlabel("Specified abscissae")

plot
clf()
x = [0:0.1:2*%pi]';
plot(x, [sin(x) sin(2*x) sin(3*x)])

Segmentos verticales entre dos curvas, con colores automáticos y utilizando

propiedades globales para los estilos de marcadores. Apuntando a ejes definidos.

clf
subplot(1,3,3)
ax3 = gca(); // We will draw here later

106
xsetech([0 0 0.7 1]) // Defines the first Axes area
t = -3:%pi/20:7;
// Tuning markers properties
plot([t ;t],[sin(t)
;cos(t)],'marker','d','markerFaceColor','green','markerEdgeColor','yel
')

// Targeting a defined axes

plot(ax3, t, sin)

107
Construcción de arreglos en Scilab

Valores aleatorios:
Para generar valores aleatorios en Scilab se usa la función rand y si queremos
llenar un arreglo con valores aleatorios se usa como en el ejemplo:

--> rand(4,4)
ans =

0.8497452 0.5608486 0.5442573 0.8833888

0.685731 0.6623569 0.2320748 0.6525135
0.8782165 0.7263507 0.2312237 0.3076091
0.068374 0.1985144 0.2164633 0.9329616

Los valores serán entre 0 y 1

Llena una matriz de 4x4 por valores aleatorios

--> A=rand(4,4)
A =

0.2146008 0.5664249 0.5015342 0.4051954

0.312642 0.4826472 0.4368588 0.9184708
0.3616361 0.3321719 0.2693125 0.0437334
0.2922267 0.5935095 0.6325745 0.4818509

Diagonal de la matriz
Para acceder a la diagonal de una matriz se usa:

En nuestro ejemplo sería la diagonal de A:

--> vec=diag(A)
vec =

0.2146008
0.4826472
0.2693125
0.4818509
Y se muestra como un vector los valores de la diagonal principal de A

Llena una matriz de 3x5 por unos

--> mat=ones(3,5)

108
mat =

1. 1. 1. 1. 1.
1. 1. 1. 1. 1.
1. 1. 1. 1. 1.

Genera un vector desde 1 a 30 en 5 partes

→linspace(1,30,5)
ans =

1. 8.25 15.5 22.75 30.

-> B=rand(4,4)
B =

0.2639556 0.7783129 0.1531217 0.4094825

0.4148104 0.211903 0.6970851 0.8784126
0.2806498 0.1121355 0.8415518 0.113836
0.1280058 0.6856896 0.4062025 0.1998338

Multiplicación de matrices
--> c=A*B
c =

0.4842268 0.6211317 1.0143647 0.7234944

0.5229046 1.0243809 1.1250428 0.7852565
0.3144248 0.4120413 0.5313314 0.4792645
0.5625404 0.7545444 1.1865461 0.8093077

Suma todo el contenido de la matriz

→sum(A)
ans =

6.8453894

z=[1,2,3;4,5,6;1,2,3]
z =

1. 2. 3.
4. 5. 6.
1. 2. 3.

Suma cada columna

--> sum(z,1)
ans =

109
 6. 9. 12.

Suma cada fila

→sum(z,2)
ans =

6.
15.
6.

Suma las columnas

→sum(z,'r')
ans =

6. 9. 12.

Suma las filas

--> sum(z,'c')
ans =

6.
15.
6.

Suma la diagonal principal de z

--> trace(z)
ans =

9.

Si mat es una matriz de 3 filas 5 columnas

--> mat
mat =

1. 1. 1. 1. 1.
1. 1. 1. 1. 1.
1. 1. 1. 1. 1.

Obtiene la dimensión de columnas en la matriz

--> size(mat,2)
ans =

5.

Obtiene la dimensión de filas en la matriz

110
--> size(mat,1)
ans =

3.

-> z
z =

1. 2. 3.
4. 5. 6.
1. 2. 3.

La matriz traspuesta

--> z'
ans =

1. 4. 1.
2. 5. 2.
3. 6. 3.

-> z
z =

1. 2. 3.
4. 5. 6.
1. 2. 3.
Mostrar la columna 2 de la matriz

--> z(:,2)
ans =

2.
5.
2.

Muestra toda la matriz

-> z(:,:)
ans =

1. 2. 3.
4. 5. 6.
1. 2. 3.

Muestra la fila 1

111
--> z(1,:)
ans =

1. 2. 3.

Muestra toda la matriz en una sola columna

--> z(:)
ans =

1.
4.
1.
2.
5.
2.
3.
6.
3.

Máximo valor de la matriz

--> max(z)
ans =

6.

Máximo de cada columna

--> max(z,'r')
ans =

4. 5. 6.

Máximo de cada fila

--> max(z,'c')
ans =

3.
6.
3.

Promedio de cada fila

--> mean(z,'c')

112
ans =

2.
5.
2.

Promedio de cada columna

--> mean(z,'r')
ans =

2. 3. 4.

Submatriz

--> z(1:2,1:2)
ans =

1. 2.
4. 5.

Si tenemos la matriz A=[1,2,3;4,5,6;7:9;10:12]

Y su tamaño es 4 filas y 3 columnas

Para acceder al número de filas y columnas usaremos el comando size

Y su respuesta es:
-→size(A)
ans =

4. 3.

La respuesta es el número de filas (4) seguido del número de columnas (3)

Como su respuesta es un vector formado por dos valores la posición 1 es el valor
de las filas y la posición 2 de la respuesta es el número de columnas. En este
ejemplo [1] es 4 filas y [2] es 3 filas, para separar los valores podemos recurrir
a la siguiente función para tomar por separado el valor de la dimensión de las
filas y de las columnas de la siguiente manera:

Para averiguar el valor del número de filas que tiene la matriz A se puede usar:

-> x=size(A,1)
x =

4.
Y para averiguar el número de columnas que tiene la matriz A:
-> y=size(A,2)

113
y =

3.

De esa manera tenemos el número de filas y columnas que posee una matriz

Diseñar un scrip que permita ingresar las notas de n estudiantes en m

asignaturas con valores entre 0 y 20 y encontrar:
• El promedio de cada estudiante
• El promedio de cada asignatura
• El estudiante de mejor promedio
• La asignatura de menor promedio

function [posmay]=maxestudiante()
posmay=0
may=0
for i=1:f
if(promfilas(i)>may)
may=promfilas(i)
posmay=i
end
end
endfunction
function[posmen]=minasignatura()
posmen=0
men=9999
for j=1:c
if(promcol(j)<men)
men=promcol(j)
posmen=j
end
end
endfunction

f=input('Ingrese el número de estudiantes: ')

c=input('Ingrese el número de asignaturas: ')
notas=int(rand(f,c)*20)
disp(notas)
promfilas=mean(notas,'c')
printf("PROMEDIO POR ESTUDIANTES\n")
disp(promfilas)
promcol=mean(notas,'r')
printf("PROMEDIO POR ASIGNATURA\n")
disp(promcol)
m=maxestudiante()
printf("El estudiante de mejor promedio es: %d \n",m)
menor=minasignatura()

114
printf("La asignatura de menor promedio es: %d \n",menor)
w=promfilas'
vec=gsort(w,"g","d")
disp(vec)
Para ordenar un vector:

-> a=[10,5,8,20,9,2]
a =

10. 5. 8. 20. 9. 2.

gsort(a,"g","d")
ans =

20. 10. 9. 8. 5. 2.

--> gsort(a,"g","i")
ans =

2. 5. 8. 9. 10. 20.

Gráficos en Scilab
Para generar un tipo de gráficos en Scilab se puede usar el comando plot para
una gráfica en 2D.

Para los gráficos en 2D es necesario definir un vector del eje X y un vector de

valores para el vector Y en los que coincida el par de valores que representan a
un punto en el gráfico por ejemplo. Si tenemos los siguientes 6 puntos para
realizar el grafico

Cada punto está formado por un par de números donde se corresponde con el
eje X el primer valor y el segundo valor para el eje Y, entonces tenemos la forma
de: P(X,Y)

En nuestro caso son 6 puntos que se muestran a continuación:

P1(-2,4)
P2(-1,1)
P3(0,0)
P4(1,1)
P5(2,4)
P6(3,9)

Entonces separamos manteniendo el orden de los pares de puntos en los

vectores de los puntos X y los puntos en Y.

Dicho de otra forma el vector X queda formado por los primeros números de
cada par de números que formaban los puntos de 1 al 6.

115
Si generalizamos seria
X=[X1,X2,X3,X4,X5,X6]

X = [-2, -1, 0, 1, 2, 3];

El vector Y queda conformado por los segundos números de cada par de números
que formaban los puntos de 1 al 6.

Y=[Y1,Y2,Y3,Y4,Y5,Y6]

Y = [4, 1, 0, 1, 4, 9];

Para graficar el Scilab usamos la función plot y como argumentos los vectores X
y Y; donde de forma automática se grafica cada punto de X con su
correspondiente posición de Y.

plot (X,Y)

Probar las siguientes instrucciones en Scilab:

-->X = [-2, -1, 0, 1, 2, 3];

--> Y = [4, 1, 0, 1, 4, 9];

--> plot(X,Y)

Verificar que los 6 puntos forman la gráfica

116
 P6(3,9)

P1(-2,4) P5(2,4)

P2(-1,1)

P4(1,1)

Si solo queremos graficar los puntos haría falta aumentar en la función plot lo
siguiente:

-->plot (X,Y,"rd")

117
Se puede también mostrar el gráfico de distinta manera y color tomando en
cuenta los siguientes parámetros. Por ejemplo, para cambiar el color en lugar
de r se puede probar con los valores de la siguiente tabla:

Para el color

Para el estilo de la línea

Entonces si queremos que nuestro gráfico sea con líneas de color negro es la
k(según la primera tabla k=Black)

Y si el estilo de la línea es entre cortada – según la tabla se corresponde con

Dashed line

--> plot (X,Y,"k--")

118
O de color magenta y de línea punteada:
-->plot (X,Y,"m:")

También se puede considerar un estilo de línea, solo como marcador en el dibujo.

Para ello puede usar la siguiente tabla

Funciones para trabajo con ventanas gráficas

scf (): establece la figura gráfica actual (ventana)
clf (): borra o restablece una figura.
gcf (): Devuelve el identificador de la ventana gráfica actual.
gdf (): devuelve el identificador de la figura predeterminada.
set (): establece un valor de propiedad de un objeto de entidad gráfica.

119
get (): recupera un valor de propiedad de una entidad gráfica o un objeto de
interfaz de usuario. Tenga en cuenta que, si especifica un marcador sin un estilo
de línea, solo el marcador es dibujado.

Para hacer referencia a cada punto también se puede realizar como se muestra
en el ejemplo como cada punto es un vector formado por dos coordenadas

//dibujar un triangulo
P1=[5,3]
P2=[0,1]
P3=[6,2]

x=[P1(1),P2(1),P3(1),P1(1)]
y=[P1(2),P2(2),P3(2),P1(2)]

f3=scf(3)
xlabel("Eje X","fontsize",3);
ylabel("Eje Y","fontsize",3);

title("Gráfico de prueba ","fontsize",5);

xgrid();

plot(x,y,"k--")

En el ejemplo se puede ver primero formar los vectores X y Y para las

coordenadas de cada punto, se inicializa el gráfico para el tipo ventana.

Se establecen dos etiquetas; una xlabel para el eje X donde aparece el texto
“Eje X”, el tipo de letra y un tamaño de 3, de la misma manera ylabel funciona
igual para crear una etiqueta para el eje y.

title es para que el gráfico tenga una título con un tipo de letra y tamaño de 5
xgrid es para que aparezca en el fondo del gráfico una cuadrícula.

120
subplot(filas, columnas, fig_actual):
Divide una ventana gráfica en una especie de ‘matriz de plots’ quiere decir que
una ventana gráfica tendrá filas y columnas y se podrá acceder a cada plot
mediante un parámetro como se explicará a continuación.

Se puede decir que el comando subplot( ) tiene como prototipo subplot( filas,
columnas, fig_actual ), tanto ‘filas’, ‘columnas’ y ‘fig_actual’ serán números
enteros positivos, donde:

• ‘filas’: Es un número entero que corresponde al número de filas en que

se ha dividido la ventana de gráficos.

• ‘columnas’: Es un número entero que corresponde al número de

columnas en que se ha dividido la ventana de gráficos.

• ‘fig_actual’: Es un número entero positivo que hace referencia al plot

o figura a la cual queremos hacer cambios, podemos decir que este valor
hace las veces de subindice dentro de esta matriz de gráficos.

En el siguiente programa:

t=-%pi:0.3:%pi;
subplot(211)
plot2d(t,sin(t),3)
subplot(212)
plot2d(t,cos(t),5)

121
Se divide la ventana en dos filas con una sola columna y el primer gráfico va en
la parte 1 y como se muestra es el gráfico de las coordenadas de t en el eje de
las x y el sin(t) como el valor del eje y

En el segundo gráfico en la parte 2 de la ventana donde las coordenadas de t

van en el eje de las x y el cos(t) como valor del eje y

Ejemplo
Si queremos graficar la función: f(X)= 3X2

Copie las siguientes líneas en un programa

function Y=curva(x1)
Y = 3*(x1^2);
endfunction

x=[-4:0.1:4]
plot(x,curva(x))

Estamos diseñando una función a la que llamaremos curva y recibe un valor de

x1, la función va a devolver para cada valor de x1 respuesta de multiplicar 3 por
el cuadrado de x1.

Definimos el rango de valores que tomara x desde -4 al 4 con incrementos de

0.1

122
Dibujamos con plot(x,curva(x)), para cada valor de x lo que devuelva el cálculo
de la función curva que en definitiva es 3X2

Para ordenar vectores en Scilab:

Se puede usar gsort donde el primer parámetro es el vector a ordenar, el
segundo parámetro el la c columna a ser ordenada o el 2 se puede usar y las
letras d para orden descendente e i para orden ascendente

--> vect=[3,1,10,6,5,15]
vect =

3. 1. 10. 6. 5. 15.

--> r=gsort(vect,"c","d")
r =

15. 10. 6. 5. 3. 1.

--> r=gsort(vect,"c","i")
r =

1. 3. 5. 6. 10. 15.

123
Ejercicios IF
1. Capturar un número cualesquiera e informar si es o no es mayor de 100
2. Capturar un número entero cualesquiera e informar si es o no es múltiplo
de 4 (recordar el operador mod, analizado en el tema de operadores
aritméticos)
3. Capturar los cinco datos más importantes de un Empleado, incluyendo el
sueldo diario y los días trabajados, desplegarle su cheque semanal solo si
ganó más de $500.00 en la semana, en caso contrario desplegarle un
bono de despensa semanal de $150.00
4. Capturar los datos más importantes de un estudiante incluyendo tres
calificaciones, que no deben ser mayores a 5
5. Capturar los datos más importantes de unos productos cualesquiera,
incluyendo cantidad, precio, etc., desplegar una orden de compra, solo si
el producto es de origen nacional, en caso contrario no hacer nada

Ejercicios IF con condiciones compuestas

1. Capture un número cualesquiera e informe si es o no es mayor de 50 y
múltiplo de tres. ( solo escribir el mensaje de respuesta de manera muy
clara y esto resuelve el problema )
2. Indique si un número es un par positivo

Ejercicios CASE
1. Construir un menú que contenga el siguiente menú
Conversión de pesos a dólares
Conversión de libras a kilogramos
Conversión de kilómetros a millas
Fin de menú
Seleccionar opción [ ]
2. Evaluar cualquier función vista para cuando x =3,-4, 5

Ejercicios if, case

1. Capturar en una lista los sueldos de 6 empleados y desplegarlos en una
segunda lista aumentados en un 30%
2. Capturar una lista los pesos en kilogramos de 6 personas desplegarlos en
una segunda lista convertidos a libras y además solo los mayores de 100
libras
3. Capturar 4 listas respectivas matricula, nombre y dos calificaciones de 5
alumnos, después calcular una lista de promedios de calificaciones
4. Capturar listas respectivas número de empleado, nombre del empleado,
días trabajados y sueldo diario de 5 empleados, y desplegar la nomina
pero solo de aquellos empleados que ganan más de $300.00 a la semana

Ejercicios While
1. Desplegar los números enteros entre 50 y 80
2. Desplegar múltiplos de 4 entre 60 y 20 acompañados de su logaritmos de
base 10 y base e respectivos
3. Construir la tabla de dividir que el usuario indique

124
Ejercicios varios
1. Convertir la edad en años de una persona a meses
2. Convertir pesos a dólares
3. Calcular el área de un círculo
4. Construir los modelos de solución de los siguientes problemas:
a. Convertir millas a kilómetros
b. Convertir 125 metros a centímetros
5. Se calcula que en promedio hay 4.7 nidos en cada árbol en la ESPOCH,
también se calcula que en cada nido existen un promedio de 5.8 pájaros,
se pide calcular la cantidad total de nidos y de pájaros en los 227 árboles
que existen en la ESPOCH
6. La Sra. López y sus 8 hijos solo compran una vez al mes su mandado en
conocido supermercado, en dicha tienda el kilogramo de fríjol cuesta
$8.75, el paquete de tortillas cuesta $3.55 y el frasco de café vale $14.25,
si solo compran de estos tres productos para su mandado, calcular su
gasto total
7. Capturar y desplegar los cinco datos más importantes de un automóvil
8. La distancia Tijuana - Ensenada es de 110 kilómetros. Si un automóvil la
recorre a una velocidad constante de 30 millas por hora, cuánto tiempo
tarda en llegar. ( 1 milla = 1.609 Km.)
9. Evaluar el factorial de cualquier número usando la formula: n!=n!-1
10.La distancia que recorre un auto es de 50 kms y su velocidad es de 30
millas por hora ¿Cuánto tiempo tardara en llegar?
11.Encontrar la derivada de x para cualquier valor con la formula(d/dx(x)=1)
12.Calcular l interés que gana un capital de x pesos a una tasa de interés del
15% anual en un periodo de n años
13.Que aceleración tiene un tren que parte de Tijuana a 10 km/hr y pasa por
Ensenada una hora después a 50 km/hr
14.Calcular el número de aulas en una escuela que tiene 10 edificios y cada
edificio 3 pisos y cada piso 5 aulas, excepto un edificio que solo tiene dos
pisos
15.Si en una escuela hay 30 maestros y 15 son hombres que atienden a 10
alumnos cada uno. ¿Cuantas maestras hay?
16.Calcular la corriente de un circuito con un voltaje de 15v y una resistencia
de 6 ohms. Formula (I= V/R)
17.Calcular la normal estándar(z) dados los datos por el usuario: X=dato,
µ=media, d=desviación. Formula (Z = X-M / d)
18.Dado un numero(N) cualesquiera obtener su raíz y potencia cuadrada
19.Determinar la media de 5 números diferentes
20.Determinar la velocidad v requerida para recorrer una distancia d en un
tiempo t . Formula (V = d * t)
21.Determinar la pendiente de una recta. Formula (y = m x + b)
22.Calcular la función de y= x² + 8x + 3 para cualquier x
23.Convertir minutos a horas
24.Aplicar la formula general para a=1, b=2, c=3
25.Se desea instalar un cable de red, el cliente pide 30 pies, considerando
que se venden en metros, cuantos deberá comprar

125
 26.Un campesino siembra trigo en un área cuadrada de 25 mts., ¿ cual es el
largo del cerco frontal en cms.?
27.Resolver x² + 15x - 8 para cualquier variable (X)
28.Convertir °C a °F
29.Si cada salón de la escuela tiene 40 alumnos y son 30 salones ¿Cuantos
alumnos son en toda la escuela?
30.Si Juan trabaja 5 días a la semana y descansa 2 ¿Cuantos días trabajo en
4 años?
31.Si en una oficina se procesan 20 facturas cada 10 minutos cuantas se
procesaran si se trabajan 5 horas?
32.Si una empresa tiene _____ de activo y un pasivo de _____ ¿Cual es su
capital?. Formula (C = A-P)
33.Calcule el voltaje de un circuito dada una intensidad I y una resistencia R.
Formula (V=IR)
34.Calcule la frecuencia de una onda que circula con un tiempo t. Formula
(F=1/t)
35.Calcule la potencia de un circuito con un voltaje V y una intensidad I.
Formula (f = VI)
36.Calcule el total que tendrá que pagar una persona que va al cine
dependiendo del número de boletos a comprar y el precio
37.Calcule las anualidades que tendrá que pagar una persona que pidió un
préstamo. Dependiendo del tiempo que el elija y el interés por año.
Formula (Anualidad=(Prestamo/Tiempo)+interes)
38.Determinar cuánto ganará una persona en base a las horas trabajadas.
Tomando en cuenta el pago por hora.
39.Convertir horas a segundos
40.Calcular la fuerza. Formula (fuerza = trabajo / tiempo)

Ejercicios propuestos de vectores y matrices

Elabore los diagramas de caja para:
1. Capturar las calificaciones de N alumnos y almacenarlas en un arreglo
para posteriormente calcular el promedio.
2. Capturar las calificaciones de N alumnos y almacenarlas en un arreglo
para posteriormente recorrerlo para encontrar la calificación mayor.
3. Capturar las ventas mensuales de una empresa durante un año
determinado y al final calcule el promedio anual de ventas y muestre el
nombre del mes con la venta mayor así como el mes con la venta menor.
4. Capture los datos de un arreglo de N posiciones de números positivos y
negativos enteros y sustituya los números negativos por cero.
5. Capturar N valores de tipo entero para almacenarlos en un arreglo y
ordenarlo en forma ascendente.
6. Calcular el promedio y la desviación estándar de un conjunto de N
números leídos del teclado. La desviación estándar se calcula con la
siguiente fórmula:

126
 7. Elaborar un programa que capture en un vector (T) la temperatura de
cada día de una semana y que realice lo siguiente :
• Imprimir la temperatura promedio.
• Formar un vector (D) que contenga las diferencias de cada
temperatura con respecto al promedio.
• Imprimir la menor temperatura y el número de día en que ocurrió.
8. Elabore un programa que encuentre la mayor diferencia entre 2 números
consecutivos y las posiciones de éstos, en un vector de N números
enteros.

9. Dado un vector V de N números enteros, cambie cada elemento menor

que 10 por 0 y cada elemento mayor que 20 por 1. Encuentre cuántos
elementos quedaron sin cambiar.
Ejemplo :

10. Elaborar un programa que capture en una matriz las calificaciones

obtenidas por un grupo de N estudiantes y que realice lo siguiente :

127
 • Formar un vector de tamaño N que contenga los promedios de cada
estudiante.
• Calcular el promedio del grupo en el examen 3.
• Imprimir el mayor promedio y el número del estudiante que lo obtuvo.
• Imprimir el total de alumnos aprobados y reprobados (la calificación
mínima aprobatoria es 70)
• Imprimir el número de alumnos que reprobaron el examen 1.
11. Diseñe un programa en que lea un vector desordenado A, compuesto de
n números enteros e imprímase este vector en la misma secuencia, pero
ignorando los valores duplicados que se encuentren en él. También se
necesita saber el número de elementos que permanecen (m); por
ejemplo, dado el siguiente vector

Matrices
12. Realice la suma matricial. El programa debe pedir las dimensiones de las
matrices A y B, validar que se pueda ejecutar la operación, capturar los
valores de cada una de las matrices, efectuar la operación y mostrar el
resultado.
13. Desarrollar un programa que lea una matriz cuadrada de tamaño n y
determine si se trata de una matriz simétrica o no. Una matriz es simétrica
si los valores de cada fila son iguales los de su columna correspondiente;
por ejemplo la siguiente matriz es simétrica:

14. Capture las celdas de una matriz de tamaño m X N y …

• Ordénelo en forma ascendente por columna
• Ordénelo en forma descendente por renglón
15. Una empresa de ventas a domicilio maneja 10 artículos diferentes y
cuenta con 50 vendedores. En un arreglo de 50x10 se tienen almacenadas
las cantidades de cada artículo vendidas por cada vendedor. Además, los
precios de cada artículo están almacenados en un vector de tamaño 10.
Se desea elaborar un algoritmo para imprimir lo siguiente :
• La cantidad de dinero recopilado por cada vendedor.
• El número del vendedor que recopiló la mayor cantidad de dinero.
• El número del artículo más vendido (entre todos los vendedores).

128
 • El total de vendedores que no vendieron ningún artículo número ocho.

16. Elabore un programa y que lea una matriz cuadrada de tamaño N de

números enteros, calcule la suma de los elementos de las diagonales
(principal e inversa y guarde estos elementos en dos vectores (DP y DI).

Ejemplo para N=4 :

Suma DP = 20 Suma DI = 23

17. Elabore un programa que lea los datos de una matriz cuadrada de tamaño
N y realice las siguientes operaciones:
• Imprima la suma de los elementos de la diagonal principal
• Imprima cuántos "0" hay en la matriz
• Imprima una matriz igual pero con las diagonales intercambiadas.
• Imprima el número mayor de la matriz
18. Elabore un programa que lea los datos de una matriz cuadrada de tamaño
N, y que intercambie los elementos de la matriz triangular superior con
los elementos correspondientes simétricamente de la matriz triangular
inferior.
EJEMPLO : RESULTADO :

19. Dada una matriz cuadrada de tamaño N, encuentre la suma de todos los
elementos que no son de la "periferia" de la matriz.

20. Se tienen los costos de producción de tres departamentos (dulces,

bebidas y conservas), correspondientes a los 12 meses del año anterior.

129
Elaborar un algoritmo que pueda proporcionar la siguiente información:
a) ¿En que mes (número) se registró el mayor costo de producción de dulces?
b) Promedio anual de los costos de producción de bebidas.
c) ¿En que mes se registró el menor costo de producción de bebidas?
d) ¿Cuál fue el departamento que tuvo el menor costo de producción en Agosto?

21. Elaborar un programa para controlar las reservaciones y cancelaciones

de boletos para las funciones de una obra de teatro.
- El teatro cuenta con 300 asientos, 200 en la planta baja y 100 en la planta
alta.
- Los asientos están numerados del 1 al 200 en la planta baja y del 1 al 100
en la alta.
- Hay 2 funciones, a las 6 y a las 9 de la noche.

Se debe preguntar si se desea planta baja o alta, la función deseada y el número

de asiento deseado, y se debe imprimir el precio del boleto. Para las
cancelaciones, preguntar el nombre y la función.
22. Una línea aérea realiza 3 vuelos diarios a Europa, uno a París, uno a
Madrid y uno a Londres. Elabore un algoritmo que controle las
reservaciones y cancelaciones de lugares.
NOTAS:
- Cuando hay una reservación, se preguntará el No. de vuelo ( 1 París , 2
Madrid , 3 Londres ), el nombre de la persona, y si desea sección de fumar
o de no fumar.
- Cuando hay una cancelación, se preguntará el nombre de la persona y el
No. de vuelo.
- Cada vuelo tiene 100 asientos. Del 1 al 50 es la sección de no fumar, y
del 51 al 100 es la sección de fumar.
- Se asignará el primer asiento que se encuentre desocupado en la sección
deseada del vuelo correspondiente.

130
 23. La Dirección General de Institutos Tecnológicos desea conocer una serie
de datos estadísticos referentes a la cantidad de Ingenieros, Masters y
Doctores que laboran en el sistema de tecnológicos. Entre otros datos se
desea saber:
a) Total de Doctores, Masters e Ingenieros por zona.
b) Sueldo promedio de un Dr. en el sistema de tecnológicos.
c) Total de Doctores en el tecnológico de Nuevo Laredo.
d) Total de Ingenieros con plaza #3 en la zona centro.
e) El monto total de los sueldos en los tecnológicos de la zona norte.
Suponga que se cuenta con 2 matrices con los siguientes datos:

NOTAS:
- La clave de empleado puede ser 1,2 o 3. (DR., MC., ING.)
- Las zonas son norte, centro y sur.
- Son 60 tecnológicos
- Existen 3 plazas (1,2,3) por cada clave de emp.

131
Direcciones de apoyo

https://www.youtube.com/watch?v=X5Wkp1gsNik
http://algoritmoscolegio40.blogspot.com/2012/09/operadores-y-funciones-de-
pseint.html
https://www.youtube.com/watch?v=wLIpOXrBpVQ
https://desarrolloweb.com/articulos/499.php
https://www.campusmvp.es/recursos/post/los-conceptos-fundamentales-
sobre-programacionorientada-objetos-explicados-de-manera-simple.aspx
http://pseint.sourceforge.net/?page=descargas.php
https://www.jdoodle.com/compile-c-sharp-online/
https://www.scilab.org/download/6.1.0
https://www.youtube.com/watch?v=mENHDQ8SLsI&list=PLyvsggKtwbLW1j0d
5yaCkRF9Axpdlhsxz
https://www.programiz.com/python-programming/online-compiler/
https://www.online-python.com/
https://entrenamiento-python-
basico.readthedocs.io/es/latest/leccion4/index.html
https://controlautomaticoeducacion.com/python-desde-cero/ciclo-for-en-
python/
https://docs.python.org/es/3/tutorial/
https://entrenamiento-python-
basico.readthedocs.io/es/latest/leccion3/tipo_listas.html
https://www.python.org/downloads/
https://www.youtube.com/watch?v=F9eM_VoKGJQ
https://www.youtube.com/watch?v=TyH98C-5fcY
https://www.youtube.com/watch?v=1Ro0kF4yxjY

132