Novice Python ici. J'essaie de transmettre un tuple de grands tableaux numpy à un script pour le traitement, j'ai donc besoin d'utiliser leurs noms de variable pour les transmettre depuis le terminal IPython.

La capacité que je recherche peut être simplifiée comme suit:

Supposons que script.py est un script qui affiche simplement la variable qui lui est transmise.

>>> var_name = (1,True)
>>> %run script.py var_name
(1,True)

Var_name ici est une variable qui est connue et créée par le terminal IPython. Pour l'instant, je n'ai réussi qu'à renvoyer "var_name" ou Namespace (data = ('var_name',)) dans les tentatives d'utilisation de sys.argv [1] ou argparse.

Dernière tentative:

import sys

data = tuple(sys.argv[1])

print data

Le résultat:

>>> t = (1, True, 3.5, "hi")
>>> t
(1, True, 3.5, "hi")
>>> %run script.py t
('t',)

Dans MATLAB, la tâche d'importation est simplement accomplie dans la première ligne:

function[] = scriptName(inputVar)
disp(inputVar)

L'appel du script depuis le terminal MATLAB ressemblerait à ceci:

>> scriptName(700)  
   700

InputVar peut être un entier, un double, une chaîne, une matrice, etc.

Existe-t-il une action équivalente en Python? Dois-je utiliser sys.argv [1] ou argparse de manière incorrecte? Je sais que c'est une question pour les débutants, mais au cours des 2 dernières heures de recherche et de lecture, je n'ai trouvé aucune solution.

Merci!

1
pythoff 16 juil. 2015 à 03:11

3 réponses

Meilleure réponse

Dans MATLAB, une fonction est définie par fichier (avec un nom correspondant) - du moins, c'était l'arrangement d'origine. Donc >> scriptName(700) charge le fichier et appelle la fonction avec l'argument que vous donnez.

En Python, un fichier contient un module, qui peut contenir de nombreuses fonctions (ainsi que des définitions de classe, des variables) et des actions. Un tel module peut être imported, ou il peut être exécuté comme un script. Lorsqu'il est exécuté (à partir du shell du système d'exploitation), le code protégé par if __name__=='__main__' est exécuté. Et sys.argv contient des arguments de ligne de commande - sous forme de liste de chaînes.

ipython peut importer des modules. Mais il a aussi cette commande magique %run. Fonctionnellement, c'est comme appeler le script à partir d'un shell, y compris en passant les chaînes sys.argv. La particularité de %run est que les résultats de l'exécution sont placés dans l'espace de travail principal d'ipython. C'est un peu comme la commande from xxx import *.

Donc, si vous avez écrit un fichier de script foo.py:

def foofn(anarg):
    print(repr(anarg))
if __name__=='__main__':
    import sys
    foofn(sys.argv)

Et l'a couru:

%run foo testing 1 2 3

Vous verriez les chaînes argv

['foo.py', 'testing', '1', '2', '3']

ipython permet également l'utilisation de {} dans les commandes magiques

%run foo {t}

Mais votre t s'étendrait à un ensemble de chaînes

'(1,', 'True,', '3.5,', 'hi)'

En effet, foo.py est responsable de l'analyse de ces chaînes (par exemple avec argparse).

Vous pouvez également appeler directement foofn:

foofn([1,2,3])

Dans ce cas, la fonction obtient une liste de nombres, pas les chaînes sys.argv.

En d'autres termes, la fonction définie dans foo.py est maintenant disponible pour utilisation. C'est proche de ce que vous pouvez faire dans MATLAB. Vous n'avez qu'à le charger avec le run.

Si au lieu de cela vous l'avez fait:

import foo

Vous devez spécifier l'espace de noms foo.

foo.foofn([1,2,3])

Dans ipython, faites

%run?

Pour voir son doc; et

%run??

Pour voir le doc et le code. Il se passe beaucoup de choses. Notez que

Il voit ainsi son environnement comme s'il était exécuté comme un programme autonome (sauf pour le partage d'objets globaux tels que des modules précédemment importés). Mais après l'exécution, l'espace de noms interactif IPython est mis à jour avec toutes les variables définies dans le programme .... Cela permet un chargement très pratique du code pour le travail interactif, tout en donnant à chaque programme une 'feuille blanche' à exécuter.


%run prend une option '-i', qui donne au script l'accès aux variables définies dans la session ipython. Donc, si le script contenait foo(t) et que t est défini dans ipython, cela serait utilisé. Je n'ai jamais eu l'occasion de l'utiliser.

0
hpaulj 16 juil. 2015 à 02:43
%run script.py json.dumps(var_name.tolist()) #im not sure if run can accept variables

Vous pouvez également essayer

% import subprocess
% subprocess.check_output('./script.py "%s"'%(json.dumps(var_name.tolist()))

script.py

import sys

data = json.loads(sys.argv[1])

print data
1
Joran Beasley 16 juil. 2015 à 00:23

IPython appelle le programme sur la ligne de commande. Il passe t, que vous pensez être un nom de variable, sous forme de chaîne. Le seul argument que votre script obtient est donc "t".

Si vous souhaitez passer des variables dans un script, vous devez importer le script, puis appeler la fonction. Voici donc votre script.py:

def main_function(argument1, argument2):
    # all the stuff you want to do in your script.

Maintenant, vous pouvez simplement importer le script et appeler cette fonction:

>>> import script
>>> script.main_function(variable1, variable2)
2
brenns10 16 juil. 2015 à 00:34