Estructuras básicas_ conceptos básicos de programación.pdf

CONCEPTOS BÁSICOS DE LA
PROGRAMACIÓN

CONCEPTOS BÁSICOS DE LA PROGRAMACIÓN
ANA SOFÍA ERAZO C.
LINDA MARIANA FLOREZ L.
SARA ISABEL LUNA C.
ÁNGELA SOFÍA OSPINA G.
ANA SOFÍA PENAGOS M.
SAARY SOPHIE ROJAS
TECNOLOGÍA E INFORMÁTICA
GUILLERMO MONDRAGON
16 de junio del 2025

1
ÍNDICE
CONSTANTES VARIABLES..................................................................................................................... 2
EJEMPLO:...............................................................................................................................................2
ACUMULADORES..................................................................................................................................... 3
CARACTERÍSTICAS DE UN ACUMULADOR..................................................................................3
EJEMPLO................................................................................................................................................4
APLICACIONES COMUNES................................................................................................................4
CONTADORES............................................................................................................................................5
EJEMPLOS DE USO:.............................................................................................................................6
CARACTERÍSTICAS.............................................................................................................................7
DIFERENCIA ENTRE CONTADOR Y ACUMULADOR:..................................................................7
IDENTIFICADORES..................................................................................................................................8
TIPOS DE IDENTIFICADORES Y CUANDO SE UTILIZA CADA UNO.........................................8
RECOMENDACIONES......................................................................................................................... 9
FUNDAMENTOS PROGRAMACION PSEINT......................................................................................9
FUNDAMENTOS..................................................................................................................................9
ENTRADA Y SALIDA....................................................................................................................9
OPERADORES:............................................................................................................................. 10
ESTRUCTURA:............................................................................................................................. 10
CUERPO DEL ALGORITMO:......................................................................................................10
EJEMPLO..............................................................................................................................................10
MAPA CONCEPTUAL............................................................................................................................. 11
¿QUÉ HABILIDADES DE TRABAJO EN EQUIPO PUSIERON EN PRÁCTICA DURANTE LA
ACTIVIDAD?.............................................................................................................................................12
¿QUÉ PODRÍAN MEJORAR COMO GRUPO EN UNA PRÓXIMA ACTIVIDAD SIMILAR?... 12
CONCLUSIONES......................................................................................................................................12
EVIDENCIAS.............................................................................................................................................15
BLOGS........................................................................................................................................................18
REFERENCIAS......................................................................................................................................... 19

2
CONSTANTES VARIABLES
En programación las constantes variables son elementos de datos que se declaran con un nombre y un
valor definido, y ese valor no puede ser cambiado durante la ejecución del programa, es decir que su
contenido es fijo una vez que se inicializan.
Este tipo de constante se declara con la palabra clave const, y es muy útil cuando se quiere asegurar que
un valor importante permanezca sin cambios, evitando errores y haciendo que el código sea más confiable
y fácil de entender.
fig. 1
EJEMPLO:
const int EDAD_MINIMA = 18
Aquí EDAD_MINIMA es una constante variable
Tiene tipo (int) y nombre, así como una variable, pero al tener const, no se puede modificar su valor.
las constantes variables se necesitan para:
proteger datos importantes, como una tasa fija, un valor estándar o un límite.
para escribir un código más claro y seguro
y para evitar errores por cambios accidentales de valores importantes.

3
ACUMULADORES
Un acumulador es una variable que se utiliza para almacenar y actualizar progresivamente un valor
durante la ejecución de un programa, en otras palabras, un acumulador es una variable especial que es
usada para guardar un resultado que va cambiando a lo largo del tiempo, especialmente cuando se repite
mucho una acción, como un bucle. Su función principal es acumular resultados de operaciones sucesivas
como sumas, promedios o concatenaciones.
fig. 2
Por ejemplo, si se quiere sumar todos los números de una lista, se necesita un lugar donde guardar ese
total. Ahí es donde se usan los acumuladores.
CARACTERÍSTICAS DE UN ACUMULADOR
1. Iniciación: Se da un valor inicial, normalmente es el 0 para sumas o 1 para productos.
2. Actualización: En cada repetición, el acumulador se actualiza con un nuevo valor, que puede ser
una suma, resta u otra operación.
3. Uso de bucles: Se usa en estructuras repetitivas para procesar listas de datos o realizar cálculos
acumulativos.

