Kräfteberechnung per Python

[cck1989]

Hallo, ich bin Fynn,
ich bin 31 Jahre alt und habe vor 2 Tagen mit dem Thema Python begonnen.
ich benötige ein bisschen Hilfe bei meinem Script.

Dazu folgendes.
Es geht um ein Script, mit dem man eine Kräfteaddition vornehmen kann. Als Ergebnis wird eine Resultierende Kraft und der Richtungswinkel ausgegeben.
In der Dritten Zeile wird abgefragt wieviele Kräfte man zusammen addieren möchte, man hat die Wahl zwischen 3 - 5 Stück.
Es soll wie folgt aussehen, wenn ich 3 eingebe, soll alles ausgeführt werden was unter " if k ==3:" steht, bei 4 alles was bei "if k == 4:" bei 5, kann man sich denken.
aber egal was ich eingebe, er führt immer nur das aus was unter …..3 steht.

hat jemand dazu eine Lösung.
Ich bitte um Kritik und Verbesserungsvorschläge.

Bitte habt Nachsicht, ich bin sehr frisch.


Danke.
Liebe Grüße
Fynn

Code: Alles auswählen

# Rechnerische Addition von 3 Kräften
print ("Wie viele Kräfte möchten Sie addieren?")
k = eval (input("Anzahl der Kräfte?  (3~5)"))
if k == 3:
    print (3)
    print("Bitte tragen Sie ihre Kräfte ein")
a = eval (input("F1    ?   "))
print("Kraft F2 beträgt %.2f N" % (a))
b = eval (input("F2    ?   "))
print("Kraft F2 beträgt %.2f N" % (b))
c = eval (input("F3    ?   "))
print("Kraft F3 beträgt %.2f N" % (c))

z = eval (input("Winkel zu F1    ?   "))
print("Der Winkel zu Kraft F1 beträgt %2.f Grad" %(z))
y = eval (input("Winkel zu F2    ?   "))
print("Der Winkel zu Kraft F2 beträgt %2.f Grad" %(y))
x = eval (input("Winkel zu F3    ?   "))
print("Der Winkel zu Kraft F3 beträgt %2.f Grad" %(x))


import math
from math import pi
from math import cos
from math import sin
from math import atan

#Kräfte
F1 = a
F2 = b
F3 = c

#Winkel
a1 = z
a2 = y
a3 = x

#Bogenlängen
a1b = (a1/180*pi)
a2b = (a2/180*pi)
a3b = (a3/180*pi)

#X-Achsen-Kraft
Fx1 = F1 * cos(a1b)
Fx2 = F2 * cos(a2b)
Fx3 = F3 * cos(a3b)

#print (cos(a1b))
#print (cos(a2b))
#print (cos(a3b))
#print("Fx1 beträgt  %.2f. Newton" % (Fx1))
#print("Fx2 beträgt %.2f. Newton" % (Fx2))

fx = Fx1+Fx2+Fx3
print("Fx gleich = Fx1: %.2f N + Fx2: %.2f N + Fx3: %.2f N" % (Fx1, Fx2, Fx3))
print("Fx beträgt %.2f. Newton" % (fx))


#Y-Achsen-Kraft
Fy1 = F1 * sin(a1b)
Fy2 = F2 * sin(a2b)
Fy3 = F3 * sin(a3b)
#print("Fy1 beträgt %.2f. Newton" % (Fy1))
#print("Fy2 beträgt %.2f. Newton" % (Fy2)) 
            
fy = Fy1+Fy2+Fy3
print("Fy gleich = Fy1: %.2f N + Fy2: %.2f N + Fy3: %.2f N" % (Fy1, Fy2, Fy3))
print("Fy beträgt %.2f. Newton" % (fy))


resultierende = (math.sqrt(fy**2+fx**2))
print("Die resultierende Kraft beträgt %.2f Newton" % (resultierende))



arcWinkel = (atan(fy/fx))

Winkel =(arcWinkel*180/pi)
if fy > 0 and fx > 0:
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fx < 0 and fy > 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx > 0:
    Winkel =(arcWinkel*180/pi+360)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx < 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
print("Zum Beenden drücken Sie bitte eine beliebige Taste")
input()
if k == 4:
    print (4)
    print("Bitte tragen Síe die Kräfte ein")
