Fragen zu Listen und arbeiten mit Modulen

[RaPi_Fan]

Hallo Forum,
um mein Programm übersichtlich zu halten, möchte ich gerne mit Modulen arbeiten.
Das Hauptprogramm ist noch sehr überschaubar:

Code: Alles auswählen

import modul_a

def main():
   
    modul_a.hintergrund_erstellen()
    
    modul_a.interface_erstellen()

    modul_a.interface_erstellen_2()
 
 
if __name__ == "__main__":
    main()

Und hier das Modul:

Code: Alles auswählen

import gpiozero
from gpiozero import MCP3008
import tkinter as tk
root = tk.Tk()

gui_höhe = 10  #Anzahl Zeilen
gui_breite =6  #Anzahl Spalten
zell_höhe=3
zell_breite = 10
zell_text="°"

def hintergrund_erstellen():
    
    kacheln = []
    for loop in range(gui_höhe):
        for loop2 in range(gui_breite):
            label = tk.Label(root,text=zell_text, bg="grey", width=zell_breite, height=zell_höhe)
            label.grid(row=loop, column=loop2)
            kacheln.append(label)
                  

def interface_erstellen():
    
    poti_=[0,1,2,3,4,5,6,7,8,9]
    for loop in range(1,9):        
        poti_[loop]=MCP3008(loop-1)        
        print("poti_" + str(loop) + " = ""%3.0f"%(poti_[loop].value *100))    


def interface_erstellen_2():
        
    poti_=[0,1,2,3,4,5,6,7]
    for loop in range(0,7):        
        poti_[loop+1]=MCP3008(loop)        
        print("poti_" + str(loop+1) + " = ""%3.0f"%(poti_[loop].value *100))  

Hierzu meine Fragen:
"hintergrund_erstellen" funktioniert wie gewünscht. bei "kacheln" brauche ich keine Angaben zur Listengröße oder Inhalt machen. Warum muß ich das bei "poti_" in den "interface_erstellen" machen? (ohne geht es nicht)

"interface_erstellen" bringt das Resultat, was ich erreichen wollte. Ich habe 8 Potentiometer, die von 1 bis 8 nummeriert sind, daher möchte ich in der Software nicht ab 0 zählen.
Meine Frage hierzu: Warum geht "interface_erstellen_2" nicht? Hier kommt die Fehlermeldung:

print("poti_" + str(loop+1) + " = ""%3.0f"%(poti_[loop].value *100))
AttributeError: 'int' object has no attribute 'value'

Für mich sieht der Bereich 0-7 richtiger aus als bei "interface_erstellen".

Und die alles entscheidende Frage: Wie bekomme ich die Werte in das Hauptprogramm? Schließlich soll da mit den Werten gerechnet werden.

Vielen Dank für eure Beiträge,
RaPi_Fan

[rogerb]

@RaPi_Fan, es ist leider etwas unklar was du vor hast. Du importierst Tkinter und legst auch Label an, die aber nie verwendet werden, da das GUI ja gar nicht gestartet wird.

Du hast ein falsches Verständnis von Listen und Schleifen in Python, scheint es mir.
Du erstellest Listen mit Zahlenwerten. Die Zahlenwerte werden dann mit MCP3008 Objekten überschrieben. Das geht zwar, macht aber nicht viel Sinn.
Und in der zweiten Funktion führt das auch zum Fehler, denn dort überschreibst du die Liste mit MCP3008 Objekten ab der Stelle 1. Die Stelle 0 enthält immer noch den Integer-Wert 0.
Darauf versuchst du dann .value anzuwenden. Das geht nicht, weil ein Integer kein Attribut "value" hat. Und daher die Fehlermeldung.

Du möchtest also mehrere Potis erstellen. Dazu bieten sich in Python Listen und Dictionaries an.
Eine Liste ist einfach ein Behälter für Objekte. Das erste Element hat immer den Index 0, das zweite den Index 1 usw.
Der Ansatz würde dann so aussehen:

Code: Alles auswählen

# erstellen der Liste: für die Zahlen (num) von 0 bis 7 erstelle ein MCP3008 Objekt, wobei jeweils das channel Attribut mit dem Wert von "num" plus 1 belegt wird.
potis = [MCP3008(num + 1) for num in range(8)]

