Introducción a

la
Programación
Teórica Parte 2

Juan Matias Novas

Contenido
Algoritmos: Parte II ................................................................................................................................................... 3
Estructuras de repetición ...................................................................................................................................... 3
WHILE – Repetición condicional ....................................................................................................................... 3
Contadores y acumuladores ............................................................................................................................. 5
Ciclo while y contadores como variables de control ......................................................................................... 6
FOR – Repetición no condicional ...................................................................................................................... 8
Validación de datos de entrada ...................................................................................................................... 11
Máximos y mínimos ........................................................................................................................................ 15
Anexo Bucles infinitos............................................................................................................................................. 19
Anexo Cadenas de caracteres.................................................................................................................................. 21
Operaciones con cadenas.................................................................................................................................... 21
Algoritmos: Parte II
Estructuras de repetición
En la solución de algunos problemas es necesario ejecutar repetidas veces una instrucción o un conjunto
de instrucciones. Para solucionar este tipo de problemas se utiliza un tipo de estructuras a las que se
conocen como estructuras de repetición, bucles o ciclos.
Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces dependiendo del cumplimiento
-de una condición.
En algunos casos, el número de repeticiones se conoce con anterioridad, mientras que en otras depende
de cálculos o estados de variables que se dan dentro de la solución del problema.
WHILE – Repetición condicional
Un bucle o ciclo while permite repetir la ejecución de un grupo de instrucciones mientras se cumpla una
condición (es decir, mientras la condición tenga el valor True).
La sintaxis del bucle while es la siguiente:

while condición:
sentencia 1
sentencia 2 Bloque de sentencias del while
siguiente sentencia fuera del while

La ejecución de esta estructura de control while es la siguiente:

1. Python evalúa la condición:
a. si el resultado es True se ejecuta el cuerpo del bucle. Una vez ejecutado el cuerpo del
bucle, se repite el proceso (se evalúa de nuevo la condición y, si es cierta, se ejecuta de
nuevo el cuerpo del bucle) una y otra vez mientras la condición sea cierta.
b. si el resultado es False, el cuerpo del bucle no se ejecuta y continúa la ejecución del resto
del programa.
Esta instrucción no permite saber de antemano cuantas veces se va a repetir el bloque de sentencias que
abarca, ya que el corte se produce por el valor de verdad de la condición, es por eso que las variables que
intervienen en la condición deben tener un valor previo y modificarse dentro del ciclo.
Algunas cuestiones importantes sobre el ciclo:
 Nunca debe forzarse la ejecución de un ciclo while, ya que puede ser que nunca se ejecute
 La variable o las variables que aparezcan en la condición se suelen llamar variables de control.
Las variables de control deben definirse antes del bucle while y modificarse en el bucle while.