a = eval (input("F1    ?   "))
print("Kraft F2 beträgt %.2f N" % (a))
b = eval (input("F2    ?   "))
print("Kraft F2 beträgt %.2f N" % (b))
c = eval (input("F3    ?   "))
print("Kraft F3 beträgt %.2f N" % (c))
d = eval (input("F4    ?   "))
print("Kraft F4 beträgt %.2f N" % (d))
z = eval (input("Winkel zu F1    ?   "))
print("Der Winkel zu Kraft F1 beträgt %2.f Grad" %(z))
y = eval (input("Winkel zu F2    ?   "))
print("Der Winkel zu Kraft F2 beträgt %2.f Grad" %(y))
x = eval (input("Winkel zu F3    ?   "))
print("Der Winkel zu Kraft F3 beträgt %2.f Grad" %(x))
w = eval (input("Winkel zu F4    ?   "))
print("Der Winkel zu Kraft F4 beträgt %2.f Grad" %(w))

import math
from math import pi
from math import cos
from math import sin
from math import atan

#Kräfte
F1 = a
F2 = b
F3 = c
F4 = d
#Winkel
a1 = z
a2 = y
a3 = x
a4 = w
#Bogenlängen
a1b = (a1/180*pi)
a2b = (a2/180*pi)
a3b = (a3/180*pi)
a4b = (a4/180*pi)
#X-Achsen-Kraft
Fx1 = F1 * cos(a1b)
Fx2 = F2 * cos(a2b)
Fx3 = F3 * cos(a3b)
Fx4 = F4 * cos(a4b)
#print (cos(a1b))
#print (cos(a2b))
#print (cos(a3b))
#print("Fx1 beträgt  %.2f. Newton" % (Fx1))
#print("Fx2 beträgt %.2f. Newton" % (Fx2))

fx = Fx1+Fx2+Fx3+Fx4
print("Fx gleich = Fx1: %.2f N + Fx2: %.2f N + Fx3: %.2f N + Fx4: %.2f N" % (Fx1, Fx2, Fx3, Fx4))
print("Fx beträgt %.2f Newton" % (fx))


#Y-Achsen-Kraft
Fy1 = F1 * sin(a1b)
Fy2 = F2 * sin(a2b)
Fy3 = F3 * sin(a3b)
Fy4 = F4 * sin(a4b)
#print("Fy1 beträgt %.2f. Newton" % (Fy1))
#print("Fy2 beträgt %.2f. Newton" % (Fy2)) 
   
fy = Fy1+Fy2+Fy3+Fy4
print("Fy gleich = Fy1: %.2f N + Fy2: %.2f N + Fy3: %.2f N + Fx4: %.2f N" % (Fy1, Fy2, Fy3, Fy4))
print("Fy beträgt %.2f Newton" % (fy))


resultierende = (math.sqrt(fy**2+fx**2))
print("Die resultierende Kraft beträgt %.2f Newton" % (resultierende))



arcWinkel = (atan(fy/fx))

Winkel =(arcWinkel*180/pi)
if fy > 0 and fx > 0:
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fx < 0 and fy > 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx > 0:
    Winkel =(arcWinkel*180/pi+360)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx < 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
print("Zum Beenden drücken Sie bitte eine beliebige Taste")
input( )
if number == 5:
    print (5)
    print("Bitte tragen Síe die Kräfte ein")
a = eval (input("F1    ?   "))
print("Kraft F2 beträgt %.2f N" % (a))
b = eval (input("F2    ?   "))
print("Kraft F2 beträgt %.2f N" % (b))
c = eval (input("F3    ?   "))
print("Kraft F3 beträgt %.2f N" % (c))
d = eval (input("F4    ?   "))
print("Kraft F4 beträgt %.2f N" % (d))
e = eval (input("F5    ?   "))
print("Kraft F5 beträgt %.2f N" % (e))
z = eval (input("Winkel zu F1    ?   "))
print("Der Winkel zu Kraft F1 beträgt %2.f Grad" %(z))
y = eval (input("Winkel zu F2    ?   "))
print("Der Winkel zu Kraft F2 beträgt %2.f Grad" %(y))
x = eval (input("Winkel zu F3    ?   "))
print("Der Winkel zu Kraft F3 beträgt %2.f Grad" %(x))
w = eval (input("Winkel zu F4    ?   "))
print("Der Winkel zu Kraft F4 beträgt %2.f Grad" %(w))
v = eval (input("Winkel zu F5    ?   "))
print("Der Winkel zu Kraft F5 beträgt %2.f Grad" %(v))