# ausgabe der Werte
# für jedes poti in der Liste potis tue folgendes:
for poti in potis:
    # poti.channel ist die Channelnummer des jeweiligen Potis, poti.value ist der Wert des jeweiligen Potis
    print(f"poti_{poti.channel} = {poti.value *100}")

Das vorgestellete "f" for der Zeichenkette erlaubt es Variablen-Werte eingebettet in {} - Klammern direkt in die Ausgabe einzufügen.

Ich hoffe das macht Sinn.

Bzgl. Import ins Hauptprogramm:
In modul_a (hoffentlich fällt dir ein besserer Name ein) hast du diese Funktion:

Code: Alles auswählen

def setup_potis():
    # erstelle 8 potis für die Kanäle 1 - 8
    # und gebe sie über return zurück
    return [MCP3008(num + 1) for num in range(8)]

Ich hoffe dir ist klar wie man Rückgabewerte von Funktionen nutzt.

im Hauptprogramm hast du dann:

Code: Alles auswählen

from modul_a import setup_potis


def main():
    potis = setup_potis()

    # ausgabe der Werte
    for poti in potis:
        print(f"poti_{poti.channel} = {poti.value *100}")


if __name__ == "__main__":
    main()

Offen ist natürlich noch wie das mit Tkinter zusammen passen soll...

[RaPi_Fan]

@ rogerb:

@RaPi_Fan, es ist leider etwas unklar was du vor hast. Du importierst Tkinter und legst auch Label an, die aber nie verwendet werden, da das GUI ja gar nicht gestartet wird.

Du hast wahrscheinlich den ersten Teil meines Posts übersehen

Du hast ein falsches Verständnis von Listen und Schleifen in Python, scheint es mir.

In anderen Sprachen komme ich mit Listen (arrays) und Schleifen (loops) gut zu recht. In Python bin ich damit zu 100% überfordert.
Ich habe die Listen mit Zahlenwerten erstellt, weil es ohne nicht ging. Darauf bezog sich auch meine erste Frage. Vielleicht hast du eine Erklärung dafür.

Leider funktioniert dein Code nicht, ich bekomme diesen Fehler:

Code: Alles auswählen

    print(f"poti_{poti.channel} = {poti.value *100}")
                                                   ^
SyntaxError: invalid syntax

Meine Versuche die Syntax zu korrigieren sind alle gescheitert.

Ich hoffe dir ist klar wie man Rückgabewerte von Funktionen nutzt.

Das sehen wir dann, wenn es keine Fehlermeldung mehr gibt. Ich gebe zu, dass ich mich mit Python unwahrscheinlich schwer tue, obwohl ich recht verständliche Tutorials gefunden habe.

Vielen Dank für deine Mühe,
RaPi_Fan

[__blackjack__]

@RaPi_Fan: Listen sind keine Arrays. Eine wichtige Operation von Listen die es auf Arrays nicht gibt ist `append()`. Bei Arrays legt man die Grösse fest und weist dann an Indizes Werte zu, Listen erstellt man leer, mit der Länge 0 und hängt dann Werte daran an. Das geht ganz ohne irgendwelche unnötigen Zahlen. So als Faustregel: Wenn Du mit Indexwerten arbeitest machst Du mit, na sagen wir mal 90%iger Wahrscheinlichkeit etwas falsch.

Sowohl das Beispiel von rogerb als auch Deine einzelne Zeile daraus sind syntaktisch korrekt. Also muss der Fehler in Code liegen, den Du nicht gezeigt hast.

[RaPi_Fan]

@__blackjack__:

Danke, du hast mir ein Stück weit die Augen geöffnet. Jetzt verstehe ich auch, warum mein Ansatz nicht funktioniert hat.

Hier der Code, der bei mir nicht funktioniert:

Code: Alles auswählen

from modul_b import setup_potis

def main():
    
    potis = setup_potis()

  
    for poti in potis:
        print(f"poti_{poti.channel} = {poti.value *100}")


if __name__ == "__main__":
    main()

Code: Alles auswählen

def setup_potis():
   
    potis = [MCP3008(num + 1) for num in range(8)]
    return [MCP3008(num + 1) for num in range(8)]
    

