ipynb başka bir ipynb dosyasını içe aktar

Etkileşimli Python (ipython), özellikle bir şeyleri anında bir araya getirdiğiniz için şaşırtıcıdır ... ve bunu geri dönmenin kolay olacağı şekilde yapar.

Bununla birlikte, ilginç görünen şey, birden çok ipython not defterine (ipynb dosyaları) sahip olmanın kullanım durumudur. Görünüşe göre bir dizüstü bilgisayarın diğer dizüstü bilgisayarlarla bir ilişkisi OLMAMASI gerekiyor, bu da mantıklı, ancak diğer ipynb dosyalarını içe aktarmayı çok isterdim.

Gördüğüm tek çözüm, * .ipynb dosyalarımı * .py dosyalarına dönüştürmek ve bu dosyalar daha sonra not defterime aktarılabilir. Bir projedeki her şeyi tutan bir dosyaya sahip olmak biraz tuhaf, özellikle de gerçekten kodun yeniden kullanımı için baskı yapmak istiyorsam (bu python'un temel ilkelerinden biri değil mi?)

Bir şey mi kaçırıyorum? Bu, ipython not defterlerinin desteklenen bir kullanım durumu değil mi? Bir ipynb dosyasının başka bir not defterine bu aktarımı için kullanabileceğim başka bir çözüm var mı? İpynb'i kullanmaya devam etmeyi çok isterdim, ancak şu anda iş akışımı gerçekten bozuyor :(

Yeni Jupyter'de gerçekten çok basit:

%run MyOtherNotebook.ipynb

Almak isterseniz A.ipynbde B.ipynbyazma

import import_ipynb
import A

içinde B.ipynb.

Oluşturduğum import_ipynbmodül pip aracılığıyla yüklendi:

pip install import_ipynb

Bu sadece bir dosya ve kesinlikle Jupyter sitesindeki resmi nasıl yapılır.

PS Ayrıca from A import foo, from A import *vb. Gibi şeyleri de destekler.

Çalıştırmak

!pip install ipynb

ve sonra diğer not defterini

from ipynb.fs.full.<notebook_name> import *

veya

from ipynb.fs.full.<notebook_name> import <function_name>

Tüm not defterlerinin aynı dizinde olduğundan emin olun.

Düzenleme 1: Resmi belgeleri burada görebilirsiniz - https://ipynb.readthedocs.io/en/stable/

Ayrıca, bir not defterinden yalnızca sınıf ve işlev tanımlarını içe aktarmak istiyorsanız (üst düzey ifadelerden değil), ipynb.fs.defsbunun yerine kullanabilirsiniz ipynb.fs.full. Tam büyük harfli değişken ataması da değerlendirilecektir.

İpynb'i komut isteminizden yükleyin

pip install import-ipynb

Not defterinize aktarın

import import_ipynb

Şimdi dosyanızı içe aktarmak için normal içe aktarma komutunu kullanın

import MyOtherNotebook

import nbimporterO zaman kullanabilirsinimport notebookName

Yukarıda belirtilen yorumlar çok kullanışlıdır ancak uygulanması biraz zordur. Aşağıda deneyebileceğiniz adımlar, ben de denedim ve işe yaradı:

1. Bu dosyayı not defterinizden PY dosya biçiminde indirin (Bu seçeneği Dosya sekmesinde bulabilirsiniz).
2. Şimdi indirilen dosyayı Jupyter Notebook'un çalışma dizinine kopyalayın
3. Artık kullanmaya hazırsınız. .PY Dosyasını ipynb dosyasına aktarın

Sorun, not defterlerinin düz bir python dosyası olmamasıdır. .ipynbDosyayı içe aktarma adımları aşağıda özetlenmiştir: Not defterini içe aktarma

Kodu yapıştırıyorum, bu yüzden ihtiyacınız olursa ... hızlıca kopyalayıp yapıştırabilirsiniz. Dikkat edin, sonunda ifadem var import primes. Elbette bunu değiştirmeniz gerekecek. Dosyamın adı primes.ipynb. Bu noktadan itibaren o dosyanın içindeki içeriği düzenli olarak yaptığınız gibi kullanabilirsiniz.

Keşke daha basit bir yöntem olsaydı, ama bu doğrudan belgelerden.
Not: ipython değil jupyter kullanıyorum.

import io, os, sys, types
from IPython import get_ipython
from nbformat import current
from IPython.core.interactiveshell import InteractiveShell


def find_notebook(fullname, path=None):
    """find a notebook, given its fully qualified name and an optional path

    This turns "foo.bar" into "foo/bar.ipynb"
    and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
    does not exist.
    """
    name = fullname.rsplit('.', 1)[-1]
    if not path:
        path = ['']
    for d in path:
        nb_path = os.path.join(d, name + ".ipynb")
        if os.path.isfile(nb_path):
            return nb_path
        # let import Notebook_Name find "Notebook Name.ipynb"
        nb_path = nb_path.replace("_", " ")
        if os.path.isfile(nb_path):
            return nb_path


class NotebookLoader(object):
    """Module Loader for Jupyter Notebooks"""
    def __init__(self, path=None):
        self.shell = InteractiveShell.instance()
        self.path = path

    def load_module(self, fullname):
        """import a notebook as a module"""
        path = find_notebook(fullname, self.path)

        print ("importing Jupyter notebook from %s" % path)

        # load the notebook object
        with io.open(path, 'r', encoding='utf-8') as f:
            nb = current.read(f, 'json')


        # create the module and add it to sys.modules
        # if name in sys.modules:
        #    return sys.modules[name]
        mod = types.ModuleType(fullname)
        mod.__file__ = path
        mod.__loader__ = self
        mod.__dict__['get_ipython'] = get_ipython
        sys.modules[fullname] = mod

        # extra work to ensure that magics that would affect the user_ns
        # actually affect the notebook module's ns
        save_user_ns = self.shell.user_ns
        self.shell.user_ns = mod.__dict__

        try:
        for cell in nb.worksheets[0].cells:
            if cell.cell_type == 'code' and cell.language == 'python':
                # transform the input to executable Python
                code = self.shell.input_transformer_manager.transform_cell(cell.input)
                # run the code in themodule
                exec(code, mod.__dict__)
        finally:
            self.shell.user_ns = save_user_ns
        return mod


class NotebookFinder(object):
    """Module finder that locates Jupyter Notebooks"""
    def __init__(self):
        self.loaders = {}

    def find_module(self, fullname, path=None):
        nb_path = find_notebook(fullname, path)
        if not nb_path:
            return

        key = path
        if path:
            # lists aren't hashable
            key = os.path.sep.join(path)

        if key not in self.loaders:
            self.loaders[key] = NotebookLoader(path)
        return self.loaders[key]

sys.meta_path.append(NotebookFinder())

import primes

Jupyter'i mevcut veya yeni Python .py modülleri ile kullanmak hiç sorun değil. Jupyter çalışırken, modül sınıfı tanımlarınızı bir .py dosyasında oluşturmak / değiştirmek için Spyder'ı (veya seçtiğiniz herhangi bir düzenleyiciyi) çalıştırın ve ardından gerektiği gibi modülleri Jupyter'e içe aktarın.

Bunu gerçekten kusursuz kılan bir şey, otomatik yeniden yükleme sihirli uzantısını kullanmaktır. Otomatik yeniden yükleme ile ilgili belgeleri burada görebilirsiniz:

http://ipython.readthedocs.io/en/stable/config/extensions/autoreload.html

Modül her değiştirildiğinde otomatik olarak yeniden yüklenecek kod:

# autoreload sets up auto reloading of modified .py modules
import autoreload
%load_ext autoreload
%autoreload 2

.İpynb dosyalarını modül olarak yüklemeyi simüle etmek için önceki yanıtta bahsedilen kodu denediğimi ve çalıştırdığımı, ancak .ipynb dosyasında değişiklik yaptığınızda boğulduğunu unutmayın. .İpynb 'modülünü' yeniden yüklemek için Jupyter geliştirme ortamını yeniden başlatmanız gerekiyor gibi görünüyor, ki bu benim kodumda birçok değişiklik yaptığım için kabul edilemezdi.

Lütfen bir de __init__.py diğer tüm .ipynb dosyalarınızın bulunduğu pakette dosya .

Bu nbviewer bağlantıya ek olarak minrkve syiyukarıda sağlanmıştır.

Ben de benzer bir sorun yaşadım ve sonra çözümün yanı sıra çalışan bir örneği olan genel google sürücü klasörüme bir bağlantı yazdım :)

Adım adım deneme ve Çözüm ile Stackoverflow gönderim:

Jupyter Notebook: .ipynb dosyasını içe aktarın ve diğer .ipynb dosyasındaki yöntemine erişin hata verir

Umarım bu başkalarına da yardımcı olur. Hepinize teşekkürler!

% run YourNotebookfile.ipynb iyi çalışıyor;

belirli bir modülü içe aktarmak istiyorsanız, ipynb'den sonra içe aktarma komutunu ekleyin, yani def Add () içeren YourNotebookfile.ipynb

o zaman onu kullanabilirsin

%run YourNotebookfile.ipynb import Add