Konzentration auf das Wesentliche?

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
Tholo
User
Beiträge: 177
Registriert: Sonntag 7. Januar 2018, 20:36

Hej,

Mir ist gerade folgendes aufgefallen.
Ich arbeite gerade an einem Projekt mit Docker, InfluxDB und Python. Die DB läuft bereits im Swarm von Docker und wird mittels einen start.sh Script gestart.
Jetzt bin ich seit ca. 3 Stunden dabei, das Startscript in Python zu schreiben. Mir ist gerade klar geworden das es eigentlich unnötig ist. Da ein Script zum Init und der Rest via Konsole Funktionsfähig ist.
Trotzdem bilde ich mich das ein haben zu wollen...
Das ist ja nicht wenig "Zeit" die man verdaddelt, wenn auch im eigentlichen Thema/Projekt.
Ich bin Anfänger und verrenne mich in Wünschen und Funktionalitäten. Ich seh eine Funktion und denke "Cool, haben will" und muss mich zu sehr einlesen. Was auch wieder Zeit kostet...

Meine Frage dazu!
Wie geht ihr damit um? Kann man das als allgemeinen Lernprozess verbuchen? Oder sollte ich mich auf die wirklichen Funktionen konzentrieren und später bei Bedarf ausbauen.

Ich ringe gerade mit diesen Gedanken...
Deswegen wollt ich das mal loswerden...

Am Beispiel hier. Die Sys.argv sind/waren erstmal überhaupt nicht wichtig..Trotzdem wollte und hab ich sie implementiert...

Code: Alles auswählen

import sys, getopt
import machine
import docker

MACHINES = machine.Machine(path="/usr/local/bin/docker-machine")


class Noder():
    def __init__(self, manager_anzahl, node_anzahl):
        """
        Init Nodes sowohl im Dev als auch Run Modus
        startet die Nodes
        Node Handling? Class via Nodenamen aufrufen?
        speicherung der Infos in der Class siehe List machine.ls()
        
        :param manager_anzahl: int
        :param node_anzahl: int
        """
        self.manager_anzahl = manager_anzahl
        self.node_anzahl =node_anzahl

    def node_info(self):
        MACHINES.ls()

def default_swarm_init():
    # Hier docker stack deploy -c docker-compose.yml
    print("Init swarm ohne machines")


def default_machine_init():
    """
    vielleicht in Class verpacken
    vererbeung für die Node
    """

    nodelist = MACHINES.ls()

    for node in nodelist:
        print(node["Name"])


def manager_anzahl(man_anzahl):
    # if machine ls == man_zahl pass ansonsten init X
    pass


def node_anzahl(node_anzahl):
    # if docker ls == node_anzahl pass ansonsten init X
    pass


def main(argv):
    opts = []
    args = [] # ggf. später verwenden
    try:
        opts, args = getopt.getopt(argv[1:], "hdm:n:", ["help", "manageranzahl=", "nodeanzahl="])
    except:
        print("start_dockering.py -d <devmode 0|1> -m <manageranzahl> -n <nodeanzahl>")

    for o, a in opts:
        if o == "--help" or o == "-h":
            print("HELP")
            print("start_dockering.py -d -m <manageranzahl> -n <nodeanzahl>")
        elif o == "--manageranzahl" or o == "-m":
            print(f"Starte mit {a} Managern")
            manager_anzahl(a)
        elif o == "-d":
            print("Starte im Dev Mode")
            default_machine_init()
        elif o == "--nodeanzahl" or o == "-n":
            print(f"Starte mit {a} Nodes")
            node_anzahl(a)

if __name__ == "__main__":
    main(sys.argv)
Benutzeravatar
__blackjack__
User
Beiträge: 13100
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Tholo: Also erstmal fällt das `getopt`-Modul auf. Das habe ich letzten Jahrtausend das letzte mal verwendet gesehen. Danach kam `optparse` und aktuell ist `argparse`. Ausserhalb der Standardbibliothek ist `click` IMHO einen Blick wert.

Von der API her ist es komisch das es nur Optionen gibt, die ja *optional* sind, das Programm aber *nichts* macht, also so wirklich gar nichts, wenn man keine Option angibt‽ Also scheint ja mindestens eine der Optionen gar nicht optional zu sein, sollte also ein Parameter sein.

Bei ``--help`` ist es unerwartet das das Programm auch trotzdem noch etwas anderes machen kann. Zudem ist die Ausgabe dafür doppelt im Code vorhanden. Ebenso wenn das parsen der Argumente fehl schlägt. `opts` und `args` sollten nicht mit leeren Listen vorbelegt werden müssen.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
Tholo
User
Beiträge: 177
Registriert: Sonntag 7. Januar 2018, 20:36

Ich wollte mit diesem Code eher nur beschreiben mit was für "Gedöhns" ich meine Zeit versemmelt habe. Ich wollt damit nicht zum nachahmen animieren sondern einfach meine Überlegungen verstärken.

