Introducción a la Programación

Introducción a
la
Programación
Teórica Parte 1

Juan Matias Novas

 Introducción a la Programación

Contenido
Algoritmos ................................................................................................................................................................3
¿Qué es un algoritmo? .........................................................................................................................................3
Teoría de Lenguaje Python ........................................................................................................................................5
Variables ...............................................................................................................................................................5
Estructuras básicas para la construcción de algoritmos ......................................................................................6
Estructuras secuenciales...................................................................................................................................6
Comentarios dentro del programa ................................................................................................................ 10
Estructuras de decisión.................................................................................................................................. 10
Decisión condicional o alternativa ................................................................................................................. 10
Condicionales alternativos ............................................................................................................................ 11
Condicionales anidados ................................................................................................................................. 14
Uso de conectores lógicos en la condición .................................................................................................... 18
Uso del and .................................................................................................................................................... 19
Uso del or....................................................................................................................................................... 20
Anexo función print ............................................................................................................................................... 22
Otra forma de imprimir en pantalla .................................................................................................................. 25
 Introducción a la Programación

Algoritmos
En esta materia vamos a diseñar programas para resolver problemas. Como bien hemos visto en el
apunte anterior existe toda una teoría sobre resolución de problemas. Aconsejamos leer el mismo
en caso de no haberlo hecho. Recordemos que los pasos a seguir para elaborar un programa son
los siguientes:

• Enunciación del problema: Formular el problema de forma clara, completa y concisa,

evitando ambigüedades.
• Diagramar la solución: Analizar el problema, identificar datos y resultados que se quieren
obtener, y pensar en los pasos necesarios para obtenerlos. (Diseñar un algoritmo)
• Codificación: Transcribir las instrucciones generadas por el algoritmo, utilizando algún
lenguaje de programación.
• Ejecución y validación del programa: probar que el programa funciona de la manera
que esperamos para distintos conjuntos de datos.

En este módulo nos centraremos en el análisis del problema y el diseño del algoritmo que lo
resuelva.

¿Qué es un algoritmo?
Un algoritmo es una secuencia ordenada y finita de pasos tal que su ejecución resuelve un
determinado problema o n grupo de problemas.
La palabra algoritmo viene de Al-Khwarizmi, sobrenombre del matemático árabe del siglo IX,
Mohámed ben Musa, que alcanzó gran reputación al enunciar paso a paso las reglas parasumar,
restar, multiplicar y dividir números con decimales.

Página 3 de 27
 Introducción a la Programación

La vida cotidiana está llena de soluciones algorítmicas, algunas de ellas son tan comunes que no se
requiere pensar en los pasos que incluye la solución. La mayoría de las actividadesque se realizan
diariamente están compuestas por tareas más simples que se ejecutan en un orden determinado,
lo cual genera un algoritmo. Desde los primeros años de escolaridadse trabaja con algoritmos, en
especial en el campo de las matemáticas, como los métodos utilizados para sumar, restar,
multiplicar y dividir.
Las características fundamentales que debe tener todo algoritmo son:

• Debe ser preciso, es decir, indicar el orden de realización de cada paso.

• Debe estar definido, esto es, si se ejecuta varias veces partiendo de las mismas
condiciones iniciales debe obtenerse siempre el mismo resultado.
• Debe ser finito (debe tener un número finito de pasos).
• Debe ser eficiente, o sea que debe emplear la menor cantidad de pasos posibles
para resolver el problema

El primer paso en el diseño de un algoritmo es conocer la temática a tratar, el segundo será pensar
en las actividades a realizar (instrucciones ) y el orden en que deben ejecutarse para lograr el
objetivo, y el tercero y no menos importante es la presentación formal.
Por ejemplo, para obtener dinero de un cajero automático, los pasos a seguir son:

1. Introducir la tarjeta de débito en el cajero.

2. Ingresar la clave.
3. Elegir del menú la operación que desea realizar
4. Ingresar el monto de dinero a extraer.
5. Retirar el dinero
6. Retirar el comprobante de la operación.
7. Seleccionar la opción Finalizar.
8. Retirar la tarjeta de débito.

Otro ejemplo de un algoritmo en la vida cotidiana puede ser el de los pasos para armar un
juguete o una receta de cocina…

