Quadrant (Winkel) im x-y-Koordinatensystem bestimmenn

[Anakonda]

Hallo zusammen,

da ich in den Foren nicht fündig werde, wende ich mich mal an Euch. Ich will über gegebene x-y-Koordinaten einen Winkel zwischen 0° und 360° ermitteln, der aber abhängig von den Koordinaten auch mal negativ ausgegeben wird. Mit meiner "Holzhammermethode" komme ich zwar irgendwie in die Richtung, aber elegant ist anders. Genauso ist es wenn ich z.B. tan-Werte abfangen will, von denen ja mehrfache von +-90° nicht berechnet werden können. Ich bräuchte nur mal das eine oder andere Stichwort, um dann weiterzukommen (googlen). Danke im voraus.

def kart_2_pol (x, y, x_pnt, y_pnt):
x_l = x + x_pnt
y_l = y + y_pnt
r = math.sqrt(x_l ** 2 + y_l ** 2)
if (x_l != 0 and y_l != 0):
winkel = math.degrees(math.atan (y_l / x_l))
winkel=0
if (y_l >= 0 and x_l < 0):
winkel = 180 - (winkel * -1)
elif (y_l <= 0 and x_l <0):
winkel = 180 + winkel
elif (y_l <= 0 and x_l > 0):
winkel = 360 - (winkel * -1)
return (r, winkel)
else:
print ("Eingabe prüfen!!!")
sys.exitt

[__deets__]

Ich vermute mal du suchst zwei Dinge:

- atan2
- den </>-Knopf im vollstaendigen Editor, um deinen Code formatiert darzustellen.

[__blackjack__]

@Anakonda: Schau Dir mal `math.atan2()` an. Oder das `cmath`-Modul und da die Funktion `polar()`.

Du solltest dringend an der Namensgebung arbeiten. Es gibt in der Funktion nur drei vernünftig benannte Werte: `x`, `y`, und `winkel`. Alles andere, inklusive dem Funktionsnamen selbst, ist nicht gut.

[Anakonda]

Danke für die Antworten. Werde ich mir mal die atan2()-Geschichte anschauen. @blackjack: Wie sollten Funktionen oder Variablen benannt werden? Das Ganze sollte doch lesbar sein und schon vom Namen her auf die Verwendung hinweisen. Das alles sind ja die Feinheiten, die man als Anfänger noch nicht kennt. Nur durch Probieren und Hinweise von erfahrenen Leuten, die man hier ja findet, kann man das Programmieren lernen.

[__blackjack__]

@Anakonda: Na Du sagst es doch selbst: der Leser soll Namen verstehen können. Also beispielsweise keine kryptischen Abkürzungen, oder Prä- und Postfixe, oder ”denglish”. `kart_2_pol():` ist ”denglisch”, hiesse besser `kartesisch_nach_polar_umrechnen()` oder `convert_cartesian_to_polar()`. Allerdings auch nur wenn es dort nur `x` und `y` als Argumente gibt.

Ich habe keine Ahnung was das `_pnt` bei `x_pnt` und `y_pnt` bedeuten soll. Point oder Punkt? Aber `x` und `y` bezeichnen doch auch einen Punkt‽ Was bedeutet das `_l` bei `x_l` und `y_l`?

`r` hiesse ausgeschrieben wohl `radius`.

[Anakonda]

Hi Blackjack, danke für die Anregungen. Mit dem denglisch gebe ich dir absolut recht, also entweder oder! Die anderen Variablen brauche ich noch für andere "defs"; ich nudele das Ganze, was die Namen angeht, mal entsprechend um. Ich bin ja froh, dass es dieses Forum gibt, wo man als Anfänger wertvolle Tips bekommen kann, um solche Kleinigkeiten zu vermeiden und einen adäquaten Stil zu entwickeln. Deswegen nochmal Danke........ich gelobe Besserung

[Sirius3]

@Anakonda: vor der öffnenden Klammer von Funktionsdefinition oder -aufruf gehört kein Leerzeichen. Die Klammern bei if sind überflüssig. Eingerückt wird immer mit 4 Leerzeichen pro Ebene, nicht mal 4 und mal 8.
Es ist wenig sinnvoll `winkel` immer auf 0 zu setzen. Und was ist der Unterschied zwischen `180 - (winkel * -1)` und `180 + winkel`?
sys.exitt wird wahrscheinlich nicht existieren. Man sollte auch niemals nie außer in der main-Funktion sys.exit benutzen (das übrigens auch noch aufgerufen werden muß). Für sowas benutzt man Ausnahmen. Wobei hier mathematisch gar keine Ausnahme existiert. Bei radius 0 ist jeder Winkel gültig, wobei meist 0 gewählt wird.

Code: Alles auswählen

def convert_cartesian_to_polar(x, y, x_point, y_point):
    radius, angle = cmath.polar(x + x_point, y + y_point)
    return radius, math.degrees(angle) % 360

[Anakonda]

Hallo Sirius,
hab jetzt mal die Geschichte umgeschrieben. Würde mich freuen, wenn ich noch weitere konstruktive Kritik bekomme.
import math
import sys

def convert_cartesian_old_to_cartesian_new(x_old, y_old, x_u_factor, y_v_factor):
x_new = x_old + x_u_factor
y_new = y_old + y_v_factor
return (x_new, y_new)

def convert_cartesian_to_polar(x, y):
radius = math.sqrt(x**2 + y**2)
try:
angle = math.degrees(math.atan2(y, x))
if angle<0:
angle = 360 + angle
return (radius, angle)
except:
print ("Eingabe prüfen!!! X-Wert muss ungleich 0 sein!")

def convert_polar_to_cartesian(angle, radius):
x = radius * math.cos (angle)
y = radius * math.sin (angle)
return (x, y)