Veamos a continuación un ejemplo sobre cómo utilizar este ciclo, para ello supongamos el siguiente
enunciado: Leer números hasta que se ingrese un cero o un negativo y mostrarlos.
En la línea 1 ingresamos el primer número a tratar. Una vez leído el número se evalúa la condición que
se encuentra en el ciclo while para determinar si se ingresa o no al ciclo. En caso que la evaluación de la
condición sea VERDADERA se ingresa al ciclo y se muestra el número ingresado como observamos en la
línea 3. Por ultimo en la línea 4 volvemos a pedir que se ingrese un nuevo número, esto lo debemos hacer
ya que el valor ingresado antes ya ha sido tratado. Una vez leído el nuevo número el código vuelve a la
línea 2 para nuevamente evaluar la condición del ciclo y así se vuelve a repetir el ciclo de instrucciones,
En caso que la evaluación de la condición sea FALSO, ya no entra al ciclo y continua con las sentencias
que tengamos debajo del ciclo while.
Supongamos algunos ingresos de datos:
1. 5, 14, 6, 8, -3 (el quinto número ingresado es menor que cero por lo tanto muestra en pantalla 5,
14, 6, 8 y sale del ciclo)
2. 7, -6 (el segundo número ingresado es menor que cero por lo tanto muestra en pantalla el número
7 y sale del ciclo).
¿Por qué es necesario realizar una lectura dentro del ciclo?
Si no leemos dentro del ciclo la variable de control, el valor de la misma no se modifica y de esa forma el
ciclo se ejecuta infinitas veces.
Si la condición del bucle se cumple siempre, el bucle no terminará nunca de ejecutarse y tendremos lo
que se denomina un bucle infinito. Aunque a veces es necesario utilizar bucles infinitos en un programa,
normalmente se deben a errores que se deben corregir.
Los bucles infinitos no intencionados deben evitarse pues significan perder el control del programa. Para
interrumpir un bucle infinito, hay que pulsar la combinación de teclas Ctrl+C.
Ver más sobre bucles infinitos en el anexo.
¿Por qué es necesario realizar una lectura antes del ciclo?
Como bien hemos comentado un ciclo while puede ser que no se ejecute nunca si la evaluación de la
condición con la variable de control es FALSA. Es por eso que los ciclos while no se fuerza su ejecución.
La lectura previa es necesaria para que la variable de control tenga un valor definido de antemano y así
poder determinar si ejecuta o no el contenido del ciclo
Veamos otro ejemplo de utilización del ciclo, En este caso tendremos en cuenta el siguiente problema:
Leer números mientras sean distintos de cero y mostrar los que son múltiplos de 5.
Nota: para determinar siun número es múltiplo o divisor de otro usamos el operador % que nos devuelve
el resto de dividir al primer número por el segundo; si la función devuelve un cero significa que el primer
número es múltiplo del segundo.
Contadores y acumuladores
Generalmente, cuando usamos ciclos de repetición, necesitamos contar cuantas veces se cumple alguna
condición o sumar todos los valores que va tomando una variable dentro del ciclo. Para ello usamos
variables que denominamos contadores y acumuladores.
Un contador es una variable que se incrementa o decrementa en un valor constante cada vez que ocurre
un evento. Los contadores se utilizan dentro de estructuras repetitivas para contar cierto evento que
ocurre dentro del ciclo.
El contador debe inicializarse en cero antes de comenzar el ciclo.
Para entender cómo se usa una variable como contador pensemos en lo siguiente: Cuando comienza el
programa no se produjo ninguna ocurrencia del evento que queremos contar, por lo tanto, el valor inicial
del contador fuera del ciclo debe ser cero.
cont = 0
Cada vez que ocurre el evento debemos sumarle 1 a la variable cont

0+1=1

1+1=2

2+1=3

3+1=4
Vemos que para contar debemos sumar 1 al valor que obtuvimos como resultado en el renglón anterior,
entonces este valor debemos guardarlo en la misma variable cont, de la siguiente forma:
cont = cont + 1 (recordar que la asignación se hace de derecha a izquierda)
Un acumulador es una variable que se incrementa en un valor variable. Se utilizan en el caso de querer
obtener la suma o el producto de los distintos valores que toma una variable dentro de un ciclo. El
acumulador debe estar inicializado antes de empezar el ciclo, en el elemento neutro de la operación, si
es suma en cero y si es producto en uno. El formato de un acumulador es:
acum = acum + variable
acum = acum * variable
A partir de lo explicado veamos un ejemplo de su utilización, para ello queremos resolver el siguiente
problema: Leer números mientras sean pares y calcular su promedio.
Para calcular el promedio de una lista de números debemos calcular la suma de todos ellos y dividirla por
la cantidad de números que ingresamos. Usaremos entonces un acumulador y un contador dentro del
ciclo mientras.

Observemos que al comienzo del algoritmo en la línea 1 están inicializadas en cero ambas variables. Algo
importante a remarcar es que el cálculo del promedio se resuelve fuera del ciclo, una vez que se sumaron
todos los múltiplos de dos ingresados. En caso de hacerlo dentro del ciclo estaríamos mostrando cálculos
parciales del promedio y eso no es correcto, ya que para poder determinar un promedio se deben sumar
todos los datos a tener en cuenta en el cálculo y luego dividir ese acumulado por la cantidad de datos
sumados.
Siempre que se deba realizar una división, antes de realizar la misma, debemos asegurarnos que la
variable por la que vamos a dividir no haya quedado en cero (recordemos que en matemática la división
por cero esta indeterminada), es por eso que para determinar lo planteado utilizamos una estructura de
decisión.
Nota: siempre que en un algoritmo aparezca una división por una variable, debemos asegurarnos que
esta variable no tenga valor CERO. Usamos entonces una estructura de decisión, si fuera necesario, antes
de plantear la división.
Una posible división por cero en un algoritmo es un ERROR GRAVE, ya que hace que el programa se corte
abruptamente.
Ciclo while y contadores como variables de control
Hasta el momento hemos visto el manejo de ciclo mediante el ingreso de datos, veamos como varia
nuestro código en caso de tener que repetir sentencias en el ciclo pero dependiendo de un contador.
Para ello supongamos el siguiente problema. Mostrar por consola todos los números pares que sean
mayores a 1 y menores o igual a 20.

