Python: une fonction retourne un tableau et une variable?

Est-il un moyen simple d'obtenir une fonction de retour d'une np.tableau et une variable?

par exemple:

my_array = np.zeros(3)
my_variable = 0.

def my_function():
    my_array = np.array([1.,2.,3.])
    my_variable = 99.
    return my_array,my_variable

my_function()

de sorte que les valeurs calculées dans la fonction peut être utilisée plus tard dans le code? Le ci-dessus ignore les valeurs calculées dans la fonction.

J'ai essayé de retourner un tuple {my_array, my_variable}, mais a obtenu la unhashable type de message pour les np.tableau

Les Tuples sont écrits entre parenthèses — () — pas croisillons — {}.
Si vous voulez retourner un tuple, il devrait être (my_array, my_variable). À l'aide d'accolades est de retour dict, ce qui nécessite l'élément à hashable, dans ce cas, list ne l'est pas.
Utilisation des accolades sans virgules construit une set, pas un dict.
Le code montré ci-dessus ne comporte pas d'erreurs, vous êtes tout simplement pas stocker le résultat de n'importe où.
oups, désolé

OriginalL'auteur dcnicholls | 2013-10-22

5

Ce n'est pas en ignorant les valeurs retournées, vous n'êtes pas en les assignant à des variables.
```
my_array, my_variable = my_function()
```
my_array, my_variable est un n-uplet. C'est la virgule qui font de tuples, pas parens. Les parenthèses ne sont nécessaires que dans certains endroits pour la désambiguïsation, comme l'intérieur d'un appel de fonction. (Ils sont presque toujours inoffensifs, et souvent faire des choses plus lisibles, même quand ils ne sont pas nécessaires—à peu près le seul endroit en Python, à l'extérieur du complexe expressions algébriques, où inutiles parens sont souvent la peine de taper de toute façon.)
Le "retour tuple' approche travaillé, et qui était nécessaire, que le tableau a été beaucoup plus grande que la taille=3 exemple. Merci, Andy

OriginalL'auteur Andy
12

Votre fonction est correcte. Lorsque vous écrivez return my_array,my_variable, votre fonction est en fait le retour d'un n-uplet (my_array, my_variable).

Vous pouvez d'abord affecter la valeur de retour de my_function() à une variable, qui serait de ce n-uplet je décris:
```
result = my_function()
```
Prochaine, car vous savez combien d'articles sont dans le tuple à l'avance, vous pouvez décompresser le tuple en deux valeurs distinctes:
```
result_array, result_variable = result
```
Ou vous pouvez le faire en une seule ligne:
```
result_array, result_variable = my_function()
```
Autres notes liés au retour de n-uplets, et de tuple déballage:

J'ai parfois de garder les deux étapes distinctes, si ma fonction peut renvoyer None dans un non-exceptionnel échec ou vide de cas:
```
result = my_function()
if result == None:
    print 'No results'
    return
a,b = result
# ...
```
Au lieu de déballage, vous pouvez également accéder à des éléments particuliers de la n-uplet, à l'aide de leur index:
```
result = my_function()
result_array = result[0]
result_variable = result[1]
```
Si, pour quelque raison que ce soit, vous avez une 1-élément d'un tuple:
```
return (my_variable,)
```
Vous pouvez le décompresser à la même (un peu maladroite) d'une virgule syntaxe:
```
my_variable, = my_function()
```
OriginalL'auteur Jonathon Reinhart
1

réponse facile
```
my_array, my_variable = my_function()
```
OriginalL'auteur Curry
0

Après la définition de la my_function, utilisez my_function = np.vectoriser(my_function).

Par exemple,
```
def jinc(x):
    if x == 0.0:
        return 1
    return 2*j1(x)/x

jinc = np.vectorize(jinc)
```
Cet exemple permet de x et les valeurs de retour sont un tableau numpy.

OriginalL'auteur Ciro Xue

Vous devez vous connecter pour publier un commentaire.