[Sirius3]

Dein Programm ist noch viel zu klein, um jetzt schon eigene Module zu schreiben. Allein schon der Name modul_b sagt schon, hier stimmt was nicht.
In setup_potis wird potis gar nicht benutzt. range sollte von 1 bis 8 laufen, nicht von 0 bis 7.
Welche Python-Version benutzt Du?

[RaPi_Fan]

Am Anfang ist alles klein! Ich versuche mich in der Programmierung zurechtzufinden und Struktur von Anfang an hineinzubekommen. Die Module werden später auch sinnhafte Namen erhalten.
Version 3.5.3

[__deets__]

Dieses Vorgehen ist fehlgeleitet. Man strukturiert nach bedarf. Nicht vor. Insbesondere wenn einem dann auch nur eine stumpfe Aufzählung dazu einfällt. Statt der gebotenen inhaltlichen Struktur.

[narpfel]

@RaPi_Fan: Dein Python ist zu alt für f-strings. Die gibt es erst seit Python 3.6 (von Dezember 2016), dein Python 3.5 ist nochmal ein Jahr älter und seit über einem Jahr end-of-life. Warum benutzt du denn so ein veraltetes Python?

[__blackjack__]

Also wenn wir es mal ganz brutal eindampfen, kommen wir auf das hier:

Code: Alles auswählen

#!/usr/bin/env python3
from gpiozero import MCP3008


def main():
    for poti in map(MCP3008, range(1, 9)):
        print(f"poti_{poti.channel()} = {poti.value * 100}")


if __name__ == "__main__":
    main()

Das mit dem auf Vorrat auf nichtssagend benannte Module aufteilen ist gar keine gute Idee. Überhaupt bewusst schlechte Namen zu verwenden und sich vorzunehmen die irgendwann später durch bessere auszutauschen ist keine gute Praxis. Dann kommt später und man hat die Namen schon überall benutzt, und scheut dann den Aufwand und die Fehler, die man vielleicht beim umbenennen machen kann, und es bleiben die schlechten Namen. Aufwand kann auch dadurch entstehen, dass man *dann* feststellt, dass einem kein passender Name einfällt, weil die Sachen die man unter dem Namen zusammengefasst hat, eigentlich gar nicht zusammengehören, und man nicht nur den Namen ändern muss, sondern das Umbenennen auch noch Umstrukturierungen nach sich zieht. Und bei Modulen stellt man beim umstrukturieren dann vielleicht fest, dass Sachen die eigentlich gar nicht zusammengehören und eine Hierarchie bilden sollten, gegenseitige Abhängigkeiten haben die sie gar nicht haben sollten, man also nicht nur umstrukturieren muss, sondern auch Teile um- oder gar neu schreiben muss. Also entweder viel Arbeit, oder man lässt dann doch die schlechten Namen — und den schlecht bis falsch strukturierten Code. Der so vielleicht gar nicht erst entstanden wäre wenn man gleich sinnvolle Namen verwendet hätte und einem beim ersten schreiben schon aufgefallen wäre, dass etwas nicht in ein Modul rein gehört weil es inhaltlich nicht zum Namen des Moduls passt.

Du hast in Deinem `modul_a` beispielsweise die unterste Schicht — das Erstellen der Hardware-Objekte — und die oberste Schicht — GUI zur Benutzerinteraktion — in einem Modul. Also eigentlich alles in einem Modul, ausser dem Programmeinstiegspunkt. Was war denn die Überlegung warum gerade *diese* Trennungslinie durch den Code sinnvoll ist? Und wie würdest Du die Module sinnvoll benennen?

Wenn man mehr als ein Modul hat, sollte man IMHO auch gleich *ein* Package einführen, in dem das zusammengefasst wird. Denn dieser eine Name auf oberster Ebene ”konkurriert” mit allen anderen installierten Python-Packages und -Modulen. Wenn man selbst nicht alles in ein Package steckt, läuft man Gefahr, dass man einen Modulnamen wählt, der schon ”vergeben” ist, und falls man eine Abhängigkeit verwendet, die das ”Original” braucht, bekommt man Probleme.

[RaPi_Fan]

