Listen Größe

[cyberangle]

Hallo zusammen,

Ich habe einige Listen mit unterschiedlich vielen Werten. Gibt es eine Möglichkeit die Anzahl der Elemente einer Liste abzufragen?

Das 2. ich kenne von anderen Sprachen die Funktion eof ( end of File) die mir das Dateiende einer Datei meldet. Gib es so etwas
auch bei Python

liebe Grüsse
cyberangle

[__blackjack__]

Ja es gibt eine Möglichkeit die Länge einer Liste zu erfahren. Konsultiere ein Grundlagentutorial Deiner Wahl.

Eine `eof()`-Funktion gibt es nicht. Dateiobjekte liefern beim Lesen einfach nichts mehr, also nur noch leere Zeichenketten/`bytes`-Objekte. Wozu brauchst Du das?

[cyberangle]

Habe eine Artikeldatei (noch aus Dbase Zeiten), darauf wollte ich mit Python zugreifen.

[__blackjack__]

@cyberangle: Das beantwortet die Frage wozu `eof()` gebraucht wird nicht wirklich. Das kann man ja sicher auch ohne eine solche Funktion. Pass auf, das Du nicht versuchst Idiome von anderen Programmiersprachen auf Python zu übertragen.

Heisst aus DBase-Zeiten, dass die Datei tatsächlich im DBF-Format vorliegt? Dafür gibt es beispielsweise das externe `dbf`-Modul.

[cyberangle]

Ja, die Datei liegt tatsächlich im DBF Format vor.
Das ist aber erst ein Projekt das noch hinten ansteht da ich ja noch neu bei Python bin.

Aber ich habe momentan noch Probleme mit Listen und Tuple.
Hier ein Prg Code:
General_lst = [2,2,2],[3,3,3,],[4,4,4],[5,5,5],[6,6,6]
Suche =[ 5,5,5]
Finde = General_lst.index(Suche)

das klappt Suche wird gefunden.

Vorsuche ich das aber mit einer for Schleife, weil ich 4 Listen habe erhalte ich ein en Fehler
for i in List1, List2, List3, List4 :
Finde = i.index(Suche)
>>> ValueError tuple.index(x): x not in tuple <<<
ich arbeite doch nur mit Listen

Sorry aber ich weis nicht wie ich den Code als Progamm auf die Antwort bringe

[__blackjack__]

@cyberangle: Nur weil Du etwas List* nennst ist das ja nicht automatisch eine Liste, denn die Ausnahme sagt deutlich, dass es keine Liste sondern ein Tupel ist.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase). Und sie sollten weder Grunddatentypen enthalten, noch kryptische Abkürzungen wie `lst`, noch sollten sie nummeriert sein. Und `i` für etwas anderes als einen Index, also eine ganze Zahl zu verwenden, ist auch eine schlechte Idee.

`Suche` ist keine Suche sondern das was gesucht wird, und `Finde` ist ein Index.

[cyberangle]

Hallo,
ich hatte eigendlich gedacht hier im Forum bekommt am HILFE und keinen Rüffel für schlechte Vaiablennamen. ich wollte nur wissen warum der erste Code
funktioniert und der zweite nicht (auch nicht mit korrekten Variablennamen). Ich bin mit pyhon wie gesagt Anfänger und bemuhe mich auch vernüfige Variablen
zu nutzen. Die im obien Code dienten nur dem besseren Verständnis weil ich nicht wurste wie ich einen Orginalcode enfüge. Somit habe ich nur etwas über Variablen
erfahren, aber der Gund für mein Schreiben blieb unerfüllt. Dazu brauche ich das Forum nicht

[sparrow]

@cyberangle: Nimm den Hinweis auf die Variablen an und mache es beim nächsten Mal besser. Die Menschen, die dir hier die Hinweise geben, weisen dich ja nicht grundlos hin. Wenn du das gleich persönlich nimmst, wirst du dir selbst im Weg stehen.
Und du musst dich auf Python einlassen. Wenn du versuchst die "Art" einer anderen Programmiersprache in Python-Syntax zu pressen, wird das nicht funktionieren.