#Kräfte
F1 = a
F2 = b
F3 = c
F4 = d
F5 = e
#Winkel
a1 = z
a2 = y
a3 = x
a4 = w
a5 = v
#Bogenlängen
a1b = (a1/180*pi)
a2b = (a2/180*pi)
a3b = (a3/180*pi)
a4b = (a4/180*pi)
a5b = (a5/180*pi)
#X-Achsen-Kraft
Fx1 = F1 * cos(a1b)
Fx2 = F2 * cos(a2b)
Fx3 = F3 * cos(a3b)
Fx4 = F4 * cos(a4b)
Fx5 = F5 * cos(a5b)
#print (cos(a1b))
#print (cos(a2b))
#print (cos(a3b))
#print("Fx1 beträgt  %.2f. Newton" % (Fx1))
#print("Fx2 beträgt %.2f. Newton" % (Fx2))

fx = Fx1+Fx2+Fx3+Fx4+Fx5
print("Fx gleich = Fx1: %.2f N + Fx2: %.2f N + Fx3: %.2f N + Fx4: %.2f N + Fx5: %.2f N" % (Fx1, Fx2, Fx3, Fx4, Fx5))
print("Fx beträgt %.2f Newton" % (fx))


#Y-Achsen-Kraft
Fy1 = F1 * sin(a1b)
Fy2 = F2 * sin(a2b)
Fy3 = F3 * sin(a3b)
Fy4 = F4 * sin(a4b)
Fy5 = F5 * sin(a5b)
#print("Fy1 beträgt %.2f. Newton" % (Fy1))
#print("Fy2 beträgt %.2f. Newton" % (Fy2)) 
   
fy = Fy1+Fy2+Fy3+Fy4+Fy5
print("Fy gleich = Fy1: %.2f N + Fy2: %.2f N + Fy3: %.2f N + Fx4: %.2f N + Fy5: %.2f N" % (Fy1, Fy2, Fy3, Fy4,Fy5))
print("Fy beträgt %.2f Newton" % (fy))


resultierende = (math.sqrt(fy**2+fx**2))
print("Die resultierende Kraft beträgt %.2f Newton" % (resultierende))



arcWinkel = (atan(fy/fx))

Winkel =(arcWinkel*180/pi)
if fy > 0 and fx > 0:
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fx < 0 and fy > 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx > 0:
    Winkel =(arcWinkel*180/pi+360)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
elif fy < 0 and fx < 0:
    Winkel =(arcWinkel*180/pi+180)
    print("Der Winkel der resultierenden Kraft beträgt %.2f Grad " % (Winkel))
print("Zum Beenden drücken Sie bitte eine beliebige Taste")
input( )

[Sirius3]

Einrückungen sind wichtig. Schau mal, was wie weit eingerückt ist, und was damit alles zum `if k ==3`-Block gehört.
Vergiss gleich wieder, dass es sowas wie `eval` überhaupt gibt. Wenn Du eine Ganzzahl willst, benutzt int, für Kommazahlen float.
Statt Variablen durchzunummerieren, schau Dir an, wie man Listen benutzt. Und for-Schleifen.

[__blackjack__]

@cck1989: Was meinst Du mit ”unter”? Es wird bei ``if …:`` wenn die Bedingung zutrifft alles ausgeführt was eingerückt in dem Block steht unter dem ``if``. Und danach dann bedingungslos alles was auf der gleichen Ebene steht wie das ``if``, denn das wird von dem ``if`` nicht mehr ”geschützt”. Einrückung ist wichtig. Woher sollte Python denn sonst wissen was zur bedingten Ausführung gehört und was nicht mehr.

