web-dev-qa-db-fra.com

Comment exécuter un fichier * .PY à partir d'un fichier * .IPYNB sur le bloc-notes Jupyter?

Je travaille sur un bloc-notes Python et j'aimerais le faire gros code d'entrée [entrée]compresser dans un fichier [* .PY] et appeler ce fichier à partir du cahier.

L’action d’exécuter un fichier [ .PY] à partir du portable est connue de moi et la commande varie entre Linux et Windows. Mais quand je fais cette action et que j'exécute le fichier [.PY] à partir du cahier, il ne reconnaît aucune bibliothèque ni variable existante chargée dans le cahier (c'est comme le [. PY] le fichier commence à zéro ...).

Est-ce qu'il y a un moyen de réparer ceci?

Un exemple simplifié possible du problème serait le suivant:

In[1]:
import numpy as np
import matplotlib.pyplot as plt

In[2]:
def f(x):
    return np.exp(-x ** 2)

In[3]:
x = np.linspace(-1, 3, 100)

In[4]:
%run script.py

Où "script.py" a le contenu suivant:

plt.plot(x, f(x))
plt.xlabel("Eje $x$",fontsize=16)
plt.ylabel("$f(x)$",fontsize=16)
plt.title("Funcion $f(x)$")
  • Dans le vrai problème, le fichier [* .PY] n'a pas 4 lignes de code, il en a assez plus.
pythonjupyter
38
JMSH

Dans la %run documentation magique vous pouvez trouver:

- i exécute le fichier dans l’espace de noms d’IPython au lieu d’un fichier vide. Ceci est utile si vous expérimentez avec du code écrit dans un éditeur de texte qui dépend de variables définies de manière interactive.

Par conséquent, fournir -i fait le tour:

%run -i 'script.py'

La manière "correcte" de le faire

Peut-être que la commande ci-dessus correspond à ce dont vous avez besoin, mais avec toute l'attention que cette question suscite, j'ai décidé d'ajouter quelques centimes supplémentaires à ceux qui ne savent pas à quoi ressemblerait une manière plus pythonique.
La solution ci-dessus est un peu compliquée et rend le code de l'autre fichier confus (d'où provient cette variable x? Et quelle est la fonction f?).

Je voudrais vous montrer comment le faire sans avoir à exécuter l'autre fichier encore et encore.
Transformez-le simplement en un module avec ses propres fonctions et classes, puis importez-le à partir de votre ordinateur portable ou de votre console Jupyter. Cela a également l’avantage de le rendre facilement réutilisable et jupyters contextassistant peut vous aider à compléter l’auto-complétion ou vous montrer la docstring si vous en avez écrit une.
Si vous modifiez constamment l'autre fichier, alors autoreload vient à votre aide.

Votre exemple ressemblerait à ceci:
script.py 

import matplotlib.pyplot as plt

def myplot(f, x):
    """
    :param f: function to plot
    :type f: callable
    :param x: values for x
    :type x: list or ndarray

    Plots the function f(x).
    """
    # yes, you can pass functions around as if
    # they were ordinary variables (they are)
    plt.plot(x, f(x))
    plt.xlabel("Eje $x$",fontsize=16)
    plt.ylabel("$f(x)$",fontsize=16)
    plt.title("Funcion $f(x)$")

Console Jupyter 

In [1]: import numpy as np

In [2]: %load_ext autoreload

In [3]: %autoreload 1

In [4]: %aimport script

In [5]: def f(x):
      :     return np.exp(-x ** 2)
      :
      :

In [6]: x = np.linspace(-1, 3, 100)

In [7]: script.myplot(f, x)

In [8]: ?script.myplot
Signature: script.myplot(f, x)
Docstring:
:param f: function to plot
:type f: callable
:param x: x values
:type x: list or ndarray
File:      [...]\script.py
Type:      function
58
swenzel

les lignes ci-dessous fonctionneraient aussi

!python script.py
11
braj

Peut-être pas très élégant, mais ça fait le travail:

exec(open("script.py").read())
8
cyprieng

! python 'script.py'

remplacez script.py par votre vrai nom de fichier, n'oubliez pas ''

5
shi95