Blog

Tuplas y Conjuntos

Variables de tipo Tupla

Las variables de tipo tupla son una colección de valores que se pueden repetir, pero que no pueden modificarse, son inmutables. Se representan con paréntesis ( ) y no se pueden modificar, son inmutables. Se crean empleando paréntesis, en lugar de corchetes como hacíamos con las listas.

tupla=("Cadiz",2,True,"Cadiz",[34,44])
print(type(tupla))
print(tupla)

Si ejecutamos el código anterior obtenemos:

<class 'tuple'>
('Cadiz', 2, True, 'Cadiz', [34, 44])

Accediendo a los elementos de una tupla

Accedemos a los elementos de una tupla igual que accedíamos a los de una lista, a través del índice que indica la posición. El índice se indica entre corchetes rectos, igual que con las listas

dias_semana=("Lunes","Martés","Miércoles","Jueves","Viernes",
             "Sábado","Domingo")
primer_dia=dias_semana[0]
ultimo_dia=dias_semana[-1]
print(f"El primer día de la semana es {primer_dia}")
print(f"El último día de la semana es {ultimo_dia}")

Y el resultado:

El primer día de la semana es Lunes
El último día de la semana es Domingo

Al ser inmutables no se puede modificar el valor de un elemento determinado:

dias_semana=("Lunes","Martés","Miércoles","Jueves","Viernes",
             "Sábado","Domingo")
dias_semana[0]="Monday"

El código anterior arroja el error:

TypeError: 'tuple' object does not support item assignment

Las tuplas tienen métodos similares a las listas, pero no aplicarían los métodos en los que se modifican valores, ya que son inmutables.

dias_semana=("Lunes","Martés","Miércoles","Jueves","Viernes",
             "Sábado","Domingo")
num_elementos=len(dias_semana)
print(f"Numero de elementos: {num_elementos}")
indice=dias_semana.index("Jueves")
print(f"Indice: {indice}")
cuenta=dias_semana.count("Jueves")
print(f"cuenta: {cuenta}")

Resultado

Numero de elementos: 7
Indice: 3
cuenta: 1

Variables de tipo Conjunto

Las variables de tipo conjunto son una colección de valores únicos mutables. Es decir, los valores no se pueden repetir, pero si se pueden cambiar, podemos añadir y eliminar elementos del conjunto.

Para crear un conjunto, encerramos los elementos entre corchetes llave. El tipo devuelto, el tipo conjunto, es set

conjunto={3,5,"Hola"}
print(type(conjunto))

Resultado:

<class 'set'>

Operaciones con conjuntos

Este tipo de colecciones disponen de una serie de operadores propios para manejarlos

  • El operador unión (“|”): conjunto_1 | conjunto_2. Devuelve un nuevo conjunto que tienen todos los elementos de los conjuntos operandos, pero sin elementos repetidos.
conjunto_1={1,2,3,4,5}
conjunto_2={3,4,5,6,7}
union=conjunto_1|conjunto_2
print(union)

Resultado:

{1, 2, 3, 4, 5, 6, 7}

El operador intersección (“&”): conjunto_1 & conjunto_2. Devuelve un nuevo conjunto con los elementos comunes a ambos conjuntos operandos.

conjunto_1={1,2,3,4,5}
conjunto_2={3,4,5,6,7}
interseccion=conjunto_1&conjunto_2
print(interseccion)

Resultado:

{3, 4, 5}

El operador diferencia (“-“): conjunto_1 – conjunto_2. Devuelve los elementos del primer conjunto operando que no están en el segundo.

conjunto_1={1,2,3,4,5}
conjunto_2={3,4,5,6,7}
dif1=conjunto_1-conjunto_2
dif2=conjunto_2-conjunto_1
print(f"elementos del conjunto 1 que no están en el 2: {dif1}")
print(f"elementos del conjunto 2 que no están en el 1: {dif2}")

Resultado:

elementos del conjunto 1 que no están en el 2: {1, 2}
elementos del conjunto 2 que no están en el 1: {6, 7}

Accediendo a los elementos de un conjunto

Los conjuntos no disponen de índices, por lo que no podremos emplearlos para acceder a sus elementos. Para recuperar los distintos elementos de un conjunto lo recorremos con un bucle

conjunto={3,5,"Hola"}
for elemento in conjunto:
    print(elemento)

Resultado:

3
5
Hola

Conocer si un elemento pertenece a un conjunto

Empleando el operador in, podemos saber si un elemento pertenece a un conjunto

conjunto={"Ana","Pepe","Rosa","Guillermo","Juan"}
persona="Rosa"
if persona in conjunto:
    print(f"{persona} está en el grupo")

Resultado:

Rosa está en el grupo

Eliminar duplicados de una lista: casting a Set

Una manera rápida de eliminar duplicados de una lista es convertirla en un tipo conjunto, para ello haríamos casting de la lista a set

lista=["cepillo","pasta de dientes","desodorante",
       "colonia","tijeras","cepillo","desodorante"]
conjunto=set(lista)
print("LISTA:")
print(lista)
print("CONJUNTO:")
print(conjunto)

Resultado:

LISTA:
['cepillo', 'pasta de dientes', 'desodorante', 'colonia', 'tijeras', 'cepillo', 'desodorante']
CONJUNTO
{'cepillo', 'colonia', 'tijeras', 'pasta de dientes', 'desodorante'}

Métodos asociados a los conjuntos

Las variables de tipo conjunto tienen una serie de métodos asociados:

  • add (<elemento>): Añade al conjunto el elemento indicado.
conjunto={"Ana","Pepe","Guillermo"}
persona="Lourdes"
conjunto.add(persona)
print(conjunto)

Resultado:

{'Guillermo', 'Lourdes', 'Pepe', 'Ana'}
  • clear( ): Elimina todos los elementos del conjunto
conjunto={"Ana","Pepe","Guillermo"}
conjunto.clear()
print(conjunto)

Resultado:

set()
  • copy( ): genera una copia del conjunto.
conjunto_1={"Ana","Pepe","Guillermo","Lourdes"}
conjunto_2=conjunto_1.copy()
conjunto_1.clear()
print(f"conjunto 1: {conjunto_1}")
print(f"conjunto 2: {conjunto_2}")

Resultado:

conjunto 1: set()
conjunto 2: {'Guillermo', 'Lourdes', 'Pepe', 'Ana'}
  • discard(<elemento>): elimina del conjunto el elemento indicado
conjunto={"Ana","Pepe","Guillermo","Lourdes"}
conjunto.discard("Guillermo")
print(f"conjunto: {conjunto}")

Resultado:

conjunto: {'Lourdes', 'Pepe', 'Ana'}
  • issubset(<conjunto_2>): comprueba si el conjunto pasado como parámetro está incluido en el conjunto al que se le aplica el método. Devuelve verdadero o falso.
conjunto_1={"Ana","Jesús"}
conjunto_2={"Ana","Lourdes","Jesús"}
if conjunto_1.issubset(conjunto_2):
    print("conjunto 2 está incluido en conjunto 1")

Resultado:

conjunto 2 está incluido en conjunto 1

NOTA:

Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.

Ejercicios con Listas en Python

En este post propongo algunos ejercicios básicos con listas en Python para practicar lo aprendido en el artículo de Listas.

