Phyton – Nivel 3 – Test 1
Tests similares
Respuestas:
1. ¿Qué es una closure en Python?
Respuesta: Una función que contiene y recuerda el entorno en el que fue creada
Explicación: Una closure es una función definida dentro de otra función que recuerda el entorno en el que se creó, incluso después de que la función exterior haya terminado su ejecución. Ejemplo:
def exterior(x):
def interior(y):
return x + y
return interior
closure = exterior(10)
print(closure(5)) # Salida: 15
2. ¿Qué es el duck typing en Python?
Respuesta: Un estilo de programación donde el tipo de un objeto es menos importante que sus métodos
Explicación: Python sigue el principio de «Si parece un pato y suena como un pato, probablemente sea un pato». Esto significa que no importa el tipo real de un objeto, sino si tiene los métodos o atributos necesarios para cumplir con un comportamiento esperado. Ejemplo:
def haz_sonido(animal):
animal.sonido()
class Pato:
def sonido(self):
print(«Cuac»)
class Perro:
def sonido(self):
print(«Guau»)
haz_sonido(Pato()) # Salida: Cuac
haz_sonido(Perro()) # Salida: Guau
3. ¿Qué es una excepción en Python?
Respuesta: Un evento que ocurre durante la ejecución que interrumpe el flujo normal
Explicación: Las excepciones ocurren cuando algo inesperado sucede durante la ejecución de un programa, como dividir por cero o intentar acceder a un índice inexistente en una lista. Ejemplo:
try:
print(10 / 0)
except ZeroDivisionError:
print(«No puedes dividir por cero.») # Salida: No puedes dividir por cero.
4. ¿Qué es un context manager en Python?
Respuesta: Un objeto que define los métodos __enter__ y __exit__
Explicación: Un context manager gestiona recursos, como archivos abiertos, asegurando que se liberen adecuadamente. Se usa típicamente con la palabra clave with. Ejemplo:
with open(«archivo.txt», «r») as archivo:
contenido = archivo.read()
# El archivo se cierra automáticamente al salir del bloque `with`
5. ¿Qué es el polimorfismo en programación orientada a objetos?
Respuesta: La capacidad de un objeto de tomar muchas formas
Explicación: El polimorfismo permite que un método en clases derivadas tenga diferentes implementaciones pero con el mismo nombre. Ejemplo:
class Animal:
def sonido(self):
pass
class Perro(Animal):
def sonido(self):
return «Guau»
class Gato(Animal):
def sonido(self):
return «Miau»
def haz_sonido(animal):
print(animal.sonido())
haz_sonido(Perro()) # Salida: Guau
haz_sonido(Gato()) # Salida: Miau
6. ¿Cuál será la salida?
x = [1, 2, 3]
y = x
y.append(4)
print(x)
Respuesta: [1, 2, 3, 4]
Explicación: En Python, las listas son mutables y y = x no crea una copia, sino que ambas referencias apuntan al mismo objeto en memoria. Cambiar y también cambia x.
7. ¿Cuál será la salida?
class A:
def __init__(self):
self.x = 1
class B(A):
def __init__(self):
super().__init__()
self.y = 2
b = B()
print(b.x, b.y)
Respuesta: 1 2
Explicación: La clase B llama al constructor de la clase base A usando super().__init__(). Esto inicializa self.x = 1, y luego self.y = 2 se define en la clase B.
8. ¿Cuál es la diferencia entre *args y **kwargs?
Respuesta: *args es para argumentos posicionales, **kwargs para argumentos de palabras clave
Explicación:
- *args permite pasar un número variable de argumentos posicionales.
- **kwargs permite pasar un número variable de argumentos de palabras clave (nombre=valor). Ejemplo:
def ejemplo(*args, **kwargs):
print(args) # Una tupla con argumentos posicionales
print(kwargs) # Un diccionario con argumentos de palabras clave
ejemplo(1, 2, 3, a=4, b=5)
# Salida: (1, 2, 3)
# Salida: {‘a’: 4, ‘b’: 5}
9. ¿Qué hace el operador @ en Python 3.5+?
Respuesta: Multiplica matrices
Explicación: El operador @ se usa para realizar la multiplicación de matrices en Python, introducido en la versión 3.5. Ejemplo:
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(a @ b)
# Salida: [[19 22]
# [43 50]]
10. ¿Cuál será la salida?
def func(x, y=[]):
y.append(x)
return y
print(func(1))
print(func(2))
print(func(3))
Respuesta: [1, 2, 3], [1, 2, 3], [1, 2, 3]
Explicación: El valor por defecto de y es una lista mutable que persiste entre llamadas. Cada llamada a func modifica la misma lista. Ejemplo:
# La lista ‘y’ es compartida:
func(1) # [1]
func(2) # [1, 2]
func(3) # [1, 2, 3]