def get_arc_length(radius, angle):
arc_length = radius * math.pi * angle / 180
return (arc_length)

def get_turn_angle(radius, arc_length):
turn_angle = arc_length * 180 / radius / math.pi
return (turn_angle)

a=100
b=60
c=convert_polar_to_cartesian(a,b)
print(c)
d=get_arc_length(a,b)
print(d)
e= get_turn_angle(a,d)
print(e)

Unten die Zeilen waren nur zum Probieren, was rauskommt. Aber noch ne Frage....wo ist der Knopf, um den Quellcode entsprechend hier anzuzeigen? Das hier ist nicht gerade übersichtlich. PS: Benutze PyCharm

[__blackjack__]

@Anakonda: `sys` wird nicht mehr benötigt.

In `convert_cartesian_old_to_cartesian_new()` muss man nicht unbedingt die beiden Zwischenergebnisse an Namen binden. Das gilt auch für die anderen Funktionen. Insbesondere wenn das Zwischenergebnis an einen Namen gebunden wird, der in der Zeile danach in einem ``return`` verwendet wird.

Bei den Leerzeichen könnten es ein paar mehr sein, nämlich um das ``=`` bei Zuweisungen (ausserhalb von Argumentlisten) und binären Operatoren, und nach Kommas. Und es könnten ein paar weniger sein: zwischen Funktionsnamen und öffnender Klammer für den Aufruf.

Bei `get_arc_length()` und `get_turn_angle()` sind unnötige Klammern um das Ergebnis.

Das ``try``/``except`` macht keinen Sinn. Und ein nacktes ``except`` ohne konkrete Ausnahme(n) sollte man sowieso nicht schreiben, denn das behandelt *alle* Ausnahmen. Allerdings ist die Ausgabe über die X-Koordinate beispielsweise keine sinnvolle Behandlung für einen `NameError` wenn man sich im Code vertippt hat, oder für einen `MemoryError` wenn dem Prozess der Speicher ausgegangen ist, oder…

Ausgaben für den Benutzer sind in solchen Funktionen auch keine sinnvollen Behandlungen. Der kann damit nichts anfangen. Der sieht die vielleicht gar nicht, wenn die Funktion beispielsweise in einem Programm mit grafischer Oberfläche verwendet wird.

Zudem ist das ein Zweig der ja auch zu einem Rückgabewert führt, und den sollte man dann auch *explizit* angeben.

Bei der Anpassung von `angle` könnte man ``+=`` verwenden.

Das `convert_cartesian_to_polar()` das Ergebnis in der Reihenfolge Winkel und Radius liefert, die Umkehrfuntkion `convert_polar_to_cartesian()` dann aber die Argumente in der Reihenfolge Radius und Winkel erwartet ist ein bisschen unschön.

Bei den letzten beiden Funktionen hast Du was selbst programmiert was es in `math` bereits gibt: Umwandlungen zwischen Grad und Bogenmass. Wobei Du an anderer Stelle ja immerhin `math.degrees()` bereits verwendest.

Das Hauptprogramm sollte in einer Funktion stehen und bessere Namen als `a` bis `e` verwenden.

Code: Alles auswählen

#!/usr/bin/env python3
import math


def convert_cartesian_old_to_cartesian_new(
    x_old, y_old, x_u_factor, y_v_factor
):
    return (x_old + x_u_factor, y_old + y_v_factor)


def convert_cartesian_to_polar(x, y):
    angle = math.degrees(math.atan2(y, x))
    if angle < 0:
        angle += 360
    return (math.sqrt(x ** 2 + y ** 2), angle)


def convert_polar_to_cartesian(radius, angle):
    return (radius * math.cos(angle), radius * math.sin(angle))


def get_arc_length(radius, angle):
    return radius * math.radians(angle)


def get_turn_angle(radius, arc_length):
    return math.degrees(arc_length / radius)


def main():
    radius = 100
    angle = 60
    coordinates = convert_polar_to_cartesian(radius, angle)
    print(coordinates)
    arc_length = get_arc_length(radius, angle)
    print(arc_length)
    turn_angle = get_turn_angle(radius, arc_length)
    print(turn_angle, math.isclose(angle, turn_angle))


if __name__ == "__main__":
    main()

[Anakonda]

Vielen Dank für die sehr ausführliche Antwort. Ich werde das in Ruhe durchgehen und erst nach Verstehen deines Codes diesen dann bei mir einbauen. Einfach nur reinkopieren ist nicht Sinn der Übung; diese Vorgehensweise würde ich auch jedem anderen Anfänger empfehlen. Wie das mit dem Einfügen von Quellcode hier in einem Beitrag funktioniert, erschliesst sich mir leider immer noch nicht.

[__blackjack__]

@Anakonda: Im vollständigen Editor gibt es eine Schaltfläche mit der Beschriftung „</>“ die Code-Tags einfügt. Dazwischen kommt dann der Quelltext. Man kann auch erst Quelltext in den Editor schreiben/einfügen, den auswählen, und dann auf „</>“ klicken — die Tags werden dann vor und nach dem ausgewählten Text gesetzt.

Und man kann die Tags natürlich auch von Hand schreiben. Das ist [ code ] am Anfang und [ /code ] am Ende — ohne die Leerzeichen in den Klammen. Beim Starttag kann man noch =python oder eine andere Programmiersprache die von Highlight.js erkannt wird angeben, falls das mit dem Raten der Sprache nicht klappt und die Syntaxhervorhebung komisch/falsch aussieht. code=text wenn man keine Syntaxhervorhebung haben möchte, beispielsweise wenn man ``print()``-Ausgaben von einem Programm zeigen will.