Was dein Problem angeht: Der Interpreter sagt dir doch, was das Problem ist: tuple haben die gewünschte Methode nicht. Du _glaubst_, dass du Listen hast. Der Interpreter _weiß_, dass du einen Tuple hast. Du zeigst aber ausgedachten Code. Wie sollen wir dir da weiterhelfen? Zeige vollständigen Code (und nicht nur einen Teil), der zu dem Problem führt und schreibe ihn zwischen Code-Tags hier ins Forum. Die Tags werden automatische eingefügt, wenn du den </> -Button im "Vollständigen Editor & Vorschau" drückst.

[DasIch]

Du hast im Namen `General_lst` einen Hinweis auf den Typen des Objektes. Der Hinweis ist allerdings falsch, den `General_lst` verweist auf ein tuple. Das hat dir auch __blackjack__ mehr oder weniger schon im ersten Satz seiner Antwort gesagt.

Wenn man auf Probleme stößt dann ist dies fast immer so weil man irgendwo falsche Annahmen gemacht hat. Deswegen muss man aufpassen, wenn man Annahmen irgendwie im Code ausdrückt sei es in Dokumentation, Kommentaren oder eben Variablennamen. Je mehr man auf einer falschen Annahme aufbaut, desto schwieriger kann es später werden dies noch nachzuvollziehen oder zu ändern. Wie du selbst feststellst, Variablennamen dienen dem Verständnis, deswegen ist es wichtig diese sorgfältig zu wählen, sonst versteht man eben später nicht mehr viel. Endet dann mit sehr langwieriger und frustrierender Suche nach Fehlern. Vielleicht kommt dir der Teil auch schon bekannt vor

[noisefloor]

Hallo,

ich arbeite doch nur mit Listen

Nee, eben nicht. Wurde ja auch schon gesagt. Im Zweifelsfall nachschauen bzw. im interaktiven Interpreter nachstellen:

Code: Alles auswählen

>>> c = [1, 1, 1], [2, 2, 2]
>>> c
([1, 1, 1], [2, 2, 2])
>>> type(c)
<class 'tuple'>

Wenn du auf diese Weise einer Variablen mehrere Werte zuweist, werden die in ein Tuple zusammengezogen. Dann ist es auch egal, ob die Werte Listen oder String oder Integer oder ... sind:

Code: Alles auswählen

>>> e = 'foo', 'bar'
>>> e
('foo', 'bar')
>>> f = 1, 2
>>> f
(1, 2)
>>> g = max, min
>>> g
(<built-in function max>, <built-in function min>)

Gruß, noisefloor

[cyberangle]