Allgemeine Anmerkungen: Ganz dringend das `eval()` loswerden. Das Argument, also hier die Eingabe des Benutzers wird als Python-Ausdruck ausgewertet. Damit kann der Benutzer im Grunde fast beliebigen Code ausführen lassen und das Programm müsste damit mindestens mal auf beliebige Fehler bei den Eingaben reagieren können. Du willst hier die eingegebenen Zeichenketten in Zahlen umwandeln, ganze Zahlen oder Gleitkommazahlen, dann mach auch nur genau *das*.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Es sieht auch so aus als wenn das gleiche da Mehrfach kopiert stehen würde. Solche Wiederholungen macht man nicht. Auch hier könnte eine oder mehrere Funktionen die Lösung sein, in der die Gemeinsamkeiten der ganzen Kopien als Argumente heraus gezogen werden.

Importe gehören an den Anfang des Moduls. Und wenn man mehrere Namen aus einem Modul importiert braucht man da nicht für jeden eine eigene Importanweisung. (Aber auch kein *-Import.) Mir ist auch nicht ganz klar warum alle möglichen Funktionen aus `math` importiert werden, aber die Wurzelfunktion dann nicht sondern über das Modul angesprochen wird.

Den ``%``-Operator würde ich nicht mehr zum formatieren von Werten in Zeichenketten verwenden. Dafür gibt es die `format()`-Methode auf Zeichenketten und ab Python 3.6 f-Zeichenkettenliterale.

Die Namen sind teilweise sehr schlecht gewählt. Das ist keine Mathematik wo man alles kryptisch in einbuchtabigen und teilweise durchnummerierten Namen ausdrückt. Was zudem noch völlig unsinnig ist, sind die nichtssagenden einbuchstabigen Namen an die die Eingaben gebunden werden die dann noch mal an ebenfalls ein- bis zwei Zeichen lange nichtssagende gebunden werden.

Die letzten beiden Zeilen sollten da eigentlich nicht sein weil die keinen Sinn machen. Konsolenprogramme führt man in einer laufenden Konsole aus, da muss man nicht am Ende noch eine sinnlose Eingabe vom Benutzer verlangen.

[cck1989]

@all danke für die Hinweise und Kritik

wie gesagt habe erst vor 3 Tagen angefangen Python zu programmieren, habe keinerlei Vorkenntnisse..
ich werde eure Hinweise annehmen und es mal versuchen zu verbessern.

Werde dann entsprechenden Code hochladen

Gruß

[cck1989]

So ich habe mich mal daran versucht den Code ein wenig zu ändern
Ist dies im Ansatz der richtige Weg?

Die letzten Zeilen habe ich weiterhin drinnen gelassen, da ich diese .py Datei als .exe umwandeln möchte, damit ich diese im Studium nutzen kann. Ohne diese 2 Zeilen beendet sich die .exe nach Ausgabe der Werte, ohne das ich dieses analysieren kann

aber wie realisiere ich das, das ich mehr als 3 Kräfte addieren kann ohne den Code großartig zu kopieren. Oder ist dies nicht möglich das ich den Code schon von vornherein falsch aufgebaut habe.

Code: Alles auswählen

# Rechnerische Addition von Kräften
import math
from math import pi
from math import cos
from math import sin
from math import atan

force = "Die Kraft {F:} beträgt {force:} N."
tangle = "Der Winkel von {F:} beträgt {tangle:} Grad."
KraftxAchse = "Die Kraft der X-Achse beträgt {SummeKraftX:} N."
KraftyAchse = "Die Kraft der Y-Achse beträgt {SummeKraftY:} N."
resultierende = "Die resultierende Kraft beträgt {resultierendeKraft:} N."
WinkelResultierendeKraft = "Der Winkel der resultierenden Kraft beträgt {WinkelResultierende} Grad. "

#Listen

ListeKraftNummern= [1,2,3,4,5,6]
ListeKraftWerte = []
ListeKraftWinkel = []
ListeBogenlängenKräfte = []
ListeKraftXAchse = []
SummeKraftxAchse = []
ListeKraftYAchse = []
SummeKraftyAchse = []
ResultierendeKraft = []
WinkelResultierende = []


