Plugin-basiertes Programm

[YAPD]

und hab mich echt gefreut, dass alles so funktioniert.

Benutze einen Autoformatter wie `black`, dann kannst du dich zusätzlich noch freuen, dass dein Code immer gleich (gut?) aussieht. Und wir freuen uns, dass wir ihn lesen können.

Und zum `dict.update`: Das wird leider in vielen Tutorials so gezeigt, und man kann als Anfänger natürlich nicht einschätzen, ob man da gerade guten Stil vermittelt bekommt. Schön wäre es mit `objects[module] = obj` (wobei man da potentiell auch noch die Namen verbessern könnte).

Hi Narpfel,

bin heute nachtaktiv

Danke für deine Antwort. Ich werd zukünftig den Autoformatter ( halb - gezwungenermaßen ) verwenden.
Aber noch wichtiger zum Dictionary :

Ich hatte es vorher genau so. Wenn ich anschließend das Dic abgefragt habe, war immer nur 1 Eintrag
des letzten Loads vorhanden. Nachdem ich es auf update umgestellt habe, hat er beide ins Dic gepackt.
Ich dachte also, dass ich mit x["Test"] = "Test" das Dic überschreibe, während die update Funktion den
neuen Wert hinzufügt. Aber da war ein anderer Fehler dahinter, den ich schon beseitigt habe Wäre auch
seltsam, ich kenne das auch genauso von Perl.

Beste Grüße
YAPD

[YAPD]

Jeder fängt mal mit etwas an, und sollte sich freuen, dazuzulernen.

Hab ja immer geschrieben, ich bin lernfähig

Offensichtlich kann ich bis 3 zählen.

OK, du hast Recht, bei den Subs hab ich irgendwie nur 3 gemacht, daher
verschiebt es sich über all um 1. Aber sonst sind es 4. Bei den defs,
ifs usw.

Das sind keine Objekte sondern alles lokale Variablen. Und bei lokalen Variablen
ist es klar, dass sie zu einer Methode gehören, die in der Klasse OM definiert ist.
Das OM_ sind also drei Buchstaben, die keinen Mehrwert bieten, sondern nur
das Lesen behindern.

Ich verstehe, was du meinst, letztendlich ist es aber Geschmackssache.

Du hast eine falsche Vorstellung davon, was Variablen in Python sind; das sind nur Referenzen
auf Objekte. Wenn man eine Referenz einer anderen Variable zuweist, werden keine Kopien erzeugt.
Strings sind unveränderlich, die können also gar nicht verändert werden.

Sorry, sei nicht böse, aber das verstehe ich nicht. Kannst du das ein bisschen erläutern. Ich weiß von
Perl, was Variablen sind und denke nicht, dass ich das falsch verstanden habe. Wenn ich einem String
x den Wert "Test" zuweise und danach den Wert "Neu" , ist der Wert, wenn ich ihn abfrage "Neu". Was
meinst du mit "Strings sind unveränderlich" ?

Beste Grüße
YAPD

[Sirius3]

Bei Perl hast Du doch das genau gleiche Verhalten:

Code: Alles auswählen

$x = "Test";
$y = $x;
$x = "Neu";
print $y;

$y zeigt weiterhin auf den String "Test". Dass $x danach auf einen neuen String "Neu" zeigt, ändert weder die Referenz auf $y noch den Inhalt des Objekts "Test".
Und auch wenn Du Strings verbindest, erzeugst Du damit nur ein neues Stringobjekt, und änderst das alte nicht:

Code: Alles auswählen

$x = "Test";
$y = $x;
$x .= "Neu";
print "$x / $y\n";

[kbr]

@Rango: hier noch eine Variante in mehr oder weniger lesbarer Form. Aufgegriffen habe ich die Idee eines direkten Unterverzeichnisses (hier "application_plugins"). Es werden nur Plugins geladen, die mit ".py" enden und nicht mit einem Unterstrich beginnen; so lassen sich Plugins im Verzeichnis auch wieder deaktivieren, ohne sie verschieben oder löschen zu müssen. Der Rückgabewert ist ein Mapping von URL auf ein callable:

Code: Alles auswählen

import importlib
import pathlib

def load_plugins(path="application_plugins"):
    path = pathlib.Path(path)
    return {
        imp.return_accepted_urls(): imp.scrape_url for imp in map(
            lambda entry: importlib.import_module(f"{path}.{entry}"), filter(
                lambda x: not x.startswith("_"), [entry.stem for entry in path.glob("*.py")]
            )
        )
    }

[__blackjack__]

Da ist `map()`, `filter()`, und eine List-Comprehension was man zusammenfassen und als Generatorausdruck schreiben kann:

Code: Alles auswählen

def load_plugins(path="application_plugins"):
    path = pathlib.Path(path)
    return {
        module.return_accepted_urls(): module.scrape_url
        for module in (
            importlib.import_module(f"{path}.{module_path.stem}")
            for module_path in path.glob("*.py")
            if not module_path.name.startswith("_")
        )
    }

[kbr]

Ja, im Grunde lässt sich auf map() und filter() durch LCs /GAs verzichten. Ist zumeist auch eleganter.