Como bien observamos en la línea 1 se establece el valor del contador para poder determinar si se ingresa
o no al ciclo. En este caso como la variable de control es un contador y se debe inicializar en un valor. Es
por eso que al usar contadores el ciclo no se fuerza a la ejecución. Como se visualiza además en la línea
5 la variable de control modifica su valor para poder determinar si se da una vuelta más en el ciclo o no.

A partir de esto quizás se te deba estar ocurriendo pensar en por que no se puede hacer lo mismo con la
lectura. Por ejemplo, lo que suele pasar muy a menudo es lo siguiente:

Este código ES INCORRECTO, primero que nada, porque estamos forzando la ejecución del ciclo, ya que
la variable num se está definiendo un valor y ese valor con la que se inicializa hace que se ingrese al ciclo.
Dentro del ciclo además pedimos el dato. El tener una sola lectura dentro del ciclo no es correcto, ya que
si en este caso ingresamos un cero, que es la condición de corte, no deberíamos ejecutar ninguna
sentencia.
Si nos fijamos en la salida, vemos que el cero lo muestra en la consola ya que al haber leído un dato por
que se forzó el ciclo le permitió ejecutar todo el contenido, cuando en realidad no debería de haber
ejecutado ninguna sentencia que se encuentra dentro del ciclo.

Volvemos a repetir, cuando se deben leer varios datos por teclado se debe leer una vez por fuera del
ciclo, y nuevamente dentro del ciclo como última sentencia.
El siguiente código que mostramos es la versión correcta del código que no es correcto

Algo nuevo en la sentencia print es el comando end=” “, este comando lo que hace es que los valores que
se imprimen se encuentren separados por un espacio en blanco en vez de mostrar un valor por renglón.
FOR – Repetición no condicional
Este ciclo también permite ejecutar repetidas veces un grupo de instrucciones, pero el número de veces
que se repite es conocido de antemano. Por eso este ciclo maneja el valor inicial, el valor final y el valor
del incremento de la variable de control como parte de la instrucción. La variable inicial no se puede
alterar dentro del ciclo. Bloque de sentencias dentro del for.

for i in range(inicio, fin, paso):

sentencia1
sentencia2
primera sentencia fuera del for

Donde i es la variable que controla el número de veces que se ejecuta el bloque de instrucciones que
queda dentro del for, inicio es el valor inicial de i, fin el valor hasta el que se va a ir incrementando i de a
tantas unidades como este indicado en paso.
Veamos un ejemplo sencillo de su utilización:

La salida de este código es la siguiente:

Algo que se puede observar en la salida por consola es que los números que se visualizan están
comprendidos entre 1 y 9. ¿Por qué no muestra el numero 10? El valor 10 no lo muestra ya que el ciclo
for en Python hace iterar la variable de control hasta un valor menos del valor de fin que se estableces,
dicho de otra forma, el ciclo se repite mientras que el valor de la variable de control sea menor que el fin
establecido.
Algunos parámetros de los que están entre paréntesis pueden no escribirse; por ejemplo, si solo se
escribe un número, Python entiende que este valor corresponde al valor de fin y asume que el valor inicial
es cero y el paso es uno. Veamos en código como se realizaría lo planteado:

Al ejecutar el código observamos que la salida ha variado:

Como observamos comienza en cero y finaliza en 9, imprimiendo de esta forma 10 números por consola.
Si se escriben solo dos valores dentro del paréntesis, se asume que son el de inicio y fin y que el paso es
uno.
Salida:

También es importante aclarar que el paso puede ser negativo, o sea en vez de ir de 1 en 1 vamos de -1
en -1. Supongamos que queremos mostrar los números del 10 al 1:

Para mostrar los números del 10 al10, la variable i debe empezar en 10 y llegar hasta 0, restándole 1 al
valor de esa variable en cada ciclo. En este caso, se indica que a i se le debe restar 1(uno) en cada vuelta
del ciclo.

