Python almacena la variable en función y la usa más tarde.

es posible almacenar una variable de un bucle while a una función y luego llamar a esa misma variable desde la función al final del bucle

por ejemplo: durante while loop, el problema aquí es que cuando bash recuperar la variable de store (), falla … ya que necesita que se pasen los argumentos …

def store(a,b,c): x1 = a y1 = b z1 = c return (x1,y1,z1) def main(): while condition: x = ....... y = ....... z = ....... ...... ...... store(x,y,z) #store to function... ...... ...... ...... s1,s2,s3 = store() ...... ...... ...... 

Hmmm, a menos que sea un malentendido, esta es una no-solución clásica a un no-problema.

¿Por qué no usar el lenguaje tal como es?

 while condition: x = something y = else z = altogether ... save_state = (x,y,z) ## this is just a python tuple. ... # do something else to x, y and z, I assume ... x, y, z = save_state 

Dependiendo del tipo de x , y , z es posible que tenga que tener cuidado de almacenar una copy en la tupla.

(Además, tu sangría está mal, y no hay tal cosa como end en python).

Actualización: Ok, si entiendo mejor, la pregunta es simplemente poder usar el valor anterior la próxima vez. En el caso más simple, no hay ningún problema: la próxima vez que pase por un bucle, el valor de x , y , z son lo que fueron al final del tiempo anterior a través del bucle (esta es la forma en que toda la progtwigción los idiomas funcionan).

Pero si quieres ser explícito, intenta algo como esto:

  x_prev = some_starting_value x = some_starting_value while condition: x = something_funky(x_prev) .... other stuff .... x_prev = x 

(pero, nuevamente, tenga en cuenta que no necesita x_prev en absoluto aquí: x=something_funky(x) x_prev x=something_funky(x) funcionará).

Como han dicho otros, probablemente haya una opción más adecuada que esta, pero podría ser conveniente en algunas situaciones (quizás en un REPL). Aquí hay una función simple que hace lo que quiere con cualquier número de valores.

 def store(*values): store.values = values or store.values return store.values store.values = () 

Ejemplo

 >>> store(1, 2, 3) >>> a, b, c = store() >>> print a, b, c 1 2 3 >>> store(4, 5) >>> a, b = store() >>> print a, b 4 5 

Hablando técnicamente, si tuvieras un profundo y ardiente deseo de hacer esto con funciones, siempre puedes hacerlo con un cierre (que es, como todos sabemos, el objeto de un hombre pobre):

 def store(a,b,c): def closure(): return (a,b,c) return closure stored = store(1,2,3) print stored() 

impresiones en (1,2,3)

No, no puedes hacer esto.

Además, es una idea terrible, terrible. “Almacenar en una función” es algo tan horrible e incorrecto que no estoy seguro de proporcionar código de trabajo.

Usa un objeto llamable.

 class Store( object ): def __init__( self ): self.x, self.y, self.z = None, None, None def __call__( self, x=None, y=None, z=None ): if x is None and y is None and z is None: return self.x, self.y, self.z else: self.x, self.y, self.z = x, y, z 

Lo mejor es hacer algo más simple que no implique una función con propiedades mágicas que haga dos cosas diferentes cuando se llama con y sin argumentos.

Cualquier cosa es mejor que “almacenar en una función”. Cualquier cosa.

De Verdad.

Cualquier cosa.

Por mucho que sea una mala idea, me gusta aplicar soluciones extrañas, así que aquí

 class Store(object): def __init__(self, f): self.f = f self.store = None def __call__(self, *args): self.store = self.f(*args) @Store def test(a,b,c): return a+b+c print test(1,2,3) print test.store 

Decore la función con Almacenar y luego llame a function.store para obtener lo que llamó, si la función nunca se llama, devuelve un solo Ninguno, puede hacer que genere una excepción, pero personalmente no quise hacerlo.