Pero si pensamos en problemas que podemos resolver con una computadora, debemos ser más
formales en la especificación de los pasos del algoritmo. Por ejemplo, si queremos hallar la suma
de dos números, los pasos a seguir son:
• Paso 1. Saber de qué números se trata.
• Paso 2. Calcular la suma de los mismos.
• Paso 3. Mostrar la suma de los números.

Página 4 de 27
 Introducción a la Programación

En cuanto a la representación de algoritmos, existen varias técnicas. Las más conocidas son
diagramas de flujo, pseudocódigo y diagramas Nassi – Schneiderman o de Chapin. Estos diagramas
facilitan la visualización del problema planteado. En esta materia no nos dedicaremos al
aprendizaje de la programación mediante diagramas sino implementado nuestros algoritmos en
un lenguaje de programación.

Teoría de Lenguaje Python

Python es un lenguaje de programación poderoso y fácil de aprender. Puede ser clasificado como un
lenguaje interpretado (ejecuta las instrucciones a medida que las va leyendo) y de alto nivel. Python
fue creado a finales de los años 80, por un programador holandés llamado Guido van Rossum, quien
sigue siendo aún hoy el líder del desarrollo del lenguaje.
Como todo lenguaje tiene una sintaxis y semántica, la sintaxis de Python es muy sencilla y cercana al
lenguaje natural. Por este motivo se trata de uno de los mejores lenguajes para comenzar a programar.

Variables
Una variable es una posición de memoria donde se puede almacenar un valor.

Las variables pueden ser de tipo entero (int), real (float), cadena de caracteres (string) o booleano
(bool)
Los nombres de las variables pueden ser cadenas de 1 a 32 letras y/o dígitos. Se acepta el guion bajo
en los nombres (nom_1), pero el nombre de la variable no puede comenzar con un número. Además,
debemos tener en cuenta que en Python se consideran como distintaslas letras en minúsculas y en
mayúsculas. Por ejemplo, la variable contc es distinta a la variable contC.
Debemos tener en cuenta también que no se pueden usar palabras reservadas del lenguaje como
nombres de variables. Python tiene 28 palabras reservadas, que son las siguientes:
and – continue – else – for – import – not – raise – assert – def – except – from – in – or – return –
break – del – exec – global – is – pass – try – class – elif – finally – if – lambda – print
- while

Según el tipo con el que se defina la variable, ocupará determinado espacio en la [Link] definición
de la variable se puede realizar en la instrucción que permite leer su valor o bien cuando le asignamos
un valor (según el tipo de valor que le asignemos será el tipo que quede definida la variable). La
asignación la realizamos con el signo “=”.

Por ejemplo, num = 15 (la variable num queda definida de tipo entero)

Página 5 de 27
 Introducción a la Programación
Asimismo, una variable queda definida de tipo real si se le asigna un número con coma
decimal. La parte entera de dicho número está formada por los dígitos ubicados a la izquierda de la
coma, mientras que los dígitos de la derecha constituyen la parte decimal.

En Python la coma decimal es el carácter ‘.’.

real = 0.2703

También se puede utilizar notación científica, y añadir una e (de exponente) para indicar unexponente
en base 10. Por ejemplo:
real = 0.1e-3 sería equivalente a 0.1 x 10-3 = 0.1 x 0.001 = 0.0001

Estructuras básicas para la construcción de algoritmos

Estructuras secuenciales

Son aquellas que se ejecutan una después de otra. Son ejemplos de estructuras secuenciales:
• La instrucción de lectura: se utiliza para recibir un dato desde un dispositivo de entrada
(generalmente el teclado) y almacenarlo en un espacio de memoria.
• La asignación (representada por el signo “=”). Se utiliza para guardar un valor o una
expresión en un espacio de memoria llamado variable. Las variables poseen un nombre
definido por el programador.
VARIABLE = EXPRESIÓN

La asignación es de derecha a izquierda

• La instrucción de mostrar: permite enviar información desde la memoria hacia un

dispositivo de salida como la pantalla o la impresora.
En Python, las estructuras secuenciales se representan como acciones se escriben en un renglón
debajo de otro

Supongamos el siguiente ejemplo: Diseñar un algoritmo para calcular el área y el perímetro de un

rectángulo conociendo las medidas de sus lados.
Datos de entrada: medida de los lados: base y altura Variables
Proceso:
Cálculo del área área = base* altura