Falls ich weiter Zeit daran investiere, werde ich deine Punkte mit einpflegen!
Ich hab einfach Google befragt und das hat funktioniert. Bei einer build in Funktion (von sys) Hinterfrage ich ja die Aktualität nicht. Zumindest bisher...

Allerdings bist du nicht auf meine Frage eingegangen. Der Standpunkt dazu würde mich doch interessieren
Benutzeravatar
__blackjack__
User
Beiträge: 13100
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@Tholo: Die Aktualität sollte man immer hinterfragen, gerade bei den Modulen die schon seit Ewigkeiten, oder gar von Anfang an dabei sind. Denn die sind in der Regel sehr Low-Level, oft nur eine ganz dünne Schicht über Funktionen aus der C-Standardbibliothek oder C-Funktionen die zum C-Standard gehören. Also eher „unpythonisch“ und mit der Zeit sind Module dazugekommen die darauf eine schönere API aufbauen.

`getopt` war die erste verfügbare Variante um `sys,argv`-Auswertung nicht komplett selbst schreiben zu müssen und die API ist der der C-Bibliothek `libgetopt` nachempfunden. In der Dokumentation zum `getopt`-Modul steht gleich am Anfang ein hervorgehobener Block der letztlich `argparse` empfiehlt. Das bietet mehr Möglichkeiten, man muss weniger Code für mehr Funktionalität schreiben, es es generiert automatisch eine Hilfe, und noch einiges mehr.

Die Frage kann man IMHO nicht wirklich beantworten, denn *Du* musst ja wissen was Du haben möchtest. Wenn Du ein Python-Programm zum starten haben möchtest, dann schreib es, wenn nicht, dann nicht. :-) Wenn es ein Shell-Skript gibt, was diese Aufgabe bereits erfüllt, dann stellt sich die Frage ob ein Python-Programm Sinn macht. Also zum Beispiel weil Python wenn es etwas komplizierter wird, leichter lesbar ist, oder weil man dann vielleicht eine Shell als Abhängigkeit loswerden kann, zum Beispiel wenn das auch unter Windows laufen können soll.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
Tholo
User
Beiträge: 177
Registriert: Sonntag 7. Januar 2018, 20:36

Ich hab mir das schon zu Herzen genommer ;)

Code: Alles auswählen

parser = argparse.ArgumentParser()
    parser.add_argument("-d", action="store_true", help="Startet im Devmode, mit Docker-Machine")
    parser.add_argument("-m", action="store", type=int, help="Anzahl der Manager", default=1)
    parser.add_argument("-n", action="store", type=int, help="Anzahl der Nodes", default=2)
    parser.add_argument_group()
    opts= parser.parse_args()

    if opts.d:
        default_machine_init()
    manager_anzahl(opts.m)
    node_anzahl(opts.n)

if __name__ == "__main__":
    main(sys.argv)
Ahh! Ich hab bisher noch nicht daran gedacht aber die Kompatibilität für Windows spricht natürlich dafür :)
Benutzeravatar
__blackjack__
User
Beiträge: 13100
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Ich würde da ja noch lange Optionen hinzufügen oder alternativ `dest`-Argumente, damit man in Python dann bessere Attributnamen als `d`, `n`, und `m` hat.

'store' ist die Default-`action`, das braucht man nicht extra angeben.
„All religions are the same: religion is basically guilt, with different holidays.” — Cathy Ladman
DasIch
User
Beiträge: 2718
Registriert: Montag 19. Mai 2008, 04:21
Wohnort: Berlin

Tholo hat geschrieben: Sonntag 9. September 2018, 11:10 Ich bin Anfänger und verrenne mich in Wünschen und Funktionalitäten. Ich seh eine Funktion und denke "Cool, haben will" und muss mich zu sehr einlesen. Was auch wieder Zeit kostet...

Meine Frage dazu!
Wie geht ihr damit um? Kann man das als allgemeinen Lernprozess verbuchen? Oder sollte ich mich auf die wirklichen Funktionen konzentrieren und später bei Bedarf ausbauen.
Ich glaub ich bin kein Anfänger mehr, hab dafür aber auch noch keine gute Antwort gefunden. Klar ist es gibt ein Spektrum. Wenn du dich nur auf „hauptsache fertig“ konzentrierst, lernst du nichts und es kommt auch häufig nur Mist bei rum, kann man ab- und zu auch hier im Forum sehr gut sehen. Auf der anderen Seite gibt es natürlich unendlich viel zu lernen und wenn du nicht akzeptierst bestimmte Dinge nicht zu wissen, kommst du vom Pfad ab und erreichst nie dein eigentliches Ziel.

Ich hab für mich festgestellt dass es mir in einem professionellen Umfeld oder bei der Mitarbeit an einem etablieren Open Source Projekt, wesentlich leichter Feld die richtige Balance zu finden. Außerdem hilft ein gewisser Sinn für Ästhetik, der einem sagt wenn Code schlecht ist auch wenn man vielleicht nicht artikulieren kann wieso und wie man es besser macht. Das motiviert nochmal im Nachhinein einen Blick drauf zu werfen.
Antworten