print ("Wie viele Kräfte möchten Sie addieren?")
number = int (input("Anzahl der Kräfte?  (3~6)"))
if number >= 3:
    print ("Addition von 3 Kräften")
    print()
    print("Bitte tragen Sie ihre Kräfte ein")
    print()
    Kraft1 = int (input("F1    ?   "))
    ListeKraftWerte.append(Kraft1)
    print(force.format(force = Kraft1 , F = ListeKraftNummern[:1]))
    Kraft2 = int (input("F2    ?   "))
    ListeKraftWerte.append(Kraft2)
    print(force.format(force = Kraft2 , F = ListeKraftNummern[1:2:]))
    Kraft3 = int (input("F3    ?   "))
    ListeKraftWerte.append(Kraft3)
    print(force.format(force = Kraft3 , F = ListeKraftNummern[2:3:]))
    print()
    Winkel1 = int (input("Winkel zu F1    ?   "))
    ListeKraftWinkel.append(Winkel1)
    print(tangle.format(tangle = Winkel1 , F = ListeKraftNummern[:1]))
    Winkel2 = int (input("Winkel zu F2    ?   "))
    ListeKraftWinkel.append(Winkel2)
    print(tangle.format(tangle = Winkel2 , F = ListeKraftNummern[1:2:]))
    Winkel3 = int (input("Winkel zu F3    ?   "))
    ListeKraftWinkel.append(Winkel3)
    print(tangle.format(tangle = Winkel3 , F = ListeKraftNummern[2:3:]))

    #print (ListeKraftWerte)
   

    #Bogenlängen
    BogenlängeKraft1 = (Winkel1/180*pi)
    ListeBogenlängenKräfte.append(BogenlängeKraft1)
    BogenlängeKraft2 = (Winkel2/180*pi)
    ListeBogenlängenKräfte.append(BogenlängeKraft2)
    BogenlängeKraft3 = (Winkel3/180*pi)
    ListeBogenlängenKräfte.append(BogenlängeKraft3)

    #print (ListeBogenlängenKräfte)

    #X-Achsen-Kräfte
    Kraft1xAchse = Kraft1 * cos(BogenlängeKraft1)
    ListeKraftXAchse.append(Kraft1xAchse)
    Kraft2xAchse = Kraft2 * cos(BogenlängeKraft2)
    ListeKraftXAchse.append(Kraft2xAchse)
    Kraft3xAchse = Kraft3 * cos(BogenlängeKraft3)
    ListeKraftXAchse.append(Kraft3xAchse)



    SummenKraftxAchse = Kraft1xAchse + Kraft2xAchse + Kraft3xAchse
    SummenKraftxAchse = round (SummenKraftxAchse,2)
    SummeKraftxAchse.append(SummenKraftxAchse)
    print(KraftxAchse.format(SummeKraftX = SummeKraftxAchse[:1]))
    print()

    #Y-Achsen-Kraft
    Kraft1yAchse = Kraft1 * sin(BogenlängeKraft1)
    ListeKraftYAchse.append(Kraft1yAchse)
    Kraft2yAchse = Kraft2 * sin(BogenlängeKraft2)
    ListeKraftYAchse.append(Kraft2yAchse)
    Kraft3yAchse = Kraft3 * sin(BogenlängeKraft3)
    ListeKraftYAchse.append(Kraft3yAchse) 

    SummenKraftyAchse = Kraft1yAchse + Kraft2yAchse + Kraft3yAchse
    SummenKraftyAchse = round (SummenKraftyAchse,2)
    SummeKraftyAchse.append(SummenKraftyAchse)
    print(KraftyAchse.format(SummeKraftY = SummeKraftyAchse[:1]))
    print()
           

    resultierendeKraft = (math.sqrt(SummenKraftyAchse**2+SummenKraftxAchse**2))
    resultierendeKraft = round (resultierendeKraft,2)
    ResultierendeKraft.append(resultierendeKraft) 
    print(resultierende.format(resultierendeKraft = ResultierendeKraft[:1]))


    arcWinkel = (atan(SummenKraftyAchse/SummenKraftxAchse))
    Winkel = (arcWinkel*180/pi)
    Winkel = round(Winkel,2)
    WinkelResultierende.append(Winkel)

    if SummenKraftyAchse > 0 and SummenKraftxAchse > 0:
        print(WinkelResultierendeKraft.format(WinkelResultierende =  Winkel))
    elif SummenKraftxAchse < 0 and SummenKraftyAchse > 0:
        Winkel = (Winkel+180)
        print(WinkelResultierendeKraft.format(WinkelResultierende =  Winkel))
    elif SummenKraftyAchse < 0 and SummenKraftxAchse > 0:
        Winkel = (Winkel+360)
        print(WinkelResultierendeKraft.format(WinkelResultierende =  Winkel))
    elif SummenKraftyAchse < 0 and SummenKraftxAchse < 0:
        Winkel = (Winkel+180)
        print(WinkelResultierendeKraft.format(WinkelResultierende =  Winkel))
    print()
    print("Zum Beenden drücken Sie bitte eine beliebige Taste")
    input ()    