Veamos un ejemplo donde utilicemos un ciclo for utilizando contadores, acumuladores y condicionales.
Supongamos el siguiente problema a resolver: Leer 10 números y calcular el promedio los numero s
mayores o iguales que 6 y el producto de los menores.
Como bien se observa todos los conceptos vistos hasta el momento se pueden combinar entre ellos.
Veamos a continuación el código que resuelve el siguiente problema: Leer la cantidad de alumnos de un
curso e ingresar las notas del primer y segundo parcial de cada alumno. Mostrar el mensaje “APROBO LA
MATERIA”, si los dos parciales tienen nota mayor o igual a 4. “RECUPERA UN PARCIAL”, si alguno de los
dos parciales no está aprobado o “RECURSA” si no aprobó ningún parcial. Por final de proceso mostrar
cuantos alumnos aprobaron la materia.

Validación de datos de entrada

Algo importante que debemos tener en cuenta es que nuestros programas solicitan datos que luego se
deberán procesar, es por eso que es tan importante que los datos que se ingresan al sistema sean lo más
correcto, ya que por lo general el usuario no siempre ingresa valores correctos.
Cabe aclarar que en esta materia la validación la vamos a realizar sobre el valor de los datos y no sobre
los tipos de datos.
Veamos un ejemplo de sobre como validar un dato de entrada, suponga para ello el siguiente problema.
Se pide ingresar el sexo y edad de cada encuestado. El fin de la carga finaliza cuando en la edad se ingresa
un cero. Se calcular la cantidad de hombres y mujeres encuestados y cual el porcentaje de cada sexo
sobre el total de encuestados. Recuerde realizar la validación de datos de entrada.

Algo importante a destacar es que nuestros códigos cada vez van siendo más largo. En el código que se
muestra en las tres primeras líneas se definen los contadores que entraran en juego en el algoritmo, ya
que debemos calcular la cantidad de encuestados, la cantidad de hombres encuestados y de mujeres
encuestadas. Con estos tres datos calculados podremos resolver el tema de los porcentajes y de los
totalizadores pedidos.
Según el enunciado no podemos determinar la cantidad la de encuestados que se procesaran, es por eso
que debemos identificar que el ciclo que utilizaremos para procesar los datos es el ciclo WHILE, y a partir
del enunciado nos indica que el fin de proceso del ciclo está determinado cuando se ingrese en la edad
un valor 0.
Es por eso que la variable de control de nuestro código será la edad. En la línea 5 solicitamos al usuario
que nos ingrese una edad. No es seguro que el usuario ingrese un valor correcto, esto quiere decir que
el usuario puede ingresar como dato una edad -25, y la misma no es correcta ya que no hay edades
negativas. Es por eso que en la línea 6 se establece la validación del dato edad. Para ello utilizamos un
ciclo while que contendrá como líneas la 7, que indica un mensaje de error y la línea 8 donde se vuelve a
pedir al usuario el ingreso de un nuevo dato, ya que el dato ingresado era incorrecto.
Como hemos comentado estas dos líneas están dentro de un ciclo while, ya que no podemos determinar
cuántas veces más el usuario ingresara un valor incorrecto. Si observamos en la línea 6 la condición es
edad < 0, como bien sabemos una edad no puede ser negativa, y además nos informan que el cero corta
el fin de ingreso de datos, es por eso que el ciclo se ejecutara mientras que la edad ingresada no se aun
cero o un valor positivo.
Una vez que salimos del ciclo while de la línea 6 es porque sabemos que el usuario ingreso una edad
valida o un cero (fin de ingreso de carga de datos)
Luego el código continúa ejecutándose en la línea 9 donde nos encontramos con otro ciclo. Este ciclo
controla el ingreso de la carga de los datos, si el usuario ingreso un dato valido en la variable edad y que
no sea un cero ingresa al ciclo y ejecutara todas las sentencias que lo conforman.
Entre las líneas 10 y 12 observamos que se pide al usuario que ingrese el sexo del encuestado, donde
deberá ingresar una M o F, nuevamente observamos que luego de realizar el input se procede a realizar
la validación del valor leído. En este caso nuestra variable de control es el sexo. Como bien se observa
entonces se pueden escribir ciclos dentro de otros ciclos, y cada ciclo tendrá su variable de control, la
que se deberá leer antes de la condición del ciclo y dentro del ciclo como última sentencia.
En el caso de la condición del sexo, observamos que la condición es compuesta, ya que se realiza una
doble comparación mediante el uso de un operador lógico. Recomendamos leer el APUNTE TEORICO en
caso de no recordar el uso de operadores lógicos.
Si observamos la línea 11 la condición es: sexo.upper() != "M" and sexo.upper() != "F".
.upper() convierte una letra de minúsculas a mayúsculas o sea sexo.upper(), indica que el valor
almacenado en la variable sexo se convierte a mayúsculas. Esto lo debemos realizar ya que el lenguaje es
case sensitive, esto quiere decir que hace diferencias entre las mayúsculas y las minúsculas.
Mediante la función upper(), establecemos un único valor así de esta forma evitamos las comparaciones
por minúsculas y mayúsculas.
Una vez ingresado un valor de sexo valido continua el algoritmo en la línea 14, donde cuenta cantidad de
encuestados, y luego en el condicional de la líneas 15 a 18, determina la cantidad de hombres y mujeres
encuestadas que se están procesando.
Por ultimo vuelve a solicitar el ingreso de la edad y posteriori su validación teniendo en cuenta lel proceso
que ya hemos comentado con anterioridad.
Por ultimo al salir de la ejecución del ciclo cuando se lea una edad igual a cero, se calcula el total de
encuestados, para luego poder determinar el porcentaje.
A continuación se visualiza en la consola que sucede cuando se ingresa una edad negativa

