Nota: Esta es una traducción al español del quiz de evaluación de habilidades Python de LinkedIn. Para la versión original en inglés, consulte python-quiz.md.
any() en una lista?any() siempre devuelve un elemento aleatorio de la lista.any() devuelve True si cualquier elemento de la lista se evalúa como True. De lo contrario, devuelve False.any() toma como argumentos la lista a verificar y el elemento a verificar. Si “cualquiera” de los elementos de la lista coincide con el elemento a verificar, la función devuelve True.any() devuelve un valor booleano que responde a la pregunta “¿Hay algún elemento en esta lista?”ejemplo
if any([True, False, False, False]) == True:
print('Yes, there is True')
>>> 'Yes, there is True'
None.if/else, utilizadas al probar la igualdad entre objetos.Explicación: Los atributos se definen bajo la clase, y los argumentos van bajo las funciones. Los argumentos generalmente se refieren a parámetros, mientras que los atributos son los constructores de la clase o una instancia de la clase.
count, fruit, price = (2, 'apple', 3.5)
.delete()pop(my_list)del(my_list).pop()ejemplo
my_list = [1,2,3]
my_list.pop(0)
my_list
>>>[2,3]
sys de Python?class Game(LogicGame): passdef Game(LogicGame): passdef Game.LogicGame(): passclass Game.LogicGame(): passExplicación: La clase padre de la cual se hereda se pasa como argumento a la clase hija. Por lo tanto, la primera opción es la respuesta correcta.
def sum(a, b):
"""
sum(4, 3)
7
sum(-4, 5)
1
"""
return a + b
def sum(a, b):
"""
>>> sum(4, 3)
7
>>> sum(-4, 5)
1
"""
return a + b
def sum(a, b):
"""
# >>> sum(4, 3)
# 7
# >>> sum(-4, 5)
# 1
"""
return a + b
def sum(a, b):
###
>>> sum(4, 3)
7
>>> sum(-4, 5)
1
###
return a + b
Explicación: Usa ''' para comenzar el doc y agrega la salida de la celda después de >>>
setlistNonedictionarySolo puedes construir una pila desde cero.college_years = ['Freshman', 'Sophomore', 'Junior', 'Senior']
return list(enumerate(college_years, 2019))
[('Freshman', 2019), ('Sophomore', 2020), ('Junior', 2021), ('Senior', 2022)][(2019, 2020, 2021, 2022), ('Freshman', 'Sophomore', 'Junior', 'Senior')][('Freshman', 'Sophomore', 'Junior', 'Senior'), (2019, 2020, 2021, 2022)][(2019, 'Freshman'), (2020, 'Sophomore'), (2021, 'Junior'), (2022, 'Senior')]self significa que no se requiere que se pasen otros argumentos al método.self; es solo jerga histórica de la informática que Python mantiene para ser consistente con otros lenguajes de programación.self se refiere a la instancia cuyo método fue llamado.self se refiere a la clase de la cual se heredó para crear el objeto usando self.Ejemplo simple
class my_secrets:
def __init__(self, password):
self.password = password
pass
instance = my_secrets('1234')
instance.password
>>>'1234'
namedtuple y hacer referencia a él de esa manera, de la misma forma que accederías a las claves en un dictionary.tuple regular.namedtuples son tan eficientes en memoria como los tuples regulares.namedtuples porque están disponibles en la biblioteca estándar.Debemos importarlo usando: from collections import namedtuple
None.my_game = class.Game()my_game = class(Game)my_game = Game()my_game = Game.create()map()?Explicación: - La sintaxis de la función map() es list(map(function,iterable)). Una calculadora simple de área usando map sería así
import math
radius = [1,2,3]
area = list(map(lambda x: round(math.pi*(x**2), 2), radius))
area
>>> [3.14, 12.57, 28.27]
None.True.referencia. Cuando la declaración return es None o no tiene valor o no hay declaración return, la función devuelve None.
pass en Python?yield de un generador y devolver un valor None.while o for y volver al inicio del bucle.La declaración pass se usa como marcador de posición para código futuro. Cuando se ejecuta la declaración pass, no pasa nada, pero evitas obtener un error cuando no se permite código vacío. referencia
slotdictionaryqueuesorted listfruits = ['Apples', 'Oranges', 'Bananas']
quantities = [5, 3, 4]
prices = [1.50, 2.25, 0.89]
#Salida deseada
[('Apples', 5, 1.50),
('Oranges', 3, 2.25),
('Bananas', 4, 0.89)]
output = []
fruit_tuple_0 = (first[0], quantities[0], price[0])
output.append(fruit_tuple)
fruit_tuple_1 = (first[1], quantities[1], price[1])
output.append(fruit_tuple)
fruit_tuple_2 = (first[2], quantities[2], price[2])
output.append(fruit_tuple)
return output
i = 0
output = []
for fruit in fruits:
temp_qty = quantities[i]
temp_price = prices[i]
output.append((fruit, temp_qty, temp_price))
i += 1
return output
groceries = zip(fruits, quantities, prices)
return groceries
>>> [
('Apples', 5, 1.50),
('Oranges', 3, 2.25),
('Bananas', 4, 0.89)
]
i = 0
output = []
for fruit in fruits:
for qty in quantities:
for price in prices:
output.append((fruit, qty, price))
i += 1
return output
all() devuelve un valor booleano que responde a la pregunta “¿Todos los elementos en esta lista son iguales?”all() devuelve True si todos los elementos en la lista pueden convertirse a cadenas. De lo contrario, devuelve False.all() devolverá todos los valores en la lista.all() devuelve True si todos los elementos en la lista se evalúan como True. De lo contrario, devuelve False.Explicación: all() devuelve True si todos los elementos en la lista son True. Ver el ejemplo abajo:
test = [True, False, False, False]
if all(test) is True:
print('Yeah, all of them are true.')
else:
print('There is an imposter.')
>>> 'There is an imposter'
(El formato de respuesta puede variar. Game y roll (o dice_roll) deben ser llamados sin parámetros.)
>>> dice = Game()
>>> dice.roll()
>>> dice = Game(self)
>>> dice.roll(self)
>>> dice = Game()
>>> dice.roll(self)
>>> dice = Game(self)
>>> dice.roll()
El ordenamiento por mezcla y el ordenamiento rápido emplean un paradigma algorítmico común basado en la recursión. Este paradigma, dividir y conquistar, descompone un problema en subproblemas similares al problema original, resuelve recursivamente los subproblemas, y finalmente combina las soluciones de los subproblemas para resolver el problema original. referencia
.append() de la lista?Esta función tiene una complejidad temporal constante, es decir, O(1), porque las listas son accesibles aleatoriamente, por lo que el último elemento puede alcanzarse en O(1), por eso el tiempo requerido para agregar el nuevo elemento al final de la lista es O(1).
set y una list?La abstracción en Python se define como un proceso de manejar la complejidad ocultando información innecesaria al usuario. referencia
def print_alpha_nums(abc_list, num_list):
for char in abc_list:
for num in num_list:
print(char, num)
return
print_alpha_nums(['a', 'b', 'c'], [1, 2, 3])
a 1
a 2
a 3
b 1
b 2
b 3
c 1
c 2
c 3
['a', 'b', 'c'], [1, 2, 3]
aaa
bbb
ccc
111
222
333
a 1 2 3
b 1 2 3
c 1 2 3
def sum(a, b):
# a = 1
# b = 2
# sum(a, b) = 3
return a + b
def sum(a, b):
"""
a = 1
b = 2
sum(a, b) = 3
"""
return a + b
def sum(a, b):
"""
>>> a = 1
>>> b = 2
>>> sum(a, b)
3
"""
return a + b
def sum(a, b):
'''
a = 1
b = 2
sum(a, b) = 3
'''
return a + b
Explicación: Usa """ para comenzar y terminar el docstring y usa >>> para representar la salida. Si escribes esto correctamente, también puedes ejecutar el doctest usando el módulo doctest incorporado
Ejemplo
# la función namedtuple acepta los siguientes argumentos para generar una clase
from collections import namedtuple
>>> Point = namedtuple('Point',['x','y'])
>>> point = Point(100, 200)
>>> point
Point(x=100, y=200)
# Lo que te permite usar tanto desempaquetado como iteración para acceder
>>> x, y = point
>>> print(f'({x}, {y})')
(100, 200)
>>> for coordinate in point:
print(coordinate)
100
200
&&===||fruit_info = {
'fruit': 'apple',
'count': 2,
'price': 3.5
}
fruit_info['price'] = 1.5my_list[3.5] = 1.51.5 = fruit_info['price]my_list['price'] == 1.55 != 6
yesFalseTrueNoneExplicación: En Python, != es equivalente a no igual a.
__init__() de una clase?Ejemplo:
class test:
def __init__(self):
print('I came here without your permission lol')
pass
t1 = test()
>>> 'I came here without your permission lol'
Cuántos microprocesadores se necesitarían para ejecutar tu código en menos de un segundoCuántas líneas de código hay en tu archivo de códigoLa cantidad de espacio ocupado en memoria en función del tamaño de la entradaCuántas copias del archivo de código podrían caber en 1 GB de memoriafruit_info = {'fruit': 'apple', 'count': 2, 'price': 3.5}fruit_info =('fruit': 'apple', 'count': 2,'price': 3.5 ).dict()fruit_info = ['fruit': 'apple', 'count': 2,'price': 3.5 ].dict()fruit_info = to_dict('fruit': 'apple', 'count': 2, 'price': 3.5)fruits = {'Apples': 5, 'Oranges': 3, 'Bananas': 4}
fruit_names = [x in fruits.keys() for x]fruit_names = for x in fruits.keys() *fruit_names = [x for x in fruits.keys()]fruit_names = x for x in fruits.keys()self al definir o llamar métodos en una instancia de un objeto?self se refiere a la clase de la cual se heredó para crear el objeto usando self.self. Es solo jerga informática heredada que Python mantiene para ser consistente con otros lenguajes de programación.self significa que no se requiere que se pasen otros argumentos al método.self se refiere a la instancia cuyo método fue llamado.Explicación: - Intenta ejecutar el ejemplo de Q42 sin pasar el argumento self en el __init__, entenderás la razón. Obtendrás el error como este __init__() takes 0 positional arguments but 1 was given, esto significa que algo entra aunque no se haya especificado, que es la instancia misma.
Referencia
Los métodos de clase son métodos que se llaman en la clase misma, no en una instancia de objeto específica. Por lo tanto, pertenece a un nivel de clase, y todas las instancias de clase comparten un método de clase.
def getMaxNum(list_of_nums): # cuerpo de la función aquífunc get_max_num(list_of_nums): # cuerpo de la función aquífunc getMaxNum(list_of_nums): # cuerpo de la función aquídef get_max_num(list_of_nums): # cuerpo de la función aquíEl uso de guiones bajos como separadores de palabras se remonta a finales de los años 1960. Está particularmente asociado con C, se encuentra en The C Programming Language (1978), y contrasta con Pascal case (un tipo de camel case). Sin embargo, la convención tradicionalmente no tenía un nombre específico: la guía de estilo del lenguaje de programación Python simplemente se refiere a él como “lower_case_with_underscores”. En Usenet, el término snake_case se vio por primera vez en la comunidad Ruby en 2004, usado por Gavin Kistner, escribiendo: Por cierto… ¿cómo llamas a este estilo de nomenclatura? ¿snake_case? Así es como lo llamaré hasta que alguien me corrija.
maxValue = 255max_value = 255MAX_VALUE = 255MaxValue = 255Usa una letra mayúscula única, una palabra o palabras. Separa las palabras con guiones bajos para mejorar la legibilidad. Referencia
Deque o Double Ended Queue es una versión generalizada de la estructura de datos Queue que permite inserción y eliminación en ambos extremos. referencia
my_set = {0, 'apple', 3.5}my_set = to_set(0, 'apple', 3.5)my_set = (0, 'apple', 3.5).to_set()my_set = (0, 'apple', 3.5).set()__init__() que no toma parámetros?class __init__(self):
pass
def __init__():
pass
class __init__():
pass
def __init__(self):
pass
En ciencias de la computación, un árbol de búsqueda binaria (BST), también llamado árbol binario ordenado o clasificado, es una estructura de datos de árbol binario enraizado con la clave de cada nodo interno siendo mayor que todas las claves en el subárbol izquierdo del nodo respectivo y menor que las de su subárbol derecho. referencia
Los decoradores nos permiten envolver otra función para extender el comportamiento de la función envuelta, sin modificarla permanentemente. referencia
def tax(my_float):
''' Calcula el impuesto de ventas de una compra. Toma un float que representa el subtotal como argumento y devuelve un float que representa el impuesto de ventas.'''
pass
def tx(amt):
''' Obtiene el impuesto de una cantidad.'''
def sales_tax(amount):
''' Calcula el impuesto de ventas de una compra. Toma un float que representa el subtotal como argumento y devuelve un float que representa el impuesto de ventas.'''
def calculate_sales_tax(subtotal):
pass
mixin?mixin para forzar a una función a aceptar un argumento en tiempo de ejecución aunque el argumento no estuviera incluido en la definición de la función.mixin para permitir que un decorador acepte argumentos de palabras clave.mixin para asegurar que los atributos y métodos de una clase no interfieran con las variables y funciones globales.mixin para definir esa funcionalidad.Hay dos situaciones principales donde se usan los mixins: Quieres proporcionar muchas funcionalidades opcionales para una clase. Quieres usar una funcionalidad particular en muchas clases diferentes. referencia explicación
Explicación: La pila usa el enfoque último en entrar, primero en salir (last in first out).
with?with te permite elegir en qué aplicación abrir el archivo.with actúa como un bucle for, y te permite acceder a cada línea en el archivo una por una.with para abrir un archivo en Python.with en Python, Python se asegurará de que el archivo se cierre, incluso si se lanza una excepción o error.Es una buena práctica usar la palabra clave ‘with’ cuando se trata de objetos archivo. La ventaja es que el archivo se cierra correctamente después de que su suite termina, incluso si se lanza una excepción en algún punto. Usar with también es mucho más corto que escribir bloques try-finally equivalentes:
ejemplo
>>> f = open('workfile', 'w', encoding="utf-8")
>>> with open('workfile', encoding="utf-8") as f:
read_data = f.read()
# Podemos verificar que el archivo se ha cerrado automáticamente.
>>> f.closed
True
python3 -m doctest <_filename_>python3 <_filename_>python3 <_filename_> rundoctestspython3 doctestTambién hay un atajo de línea de comandos para ejecutar testmod(). Puedes instruir al intérprete de Python para ejecutar el módulo doctest directamente desde la biblioteca estándar y pasar el/los nombre(s) de módulo en la línea de comandos:
python -m doctest -v example.py
Esto importará example.py como un módulo independiente y ejecutará testmod() en él. Ten en cuenta que esto puede no funcionar correctamente si el archivo es parte de un paquete e importa otros submódulos de ese paquete.
referencia
video tutorial
Explicación:
La notación lambda es una función anónima que puede tomar cualquier número de argumentos con solo una expresión (es decir, no puede sobrecargarse). Ha sido introducida en otros lenguajes de programación, como C++ y Java. La notación lambda permite a los programadores “evitar” la declaración de función.
def get_next_card():
# cuerpo del método aquí
def get_next_card(self):
# cuerpo del método aquí
def self.get_next_card():
# cuerpo del método aquí
def self.get_next_card(self):
# cuerpo del método aquí
get_max_num([57, 99, 31, 18])call.(get_max_num)def get_max_num([57, 99, 31, 18])call.get_max_num([57, 99, 31, 18])-- Esto es un comentario# Esto es un comentario/* Esto es un comentario */// Esto es un comentarioapple en la lista con la cadena orange?my_list = ['kiwi', 'apple', 'banana']
orange = my_list[1]my_list[1] = 'orange'my_list['orange'] = 1my_list[1] == orangenum_people = 5
if num_people > 10:
print("There is a lot of people in the pool.")
elif num_people > 4:
print("There are some people in the pool.")
else:
print("There is no one in the pool.")
num_people = 5
if num_people > 10:
print("There is a lot of people in the pool.")
if num_people > 4:
print("There are some people in the pool.")
else:
print("There is no one in the pool.")
num_people = 5
if num_people > 10;
print("There is a lot of people in the pool.")
elif num_people > 4;
print("There are some people in the pool.")
else;
print("There is no one in the pool.")
if num_people > 10;
print("There is a lot of people in the pool.")
if num_people > 4;
print("Hay algunas personas en la piscina.")
else;
print("No hay nadie en la piscina.")
defaultdict?defaultdict creará automáticamente un diccionario para ti que tiene claves que son los enteros 0-10.defaultdict fuerza a un diccionario a aceptar solo claves de los tipos especificados cuando se crea el defaultdict (como cadenas o enteros).defaultdict con una clave inexistente, se creará un nuevo par clave-valor por defecto para ti en lugar de lanzar un KeyError.defaultdict almacena una copia de un diccionario en memoria al cual puedes volver por defecto si el original se modifica involuntariamente.defaultdict es un diccionario tipo contenedor presente en el módulo collections. La funcionalidad de los diccionarios y de defaultdict es casi la misma, excepto que defaultdict nunca lanza un KeyError. Proporciona un valor por defecto para la clave que no existe.
ejemplo
# Función para devolver un valor por defecto
# para claves que no están presentes
def def_value():
return "Not Present"
# Definiendo el dict
d = defaultdict(def_value)
variety al diccionario fruit_info que tiene un valor de Red Delicious?fruit_info['variety'] == 'Red Delicious'fruit_info['variety'] = 'Red Delicious'red_delicious = fruit_info['variety']red_delicious == fruit_info['variety']while?Ejemplo Simple
i = 1
while i<6:
print(f"Countdown: {i}")
i = i + 1
__init__() que establece atributos específicos de instancia al crear una nueva instancia de clase?def __init__(self, attr1, attr2):
attr1 = attr1
attr2 = attr2
def __init__(attr1, attr2):
attr1 = attr1
attr2 = attr2
def __init__(self, attr1, attr2):
self.attr1 = attr1
self.attr2 = attr2
def __init__(attr1, attr2):
self.attr1 = attr1
self.attr2 = attr2
Explicación: Al instanciar un nuevo objeto de una clase dada, el método __init__() tomará tanto attr1 como attr2, y establecerá sus valores a su atributo de objeto correspondiente, por eso necesitas usar self.attr1 = attr1 en lugar de attr1 = attr1.
def count_recursive(n=1):
if n > 3:
return
print(n)
count_recursive(n + 1)
1
1
2
2
3
3
3
2
1
3
3
2
2
1
1
1
2
3
Intersect; union|; &&; |&&; ||import numpy as np
np.ones([1,2,3,4,5])
open. ¿Cuál podría ser la solución más simple?PATH del sistema.PYTHONPATH.{x for x in range(100) if x%3 == 0}
referencia Es una Comprensión de Conjunto porque está entre ‘{}’, llaves, así que devolverá un ‘Conjunto’ !
datetimedatedaydaytimetimedatedef Game(): passdef Game: passclass Game: passclass Game(): passmy_game = Game(self) self.my_game.roll_dice()my_game = Game() self.my_game.roll_dice()my_game = Game() my_game.roll_dice()my_game = Game(self) my_game.roll_dice(self)a = np.array([1,2,3,4])
print(a[[False, True, False, False]])
{0,2}[2]{2}[0,2,0,0]z = y.split(';')
len(z)
Explicación:
y="stuff;thing;junk"
len(z) ==> 3
y="stuff;thing;junk;"
len(z) ==> 4
num_list = [1,2,3,4,5]
num_list.remove(2)
print(num_list)
[1,2,4,5][1,3,4,5][3,4,5][1,2,3]Explicación: .remove() está basado en el valor del elemento, no en el índice; aquí, elimina el elemento que coincide con “2”. Si quisieras eliminar un elemento basado en su índice, usarías .pop().
num_list = [1,2,3,4,5]
num_list.pop(2)
>>> [1,2,4,5]
num_list.remove(2)
>>> [1,3,4,5]
[10,9,8,7,6,5,4,3,2,1]
reversed(list(range(1,11)))list(reversed(range(1,10)))list(range(10,1,-1))list(reversed(range(1,11)))import math
print(math.pow(2,10)) # imprime 2 elevado a la potencia 10
print(2^10)
print(2**10)
y = [x*2 for x in range(1,10)]
print(y)
y = 1
for i in range(1,10):
y = y * 2
print(y)
[] son _, {} son _, y () son _.table = np.array([
[1,3],
[2,4]])
print(table.max(axis=1))
[2, 4][3, 4][4][1,2]number = 3
print(f"The number is {number}")
The number is 3the number is 3THE NUMBER IS 3TypeError porque el entero debe convertirse a cadena.my_tuple tup(2, 'apple', 3.5) %Dmy_tuple [2, 'apple', 3.5].tuple() %Dmy_tuple = (2, 'apple', 3.5)my_tuple = [2, 'apple', 3.5]write('w')scan('s')append('a')read('r')setlisttupledictionarysys.exc_info()os.system()os.getcwd()sys.executablemy_dictionary = {
'A': 1,
'B': 2,
'C': 3,
'D': 4,
'E': 5
}
letters = []
for letter in my_dictionary.values():
letters.append(letter)
letters = my_dictionary.keys()letters = [letter for (letter, number) in my_dictionary.items()]letters4 = list(my_dictionary)Explicación: El primero (la opción correcta) devuelve la lista de los valores (los números). El resto de las opciones devuelven una lista de las claves.
print. ¿Qué función puedes usar dentro de NumPy para forzarlo a imprimir todo el array?set_printparamsset_printoptionsset_fullprintsetp_printwholetry/except cuando quieres ejecutar algún código, pero necesitas una forma de ejecutar código diferente si se lanza una excepción.try/except dentro de pruebas unitarias para que las pruebas unitarias siempre pasen.try/except para poder demostrar a tus revisores de código que intentaste un nuevo enfoque, pero si el nuevo enfoque no es lo que estaban buscando, pueden dejar comentarios bajo la palabra clave except.try/except para que ninguna de tus funciones o métodos devuelva None.debido al nivel de indentación después del bucle fordebido a la palabra clave end al final del bucle forporque el bloque está rodeado por llaves ({})debido al espacio en blanco al final del cuerpo del bucle forsys.stdoutx después de ejecutar este código?x = {1,2,3,4,5}
x.add(5)
x.add(6)
{1, 2, 3, 4, 5, 5, 6}{5, 6, 1, 2, 3, 4, 5, 6}{6, 1, 2, 3, 4, 5}{1, 2, 3, 4, 5, 6}Explicación: El método .add() agrega el elemento al conjunto solo si no existe.
fruit_info = {
'fruit': 'apple',
'count': 2,
'price': 3.5
}
my_keys = fruit_info.to_keys()my_keys = fruit_info.all_keys()my_keys = fruit_info.keysmy_keys = fruit_info.keys()def be_friendly(greet = "How are you!", name):
pass
name es una palabra reservada.np, ¿qué opción devolverá True?a = np.zeros([3,4])
b = a.copy()
np.array_equal(a,b)
a = np.empty([3,4])
b = np.empty([3,4])
np.array_equal(a,b)
a = np.zeros([3,4])
b = np.zeros([4,3])
np.array_equal(a,b)
a = np.array([1, np.nan])
np.array_equal(a,a)
// Esto es un comentario# Esto es un comentario-- Esto es un comentario/* Esto es un comentario */import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = a*b
d = np.dot(a,b)
c = [ a[1] * b[1], a[2] * b[2], a[3] * b[3] ]
d = sum(c)
c = a[0] * b[0], a[1] * b[1], a[2] * b[2]
d = [ a[0] * b[0], a[1] * b[1], a[2] * b[2] ]
c = [ a[0] * b[0], a[1] * b[1], a[2] * b[2] ]
d = sum(a) + sum(b)
c = [ a[0] * b[0], a[1] * b[1], a[2] * b[2] ]
d = sum(c)
linalg.eig() and .matmul()linalg.inv() and .dot()linalg.det() and .dot()linalg.inv() and .eye()Explicación: Entender esta respuesta requiere conocimiento de álgebra lineal. Algunos sistemas de ecuaciones pueden resolverse mediante el método de diagonalización, que implica encontrar los vectores propios y valores propios de la matriz del sistema y multiplicar matrices relacionadas.
my_list = (2, 'apple', 3.5)my_list = [2, 'apple', 3.5]my_list = [2, 'apple', 3.5].to_list()my_list = to_list(2, 'apple', 3.5)num_list = [21, 13, 19, 3, 11, 5, 18]
num_list.sort()
num_list[len(num_list) // 2]
Explicación: // es el operador de división entera, que es una operación de división normal que devuelve el entero más grande posible, menor o igual al resultado de la división normal. Aquí se usa para encontrar la mediana, que es el valor que separa la mitad superior de la mitad inferior de una muestra de datos, encontrando el índice del elemento de la lista en el medio de la lista. (Esto es suficiente para una lista con un número impar de elementos; si la lista tuviera un número par de elementos, promediarías los valores de los dos elementos del medio para encontrar el valor de la mediana.)
vector de tipo np.array con 10,000 elementos. ¿Cómo puedes convertir vector en una variable llamada matrix con dimensiones 100x100?matrix = (vector.shape = (100,100))matrix = vector.to_matrix(100,100)matrix = matrix(vector,100,100)matrix = vector.reshape(100, 100)def myFunction(country = "France"):
print(f"Hello, I am from {country}")
myFunction("Spain")
myFunction("")
myFunction()
Hello, I am from Spain
Hello, I am from
Hello, I am from
Hello, I am from France
Hello, I am from France
Hello, I am from France
Hello, I am from Spain
Hello, I am from
Hello, I am from France
Hello, I am from Spain
Hello, I am from France
Hello, I am from France

sum(titanic['Survived'])[x for x in titanic['Survived'] if x == 1]len(titanic["Survived"])sum(titanic['Survived']==0)Explicación: El titanic['Survived'] devuelve un objeto pandas.Series, que contiene la columna Survived del DataFrame.
Sumar los valores de esta columna (es decir, sum(titanic['Survived'])) devuelve el número total de sobrevivientes ya que un sobreviviente está representado por un 1 y una pérdida por 0.
characters = ["Iron Man", "Spider Man", "Captain America"]
actors = ["Downey", "Holland", "Evans"]
# salida ejemplo : [("IronMan", "Downey"), ("Spider Man", "Holland"), ("Captain America", "Evans")]
[(x,y)] for x in characters for y in actors]zip(characters, actors)
d = {}
for x in range(1, len(characters)):
d[x] = actors[x]
{x:y for x in characters for y in actors}{x : x*x for x in range(1,100)}
x como clave, y x al cuadrado como su valor; de 1 a 100.x como clave, y x al cuadrado como su valor; de 1 a 99.x, x al cuadrado); de 1 a 99.
def jaccard(a, b): return len (a | b) / len (a & b)def jaccard(a, b): return len (a & b) / len (a | b)def jaccard(a, b): return len (a && b) / len (a || b)def jaccard(a, b): return a.intersection(b) / a.union(b)[1,2,3] * 3
[3,2,3][1, 2, 3, 1, 2, 3, 1, 2, 3][3,6,9][1,2,3,4], ¿cuál es el valor de numbers[-2]?__init__() que no toma parámetros?def __init__(self): passclass __init__(self): passclass __init__(): passdef __init__(): pass() - parámetro vacío.
self - se refiere a todas las instancias dentro de una clase.
__init__ - un método reservado, también conocido como constructor.
__init__() - siempre se ejecuta cuando se inicia la clase.
sin de la biblioteca math. ¿Cuál es la sintaxis correcta para importar solo esa función?from math import sinimport sin from mathimport math.sinfrom math.sin import mathmy_set = {0, 'apple', 3.5}my_set = to_set(0, 'apple', 3.5)my_set = (0, 'apple', 3.5).to_set()my_set = (0, 'apple', 3.5).set()import numpy as np
a = np.array([1, 2, 3])
print(a[1])
2[1, 2, 3]1[2]fruit_info = to_dict("fruit": "apple", "count": 2, "price": 3.5)fruit_info = {"fruit": "apple", "count": 2, "price": 3.5}fruit_info = ("fruit": "apple", "count": 2, "price": 3.5).dict()fruit_info = ("fruit": "apple", "count": 2, "price": 3.5)Explicación: La biblioteca Pandas se usa comúnmente para trabajar con datos tabulares, como datos en forma de tablas o hojas de cálculo. Proporciona estructuras de datos y funciones para manipulación y análisis de datos. Por otro lado, NumPy es una biblioteca poderosa para computación numérica en Python, y a menudo se usa para realizar operaciones matemáticas en datos numéricos, como arrays y matrices.
gcc o clang.pip o conda.
random.uniform(0,50);plt.histrandom.gauss(50,20);plt.histrandom();plt.scatterrandom.triangular(0,50);plt.bara y b?import numpy as np
a = np.arange(100)
b = a[50:60:2]
a: todos los enteros de 0 a 99 (inclusive); b: todos los enteros pares de 50 a 58 (inclusive).a: todos los enteros de 0 a 100 (inclusive); b: todos los enteros pares de 50 a 60 (inclusive).a: todos los enteros de 0 a 99 (inclusive); b: todos los enteros pares de 50 a 60 (inclusive).a: todos los enteros de 0 a 99 (inclusive); b: todos los enteros impares de 49 a 59 (inclusive).my_object?my_object.get_shape()my_object.shapemy_object.dim()len(my_object)mylist y quieres buscar un valor específico. El número mínimo de comparaciones será _ y el número máximo de comparaciones será _.len(mylist); len(mylist)1; len(mylist)2; len(mylist)0; len(mylist)Explicación: Puedes usar una declaración break y el valor que se busca puede ser el primer elemento de la lista, dado que no está vacía.
0TrueNoneFalseimport numpy as np
def can_matrices_be_multiplied (matrix1, matrix2):
rowsMat1, columnsMat1 = matrix1.shape
rowsMat2, columnsMat2 = matrix2.shape
if _____ == ______ :
print("Las matrices pueden multiplicarse!")
return True
else:
return False
referencia. Una matriz puede multiplicarse por cualquier otra matriz que tenga el mismo número de filas que la primera tiene columnas. Es decir, una matriz con 2 columnas puede multiplicarse por cualquier matriz con 2 filas
[(x, x+1) for x in range(1,5)]
class Father():
name = 'Robert'
class Person(Father):
def __init__(self, name):
self.fathername = super.name
self.name = name
def introduce(self):
print(f"My name is {self.name} son of {self.fathername}")
king = Person("Joffrey")
king.introduce()
class Father():
name = 'Robert'
class Person(Father):
def __init__(self, name):
self.fathername = self.name
self.name = name
def introduce(self):
print(f"My name is {self.name} son of {self.fathername}")
king = Person("Joffrey")
king.introduce()
class Father():
name = 'Robert'
class Person(Father):
def __init__(self, name):
self.name = name
def introduce(self):
print(f"My name is {self.name} son of {super.name}")
king = Person("Joffrey")
king.introduce()
class Father():
name = 'Robert'
class Person(Father):
def __init__(self, name):
self.name = name
def introduce(self):
print(f"My name is {self.name} son of {base.name}")
king = Person("Joffrey")
king.introduce()
Explicación: En el primero, super no tiene .name (debería ser self.name). El tercero pierde Robert, y base no está definido en el cuarto.
animals = {
'a': ['ant', 'antelope', 'armadillo'],
'b': ['beetle', 'bear', 'bat'],
'c': ['cat', 'cougar', 'camel']
}
animals = defaultdict(list, animals)
print(animals['b'])
print(animals['d'])
['beetle', 'bear', 'bat']
[]
['beetle', 'bear', 'bat']
# se lanzará una excepción
['beetle', 'bear', 'bat']
None
['bat', 'bear', 'beetle']
[]
Explicación: Los diccionarios usualmente resultan en una excepción cuando se usa la sintaxis de corchetes cuadrados. Defaultdict aquí devuelve un valor por defecto dedicado por el primer parámetro, así que en lugar de lanzar una excepción, devuelven el valor por defecto. Nota que esto necesita importarse como sigue: from collections import defaultdict
n ya está definido como cualquier valor entero positivo.)[x*2 for x in range(1,n)]
x = 18
if x > 10:
if x > 15:
print('A')
else:
print('B')
else:
print('C')
CBABCreferencia No se especifica una longitud fija pero Pep-8 especifica bajo “Longitud Máxima de Línea” “Limitar todas las líneas a un máximo de 79 caracteres”.
i cuando el siguiente bucle termine su ejecución?for i in range(5): pass
f-strings también se llaman:Explicación: El threading de Python está restringido a un solo CPU a la vez. La biblioteca multiprocessing te permitirá ejecutar código en diferentes procesadores.
y en este código?x = 5
y = 1 + (20 if x < 5 else 30)
False21231Explicación: Si tienes solo una declaración para ejecutar, una para if y una para else, puedes ponerlo todo en la misma línea.
x = 5
# Esta es la misma declaración expandida a múltiples líneas
y = 1
if (x < 5):
y += 20
else:
y += 30
referencia
“Pickling” es el proceso por el cual una jerarquía de objetos Python se convierte en un flujo de bytes, y “unpickling” es la operación inversa, por la cual un flujo de bytes (de un archivo binario u objeto tipo bytes) se convierte de vuelta en una jerarquía de objetos.
print("codescracker".endswith("er"))
True12Falseprint("programming".center())
crprogrammingTypeError: center expected at least 1 argument, got 0.referencia. El método center() alineará al centro la cadena, usando un carácter especificado (el espacio es el predeterminado) como carácter de relleno.
Sintaxis: string.center(length, character) donde length es requerido!
x = 1j
print(x**2 == -1)
j no ha sido inicializada.True1jFalseExplicación: La letra j actúa como la unidad imaginaria en Python, por lo tanto x**2 significa j**2 que es igual a -1. La declaración x**2 == -1 se evalúa como True.
print(0xA + 0xB + 0xC)
33630xA + 0xB + 0xCNoneExplicación: A, B y C son enteros hexadecimales con valores 10, 11 y 12 respectivamente, así que la suma de A, B y C es 33.
for i in range(5):
print(i)
else:
print("Done!")
1
2
3
4
5
Done!
0
1
2
3
4
5
Done!
0
1
2
3
4
Done!
execution_fn:import functools
import time
def timer(MISSING_ARG_1):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = time.perf_counter()
rval = func(*args, **kwargs)
end_time = time.perf_counter()
duration = end_time - start_time
print(f"Executed in {duration:.4f} seconds")
return MISSING_ARG_2
return MISSING_ARG_3
@timer
def execution_fn():
for i in range(3):
time.sleep(1)
execution_fn()
¿Cuál de las siguientes opciones son los argumentos faltantes?
MISSING_ARG_1 = wrapper
MISSING_ARG_2 = rval
MISSING_ARG_3 = func
MISSING_ARG_1 = func
MISSING_ARG_2 = rval
MISSING_ARG_3 = wrapper
MISSING_ARG_1 está vacío
MISSING_ARG_2 = rval
MISSING_ARG_3 = wrapper
MISSING_ARG_1 está vacío
MISSING_ARG_2 = rval
MISSING_ARG_3 = func
Dog en Python?class Dog:Dog class:Dog:class Dogscikit-learn, importa del submódulo scikit-learn.\_.preprocessingpipelinefilterspipe_filterreferencia La sintaxis correcta es en realidad: from sklearn.pipeline import Pipeline
a = np.array([[1, 2], [3, 4], [5, 6]])
c = a[(a > 3) & (a < 11)]
print(c)
[[3, 4], [5, 6]][False, False, False, True, True, True][[0,0], [3, 4], [5, 6]][4 5 6]m, n, y p son enteros positivos. En la siguiente comprensión, ¿cuántas veces se llamará la función randint?[ [ [ randint(1,100) for i in range(m) ] for j in range(n) ] for k in range(p) ]
m * n * p(m,n,p).m + n + pMyClass que tiene herencia múltiple y métodos con el mismo nombre en sus ancestros. ¿Qué método de clase podrías llamar para ver qué método tendrá prioridad cuando sea invocado?MyClass.__mro__MyClass.hierarchy()callable(MyClass)dir(MyClass)Explicación: MRO significa Method Resolution Order (Orden de Resolución de Métodos). Devuelve una lista de tipos de los cuales la clase se deriva, en el orden en que se buscan los métodos.
employees = {
'alice':{
'position':'Lead Developer',
'salary':1000
},
'bob':{
'position': 'Lead Artist',
'salary':2000
},
'charlie':{
'position':'cfo',
'salary':3000
}
}
employees['alice']['salary'] = employees['charlie']['salary']employees.alice.salary = employees.charlie.salaryemployees['alice'][1] = employees['charlie'][1]employees['alice'].salary = employees['charlie'].salaryExplicación: Esto es acceder a una clave en un diccionario anidado dentro de otro diccionario. El comando employees['alice']['salary'] = employees['charlie']['salary'] asigna el valor de la clave salary en el diccionario del empleado charlie al valor de la clave salary en el diccionario del empleado alice.
m y n ya están definidos como algún valor entero positivo. Cuando se complete, ¿cuántas tuplas contendrá mi lista?mylist = []
for i in range(m):
for j in range(n):
mylist.append((i,j))
mm + nnm * nExplicación: Este código se ejecutará m x n veces, si ejecutas este código, creará m x n tuplas.
El primer bucle se ejecuta m veces y el bucle interno se ejecutará n veces. La única iteración del primer bucle solo se completará cuando todas las n iteraciones de un bucle interno se hayan completado. Este es el mismo proceso para la 2da, y 3ra, … m-ésima iteraciones para el bucle externo. En general, ambos bucles se ejecutarán m x n veces.
{x : [y for y in range (1, x) if x % y == 0] for x in range (2, 100)}
characters = ["Iron Man", "Spider Man", "Captain America"]
actors = ["Downey", "Holland", "Evans"]
#Salida deseada : [("Iron Man", "Downey"), ("Spider Man", "Holland"), ("Captain America", "Evans")]
Explicación: zip() es la función correcta para este caso de uso. Sin embargo, zip() hace un objeto tipo zip que es un iterador. Por lo tanto, usar list() es necesario para convertir el objeto zip en una lista de tuplas que puede mostrarse o accederse directamente. Las otras opciones tienen errores lógicos.
if __name__ == "__main__": en un script Python?El bloque if __name__ == "__main__": se ejecuta cuando el script se ejecuta directamente pero no cuando se importa como módulo en otro script.
referencia
def square(x):
return x * x
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)
result = list(squared_numbers)
print(result)
[1, 4, 9, 16, 25][1, 2, 3, 4, 5][1, 8, 27, 64, 125][2, 4, 6, 8, 10]El código define una función square para calcular el cuadrado de un número. Luego usa la función map para aplicar esta función a cada elemento en la lista numbers, resultando en un nuevo iterable. Finalmente, el constructor list se usa para convertir este iterable en una lista. La salida será una lista de números al cuadrado.
referencia
print("Hello {name1} and {name2}".format(name1='foo', name2='bin'))
def outer_func(x):
y = x + 1
def inner_func():
return y + x
return inner_func
x = 10
y = 20
closure_func = outer_func(x)
print(closure_func())
Explicación: Cuando se llama outer_func(10), y se establece en 11 dentro de outer_func. La inner_func, que tiene acceso al ámbito de outer_func, devuelve y + x. Cuando se llama closure_func(), usa y = 11 (de outer_func) y x = 10 del ámbito global, no del argumento de la función. Por lo tanto, closure_func() devuelve 11 + 10 = 21.
x = 5
def func():
x = 10
print(x)
func()
print(x)
Explicación: La respuesta correcta es 10, 5.
En el código dado, la variable x se define primero en el ámbito global con un valor de 5. Dentro de la función func(), se crea una nueva variable local x y se le asigna el valor de 10. Cuando se llama func(), imprime el valor de la x local, que es 10.
Después de la llamada a la función, la declaración print fuera de la función se refiere a la x global, que aún tiene el valor de 5.
Por lo tanto, la salida es 10, 5.
def func(a, b=2, c=3):
print(a, b, c)
func(10)
func(10, 20)
func(10, 20, 30)
Explicación: La respuesta correcta es 10 2 3, 10 20 3, 10 20 30.
En el código dado, la función func() tiene tres parámetros: a, b, y c. b y c tienen valores por defecto de 2 y 3, respectivamente.
Cuando se llama func(10), solo se proporciona el primer parámetro a, así que b y c toman sus valores por defecto de 2 y 3, respectivamente.
Cuando se llama func(10, 20), el primer parámetro a es 10, y el segundo parámetro b es 20. El tercer parámetro c toma su valor por defecto de 3.
Cuando se llama func(10, 20, 30), se proporcionan los tres parámetros, así que a es 10, b es 20, y c es 30.
Por lo tanto, la salida es: 10 2 3 10 20 3 10 20 30
x = [1, 2, 3]
y = x
y.append(4)
print(x)
Explicación: La respuesta correcta es [1, 2, 3, 4].
En Python, asignar y = x no crea una nueva lista; tanto x como y se refieren al mismo objeto en memoria. Así que cuando llamamos y.append(4), modifica la lista original a la que ambas variables apuntan. Por lo tanto, imprimir x mostrará la lista actualizada [1, 2, 3, 4].
def add_item(item, item_list=[]):
item_list.append(item)
return item_list
print(add_item(1))
print(add_item(2))
print(add_item(3, []))
Explicación: La respuesta correcta es [1] [1, 2] [3].
En Python, los argumentos mutables por defecto (como las listas) se evalúan solo una vez cuando se define la función — no cada vez que se llama. Eso significa que las primeras dos llamadas a add_item() comparten la misma lista por defecto, así que acumula valores [1] y luego [1, 2].
Sin embargo, en la tercera llamada add_item(3, []), pasamos una nueva lista vacía, así que crea una lista separada [3].
len() para una clase personalizada?__length__()__len__()__size__()__count__()def decorator(func):
def wrapper(*args, **kwargs):
print("Before function call")
result = func(*args, **kwargs)
print("After function call")
return result
return wrapper
@decorator
def greet(name):
print(f"Hello, {name}!")
greet("Alice")
Before function call, Hello, Alice!, After function callHello, Alice!Before function call, After function calldecoratoryieldclass Parent:
def method(self):
print("Parent method")
class Child(Parent):
def method(self):
super().method()
print("Child method")
obj = Child()
obj.method()
Parent method, Child methodChild method, Parent methodChild methodParent method__str__()__repr__()__format__()__debug__()from functools import lru_cache
@lru_cache(maxsize=None)
def fibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(10))
print(fibonacci.cache_info())
55 y estadísticas de caché55 y NoneRecursionErrorTypeError