El código de los programas viene con varios comentarios que pretenden hacer lo más comprensible posible la solución que se plantea.

Ejercicio 1: Contar vocales de una frase

Realiza un programa que solicite al usuario que introduzca una frase y cuente cuántas vocales hay en ella. El programa debe contar tanto las vocales minúsculas como las mayúsculas.

Por ejemplo:

  • Frase introducida: “Ocho elefantes comen trigo en un trigal”
  • Resultado: 14 vocales

Solución propuesta:

# Solicitar al usuario que introduzca una frase
frase = input("Introduce una frase: ")

# Inicializar el contador de vocales
contador_vocales = 0

# Definir una lista de vocales tanto en minúsculas como mayúsculas
vocales = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']

# Contar el número de vocales en la frase
for caracter in frase:
    if caracter in vocales:
        contador_vocales += 1

# Imprimir el resultado
print("Resultado:", contador_vocales, "vocales")

Ejercicio 2: Lista de listas

Crear la siguiente lista de dos dimensiones: lis1 = [[4,3,5],[3,5,8],[4,5,6]]. Con esta lista realizamos las siguientes operaciones:

  1. Crear una función llamada obt_valor_medio que calcule usando iteraciones el valor medio de todos elementos de la lista anterior (resultado: 4,78).
  2. Crear una función que realice un cálculo sobre los elementos de la lista anterior. El alumno puede elegir el cálculo a realizar. La función recibe como entrada la lista y da un valor de retorno.

Solución propuesta:

# Lista inicial
lis1 = [[4, 3, 5], [3, 5, 8], [4, 5, 6]]

# Función para obtener el valor medio
def obt_valor_medio(lista):
    suma_elementos = 0
    num_elementos = 0
    for sublista in lista:
        for elemento in sublista:
            suma_elementos += elemento
            num_elementos += 1
    return suma_elementos/num_elementos

# Función que devuelve el valor máximo
def obt_valor_maximo(lista):
    maximo = lista[0][0]  # Inicializar el máximo con el primer elemento de la lista
    for sublista in lista:
        for elemento in sublista:
            if elemento > maximo:
                maximo = elemento
    return maximo

# Llamadas a las funciones
valor_medio = obt_valor_medio(lis1)
valor_maximo = obt_valor_maximo(lis1)

# Mostrar los resultados
print(f"Valor medio de los elementos de la lista: {valor_medio}")
print(f"Valor máximo de los elementos de la lista: {valor_maximo}")

Ejercicio 3: Invertir cadena de caracteres

Escribe un programa en Python que solicite al usuario ingresar una cadena de caracteres y luego imprima la misma cadena, pero con los caracteres en orden inverso. Por ejemplo, si el usuario ingresa «Hola mundo», el programa deberá imprimir «odnum aloH”.

Solución propuesta:

cadena = input("Ingrese una cadena de caracteres: ")
# Invierte la cadena usando el operador de slicing [::-1]
cadena_invertida = cadena[::-1]
print("La cadena invertida es:", cadena_invertida)

Ejercicio 4: Mediana de una lista

Escribe un programa que obtenga la mediana de una lista de enteros. La lista es inicializada en el código, no hay que pedir al usuario que introduzca ningún dato. Y el programa tiene que funcionar para cualquier lista, con independencia de la longitud de esta.

No sé puede utilizar la función median de la librería statistics que devuelve la mediana directamente, se trata de programar esa función.

Nota: Recordad que la mediana es el valor que ocupa el lugar central de un conjunto de datos ordenados. Por tanto, si un conjunto de datos tiene un número de elementos impar, la mediana es el valor que ocupa la posición central, teniendo el mismo número de elementos mayores que elementos menores. Si el conjunto de datos tiene un número par de elementos, entonces la mediana es la media de los dos valores centrales.

lista = [1,21,7,5,3,11,10]
# Ordenamos la lista en orden ascendente 
lista_ordenada = sorted(lista)
n = len(lista_ordenada)
# Calculamos la posición del elemento central
mitad=int(n/2)
# Verificamos si la longitud de la lista es par o impar
if n % 2 == 0: # Si es par, la mediana es el promedio de los dos elementos centrales
    mediana = (lista_ordenada[mitad-1] + lista_ordenada[mitad]) / 2
else:  # Si es impar, la mediana es el elemento central
    mediana = lista_ordenada[mitad]

print("La mediana de la lista es:", mediana)

Ejercicio 5: Detectando anagramas

Escribe un programa en Python que solicite al usuario ingresar una cadena de caracteres y luego determine si esa cadena es un anagrama de otra cadena ingresada posteriormente. Dos cadenas son anagramas si tienen las mismas letras, pero en distinto orden. Por ejemplo, «roma» y «amor» son anagramas.

# Solicitamos al usuario que ingrese la primera cadena
cadena1 = input("Ingrese la primera cadena: ")

# Solicitamos al usuario que ingrese la segunda cadena
cadena2 = input("Ingrese la segunda cadena: ")

# Convertimos ambas cadenas a minúsculas para compararlas de manera case insensitive
cadena1 = cadena1.lower()
cadena2 = cadena2.lower()

# Ordenamos ambas cadenas y comparamos si son iguales
if sorted(cadena1) == sorted(cadena2):
    print("Las cadenas son anagramas")
else:
    print("Las cadenas no son anagramas")

NOTA:

Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.

Listas en Python

Última actualización: noviembre 2024

Las listas en Python son estructuras de datos que guardan una colección de elementos que pueden ser de distinto tipo (cadenas, números, …). Estos elementos se presentan dentro de corchetes [ ] separados por comas. Un ejemplo sería el siguiente

lista=[2,"Cadiz",True,25.7]
print(type(lista))

Este código arrojaría el siguiente resultado:

&lt;class 'list'>

que nos muestra que la variable de nombre lista que acabamos de crear es tipo ‘list’

Vamos a ver ahora algunas de las acciones más habituales con listas.

funcion len()

Nos devuelve la longitud de una lista, es decir, el número de elementos que tiene.

lista=[2,"Cadiz",True,25.7]
numElementos=len(lista)
print(f"La longitud de la lista es {numElementos}")

Resultado:

La longitud de la lista es 4

Generar una lista vacia

Sencillamente no incluimos ningún elemento cuando la creamos.

lista=[]

También podemos vaciar una lista empleando la función clear( )

numeros=[1,3,5,7,9]
print("lista numeros",numeros)
numeros.clear()
print("lista numeros",numeros)

Resultado:

lista numeros [1, 3, 5, 7, 9]
lista numeros []

Accediendo a los elementos de una lista

Podemos acceder a un elemento concreto de la lista, a través de su índice. Los índices comienzan en cero

lista=[2,"Cadiz",True,25.7]
print(f"el primer elemento de la lista es {lista[0]}")
print(f"el tercer elemento de la lista es {lista[2]}")

Resultado:

el primer elemento de la lista es 2
el tercer elemento de la lista es True

Podemos recorrer la lista empezando por el final, empleando índices negativos. Para -1 recuperamos el último elemento, para -2 el penultimo y así sucesivamente.

lista=[2,"Cadiz",True,25.7]
print(f"el ultimo elemento de la lista es {lista[-1]}")
print(f"el penultimo elemento de la lista es {lista[-2]}")