[__blackjack__]

@cck1989: Umwandlung in eine EXE ändert nichts daran das man Konsolenprogramme in einer Konsole startet und deshalb diese beiden Zeilen nicht benötigt.

Grundatentypen haben nichts in Namen zu suchen und auch der Kommentar ``# Listen`` bringt dem Leser nicht wirklich etwas. Es gibt auch immer noch nummierte Namen, was nicht sein sollte. Die Listen werden auch nicht wirllich verwendet, jedenfalls nicht richtig. Denn auch diese ganzen Indexwerte und „slices“ mit den festen Zahlen sind ja letztlich nichts anderes als nummierte Namen.

`ListeKraftNummern` ist unsinnig. In die meisten anderen Listen werden entweder mehrere Werte gesteckt, und die Liste wird danach zu überhaupt nichts verwendet, oder es wird nur *ein* Wert in eine *Liste* gesteckt. Und dann auch noch per „slicing“ in eine neue Liste kopiert die auch nicht wirklich sinnvoll verwendet wird. WTF‽

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase).

`round()` verwendet man, wenn man tatsächlich mit einem gerundeten Ergebnis weiterrechnen will. Und wenn man verstanden hat *wie* `round()` rundet und man dieses Verhalten auch wirklich haben möchte. Wenn man Ausgaben auf eine Anzahl von Nachkommastellen beschränken möchte, macht man das über die entsprechenden Formatangaben.

Du solltest Dir zusammen mit den Listen mal Schleifen anschauen.

[cck1989]

Danke _Blackjack_, dann werde ich mich damit nochmal befassen

[peachli]

Meine Antwort ist zwar Offtopic, aber vielleicht hilft es dir.
Ich weiß zwar nicht, ob du diese Berechnung als Übung machst, um in Python hereinzukommen oder ob du mit Python dieses Problem lösen möchtes.
Falls das zweite der Fall ist, kannst du es mit einer Programmiersprache versuchen die viel besser und viel einfacher ist.

Schau dir dafür mal P5.js an, also Java Script, dort gibt es Funktionen mit denen du mit sehr wenig Code Vektoren hoch und runter addieren, subtrahieren, Kreuz- und Skalarprodukte bilden kannst. Das Schöne daran ist, dass du das Ganze auch sofort flüssig im Browser sofort ausführen und mit schöner Grafik visualisieren kannst.

[cck1989]

Danke peachli,
Ich habe dieses Script einfach nur erstellt um ein wenig in Python und seine Möglichkeiten rein zu kommen. Wollte nur, da ich gerade in dem Thema der Kräfteberechnung bin, mir da ein wenig was schreiben, wo ich weiß was als Ergebnis erwartet wird, um somit sehen zu können ob das was ich schreibe plausibel ist. Wiederum soll man die Formatierung ausser acht lassen, da ich in diesen Thema noch nicht so drin stecke, denke mal das ich da noch rein komme.

Aber danke für deinen Hinweis, werde da trotzdem mal schauen

[sparrow]

Falls das zweite der Fall ist, kannst du es mit einer Programmiersprache versuchen die viel besser und viel einfacher ist. [...] Java Script

Das halte ich mal für ein haltloses Gerücht.

[__blackjack__]

Wobei P5.js ja nicht gleichzusetzen ist mit JavaScript. Die Vectorrechnung wird ja nicht durch JavaScript so einfach, sondern wegen dieser Bibliothek. Dadurch wird die Programmiersprache JavaScript nicht besser und/oder einfacher.

[cck1989]

Du solltest Dir zusammen mit den Listen mal Schleifen anschauen.

while-schleifen sind dann dazu das RIchtige?

[__deets__]

Nein. for-Schleifen.

