Me encanta Python, pero en pleno 2024 me parece una necesidad aprender Python tarde o temprano, este repo en un intento para lograr eso. Última vez actualizado: 04 Abril 2024
Los retos consisten en preguntas de selección múltiple en tres niveles: Fácil , Intermedio y Avanzado. Las respuestas estarán collapsadas para no spoilearnos, el objetivo es aprender, así que trata de solucionar el reto sin ver la solución ni ejecutar el código.
Sigueme en mis redes para más! 😊
Instagram || Twitter || LinkedIn || Dev.to
| Diviertete! |
|---|
➡️ Dificultad: Fácil
x,y,z = 1,2,3
print(x,y,z)- A.
123 - B.
1 2 3 - C.
ValueError - D.
SyntaxError
Respuesta
✅ B. 1 2 3
En Python es posible declarar múltiples variables en una sola lineal separándolas por comas, las asignaciones de valores a las variables se hace de manera simétrica: x=1, y=2 y y=3.
➡️ Dificultad: Fácil
if True:
print("True")- A.
True - B.
1 - C.
IndentationError - D.
TypeError
Respuesta
✅ C. IndentationError
A diferencia de otros lenguajes de programación, para anidar código en Python no se usan llaves {}, sino que usamos indentaciones. En el ejemplo es como si tuviéramos el cuerpo del if completamente vacío justamente por que no tenemos la indentación bien escrita.
Para solucionar esto solo tenemos que indentar bien nuestro código:
if True:
print("True") # TrueLa recomendación es usar siempre 4 espacios de identación.
➡️ Dificultad: Fácil
for i in range(1,10,2):
print(i)- A.
1 3 5 7 9 - B.
0 2 4 6 8 10 - C.
1 3 5 7 9 10 - D.
2 4 6 8 10
Respuesta
✅ A. 1 3 5 7 9
La función range en Python es útil para crear intervalos. Recibe 3 parámetros: range(inicio, final y salto) donde:
inicio(opcional), es el punto de partida del intervalo, si se omite por defecto toma el valor de0.final(requerido), es el punto final del intervalo, es obligatorio ponerlo.salto(opcional), equivale a decir "de cuanto en cuanto" saltará el intervalo, si se omite por defecto el salto es1, ósea recorre el intervalo de uno en uno.
Dicho esto, range(1, 10, 2) inicia en 1 y termina en 10: 1, 2, 3, 4, 5, 6, 7, 8, 9 (en Python el final es siempre final - 1) por eso solo se crea el intervalo hasta el 9.
Pero el salto es 2, entonces tendríamos: 1, 3, 5, 7, 9.
➡️ Dificultad: Fácil
for i in range(7):
print(i)- A.
1 2 3 4 5 6 7 - B.
0 1 2 3 4 5 6 7 - C.
0 1 2 3 4 5 6 - D.
Ninguna de las anteriores
Respuesta
✅ C. 0 1 2 3 4 5 6
La función range en Python solo acepta como parámetro obligatorio el final del intervalo que queremos crear, en este caso: inicio = 0, final = 7, salto = 1, en otras palabras tendremos un intervalo entre 0 y 7-1 que vaya de uno en uno.
La salida tiene que ser: 0, 1, 2, 3, 4, 5, 6
➡️ Dificultad: Fácil
for i in range (5, 0, -1):
print(i)- A.
0 1 2 3 4 - B.
5 4 3 2 1 - C.
-5 -4 -3 -2 -1 - D.
Ninguna de las anteriores
Respuesta
✅ B. 5 4 3 2 1
En Python es posible crear intervalos de mayor a menor con la función range. En este caso el intervalo se verá así: inicio=5, final=0, salto=-1; o en otras palabras el intervalo empezara en 5, terminara en 0+1 y los saltos iran en decremento: 5 4 3 2 1
➡️ Dificultad: Fácil
numbers = [12, 5, 8, 13, 4]
num = numbers[::2]
print(num)- A.
[12, 8, 4] - B.
[5, 13] - C.
[4, 8, 12] - D.
[4, 13, 8, 5, 12]
Respuesta
✅ A. [12, 8, 4]
Al momento de parcelar la lista omitimos los parámetros de inicio y final por lo que operaremos sobre toda la lista haciendo saltos de 2 en 2: [12, 8, 4]
➡️ Dificultad: Fácil
primos = [2,3,5,7,11]
for indice, primo in enumerate(primos):
print(f"{indice} -> {primo}")- A.
0 -> 2
1 -> 3
2 -> 5
3 -> 7
4 -> 11- B.
1 -> 2
2 -> 3
3 -> 5
4 -> 7
5 -> 11- C.
2 -> 0
3 -> 1
5 -> 3
7 -> 3
11 -> 4- D.
SyntaxError
Respuesta
✅ A.
0 -> 2
1 -> 3
2 -> 5
3 -> 7
4 -> 11La función enumerate() en Python es muy útil cuando no solo necesitamos recorrer y acceder a los items de una lista, sino también a los índices de la misma. Por defecto los índices comienzan en 0 y van hasta el final de la lista.
➡️ Dificultad: Fácil
list = [ x*5 for x in range(1,5)]
print(list)- A.
[1, 2, 3, 4, 5] - B.
[5, 10, 15, 20] - C.
[5, 5, 5, 5, 5] - D.
SyntaxError
Respuesta
✅ - B. [5, 10, 15, 20]
Python posee una característica bien interesante denominada list comprehension o compresión de listas en español. Es una sintaxis para poder escribir patrones de listas de una manera sencilla y fácil de comprender.
La sintaxis es la siguiente:
lista = [expresión for elemento in iterable]Donde:
expresión: es la variante de item que queremos mostrar en cada interacción.for elemento in iterable: es elfortípico de Python para recorrer iterables (listas, diccionarios, tuplas, sets, cadenas, etc)
En nuestro ejemplo for x in range(1,5) genera un rango entre 1 y 4 que lo guardamos en la variable x, y con nuestra expresión x*5 multiplicamos este valor por 5 en cada vuelta del bucle.
Por ello nuestro resultado es [5, 10, 15, 20].
➡️ Dificultad: Intermedio
frase = "Feliz Año nuevo 2024"
salida = [ letra for letra in frase if(letra == "e") ]
print(len(salida))- A.
3 - B.
0 - C.
2 - D.
SyntaxisError
Respuesta
✅ C. 2
En nuestro último reto vimos las list comprehension de Python, una manera super útil de poder crear listas en una sola línea de código. Olvide mencionarte que sintaxis también puede tener condicionales en su sintaxis 👀
La sintaxis final quedaría así:
lista = [expresión for elemento in iterable condicional]Entonces en nuestro reto con for letra in frase iteramos cada letra de la cadena frase, luego con if(letra == "e") verificamos en cada iteración que la letra sea e, si esto se cumple almacenamos la letra en la expresión letra.
La cadena Feliz Año nuevo 2024 tiene un par de letras e por lo que quedaría ["e", "e"] pero en la impresión final aplicamos len al resultado, en conclusión mostramos 2 por consola.
➡️ Dificultad: Intermedio
print(bool([])) # 🤔
print(bool(0)) # 🤔
print(bool("")) # 🤔- A.
False,False,True - B.
True,False,False - C.
True,True,False - D.
False,False,False
Respuesta
✅ D. False, False, False
Python considera tanto las listas vacías, el número 0 y las cadenas vacías como False.
➡️ Dificultad: Fácil
frase = " Hola mundo "
print(frase.strip())- A.
Hola mundo - B.
mundo Hola - C.
Hola - D.
mundo
Respuesta
✅ A. Hola mundo
strip() en Python elimina los espacios sobrantes tanto de izquierda como de derecha de una cadena. Muy similar al método trim() de otros lenguajes de programación.
➡️ Dificultad: Intermedio
def my_fn(precio):
if(len(precio) == 1):
return precio.zfill(2)
if(len(precio) == 2):
return precio.zfill(3)
print(my_fn("5"))
print(my_fn("50"))- A.
5,50 - B.
005,00050 - C.
05,050 - D.
50,50
Respuesta
✅ C. 05, 050
El método zfill de Python es útil para completar con ceros una cadena dada. En el ejemplo verificamos la longitud del precio mandado como argumento, si su longitud es de 1 entonces completamos con ceros hasta que la longitud final sea de 2; así mismo si la longitud del precio es 2 entonces completamos con ceros hasta que la longitud final sea de 3. Eso es todo. ¿Muy fácil no?
➡️ Dificultad: Intermedio
print("-".join([str(i) for i in range(11,2,-2)]))- A.
[11, 9, 7, 5, 3] - B.
11-9-7-5-3 - C.
[3, 5, 7, 9, 11] - D.
3-5-7-9-11
Respuesta
✅ B. 11-9-7-5-3
El método join de las cadenas de Python es útil para convertir un iterable en un string en base a un separador.
Su sintaxis es la siguiente: separador.join(iterable).
En nuestro ejemplo el iterable es una compresión de lista que va del 11 al 2 de uno en uno en secuencia decremental.
Y nuestro separador es un -, por ello el resultado final es 11-9-7-5-3 como string.
➡️ Dificultad: Fácil
print("hola mundo como estas".split(" "))- A.
['hola', 'mundo', 'como', 'estas'] - B.
['hola mundo como estas'] - C.
hola mundo como estas - D.
Ninguna de las anteriores
Respuesta
✅ A. ['hola', 'mundo', 'como', 'estas']
split en Python es un método que se aplica sobre cadenas de texto, convierte a la cadena en una lista separando los items por el separador que pasamos por argumento a split. En este caso un espacio en blanco.
➡️ Dificultad: Fácil
list = [1, 2, 3, 4]
list.append(10)
print(list)- A.
[10] - B.
10 - C.
[10, 1, 2, 3, 4] - D.
[1, 2, 3, 4, 10]
Respuesta
✅ D. [1, 2, 3, 4, 10]
append() en Python es un método de listas que se usa para agregar al final de la lista un item nuevo. Si vienes por ejemplos de JavaScript es muy similar a lo que hace el método push.
➡️ Dificultad: Fácil
l = [1, 2]
l.extend([3, 4])
print(l) - A.
[1, 2, 3, 4] - B.
[3, 4, 1, 2] - C.
[1, 2],[3, 4] - D.
Ninguna de las anteriores
Respuesta
✅ A. [1, 2, 3, 4]
extend() en Python es un método de listas que nos sirve para concatenar dos listas para convertirlas en una sola. Es un método muy intuitivo y fácil de usar.
➡️ Dificultad: Fácil
l = [1, 2]
l.insert(1,[1,2,3])
print(l)- A.
[1, 2, [1, 2, 3]] - B.
[1, [1, 2, 3], 2] - C.
[1, 2, 1, 2, 3] - D.
[[1, 2, 3], 1, 2]
Respuesta
✅ B. [1, [1, 2, 3], 2]
insert() en Python es un método de listas que permite agregar un nuevo item a la lista, pero a diferencia de append() que lo agrega al final de la lista, insert() lo agrega en la posición de la lista que nosotros queramos.
insert() recibe 2 parámetros: el índice donde queremos hacer la inserción y el objeto como tal que queremos insertar en la lista.
En nuestro ejemplo insertamos en la posición 1 una nueva lista [1,2,3] dando como resultado final una lista anidada: [1, [1, 2, 3], 2].
Eso es todo.
➡️ Dificultad: Fácil
colors = ["red", "green", "pink"]
colors.pop()
colors.pop()
colors.pop()
colors.pop()
print(colors)- A.
[] - B.
IndexError - C.
SintaxError - D.
[-1]
Respuesta
✅ B. IndexError
La lista colors tiene solo 3 items y nosotros estamos intentando eliminar 4 items con pop(), esto no es correcto y por ello tenemos un IndexError.
➡️ Dificultad: Fácil
dias = "Lunes", "Martes", "Miercoles", "Jueves", "Viernes"
print(type(dias)) # 🤔👉 A. <class 'set'>
👉 B. <class 'list'>
👉 C. <class 'tuple'>
👉 D. <class 'str'>
Respuesta
👉 C. <class 'tuple'>
Las tuplas en Python son una estructura de datos muy similares a las listas pero con la característica de ser inmutables.
Comúnmente su sintaxis se la puede reconocer con el uso de () encerrando todos los items, por ejemplo:
dias = "Lunes", "Martes", "Miercoles", "Jueves", "Viernes"
dias2 = ("Lunes", "Martes", "Miercoles", "Jueves", "Viernes")➡️ Dificultad: Fácil
list = [1,2,2,3,4,5,5,6]
set = set(list)
print(set)- A.
{1, 2, 3, 4, 5, 6} - B.
{2, 2, 5, 5} - C.
{1, 3, 4, 6} - D.
{2, 5}
Respuesta
✅ A. {1, 2, 3, 4, 5, 6}
set es una estructura de datos similar a las listas pero con algunas diferencias: los items en un set no están indexados por posición y los set no admiten elementos repetidos.
Esto último es super importante para comprender este reto, en el mismo usamos la función set() para convertir una lista a un set, como este no puede contener elementos repetidos, en dicha conversión se perderán algunos items: un 2 y un 5.
El resultado final será un nuevo set sin dichos elementos repetidos.
➡️ Dificultad: Fácil
s1 = {1, 2, 3}
s2 = {4, 2, 6}
s3 = {2, 5, 7}
print((s1 & s2) | s3) # 🤔- A.
{1, 2, 3, 4, 6} - B.
{2} - C.
{1, 2, 3, 4, 5, 6, 7} - D.
{2, 5, 7}
Respuesta
✅ D. {2, 5, 7}
Los set en Python soportan operaciones con conjuntos.
En este ejemplo aplicamos la operación de union (|) y también la operación de intersection (&).
Vamos por pasos:
- Primeramente hacemos la
intersectionentres1ys2
s1 = {1, 2, 3}
s2 = {4, 2, 6}
## esto nos dará {2} puesto que solo necesitamos
## los items que se repitan en ambos sets- Ahora que tenemos
{2}de laintersectiones momento de hacer launioncon el sets3
print({2} | {2, 5, 7})
## acá nos toca seleccionar todos los elementos
## y los que se repiten solo los tomamos en cuenta una vezFinalmente llegamos al resultado: {2, 5, 7}
➡️ Dificultad: Fácil
persona = {
"nombre": "Cris",
"apellido": "Villca",
"edad": 27,
"soltero": False,
"direccion": {
"calle": 17,
"avenida": "Tomas Monje",
"pasaje": "A"
}
}
print(persona.get("direccion").get("avenida").upper())- A.
None - B.
TOMAS MONJE - C.
tomas monje - D.
ToMaS mOnJe
Respuesta
✅ B. TOMAS MONJE
Los diccionarios en Python son estructuras de datos de pares clave valor que podemos usar para administrar data de una manera mas eficiente y legible.
En este caso tenemos el diccionario anidado de dos niveles persona al cual queremos acceder a su propiedad avenida.
Para acceder a propiedades de un diccionario podemos usar la notación de corchetes [] o también el método get() como en este caso.
Encadenamos 2 veces el método get() pasando como argumento el nombre de la propiedad a la que queremos acceder, finalmente le pasamos un upper() para convertir todos los caracteres a mayúsculas.
➡️ Dificultad: Fácil
persona = {
"nombre": "Cris",
"apellido": "Villca",
"edad": 27,
"soltero": False,
"direccion": {
"calle": 17,
"avenida": "Tomas Monje",
"pasaje": "A"
}
}
print(persona.get("peso", 50))- A.
peso - B.
None - C.
50 - D.
TypeError
Respuesta
✅ C. 50
El método get() de los diccionarios recibe un segundo parámetro que es el valor por defecto que le daremos a una propiedad en caso de que esta no exista en el diccionario.
En este caso queremos acceder a la propiedad peso de persona, la misma no existe, entonces el valor por consola será nuestro valor por defecto que en este caso es 50.
➡️ Dificultad: Fácil
persona = {
"nombre": "Cris",
"apellido": "Villca",
"edad": 27,
"soltero": False,
}
print(persona.items())- A.
['nombre', 'apellido', 'edad', 'soltero'] - B.
[('nombre', 'Cris'), ('apellido', 'Villca'), ('edad', 27), ('soltero', False)] - C.
['Cris', 'Villca', 27, False] - D.
SintaxError
Respuesta
✅ B. [('nombre', 'Cris'), ('apellido', 'Villca'), ('edad', 27), ('soltero', False)]
items() es un metodo de los diccionarios en Python que regresa una lista de tuplas, organizando cada una de ellas en pares clave-valor.
➡️ Dificultad: Fácil
def fn():
a=1
print(fn())- A.
TypeError - B.
None - C.
Null - D.
SyntaxError
Respuesta
✅ B. None
Cuando una función en Python no regresa nada y es invocada automáticamente el interprete hará que regrese None.
➡️ Dificultad: Fácil
def fn(x=0, y=0):
return x + y
print(fn(1,1))
print(fn())- A.
2,0 - B.
0,2 - C.
0,0 - D.
2,2
Respuesta
✅ - A. 2, 0
En Python podemos usar valores por defecto para los parámetros de una una función.
En este caso cuando llamamos a fn() con los argumentos (1,1) es fácil deducir que el resultado es 2.
Cuando llamamos a fn() sin argumentos entonces entran en acción los parámetros por defecto (0,0) dando como resultado la suma 0.
Finalmente el resultado es 2,0.
➡️ Dificultad: Fácil
def fn(x=0, y):
return x - y
print(fn(1))- A.
-1 - B.
1 - C.
SyntaxError - D.
0
Respuesta
✅ C. SyntaxError
Cuando queremos usar parámetros por defecto en Python estos siempre tienen que ir al final de la lista de parámetros en la función, sino tendremos un SyntaxError.
Corrigiendo el ejemplo, tendríamos:
def fn(y, x=0):
return x - y
print(fn(1)) # -1➡️ Dificultad: Fácil
def fn(*numbers):
return type(numbers)
print(fn())- A.
<class 'list'> - B.
<class 'int'> - C.
<class 'tuple'> - D.
<class 'dict'>
Respuesta
✅ C. <class 'tuple'>
En la lista de parámetros de una función escrita con Python, si vemos uno que empieza con un asterisco, en este ejemplo *numbers significa que dicho parámetro por defecto para el interprete de Python será considerado como una tupla.
Si vienes de JavaScript esto es muy similar a los parámetros REST.
Non confundir la sintaxis de asterisco con punteros de lenguajes como C, no tiene nada que ver.
➡️ Dificultad: Fácil
def maximo(ls):
return max(ls)
print(maximo(["a", "b", "c"]))- A.
a - B.
b - C.
c - D.
None
Respuesta
✅ - C. c
La función max() de Python como su nombre lo indica regresa el valor máximo de un iterable que le pasemos como argumento.
En este caso debemos encontrar el máximo de una lista de strings, entonces lo que hace Python es convertir de manera implícita los strings a su respectivo código ASCII:
Entonces tenemos algo como esto:
def maximo(ls):
return max(ls)
print(maximo([97, 98, 99])) # a->97, b->98, c->99Ahora si es mucho más fácil saber por que la respuesta es c.
➡️ Dificultad: Intermedio
x = 10
def fn(entrada):
entrada = 0
return entrada
print(x)
print(fn(x))- A.
10,10 - B.
0,0 - C.
10,0 - D.
0,10
Respuesta
✅ - C. 10, 0
La variable x esta fuera de la función fn por ende el valor de esta no se ve alterado mostrando primero por consola 10.
Cuando mandamos x como argumento a fn(entrada) cambiamos su valor de 10 a 0 en el cuerpo de la función y luego lo regresamos mostrando posteriormente por consola dicho valor alterado, osea 0.
En síntesis, el parametro entrada que pasamos a la función es recibido por valor, entonces fuera del scope de la función no sufre cambios, pero dentro de la función si.
➡️ Dificultad: Fácil
frutas = ["manzana", "pera", "fresa"]
frutas2 = frutas
frutas2.append("banana")
print(frutas)- A.
['manzana', 'pera', 'fresa'] - B.
['manzana', 'pera', 'fresa', 'banana'] - C.
['banana', 'manzana', 'pera', 'fresa'] - D.
Ninguna de las anteriores
Respuesta
✅ B. ['manzana', 'pera', 'fresa', 'banana']
En Python las listas se asignan por referencia, esto significa que su valor queda ligado a una dirección de memoria dentro de nuestro ordenador, por ende cuando hacemos frutas2 = frutas lo que copiamos en la variable frutas2 no es el valor de toda la lista frutas, sino que copiamos la referencia en memoria de la lista frutas.
En Python y a diferencia de otros lenguajes podemos verificar esto haciendo uso de la función id() que justamente nos regresa la dirección de memoria donde esta almacenada nuestra variable:
print(id(frutas)) # 140428447337024
print(id(frutas2)) # 140428447337024Vemos que la dirección en memoria de ambas variables es la misma y es por este motivo que al alterar la lista de frutas de la variable frutas2 los cambios también se ven reflejados en la variable original frutas.
➡️ Dificultad: Intermedio
frutas = ["manzana", "pera", "fresa"]
frutas2 = frutas.copy()
frutas2.append("banana")
print(frutas)- A.
['manzana', 'pera', 'fresa'] - B.
['manzana', 'pera', 'fresa', 'banana'] - C.
['banana', 'manzana', 'pera', 'fresa'] - D.
Ninguna de las anteriores
Respuesta
✅ - A. ['manzana', 'pera', 'fresa']
El método copy() sirve para poder realizar copias completamente independientes de listas. En nuestro ejemplo al usar este método solo afectamos a frutas2, dejando a frutas intacto.
➡️ Dificultad: Fácil
print(list())- A.
[] - B.
IndexError - C.
TypeError - D.
SyntaxError
Respuesta
✅ A. []
Podemos crear listas en Python usando la función list() y no pasarle ningún parámetro. La manera más pythonica de hacerlo es solamente usando la sintaxis de corches vacíos: [].
➡️ Dificultad: Intermedio
lista_compras = ["huevos", "pan", "tomates", "leche"]
print(lista_compras[100:200:50])- A.
IndexError - B.
SyntaxError - C.
TypeError - D.
[]
Respuesta
✅ D. []
Cuando intentamos acceder a una porción que no existe en una lista quizá pienses que deberíamos ver un error por consola, pero la verdad es que solo veremos un arreglo vacío haciendo referencia a que dicha porción de la lista justamente esta vacía.
➡️ Dificultad: Intermedio
lista_compras = ["huevos", "pan", "tomates", "leche"]
print(lista_compras[100:200:50]) # 🤔👉 A. IndexError
👉 B. SyntaxError
👉 C. ["huevos", "pan", "tomates", "leche"]
👉 D. []
Respuesta
✅ D. []
En nuestro ejemplo queremos acceder a la porción de la lista que empieza en el índice 100 y que termina en el índice 200 dando saltos de 50 en 50.
Como podemos ver esto no es posible por que nuestra lista es muy pequeña, Python no nos lanzará ningún error pero si nos mostrará lo que considera correcto que es una lista vacía.
Si lo pensamos tiene sentido puesto que el rango de la lista al que queremos acceder está vacío.
➡️ Dificultad: Intermedio
lista_compras = ["huevos", "pan", "tomates", "leche"]
lista_compras.insert(100, "peras")
lista_compras.insert(-100, "manzanas")
print(lista_compras) 👉 A. ["huevos", "pan", "tomates", "leche"]
👉 B. ['manzanas', 'huevos', 'pan', 'tomates', 'leche', 'peras']
👉 C. ['peras', 'huevos', 'pan', 'tomates', 'leche', 'manzanas']
👉 D. IndexError
Respuesta
✅ B. ['manzanas', 'huevos', 'pan', 'tomates', 'leche', 'peras']
Al intentar hacer lista_compras.insert(100, "peras") en nuestra lista lista_compras buscamos insertar el item peras en el index 100 de nuestra lista cuya longitud es solo de 4 items.
Al ser 100 un index extremadamente lejano para nuestra pequeña lista esto debería dar un error, pero no. El interprete de Python lo pondrá en este caso hasta el final; por eso nuestra lista termina con el item peras.
Del mismo modo al tratar con index negativos empezamos a asignar dichos index de derecha a izquierda, siendo peras el index -1, leche el index -2 y así sucesivamente. El index -100 nuevamente esta muy lejano pero Python lo asignará hasta el principio de la lista y por ello empieza con manzanas.
➡️ Dificultad: Fácil
lista_compras = ["huevos", "pan"]
print(lista_compras * int(3.5))👉 A. ['huevos', 'pan', 'huevos', 'pan', 'huevos', 'pan']
👉 B. ['huevos', 'pan', 'huevos', 'pan']
👉 C. ["huevos", "pan"]
👉 D. TypeError
Respuesta
✅ A. ['huevos', 'pan', 'huevos', 'pan', 'huevos', 'pan']
int(3.5) nos dará 3 perdiendo así la parte flotante del número y lista_compras * 3 repetirá nuestra lista por si misma tres veces y en su mismo orden.
➡️ Dificultad: Fácil
lista_bebidas = ["agua", "jugo"]
lista_bebidas[::-1]
print(lista_bebidas)👉 A. ["jugo", "agua"]
👉 B. ["jugo"]
👉 C. ["agua", "jugo"]
👉 D. ["agua"]
Respuesta
✅ C. ["agua", "jugo"]
Una manera muy pythonesca de dar la vuelta una lista es usar la sintaxis lista_bebidas[::-1], lo importante acá es saber que esta sintaxis es inmutable, ósea que no modifica la lista original.
Efectivamente logramos dar la vuelta los items de la lista pero sin afectar a la lista original:
lista_bebidas = ["agua", "jugo"]
print(lista_bebidas[::-1]) # ['jugo', 'agua']
print(lista_bebidas) # ['agua', 'jugo']➡️ Dificultad: Fácil
lista_1 = ["item1", "item2"]
lista_2 = []
lista_3 = ["item3", "item4"]
print(lista_1 + lista_2 + lista_3)👉 A. ['item1', 'item2', [], 'item3', 'item4']
👉 B. ['item1', 'item2', [''], 'item3', 'item4']
👉 C. ['item1', 'item2', 'item3', 'item4']
👉 D. ['item1', 'item2', '', 'item3', 'item4']
Respuesta
✅ C. ['item1', 'item2', 'item3', 'item4']
En Python es posible usar el operador + para "sumar" o mejor dicho concatenar listas. Su funcionamiento es muy simple e intuitivo, es como una suma de toda la vida pero con listas.
En ese caso lista_2 al contener una lista vacía es omitida y por ello no aparece en el resultado final.
➡️ Dificultad: Fácil
frutas= ["manzana", "pera", "fresa"]
frutas.extend("uva")
print(frutas)👉 A. ['uva', 'manzana', 'pera', 'fresa'] 👉 B. ['manzana', 'pera', 'fresa', ['uva']] 👉 C. ['manzana', 'pera', 'fresa', 'uva'] 👉 D. ['manzana', 'pera', 'fresa', 'u', 'v', 'a']
Respuesta
✅ D. ['manzana', 'pera', 'fresa', 'u', 'v', 'a']
El método extend en Python lo usamos para unir listas, pero ¿qué pasa cuando intentamos unir una lista con, por ejemplo, una cadena de texto?
extend va recorriendo item por item toda la lista, al llegar a uva se da cuenta que es un iterable de tipo cadena, entonces empieza a recorrer carácter por carácter todo el string y por ello el resultado es el mostrado.
➡️ Dificultad: Fácil
numeros = [1,1,1,1,1,1]
numeros[2:5] = [0,0,0]
print(numeros)👉 A. [1, 1, 0, 0, 0, 1]
👉 B. [1, 1, 0, 0, 0, 0]
👉 C. [1, 0, 0, 0, 0, 0]
👉 D. Ninguna de las anteriores
Respuesta
✅ A. [1, 1, 0, 0, 0, 1]
En Python es posible asignar valores a trozos de un arreglo. En este caso cortamos el fragmento [2, 5] de la lista y en vez de [1, 1, 1] ponemos [0, 0, 0].
➡️ Dificultad: Fácil
numeros = [1,1,1,1,1,1]
print(numeros.find(1))👉 A. 1
👉 B. AttributeError
👉 C. SyntaxError
👉 D. IndexError
Respuesta
✅ B. AttributeError
Si bien el método find() existe para las cadenas, las listas no cuentan con este método. Es por eso que obtenemos un AttributeError, esto significa que dicha propiedad no pertenece a un tipo o estructura de datos.
➡️ Dificultad: Fácil
productos = ["helado", "pan", "queso"]
precios = [15.5, 5, 29.99]
for producto, precio in zip(productos, precios):
print(producto, precio)👉 A.
helado 15.5
pan 5
queso 29.99👉 B.
15.5 helado
5 pan
29.99 queso 👉 C. AttributeError
👉 D. NameError
Respuesta
✅ A.
helado 15.5
pan 5
queso 29.99zip en Python sirve para trabajar con listas en paralelo, en nuestro ejemplo cada producto en index x será emparejado con su respectivo precio en index x también y terminamos por recorrer ambas listas en un solo for.
➡️ Dificultad: Intermedio
print([0,0,0] > [2,0,10])👉 A. True
👉 B. False
👉 C. None
👉 D. SyntaxError
Respuesta
✅ B. False
En Python podemos usar signos de comparación entre listas donde haremos dicha comparación item a item (por index), veamos esto paso por paso.
Python hará las siguientes comparaciones en orden hasta que una sea falsa:
0>20>00>10
La primera comparación de entrada es falsa, entonces el interprete de Python se detiene y regresa False.
Para que regrese True todas y cada una de las comparaciones deben ser verdaderas.
➡️ Dificultad: Intermedio
my_string = "52,69,10,47,230,5,415,233"
mi_list = [ int(value) for value in my_string.split(",") if len(value) == 3]
print(mi_list)👉 A. [52, 69, 10, 47]
👉 B. ['230', '415', '233']
👉 C. [230, 415, 233]
👉 D. ['230415233']
Respuesta
✅ C. [230, 415, 233]
Las listas comprimidas son una característica brutal de Python. Permite al programador escribir listas complejas de una manera sencilla y en una sola línea de código.
Para entender mejor como es que funcionan las listas comprimidas sugiero aprender primero su sintaxis:
mi_list = [ VALUE LOOP CONDITION] Donde:
value: es el valor que tendrá cada item en la lista.loop: es el ciclo que usaremos para generar la lista.condition: es la condición opcional que podemos usar para filtrar el resultado final de nuestra lista.
Volviendo al ejemplo:
-
value:int(value)indica que cada item de la lista resultante sera convertida a entero. -
loop:for value in my_string.split(",")indica que iteraremos sobre la cadenamy_stringconvirtiendola a una lista usando el métodosplit()y almacenando cada item en una variablevalue. -
condition:if len(value) == 3indica que solo tomaremos en cuenta a los items cuya longitud sea igual a3o en otras palabras, números de3digitos.
Finalmente pasado todos los filtros el resultado final queda: [230, 415, 233].
➡️ Dificultad: Fácil
my_tuple = ('a', 'b', 'c')
my_tuple[0] = 'A'
print(my_tuple)👉 A. ('A', 'b', 'c')
👉 B. ('a', 'A', 'c')
👉 C. ReferenceError
👉 D. TypeError
Respuesta
✅ D. TypeError
Recordemos que las tuplas son estructuras de datos parecidas a las listas pero inmutables, dicho de otra manera, no podemos cambiar sus valores.
En este ejemplo intentamos cambiar el primer item de la tupla lo que es una violación clara a la naturaleza funcional de las tuplas, por ello obtenemos un TypeError.
➡️ Dificultad: Fácil
my_tuple = (123, 456, 789, 0)
a, *b, c = my_tuple
print(a, b, c)👉 A. 123 [456, 789] 0
👉 B. 123 0 456 789
👉 C. 123 456 789
👉 D. Ninguna de las anteriores
Respuesta
✅ A. 123 [456, 789] 0
Las tuplas poseen una característica denominada desempaquetado, esto significa que podemos acceder a sus valores en variables independientes.
En este caso a vale 123, *b al tener el asterisco valdrá todo lo que este en medio entre a y c y lo regresa como una lista, por ello b vale [456, 789] y finalmente c vale el último valor de nuestra tupla, ósea 0.
➡️ Dificultad: Fácil
print(dict(["a1", "b2", "c3"]))👉 A. {'0': 'a1', '1': 'a2', '2': 'a3'}
👉 B. {'a': '1', 'b': '2', 'c': '3'}
👉 C. {'1': 'a', '2': 'b', '3': 'c'}
👉 D. Ninguno de los anteriores
Respuesta
✅ B. {'a': '1', 'b': '2', 'c': '3'}
La función dict de Python permite convertir variables a diccionarios, en este caso pasamos una lista que que sea convertida a diccionario. Python divide cada item y regresa para este ejemplo el primer carácter como llave y el segundo carácter como valor.
➡️ Dificultad: Intermedio
my_dict = dict(["a1", "b2", "c3"])
print(my_dict.get("d"))
print(my_dict["d"])👉 A. 0, 0
👉 B. KeyError, KeyError
👉 C. None, KeyError
👉 D. None, None
Respuesta
✅ C. None, KeyError
En Python podemos acceder a los valores de un diccionario de 2 maneras diferentes:
- Usando el método
get(): regresaNoneen caso de que el par clave-valor no exista en el diccionario. - Usando la notación de corchetes: regresa el error
KeyErrory detiene la ejecución del programa.
Ambas maneras sirven para lo mismo pero la diferencia radica en cuando no encontramos la propiedad en el diccionario. Esta característica es muy peculiar de Python y esta bueno saberlo.
➡️ Dificultad: Fácil
my_dict = {"nombre": "John", "edad": 30, "ciudad": "New York"}
my_dict["isSoltero"] = True
my_dict["edad"] = 25
print(my_dict)👉 A. {'nombre': 'John', 'edad': 30, 'ciudad': 'New York', 'isSoltero': True}
👉 B. {'nombre': 'John', 'edad': 25, 'ciudad': 'New York', 'isSoltero': True}
👉 C. {'nombre': 'John', 'edad': 25, 'ciudad': 'New York'}
👉 D. {"nombre": "John", "edad": 30, "ciudad": "New York"}
Respuesta
✅ B. {'nombre': 'John', 'edad': 25, 'ciudad': 'New York', 'isSoltero': True}
Al trabajar con Python y los diccionarios hay maneras de manipularlos, por ejemplo al usar la sintaxis de corchetes con una llave que no existe en nuestro diccionario como pasa con my_dict["isSoltero"] = True, Python procede a agregar un nuevo campo al diccionario con la key y value nuevos.
Ahora bien, al usar la sintaxis de corches con una llave que ya existe en el diccionario, como es el caso de my_dict["edad"] = 25 entonces procedemos a modificar la value de dicho campo, para el ejemplo cambiamos edad de 30 a 25.
El diccionario original era:
my_dict = {"nombre": "John", "edad": 30, "ciudad": "New York"}Pero agregamos el campo isSoltero con el valor de True y modificamos el campo edad de 30 a 25:
my_dict = {'nombre': 'John', 'edad': 25, 'ciudad': 'New York', 'isSoltero': True}➡️ Dificultad: Fácil
keys = "xyz"
my_dict = {}
for index, value in enumerate(keys, start=1):
my_dict[index] = value
print(my_dict)👉 A. {1: 'xyz', 2: 'xyz', 3: 'xyz'} 👉 B. {x: '1', y: '2', z: '3'} 👉 C. {1: 'x', 2: 'y', 3: 'z'} 👉 D. {0: 'x', 1: 'y', 2: 'z'}
Respuesta
✅ C. {1: 'x', 2: 'y', 3: 'z'}
Podemos llenar de manera dinámica un diccionario.
En este aso recorremos la cadena keys tanto sus valores como sus indices haciendo uso de la función enumerate() empezando desde 1; a cada iteración asignamos a cada index un valor: 1 -> x, 2 -> y y 3 -> z; mostramos por consola el resultado.
➡️ Dificultad: Fácil
my_dict = {"name": "John", "age": 30, "city": "New York"}
print("name" in my_dict)
print(len(my_dict))👉 A. True, 3 👉 B. True, 2 👉 C. True, TypeError 👉 D. False, 3
Respuesta
✅ A. True, 3
Para saber si existe una determinada llave en el diccionario podemos usar el operador in que regresa True o False dependiendo que si existe o no dicha llave. Como name existe en my_dict regresamos True.
Usamos len para saber la longitud del diccionario, entendemos por longitud la cantidad de pares clave-valor que contiene el diccionario:
"name": "John" # 1
"age": 30 # 2
"city": "New York" # 3Hay tres pares clave-valor, entonces regresamos 3.
➡️ Dificultad: Fácil
my_dict = {"name": "John", "age": 30, "city": "New York"}
for key, value in my_dict.items():
print(f"{key}: {value}")👉 A. KeyError
👉 B. TypeError
👉 C. SyntaxError
👉 D.
name: John
age: 30
city: New York➡️ Dificultad: Fácil
my_dict = {"name": "John", "age": 30, "city": "New York"}
del my_dict["age"]
print(my_dict)👉 A. {'name': 'John', 'city': 'New York'}
👉 B. {"name": "John", "age": 30, "city": "New York"}
👉 C. SyntaxError
👉 D. TypeError
Respuesta
✅ A. {'name': 'John', 'city': 'New York'}
Una manera de poder eliminar pares clave-valor de un diccionario es usando el operador del. Su sintaxis es muy sencilla de usar e intuitiva de entender.
➡️ Dificultad: Fácil
my_dict = {"name": "John", "age": 30, "city": "New York"}
my_dict.pop("last_name")
print(my_dict)👉 A. TypeError
👉 B. SyntaxError
👉 C. KeyError
👉 D. {"name": "John", "age": 30, "city": "New York"}
Respuesta
✅ C. KeyError
Podemos usar el método pop() para eliminar items de un diccionario pero siempre y cuando estemos seguros de que la key existe en dicho diccionario.
Cuando esto se cumple eliminar un item es sencillo, pero cuando no obtendremos un KeyError al no poder encontrar que es lo que se desea eliminar. Ojo con eso!
➡️ Dificultad: Intermedio
my_dict = {"a":1, "b":2}
my_dict2 = {"x":-1, "y":-2}
print({**my_dict, **my_dict2})👉 A. {'a': 1, 'b': 2}, {'x': -1, 'y': -2}
👉 B. {'a': 1, 'b': 2, 'x': -1, 'y': -2}
👉 C. [{'a': 1, 'b': 2}, {'x': -1, 'y': -2}]
👉 D. ({'a': 1, 'b': 2}, {'x': -1, 'y': -2})
Respuesta
✅ B. {'a': 1, 'b': 2, 'x': -1, 'y': -2}
Podemos usar el operador ** para poder combinar diccionarios en Python. El resultado será un nuevo diccionario con todos las claves llave-valor de los diccionarios a combinar.
➡️ Dificultad: Intermedio
my_dict = {"a":1, "b":2}
my_dict2 = {"x":-1, "y":-2}
print(my_dict | my_dict2)👉 A. {'a': 1, 'b': 2}, {'x': -1, 'y': -2}
👉 B. {'a': 1, 'b': 2, 'x': -1, 'y': -2}
👉 C. [{'a': 1, 'b': 2}, {'x': -1, 'y': -2}]
👉 D. ({'a': 1, 'b': 2}, {'x': -1, 'y': -2})
Respuesta
✅ B. {'a': 1, 'b': 2, 'x': -1, 'y': -2}
A partir de Python 3.9 podemos usar el operador | para poder combinar diccionarios sin la necesidad de crear uno nuevo. Es un manera más moderna de llegar al mismo resultado.
➡️ Dificultad: Intermedio
my_dict = {"a":1, "b":2}
copy_my_dict = my_dict
my_dict["c"] = 3
print(copy_my_dict)👉 A. TypeError
👉 B. {'a': 1, 'b': 2, 'c': 3}
👉 C. {'a': 1, 'b': 2}
👉 D. Ninguna de las anteriores
Respuesta
✅ B. {'a': 1, 'b': 2, 'c': 3}
En Python los diccionarios se manipulan por referencia, esto quiere decir que copy_my_dict no es un nuevo diccionario sino que solo es una copia de la referencia al diccionario orinal my_dict, dicho de otra manera, cualquier cambio que se haga a la copia también se hará a al original por que comparten la misma dirección de memoria.
Para solucionar esto podemos hacer uso del método copy:
my_dict = {"a":1, "b":2}
copy_my_dict = my_dict.copy()
my_dict["c"] = 3
print(copy_my_dict) ## {'a': 1, 'b': 2}De esta manera el cambio solo se ve reflejado en la copia y no así en la variable original.
➡️ Dificultad: Fácil
print("\")👉 A. \
👉 B. SyntaxError
👉 C. /
👉 D. NameError
Respuesta
✅ B. SyntaxError
La barra invertida en la gran mayoría de los lenguajes de programación es usada para escapar caracteres, en este caso no podemos imprimir una barra invertida por consola justamente por que Python interpreta que deseamos escapar algún carácter.
Para que esto funcione necesitamos hacer print("\\") para obtener \ por consola.
➡️ Dificultad: Fácil
print("Mi", "nombre", "es", sep="_", end="*")
print("Monty", "Python.", sep="*", end="*\n")👉 A. Mi_nombre_es Monty*Python.*
👉 B. Mi*nombre*es*Monty_Python.*
👉 C. Mi_nombre_es*Monty*Python.*
👉 D. Mi_nombre_es*Monty*Python._
Respuesta
✅ C. Mi_nombre_es*Monty*Python.*
La función print de Python puede recibir argumentos de palabra clave como:
sep(): que significa separador, y hace justamente eso, separa mediante un carácter los parámetros deprint.end(): determina cual será el último carácter que imprimiremos.
En nuestro ejemplo, para el primer print:
print("Mi", "nombre", "es", sep="_", end="*")
## separamos con _ y terminamos el print con *
## Mi_nombre_es*y para el segundo print
print("Monty", "Python.", sep="*", end="*\n")
## separemos con * y terminamos con un * y un salto de línea
## Mi_nombre_es*Monty*Python.*Así de fácil, así de sencillo.
➡️ Dificultad: Fácil
print(sep=".", "hola", "mundo")👉 A. hola.mundo
👉 B. .hola mundo
👉 C. SyntaxError
👉 D. Ninguna de las anteriores
Respuesta
✅ C. SyntaxError
Los argumentos de palabra reservada como end y sep (para la función print) deben ir siempre luego del último argumento posicional.
En nuestro ejemplo, los únicos argumentos posicionales que tenemos son hola y mundo, por ende para que funcione deberíamos reescribirlo de la siguiente manera:
print("hola", "mundo", sep=".") ## hola.mundo➡️ Dificultad: Fácil
i = 5
while i < 5:
print(i)
i += 1
else:
print("else:", i)👉 A. else: 5
👉 B. else: 4
👉 C. 5
👉 D. No imprime nada
Respuesta
✅ A. else: 5
En Python los bucles pueden tener una sentencia else, esta característica es muy propia y peculiar de Python.
Por mas que a priori el bucle nunca llega a ejecutarse, el bloque else siempre lo hará, por este motivo la variable i se queda con el valor de 5 y eso es lo que se muestra por pantalla.
➡️ Dificultad: Fácil
print(list("Hola python"))👉 A. ['Hola', ' ', 'python']
👉 B. ['H', 'o', 'l', 'a', ' ', 'p', 'y', 't', 'h', 'o', 'n']
👉 C. SyntaxError
👉 D. Ninguna de las anteriores
Respuesta
✅ B. ['H', 'o', 'l', 'a', ' ', 'p', 'y', 't', 'h', 'o', 'n']
En Python podemos usar la función list() para convertir valores iterables (como por ejemplo un string) a una lista. De esta manera, cada caracter del iterable se convierte en un item para la lista.
➡️ Dificultad: Fácil
print(list(range(1,11,2)))👉 A. [0, 3, 5, 7, 9]
👉 B. [3, 5, 7, 9, 11]
👉 C. [2, 4, 6, 8, 10]
👉 D. [1, 3, 5, 7, 9]
Respuesta
✅ D. [1, 3, 5, 7, 9]
En Python podemos crear listas usando la función list() y pasarle un intervalo usando la función range(). Esto hará que tengamos un item por cada valor que nos regrese range() y se almacene en una lista.
➡️ Dificultad: Fácil
test = list(range(11))
test[:6] = [10, 10, 10, 10, 10]
print(test)👉 A. [10, 10, 10, 10, 10]
👉 B. [1, 2, 3, 4, 5, 6, 10, 10, 10, 10, 10]
👉 C. [10, 10, 10, 10, 10, 6, 7, 8, 9, 10]
👉 D. [0, 1, 2, 3, 4, 5]
Respuesta
✅ C. [10, 10, 10, 10, 10, 6, 7, 8, 9, 10]
Vamos línea por línea:
-
test = list(range(11)): Creamos en la variable test una lista de números, del 0 al 10. Tendríamos:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] -
test[:6] = [10, 10, 10, 10, 10]: De la posición 0 a la posición 5 agregamos el arreglo[10, 10, 10, 10, 10] -
print(test): Imprimimos el resultado:[10, 10, 10, 10, 10, 6, 7, 8, 9, 10]
➡️ Dificultad: Fácil
numeros = list(range(2, 16, 3))
del numeros[-1]
numeros.remove(2)
print(numeros)👉 A. [5, 8, 11, 14]
👉 B. [5, 8, 11]
👉 C. [2, 5, 8, 11]
👉 D. [5, 8, 11, 14]
Respuesta
✅ B. [5, 8, 11]
En Python podemos borrar items de una lista por índice o por valor.
Al hacer del numeros[-1] eliminamos por índice el último item de la lista numeros.
Al hacer numeros.remove(2) eliminamos el item con el valor de 2 de la lista numeros; si es que hubiera items repetidos este solo elimina el primero que coincida.
➡️ Dificultad: Intermedio
cadena = "3+5"
print(cadena.partition("+"))👉 A. (3, '+', 5)
👉 B. ('3', '+', '5')
👉 C. ['3', '+', '5']
👉 D. Ninguna de las anteriores
Respuesta
✅ B. ('3', '+', '5')
La función partition() en Python se utiliza para dividir una cadena en una tupla de tres partes, utilizando un separador especificado. Esta función devuelve una tupla que contiene tres elementos:
- La parte de la cadena antes del separador.
- El separador mismo.
- La parte de la cadena después del separador.
La sintaxis general es:
cadena.partition(separador)Donde cadena es la cadena en la que deseas realizar la partición y separador es el carácter o subcadena que se utiliza para dividir la cadena. Es importante tener en cuenta que partition() devuelve una tupla incluso si el separador no está presente en la cadena.
➡️ Dificultad: Fácil
dos = two = deux = 2
print((dos + two - 2)**deux)👉 A. 2
👉 B. 16
👉 C. 4
👉 D. SyntaxError
Respuesta
✅ C. 4
En Python podemos asignar el valor a varias variables en una sola línea. En nuestro ejemplo las 3 variables tendrán el valor de 2, dicho esto tendremos algo como: (2 + 2 - 2)**2 dando como resultado 4.
➡️ Dificultad: Fácil
var = 1
print(bool(var) + float("1"))👉 A. True1
👉 B. 11
👉 C. 2
👉 D. 2.0
Respuesta
✅ D. 2.0
Vamos parte por parte:
varvale1.- Tendríamos
bool(1)que es igual aTruepor conversión de tipos (en Python0equivale aFalsey1equivale aTrue). - Luego
float("1")convierte a la cadena"1"en un número con punto decimal, entonces nos daría1.0. - Nos quedaría:
True +1.0, recordemos queTrueequivale a1. Entonces tendríamos:1 + 1.0, el resultado final2.0`
➡️ Dificultad: Fácil
# ¿Cuál de las siguientes sentencias es la incorrecta?
x = "hola"
print("El valor de a es: " + x) # A
print("El valor de a es:", x) # B
print(f"El valor de a es: {x}") # C👉 A. A
👉 B. B
👉 C. C
👉 D. Todas son correctas
Respuesta
✅ D. Todas son correctas
En Python podemos concatenar valores de muchas maneras, 3 de ellas son:
- Usando el operador
+. - Usando una simple
,. - Usando lo que se denomina un f-string e interpolar el valor final.
➡️ Dificultad: Fácil
print(type(float(True) + int("1")) == "int")- A.
True - B.
False - C.
None - D.
TypeError
Respuesta
✅ B. False
Vamos por partes:
float(True)será igual a1.0.int("1")será igual a1.type(1.0 + 1)será igual aclass <float>.floates diferente deint, por ende el resultado esFalse.
➡️ Dificultad: Fácil
print(len("1.0"))- A.
3 - B.
2 - C.
1 - D.
TypeError
Respuesta
✅ A. 3
La función len de Python sirve para obtener la longitud de un iterable, por ejemplo una cadena o una lista, en este caso la cadena 1.0 tiene 3 caracteres: 1, . y 0.
➡️ Dificultad: Fácil
print(len(1.0))- A.
3 - B.
2 - C.
1 - D.
TypeError
Respuesta
✅ D. TypeError
La función len de Python sirve para obtener la longitud de un iterable, por ejemplo una cadena o una lista, en este caso la intentamos obtener la longitud de un float por lo que tendremos un TypeError por consola.
➡️ Dificultad: Intermedio
def f(text, target_word, replace_word):
index_target_word = text.find(target_word)
x = text[0:index_target_word]
y = text[index_target_word + len(target_word):len(text)]
return f"{x}{replace_word}{y}"
print(f("Keep calm and write Python", "write", "enjoy"))- A.
Keep calm and write Python - B.
Keep calm and enjoy Python - C.
IndexError - D.
TypeError
Respuesta
✅ B. Keep calm and enjoy Python
La función f implementa un algoritmo para buscar y remplazar una palabra dada por otra sin el uso de la función replace de Python.
Usando find() y dividiendo la cadena podemos lograr lo que se pretende.
➡️ Dificultad: Fácil
mensaje = "Mi amigo Pedro juega fútbol. !Que bien juega Pedro¡"
print(mensaje.replace("Pedro", "Carlos", 1))- A.
Mi amigo Carlos juega fútbol. !Que bien juega Carlos¡ - B.
Mi amigo Carlos juega fútbol. !Que bien juega Pedro¡ - C.
Mi amigo Pedro juega fútbol. !Que bien juega Pedro¡ - D.
Ninguno de los anteriores
Respuesta
✅ B. Mi amigo Carlos juega fútbol. !Que bien juega Pedro¡
La función replace de Python permite remplazar una cadena dada por otra. Por defecto remplaza todas las coincidencias que se encuentre pero podemos modificar este comportamiento.
replace recibe un tercer argumento de tipo entero que representa la cantidad de veces que queremos que se haga el remplazo.
En nuestro ejemplo solo queremos que se haga 1 vez.
➡️ Dificultad: Intermedio
monto = 35_200
print(f"{monto:010d}")- A.
0000035200 - B.
0000035_200 - C.
000035_200 - D.
35200
Respuesta
✅ A. 0000035200
En Python podemos usar los f-string no solo para interpolar valores, sino que también podemos ir un poco mas lejos y usarlo para dar formato a diferentes tipos de datos.
En este caso usamos la sintaxis monto:010d donde:
montoes un número entero.- La letra
dse usa para formatear digitos enteros. - El valor
010significa que el formato del resultado final debe contener en total 10 dígitos y los espacios faltantes deben ser rellenados con0'sdelante.
➡️ Dificultad: Fácil
cadena = "Hola mundo"
print(f"{cadena=}")- A.
{cadena=} - B.
cadena='Hola mundo' - C.
Hola mundo - D.
SyntaxError
Respuesta
✅ B. cadena='Hola mundo'
Desde Python 3.8 podemos usar los f-string no solo para interpolar variables o dar formato, sino que también tenemos la posibilidad de usarlos para hacer debugging del código.
Esto se logra agregando el signo = al la variable que queramos imprimir. De esta manera no solo imprimimos su valor, sino también el nombre de la variable y su respectivo valor en ese momento de la ejecución.
➡️ Dificultad: Fácil
def f(n):
aux = 5
r = []
while aux <= n:
r.append(aux)
aux +=5
return r
print(f(36))- A.
[10, 15, 20, 25, 30, 35] - B.
[5, 10, 15, 20, 25, 30, 35] - C.
[5, 10, 15, 20, 25, 30] - D.
SyntaxError
Respuesta
✅ B. [5, 10, 15, 20, 25, 30, 35]
Lo que hace nuestra función solamente es agregar los numeros múltiplos menores a un número dado, en este caso, todos los menores a 36.
Almacenamos cada valor en un lista y la imprimimos por consola.
➡️ Dificultad: Intermedio
i = range(6)
print(type(i))- A.
<class 'tuple'> - B.
<class 'list'> - C.
<class 'range'> - D.
<class 'int'>
Respuesta
✅ C. <class 'range'>
Cuando usamos la función range() creamos un objeto de tipo de range en Python. Los objetos de tipo range son eficientes y óptimos para ser recorridos por bucles.
➡️ Dificultad: Fácil
f = "A"
print(int(f, 16))- A.
10 - B.
16 - C.
A - D.
1
Respuesta
✅ A. 10
La función int de Python es útil para realizar conversiones de tipo a entero, pero la base no siempre tiene que ser decimal, podemos convertir valores a otros sistemas numéricos como por ejemplo el octal (en base 8) y el hexadecimal (en base 16).
En el ejemplo convertimos la letra A a hexadecimal, lo que nos dará el resultado de 10.
➡️ Dificultad: Fácil
x = (1,"2",3)
print(list(x))- A.
(1,"2",3) - B.
[1, 2, 3] - C.
[1, "2", 3] - D.
SyntaxError
Respuesta
✅ C. [1, "2", 3]
La función list es muy útil para poder convertir iterables a listas. En nuestro ejemplo convertimos la tupla x a una lista respetando el tipo de dato de cada elemento.
➡️ Dificultad: Fácil
shopping = ["Agua", "Huevos", "Aceite", "Sal", "Limón"]
print(shopping[::-1])- A.
["Agua", "Huevos", "Aceite", "Sal", "Limón"] - B.
['Limón', 'Sal', 'Aceite', 'Huevos', 'Agua'] - C.
['Limón'] - D.
["Agua"]
Respuesta
✅ B. ['Limón', 'Sal', 'Aceite', 'Huevos', 'Agua']
Al igual que con las cadenas, podemos trocear listas en Python. La sintaxis es la misma:
[ <inicio>, <final>, <salto> ]Donde:
<inicio>: desde donde queremos cortar<final>: hasta donde queremos cortar<salto>: de cuanto en cuantos item queremos cortar
Una manera peculiar de usar esta manera de cortar listas es invertir una lista: [::-1].
En este caso no tenemos <inicio> ni <final>, lo que significa que abarcaremos toda la lista, el <salto> es de -1 en -1 lo que quiere decir que empezaremos por el último item hasta llegar al primero. En otras palabras la lista quedara invertida.
➡️ Dificultad: Intermedio
bebidas = ["Agua", "Coca-Cola"]
bebidas.extend("Cerveza")
print(bebidas)- A.
["Agua", "Coca-Cola", "Cerveza"] - B.
["Agua", "Coca-Cola", ["Cerveza"]] - C.
["Cerveza", "Agua", "Coca-Cola"] - D.
['Agua', 'Coca-Cola', 'C', 'e', 'r', 'v', 'e', 'z', 'a']
Respuesta
✅ D. ['Agua', 'Coca-Cola', 'C', 'e', 'r', 'v', 'e', 'z', 'a']
El método extends en Python no es útil para concatenar listas, lo que significa que podemos fusionar 2 o más listas de manera sencilla.
En nuestro ejemplo intentamos concatenar la lista bebidas con la cadena Carveza, esto si bien no nos dará ningún error si nos arrojará un resultado inesperado.
extends recorre cada elemento de la lista para poder concatenarlo, pero en nuestro caso recorre cada carácter de la cadena Cerveza y lo concatenado carácter por carácter.
Si queremos concatenar listas podemos usar el operador + o el método extend.
Si queremos agregar un item a una lista podemos usar append o insert
➡️ Dificultad: Fácil
bebidas = ["Agua", "Coca-Cola"]
bebidas.append(["Pepsi"])
print(bebidas)- A.
["Agua", "Coca-Cola", "Pepsi"] - B.
["Agua", "Coca-Cola", ["Pepsi"]] - C.
["Agua", "Coca-Cola", ["P","e","p","s","i"]] - D.
["Pepsi", "Agua", "Coca-Cola"]
Respuesta
✅ B. ['Agua', 'Coca-Cola', ['Pepsi']]
append sirve para agregar un item al final de una lista, ojo, dije agregar un item.
En nuestro ejemplo estamos agregando una lista al final de nuestra lista bebidas, esto no da ningún error pero regresa una lista anidada que usualmente no es lo que queremos.
Para concatenar listas se debe usar el operador + o la función extend.
bebidas = ["Agua", "Coca-Cola"]
print(bebidas + ["Pepsi"]) # ['Agua', 'Coca-Cola', 'Pepsi']
bebidas.extend(["Pepsi"])
print(bebidas) # ['Agua', 'Coca-Cola', 'Pepsi']
</p>
</details>
#### 95. Explica el siguiente código Python
➡️ Dificultad: <mark> Fácil </mark>
```py
bebidas = ["Agua", "Coca-Cola"]
bebidas[2] = "Pepsi"
print(bebidas)- A.
["Agua", "Coca-Cola", "Pepsi"] - B.
["Agua", "Pepsi"] - C.
TypeError - D.
IndexError
Respuesta
✅ D. IndexError
En Python no solo es posible acceder a los items de un arreglo por su índice, también podemos modificar elementos accediendo a un índice en particular.
El detalle de nuestro ejemplo es que queremos modificar una posición de nuestro arreglo que no existe, ello deriva a un error de tipo IndexError.
Una solución podría ser sustituir un item que si existe, por ejemplo:
bebidas = ["Agua", "Coca-Cola"]
bebidas[1] = "Pepsi"
print(bebidas) # ['Agua', 'Pepsi']➡️ Dificultad: Fácil
bebidas = ["Agua", "Coca-Cola", "Pepsi"]
bebidas[0:2] = ["Limonada", "Fanta"]
print(bebidas)- A.
["Pepsi", "Limonada", "Fanta"] - B.
["Limonada", "Fanta", "Agua", "Coca-Cola", "Pepsi"] - C.
["Limonada", "Fanta", "Pepsi"] - D.
IndexError
Respuesta
✅ C. ["Limonada", "Fanta", "Pepsi"]
En Python podemos tomar un intervalo de un lista para poder sustituirlo por otro.
Lograr esto es muy sencillo, solo tenemos que seleccionar el trozo de lista a sustituir y remplazarla por el nuevo trozo.
En nuestro ejemplo cortamos [0:2], ósea ["Agua", "Coca-Cola"], para poder remplazarlo por ["Limonada", "Fanta"].
Es importante mencionar que el trozo a cortar no necesariamente debe ser del mismo tamaño que el trozo a agregar, por ejemplo:
bebidas = ["Agua", "Coca-Cola", "Pepsi"]
bebidas[0:2] = ["Limonada", "Fanta", "Agua con gas", "Sprite"]
print(bebidas) # ['Limonada', 'Fanta', 'Agua con gas', 'Sprite', 'Pepsi']➡️ Dificultad: Intermedio
numeros = [42,96,12,20,36]
del numeros[100]
print(numeros)- A.
TypeError - B.
SyntaxError - C.
NameError - D.
IndexError
Respuesta
✅ D. IndexError
Para eliminar un item de una lista podemos usar el operador del seguido de la posición que queremos eliminar.
En este sentido, ¿qué sucede si la posición que queremos eliminar no existe dentro de la lista? Entonces el interprete de Python nos regresa un IndexError.
Para solucionar esto debemos eliminar siempre posiciones de la lista que sabemos que existen:
numeros = [42,96,12,20,36]
del numeros[2]
print(numeros) # [42, 96, 20, 36]➡️ Dificultad: Fácil
numeros = [42,96,12,20,36]
numeros.remove(20)
print(numeros) - A.
[42, 96, 12, 36] - B.
ValueError - C.
IndexError - D.
[42, 96, 12, 36, 20]
Respuesta
✅ D. [42, 96, 12, 36, 20]
Otra manera de eliminar items de una lista en Python es usando el método remove() y pasarle el item a borrar.
Cuando tenemos 2 o mas items repetidos en la lista, entonces solo se borra la primera coincidencia que encuentre.
➡️ Dificultad: Fácil
numeros = [42,96,12,20,36]
print(numeros.pop(), numeros) - A.
36,[42, 96, 12, 20] - B.
42,[96, 12, 20, 36] - C.
12,[42, 96, 20, 36] - D.
TypeError
Respuesta
✅ A. 36, [42, 96, 12, 20]
Podemos eliminar items usando la función pop() de Python. A diferencia de usar del o remove que solo eliminaban el item y ya, pop es diferente ya que en efecto lo elimina pero también regresa el item eliminado.
Por ello la salida es 36 (elimina el último item) y luego la lista queda [42, 96, 12, 20].
➡️ Dificultad: Fácil
# reto #100 😎
mi_lista = [True, "hi", "bye", (1,2,3), {"1": "uno"}]
mi_lista.clear()
print(mi_lista)- A.
() - B.
[] - C.
{} - D.
SyntaxError
Respuesta
✅ B. []
La manera mas sencilla de eliminar todos los items de una lista es usando la función clear().
➡️ Dificultad: Intermedio
text = "hi"
a = len(text) == 2
b = text.endswith("i")
c = text.islower()
if all([a, b, c]):
print("👌")
else:
print("🔴")- A.
SyntaxError - B.
👌 - C.
🔴 - D.
ValueError
Respuesta
✅ B. 👌
En Python tenemos palabras clave para agrupar un conjunto de condiciones, en este caso vemos all que significa que todas las condiciones tienen que evaluar a True para que pase y se ejecute el bloque de código siguiente.
En nuestro ejemplo la palabra hi cumple las condiciones a, b y c por lo tanto pasa y se ejecuta el if.
➡️ Dificultad: Fácil
x = 1,
print(type(x))- A.
<class 'list'> - B.
<class 'tuple'> - C.
<class 'dict'> - D.
SyntaxError
Respuesta
✅ B. <class 'tuple'>
Si bien no se recomienda es posible escribir una tupla con una sintaxis sin paréntesis.
➡️ Dificultad: Fácil
x = ("hola", "como", "estas", "?")
x.append("?")
print(x)👉 A. ("hola", "como", "estas", "?", "?")
👉 B. AttributeError
👉 C. SyntaxError
👉 D. NameError
Respuesta
✅ B. AttributeError
Las tuplas tienen las mismas características de las listas pero con la peculiaridad de que son inmutables. Esto significa que no podemos alterar ningún item de una tupla.
No podemos usar ningún método que mute la tupla, por ejemplo:
- append()
- remove()
- extend()
- reverse()
- clear()
- sort()
➡️ Dificultad: Fácil
z = (4, 8, 12)
cuatro, ocho, doce = z
print(doce)- A.
4 - B.
8 - C.
12 - D.
Ninguna de las anteriores
Respuesta
✅ C. 12
Python posee una característica denominada desempaquetado (es muy similar a la desestructuración de JavaScript). Consiste en separar en variables individuales los items de una lista o una tupla.
En este caso separamos en 3 variables los 3 items de la tupla de manera posicional. Imprimimos 12 y eso es lo que mostramos por pantalla.
➡️ Dificultad: Fácil
d = {3: 'd', 2: 'c', 1: 'b', 0: 'a'}
print(d[0])- A.
a - B.
d - C.
c - D.
b
Respuesta
✅ A. a
Las claves de un diccionario pueden ser cualquier valor inmutable, por ende no hay problema en usar números enteros como claves.
No se debe confundir las claves numéricas como si una indexación de listas, cuando escribimos d[0] no significa la posición 0 del diccionario d, sino la clave 0 del diccionario d.
No son índices de lista, son claves de diccionario.
➡️ Dificultad: Fácil
MLB_team = {
'Colorado' : 'Rockies',
'Boston' : 'Red Sox',
'Minnesota': 'Twins',
'Milwaukee': 'Brewers',
'Seattle' : 'Mariners'
}
print(MLB_team[-1])- A.
Mariners - B.
KeyError - C.
Rockies - D.
-1
Respuesta
✅ B. KeyError
Los diccionarios no pueden ser tratados como listas, no es posible acceder al último elemento de diccionario MLB_team haciendo MLB_team[-1]. Los diccionarios no tienen las mismas propiedades que las listas.
➡️ Dificultad: Intermedio
MLB_team = {
'Colorado' : 'Rockies',
'Boston' : 'Red Sox',
'Minnesota': 'Twins',
'Milwaukee': 'Brewers',
'Seattle' : 'Mariners'
}
print(MLB_team[0:2])- A.
('Rockies', 'Red Sox') - B.
['Rockies', 'Red Sox'] - C.
{'Rockies', 'Red Sox'} - D.
TypeError
Respuesta
✅ D. TypeError
Los diccionarios no tienen una sintaxis de slice, no se pude cortar el diccionario como lista. Intentar hacer esto produce un TypeError.
➡️ Dificultad: Fácil
person = {}
person['fname'] = 'Joe'
person['lname'] = 'Fonebone'
person['age'] = 51
person['spouse'] = 'Edna'
person['children'] = ['Ralph', 'Betty', 'Joey']
person['pets'] = {'dog': 'Fido', 'cat': 'Sox'}
print(person.get("pets").get("cat"))- A.
Fido - B.
Sox - C.
SyntaxError - D.
TypeError
Respuesta
✅ B. Sox
Los diccionarios pueden contener otros diccionarios en su interior. Esta sintaxis se llama diccionario anidados y para acceder a sus valores se debe concatenar métodos get() (como en este reto) o se puede usar también la sintaxis de corchete:
print(person["pets"]["cat"]) # SoxNota también como creamos el diccionario, inicialmente person es un diccionario vacío y lo vamos llenando propiedad a propiedad asignado valores a diferentes claves.
➡️ Dificultad: Intermedio
d = {[1, 1]: 'a', [1, 2]: 'b', [2, 1]: 'c', [2, 2]: 'd'}
print(d[[1,1]])- A.
a - B.
NameError - C.
TypeError - D.
Ninguna de las anteriores
Respuesta
✅ C. TypeError
Las claves de un diccionario deben ser siempre inmutables, como por ejemplo, una cadena, un número, un booleano o una tupla. No pueden ser ni listas ni otros diccionarios (ambos son mutables).
➡️ Dificultad: Fácil
def f(d):
r = {}
for key, value in d.items():
r[value] = key
return r
print(f({"a":1, "b":2, "c":3}))- A.
{1: "a", 2: "b", 3: "c"} - B.
{"a":1, "b":2, "c":3} - C.
[1: "a", 2: "b", 3: "c"] - D.
(1: "a", 2: "b", 3: "c")
Respuesta
✅ A. {1: "a", 2: "b", 3: "c"}
Podemos hacer un sencillo intercambio de llaves por valores y regresar un nuevo diccionario iterando con el método items() y desempaquetando tanto llaves como valores.
➡️ Dificultad: Fácil
categories = ["color", "fruit", "pet"]
objects = ["blue", "apple", "dog"]
new_dict = {key:value for key, value in zip(categories, objects)}
print(new_dict)- A.
{'blue': 'color', 'apple': 'fruit', 'dog': 'pet'} - B.
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'} - C.
KeyError - D.
RangeError
Respuesta
✅ B. {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
Podemos crear diccionarios por comprensión de una manera muy similar a las listas por comprehensión.
En el ejemplo iteramos de manera paralela sobre las listas categories y objects y regresamos cada par clave valor dentro de un nuevo diccionario.
➡️ Dificultad: Intermedio
print(bool(-100), bool(100))- A.
True,True - B.
True,False - C.
False,True - D.
False,False
Respuesta
✅ A. True, True
En Python los tipos de datos booleanos descienden del tipo de datos de los números. Entonces El posible representar tanto True como False como valores numéricos, donde: True equivale a 1 y False equivale a 0.
Ahora bien, tenemos una peculiaridad con los números que sean diferentes de 1 y 0.
Todos los numeros enteros que sean diferentes de 0 serán considerados como True (incluidos los valores negativos), solo el valor 0 equivale a False.
En nuestro ejemplo -100 infiere a True por mas que sea negativo porque es diferente de 0 y 100 también infiere a True por las mismas razones.
➡️ Dificultad: Fácil
print(not True * (100 + True))- A.
101 - B.
0 - C.
100True - D.
SyntaxError
Respuesta
✅ B. 0
Ya sabemos que True infiere a 1 y False infiere a 0.
Entonces es posible hacer operaciones aritméticas con booleanos.
Vamos por partes:
not Trueequivale aFalse, que en numeros equivale a0.100 + Trueequivale a101porqueTruees1.- Finalmente tendríamos
0 * 101que nos da0
En este ejercicio en concreto basta con saber que not True da 0 para inferir que el resultado total será 0 (todo número multiplicado por 0 será 0 ya que el 0 es neutro multiplicativo)
➡️ Dificultad: Fácil
print( ((True / True) - 10 ) * 9)- A.
80 - B.
81 - C.
-81 - D.
SyntaxError
Respuesta
✅ C. -81
Nuevamente operaciones aritméticas con booleanos:
True / Truees lo mismo que1/1, por lo tanto nos da1.1 - 10nos dará-9- Y
-9 * 9será-81como resultado final.
➡️ Dificultad: Fácil
my_tuple = (12, 45, 78)
x, y, z, t = my_tuple
print(t)- A.
78 - B.
ValueError - C.
45 - D.
12
Respuesta
✅ B. ValueError
Para poder desempaquetar tuplas es necesario que la cantidad de variables creadas sea igual a la longitud de la tupla per se. Si esto no pasa entonces tenemos un ValueError.
➡️ Dificultad: Fácil
my_tuple = (1, 2, True, 3)
print(my_tuple.count(1))- A.
1 - B.
2 - C.
3 - D.
Ninguno de los anteriores
Respuesta
✅ B. 2
Recordemos que los booleanos en Python derivan del tipo number, entonces el valor True del ejemplo equivale a un 1.
Por ello al contar cuantos valores 1 existen el resultado es 2.
➡️ Dificultad: Fácil
my_tuple = (1, 2, False, 3)
print(min(my_tuple))- A.
1 - B.
2 - C.
0 - D.
False
Respuesta
✅ D. False
Nuevamente los valores booleanos infieren a números. En este caso False infiere a 0 por ello es considerado el valor mas pequeño de la tupla. Lo interesante es que no regresamos el valor 0 como número, sino el booleano False.
➡️ Dificultad: Fácil
my_tuple = (1, 2, True * 2, 3)
print(sum(my_tuple))- A.
8 - B.
6 - C.
7 - D.
SyntaxError
Respuesta
✅ A. 8
Siempre y cuando todos los valores de la tupla sean números es posible usar la función sum(). En nuestro ejemplo True infiere a 1 y multiplicado por 2 lo sumamos con todos los demás valores de la tupla.
➡️ Dificultad: Intermedio
my_tuple = ("1", "20", "30", "9")
print(max(my_tuple))- A.
1 - B.
20 - C.
30 - D.
9
Respuesta
✅ D. 9
Al comparar cadenas como items de una tupla usando max o min importa mas el valor como carácter y no como número.
En nuestro ejemplo tomamos el primer carácter de cada item y los comparamos entre ellos para hallar el máximo, el cual es 9.
➡️ Dificultad: Fácil
x = {"pepe", "albert", "jacinto", "alba"}
print(x[1])- A.
pepe - B.
albert - C.
jacinto - D.
TypeError
Respuesta
✅ D. TypeError
Los conjuntos son una estructura de datos de Python que se caracterizan por no indexar sus elementos, por ende no es posible acceder a un valor especifico de un conjunto mediante su índice (cosa que si se puede hacer con listas y tuplas).
➡️ Dificultad: Fácil
x = {"pepe", "albert", "jacinto"}
print(x)- A.
{"pepe", "albert", "jacinto"} - B.
{"albert", "pepe", "jacinto"} - C.
{"jacinto", "albert", "pepe"} - D.
Todas las anteriores
Respuesta
✅ D. Todas las anteriores
Los conjuntos son estructuras de datos no ordenadas, por este motivo no es posible saber el orden concreto de sus elementos en un momento dato de un programa. Cada vez que imprimamos nuestro conjunto x las posiciones de sus elementos irán cambiando.
➡️ Dificultad: Fácil
conjunto_vacio = {}
print(type(conjunto_vacio))- A.
<class 'tuple'> - B.
<class 'dict'> - C.
<class 'set'> - D.
<class 'str'>
Respuesta
✅ B. <class 'dict'>
No es posible crear conjuntos vacios usando a notación de {}, para lograr esto es necesario usar la palabra reservada set, así:
conjunto_vacio = set({})
print(type(conjunto_vacio)) # <class 'set'>➡️ Dificultad: Fácil
print(set("Alemania"))- A.
{'n', 'i', 'e', 'm', 'l', 'A', 'a'} - B.
{'n', 'i', 'e', 'm', 'l', 'a'} - C.
SyntaxError - D.
Ninguana de las anteriores
Respuesta
✅ A. {'n', 'i', 'e', 'm', 'l', 'A', 'a'}
Un set en Python es una estructura de datos que permite eliminar los elementos repetidos.
En este caso le pasamos una cadena a la función set, posteriormente separa carácter por carácter y procede a eliminar los elementos repetidos.
Notar que a en minúscula no es lo mismo que A en mayúscula, por ello no se elimina la letra A de de la cadena.
También es importante hacer notar que un set no es una estructura de datos ordenada, sino que cada vez que se ejecute el programa, el orden de los caracteres cambiará pero respetando la eliminación de los items repetidos.
➡️ Dificultad: Fácil
print(set([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]))- A.
{0, 1, 2, 3, 4, 5} - B.
{1, 2, 3, 4, 5} - C.
{0, 1, 2, 3, 4} - D.
{}
Respuesta
✅ B. {1, 2, 3, 4, 5}
¿Qué sucede si pasamos a la función set una lista?
Elimina todos los duplicados y regresa un set con los items no repetidos de la lista.
➡️ Dificultad: Fácil
print(set(("ADENINA", "TIMINA", "TIMINA", "GUANINA", "ADENINA", "CITOSINA")))- A.
{'ADENINA', 'TIMINA', 'GUANINA'} - B.
{'CITOSINA', 'ADENINA', 'GUANINA'} - C.
{'CITOSINA', 'ADENINA', 'TIMINA', 'GUANINA'} - D.
Ninguna de las anteriores
Respuesta
✅ C. {'CITOSINA', 'ADENINA', 'TIMINA', 'GUANINA'}
¿Qué sucede si le pasamos a la función set una tupla?
Nuevamente elimina todos los items repetidos y regresa un set con lo valores únicos.
➡️ Dificultad: Fácil
print(set({"uno":1, "dos": 2, "tres":3}))- A.
{'uno', 'dos', 'tres'} - B.
{'uno', 'tres', 'dos'} - C.
{'tres', 'dos', 'uno'} - D.
Todas las anteriores
Respuesta
✅ D. Todas las anteriores
Para usar set con diccionarios debemos tener en cuenta que las keys de los diccionarios son únicas, y que por ende estas serán consideras al momento de usar set.
En nuestro caso, extraemos las llaves del diccionario, y por la naturaleza de los set no regresa las llaves ordenadas, por ende depende de cada ejecución del código para que regrese un resultado correcto pero desordenado.
➡️ Dificultad: Fácil
x = {1, 2, 3}
x.add(10)
print(x)- A.
{10, 1, 2, 3} - B.
{1, 2, 3} - C.
{10} - D.
Ninguno de los anteriores
Respuesta
✅ A. {10, 1, 2, 3}
Para agregar items a un conjunto se debe usar el método add().
Se verifica que el item a agregar no exista en el conjunto, si existe entonces no lo agrega.
➡️ Dificultad: Fácil
x = {"a", "b", "c"}
x.remove("x")
print(x)- A.
{} - B.
{"a", "b", "c"} - C.
KeyError - D.
SyntaxError
Respuesta
✅ C. KeyError
Para poder eliminar items de un conjunto usamos el método remove().
Si el item a eliminar no existe en el conjunto entonces regresamos un KeyError.
Por ejemplo, para eliminar el item a tendriamos:
x = {"a", "b", "c"}
x.remove("a")
print(x) # {'b', 'c'}➡️ Dificultad: Fácil
x = {"a", "b", "c"}
x.add("a")
print(len(x))- A.
4 - B.
3 - C.
2 - D.
5
Respuesta
✅ B. 3
len() nos es útil para saber la longitud del conjunto.
En nuestro ejemplo no se agrega a con add() por que el conjunto ya tiene un valor a.
Aplicamos len() y tenemos como resultado 3.
➡️ Dificultad: Fácil
x = {"a", "b", "c"}
print("c" in x)- A.
True - B.
False - C.
NameError - D.
SyntaxError