@__blackjack__, __deets__:
das was ich hier präsentiere sind Testprogramme, die nichts mit dem "richtigen" Code zu tun haben. Ich bin Anfänger in Python und übe mit Modulen, Listen & Co umzugehen.

@RaPi_Fan: Dein Python ist zu alt für f-strings. Die gibt es erst seit Python 3.6 (von Dezember 2016), dein Python 3.5 ist nochmal ein Jahr älter und seit über einem Jahr end-of-life. Warum benutzt du denn so ein veraltetes Python?

Ich habe jetzt endlich ein Update hinbekommen. Der Code von __blackjack__ funktioniert jetzt.

Allerdings möchte ich im Hauptprogramm die Hardware-Variablen nicht rechnen, das soll im entsprechenden Modul gemacht werden. Mit der Übergabe aus dem Modul klappt es aber nicht richtig.
Im Modul kann ich die einzelnen Werte noch auslesen, ins Hauptprogramm wird die Liste übertragen, aber die Abfrage der einzelnen Werte geht nicht.

Code: Alles auswählen

from modul_c import setup_potis

def main():
    
    potentiometer_ = setup_potis()

 
    print (potentiometer_[0])
    print (potentiometer_[8])

if __name__ == "__main__":
    main()

Code: Alles auswählen

import gpiozero 
from gpiozero import MCP3008
def setup_potis():
   
    potis = [MCP3008(num) for num in range(8)]

    potentiometer_ = []
    potentiometer_.append(0)
    for poti in potis:
        wert= f"{poti.value *100}"
        potentiometer_.append(wert)
        print(f"potentiometer_{poti.channel+1} = {poti.value *100}")
    
    print (potentiometer_[8])
    print("----- Modul Ende -----")
    
    return [potentiometer_]
    

Das Ergebnis sieht so aus:

Code: Alles auswählen

==================== RESTART: /home/pi/Dokumente/Lesson 2/test c1.py ====================
potentiometer_1 = 0.7327796775769446
potentiometer_2 = 0.04885197850512668
potentiometer_3 = 1.025891548607727
potentiometer_4 = 2.1006350757205583
potentiometer_5 = 2.491450903761594
potentiometer_6 = 1.9052271617000516
potentiometer_7 = 1.6121152906692693
potentiometer_8 = 48.900830483634586
48.900830483634586
----- Modul Ende -----
[0, '1.7098192476795226', '0.04885197850512668', '0.04885197850512668', '1.7098192476795226', '5.031753786028337', '3.957010258915483', '3.663898387884701', '48.900830483634586']
Traceback (most recent call last):
  File "/home/pi/Dokumente/Lesson 2/test c1.py", line 13, in <module>
    main()
  File "/home/pi/Dokumente/Lesson 2/test c1.py", line 10, in main
    print (potentiometer_[8])
IndexError: list index out of range
>>> 

Wie muss ich die Liste übergeben, dass das Hauptprogramm die Werte abfragen kann?
("list index out of range" ist alles außer "0")

Vielen Dank für eure Hilfe,
RaPi_Fan

[__deets__]

Wir wissen nicht, was du alles weisst oder nicht weisst. Wir koennen dein Wirken nur beurteilen anhand dessen, was du hier praesentierst. Und da praesentierst du sinnlose Namen wie modul_c. Wenn das nicht der richtige Name ist, weil du eigentlich was ganz anderes machst, dann lass das doch, und zeig wahlweise den richtigen Code, oder spar dir den fuer ein Testprogramm ueberfluessigen Aufwand.

Dein Problem hier ist erstmal, dass du das falsche zurueckgibst. potentiometer_ (warum der abschliessende Unterstrich, warum das ueberfluessige erste Element?) ist eine Liste, mit 9 Eintraegen. Aber du gibst die nicht direkt zurueck, sondern packst die Liste nochmal in eine Liste. In deinem Return-Statement. Die hat dann nunmal nur ein Element. Wenn du das laesst, dann geht das auch wie gewuenscht.

Dann ist "setup_potis" ein schlechter Name, der suggeriert ja einen Schritt, bei dem die Potentiometer zum Zugriff vorbereitet werden. Das ist aber nicht, was passiert. Du liest deren aktuellen Werte, und gibst nur die Werte zurueck. Angelegt fuer einen zukuenftigen Zugriff ist da also nichts.

