any()
en una lista?any()
devolverá aleatoriamente cualquier elemento de la lista.any()
devuelve True si algún elemento de la lista se evalúa como True. De lo contrario, devuelve False.any()
toma como argumentos la lista a verificar dentro y el elemento a verificar. Si “cualquiera” de los elementos de la lista coincide con el elemento a comprobar, 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
, que se usa cuando se prueba la igualdad entre objetos.Explicación `Atributos definidos bajo la clase, los argumentos van bajo las funciones. los argumentos generalmente se refieren como parámetros, mientras que los atributos son el constructor de la clase o una instancia de una clase.
recuento, fruta, precio = (2, 'manzana', 3,5)
asignación de tupla
desempaquetado de tuplas
coincidencia de tuplas
duplicación de tuplas
.delete()
pop(mi_lista)
del(mi_lista)
.pop()
ejemplo
my_list = [1,2,3]
my_list.pop(0)
my_list
>>>[2,3]
class Game(LogicGame): pass
def Game(LogicGame): pass
def Game.LogicGame(): pass
class Game.LogicGame(): pass
Explicación: La clase principal que se hereda se pasa como argumento a la clase secundaria. Por lo tanto, aquí 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: use '''
para iniciar el documento y agregue la salida de la celda después de >>>
set
list
None
dictionary
Solo 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 es necesario pasar ningún otro argumento al método.self
; es solo una jerga informática histórica que Python mantiene para mantenerse 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 que se heredó para crear el objeto usando self
.Ejemplo sencillo
class my_secrets:
def __init__(self, password):
self.password = password
pass
instance = my_secrets('1234')
instance.password
>>>'1234'
namedtuple
y referirse a ellos de esa manera, de manera similar a como accedería a las claves en el dictionary
.tuple
normal.namedtuples
son tan eficientes en memoria como las tuple
regulares.namedtuples
porque están disponibles en la biblioteca estándar.Necesitamos importarlo usando:from collections import namedtuple
Ninguno
.set
en Inglés Referenciami_juego = class.Juego()
mi_juego = class(Juego)
mi_juego = Juego()
mi_juego = Juego.create()
map()
?Explicación: - La sinaxis para la función map()
es list(map(function,iterable))
. El buscador de área simple usando el mapa 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
.pass
en Python?yield
de un generador y devolver un valor de Ninguno.while
o for
y volver al inicio del ciclo.slot
dictionary
queue
sorted list
fruits = ['Apples', 'Oranges', 'Bananas']
quantities = [5, 3, 4]
prices = [1.50, 2.25, 0.89]
#Desired output
[('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 “¿Son iguales todos los elementos de esta lista?all()
devuelve True si todos los elementos de la lista se pueden convertir en cadenas. De lo contrario, devuelve False.all()
devolverá todos los valores de la lista.all()
devuelve True si todos los elementos de la lista se evalúan como True. De lo contrario, devuelve False.Explicación - all()
devuelve verdadero si todo en la lista es Verdadero, vea el ejemplo a continuación
test = [True,False,False,False]
if all(test) is True:
print('Yeah all are True')
else:
print('There is an imposter')
>>> 'There is an imposter'
(El formato de respuesta puede variar. Game and roll (o dice_roll) deben llamarse sin parámetros).
>>> dice = Game()
>>> dice.roll()
>>> dice = Game(self)
>>> dice.roll(self)
>>> dice = Game()
>>> dice.roll(self)
>>> dice = Game(self)
>>> dice.roll()
.append()
de la lista?set
en Inglés) y una ‘lista’?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: Use """
para iniciar y finalizar la cadena de documentación y use >>>
para representar la salida. Si escribe esto correctamente, también puede ejecutar la prueba de documentación usando el módulo de prueba de documentación incorporado
Ejemplo
# la función namedtuple acepta los siguientes argumentos para generar una clase
desde colecciones importar namedtuple
>>> Point = namedtuple('Point',['x','y'])
>>> point = Point(100, 200)
>>> point
Point(x=100, y=200)
# Lo que le permite usar tanto el desempaquetado como la 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.5
my_list [3.5] = 1.5
1.5 = fruit_info ['price]
my_list['price'] == 1.5
5 != 6
yes
False
True
None
Explicación - !=
es equivalente a no igual a en python
__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 su código en menos de un segundo
Cuántas líneas de código hay en su archivo de código
La cantidad de espacio ocupado en la memoria en función del tamaño de entrada
¿Cuántas copias del archivo de código caben en 1 GB de memoria
info_fruta = {'fruta': 'manzana', 'recuento': 2, 'precio': 3.5}
info_fruta =('fruta': 'manzana', 'recuento': 2,'precio': 3.5 ).dict()
info_fruta = ['fruta': 'manzana', 'recuento': 2, 'precio': 3.5 ].dict()
info_fruta = to_dict('fruta': 'manzana', 'recuento': 2, 'precio': 3.5)
frutas = {'Manzanas': 5, 'Naranjas': 3, 'Plátanos': 4}
nombres_de_frutas = [x en fruit.keys() for x]
nombres_de_frutas = para x en fruit.keys() *
nombres_de_frutas = [x por x en fruit.keys()]
nombres_de_frutas = x para x en fruit.keys()
self
al definir o llamar a métodos en una instancia de un objeto?self
se refiere a la clase de la que se heredó para crear el objeto usando self
.self
. Es solo una jerga informática heredada que Python mantiene para mantenerse consistente con otros lenguajes de programación.self
significa que no es necesario pasar ningún otro argumento al método.self
se refiere a la instancia cuyo método fue llamado.Explicación: - Intente ejecutar el ejemplo de Q42 sin pasar el argumento self
dentro de __init__
, comprenderá el motivo. Obtendrá un error como este __init__() toma 0 argumentos posicionales pero se le dio 1
, esto significa que algo va adentro incluso si no se ha especificado, que es la instancia misma.
def getMaxNum(list_of_nums): # el cuerpo de la función va aquí
func get_max_num(list_of_nums): # el cuerpo de la función va aquí
func getMaxNum(list_of_nums): # el cuerpo de la función va aquí
def get_max_num(list_of_nums): # el cuerpo de la función va aquí
valor máximo = 255
valor_máximo = 255
VALOR_MAXIMO = 255
Valor máximo = 255
Explicación - deque
se usa para crear un canal de bloque y en eso hay un enfoque de primero en entrar, primero en salir, lo que significa que el último elemento en entrar será el primero en salir.
mi_conjunto = {0, 'manzana', 3.5}
mi_conjunto = to_set(0, 'manzana', 3.5)
mi_conjunto = (0, 'manzana', 3.5).to_set()
mi_conjunto = (0, 'manzana', 3.5).conjunto()
__init__()
que no toma parámetros?class __init__(self):
pass
def __init__():
pass
class __init__():
pass
def __init__(self):
pass
def tax(my_float):
'''Calculates the sales tax of a purchase. Takes in a float representing the subtotal as an argument and returns a float representing the sales tax.'''
pass
def tx(amt):
'''Gets the tax on an amount.'''
def sales_tax(amount):
'''Calculates the sales tax of a purchase. Takes in a float representing the subtotal as an argument and returns a float representing the sales tax.'''
def calculate_sales_tax(subtotal):
pass
mixin
?mixin
para obligar a una función a aceptar un argumento en tiempo de ejecución incluso si el argumento no estaba incluido en la definición de la función.mixin
para permitir que un decorador acepte argumentos de palabras clave.mixin
para asegurarte de que los atributos y métodos de una clase no interfieran con variables y funciones globales.mixin
para definir esa funcionalidad.Explicación La pila usa el enfoque último en entrar, primero en salir
with
?with
le permite elegir en qué aplicación abrir el archivo.with
actúa como un bucle for
y te permite acceder a cada línea del 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 produce una excepción o un error.python3 -m doctest <_nombre_archivo_>
python3 <_nombre_archivo_>
python3 <_nombre de archivo_> pruebas de ejecución
test de documento de python3
Explicación:
La notación lambda es básicamente una función anónima que puede tomar cualquier cantidad de argumentos con una sola expresión (es decir, no se puede sobrecargar). Se ha introducido en otros lenguajes de programación, como C++ y Java. La notación lambda permite a los programadores “pasar por alto” la declaración de funciones.
def get_next_card():
# method body goes here
def get_next_card(self):
# method body goes here
def self.get_next_card():
# method body goes here
def self.get_next_card(self):
# method body goes here
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 comentario
my_list = ['kiwi', 'apple', 'banana']
orange = my_list[1]
my_list[1] = 'orange'
my_list['orange'] = 1
my_list[1] == orange
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.")
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("There are some people in the pool.")
else;
print("There is no one in the pool.")
defaultdict
?defaultdict
creará automáticamente un diccionario para usted que tiene claves que son los números enteros 0-10.defaultdict
obliga a un diccionario a aceptar solo claves que sean de los tipos especificados cuando creó el defaultdict
(como cadenas o números enteros).defaultdict
con una clave inexistente, se creará un nuevo par clave-valor predeterminado para usted en lugar de generar un KeyError
.defaultdict
almacena una copia de un diccionario en la memoria que puede usar de forma predeterminada si el original se modifica involuntariamente.variedad
al diccionario fruit_info
que tiene un valor de Red Delicious
?info_fruta['variedad'] == 'Red Delicious'
info_fruta['variedad'] = 'Red Delicious'
rojo_delicioso = fruit_info['variedad']
rojo_delicioso == fruit_info['variedad']
while
?Ejemplo sencillo
i = 1
while i<6:
print('Countdown:',i)
i = i + 1
__init__()
que establece atributos específicos de la 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á attr1
y attr2
, y establezca sus valores en su atributo de objeto correspondiente, por eso es necesario 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 fácil?{x for x in range(100) if x%3 == 0}
def Juego(): pass
def Juego: pass
class Juego: pass
class Juego(): pass
my_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:
num_list = [1,2,3,4,5]
num_list.pop(3)
>>> [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)) # prints 2 elevated to the 10th power
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}")
El número es 3
el número es 3
EL NÚMERO ES 3
mi_tuple tup(2, 'manzana', 3.5) %D
mi_tupla [2, 'manzana', 3.5].tuple() %D
mi_tupla = (2, 'manzana', 3.5)
mi_tupla = [2, 'manzana', 3.5]
write('w')
scan('s')
append('a')
read('r')
conjunto
lista
tupla
diccionario
sys.exc_info()
os.system()
os.getcwd()
sys.executable
my_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: La primera (la opción correcta) devuelve la lista de los valores (los números). El resto de las opciones devuelven una lista de las claves.
set_printparams
set_printoptions
set_fullprint
setp_printwhole
try/except
cuando desea ejecutar algún código, pero necesita una forma de ejecutar código diferente si se genera una excepción.try/except
dentro de las pruebas unitarias para que los testículos unitarios siempre pasen.try/except
para que pueda demostrar a sus revisores de código que probó 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 sus funciones o métodos devuelva Ninguno
.debido al nivel de sangría después del ciclo for
debido a la palabra clave end al final del bucle for
porque el bloque está entre corchetes ({})
debido al espacio en blanco al final del cuerpo del bucle for
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.keys
my_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() y .matmul()
linalg.inv() y .dot()
linalg.det() y .dot()
linalg.inv() y .eye()
mi_lista = (2, 'manzana', 3.5)
mi_lista = [2, 'manzana', 3.5]
mi_lista = [2, 'manzana', 3.5].to_list()
mi_lista = to_list(2, 'manzana', 3.5)
num_list = [21, 13, 19, 3, 11, 5, 18]
num_list.sort()
num_list[len(num_list) // 2]
Explicación: La mediana es el valor que separa la mitad superior de la mitad inferior de una muestra de datos. Aquí son las 13.
vector
de tipo np.array con 10.000 elementos. ¿Cómo puedes convertir vector
en una variable llamada matriz
con dimensiones 100x100?matrix = (vector.shape = (100,100))
matrix = vector.to_matrix(100,100)
matrix = matrix(vector,100,100)
matrix = vector.reshape(100, 100)
set
en Inglés)string
en Inglés)def myFunction(country = "France"):
print("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: 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 supervivientes, ya que un superviviente se representa con un 1 y una pérdida con un 0.
characters = ["Iron Man", "Spider Man", "Captain America"]
actors = ["Downey", "Holland", "Evans"]
# example output : [("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)}
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]
?() -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?using math.sin
import math.sin
from math import sin
import sin from math
0
el recuento de todos los valores verdaderos
un error de tipo
Ninguno
print ("foo" if (256).bit_length() > 8 else "bar")
random.uniform(0,50);plt.hist
random.gauss(50,20);plt.hist
random();plt.scatter
random.triangular(0,50);plt.bar
import numpy as np
a = np.arange(100)
b = a[50:60:2]
my_object.get_shape()
my_object.shape
my_object.dim()
len(my_object)
len(milista); len(milista)
1; len(milista)
2; len(milista)
0; len(milista)
Explicación: Puede usar una declaración de interrupción y el valor que se busca puede ser el primer elemento de la lista, dado que no está vacío.
import numpy as np
def can_matrices_be_multiplied (matrix1, matrix2):
rowsMat1, columnsMat1 = matrix1.shape
rowsMat2, columnsMat2 = matrix2.shape
if _____ == ______ :
print('The matrices can be multipled!')
return True
else:
return False
[(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("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("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("My name is", self.name, "son of", super.name)
king = Person("Jofrey")
rey.presentar()
clase Padre():
nombre = 'Roberto'
Persona de clase (Padre):
def __init__(uno mismo, nombre):
self.nombre = nombre
def presentar (auto):
print("Mi nombre es", self.name, "hijo de", base.name)
rey = Persona("Joffrey")
rey.presentar()
Explicación: En el primero, super no tiene .name (debe ser self.name), el tercero elimina a Robert y la base no está definida en el 4to.
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']
# an exception will be thrown
['beetle', 'bear', 'bat']
None
['bat', 'bear', 'beetle']
[]
Explicación: Los diccionarios generalmente generan una excepción cuando se usa la sintaxis de corchetes. Defaultdict aquí devuelve un valor predeterminado dedicado por el primer parámetro, por lo que en lugar de lanzar una excepción, devuelven el valor predeterminado. Tenga en cuenta que esto debe importarse de la siguiente manera: from collections import defaultdict
[x*2 for x in range(1,n)]
x = 18
if x > 10:
if x > 15:
print('A')
else:
print('B')
else:
print('C')
para i en el rango (5): pasar
Explicación: los subprocesos de Python están restringidos a una sola CPU a la vez. La biblioteca de multiprocesamiento le permitirá ejecutar código en diferentes procesadores.
x = 5
y = 1 + (20 if x < 5 else 30)
Explicación: Si x < 5 ==> y = 1 + 20 De lo contrario y = 1 + 30
Explicación: el decapado es el proceso de esterilización de un objeto de Python, es decir, la conversión de un flujo de bytes en una jerarquía de objetos de Python. El reverso de este proceso se conoce como decapado.
print("codescracker".endswith("er"))
print(“programming”.center())
x = 1j
print(x**2 == -1)
j
no se ha inicializadoExplicació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 sentencia x**2 == -1
se evalúa como True
.
print(0xA + 0xB + 0xC)
Explicación: A, B y C son números enteros hexadecimales con valores 10, 11 y 12 respectivamente, por lo que la suma de A, B y C es 33.
for i in range(5):
print(i)
else:
print("Done!")
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áles de las siguientes opciones son los argumentos que faltan?
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 is empty
MISSING_ARG_2 = rval
MISSING_ARG_3 = wrapper
MISSING_ARG_1 is empty
MISSING_ARG_2 = rval
MISSING_ARG_3 = func
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]