Wie kann ich in Jupyter Notebook ein Modul in einer Zelle darstellen und ein ...

[Brando]

In Jupyter Notebook haben die aufgerufenen Programme keine main Methode. Sie werden von einer initialen Methode heraus gestartet. Das meine ich mit initial. Das Interface, welches so angesprochen wird greift dann theoretisch auf die Modulinhalte zu, die in einer jupyter cell niedergelegt werden. Der Aufruf dieser Methoden vom Interface aus ist aber nicht zu bewerkstelligen, weil der Zellinhalt nicht als relevant für das Interface erkannt wird.

[Brando]

Selbst der Code funktioniert nicht:

Code: Alles auswählen

from sympy.matrices import *
from builtins import str
from ipywidgets import widgets
from IPython.display import display, HTML, Math, Latex, clear_output
from random import randint
import sys
from sympy.matrices import *
from sympy.printing import *
from IPython.display import display, HTML, Math, Latex, clear_output
from ipywidgets import widgets
from random import randint
from sympy import *
from builtins import str
from copy import deepcopy
import numpy as np
import importlib
import matrix_mult_module as mmm
import sys
import sympy as sp




sys.path.insert(0,"/home/Brando/.ipython/profile_default/startup")
x=[]
tb_container=[]
def init_vector(matrix,m_2):
  global x
  x=[]
  a_matrix=zeros(matrix.shape[0], matrix.shape[1])
  b_matrix=zeros(matrix.shape[0], matrix.shape[1])
  for i in range(matrix.shape[0]):
    for j in range(matrix.shape[1]):
      a_matrix[i,j]=randint(-10,10)
      b_matrix[i,j]=randint(-10,10)
  x.append(a_matrix)
  x.append(b_matrix)
  a=[]
  for i in range(m_2):
             b=latex(x[i])
             b=b.replace("left[", "left(")
             b=b.replace("right]", "right)")
             a.append(b)
        
  str1="$\langle" 
  for i in range(m_2):
               if i==m_2-1:
                   str1=str1+a[i]
               else:
                   str1=str1+a[i]+", " 
  str1 += "\\rangle$"
  return str1

def init_containers(efeld):
  global tb_container
  tb_container = []
  c=[] 
  
  for j in range(efeld.shape[1]):
       for i in range(efeld.shape[0]):
               c.append(widgets.Text(Description="Thema", width=140))
       tb_container.append(widgets.HBox(children = [u for u in c]))
       c=[]
       
       
  
                
  return tb_container


def evaluate(Ergebnis): 
  global tb_container
  gefunden=True
  fehlerbericht=""
  Lösung=zeros(Ergebnis.shape[0], Ergebnis.shape[1])
  
  for i in range(Ergebnis.shape[0]):
    for j in range(Ergebnis.shape[1]):
      Lösung[i,j]=tb_container[i].children[j].value
      
  for i in range(Lösung.shape[0]):
    for j in range(Lösung.shape[1]):
      if str(Ergebnis[i,j]).strip() != str(Lösung[i,j]).strip():
        gefunden=False
        fehlerbericht+=" Fehler in Zelle "+ str(i)+" " +str(j) + " wahrer Wert ist " + str(Ergebnis[i,j]) + "\n"
    
  if gefunden==True:
    fehlerbericht=" Richtige Lösung "
  return gefunden, fehlerbericht


def rechne():
   z=x[0]*x[1]
  
   return evaluate(z)

def initialisiere(): 
    i_progr=importlib.import_module("la_scalar_8") 
    i_progr.exec_render(Matrix([[0,0],[0,0]]),"Matrixmultiplikation:", Matrix([[0,0],[0,0]]),2)
    
initialisiere()

[Sirius3]

@Brando: wenn la_scalar_8 ein Modul ist, das Du einfach importieren kannst, dann mach das doch mit "import" und mach nicht solche Verrenkungen.
Dass inzwischen alle Importe doppelt sind, macht die Sache nicht besser. Ein "funktioniert nicht" ist bei der Fehlersuche nicht sehr hilfreich. Bisher ist glaube ich noch niemandem hier klar, was eigentlich Dein Problem ist.

[Brando]

