Boolschen Operator in Variable speichern und verwenden

[zoddl]

Der Betreff sagt es schon ganz gut, denke ich.
Wie muss ich den Bool in einem Array, sagen wir x, speichern, damit ich sie anschliessen benutzen kann

Code: Alles auswählen

test1 = 4
test2 = 6
x = [<,<=,=,>=,>]

if (test1 x test2):
   print "test1 " + str(x) + "test2"
else:
    None

Grazie

[BlackJack]

@zoddl: Operatoren sind Syntax und keine Objekte, also kann man sie nicht in Datenstrukturen speichern oder an Namen binden.

Du kannst Zeichenketten, die die Operatoren repräsentieren und Funktionen die das selbe ergebnis haben wie die Operatoren zum Beispiel in Tupel und diese Tupel dann in einer Liste speichern. Array solltest Du zu Listen nicht sagen, denn Array-Datentypen gibt es auch, die verwendet man aber nicht für so etwas.

Funktionen, die das tun was die Operatoren machen, gibt es schon fertig in der Standardbibliothek im `operator`-Modul.

Was denkst Du was der Sinn von Deinem ``else``-Zweig ist‽

Klammern um Bedingungen bei ``if`` & Co sind überflüssig.

[Hyperion]

Ergänzend zu BlackJack: Zudem fehlt dann noch eine Art von Schleifenmechanismus, mit der Du *alle* Operationen auswertest.

[/me]

Wie muss ich den Bool in einem Array, sagen wir x, speichern, damit ich sie anschliessen benutzen kann

Ich würde eine Liste (kein Array!) nehmen, deren Inhalte Tupel mit dem Namen (bzw. der Zeichendarstellung) des Operators und dem passenden Operator selbst sind.

Ein Tupel sähe dann wie folgt aus:

Code: Alles auswählen

('<', operator.lt)

[zoddl]

Zunaechst einmal, dass das dieser kleine Codefetzen keinen Sinn macht, ist klar Aber das ganze Script zu posten haette wenig Sinn gemacht.
Kurz gesagt, ich moechte einem Benutzer die Moeglichkeit geben, Daten auszuwerten. Dabei moechte ich einmal am Anfang die Bedingungen setzen und mit diesen Bedingungen mehrere Dateien durchsuchen. Da ich auch mehrere Unterordner habe, will ich nicht mit switch oder if else cases anfangen, so lange ich es maximal variabel halten kann.

Ich schaue mir das mit den tuples mal an.

[/me]

Ich schaue mir das mit den tuples mal an.

Experimentiere und frag bei Bedarf gezielt(!) nach.

Meine Lösung für diese Aufgabe liegt hier zu Hause auf der Platte.

[zoddl]

Habe es nun anders gemacht, und zwar mit einer Funktion.
Vielleicht nicht gerade "Profihaft", aber sie funktioniert ;D

Code: Alles auswählen

def compare_data_and_filter(row,condi_column,condi_cond,condi_value):
    return_record = 0
    row[condi_column] = float(row[condi_column])
    condi_value = float(condi_value)
    if (condi_cond == '>'):
        if (row[condi_column] > condi_value):
            return_record = 1
        else:
            return_record = 0
    if (condi_cond == '>='):
        if (row[condi_column] >= condi_value):
            return_record = 1
        else:
            return_record = 0
    if (condi_cond == '=='):
        if (row[condi_column] == condi_value):
            return_record = 1
        else:
            return_record = 0
    if (condi_cond == '<='):
        if (row[condi_column] <= condi_value):
            return_record = 1
        else:
            return_record = 0
    if (condi_cond == '<'):
        if (row[condi_column] < condi_value):
            return_record = 1
        else:
            return_record = 0
    return return_record

[BlackJack]

@zoddl: Das sieht wirklich nicht profihaft aus. Was sollen die `condi_`-Präfixe? `condi_cond` klingt fast schon lächerlich. An der Stelle hätte man einfach nur die passende Prüffunktion übergeben müssen, schon kann man sich die ganzen ``if``\s sparen. Die übrigens alle unnötige Klammern besitzen.

Bessere Namen für die Argumente wären `column_index`, `condition`, und `value`. `row` würde ich als letztes Argument in die Signatur schreiben, denn dann kann man mit `functools.partial()` eine Funktion erstellen die man mit `filter()` oder `itertools.ifilter()` einfach auf viele Datensätze anwenden kann.

Statt 1 und 0 sollte man Wahrheitswerte verwenden — dazu gibt es sie. Und dann braucht man die auch nicht explizit zuweisen, denn das Ergebnis der Bedingungsausdrücke ist ja schon selbst ein Wahrheitswert.

Das unbekannte Bedingungen einfach lautlos zu `False` bzw. 0 ausgewertet werden, ist IMHO ein schlechter Entwurf.

Edit: Die ganze Funktion würde dann zu so etwas hier zusammen schrumpfen (ungetestet):

Code: Alles auswählen

def test_row(column_index, compare_func, value, row, convert_func=float):
    return compare_func(convert_func(row[column_index]), value)

`value` müsste schon als korrekter Wert/Typ übergeben werden, und Werte für `compare_func` findet man wie gesagt im `operator`-Modul.