Dann wandelst du diesen Wert auch noch gleich in einen String um. Statt ihn als Zahlwert zu erhalten. Das ist unueblich, weil es einfach nur spaeter im Programm Probleme macht, wenn man dann mit den Werten rechnen will. Und zur Testausgabe ist es auch nicht noetig, print(liste) funktioniert auch ohne eine Wandlung in Strings.

So saehe das fuer die momentan Funktionalitaet aus:

Code: Alles auswählen

def read_potis():   
    return [MCP3008(num).value * 100 for num in range(8)]

[RaPi_Fan]

Ich kann euch keinen fertigen, richtigen Code geben, da er noch nicht geschrieben ist. Ich experimentiere! "Test c" und "modul_c" sind doch dafür gar nicht so dumme Namen.
Die String-Problematik habe ich inzwischen gelöst, bekomme jetzt einen float mit einer Nachkommastelle.

Dein Vorschlag geht an mein Erfordernissen vorbei. Ich möchte im Hauptprogramm auf eine Liste zugreifen, die einen lesbaren Variablennamen hat. Ich möchte die Zuweisung von MCP3008irgendwas zum richigen Namen eben nicht im Hauptprogramm machen. Kannst du mir zeigen, wie ich die Liste aus dem Modul ins Hauptprogramm bringe (ohne sie in eine weitere Liste zu stecken)?

[__deets__]

Doch, es sind schlechte Namen. Denn sie sind nichtssagend. Wenn man auf den Code schaut, oder hat man keinerlei Idee, was denn da drin sein sollte. Ein sinnvollerer Name waere sowas wie "io_definitions" zB, wenn das allgemein alle Ein/Ausgaben definieren soll. Ich wuerde es bei einem so kleinen Programm trotzdem lassen, vor allem, wenn es an so vielen anderen Stellen auch noch hapert.

Und durch das return kommt die Liste doch aus dem Modul in dein Programm. Da steht dann halt irgendwo

Code: Alles auswählen

def wichtige_funktion():
    poti_werte = read_potis()
    ... # mach was mit den Werten

poti_werte ist dann der lesbare Name. Von MCP3008 steht dann da auch nichts mehr. Oder was ist da dein Problem?

[RaPi_Fan]

Sorry, ich bekomme es nicht zusammen. Was steht von deinen Vorschlägen im Hauptprogramm, was im Modul?

Wie ich schon schrieb, im Hauptprogamm möchte ich keine Hardware-Variablen rechnen, Ich möchte da auf Listen zugreifen, die die Werte im richtigen Format haben. Dazu gehört auch, dass es das Poti "0" nicht gibt, also die Werte einen offset bekommen. Das ist bei meinem Test ja alles richtig, nur die Übergabe geht nicht.

Wenn du mir einfach schreibst, wie ich meine Liste "potentiometer_" ins Hauptprogramm bekomme, bin ich schon glücklich.

Danke für deine Geduld.

[__deets__]

Code: Alles auswählen

# io_modul
def read_potis():
    ... # wie oben beschrieben

Code: Alles auswählen

# main.py
import io_modul

def main():
     poti_werte = io_modul.read_potis()
     print(poti_werte)

if __name__ == "__main__":
    main()

Was du da beschreibst mit "richtigen Format haben", und auch vorher mit "einer Nachkommastelle", das klingt schon wieder ziemlich falsch. Ist das der Grund fuer die ueberfluessige 0? Computer zaehlen ab 0. Daran rumzudoktern ist ziemlich vergebliche Liebesmueh, und wird auch an allen Ecken und Enden Probleme machen - denn niemand ausser dir macht das so, du wirst dich also dann eh bei Modulen anderer umgewoehnen muessen.

Und deine Potis liefern float-Werte. Wenn du die *Darstellen* willst an einer Stelle, *DANN* macht man da eine Zuordnung auf "menschenlesbare" Zahlen, und *DANN* formatiert man auch die Werte so, dass sie die entsprechenden Nachkommastellen haben, etc.

Code: Alles auswählen

def irgendeine_funktion():
    poti_werte = read_potis()
    for index, wert in enumerate(poti_werte, start=1):  # erzeuge einen menschenlesbaren Index, der bei 1 startet
          print(f"Poti {index}: {wert:.1f}")