4
EJEMPLO
Suponga que quiere calcular la suma de una lista de números:
numeros = [10, 20, 30, 40, 50]
acumulador = 0
for num in numeros:
acumulador += num
print("La suma total es:", acumulador)
En este ejemplo, el acumulador comienza en 0 y se irá actualizando con la suma de cada número en la
lista. Al finalizar el bucle, el acumulador contendrá el valor total de la suma.
APLICACIONES COMUNES
1. Cálculos financieros: Para llevar la cuenta de ingresos en una cuenta bancaria.
2. Análisis de datos: Para calcular promedios, totales acumulados o realizar estadísticas.
3. Procesamiento de listas: Para sumar o contar elementos de una lista o conjunto de datos.

5
CONTADORES
fig. 3
En programación, un contador es una variable utilizada para mantener un registro de una cantidad
específica, normalmente incrementando su valor en una unidad fija cada vez que ocurre un evento o se
ejecuta un ciclo. Sirve para contar el número de repeticiones de un bucle o para realizar un seguimiento de
eventos en un programa. La forma general de los contadores es la siguiente:
Contador=contador + <valor constante>
Como el contador aparece al lado derecho de la expresión, antes de usarse se le debe dar un valor que
borre lo que había en la dirección de memoria asignada a la variable utilizada. Esa orden de borrados debe
indicarse una vez; por lo tanto, debe de estar antes de activar el ciclo donde se necesita el contador, de lo
contrario se repetirá la orden de ahorrado cada vez que se repite el ciclo. Ejemplo:
Una orden de borrado puede ser: CONTADOR=0

6
EJEMPLOS DE USO:
1. Contar la repeticiones de un bucle:
// En C++
int contador = 0;
for (int i = 0; i < 5; i++) {
contador++; // Incrementa el contador en cada iteración del bucle
// ... código a ejecutar ...
}
cout << "El bucle se ejecutó " << contador << " veces." << endl;
En este ejemplo, el contador se inicializa a 0 y se incrementa en 1 en cada vuelta del bucle for, mostrando
al final cuántas veces se ejecuta el bucle.
2. Contar eventos específicos:
// En Java
int contador_clicks = 0;
// ... código para manejar clics de un botón ...
if (boton.fueClicado()) {
contador_clicks++;
}
// ... Mostrar el número de clics …
El contador contador_clicks se usa para registrar el número de veces que se ha hecho clic en un botón
específico, mostrando el valor en el código.
3. Contar el número de elementos de un arreglo:
# En Python
lista = [10, 20, 30, 40, 50]
contador_elementos = 0
for elemento in lista:

7
contador_elementos += 1
print(f"El arreglo tiene {contador_elementos} elementos.")
Aquí, el contador contador_elementos se incrementa por cada elemento del arreglo, permitiendo contar
cuántos elementos contiene.
CARACTERÍSTICAS
● Variable entera:
Los contadores suelen ser variables enteras, ya que representan números de objetos o eventos, los cuales
deben ser enteros.
● Valor inicial:
Un contador generalmente se inicializa a un valor, comúnmente cero, antes de empezar a contar.
● Incremento o decremento constante:
El valor del contador se modifica agregando o restando un valor constante a su valor anterior. Este valor
constante suele ser 1, pero puede ser cualquier otro número entero.
● Uso en bucles:
Los contadores se utilizan frecuentemente en bucles para controlar el número de iteraciones. Por ejemplo,
un bucle puede continuar ejecutándose mientras el valor del contador sea menor que un cierto número.
● Uso en eventos:
También pueden utilizarse para contar eventos, como el número de veces que se ha llamado a una
función.
DIFERENCIA ENTRE CONTADOR Y ACUMULADOR:
Es importante diferenciar un contador de un acumulador. A diferencia de los contadores, que incrementan
en pasos fijos (normalmente de 1 en 1), los acumuladores pueden hacer operaciones con valores variables.