Y el resultado sería:

el ultimo elemento de la lista es 25.7
el penultimo elemento de la lista es True

Es posible recuperar también un rango de elementos, indicando los índices de los extremos separados por dos puntos [elemento_inicial:elemento_final] (no recupera el último elemento)

lista=[2,"Cadiz",True,25.7]
trozo=lista[1:3]
print(trozo)

Resultado:

['Cadiz', True]

Si queremos extraer un fragmento desde el principio hasta una posición, dejamos el índice del extremo inicial vacio y indicamos hasta que índice queremos recuperar en el extremo final (recordar este último elemento no se incluye). Y al contrario, si quisiéramos obtener un fragmento desde una posición hasta el final de la lista, indicamos en el extremo inicial el índice del elemento que inicia el fragmento y dejamos vacio el elemento final:

lista=[2,"Cadiz",True,25.7]
fragmento1=lista[:3]
fragmento2=lista[1:]
print("fragmento1= ",fragmento1)
print("fragmento2= ",fragmento2)

Resultado:

fragmento1=  [2, 'Cadiz', True]
fragmento2=  ['Cadiz', True, 25.7]

Comprobando si un elemento está en una lista

Para comprobar si un elemento está incluido en una lista, empleamos el operador in. El primer operando es el elemento que queremos comprobar si está en la lista y el segundo es la lista. La operación devuelve un booleano:True/False

lista=["Cadiz","Sevilla","Cordoba","Madrid","Leon","Gijon"]
ciudad="Cadiz"
if(ciudad in lista):
    print(f"{ciudad} está en la lista")
else:
    print(f"{ciudad} no está en la lista")

Resultado:

Cadiz está en la lista

count (<elemento>): Utilizando la función count(<elemento>) podemos saber el número de veces que aparece un elemento en una lista. Sencillamente le pasamos el valor de dicho elemento y la función count(<elemento>) devuelve el número de veces que aparece en la lista.

lista=["Cadiz","Sevilla","Cadiz","Madrid"]
ciudad="Cadiz"
veces= lista.count(ciudad)
print(f"{ciudad} aparece {veces} veces en la lista")

Resultado:

Cadiz aparece 2 veces en la lista

Modificando los elementos de una lista

Las variables de tipo lista son mutables, lo cual quiere decir que se pueden modificar. Además, una lista, admite valores repetidos. Podemos cambiar el valor de un elemento de una lista accediendo a él a través del índice.

lista=["Cadiz","Sevilla","Cordoba","Madrid"]
indice=2
print(lista[indice])
lista[2]="Gijon"
print(lista[indice])

Y el resultado:

Cordoba
Gijon

Borrar elementos de una lista

Podemos borrar el elemento indicando su posición o por su valor.

Para borrar indicando su posición, tenemos dos funciones: del y pop

  • del(posición): borra el elemento y no devuelve nada
lista=["Cadiz","Sevilla","Cordoba","Madrid"]
indice=1
del(lista[indice])
print(lista)

Resultado:

['Cadiz', 'Cordoba', 'Madrid']
  • pop(posición): borra el elemento y devuelve el elemento borrado.
lista=["Cadiz","Sevilla","Cordoba","Madrid"]
print(f"lista inicial: {lista}")
indice=1
ciudad_borrada=(lista.pop(indice))
print(f"Ciudad eliminada: {ciudad_borrada}")
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba', 'Madrid']
Ciudad eliminada: Sevilla
nueva lista ['Cadiz', 'Cordoba', 'Madrid']

Si usamos pop() sin indicar índice, borraremos el último elemento de la lista, que equivale al último elemento introducido, como si fuera una pila, el que está en lo más alto.

lista=["Cadiz","Sevilla","Cordoba","Madrid"]
print(f"lista inicial: {lista}")
ciudad_borrada=(lista.pop())
print(f"Ciudad eliminada: {ciudad_borrada}")
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba', 'Madrid']
Ciudad eliminada: Madrid
nueva lista ['Cadiz', 'Sevilla', 'Cordoba']

Por otro lado, para borrar un elemento de una lista por su valor, usamos la función remove(valor).

  • remove(valor): Eliminamos la primera aparición del elemento
lista=["Cadiz","Sevilla","Cordoba","Madrid","Cadiz","Merida"]
print(f"lista inicial: {lista}")
lista.remove("Cadiz")
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba', 'Madrid', 'Cadiz', 'Merida']
nueva lista ['Sevilla', 'Cordoba', 'Madrid', 'Cadiz', 'Merida']

La función remove sólo elimina la primera aparición del elemento, con lo que tendremos que usar un bucle while para eliminarlos todas las apariciones del valor, mientras exista el valor en la lista.

lista=["Cadiz","Sevilla","Cordoba","Madrid","Cadiz","Merida","Cadiz"]
print(f"lista inicial: {lista}")
borrar_ciudad="Cadiz"
while (borrar_ciudad in lista):
    lista.remove(borrar_ciudad)
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba', 'Madrid', 'Cadiz', 'Merida', 'Cadiz']
nueva lista ['Sevilla', 'Cordoba', 'Madrid', 'Merida']

Añadir elementos a una lista

  • append( ): Con esta función añadimos un elemento al final de la lista, pasando como parámetro el elemento que queremos añadir.
lista=["Cadiz","Sevilla","Cordoba"]
print(f"lista inicial: {lista}")
lista.append(5)
lista.append("Madrid")
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba']
nueva lista ['Cadiz', 'Sevilla', 'Cordoba', 5, 'Madrid']

Recordemos que los elementos de una lista pueden ser de distinto tipo

  • insert( <posicion>,<elemento> ): inserta el elemento <elemento> en la posición <posición>
lista=["Cadiz","Sevilla","Cordoba"]
print(f"lista inicial: {lista}")
lista.insert(2,"Puerto de Santa Maria")
print(f"nueva lista {lista}")

Resultado:

lista inicial: ['Cadiz', 'Sevilla', 'Cordoba']
nueva lista ['Cadiz', 'Sevilla', 'Puerto de Santa Maria', 'Cordoba']
  • extend(<list>): añade al final de una lista, los elementos de la lista que se le pase como parámetro.
lista=["Cadiz","Sevilla","Cadiz","Madrid"]
añadidos=["Gijon","Leon","Pontevedra"]
lista.extend(añadidos)
print(lista)

Resultado:

['Cadiz', 'Sevilla', 'Cadiz', 'Madrid', 'Gijon', 'Leon', 'Pontevedra']

Ordenar los elementos de una lista

  • sorted(<lista>): La función sorted( ) nos permite ordenar los elementos de una lista que le pasemos como parámetro. Con el parámetro reverse, podemos indicar si queremos ordenar en orden descendente.
ciudades=["Cadiz","Sevilla","Cordoba","Gijon","Bilbao","Santander"]
ciudades_ordenAscendente=sorted(ciudades)
ciudades_ordenDescendente=sorted(ciudades,reverse=True)
print("--Lista inicial:---")
print(ciudades)
print("--Lista ordenada en orden ascendente:---")
print(ciudades_ordenAscendente)
print("--Lista ordenada en orden descendente:---")
print(ciudades_ordenDescendente)

