Si te encuentras con alguna parte que no entiendes puedes comentarlo y haremos todo lo necesario de ayudarte tan rápido como podamos.
Solución:
Por conveniencia, Python construye una tupla temporal según sea necesario para una instrucción de asignación. Por lo tanto, las tres declaraciones de asignación son exactamente iguales una vez que alcanzan el movimiento de datos.
Una llamada de función no es una instrucción de asignación; es un mapeo de referencia. Por lo tanto, la semántica es diferente.
Si quiere que Python descomprima su tupla en dos argumentos separados, use el * operador:
f(*(2, 3))
Una tupla se comporta como una lista inmutable. El hecho de que los anote con paréntesis quizás sea confuso, pero es más o menos una coincidencia, como resultado del hecho de que los paréntesis se usan para agrupar cosas y, de lo contrario, reducir la ambigüedad.
Cuando llamas a una función, no estás proporcionando una tupla. Estás proporcionando argumentos. una tupla puede ser un argumento, pero solo uno: es solo una variable de tipo tuple.
lo que puedes hacer es expandir una tupla (o una lista) en una serie de argumentos con esta notación:
tup = (2, 3)
f(*tup)
# expand the tuple (2,3) into a series of arguments 2, 3
También puede hacerlo con diccionarios, excepto con ** en vez de *:
my_dict = "arg1": 1, "arg2": 2
f(arg1=my_dict["arg1"], arg2=my_dict["arg2"])
f(**my_dict) # these are equivalent
Por otro lado, las funciones pueden tomar números arbitrarios de argumentos (similar a como lo hacen otros lenguajes para printf() llamadas). Por ejemplo:
def g(*args):
print("I got this many arguments:", len(args))
Aquí, si lo haces type(args)usted obtiene tupley si lo haces type(*args), obtienes un error. Esto se debe a que, en los encabezados de función, el * hace exactamente lo contrario: empaqueta los argumentos que se le dieron a la función en una sola tupla, para que pueda trabajar con ellos. Considera lo siguiente:
g(2, 3) # 2 arguments, both integers
g((2, 3)) # 1 argument, a tuple
g(*(2, 3)) # 2 arguments, both integers
En breve,
- Las funciones están construidas de tal manera que toman un número arbitrario de argumentos.
- los
*y**los operadores son capaces de deshacer tuplas/listas/dictados en argumentos en un extremo, y paquete ellos en el otro extremo - las tuplas/listas/dicts individuales son, por lo demás, solo variables individuales.
La cuestión es que los paréntesis se usan para varias cosas diferentes en Python: para llamar a funciones, para hacer tuplas (no es sólo las comas que importan, mira la tupla vacía ()), para cambiar la prioridad de evaluación en las expresiones.
En los casos en que su interpretación sea ambigua (por ejemplo, su ejemplo f(2, 3) podría ser una llamada de función con dos argumentos, o una llamada de función con un argumento que es una tupla), el idioma tiene que hacer una elección.
Si el analizador de Python se implementara de modo que analizara esto como una tupla, sería imposible tener funciones con más de un argumento. Si el analizador de Python se implementó de modo que analizó esto como dos argumentos, es imposible pasar una tupla literal sin los paréntesis.
Claramente, la primera es una limitación mucho mayor, por lo que se optó por la segunda.
Otro ejemplo es con tuplas con una elemento — es (1+2) una expresión que da el número 3, o una tupla con un elemento, 3? Aquí, si fuera el segundo, entonces sería imposible usar paréntesis para expresar prioridad en una expresión ((3+4)*5 contra 3+(4*5)). Entonces se decidió requerir la coma después del primer elemento para tuplas de 1 elemento ((3,)).
Te mostramos comentarios y puntuaciones
Agradecemos que desees reafirmar nuestro ensayo poniendo un comentario o valorándolo te damos la bienvenida.