8
IDENTIFICADORES
Son un concepto fundamental de la programación, se utilizan para nombrar variables, funciones, clases y
otras entidades de programación. Su principal función es proporcionar una forma única y legible para
referirse a estos elementos dentro del programa. Para nombrar los identificadores, se deben seguir
diferentes reglas y convenciones de nomenclaturas.
TIPOS DE IDENTIFICADORES Y CUANDO SE UTILIZA CADA UNO
- Identificadores de Variable: Se utilizan para dar nombres a las variables en un programa. Estos
nombres deben seguir ciertas reglas, como comenzar con una letra o guión bajo, y pueden
contener letra números y otros guiones bajos. Es importante elegir nombres significativos y
descriptivos para nuestras variables de modo que sea legible y comprensible.
- Identificadores de Constantes: Estos se utilizan para dar nombres o valores que no van a
cambiar durante la ejecución del programa. Siguen las mismas reglas que los identificadores de
variables pero generalmente se escriben con mayúsculas para que se puedan distinguir.
- Identificadores de Función: Se utilizan para nombrar funciones en un programa. Estos nombres
siguen las reglas de los identificadores de variables pero generalmente se escoge un nombre
descriptivo para indicar la funcionalidad de la función Ej. int calcularsuma(int a, int b) [...]
En este caso “calcularsuma” es el identificador de la función y nos indica que su propósito es calcular la
suma de dos números enteros.
- Identificadores de clase: Se utilizan para nombrar las clases en programación orientada a
objetos. Estos nombres siguen las mismas características que los identificadores de variables,
pero generalmente se utiliza la primera letra en mayúscula.
- Identificadores de etiqueta: Se utilizan en lenguajes de marcado, como HTML, para crear
referencias a elementos específicos. Estos nombres siguen las mismas características que los
identificadores de variables, pero generalmente se elige un nombre descriptivo para identificar la
función del elemento al que hace referencia.

9
RECOMENDACIONES
Algunas recomendaciones para seguir buenas prácticas al nombrar identificadores son:
- Utilizar palabras completas y descriptivas en lugar de abreviaciones y acrónimos confusos.
- Evitar nombres demasiado largos o complicados, que puedan dificultar la legibilidad del código.
- Usar una combinación de minúsculas y mayúsculas para mejorar la legibilidad.
- Elegir nombres que reflejan claramente el propósito o función del elemento nombrado
FUNDAMENTOS PROGRAMACION PSEINT
PSeInt es una herramienta educativa diseñada para ayudar a los estudiantes a aprender los fundamentos de
la programación, ayuda en sus primeros pasos en este mundo de la programación. Utiliza un
pseudolenguaje sencillo y comprensible lo que facilita la comprensión de los conceptos básicos antes de
pasar a lenguajes de programación más complejos.
FUNDAMENTOS
Algoritmos: Un algoritmo es una secuencia de pasos lógicos y ordenados para resolver un problema
específico. En PSeInt, cada programa es un algoritmo, estos algoritmos tienen unas características: cada
paso debe ser claro y sin ambigüedades, si se sigue el mismo algoritmo varias veces con los mismos
datos, debe producir el mismo resultado, debe tener un número limitado de pasos.
conceptos clave: VARIABLES (Se usan para almacenar datos) pueden ser tipo:
ENTERO: Números enteros.
REAL: Números con decimales.
CADENA: Texto.
CARÁCTER: Un solo carácter.
LÓGICO: verdadero o falso
ENTRADA Y SALIDA
ENTRADA: ¨¨leer´¨ permite que el usuario ingrese datos

10
SALIDA; ¨¨escribir´¨ muestra resultados en pantalla.
OPERADORES:
Aritméticos: +, -, *, /, ^
Relacionales: =, <>, <, >, <=, >=
Lógicos: Y, O, NO
ESTRUCTURA:
Cabecera:
Algoritmo <nombre_del_algoritmo>: (Define el nombre del programa)
Declaración de Variables:
Definir <variable1>, <variable2> Como <tipo_de_dato>: (Especifica las variables)
CUERPO DEL ALGORITMO:
Inicio: (Marca el comienzo del program)
Sentencias: (Instrucciones que se ejecutan secuencialmente)
FinAlgoritmo: (Marca el final del programa)
EJEMPLO
pseudocódigo
Algoritmo SumaDosNumeros
Definir num1, num2, suma Como Real
Escribir "Ingrese el primer número:"