Resultado:

--Lista inicial:---
['Cadiz', 'Sevilla', 'Cordoba', 'Gijon', 'Bilbao', 'Santander']
--Lista ordenada en orden ascendente:---
['Bilbao', 'Cadiz', 'Cordoba', 'Gijon', 'Santander', 'Sevilla']
--Lista ordenada en orden descendente:---
['Sevilla', 'Santander', 'Gijon', 'Cordoba', 'Cadiz', 'Bilbao']

Obviamente, también funciona con números

Además. disponemos de la función reverse( ) que nos permite invertir el orden de los elementos en la lista: El último pasaría a ser el primero, el penúltimo el segundo y así sucesivamente. No hay que confundir el método reverse( ) con el parámetro reverse que empleábamos en el método sorted( )

numeros=[1,3,5,7,9]
print("lista numeros",numeros)
numeros.reverse()
print("lista numeros",numeros)

Resultado

lista numeros [1, 3, 5, 7, 9]
lista numeros [9, 7, 5, 3, 1]

Anidar listas en listas

Los elementos de una lista pueden ser cualquier tipo de objeto, y eso incluye otra lista.

sur=["Cadiz","Sevilla","Cordoba"]
norte=["Gijon","Bilbao","Santander"]
ciudades=[sur,norte,["Madrid","Caceres","Toledo"]]
print(f"ciudades: {ciudades}")

Resultados:

ciudades: [['Cadiz', 'Sevilla', 'Cordoba'], ['Gijon', 'Bilbao', 'Santander'], ['Madrid', 'Caceres', 'Toledo']]

Para acceder a un elemento de una lista incluida en otra lista, accedo a través de los índices de forma jerárquica: primero el índice de la posición de la lista incluida y después el índice del elemento en la lista incluida.

Empleando el ejemplo anterior, para acceder al elemento “Gijon”, primero indicamos el índice de la posición que ocupa la lista dentro de la lista principal (segundo elemento: índice =1) y luego indicamos el índice de la posición que ocupa el elemento en la lista incluida (primer elemento: índice=0)

sur=["Cadiz","Sevilla","Cordoba"]
norte=["Gijon","Bilbao","Santander"]
ciudades=[sur,norte,["Madrid","Caceres","Toledo"]]
ciudad=ciudades[1][0]
print(f"ciudad: {ciudad}")

Resultado:

ciudad: Gijon

Copiar listas

Existen diferentes formas de asignar los valores de una lista a otra. Si empleamos una asignación, el resultado es que ambas listas referencian el mismo objeto y al modificar una, modificamos la otra.

lista1=[1,3,5,7,9,11]
print(f"El primer elemento de lista1 es {lista1[0]}")
lista2=lista1
lista2[0]=0
print(f"El primer elemento de lista1 es {lista1[0]}")

Resultado:

El primer elemento de lista1 es 1
El primer elemento de lista1 es 0

Para asignar los valores de una lista a otra y que sean dos objetos independientes, empleamos el método copy. En el ejemplo siguiente, se copia lista1 en lista2, y las modificaciones que hagamos sobre la última no afectan a la primera.

lista1=[1,3,5,7,9,11]
print(f"El primer elemento de lista1 es {lista1[0]}")
lista2=lista1.copy( )
lista2[0]=0
print(f"El primer elemento de lista1 es {lista1[0]}")

Resultado:

El primer elemento de lista1 es 1
El primer elemento de lista1 es 1

También podríamos utilizar índices para copiar un conjunto de elementos de una lista a otra. Sencillamente seleccionamos el rango de elementos que queramos copiar indicando los indices de principio y fin (recuerda que python no incluye el indice final del rango). Por ejemplo, el siguiente código copia los elementos desde la segunda posición (indice 1) a la cuarta (indice 3).

lista1=[1,3,5,7,9,11]
print(f"lista1 es :{lista1}")
lista2=lista1[1:4]
print(f"lista2 es {lista2}")

El resultado:

lista1 es :[1, 3, 5, 7, 9, 11]
lista2 es [3, 5, 7]

e indicando todos los indices podríamos copiar la lista entera

lista2=lista1[:]

Funciones en listas de numeros

Hay algunas funciones muy útiles cuando nuestra lista es de números:

  • min(lista): devuelve el valor mínimo
  • max (lista): devuelve el valor máximo
  • sum (lista): devuelve la suma de los elementos de la lista
numeros=[1,3,5,7,9]
print("valor minimo",min(numeros))
print("valor maximo",max(numeros))
print("suma de todos los numeros ",sum(numeros))

Resultado:

valor minimo 1
valor maximo 9
suma de todos los numeros  25

Emplearemos las listas cuando trabajemos con conjuntos de datos que se puedan repetir y que tengamos que modificar

NOTA:

Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.

Variables en Python

Última actualización: septiembre 2024

Las variables en Python pueden contener distintos tipos de datos básicos:

  • Cadenas de texto
  • Booleanos (True o False)
  • Numéricos: enteros, decimales y complejos
  • Colecciones: listas, tuplas, conjuntos, diccionarios.

Como veremos más adelante algunos de estos tipos de variables se pueden modificar (tipos mutables) y otros no se pueden modificar (inmutable)

Al añadir módulos, aparecen nuevos tipos como fechas u otros tipos de colecciones o estructuras de datos El objetivo es emplear el tipo de dato o estructura que mejor se ajuste a los datos con los que vamos a trabajar.

Creación de variables

La creación de variables en Python es sencilla, directamente asignamos un valor a la variable e internamente Python le asigna el tipo (entero, cadena, lista..). Es decir, no tenemos que declarar e inicializar las variables, sino que directamente las inicializamos asignándoles un valor y Python infiere el tipo de la variable en función del valor asignado, es lo que se conoce como tipado dinámico.

Internamente las variables son referencias a los objetos. Una variable es una especie de etiqueta para referirnos al objeto. En el siguiente ejemplo, creamos dos variables: curso (cadena de texto) y numero_horas (entero).

curso = “Python”
numero_horas = 20

Es posible asignar asignación múltiple:

a, b = 6, 8
c = d = e = 7

Para conocer el tipo de una variable, empleamos la función type:

curso ="Python"
tipo=type(curso)
print(tipo)

Resultado: <class ‘str’>

Los nombres de las variables deben ser secuencias de letras y números. La secuencia debe empezar por letras. También es válido el carácter: “_”.

Ahora que sabemos como conocer el tipo de una variable, podemos experimentar el tipado dinámico. En el ejemplo siguiente, a una misma variable, se le asigna primero un valor numérico y luego un valor de texto, y vemos como Python cambia el tipo de la variable.

variable =99
print(type(variable))
variable ="Python"
print(type(variable))

Resultado:

&lt;class 'int'>
&lt;class 'str'>

Variables numéricas

Las variables de tipo numéricas almacenan números y pueden ser de tres tipos:

int: valores enteros.

float: valores con decimales (separador punto).

complex: números complejos.

edad = 35
margen = 22.75

Operaciones combinando números enteros y flotantes:

Dividiendo siempre obtendremos un número flotante, aunque numerador y denominador sean enteros y el resultado sea exacto (resto 0)

Python por defecto devolverá un flotante para no perder precisión cuando operamos con un entero y un flotante.