Code: Alles auswählen

for ding in liste_von_dingen:
...

zB.

[cck1989]

Habe jetzt nochmal ein wenig probiert,
bin jetzt zu diesem Anfang gekommen.
der erste teil Klappt, sodass wenn ich auf diesn

"n = int(input("Wie viele Kräfte sollen addiert werden?"))"

die zahl 3,4 oder 5 eingebe, er mich auch jeweils nach der Anzahl der Kräfte fragt dieses klappt auch in Teil 2 beim Winkel,
diese Werte werden aus fleißig in einer Liste "list_force" gespeichert, lassen sich auch fein mit print(list_force[0][0] usw.... ansprechen.

Jetzt benötige ich beim nächsten Schritt ein wenig Unterstützung, nämlich jetzt sollen.

alle Einträge der Liste "list_force" die für den Input "Betrag der Kraft F%d: " eingetragen sind sollen mit den Cosinus und Sinus der einzelnen zugehörigen Winkeln multipliziert werden.

z.B

Kraft " 1 * cos Winkel "1"
usw….
dasselbe mit dem Sinus

Wenn ich z.b 3 Kräfte (1,2,3) und 3 Winkel (1,2,3) habe, dann sieht die list_force folgendermaßen aus: list_force = [2,3,4],[2,3,4] wie kann man das automatisieren, das die 2 aus dem ersten Block mit dem Sinus und Cosinus mit dem ersten Element des 2ten Blockes multipliziert wird

einzeln lass die sich ansprechen: print(list_force[0][0] …… [0][1]…… usw... aber die Anzahl verändert sich mit der Eingabe des ersten Inputs, wieviele Kräfte addiert werden sollen.
Stehe dort auf dem Schlauch.... kann in den Grundlagen nichts Gescheites finden.


wie lässt sich das realisieren?

Code: Alles auswählen

# Rechnerische Addition von Kräften
import math
from math import pi
from math import sin
from math import cos
from math import atan

list_force = []

n = int(input("Wie viele Kräfte sollen addiert werden?"))
print()
print ("Bitte tragen Sie Ihre Kräfte ein.")
print()
inputs = [int(input("Betrag der Kraft F%d: " %i))
for i in range(1 , n+1)]
list_force.append(inputs)
print()
print ("Bitte tragen Sie die Winkel zu den Kräften ein")
print()
tangle = [int(input("Winkel zu Kraft F%d: " %i))
for i in range(1, n+1)]
list_force.append(tangle)

[__blackjack__]

@cck1989: Ich würde sagen die Antwort ist immer noch: Lerne mit Listen umzugehen. Und vergiss dabei erst einmal irgendwas mit festen Indexwerten wie ``print(list_force[0][0] …… [0][1]……``.

Was enthält `list_force` denn eigentlich? Das macht doch so überhaupt keinen Sinn. Weder der Name, noch wie das da gespeichert ist. Wenn Kraft und Winkel zusammengehören, sollte das auch zusammen gespeichert werden. Also jede Kraft mit dem dazugehörigen Winkel. Und das dann am besten als Tupel oder noch besser als `collections.namedtuple`.

Grunddatentypen haben in Namen nichts zu suchen.

[Sirius3]

Ein Kraft besteht bei Dir aus Betrag und Winkel, diese beiden Informationen sollten immer zusammen bleiben und auch zusammen abgefragt werden. Das ist ja schon für den Nutzer umständlich, erst alle Beträge eintippen zu müssen, und dann sich daran zu erinnern, bei welcher Kraft welcher Winkel galt.
`list_force` enthält dann bei Dir fix zwei Elemente, damit ist das keine Liste, sondern nur zwei Werte irgendwie zusammengepackt, die nichts miteinander zu tun haben (Winkel und Beträge). Du brauchst also eine Datenstruktur, die zwei Werte aufnehmen kann (das ist ein Tuple) und eine Liste, die jeweils für jede Kraft in solches Tuple enthält.
Statt list_force nennt man das einfach forces; am Plural erkennt der Leser, dass es sich um ein Objekt handelt, dass mehrere Kräfte enthalten kann (was Du ja bei `inputs` schon genau so gemacht hast, wobei inputs nicht erkennen läßt, dass eigentlich Beträge enthalten sind).

[cck1989]

@Sirius3, ich habe den Code ein wenig geändert

[code]
# Rechnerische Addition von Kräften
import math
from math import pi
from math import sin
from math import cos
from math import atan

forces = []

n = int(input("Wie viele Kräfte sollen addiert werden?"))
print()
print ("Bitte tragen Sie Ihre Kräfte ein.")
print()
force = [int(input("Betrag der Kraft F%d: " %i))
for i in range(1 , n+1)]
forces.append(force)
print()
print ("Bitte tragen Sie die Winkel zu den Kräften ein")
print()
tangle = [int(input("Winkel zu Kraft F%d: " %i))
for i in range(1, n+1)]
forces.append(tangle)
forces = tuple(forces)
print(forces)[/code]

wie bekomme ich die Kraft und den Winkel zusammen?

Die Ausgabe sieht bei mir so aus
[img]https://de.share-your-photo.com/c2cb8884ac[/img]

Auf dem Bild erkennt man in der Zeile "print(Forces)" das alle Werte die zur Kraft eingetragen wurden mit einer [ ] eingefasst sind, ebenso die 3 Werte für den Winkel. bekommt man das weg? oder wie muss ich das machen das ich die Kraft mit dem dazugehörigen Winkel zusammen bekomme?


Hatte hierzu auch noch einen anderen Code, wo ich nochmal was anderes ausprobiert habe, kann man damit etwas anfangen?

[code]
# Rechnerische Addition von Kräften
import math
from math import pi
from math import sin
from math import cos
from math import atan

a = []

n = int(input("Wie viele Kräfte sollen addiert werden?"))

for i in range(1, n+1):
a.append(int(input("Wert für Kraft F%d? " %i)))
a.append(int(input("Winkel zur Kraft F%d? " %i)))

a = tuple(a)

print(a)



[/code]

[Caskuda]

@cck1989:

Code: Alles auswählen

kraefte_und_angriffswinkel = list(zip(forces,tangle))

wäre eine Möglichkeit Tupel, also Kraft - Winkel - Paare, aus deinen beiden Listen zu erzeugen.
Die Werte lassen sich dann jedoch nicht mehr verändern.

Alternativ:

Code: Alles auswählen

kraefte_und_angriffswinkel = [[kraft,winkel] for kraft, winkel in zip(forces, tangle)]

Erzeugt eine Liste von Listen mit je zwei Elementen. Hier könntest du die Wertepaare überschreiben.

Ausgabe:

Code: Alles auswählen

for kraft, winkel in kraefte_und_angriffswinkel:
	print(f'Kraft {kraft}, Winkel {winkel}')

Worauf Sirius hinaus möchte geht in folgende Richtung:

Code: Alles auswählen

anzahl_eintraege = int(input("Anzahl nachfolgender Messwerte: "))
kraefte_und_angriffswinkel = list()

for _ in range(anzahl_eintraege):
    kraft = input('Betrag der Kraft: ')
    winkel = input('Betrag des zugehörigen Winkels: ')
    kraefte_und_angriffswinkel.append((kraft, winkel))

for kraft, winkel in kraefte_und_angriffswinkel:
	print(f'Kraft {kraft}, Winkel {winkel}')

Kraft und Winkel kommen als Paar vor. Also lege sie direkt zusammen ab, anstatt zunächst zwei Listen zu erstellen, welche du anschließend zusammenführen musst.

@Sirius3:
Freue mich ebenfalls über Verbesserungsvorschläge.

[cck1989]

@Caskuda: Danke. Das mit dem ZIP habe ich auch schon gelesen, aber stieg da nicht so durch. Werde mich mal probieren.
Danke für die Hilfestellung, werden wohl noch mehr fragen kommen, war noch nicht alles. Kommen leider noch paar rechen-Operationen.

Ich melde mich

[Caskuda]

@cck1989:
zip ist eine wunderschöne Funktion, um Listen zusammenzufassen, allerdings bin ich selbst noch weit davon entfernt alle Finessen zu meistern.

Vermutlich wirst du dir die math.radians() - Methode ansehen wollen, um die Winkel in Bogenmaß zu bekommen.

Es ist eine Weile her, aber du willst die Kraft jeweils in eine X- und Y-Achsen Projektion aufteilen?