11
Leer num1
Escribir "Ingrese el segundo número:"
Leer num2
suma <- num1 + num2
Escribir "La suma es: ", suma
FinAlgoritmo
MAPA CONCEPTUAL
fig. 4

12
¿QUÉ HABILIDADES DE TRABAJO EN EQUIPO PUSIERON EN PRÁCTICA DURANTE LA
ACTIVIDAD?
Durante la actividad, trabajamos en equipo y usamos varias habilidades importantes. Primero, nos
organizamos para repartir las tareas de manera justa. También hablamos constantemente entre nosotros
para asegurarnos de que todos entendieran bien los temas y que la información fuera clara y correcta.
Cada uno fue responsable de hacer su parte y revisar lo que hicieron los demás para que el trabajo final
quedara bien hecho. Además, tomamos decisiones juntos, como cómo organizar el documento, lo que
hizo que el trabajo fuera más completo y variado.
¿QUÉ PODRÍAN MEJORAR COMO GRUPO EN UNA PRÓXIMA ACTIVIDAD SIMILAR?
Para la próxima actividad, podríamos organizar mejor nuestro tiempo. Aunque terminamos el trabajo,
sería bueno planear mejor cada parte para no andar con prisas al final. También podríamos revisar con
más cuidado el trabajo final para encontrar y corregir errores. Otra cosa que podemos mejorar es asignar
roles más claros desde el principio para trabajar de forma más ordenada y eficiente.
CONCLUSIONES
ANA SOFÍA ERAZO C:
En la programación con PSeInt, las constantes son valores fijos que no cambian durante la ejecución del
programa, mientras que las variables almacenan datos que pueden modificarse. Los acumuladores son
variables que incrementan su valor sumando o concatenando valores, y los contadores son variables que
aumentan o disminuyen en una cantidad fija (generalmente 1) para llevar un registro de eventos. Los
identificadores son los nombres que se asignan a variables, constantes, funciones y otros elementos del
programa, permitiendo diferenciarlos de manera única. Todos estos elementos son fundamentales para
construir algoritmos y programas estructurados en PSeInt

13
LINDA MARIANA FLOREZ L:
Aprendí que los conceptos básicos de programación son super importantes porque me ayudan a entender
cómo funcionan las aplicaciones, los juegos y muchas cosas que usamos todos los días. Cosas como las
variables, los tipos de datos o los condicionales pueden sonar raras al principio, pero en realidad son
herramientas que me permiten decirle a la computadora qué hacer. Además, la programación no solo me
enseña a usar la tecnología, también me ayuda a pensar mejor, resolver problemas y a ser más creativa.
SARA ISABEL LUNA C:
Aprendí varios conceptos importantes de programación como los acumuladores, contadores, constantes e
identificadores, además de cómo usar PSeInt y entender mejor los algoritmos. También entendí lo valioso
que es organizarse bien en grupo, repartir tareas y comunicarse para que todo salga bien. Aprendí de este
trabajo en grupo a trabajar mejor con mis compañeras, a expresarme con más claridad y a comprender
temas que antes se me dificultaron.
ÁNGELA SOFÍA OSPINA G:
Fue un trabajo muy interesante, ya que a través de este conocí muchos conceptos nuevos, como el uso de
los identificadores, y que cuando hablamos de nombrar un programa, hay que utilizar nombre conciso,
este a su vez debe ayudarnos a identificar la función del programa. Además de aprender a que es y cómo
se utiliza el PSeInt, todo esto ayudándonos a escribir y comprender de mejor manera los programas.
ANA SOFÍA PENAGOS M:
Fue un trabajo didáctico, cada una apartó su parte para formar algo bien elaborado, además de aprender de
los conceptos investigados que pronto nos servirán para futuros trabajos.
SAARY SOPHIE ROJAS:
En esta actividad aprendimos conceptos básicos pero muy importantes de programación, como el uso de
constantes, que son valores que no cambian; acumuladores, que sirven para sumar o guardar resultados; y
contadores, que se usan para contar repeticiones o eventos. También entendimos qué son los
identificadores, que son los nombres que damos a variables, funciones o clases, y cómo escribirlos
correctamente. Además, conocimos PSeInt, una herramienta útil para empezar a programar usando