numero_1= 77
numero_2=10
print(numero_1/numero_2)

Resultado: 7.7

Guiones en números:

Trabajando con números largos podemos agrupar los dígitos utilizando guiones bajos para leerlos mejor:

numeroWebs=3_876_345_765
print("numero de webs en el mundo: ",numeroWebs)

Resultado:

numero de webs en el mundo:  3876345765

Operadores aritméticos

Los operadores aritméticos los emplearemos para realizar operaciones con variables numéricas. El siguiente cuadro muestra una lista de los principales operadores aritméticos y la operación que implementan:

OperadorOperación aritmética
X + YSuma
X – YResta
X * YProducto
X / YDivisión
X // YDivisión entera
X % YResto
X ** YX elevado a Y
X +=1Incremento
Operadores aritméticos

Ejemplos de operaciones:

numero1=2
numero2=3
print("Numero 1 : ",numero1)
print("Numero 2 : ",numero2)
print("La suma del Numero 1 y del Numero 2 es: ",numero1+numero2)
print("división del Numero 1 entre el Numero 2 es: ",numero1/numero2)
print("Numero 1 elevado al Numero 2 es: ",numero1**numero2)
print("La división del Numero 1 entre el Numero 2 tiene un resto de: ",numero1%numero2)

Resultado:

Numero 1 :  2
Numero 2 :  3
La suma del Numero 1 y del Numero 2 es:  5
división del Numero 1 entre el Numero 2 es:  0.6666666666666666
Numero 1 elevado al Numero 2 es:  8
La división del Numero 1 entre el Numero 2 tiene un resto de:  2

Variables de tipo cadena

Las variables de tipo cadena o string guardan cadenas de caracteres y se representan con comillas simples o dobles.

ciudad1 = ‘Madrid’
ciudad2 = “Valencia”

Función len( ): devuelve la longitud de la cadena que se le pasa como parámetro.

ciudad="Madrid"
longitud=len(ciudad)
print(longitud)

Resultado: 6

Concatenar cadenas: sencillamente utilizamos el signo “+”, como si estuviéramos sumando números.

ciudad1="Madrid"
ciudad2="Cadiz"
print(ciudad1+" - "+ciudad2)

Resultado:

Madrid – Cadiz

Acceder a los caracteres de una cadena: Las cadenas se pueden acceder elemento a elemento mediante índices. Obteniendo caracteres sueltos o subcadenas de la cadena principal:

ciudad="Cadiz"
print(ciudad[0])
print(ciudad[1:3])

Resultado:

C
ad

La primera posición de la cadena, correspondiente al primer carácter, se corresponde con el índice 0.

Cuando marcamos un rango, el número superior del rango no se incluye. En el ejemplo, el rango [1:3], incluye los caracteres con índices 1 y 2.

Las cadenas son inmutables no puedo modificar un elemento. El código:

ciudad="Cadiz"
ciudad[1]="w"

Arroja el error:

TypeError: 'str' object does not support item assignment

Las variables de tipo cadena tienen una serie de métodos asociados para realizar distintas operaciones (dividir, buscar, reemplazar…).Cada clase de Python tiene métodos asociados y las cadenas son una clase más.

Algunos de los métodos más utilizados son:

split([sep]): Divide una cadena en subcadenas utilizando el carácter separador indicado por el parámetro sep

saludo="Buenos-dias-hoy"
lista=saludo.split(sep="-")
for trozo in lista:
    print(trozo)

Resultado:

Buenos
dias
hoy

lower( ) y upper( ): convierte los caracteres de la cadena a minúsculas o mayúsculas respectivamente:

saludo="Buenos dias"
print(saludo.lower())
print(saludo.upper())

Resultado:

buenos dias
BUENOS DIAS

cad.rstrip( ): Elimina los caracteres en blanco al final de la cadena

cad.lstrip( ): Elimina los caracteres en blanco al comienzo de la cadena

cad.strip( ): Elimina los caracteres en blanco al comienzo y al final de la cadena

saludo="  Buenos dias  "
print("--",saludo.rstrip(),"--")
print("--",saludo.lstrip(),"--")
print("--",saludo.strip(),"--")

Resultado:

--   Buenos dias --
-- Buenos dias   --
-- Buenos dias --

cad.title( ): Pone la inicial de cada palabra a mayúscula

saludo="buenos dias  "
print(saludo.title())

Resultado:

Buenos Dias

Cadenas de texto formateadas: Son las conocidas como cadenas f, ya que se coloca una f antes de las comillas de comienzo de la cadena y Python reemplaza cualquier variable entre llaves por su valor.

nombre="Pedro"
apellidos="Garcia Martinez"
saludo=f"Buenos días, {nombre} {apellidos}"
print(saludo)

Resultado:

Buenos días, Pedro Garcia Martinez

Caracteres de escape: Fundamentalmente emplearemos dos:

\n: nueva línea

\t: tabulador

texto="Asistentes:\n\tPedro\n\tMaria\n\tJuan"
print(texto)

Resultado:

Asistentes:
	Pedro
	Maria
	Juan

Variables de tipo booleano

Las variables de tipo booleano o tipo de dato lógico representan valores de lógica binaria, esto es 2 valores, que normalmente representan falso (False) o verdadero (True).

Por ejemplo, un booleano puede guardar el resultado de una comparación:

a=7
b=3
comparacion=(a==b)
print(comparacion)

Resultado: False

Conversión de tipos

Hemos visto diferentes tipos de variables entre las que es frecuente tener que realizar conversiones de tipo para pasar un valor almacenado en un tipo de variable a otro tipo de variable. Las funciones que realizan estas conversiones tienen el mismo nombre que el tipo de variable de destino. Por ejemplo si pasamos un valor a cadena (str) la función es str().

numero= 77
print(f"{numero} es de tipo {type(numero)}")
numero= str(numero)
print(f"{numero} es de tipo {type(numero)}")
numero=int(numero)
print(f"{numero} es de tipo {type(numero)}")
numero=float(numero)
print(f"{numero} es de tipo {type(numero)}")

Resultado:

77 es de tipo <class 'int'>
77 es de tipo <class 'str'>
77 es de tipo <class 'int'>
77.0 es de tipo <class 'float'>

Comentarios

Para realizar comentarios en Python tenemos dos opciones básicas:

  • Comentario de una línea, para el que emplearemos el carácter almohadilla.
  • Comentario para un bloque, donde emplearemos tres comillas al comienzo del bloque y otras tres al final.
#linea de comentario
"""
primera linea del bloque de comentarios
este bloque tiene tres lineas de comentarios
ultima linea del bloque
"""

NOTA:

Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.

Introducción a Python

Última actualización: septiembre 2024

Python es uno de los lenguajes de programación más extendidos y que más está creciendo, empleado en multitud de campos como el análisis de datos, la inteligencia artificial o el desarrollo de juegos.

Es además un software libre administrado por Phyton Software Foundation: www.python.org

Versiones Python

Actualmente se mantienen dos versiones de Python en paralelo:

  • Versiones 2.x (desde el año 2.000)
  • Versiones 3.x (en paralelo con 2.x desde 2.008)

Existen algunas diferencias notables entre la versión 3 y la 2. En este curso, nos centraremos en la versión 3, la versión 2 está prácticamente en desuso.