Una vez ingresada la edad correcta nos pide el tipo de sexo.

Al ingresar un dato incorrecto el sistema nos indica que el dato es erróneo y nos pide el ingreso por
consola nuevamente.

A continuación se visualiza la salida completa con una carga de datos

Máximos y mínimos
En los programas muchas veces debemos buscar el máximo de un conjunto de datos, un método bastante
estándar es asignar a una variable el primer valor leído y luego comparar cada valor siguiente con esa
variable.
En caso de que alguno de los valores leídos sea mayor al de esa variable, se le asigna el nuevo valor. El
resto de los valores se seguirá comparando con el mayor obtenido hasta ese momento, y si alguno es
mayor se guardará en la variable, reemplazando al anterior.
De forma similar se procede para determinar el mínimo de un conjunto de datos Ejemplo 1:
Supongamos el siguiente problema: Leer 11 números y determinar el valor máximo leído.
En este caso la resolución de nuestro problema la determinaremos a través del ciclo for ya que
conocemos de antemano la cantidad de elementos que vamos a procesar.

En este caso es sencillo determinar el primer número leído ya que como sabemos la cantidad, podemos
leer el primer valor fuera del ciclo y luego pedir 10 números más y compara el máximo obtenido con el
valor leído.
En la línea 5 se evalúa si el valor que se leyó es mayor al valor que está almacenado en máximo, en caso
de ser así, el nuevo máximo es el número leído. En caso de no cumplirse la condición se saltea el
condicional.
Salida
Otra forma de escribir el código con el for sin tener que leer el primer elemento por fuera es:

En este caso observamos que cambia un poco el código al no leer por fuera del ciclo el primer elemento.
Es por eso que en la línea 3 el condición identifica si es la primera vez que se ejecuta el ciclo. Recordemos
que cuando en el RANGE solo se pone la cantidad de iteraciones que debemos hacer el valor inicial de i
es 0.
Al ser i = 0, entonces lo que hacemos es inicializar la variable máximo con el primer valor leído. En este
condicional solo entramos la primera vez, luego entraremos por el else de la línea 5, donde para el resto
de las iteraciones se realizara la consulta para determinar si hay que cambiar el máximo a partir del nuevo
valor leído.
Como bien se observa en la salida a pesar de ser códigos distintos, ante la carga de los mismo números,
nos da el mismo resultado