14
pseudocódigo, con ideas como algoritmos, variables, operadores y estructuras básicas. Todo esto nos
ayuda a escribir un código más claro, organizado y funcional.

18
BLOGS
● Rojas Saary: https://tecnorojass.blogspot.com/
● Erazo Ana: https://tecnoin123456789.blogspot.com/
● Luna Sara: https://01022207102223.blogspot.com/
● Ospina Angela: https://angelasofiaospina.blogspot.com/?m=1
● Penagos Ana: CRIME TECHNOLOGY
(https://theratsinthehouseofthedead.blogspot.com/ )
● Flórez Linda: https://lindafloleal.blogspot.com/

19
REFERENCIAS
Arana Flores, V. (2023, septiembre 18). Introducción a la Programación con Pseint: Conceptos Básicos.
Coders Free.
https://codersfree.com/posts/introduccion-a-la-programacion-con-pseint-conceptos-basicos
Busbee, K. L., & Braunschweig, D. (n.d.). Constants and Variables. Rebus COMMUNITY.
https://press.rebus.community/programmingfundamentals/chapter/constants-and-variables/
Constantes y variables. (2021, marzo 26). IBM.
https://www.ibm.com/docs/es/tcamfma/6.3.0?topic=tesl-constants-variables-4
Definición de Acumulador. (n.d.). carlospes.com.
https://www.carlospes.com/minidiccionario/acumulador.php
Definición de Variable Acumulador (en programación). (n.d.). carlospes.com.
https://www.carlospes.com/minidiccionario/variable_acumulador.php
Definición de Variable Contador. (n.d.). carlospes.com.
https://www.carlospes.com/minidiccionario/variable_contador.php
Del Rosario, E. (2015, julio 05). Contadores y Acumuladores en programación. WordPress.
https://blog.espol.edu.ec/ccpg1001/contadores-y-acumuladores/
García Santillán, I. (2014, diciembre 01). Fundamentos de programación usando PSEINT. Universidad
Politécnica Estatal del Carchi.
https://www.publicacionesupec.org/index.php/carchi/catalog/book/64
Identificador en programación: Todo lo que necesitas saber para diferenciar tu código. (n.d.). Guía
Experta.
https://guiaexperta.website/identificador-en-programacion-todo-lo-que-necesitas-saber-para-difer
enciar-tu-codigo/
Qué es un acumulador en programación: Función y uso en diversos lenguajes. (n.d.). JMJ
INFORMÁTICO. https://jmjinformatico.es/que-es-un-acumulador-en-programacion/

20
Tantaruna, G. (2014, Agosto 03). Estructuras de Control Repetitivas, Acumuladores y Contadores. ::
Programación para principiantes ::.
https://fisiprogramacion.wordpress.com/2014/08/03/basico-5-estructuras-de-control-repetitivas/
TecnoDigital. (2025, Febrero 12). Acumuladores en programación: qué son y cómo se usan. ITD.
https://informatecdigital.com/acumuladores-en-programacion/
Tutorial Fundamentos: Instalar y configurar PseInt y Python. (n.d.). CertiDevs.
https://certidevs.com/tutorial-fundamentos-programacion-introduccion-historia-proposito
Uso específico de variables: contadores, acumuladores e indicadores. (mayo, 25). Pledin 3.0.
https://plataforma.josedomingo.org/pledin/cursos/programacion/curso/u23/index.html

Estructuras básicas_ conceptos básicos de programación.pdf

Más contenido relacionado

Similar a Estructuras básicas_ conceptos básicos de programación.pdf (20)

Último (20)

Estructuras básicas_ conceptos básicos de programación.pdf