Vamos a trabajar con la versión 3.11, que es la más actual que aparece como segura desde el punto de vista de mantenimiento:

Estado de las distintas versiones de Python (septiembre 2024)

Características y ventajas principales

Phyton tiene importantes ventajas sobre otros lenguajes:

  • Es de propósito general.
  • Interpretado.
  • Tipado dinámico.
  • Open source.
  • Lenguaje multiparadigma: procedural, funcional, POO.
  • Multiplataforma: Linux, Windows, OSX.
  • Python busca: simplicidad, elegancia y legibilidad.
  • Gran comunidad de usuarios.
  • Es el lenguaje que más rápido ha crecido en los últimos años por delante de lenguajes como Javascript, Java, PHP, C++

Cuando empiezas a programar con Python es habitual que te llegue información del PEP 20, que es la «filosofía» empleada en el diseño de este lenguaje de programación. Los principios de esta filosofía, conocida como el Zen de Python, fueron declarados por Tim Peters, el creador de la primera versión de Python: CPython.

A mi modo de ver es recomendable dedicar unos minutos a leer estos principios antes de sumergirse en la tarea de aprender Python, según vayamos aprendiendo el lenguaje iremos apreciando la implementación de estos principios. Por ello te reproduzco aquí los principios del Zen de Python:

El Zen de Python, por Tim Peters

Lo bonito es mejor que lo feo.
Lo explícito es mejor que lo implícito.
Lo simple es mejor que lo complejo.
Lo complejo es mejor que lo complicado.
Lo plano es mejor que lo anidado.
Lo disperso es mejor que lo denso.
La legibilidad cuenta.
Los casos especiales no son lo suficientemente especiales como para romper las reglas.
Aunque la practicidad vence a la pureza.
Los errores nunca deben pasar en silencio.
A menos que se silencien explícitamente.
En caso de ambigüedad, rechaza la tentación de adivinar.
Debería haber una, y preferiblemente solo una, forma obvia de hacerlo.
Aunque esa forma puede no ser obvia al principio, a menos que seas holandés.
Ahora es mejor que nunca.
Aunque nunca es mejor que *ahora mismo*.
Si la implementación es difícil de explicar, es una mala idea.
Si la implementación es fácil de explicar, puede que sea una buena idea.
Los espacios de nombres son una gran idea, ¡hagamos más de ellos!

Si quiere leer un poco más de este tema, puedes echar un ojo a este post.

Instalando Python

Obviamente, antes de empezar a trabajar con Python, lo primero que tenemos que hacer es instalarlo en nuestro ordenador. La instalación es distinta dependiendo del sistema operativo que empleemos.

Pero antes de lanzarte a instalar Python, mi recomendación es que mejor te instales el paquete Anaconda, que además de Python incluye herramientas muy útiles para trabajar con este lenguaje de programación. Si vas a instalarte Anaconda directamente, pasa a la sección de Instalando Anaconda.

Instalación en Windows

Es posible que ya tengamos instalado Python porque lo hayamos hecho con alguna aplicación, así es que empezaremos por comprobar si ya lo tenemos instalado. Para ello abrimos una ventana de comandos (tecleamos cmd en la ventana de aplicaciones) e introducimos el comando:

python --version

Si lo tenemos instalado, veremos la versión de Python que tenemos instalada:

C:\ProgramData\anaconda3>python --version
Python 3.12.4

Posteriormente, cuando trabajemos en proyectos y nos creemos un entorno específico para cada proyecto, veremos que podemos instalar la versión del interprete que queramos para ese proyecto.

Si NO lo tenemos instalado, veremos algo similar a:

C:\Users\Jegarcia>python - -version
No se encontr¾ Python; ejecuta sin argumentos para instalar desde Microsoft Store o deshabilita este acceso directo en Configuraci¾n > Administrar alias de ejecuci¾n de la aplicaci¾n.

Aunque también puede ocurrir que no tengamos la ruta de Python en la variable de entorno Path, por lo que para ejecutar Python tendríamos que colocarnos en la carpeta donde estuviera el ejecutable.

Si no lo tenemos instalado y tecleamos directamente «Python» en la ventana de la consola. Dependiendo de la versión de Windows, es posible que te dirija a Microsoft Store y te permita obtenerlo desde ahí:

Descarga de Python 3.12 desde Microsoft Store
Descarga de Python desde Microsoft Store

También podemos ir a descargarlo directamente desde la web oficial: downloads

Descarga de Python desde la web Oficial (septiembre 2024)

Las versiones de Python tienen tres valores separados por puntos. El primero indica la versión principal, el segundo una versión secundaria y el tercero la versión micro. En este caso, lo importante es que trabajemos con la versión principal 3, ya que hay diferencias notables con la versión principal 2. Idealmente iremos a la última versión en estado: “security”, lo que indica que la versión está segura, que en nuestro caso es 3.11 (septiembre 2024)

Ahora procederíamos a instalarlo y una vez instalado, comprobamos en una ventana de comandos la versión instalada, como indicaba al principio de este apartado.

Con Python ya instalado, lo único que necesitaríamos hacer es instalarnos un IDE de nuestra elección para empezar a programar. Algunos de los más utilizados con Python son: Jupyter Notebook, Visual Studio Code y Spyder.

Instalando Anaconda

No obstante, Python es un lenguaje de propósito general que tiene múltiples campos de aplicación: ciencia en datos, aprendizaje automático, etc, para los que emplearíamos otras aplicaciones y librerías. Por ello, nos puede resultar más interesante instalarnos una distribución de Python que incluya varias de estas herramientas. La más popular sin duda es Anaconda.

Herramientas disponibles en el repositorio Anaconda

Podemos descargar Anaconda desde el repositorio oficial: descarga Anaconda

Nos descargamos Anaconda y así además de Spyder, tenemos Jupyter, pero también un montón de librerías que emplearemos luego en ciencia en datos, como Numpy, Pytorch, pandas y matplotlib. Además, tendríamos tensorFlow por si trabajamos con IA.

Anaconda provee distintos instaladores para los distintos Sistemas Operativos con los que trabajemos. Todos ellos de sencilla instalación, en la que seguiríamos las indicaciones del instalador para realizar la instalación recomendada.

NOTA:

Este post es parte de la colección “Python”. Puedes ver el índice de esta colección aquí.

Tratamiento de excepciones en java

Cuando estamos programando, no todos los errores se producen cuando compilamos el código, sino que también se pueden producir errores en tiempo de ejecución. A estos errores que ocurren cuando ejecutamos el programa, se les conoce con el nombre de excepción. En este post, hablaré del tratamiento de excepciones en java.

Vamos a distinguir dos tipos de excepciones: las chequeadas y las no chequeadas. Por las primeras entendemos aquellas que manejamos en nuestro código con instrucciones que proporciona el lenguaje de programación, en el caso de Java serían los bloques try – cath. Y por excepciones no chequeadas entenderemos aquellas que no tratamos en nuestro código.

Excepciones no chequeadas

Las excepciones no chequeadas son errores de nuestro código que dependen de nosotros y debiéramos ser capaces de evitar empleando técnicas de programación segura. Un ejemplo clásico de este tipo de excepciones es la división por cero, que arroja un número infinito que el ordenador no puede tratar.