Cálculo perímetro perímetro = 2 * (base + altura)

Salida:
Mostrar los resultados obtenidos área y perímetro

Página 6 de 27
 Introducción a la Programación

Nota: área y perímetro son variables en las que se almacena el resultado de las operaciones
planteadas a la derecha del igual. el int es para decir que puedo poner cualquier entero. El
input(" ") se usa para escribir texto. El print se usa para
Código en Python de la resolución del problema planteado: para imprimir las variables que definimos que sean
necesarias para resolver el resultado

Como bien observamos cada línea es una sentencia que le indicamos al compilar que interprete.
En las líneas 1 y 2 mediante la función input le pedimos al programa que le solicite al usuario un dato.

La función input, es nuestra sentencia que nos permitirá ingresar datos desde el teclado. Entre los
paréntesis y encerrado entre comillas dobles se escribe el texto que se desea mostrar al usuario. Esta
función por defecto convierte todo lo ingresado por teclado en formato texto (string). Es por eso que
la función input se encuentra entre paréntesis y delante de los mismos la palabra int, lo que se realiza
mediante la función int es convertir el texto ingresado en un valor de tipo entero. Luego ese valor
convertido es asignado en las variables base y altura.

Una vez ingresados los datos se realizan los cálculos del perímetro (línea 3) y del área (línea 4).

Por ultimo en las líneas 5 y 6 se pide al compilador que muestre los datos por pantalla. Para ello
utilizaremos la función print.

La función print nos permite informar mediante mensajes en la consola al usuario resultados de
cálculos, o tan solo informar situaciones que suceden a lo largo del programa. La función print muestra
por pantalla todo lo que se escriba dentro de las comillas dobles, por ejemplo:

En este caso si ejecutamos esta única sentencia visualizaremos por consola el siguiente mensaje:

Página 7 de 27
 Introducción a la Programación

Volviendo el ejemplo del cálculo del área y del perímetro, observaremos que las sentencias print
además de mostrar un literal (texto a visualizar), hay un nombre de variable separado por una ‘, ‘. En
este caso lo que se está indicando al compilador es que además del mensaje muestra el valor de cada
variable.

A continuación, se muestra la ejecución del código:

Como bien hemos observado en el ejemplo las sentencias que se ejecutan pueden tener
operaciones matemáticas, veamos a continuación cuales son los operadores matemáticos en
Python y sus significados y utilización

Operador Descripción Ejemplo

+ Suma r=3+2 # r es 5
- Resta r=4-7 # r es -3
* Multiplicación r=2*6 # r es 12
** Exponente r = 2 ** 6 # r es 64
/ División r = 3.5 / 2 # r es 1.75
// División entera r = 3.5 // 2 # r es 1.0
% Módulo (resto de la división entera) r=7%2 # r es 1

Como bien hemos comentado, en Python el operador de asignación es un único signo = (igual).

Una asignación significa que la variable que se encuentra a la izquierda del = toma el valorque contiene
la variable de la derecha.

Si a la derecha hay un operando o más, primero se resuelve esa expresión y luego se asigna.

Ejemplo: variable_1 = variable_2

 x=y la variable x toma el valor que contiene la variable y

Ejemplo: variable1 = variable2 operador variable3

 x=y+z la variable x toma el valor de la suma entre el contenido de y y el de z

Página 8 de 27
 Introducción a la Programación

Python, como otros lenguajes, permite un formato abreviado en los casos en los que una variable
aparezca a la izquierda y a la derecha del igual: variable1 = variable1 operador expresión

Se puede abreviar por: variable1 operador = expresión

Ejemplo: x = x +10 se puede escribir x + = 10

El contenido de la variable x es reemplazado por el valor que contenía más diez

 y=y*z se puede escribir y * = z

El contenido de la variable y es reemplazado por el valor que contenía multiplicado por 10.

IMPORTANTE: Las variables se deben inicializar, según corresponda, antes de realizar la operación.

Veamos otro ejemplo, supongamos el siguiente enunciado: Ingresar un importe de dinero en pesos
y mostrar su equivalente en dólares y euros, considerando la cotización del día
Datos de entrada:
Importe en pesos: pesos
Cotización del dólar: dólar Variables
Cotización del Euro: euro
Proceso:
Cálculo del equivalente en dólares dólares = pesos/dólar
Cálculo del equivalente en euros euros = pesos/euro