[RaPi_Fan]

dein Vorschlag sieht bei mir so aus:

Code: Alles auswählen

# main.py
import io_modul

def main():
     poti_werte = io_modul.read_potis()
     print(poti_werte)

def irgendeine_funktion():
    poti_werte = read_potis()
    for index, wert in enumerate(poti_werte, start=1):  # erzeuge einen menschenlesbaren Index, der bei 1 startet
          print(f"Poti {index}: {wert:.1f}")
     

if __name__ == "__main__":
    main()

Code: Alles auswählen

import gpiozero 
from gpiozero import MCP3008
def read_potis():
    return [MCP3008(num).value * 100 for num in range(8)]

Ergebnis:

Code: Alles auswählen

[0.2442598925256556, 5.715681485100155, 4.445530043966772, 4.7386419149975545, 0.830483634587198, 0.14655593551538004, 0.04885197850512668, 48.900830483634586]

Da ist dann doch wieder Aufwand im Hauptprogramm zu leisten, um Werte anzuzeigen oder zu verarbeiten!

Auch wenn meine Art der Programmierung nicht professionell ist, ich möchte trotzdem nur mit einer Nachkommastelle arbeiten. Schreib mir doch einfach, wie ich meine Liste ins Hauptprogramm bekomme.

Dankeschön,
RaPi_Fan

[__deets__]

Es hilft nichts, irgendeine_Funktion einfach einzukopieren, sie dann aber nicht mal aufzurufen.

Und die Liste aus read_potis ist doch im Hauptprogramm. Was soll da noch gezeigt werden?

Werte Verarbeitet man zur Darstellung eben da, wo sie dargestellt werden. Nicht wo sie gewonnen werden. Wenn das dein „Hauptprogramm“ ist, dann eben da. Wenn in einem andern Modul, das Daten zb als Datei wegschreibt, dann eben da.

Es ist nunmal eine fehlgeleitete Vorstellung, die du da zur Schau trägst. Wenn du die nicht ändern willst, bitte sehr. Aber absichtlich schlechten Code schreiben werde ich nicht.

[__blackjack__]

Um das noch mal zusammen zu fassen, sollte man das hier nicht sinnlos auf Module verteilen:

Code: Alles auswählen

#!/usr/bin/env python3
from gpiozero import MCP3008


def main():
    percentages = [MCP3008(channel).value * 100 for channel in range(8)]
    for number, value in enumerate(percentages):
        print(f"Poti {number}: {value:.1f}")


if __name__ == "__main__":
    main()

[RaPi_Fan]

Es hilft nichts, irgendeine_Funktion einfach einzukopieren, sie dann aber nicht mal aufzurufen.

Und die Liste aus read_potis ist doch im Hauptprogramm. Was soll da noch gezeigt werden?

Das verstehe ich nicht, wird doch aufgerufen ?!?



Ich fühle mich echt missverstanden. Wenn ich alles in das Hauptprogramm schreibe, wird der Code einfach nur lang und unübersichtlich. Deswegen soll alles, was Sinn ergibt, in Module ausgelagert werden. Das mache ich in anderen Sprachen seit Jahren so, und glaubt mir, ICH komme damit gut zurecht. Das letzte Beispiel von __blackjack__ funktioniert, ist aber nicht das was ich will. Um einzelne Werte zu verarbeiten (es werden ja nicht zwangsläufig immer alle Poti-Werte gleichzeitig vom Programm benutzt) wird die Abfrage dann eben nicht kurz und übersichtlich, sondern z.B. bei einer Ausgabe grundsätzlich mit Formatierungsparametern zu versehen sein. Ich möchte sinngemäß einfach "potentiometer_[6]" verwenden können, egal ob für eine Berechnung oder eine Ausgabe, weil einfach ein float mit einer Nachkommastelle in dem Wert steht. (und "potentiometer_[6]" ist dann auch tatsächlich das Poti, an dem ein 6 geschrieben steht! )
Also, wie sieht es aus, gebt mir einen Tipp wie ich die Liste ins Hauptprogramm bekomme und wir können hier die Diskussion einstellen.

Vielen Dank,
RaPi_Fan