En la siguiente actividad, practicamos el manejo de las excepciones no chequeadas.

Actividad: Manejo de excepciones no chequeadas

  1. Empezamos abriendo un proyecto nuevo para practicar con las excepciones. En mi caso, le pongo de nombre al proyecto: PracticandoConExcepciones.
  2. Elimino los comentarios y me queda el código inicial:
  1. De momento nada nuevo. Vamos a crear ahora un código que nos genere un error de programación que se manifieste en tiempo de ejecución. Por ejemplo, la división por cero.
  2. Nuestro código sería:
  1. Con este código estamos realizando una división por cero que nos arrojaría la correspondiente excepción en ejecución. Mostrándonos un error. En este caso, NetBeans es capaz de evitarlo ya que este es un error tan habitual que ya lo tiene contemplado. Si ejecutamos el programa obtendremos:
  1. Se trata de un error tan básico que el compilador es capaz de tratarlo automáticamente. No obstante, es un error y nosotros no queremos que se produzca. El resultado infinito no nos vale para nada y no podemos operar con él.
  2. ¿Cómo prevenir este error?: Aplicando programación segura que en muchos casos se limita a comprobar los valores antes de operar con ellos.
  3. Pero mejor, veamos otro ejemplo muy habitual de excepción no chequeada que esta vez no solucione el compilador. Se trata del error: NullPointerException, intentamos leer el contenido de una variable que no contiene nada, que es nula. Por ejemplo, tecleamos el código siguiente:
  1. En este código intentamos acceder al String texto para, usando la función toUpperCase, pasar el texto a mayúsculas. Pero el texto es nulo, no tenemos nada. Si ejecutamos el programa, obtendremos el siguiente error:
  1. Donde vemos la excepción arrojada: NullPointerException. Para evitar esta excepción con prácticas de programación segura, sencillamente tendremos que comprobar antes que el String no es nulo. Haríamos algo parecido a:
  1. Si ejecutáramos ahora el programa, veremos que ya no se produce el error. Y a partir de este punto, podemos programar la respuesta para este caso. Por ejemplo, pedirle al usuario que introduzca un texto:
  1. Si ejecutamos ahora el programa, un posible resultado sería:
  1. Otra excepción no chequeada muy frecuente es: ArrayIndexOutOfBoundsException. Como su nombre indica, se produce cuando intentamos acceder a un elemento de un array empleando un índice que está fuera del rango. Por ejemplo si tenemos un array de 5 elementos e intentamos acceder al elemento array[5], nos daría esta excepción (recordemos que los índices de los arrays empiezan en 0, así que para un array de 5 elementos el rango de índices es 0-4)
  2. El alumno puede probar a reproducir esta excepción programando su propio código.

Excepciones chequeadas

Las excepciones chequeadas son aquellas que dependen del entorno y nosotros, como programadores, no tenemos manera de evitarlas. Lo que tenemos que hacer es asegurarnos de que las tratamos. Un ejemplo clásico de este tipo de excepciones es cuando el usuario nos tiene que proporcionar algún dato y lo hace de forma incorrecta. Por ejemplo, nos tiene que proporcionar la ruta a un fichero y lo hace mal, con lo que al intentar acceder al fichero no podremos y obtendríamos un error.

Para tratar estas excepciones, Java provee los bloques try – catch que el compilador nos va a obligar a utilizar cuando una operación tenga riesgo de arrojar una excepción, como por ejemplo abrir un fichero.

Las excepciones no chequeadas, que veíamos en el apartado anterior, también pueden ser tratadas en el código con un bloque try – catch, pero es más recomendable evitarlas con prácticas de programación segura en lugar de permitir que ocurran y tratarlas después.

Como siempre, practiquemos estos conceptos en una actividad.

Actividad: Manejo de excepciones chequeadas

  1. Continuamos trabajando en el proyecto: PracticandoConExcepciones.
  2. Para practicar las excepciones chequeadas, vamos a realizar un programa que cree un fichero y que introduzca una serie de datos en el mismo. Aunque todavía no hemos visto la clase File para el manejo de ficheros, aquí tendremos un pequeño adelanto para ver cómo tratar las excepciones con los bloques try-catch. Veremos también, que el compilador nos obliga a tratar este tipo de excepciones.
  3. Tecleamos el siguiente código:
  1. Nos hemos creado un objeto tipo File que en realidad es la ruta a nuestro fichero. Para crear el fichero empleamos la función createNewFile(). No hay que preocuparse de momento por el manejo de esta Clase, en el próximo cuaderno veremos el manejo de ficheros.
  2. De momento, lo que vemos es que el compilador nos indica el siguiente error:
  1. Nos fuerza a tratar la excepción, nos dice que tenemos que tratar la excepción que podría causarse al ejecutar esta instrucción.
  2. Esa excepción no es un error de programación. Puede deberse por ejemplo a que no exista el directorio donde queremos crear el fichero, un error de entorno imposible de evitar por programación, por lo que hay que asegurarnos de que los tratamos en nuestro código.
  3. Si clicamos en el icono que nos da el aviso de que tenemos que tratar la excepción, el compilador nos da algunas opciones. Vamos a escoger la opción:
  1. Y nuestro código quedaría:
  1. Podemos ver, que la sentencia que nos puede arrojar la excepción, en la línea 11, la hemos introducido dentro del bloque try. El código de la línea 13 lo introducimos nosotros para enseñar por pantalla la excepción que se produce.
  2. Así funciona el bloque try-catch. Colocamos en el bloque try las sentencias que queramos ejecutar que puedan causar una excepción. Y en el bloque catch colocamos las sentencias que emplearemos para tratar esa posible excepción
  3. El bloque catch recibe como parámetro la excepción que se ha producido. Sin embargo, ahora el programa no se interrumpirá arrojando un error, sino que se pasará a ejecutar las instrucciones en el bloque catch.
  4. Si ejecutamos este programa, obtenemos:
  1. Vemos que se produce una excepción que nos indica que la ruta donde hemos querido crear el fichero no se encuentra. Normal, es que no existe, no he creado la carpeta pruebas.
  2. Tratamos la excepción dentro de un bloque catch, escribiendo la misma por pantalla y el programa sigue su curso, ejecutando la línea 13. Pero el programa no ha fallado y ni se ha interrumpido delante del usuario, sino que hemos tratado la excepción y el programa ha finalizado de manera ordenada.

Para entender un poco mejor como funciona los bloques try-catch, vamos a introducir algunas líneas más en nuestro código. Dibujando mensajes por pantalla podremos entender mejor el flujo de nuestro programa. El código queda:

  1. Las nuevas líneas introducidas son sentencias simples para presentar por pantallas distintos mensajes que indican el momento en el que estamos en el programa.
  2. Las dos primeras líneas del bloque try:

Siempre se ejecutarán. Si se produjera una excepción en la segunda, el programa saltaría al bloque catch. Si tal excepción no se produce, continúa ejecutando las instrucciones en el bloque try y cuando acaba, sin que se produzcan excepciones, no ejecuta el bloque catch y continua con el código. En este caso, en la línea 18.

  1. Si ejecutamos el programa sin crear la carpeta pruebas, generaríamos la excepción y el resultado sería:
  1. Por el contrario, si creamos la carpeta, el resultado de la ejecución sería:

