learning python: Koordinatensystem

[NoPy]

Hallo Wissende,

einige von Euch haben ja schon mit mir zu tun gehabt. Ich begann vor ca. 25 Jahren mit der Entwicklung von Software, in den letzten Jahren aber eher untergeordnet. Mit python habe ich seit wenigen Monaten und eher gelegentlich zu tun, meine Lieblingssprachen sind Pascal- Derivate und C++.

Ich habe aber beschlossen, mich intensiver in meiner Freizeit mit der Schlange zu beschäftigen. Fernziel (also irgendwann in 5 Jahren, je nachdem, wieviel Freizeit mir so bleibt ) möchte ich vielleicht mal einen Noteneditor mit Soundausgabe auf meinem Android- Tablet gebaut haben.

Habe auf einer Zugfahrt dann auch mal begonnen. Die folgende Funktion ist im Grunde so programmiert, wie ich es in anderen Sprachen auch tun würde (mal abgesehen von diversem sprachspezifischen Schnickschnack, um das zu optimieren.
Ziel ist es, aus übergebenen Achseneigenschaften (Minimum, Maximum, Schrittweite) die Achsenabschnitte für ein Koordinatensystem zu generieren, mit folgenden Besonderheiten:
- wenn nicht gerade (0,0,0) o.ä. übergeben wurde, dann soll er immer irgend etwas produzieren
- wenn die Reihenfolge vertauscht oder eine negative Schrittweite eingegeben wurde, dann soll er das auflösen
- Wenn es einen Nulldurchgang gibt, dann soll der Achsenabschnitt auch auf 0 landen

Der Code ist natürlich zugegebener Maßen sehr umständlich. (numpy hatte ich im Zug nicht, daher ohne)
Wenn jemand Lust hat, dann möge er mich belehren, wie man das in python wirklich macht.

Code: Alles auswählen

MIN_STEP_COUNT = 6.
MAX_STEP_COUNT = 20.

#import numpy

def my_range(my_min, my_max, my_step):
    if my_step<0:
        my_step = -my_step
    if my_max < my_min:
        my_min, my_max = my_max, my_min
    if my_max == my_min:
        my_max = my_max + MIN_STEP_COUNT * my_step 
        my_min = my_min - MIN_STEP_COUNT * my_step 
    if my_step < (my_max - my_min)/MAX_STEP_COUNT:
        my_step = (my_max - my_min)/MAX_STEP_COUNT
    if my_step > (my_max - my_min)/MIN_STEP_COUNT:
        my_step = (my_max - my_min)/MIN_STEP_COUNT
    result = []
    if my_step>0:
        if (my_min < 0) and (my_max > 0):
            my_x = 0
            while my_x > my_min:
                result.append (my_x)
                my_x -= my_step
            my_x = my_step
            while my_x < my_max:
                result.append (my_x)
                my_x += my_step
        else:
            my_x = my_step
            while my_x < my_max:
                result.append (my_x)
                my_x += my_step
        result.sort()
    return result

Anmerkungen:
- my_* kommt daher, dass zumindest die Android- Variante meckerte, wenn ich max oder min verwendet habe. Also habe ich dann konsequent my_ davorgesetzt
- ich weiß, ich komme ohne "result" aus, aber da ich noch nicht sicher bin und für das debuggen ein "print result" ganz nützlich sein kann - gerade auf dem Tablet ohne Debugger - würde ich es gern behalten.

[EyDu]

Ich arbeite es einfach mal von oben nach unten ab:

- Warum sind MIN_STEP_COUNT und MAX_STEP_COUNT Konstanten? Warum existieren die überhaupt? Für mich machen die wenig Sinn.

- ``elif`` existiert, also solltest du es auch verwenden.

- Du berechnest diverse Werte doppelt. Berechne sie einmal, binde das Ergebnis an einen Namen und verwende diesen dann. Wenn du mal etwas ändern musst, dann musst du das nur an genau einer stelle und dich 6 verschiedenen.

- ``result`` sollte keine Liste sein, am besten schreibst du eine Generator-Funktion, welche mittels ``yield`` die berechneten Schritte auswirft.

- Die while-Schleifen kannst du zu einer einzigen zusammenfassen. Rechen vorher aus, wie viele Schritte du benötigst, denn Rest kannst du dan parametrisieren.

- Was macht der sort-Aufruf da am Ende? Wenn du auch Schritte rückwärts machen willst, dann ist das sehr kontraproduktiv. Wenn du keine Schritte Rückwärts machen willst, dann musst du, wie beim Punkt vorher erwähnt, entsprechend konvertieren.

Edit: Ach ja, die ganzen ``my``s solltest du lassen, das ist ech gruselig. Wenn du mit den Namen mit und max Probleme hattest, dann nenne sie low und high oder min_ und_ max_.

[p90]

Also wenn ich das richtig verstehe möchtest du pythons "range" nachprogrammieren
mit einer minimalen und maximalen Anzahl an schritten?
Fall du Range nicht kennts:
http://docs.python.org/3.3/library/stdt ... sseq-range

hier mal ein paar Zeilen die dir vlt. Ideen geben

Code: Alles auswählen

MIN_STEP_COUNT = 6.
MAX_STEP_COUNT = 20.

def my_range(border1, border2, my_step=1):
    range_min = min(border1, border2)
    range_max = max(border1, border2)
    step = my_step if my_step else -my_step
    tmp = []
    if step:
        #step ist nicht 0
        if range_min == range_max:
            range_max = range_max + MIN_STEP_COUNT * step
            range_min = range_min - MIN_STEP_COUNT * step
        stepnumber = (range_max - range_min) / step
        step = step if stepnumber < MAX_STEP_COUNT else (range_max - range_min)/MAX_STEP_COUNT
        step = step if stepnumber > MIN_STEP_COUNT else (range_max - range_min)/MIN_STEP_COUNT
        #tmp = list(range(range_min, range_max, step))
        #wenn du range nehmen möchtest
        #ansonsten vlt so?
        i = range_min
        while i < range_max:
            tmp.append(i)
            i += step
    return tmp

Ansonsten guck auf meinen Vorposter.

[NoPy]

- mit MIN_STEP_COUNT und MAX_STEP_COUNT will ich "verhindern", dass ich zu viele Abschnitte kriege, eben nicht weniger als 6, nicht mehr als 20. Das lief ja erst mal im Textfenster, irgendwann begrenzt sich das dann durch die Bildschirmgröße. Oder anders: Das ist Absicht.
- elif funktioniert nur bei Zeile 14 und 16, in allen anderen Fällen muss der vorige if- Zweig durchlaufen werden
- an welchen Stellen berechne ich etwas doppelt? Ich hätte die While- Schleifen zusammentricksen können, aber etwas anderes sehe ich nicht. Ich könnte sozusagen einen Verschiebungsvektor berechnen, damit ich genau auf 0 komme, aber liest sich das dann noch? Macht man das so in python?
- sort ist nur dafür da, weil ich in einem Fall die negativen Werte rückwärts dranhänge. Könnte ich auch sparen, aber liest es sich so nicht besser?
- ehe ich solange probiere, bis ein Name passt (wer weiß, wann low und high auf Widerstand stoßen) nenne ich sie lieber my_ und max_ und min_ erscheint mir ehrlich gesagt im Moment noch grusliger. Dann würde ich eher ausnutzen, dass python englisch spricht und kleinste, groesste und schrittweite verwenden

[EyDu]

mit MIN_STEP_COUNT und MAX_STEP_COUNT will ich "verhindern", dass ich zu viele Abschnitte kriege, eben nicht weniger als 6, nicht mehr als 20. Das lief ja erst mal im Textfenster, irgendwann begrenzt sich das dann durch die Bildschirmgröße. Oder anders: Das ist Absicht.

Dann schicke die Werte als Parameter mit Default-Werten in die Funktion

elif funktioniert nur bei Zeile 14 und 16, in allen anderen Fällen muss der vorige if- Zweig durchlaufen werden

Und bei Zeile 9 und 11.

an welchen Stellen berechne ich etwas doppelt? Ich hätte die While- Schleifen zusammentricksen können, aber etwas anderes sehe ich nicht. Ich könnte sozusagen einen Verschiebungsvektor berechnen, damit ich genau auf 0 komme, aber liest sich das dann noch? Macht man das so in python?

Deine drei while-Schleifen sind alle quasi identisch. Zum zusammenfassen musst du auch nichts zusammenbasteln, sonder nur ein wenig nachdenken

sort ist nur dafür da, weil ich in einem Fall die negativen Werte rückwärts dranhänge. Könnte ich auch sparen, aber liest es sich so nicht besser?

Du must in deinem Code vorher dafür sorgen, dass dieser Fall gar nicht erst auftreten kann.

he ich solange probiere, bis ein Name passt (wer weiß, wann low und high auf Widerstand stoßen) nenne ich sie lieber my_ und max_ und min_ erscheint mir ehrlich gesagt im Moment noch grusliger. Dann würde ich eher ausnutzen, dass python englisch spricht und kleinste, groesste und schrittweite verwenden

Dann werfe ich mal noch start und stop in den Raum. Die englische Sprache bietet hier sicher noch jede Menge weiterer Alternativen.

[NoPy]

@P90: Danke auch für Dein Posting, aber wirklich kürzer und einleuchtender finde ich es nicht, wenn ich ehrlich bin, zumal es ja die Spezifikation nicht erfüllt:

Wenn der Bereich über 0 hinweg geht, soll zwingend die 0 als Wert in der Liste erscheinen.
Beispiel: my_range(-11,5,2)
meine Version: [-10, -8, -6, -4, -2, 0, 2, 4]
deine Version: [-11, -9, -7, -5, -3, -1, 1, 3]

Die Schrittweite soll nur korrigiert werden, wenn sie aus dem Rahmen fällt
Beispiel: my_range(0,100,15)
meine Version: [15, 30, 45, 60, 75, 90]
deine Version: [0, 16.666666666666668, 33.333333333333336, 50.0, 66.66666666666667, 83.33333333333334]

Alles andere ist im Grunde identisch, dass bei Dir die Untergrenze immer dabei ist und die Obergrenze immer fehlt und bei mir prinzipiell beide Grenzen fehlen ist so oder so überarbeitungsbedürftig.

@EyDu: Mit Generatorfunktionen muss ich mich sicher noch beschäftigen. Der Vorteil wäre in diesem Fall aber welcher?

[NoPy]

Dann schicke die Werte als Parameter mit Default-Werten in die Funktion

Ungern, weil diese Parameter ja de facto nie verändert werden sollen. Aber wenn es Dir besser gefällt, mach ich das Gern. Darauf kommt es mir hier nicht an. Irgendwann in einem Gesamtprojekt gäbe es quasi "Einstellungen", die solches Verhalten steuern. Und ob ich dann alle Funktionen, die an den gleichen Einstellungen hängen, mit diesen Parametern beschicke oder die Parameter gleich aus den Einstellungen geholt werden, das ist mir letztlich erst einmal gleich.

Und bei Zeile 9 und 11.

stimmt.

Deine drei while-Schleifen sind alle quasi identisch. Zum zusammenfassen musst du auch nichts zusammenbasteln, sonder nur ein wenig nachdenken

Wie gesagt, ich müsste ein Offset berechnen, das vom Anfang, Ende und Schrittweite abhängt. Was gewinne ich dadurch? Die Anzahl der Schleifendurchläufe bleibt identisch, ich habe eine komplizierte Berechnung und eine Schleifenendbedingung statt zweier (bzw. dreier) einfacherer Berechnungen und 2 Schleifenendbedingungen. Unter dem Aspekt der Wartbarkeit erschiene mir das nur sinnvoll, wenn innerhalb der Schleife komplizierte Dinge stattfinden würden, oder?

Du must in deinem Code vorher dafür sorgen, dass dieser Fall gar nicht erst auftreten kann.

Das könnte ich, aber auch das wäre eine kompliziertere und damit fehleranfälligere Formel, als hinterher zu sortieren. Wenn man nach dem KISS- Prinzip verfährt, sollte sich das doch verbieten, oder? Alternativ müsste ich schreiben:
my_x = int(min_x / my_step)*my_step und dann bis 0 zählen.

Dann werfe ich mal noch start und stop in den Raum. Die englische Sprache bietet hier sicher noch jede Menge weiterer Alternativen.

Das Problem bei solchen bezeichnern ist, dass sie immer irgendwann mit irgendetwas kollidieren und ich dann wieder probieren muss. Dazu kommt, dass die englischen Bezeichner wesentlich unspezifischer sind, als die Bezeichner anderer Sprachen, was in der Programmierung eigentlich kein Zugewinn ist. Aber nun gut, es ist usus.

[p90]

@P90: Danke auch für Dein Posting, aber wirklich kürzer und einleuchtender finde ich es nicht, wenn ich ehrlich bin, zumal es ja die Spezifikation nicht erfüllt:

Wenn der Bereich über 0 hinweg geht, soll zwingend die 0 als Wert in der Liste erscheinen.

Ah, das hatte ich übersehen, lässt sich aber sehr leicht mit einem if in der while Schleife beheben.
Ansonsten hast du bei mir halt nur eine While Schleife statt 3 und die ganze Behandelung von
Sonderfällen in riesigen If zweigen fällt weg.

Was meinst du genau mit Unübersichtlich?
VLt. die conditional binds die ich verwende?

Die Schrittweite soll nur korrigiert werden, wenn sie aus dem Rahmen fällt
Beispiel: my_range(0,100,15)
meine Version: [15, 30, 45, 60, 75, 90]
deine Version: [0, 16.666666666666668, 33.333333333333336, 50.0, 66.66666666666667, 83.33333333333334]

In meiner Version ist sie ja aus dem Rahmen gefallen, da ich mich an range orientiert habe und das nimmt als erstes Element immer die untere Schranke. Und das ist je genau das gewollte verhalten oder? Die Versionen unterscheiden sicht halt genau um 1 was die Zählweise der Schritte angeht.

[NoPy]

Hab mal eine erste Anpassung vorgenommen

Code: Alles auswählen

def my_range(kleinster, groesster, schritt):
    schritt = schritt if schritt else - schritt
    if schritt<0:
        schritt = -schritt
    if groesster < kleinster:
        kleinster, groesster = groesster, kleinster
    elif groesster == kleinster:
        groesster = groesster + MIN_STEP_COUNT * schritt 
        kleinster = kleinster - MIN_STEP_COUNT * schritt 
    if schritt < (groesster - kleinster)/MAX_STEP_COUNT:
        schritt = (groesster - kleinster)/MAX_STEP_COUNT
    if schritt > (groesster - kleinster)/MIN_STEP_COUNT:
        schritt = (groesster - kleinster)/MIN_STEP_COUNT
    result = []
    if schritt>0:
        if (kleinster < 0) and (groesster > 0):
            x = round(kleinster / schritt + 0.5)*schritt
        else:
            x = kleinster
        while x <= groesster:
            result.append (x)
            x += schritt
    return result

[NoPy]

[quote="p90"]Was meinst du genau mit Unübersichtlich?
[quote="NoPy"]

Das mit der Schrittweite am Anfang ist eine Verbesserung:

Code: Alles auswählen

schritt = schritt if schritt else - schritt

Aber die Beachtung der Randbedingungen MIN_STEP_COUNT, MAX_STEP_COUNT finde ich persönlich unübersichtlich. Vermutlich ist das Geschmackssache, fürchte ich. Denn im Grunde ist es ja das gleiche, wie oben

Und die neuen Variablen range_min und .. max brauche ich ja auch nicht, wenn ich die anderen beiden vertausche.

[Sirius3]

Am besten ist es, ein Range-Objekt ähnlich einem xrange-Objekt zu erzeugen. Es verhält sich weitgehend so wie eine Liste, braucht aber nicht den Speicher einer Liste:

Code: Alles auswählen

class Range(object):
    def __init__(self, start, stop, step, min_step_count=6, max_step_count=20):
        start, stop = sorted([start, stop])
        step = abs(step)
        if start == stop:
            start -= min_step_count * step
            self.stop += min_step_count * step
        min_step = (stop-start) / max_step_count
        max_step = (stop-start) / min_step_count
        step = sorted([min_step, step, max_step])[1]
        self.min_step_count = min_step_count
        self.max_step_count = max_step_count
        self.start = step * math.floor(start / step)
        self.stop = step * math.ceil(stop / step)
        self.step = step
        self.step_count = round((stop-start)/step)
		
    def __iter__(self):
        for i in xrange(self.step_count):
            yield self.start + i * self.step
			
    def __getitem__(self, index):
        if index<0 or index>=self.step_count:
            raise IndexError('index out of range')
        return self.start + index * self.step

	def __len__(self):
	    return self.step_count

[EyDu]

Schon deutlich schöner. Aber was versprichst du dir von Zeile zwei in deinem Code? Zeile 15 sollte jetzt auch überflüssig sein, die Bedingung ist immer erfüllt.

Code: Alles auswählen

def my_range(
        kleinster, groesster, schritt,
        min_step_count=MIN_STEP_COUNT,
        max_step_count=MAX_STEP_COUNT):
    schritt = abs(schritt)

    if groesster < kleinster:
        kleinster, groesster = groesster, kleinster
    elif groesster == kleinster:
        kleinste_breite = min_step_count * schritt
        groesster = groesster + kleinste_breite
        kleinster = kleinster - kleinste_breite
    
    breite = groesster - kleinster
    kleinster_schritt, groesster_schritt = breite/max_step_count, breite/min_step_count
    if schritt < kleinster_schritt:
        schritt = kleinster_schritt
    if schritt > groesster_schritt:
        schritt = groesster_schritt

    if (kleinster < 0) and (groesster > 0):
        x = round(kleinster / schritt + 0.5)*schritt
    else:
        x = kleinster
    while x <= groesster:
        yield x
        x += schritt

Bzw. dann noch weiter vereinfacht:

Code: Alles auswählen

def my_range(
        kleinster, groesster, schritt,
        min_step_count=MIN_STEP_COUNT,
        max_step_count=MAX_STEP_COUNT):
    schritt = abs(schritt)

    if groesster < kleinster:
        kleinster, groesster = groesster, kleinster
    elif groesster == kleinster:
        kleinste_breite = min_step_count * schritt
        groesster = groesster + kleinste_breite
        kleinster = kleinster - kleinste_breite
    
    breite = groesster - kleinster
    kleinster_schritt, groesster_schritt = breite/max_step_count, breite/min_step_count
    schritt = min(max(kleinster_schritt, schritt), groester_schritt)

    if (kleinster < 0) and (groesster > 0):
        x = round(kleinster / schritt + 0.5)*schritt
    else:
        x = kleinster
    while x <= groesster:
        yield x
        x += schritt

[pillmuncher]

Ich werfe mal das hier in den Ring:

Code: Alles auswählen

MIN_STEP_COUNT = 6.
MAX_STEP_COUNT = 20.

def my_range(lo, hi, step):

    step = abs(step)

    if lo > hi:
        lo, hi = hi, lo
    elif lo == hi:
        hi += MIN_STEP_COUNT * step
        lo -= MIN_STEP_COUNT * step

    if step < (hi - lo) / MAX_STEP_COUNT:
        step = (hi - lo) / MAX_STEP_COUNT
    elif step > (hi - lo) / MIN_STEP_COUNT:
        step = (hi - lo) / MIN_STEP_COUNT

    if step == 0:
        return []

    result = []

    if lo < 0 < hi:
        x = 0
        while x > lo:
            result.append(x)
            x -= step
        result = result[::-1]

    x = step
    while x < hi:
        result.append(x)
        x += step

    return result

Algorithmisch habe ich nichts geändert. Ich habe es nur etwas pythonischer gemacht.

Sowohl im Original-Code, als auch in meiner Version, ist IMO ein Bug: Wenn lo < 0 und hi < 0 und lo != hi, dann ist das Ergebnis [].

[NoPy]

Muss leider erst mal schluss machen. Kurz überflogen: Interessantes dabei.

@sirius: Bist Du Dir sicher, dass Du dich zwischen stop / self.stop und start / self.start nicht verhaspelt hast?
Mir ging es schon öfter so und bei Dir habe ich zumindest in den Zeilen 6 und 7 auch das Gefühl.

Code: Alles auswählen

            start -= min_step_count * step
            self.stop += min_step_count * step

Den Rest muss ich mir später ansehen.

[p90]

Sehe gerade noch einen blöden Fehler in meinem Code:

Und zwar:

Code: Alles auswählen

a = a if a else -a

verändert a niemals.

Hintergrund:
Der boolische Wert für a ist:
False falls a = 0
True für JEDEN anderen Fall

es ergibt sich also für negative Zahlen folgendes:

Code: Alles auswählen

a = -5
a = -5 if True else 5

Ergo ist a danach immer noch -5 statt 5

Möchte man das Vorzeichen ändern sollte man also direkt die Richtige Funktion nehmen und

Code: Alles auswählen

a = -5
a = abs(a)

verwenden.

[pillmuncher]

Den o.g. Bug kann man leicht richten, und damit lässt es sich es auch einfacher zum Generator umbauen:

Code: Alles auswählen

MIN_STEP_COUNT = 6.
MAX_STEP_COUNT = 20.

def my_range(lo, hi, step):

    step = abs(step)

    if lo > hi:
        lo, hi = hi, lo
    elif lo == hi:
        hi += MIN_STEP_COUNT * step
        lo -= MIN_STEP_COUNT * step

    if step < (hi - lo) / MAX_STEP_COUNT:
        step = (hi - lo) / MAX_STEP_COUNT
    elif step > (hi - lo) / MIN_STEP_COUNT:
        step = (hi - lo) / MIN_STEP_COUNT

    if step <= 0:
        return

    if lo < 0 < hi:
        offset = lo % step
        lo -= offset
        hi -= offset

    x = lo
    while x < hi:
        yield x
        x += step

[pillmuncher]

Habe noch zwei Bugs im Code gefunden.

Dieser ist vielleicht ein Feature:

Code: Alles auswählen

>>> print my_range(10, 20, 3)
[1.6666666666666667, 3.3333333333333335, 5.0, 6.666666666666667, 8.333333333333334, 10.0, 11.666666666666666, 13.333333333333332, 14.999999999999998, 16.666666666666664, 18.333333333333332]

Dieser wohl nicht:

Code: Alles auswählen

>>> print my_range(.1 + .2, .3, .01)

Da landet man in einer Endlosschleife.

Wahrscheinlich hat der OP nicht gar damit gerechnet, dass jemand die Funktion mit floating point Argumenten aufrufen würde. Er schrieb ja, dass er von statisch typisierten Sprachen kommt. Für alle anderen gilt, was ich heute zufällig gelesen habe: Some programmers, when confronted with a problem, think "I know, I'll use floating point arithmetic." Now they have 1.999999999997 problems.

[pillmuncher]

Nur, damit ich sicher sein kann, dass ich die Spezifikation der Funktion auch verstanden habe. Gegeben drei Zahlen a, b und c mit lo = min(a, b) und hi = max(a, b) und step = abs(c) und num_steps = (hi - lo) / step und dazu zwei Konstanten MIN und MAX mit MIN < MAX, dann gilt:

Code: Alles auswählen

lo == hi or lo < hi
lo <= hi < 0 or lo <= 0 <= hi or 0 < lo <= hi
num_steps < MIN or MIN <= num_steps <= MAX or MAX < num_steps
0 == step or 0 < step 

Da num_steps nicht existiert, sofern step == 0 ist, ergeben sich daraus 2 * 3 + 2 * 3 * 3 == 24 Kombinationen. Was soll im jeweiligen Fall geschehen?