hi, ich würde gerne mit einem neuen Programm mein altes aufrufen und die darin erhaltene Funktion verwenden. Die Funktion hat vorher funktioniert um Vektoren und Matrizen mal -1 zu rechnen. Leider findet er meine Funktion nicht. Ich arbeite mit JupyterLab.
a=[1,2]
import meinmodule
b=meinmodule.meinefunk(a)
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-3-38f37ffeda2b> in <module>()
----> 1 b=meinmodule.meinefunk(a)
AttributeError: module 'meinmodule' has no attribute 'meinefunk'
meinmodule
def meinefunk(x):
B=x.copy()
if type(B[0]) == int:
for Vektor in range(len(B)) :
B[Vektor]=B[Vektor]*-1
elif type(B[0]) == list :
import numpy
y = numpy.array([])
y=B
B=numpy.dot(y,-1)
return B
Attribute error beim Module import
Biite benutze die Code-Tags im vollständigen Editor, so ist bei deiner Funktion meinefunk() nicht erkenntlich wie genau sie aufgebaut sein soll, insbesondere wo sie endet.
z.B. liegt die Zeile import numpy innerhalb der Funktion?
Des weiteren; Liegen dein Notebook und die Datei meinmodule.py im gleichen Verzeichnis?
Oder liegt deine Funktion innerhalb eines anderen Notebooks?
z.B. liegt die Zeile import numpy innerhalb der Funktion?
Des weiteren; Liegen dein Notebook und die Datei meinmodule.py im gleichen Verzeichnis?
Oder liegt deine Funktion innerhalb eines anderen Notebooks?
Ich bin Pazifist und greife niemanden an, auch nicht mit Worten.
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
oh my bad, ich bin neu auf der seite danke für den tipp hier ist der Code ich hoffe jetzt kann man es lesen
Code: Alles auswählen
a=[1,2]
import meinmodule
b=meinmodule.meinefunk(a)
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-3-38f37ffeda2b> in <module>()
----> 1 b=meinmodule.meinefunk(a)
AttributeError: module 'meinmodule' has no attribute 'meinefunk
Code: Alles auswählen
def meinefunk(x):
B=x.copy()
if type(B[0]) == int:
for Vektor in range(len(B)) :
B[Vektor]=B[Vektor]*-1
elif type(B[0]) == list :
import numpy
y = numpy.array([])
y=B
B=numpy.dot(y,-1)
return B
- __blackjack__
- User
- Beiträge: 13077
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@Compunerd: Hattest Du das Modul denn schon einmal importiert *bevor* Du die Funktion geschrieben hast? ``import`` lädt nur beim ersten mal die Datei und führt den Code auf Modulebene aus, bei folgenden Importen wird einfach nur das beim ersten mal erstellte Modulobjekt erneut an den Namen nach ``import`` gebunden.
Die Funktion ist ziemlich gruselig. Angefangen bei schlechten Namen, die sich teilweise nicht an die Konventionen halten. Siehe Style Guide for Python Code. Eingerückt wird mit vier Leerzeichen pro Ebene. Funktionsnamen beschreiben üblicherweise die Tätigkeit der Funktion.
Entscheidung aufgrund eines Datentyps sind nur sehr selten eine gute Idee weil sie „duck typing“ unterlaufen, und wenn dann nicht mit `type()` sondern mit `isinstance()` um wenigstens abgeleitete Typen erfassen zu können. Wobei ich diese Fallunterscheidung nicht nachvollziehen kann. Welchen Sinn hat die?
Die ``for``-Schleife ist in Python ein „anti-pattern“. Statt über Indices zu iterieren, die dann nur für den Zugriff auf eine Sequenz verwendet werden, kann man in Python *direkt* über die Elemente iterieren. Und statt eine Liste elementweise zu verändern, würde man in Python einfach eine neue aufbauen. Dann könntest Du Dir auch den `copy()`-Aufruf sparen. Mit „list comprehension“-Syntax wäre das dann auch schön kompakt.
Importe gehören an den Anfang von Modulen, damit man dort leicht die Abhängigkeiten des Moduls sehen kann, und einem die auch möglichst schnell auf die Füsse fallen wenn sie nicht erfüllt sind.
`y` ist überflüssig. Die erste Zuweisung an `y` ist sinnfrei weil der Wert danach nirgends verwendet wird. Und statt `B` in `y` umzubenennen, hätte man einfach `B` im `dot()`-Aufruf verwenden können.
Wenn die Elemente weder ganze Zahlen noch Listen sind, dann macht die Funktion einfach gar nichts, und gibt nur eine flache Kopie des Arguments zurück. Das erscheint mir komisch. Ich hätte da dann eher eine Ausnahme erwartet. `TypeError` zum Beispiel.
Unterm Strich erscheint mir das ziemlich viel Code für etwas das man auch so ausdrücken könnte:
Die Funktion ist ziemlich gruselig. Angefangen bei schlechten Namen, die sich teilweise nicht an die Konventionen halten. Siehe Style Guide for Python Code. Eingerückt wird mit vier Leerzeichen pro Ebene. Funktionsnamen beschreiben üblicherweise die Tätigkeit der Funktion.
Entscheidung aufgrund eines Datentyps sind nur sehr selten eine gute Idee weil sie „duck typing“ unterlaufen, und wenn dann nicht mit `type()` sondern mit `isinstance()` um wenigstens abgeleitete Typen erfassen zu können. Wobei ich diese Fallunterscheidung nicht nachvollziehen kann. Welchen Sinn hat die?
Die ``for``-Schleife ist in Python ein „anti-pattern“. Statt über Indices zu iterieren, die dann nur für den Zugriff auf eine Sequenz verwendet werden, kann man in Python *direkt* über die Elemente iterieren. Und statt eine Liste elementweise zu verändern, würde man in Python einfach eine neue aufbauen. Dann könntest Du Dir auch den `copy()`-Aufruf sparen. Mit „list comprehension“-Syntax wäre das dann auch schön kompakt.
Importe gehören an den Anfang von Modulen, damit man dort leicht die Abhängigkeiten des Moduls sehen kann, und einem die auch möglichst schnell auf die Füsse fallen wenn sie nicht erfüllt sind.
`y` ist überflüssig. Die erste Zuweisung an `y` ist sinnfrei weil der Wert danach nirgends verwendet wird. Und statt `B` in `y` umzubenennen, hätte man einfach `B` im `dot()`-Aufruf verwenden können.
Wenn die Elemente weder ganze Zahlen noch Listen sind, dann macht die Funktion einfach gar nichts, und gibt nur eine flache Kopie des Arguments zurück. Das erscheint mir komisch. Ich hätte da dann eher eine Ausnahme erwartet. `TypeError` zum Beispiel.
Unterm Strich erscheint mir das ziemlich viel Code für etwas das man auch so ausdrücken könnte:
Code: Alles auswählen
import numpy as np
def some_better_name(values):
return np.dot(values, -1)
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
Die Funktion `meinfunk` ist in einer Datei mit dem Namen `meinmodule.py` und das ist auch die Datei, die Du importierst?
Du hast die Datei gespeichert?
Du hast Deinen Pythoninterpreter vom Jupyter-Workbook danach neugestartet?
Zur Funktion: Warum schreibst Du eine eigene Funktion, wenn Du doch schon numpy benutzt?
Statt eine Liste zu kopieren um sie dann zu ändern erzeugt man in Python eine neue Liste.
Warum liefert die Funktion nur eine Kopie der Ursprungsliste zurück, wenn das erste Element weder eine Ganzzahl noch eine Liste ist?
oder kurz:
Variablen schreibt man nach Konvention klein, einbuchstabige Namen vermeiden. Statt type isinstance benutzen. Eingerückt wird mit 4 Leerzeichen pro Ebene, nicht 1 oder 3 oder 4.
Du hast die Datei gespeichert?
Du hast Deinen Pythoninterpreter vom Jupyter-Workbook danach neugestartet?
Zur Funktion: Warum schreibst Du eine eigene Funktion, wenn Du doch schon numpy benutzt?
Statt eine Liste zu kopieren um sie dann zu ändern erzeugt man in Python eine neue Liste.
Warum liefert die Funktion nur eine Kopie der Ursprungsliste zurück, wenn das erste Element weder eine Ganzzahl noch eine Liste ist?
Code: Alles auswählen
def multiply_vector(vector, scalar=-1):
if isinstance(B[0], int):
return [x * scalar for x in vector]
return [multiply_vector(v, scalar) for v in vector]
Code: Alles auswählen
neues_x = -numpy.asanyarray(x)