La clausula Finally

Viendo cómo funciona el bloque try-catch, podemos echar en falta una funcionalidad. No tenemos forma de hacer que un conjunto de instrucciones se ejecute siempre, con independencia de que se produzca la excepción o no. Podríamos duplicar el código en ambos bloques, try y catch, pero esto es bastante ineficiente.

Esta situación se da en no pocas ocasiones. Por ejemplo, trabajando con ficheros, debiéramos cerrar los objetos una vez utilizados, empleando el método close, se haya producido excepción o no. Si estamos intentando acceder a una base de datos, tendríamos básicamente la misma situación.

Para dar solución a este tema, java introduce un bloque adicional al try-catch, el bloque finally. Vamos a verlo en un ejemplo con un fichero.

Actividad: Entendiendo la clausula finally

  1. Continuamos trabajando en el proyecto: PracticandoConExcepciones. Recupero aquí el último código que tecleamos:
  1. Para probar el uso de finally, añadimos la cláusula con un mensaje. Aunque no tiene mucho sentido, nos ayuda a probar y entender el funcionamiento de finally. El código podría ser:
  1. Si ejecutamos este código, como no se produce excepción, el resultado sería:
  1. Lo siguiente que haremos será provocar una excepción para analizar el comportamiento de finally en este caso. Para ello, cambiamos el nombre de la carpeta donde íbamos a crear el fichero, poniendo un carpeta que no exista.
  2. Si ejecutamos el programa obtenemos el siguiente resultado:

En ambos casos, podemos ver que las instrucciones dentro del bloque finally se ejecutan siempre, haya o no excepción.

NOTA: Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.

Ejercicios con entradas y salidas

Última actualización: septiembre 24

En esta ocasión, propongo algunos ejercicios muy sencillos para practicar lo explicado sobre las entradas y salidas estándar: teclado y pantalla.

Ejercicio 1: Aplicar descuento

Codifica un programa que calcule el descuento de una compra. El programa pedirá al usuario que indique el precio del producto, el número de unidades que compra y el descuento total que tiene. Con esos datos, el programa presenta por pantalla lo que ha pagado el cliente y lo que se ha ahorrado gracias al descuento.

Una posible solución es:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        double descuento, cantidad, precio;
        Scanner sc=new Scanner(System.in);
        System.out.println("Introduce el precio del producto");
        precio=sc.nextDouble();
        System.out.println("Indica cuantas unidades quieres comprar");
        cantidad=sc.nextDouble();
        System.out.println("Indica el descuento que te dan (0-100)");
        descuento=sc.nextDouble();
        System.out.println("Has comprado "+cantidad+" unidades con un descuento de "+descuento);
        System.out.println("Has pagado: "+(cantidad*precio*(1-descuento/100)));
        System.out.println("Te has ahorrado: "+(cantidad*precio*descuento/100));
    }
}

Ejercicio 2: Ecuación de segundo grado

Realiza un programa que devuelva los resultados de una ecuación de segundo grado. El usuario tiene que introducir por teclado los coeficientes de la ecuación de segundo grado. En el caso de no tener soluciones reales, hay que detectarlo e indicarlo con un mensaje por pantalla.

Recordatorio: para el polinomio:

las dos soluciones posibles vienen dadas por la ecuación:

Una posible solución sería:

import java.util.Scanner;

public class EcuacionSegundoGrado {

    public static void main(String[] args) {
        double a,b,c;
        double d, solucion1, solucion2;
        Scanner sc1=new Scanner(System.in);
        System.out.println("Introduce el coeficiente de segundo grado:");
        a=sc1.nextDouble();
        System.out.println("Introduce el coeficiente de primer grado:");
        b=sc1.nextDouble();
        System.out.println("Introduce el termino independiente:");
        c=sc1.nextDouble();
        d=b*b-4*a*c;
        if (d<0){
            System.out.println("No hay soluciones reales");
        }
        else {
            solucion1=-(b+Math.sqrt(d))/(2*a);
            solucion2=-(b-Math.sqrt(d))/(2*a);
            System.out.println("la primera solución es: "+solucion1);
            System.out.println("la segunda solución es: "+solucion2);
        }
    }
}

Ejercicio 3: Promedio de números introducidos

Realizar un programa que pida de manera interrumpida al usuario que introduzca un número entero positivo. El programa dejará de pedir al usuario que introduzca un número cuando el número introducido sea el cero. Al finalizar, el programa debe calcular y mostrar el promedio de los números introducidos.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numero;
        int suma = 0;
        int contador = 0;

        // Bucle para pedir números al usuario hasta que introduzca un 0
        while (true) {
            System.out.print("Introduce un número entero positivo (0 para terminar): ");
            numero = scanner.nextInt();
            if (numero == 0) {
                break; // Sale del bucle si el número introducido es 0
            } else if (numero > 0) {
                suma += numero;
                contador++;
            }
        }
        // Cálculo del promedio
        if (contador > 0) {
            double promedio = (double) suma / contador;
            System.out.println("El promedio de los números introducidos es: " + promedio);
        } else {
            System.out.println("No se introdujeron números positivos.");
        }
        // cierre del objeto Scanner
        scanner.close();
    }
}

NOTA: Este post es parte de la colección “Java”. Puedes ver el índice de esta colección aquí.

Ejercicios con listas en Java

Aquí tenéis una propuesta de ejercicios con listas en Java para practicar lo explicado en el post de listas. Hay varias soluciones posibles para resolver un mismo problema, unas más eficientes que otras. Aquí podéis ver una solución posible para cada ejercicio propuesto.

Ejercicio 1: ListaNumerosDivisiblesPorNum

Enunciado:

Crea una lista de todos los números del 1 a 100 que sean divisibles por un número que introduzca el usuario. Este número tiene que estar comprendido entre 2 y 7. Pinta la lista por pantalla.

Sigue leyendo Ejercicios con listas en Java

La colección Mapas en Java

Otro tipo de colección muy interesante son los Mapas. Los mapas son colecciones de parejas clave-valor. Podría decirse que son como los arrays pero en lugar de usar un índice consecutivo que marca la posición del elemento en el array, vamos a utilizar una clave asociada a cada elemento.

La clase HashMap

La clase HashMap tiene la siguiente sintaxis:

HashMap<tipo clave,tipo de elemento>nombreDelMap= new HashMap<>();

Para trabajar con mapas vamos a utilizar la clase HashMap. Practiquemos con ella en la siguiente actividad:

Sigue leyendo La colección Mapas en Java

Listas en Java: tipo Set

En el post de Colecciones, mencionaba dos tipos de listas con las que podemos trabajar en Java: List y Set. En un post anterior me centraba en las listas de tipo List y ahora lo haré en las tipo Set, que a diferencia de las anteriores, no admiten duplicados.

La clase HashSet

Las listas tipo Set, las manejaremos con la clase HashSet. Esta clase funciona de manera muy parecida a la clase ArrayList, tienen muchos métodos iguales. Por ello, en la actividad siguiente para practicar con esta clase, me centraré en las diferencias de la clase HashSet con la clase ArrayList, vista previamente.

Sigue leyendo Listas en Java: tipo Set