[Vielen Dank für Eure Hilfe,
ich habe mich am Donnerstag noch einmal hingesetzt und alles überarbeitet.
hier das Ergebnis:

Code: Alles auswählen

schock_list =  ['000', '111', '112', '113', '114', '115', '116']
general_list = ['000','222', '333', '444', '555', '666']
stra_list =['123', '234', '345', '456']
normwurf_list = ['166', '266', '366', '466','566']
finde = 1
test = "0"
while test != 9:
	test = input('Bitte 3 stellinge Zahl eingeben: ')
	if test == '9':
		break
	for werte in schock_list, general_list, stra_list, normwurf_list:
		print (werte)
		try:
			if finde > 0:
				finde = werte.index(test)
				print('Gefunden Wert ist: ', finde)
				break
	
		except:
			print('Weitersuchen!!')
	
print('Programmende')

[__blackjack__]

@cyberangle: Eingerückt wird per Konvention mit vier Leerzeichen pro Ebene, keine Tabs.

Grunddatentypen haben nichts in Namen zu suchen. Und sie sollten keine kryptischen Abkürzungen enthalten. Wer oder was ist ein/sind `stra`?

Die Bedingung ``test != 9`` ist *immer* wahr, die kann niemals unwahr sein, weil `test` immer an eine Zeichenkette gebunden ist und damit immer ungleich einer Zahl ist. Da kann man also auch einfach `True` direkt hin schreiben, statt das so zu verschleiern. Und dann muss man `test` auch vor der Schleife nicht mit einem Dummy-Wert belegen.

`finde` ist wie schon mal erwähnt ein komischer Name für einen Index. Das klingt mehr nach einem Funktionsnamen. Der Text der Ausgabe ist da auch falsch/irreführend, denn da wird gar nicht der Wert ausgegeben, sondern der Index an dem sich der Wert befindet.

Niemals nackte ``except:``\s ohne konkrete Ausnahme verwenden. Wenn da eine Ausnahme kommt die durch einen Programmierfehler entstanden ist, muss man unnötig lange suchen weil der einfach verschluckt wird. Du willst da auf einen `ValueError` reagieren. Und auch gar nicht in dem gesamten ``try``-Block, sondern eigentlich nur in einer einzigen Zeile davon. Daruf sollte der ``try``-Block auch beschränkt sein.

Was soll denn das ``if index > 0:`` bewirken? Dadurch findet das Programm effektiv nie wieder etwas nachdem das erste mal ein Wert an erster Stelle in einer Liste gefunden wurde, was mir wenig sinnvoll erscheint:

Code: Alles auswählen

$ ./forum20.py 
Bitte 3-stellige Zahl eingeben (oder 9 zum beenden): 123
['000', '111', '112', '113', '114', '115', '116']
Weitersuchen!!
['000', '222', '333', '444', '555', '666']
Weitersuchen!!
['123', '234', '345', '456']
Gefunder Wert ist an Index: 0
Bitte 3-stellige Zahl eingeben (oder 9 zum beenden): 123
['000', '111', '112', '113', '114', '115', '116']
['000', '222', '333', '444', '555', '666']
['123', '234', '345', '456']
['166', '266', '366', '466', '566']
Bitte 3-stellige Zahl eingeben (oder 9 zum beenden): 566
['000', '111', '112', '113', '114', '115', '116']
['000', '222', '333', '444', '555', '666']
['123', '234', '345', '456']
['166', '266', '366', '466', '566']
Bitte 3-stellige Zahl eingeben (oder 9 zum beenden): 9
Programmende

Zwischenstand:

Code: Alles auswählen

#!/usr/bin/env python3


def main():
    schock_werte = ["000", "111", "112", "113", "114", "115", "116"]
    general_werte = ["000", "222", "333", "444", "555", "666"]
    stra_werte = ["123", "234", "345", "456"]
    normwurf_werte = ["166", "266", "366", "466", "566"]
    index = 1
    while True:
        gesuchter_wert = input(
            "Bitte 3-stellige Zahl eingeben (oder 9 zum beenden): "
        )
        if gesuchter_wert == "9":
            break
        
        for werte in schock_werte, general_werte, stra_werte, normwurf_werte:
            print(werte)
            if index > 0:
                try:
                    index = werte.index(gesuchter_wert)
                except ValueError:
                    print("Weitersuchen!!")
                else:
                    print("Gefunder Wert ist an Index:", index)
                    break

    print("Programmende")


if __name__ == "__main__":
    main()

[/me]

Ich habe mal Folgendes daraus gemacht (wobei `WERTE` noch nicht wirklich ein schöner deskriptiver Name ist)

Code: Alles auswählen

#!/usr/bin/env python3

WERTE = {
    'schock': ["000", "111", "112", "113", "114", "115", "116"],
    'general': ["000", "222", "333", "444", "555", "666"],
    'stra': ["123", "234", "345", "456"],
    'normwurf': ["166", "266", "366", "466", "566"]
}


def get_index(data, value):
    try:
        index = data.index(value)
        return index
    except ValueError:
        return None


def main():
    while True:
        gesuchter_wert = input('Bitte dreistellige Zahl eingeben (9 zum Beenden): ')
        if gesuchter_wert == '9':
            break

        for key, data in WERTE.items():
            index = get_index(data, gesuchter_wert)
            if index is not None:
                break
        else:
            print(f'Index von {gesuchter_wert} nicht gefunden\nNeuer Versuch.')
            continue
        print(f'Index von {gesuchter_wert} in Liste "{key}" an Stelle {index} gefunden.')


if __name__ == '__main__':
    main()