Cabe aclarar que la búsqueda del mínimo es igual a la del máximo, pero teniendo en cuenta que al
momento de determinar con el if la comparación se cambia el signo > por <.
Siempre en la búsqueda de máximos y mínimos se buscar por orden estrictico, esto quiere decir que
nunca se tienen en cuenta los valores máximos ni mínimos que sean iguales, en caso de haber un mismo
máximo más de una vez siempre nos quedaremos con el primero de todos los que aparecen.
De la misma forma que buscamos máximos y mínimos con un ciclo for también podemos realizar la
búsqueda de máximos y mínimos con un ciclo while. En este caso no podemos determinar la cantidad de
elementos por lo que cambia un poco la forma de escribir el código, pero la forma de determinarlo es la
misma. Siempre vamos a inicializar la variable que contiene el valor máximo o mínimo a partir de la
primera lectura de datos.
Veamos a continuación un ejemplo de búsqueda con un ciclo while. Supongamos para ello el siguiente
problema: A partir de la lectura de varias temperaturas se desea determinar cuál es la temperatura
máximo ingresada. La carga de datos finaliza cuando se lee una temperatura igual a cero.

En este caso al desconocer la cantidad de elementos que se van a leer no podemos realizar una lectura
fuera del ciclo y asignar ese valor al máximo, ya que si lo que se lee es el fin de carga de datos, no existe
el valor máximo.
Es por eso que definimos la variable max, esta variable contendrá el máximo durante la ejecución del
programa., y la misma la inicializamos con un valor, en este caso un cero.
Como se observa en la línea 2 se solicita el dato al usuario y en la línea 3 controla la condición de ingreso
al ciclo.
Una vez dentro del ciclo, en la línea 4 es donde vamos a tratar de identificar si es la primera vez que se
ingresa al ciclo o si ya hemos pasado más de una y hay que cambiar el valor del máximo. Es por eso que
la condición del if es compuesta.
La primer parte del condicional max == 0, es la condición que nos indicara si es la primera vez que se
ingresó al ciclo. Observar que el valor de la variable max contra el que comparamos es el mismo que la
inicialización, por lo tanto al ser verdadera esta parte de la condición no sigue evaluando el resto de las
condiciones ya que estamos utilizando un operador OR. Recordemos que en el operador con que una de
todas las condiciones que se evalúan sea VERDADERA es suficiente para que todo el condicional sea
VERDADERO, logrando de esta forma la inicialización de la variable max con el primer valor de la
temperatura leída.
Si por el contrario, max no fuese cero, por que en algún momento ya hemos leído el primer número,
entonces la primer parte del condicional daría como resultado de la comparación FALSO, por lo tanto
pasa a evaluar la siguiente condición que es temp > max, en este caso si la misma es VERDADERA se
procede a cambiar el valor del máximo.
Veamos una ejecución de la salida:

En este caso observamos que todas las temperaturas leídas son por arriba de cero.
Otra ejecución:

En este caso observamos que todas las temperaturas leídas son bajo cero.
Otra ejecución más:
En este caso observamos que todas las temperaturas leídas son por arriba de cero y bajo cero. En todos
los casos no importa el valor de lo que se busca, siempre el algoritmo determina el valor máximo.
Es por eso que la búsqueda de un máximo o de un mínimo no importa qué tipo de máximo o mínimo se
desea buscar, en este caso se plantea un modelo que resuelve cualquier caso de máximo o mínimo.

Anexo Bucles infinitos

Por desgracia, es fácil programar involuntariamente un bucle infinito, por lo que es inevitable hacerlo
de vez en cuando, sobre todo cuando se está aprendiendo a programar. Estos algunos ejemplos de
bucles infinitos:

1. El programador ha olvidado modificar la variable de control dentro del bucle y el programa imprimirá
números 1 indefinidamente:

Salida

2. El programador ha escrito una condición que se cumplirá siempre y el programa imprimirá números
consecutivos indefinidamente:
 Introducción a la Programación

Salida

3. Se aconseja expresar las condiciones como desigualdades en vez de comparar valores. En el

ejemplo siguiente, el programador ha escrito una condición que se cumplirá siempre y el
programa imprimirá números consecutivos indefinidamente:

Salida

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

Anexo Cadenas de caracteres

Llamamos cadena, cadena de caracteres o string a una secuencia de caracteres. Se entiende como
carácter a cualquier elemento que se encuentra declarado en la tabla de código ASCII. A continuación,
veremos cómo manipular cadenas de caracteres y variables de este tipo en Python.

Operaciones con cadenas

Concatenar cadenas entre sí: podemos unir cadenas de caracteres usando elsímbolo “+”. Por ejemplo:

Muestra en pantalla hola mundo print (“hola” + “mundo”)