Ein einfaches import löst das Problem auch nicht. Es wird nicht erkannt, was ich an Methoden in die Zelle geschrieben habe. Die Fehlermeldung lautet:
NameError: name 'init_vector' is not defined.

Also genau die Methode, die ich in der Zelle verwende wird nicht erkannt.

[BlackJack]

@Brando: Also mir ist immer noch nicht ganz klar wie das funktionieren soll. Diese Meldung kommt vom importieren des Moduls? Dann fehlt dem diese Funktion, oder aber es läuft Code mit Nebeneffekten beim importieren, was nicht sein sollte, denn dann kann man das Modul nicht sinnvoll als Modul verwenden.

@Sirius3: Also das eigentliche Problem ist mir schon klar, und das sitzt IMHO eindeutig vor dem Rechner.

[Brando]

Der letzte Code, den ich gesandt habe versucht das Modul in die Jupyter Zelle zu schreiben, wobei dieses Modul eine Anweisung enthält das Interface zu laden und auszuführen. Dieses Interface möchte aber seinerseits die Funktionen des Moduls nutzen - dieses steht wie gesagt in der Jupyter Notebook Zelle mit bspw. der Funktion init_vector, welche als erstes ausgeführt werden soll. Es muss doch möglich sein dem interface mitzuteilen, dass in der Zelle in der auch der Import des Interfaces stattfindet der Code steht, den das Interface benötigt, um ausgeführt werden zu können.

Eine andere Möglichkeit, mit der ich begonnen hatte war: Der Code des Moduls wird in eine Jupyter Notebook Zelle geschrieben; es endet mit der Anweisung exec_render() und ruft das Interface auf. Jetzt wäre es optimal, wenn das aufgerufene Interface auch die Zelle kennen könnte, von der es aus aufgerufen wurde und die Methoden dort adressieren. Wie man das macht weiß ich nicht. Habe wie gesagt schon alles ausprobiert.

[BlackJack]

@Brando: Und wenn Du tausendmal was von Modulen in Zellen schreibst: Der Zellinhalt ist kein Modul! Jegliche Versuche den krampfhaft als solches sehen zu wollen ist Realitätsverweigerung und führt zu nichts sinnvollem.

Alleine schon der Gedanke das ein Modul beim importieren etwas mit dem Modul machen soll von dem es importiert wird, ist irgendwie ziemlich krank. Zumal das auch eine einmalige Sache wäre, denn der Code auf  Modulebene wird nur einmal, beim ersten Import ausgeführt. Jeder weitere Import liefert nur das bereits importierte Modul.

Du nennst übrigens Funktionen Methoden, was ein wenig verwirrend ist. Wäre besser wenn man den Begriff tatsächlichen Methoden vorbehalten würde.

Wie gesagt, lerne mit Funktionen umzugehen, also ``global`` sein zu lassen. Dann wirst Du auch nicht mehr so komische Sachen machen wollen, sondern die `exec_render()`-Funktion so schreiben, dass sie alles was sie an variablen Werten benötigt, als Argument(e) übergeben bekommt. Ich glaube das hatte Sirius3 ein paar Beiträge weiter vorne bereits erwähnt.

[Brando]

Aber wie löse ich dann mein Problem??:
1) Ein Modul darf nicht im Dateisystem gespeichert werden, es geht allenfalls als Zellinhalt durch (und ist dann kein Modul mehr nach vorheriger Auskunft)
2) Ein Interface, welches im Dateisystem hinterlegt wird, stellt die Funktionen des Modules dar.
3) Wie teile ich dem Interface den Modulinhalt mit?

[BlackJack]

@Brando: Ad 3) Gar nicht. Du änderst den Code dort so, das es kein Modul importiert, sondern die nötigen Werte bei der entsprechenden Funktion als Argument(e) übergeben bekommt. Sonst müsstest Du wie gesagt unschöne Hacks mit dem Import-Mechanismus anstellen. Da würde ich aber mal behaupten das Du nicht genug von der Materie verstehst, und helfen werde *ich* zumindest nicht bei so etwas. Wenn jemand mit einem Schrotgewehr hantiert, dann sagt man ihm er soll's weg legen und zeigt nicht wie man sich möglichst dicht am Fuss vorbei schiesst.