Salida:
Mostrar los resultados obtenidos dólares y euros

Página 9 de 27
 Introducción a la Programación

Comentarios dentro del programa

En el programa se puede indicar o agregar una línea como comentario. Esto es útil para documentar
los programas, explicar el funcionamiento de una parte en particular y mejorar la legibilidad de los
mismos.
 Si el comentario ocupa solo una línea, se coloca al comenzar el mismo el símbolo denumeral
(#). Si el comentario tiene más de una línea, se escribe todo el texto entre tres comillas dobles
(“““comentario”””).
 Los comentarios en la misma línea deben separarse con dos espacios en blanco y después del
símbolo # también hay que dejar un espacio en blanco.

Estructuras de decisión

Las estructuras de decisión permiten controlar la ejecución de ciertas acciones, según se cumpla o
no cierta condición. La condición es evaluada para el valor que toma la olas variables que la forman,
en el momento en que ésta se ejecuta. Dicho de otro modo, las estructuras de decisión son aquellas
que nos permiten "preguntar" sobre el valor de una o más variables, pudiendo así actuar según la
respuesta obtenida . Estas respuestas siempre serán Verdaderas o Falsas, pudiendo tomar de esta
manera dos caminos diferentes.

Decisión condicional o alternativa

Si expresion_logica Entonces
acciones_por_verdadero
Sino
acciones_por_falso
Fin Si

Página 10 de 27
 Introducción a la Programación

La decisión es condicional si sólo se ejecuta una acción por la condición verdadera, en cambio es
alternativa si se ejecutan ciertas acciones cuando la condición es verdadera y otras cuando la
condición es falsa. La decisión condicional en Python está identificada por la palabra reservada IF

La forma más simple de un condicional es un if (del inglés si) seguido de la condición a evaluar y dos
puntos (:) al final de la línea. En las siguientes líneas e indentado, se escribe el código a ejecutar en caso
de que dicha condición sea verdadera. Este bloque de instrucciones a ejecutar con la condición
verdadera finaliza con la siguiente instrucción sin indentar.

if condición:
sentencia 1 Bloque de instrucciones a ejecutar si la
sentencia 2 condición es verdadera

…..
instrucción fuera del if

Ejemplo:

NOTA: Siempre tiene que haber una instrucción a ejecutar cuando la condición resultaVERDADERA.

En este caso, solo se mostrará el mensaje por consola en caso que el número ingresado por teclado
sea mayor a 10

Condicionales alternativos
Otra forma de la estructura de decisión if es la ejecución alternativa, en la que hay dosposibilidades
y la condición determina cuál de las dos se ejecuta. La sintaxis en este caso es:
if condición:
sentencia 1
Ejecuta si la condición es verdadera
sentencia 2
else:
sentencia3 Ejecuta si la condición es falsa

Página 11 de 27
 Introducción a la Programación

Si se debe ejecutar alguna acción cuando la condición es falsa, esta debe estar precedida por la palabra
else: a la altura del if al que se asocia.

Como vimos antes, el else es opcional, o sea que no tiene que colocarse en el caso que no haya que
ejecutar ninguna sentencia cuando la condición es falsa.

Supongamos el siguiente ejemplo: ingresar un número distinto de cero y decir si es par o impar.

Para poder determinar que un número es par o no lo que debemos hacer es dividir el número por dos
y ver su resto, si el mismo es cero entonces el número es par sino es impar.

Como bien se observa en el código en la línea 2 se realiza la consulta si el resto de dividir el número
ingresado por 2 es igual a cero. En estas condiciones que se verifican en los condicionales siempre se
determina su valor de verdadero o falso a través de una comparación.
Para realizar las comparaciones utilizamos los operadores relacionales, estos son símbolos que se usan
para comparar dos valores. Si el resultado de la comparación es correcto, la expresión considerada es
verdadera, en caso contrario es falsa.

Estos operadores son utilizados a nivel matemáticas, por ejemplo:

5 < 18 → la expresión es VERDADERA

4 < 2 → la expresión en FALSA

A continuación, se visualiza una tabla con los símbolos de los operadores relacionales que se utilizan
en Python y sus significados:

Página 12 de 27
 Introducción a la Programación

Operador Nombre Ejemplo Significado

< menor que a<b a es menor que b

> mayor que a>b a es mayor que b

== igual a a == b a es igual a b

!= no igual a a != b a no es igual a b

<= menor que o igual a a <= 5 a es menor o igual a b

>= mayor que o igual a a >= b a es mayor o igual a b

A continuación, vemos los resultados que se emiten por consola a partir del código presentado en el
ejemplo;

Veamos un nuevo ejemplo, supongamos el siguiente enunciado: Se desea desarrollar un algoritmo que muestre
el valor absoluto de un número.

Datos de entrada:
Número que se ingresa: nro variable

Proceso:

Analizar el signo del número. nro < 0

Si es VERDADERO (número negativo) multiplicarlo por -1 y guardar en abs nro.

Si es FALSO (número positivo o cero), guardar nro en abs

Página 13 de 27
 Introducción a la Programación

Información de salida:

Mostrar el valor absoluto del número absnum

Condicionales anidados

Se llaman condicionales anidados a un condicional que adentro de alguna de sus partes tiene otra
condición dentro de él. Supongamos el siguiente enunciado: Ingresar un número y determina si el
mismo es positivo, negativo o neutro.
Veamos a continuación la resolución de este problema y su explicación:

Página 14 de 27
 Introducción a la Programación

Como observamos el código tiene dos condicionales uno en la línea 2 y que tiene un bloque else en la
línea 4. En este bloque se determina si el número es negativo, en caso de serlo se mostrará por consola
el mensaje correspondiente.

En caso que numero no fue negativo ejecutara el código que se encuentre dentro del bloque else de la
línea 4. Esto implica entonces que el número leído puede ser > 0 o =0 , por lo tanto el condicional de la
línea 5 vuelve a preguntar con un condicional si el numero ingresado es mayor que cero, de ser asi
imprime por consola el mensaje correspondiente. En caso de no ser >0 y <0 por descarte se infiere que
el número es = 0, imprimiendo por el else de la línea 8 el mensaje que el número es neutro.

Es importante darse cuenta que las estructuras condicionales las podemos anidar, o poner unas debajo
de otra. Si tenemos en cuenta el ejemplo anterior, otra forma de ver el código seria de la siguiente
forma:

El resultado que obtendremos al ejecutar el código es exactamente el mismo en ambos casos, la

diferencia está en cómo se escriben las sentencias. En este caso se evalúa por separado cada if, y solo
mostrar el mensaje correspondiente al condicional que cumpla la condición.

Página 15 de 27
 Introducción a la Programación

Python además nos provee una forma más sencilla de escribir condicionales anidados. Es por eso que,
si hay más de dos ramas en la salida de la condición, se puede usar la sentencia elif como una
abreviatura de else if. Veamos a continuación un ejemplo de esto, teniendo en cuenta el mismo caso
de estudio.

El elif se usa como para poner

más de un if, se puede usar
cuantas veces quiera. siempre
después del elif va el else

Cualquiera de los tres códigos genera la misma salida. Como bien observaran entonces no hay una única
forma de escribir un código.

Veamos otro ejemplo de utilización de la instrucción elif:. Supongamos el siguiente enunciado: Ingresar
un número positivo de un digito y mostrar su nombre en letras.

Página 16 de 27
 Introducción a la Programación

Página 17 de 27
 Introducción a la Programación

Uso de conectores lógicos en la condición

En algunos casos, podemos reducir la cantidad de if usando los operadores lógicos and (y) y or (o)
dentro de una misma condición.

Los operadores lógicos retornan un valor lógico (verdadero o falso) basados sus tablas de verdad.
Operador Descripción
not Negación (no)
and Conjunción (y)
or Disyunción (o)

if (condición1) and (condición2): if (condición1) or (condición2):

Una condición con and es verdadera si todas las condiciones que conecta son verdaderas, para ello
observemos la tabla de verdad del operador and.

Condición 1 and Condición 2

V V V
V F F
F F V
F F F

Y una condición con or es verdadera si por lo menos una de las dos condiciones es verdadera.

Página 18 de 27
 Introducción a la Programación

Condición 1 or Condición 2
V V V
V V F
F V V
F F F
Por lo tanto, una condición and es falsa si alguna de las condiciones que conecta es falsa y una condición
or es falsa si todas las condiciones que conecta son falsas

En ciertas ocasiones, también es útil usar el operador not (negación de la condición), que devuelve el
valor de verdad contrario al de la condición que afecta. Si la condición es verdadera, al anteponerle el
operador not, el valor de verdad será falso; y por el contrario, si la condición es falsa, anteponiéndole
el operador not obtendremos una condición verdadera.

not Condición

F V

V F

El orden de precedencia para los operadores booleanos es el siguiente:

1. not
2. and
3. or

Este orden se puede alterar utilizando paréntesis. Por ejemplo:

 not condición 1 and condición 2: devuelve el valor de verdad del and entre la
 negación de la condición 1 y la condición 2

 not (condición 1 and condición 2): devuelve la negación del and entre la condición
1 y la condición 2

Para poder comprender un poco más sobre el uso de los conectores lógicos planteamos los siguientes escenarios:

Uso del and

Suponga que en un aviso del diario se piden ingenieros en sistemas con 5 años de experiencia a lo
sumo para ocupar un puesto laboral.

Página 19 de 27
 Introducción a la Programación

A continuación, indicamos 4 postulantes al puesto:

 Un licenciado en sistemas con 4 años de experiencia: NO LO TOMAN, pues la primeracondición

es falsa ya que el título que tiene no es el solicitado.
 Un ingeniero en sistemas con 8 años de experiencia: NO LO TOMAN, pues la segundacondición
es falsa ya que posee más de 5 años de experiencia.
 Un analista programador con 8 años de experiencia: NO LO TOMAN, pues las 2condiciones
son falsas ya que el título que tiene no es el solicitado y además posee más de 5 años de
experiencia.
 Un ingeniero en sistemas con 4 años de experiencia: LO TOMAN, pues las 2condiciones son
verdaderas, o sea que cumple con ambas condiciones para el puesto

Uso del or

Tengo invitados en casa y voy a comprar 1 kilo de helado. Sé que los únicos gustos que comen son chocolate o
vainilla. Al llegar a la heladería nos informan
 Hay chocolate, pero no hay vainilla. LO COMPRO, pues la primera condición esverdadera.
 Sólo hay vainilla, chocolate no. LO COMPRO, pues la segunda condición esverdadera.
 Hay chocolate y vainilla. LO COMPRO, pues las dos condiciones son verdaderas.
 Hay americana y dulce de leche. NO LO COMPRO, pues ninguna de las condiciones es
verdadera.
En base a lo visto sobre el uso de operadores lógicos, supongo el siguiente caso: Realizar
un programa que permita ingresar un número y decir si es de dos cifras ono.
Una primera resolución podría ser:

Pero si incluimos el uso de conectivos puede quedar de la siguiente forma

Página 20 de 27
 Introducción a la Programación

Veamos otro ejemplo con el uso de operadores lógicos: Ingresar dos números enteros y decir si
alguno es divisible por el otro

En resumen:

Operador Nombre Valor de verdad

and y Es verdadero sólo si las dos condiciones son verdaderas
or o Es falso sólo si las dos condiciones son falsas
not negación devuelve el valor de verdad opuesto de la condición

Página 21 de 27
 Introducción a la Programación

Anexo función print

Como ya hemos visto para mostrar por pantalla o imprimir utilizamos la función print(). Vimos que para
mostrar una leyenda la escribimos después del primer paréntesis del print entre comillas

print ("Hola Mundo")

Los paréntesis se escriben después del nombre de toda función para escribir entre ellos el argumento.
En el programa que aparece en el cuadro anterior se quiere mostrar la cadena de caracteresenunciada
entre comillas dobles. Al ejecutarlo, aparecerá en la pantalla Hola Mundo.
La cadena de caracteres escrita entre comillas también se llama mensaje, leyenda o literal, y al
mostrarla se respetan exactamente todos los caracteres que aparecen allí.
Dentro del texto a visualizar podemos aplicar secuencias de escape que nos permitirán dar formato a
los textos que se muestran por la consola. Todas las secuencias de escape se escriben con la barra
invertida ´\´y a continuación un carácter. Mediante el uso de esta secuencia podemos hacer que en
los textos aparezcan algunos caracteres especiales como “, \ etc.
A continuación detallamos algunos de las secuencias de escape que podemos utilizar en el print()
 \n: significa línea nueva (el cursor se coloca al comienzo de la siguiente línea).
 \t: tabulador horizontal
 \\: imprime una diagonal invertida \
 \": imprime la doble comilla

Veamos algunos ejemplos de utilización de las secuencias de escape y como se visualizan las mismas
en la consola de Python
 \n - Enter

Página 22 de 27
 Introducción a la Programación

 \t - Tabulación

 \” – Se la utiliza cuando se quiere poner un texto entre comillas

 \\ - Se la utiliza para poner una contra barra

Como ya hemos visto podemos agregar a nuestros mensajes los valores de una variable. Si queremos
que además de la leyenda el programa muestre el contenido más de una variable, podemos usar la
siguiente notación:

Al ejecutar este código se verá en pantalla “la suma entre 4 y 5 es 9”.

Página 23 de 27
 Introducción a la Programación

Esta forma nos permite armar el texto incluyendo las variables entre los literales. Nótese que el texto
va siempre entre “” y separando por ‘,’ se escriben los nombres de las variables. Estas no quedan
dentro de las comillas.

Como bien observamos además en la línea 3 del ejemplo, también se resuelve la suma de las variables
a y b, esto quiere decir que dentro de un print podemos realizar cálculos matemáticos.
Otra forma de obtener el mismo resultado es escribir dentro de las comillas, en el lugar quequeremos
que aparezca el valor de la variable, el símbolo de % seguido de la letra que indica
el tipo de variable y luego de las comillas, el símbolo % y entre paréntesis el nombre de la/s variable/s,
separadas por una coma en caso de haber más de uno.
Veamos un ejemplo de lo planteado
en dónde dice %d
puede ser cualquier
letra (%a, %h, etc.)

En este caso el resultado es el mismo que en el código anterior, pero es diferente la forma en que se
escribe la sentencia print().
Como comentamos cada porcentaje identifica el valor de una variable. Es por eso que en el listado de
variables que se encuentra en % se enumeran las variables que se quieren mostrar.
La función reemplazara entonces el primer formato por la primera variable de la lista, el segundo
formato por la segunda variables, y así sucesivamente. En definitiva, el reemplazo del formato es
posición con respecto a las variables.
Cabe aclara que dependiendo del tipo de dato que queramos mostrar es el formato a poner. Veamos a
continuación un ejemplo de los diversos formatos que podremos utilizar en la función print().

Página 24 de 27
 Introducción a la Programación

%d = para
números enteros
% f = para
números float
%s = para strings

En la línea 4 se muestra un valor int (entero), para ello utilizamos %d

En la línea 5 se muestra un valor float (real), para ello utilizamos %f. Cabe aclara que entre el símbolo
“%” y la “f”, hay un formato que se aplicara sobre el número. Este formato (.2) lo que hara es mostrar
la cantidad de 2 decimales.
En la línea 6 se muestra un string (texto), para ello se utiliza el formato %s
A continuación, se visualiza la salida del programa

Otra forma de imprimir en pantalla

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.
Veamos un ejemplo de su utilización y las diferencia que hay con las otras formas que hemos visto para
imprimir mensajes y resultados por consola

Página 25 de 27
 Introducción a la Programación

Como se observa en la imagen con el código dentro de los paréntesis del print primero escribimos f y
encerrado entre ‘ escribimos el texto que queremos mostrar, en caso de tener que mostrar el valor
contenido en una variable, ponemos en { } el nombre de la variable que queremos mostrar.
Si observamos la salida por cada renglón tendremos la salida que hemos estipulado en cada print.

Si te estas preguntando si podés meter más de una variable entre las llaves, la respuesta es si, en caso
de hacerlo debes poner las variables dentro de las llaves, pero separando cada una por una coma (“,”)
Como se observa en el código en la línea 7 se imprimirán ambos datos.

En la salida observaremos que al mostrar los datos, los mismos se ven como una tupla y no sería
correcto mostrarlo de esta forma.

En caso de querer formatear datos, como ser la cantidad de decimales a mostrar, lo haremos indicando
la de decimales a mostrar. Veamos el código como seria esto que estamos planteando.

Página 26 de 27
 Introducción a la Programación

Si observamos en la línea 6, luego del nombre de la variable precio escribimos : y a continuación . y la

cantidad de decimales, en este caso estar mostrando solo 2 decimales, y redondeará el numero según
corresponda.
Veamos la salida del código.

Página 27 de 27