Guarda en la variable cadena el string holamundo cadena = “hola” + “mundo”

Obtener el largo de una cadena: podemos contar cuantos caracteres tiene una cadena usando la
función “len ( )”.

a = “hola”
print(len(a))

La función len() cuenta cuántos caracteres tiene la cadena “hola” y muestra en pantalla 4.
Nota: existe una cadena especial, que llamaremos cadena vacía, que es la cadena que no contiene
ningún carácter (se la indica solo con un apóstrofe o comilla que abre, y un apóstrofe o comilla que
cierra “ ”), y que por lo tanto tiene longitud cero.
Recorrer una cadena: podemos recorrer una cadena, elemento por elemento, usando un ciclo for
definido de la siguiente manera:

Página 21 de 24
 Introducción a la Programación
en la terminal aparece así:
h
for x in “hola”: o
print (x) l
a
Donde la variable x representa a cada carácter de la cadena. En cada iteración del for la variable x va
tomando los valores de cada carácter de la cadena. En la primera iteración la variable x contiene la “h”,
en la segunda, la “o” y así sucesivamente. La cadena a recorrer la escribimos después del “in”.
Acceder a una posición de la cadena : podemos hacerlo escribiendo el nombre de la cadena y entre
corchetes la posición a la cual queremos acceder (índice ). Tener en cuenta que las posiciones
comienzan a contarse desde cero.

a = “hola”
print(“El tercer carácter de la palabra es”, a[2])

Muestra en pantalla la letra l.

Los índices son números enteros entre 0 y len(a) – 1. Se pueden utilizar también índices negativos que
acceden a los caracteres de la cadena desde el último al primero. Por ejemplo, a [-1] accede al último,
a[-2] al anteúltimo, etc.

cuando se cuenta al revés, es decir,

a = “hola”
en negativo, se cuenta desde el -1, no
print(“El último carácter de la palabra es”, a[-1])
del 0

Muestra en pantalla la letra a.

Segmentar una cadena: podemos identificar partes de una cadena escribiendo entre corchetes el rango
de índices que queremos considerar.

a = “hola”
print(a[1:3])

Muestra en pantalla ol.

Tener en cuenta que Python considera el intervalo abierto en el límite superior, o sea que el rango no
incluye el carácter correspondiente al segundo índice sino que llega hasta al anterior.

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

Si j es un entero no negativo, se puede usar la notación a[ :j] para representar al

segmentoa[0: j]. También se puede usar la notación a[j: ] para representar al segmento a[j: len(a)].

a = “programación”
print(a[:4])
print(a[6:])

El primer print muestra “prog” y el segundo “mación”.

Pasar toda la cadena a mayúsculas: la función UPPER permite transformar todos loscaracteres de una
cadena en mayúsculas.
Pasar toda la cadena a minúsculas: la función LOWER permite transformar todos los caracteres de una
cadena en minúsculas. Se utilizan escribiendo el nombre de la variable, luego un punto y a continuación
el nombre de la función seguido de paréntesis.

nombre = “programación” Muestra PROGRAMACIÓN

print (nombre.upper())
print (nombre.lower())
Muestra programación

Aclaración: Las cadenas son inmutables, es decir que no se puede modificar uno o algunos
caracteres sobre la misma variable.
Añadir caracteres a una cadena: se utiliza el operador +=

nombre = “programación”
si pongo al revés "python" y "en", es
nombre+=”en “
decir, arriba "python y abajo en,
nombre+= “Python”
mostraría programación Python en
print(nombre)

Mostrará programación en Python.

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

Encontrar una sub cadena en una cadena: la función find muestra el valor de la posición
donde empieza la sub cadena indicada entre paréntesis. Recordar que siempre comienza el conteo
desde 0. Si no encuentra la sub cadena indicada mostrará un -1.

nombre = “programación en python”

m=nombre.find(“python”)
print(m)

En pantalla aparecerá el número 16.

Reemplazar una sub cadena en una cadena: utilizamos la función replace para reemplazar una parte
de la cadena por otra. Escribimos la variable que contiene a toda la cadena, un punto, replace y entre
paréntesis primero la parte que tiene que reemplazar y luego la cadena por la que va a ser reemplazada.

nombre = 'programación en python'

m=nombre.replace('pro', 'código')
print(m)

Muestra en pantalla: códigogramación en python

Página 24 de 24