Input sowohl string als auch int möglich?

[ebassti]

Hallo Zusammen,

ich habe ein kleines unausgereiftes Programm geschrieben, welches mit verschiedenen Eingaben(alles Zahlen) und Matrizen was errechnet. Jetzt würde ich den ganzen Code gerne auch in Abhängigkeit des Entwurfsparameters L(änge) weiterführen, um später einen Plot zu haben der das Ergebnis in ein Verhältnis mit dem Entwurfsparameter L bringt.
Dabei komme ich schon bei dem Errechnen des Winkels mittels "ß=math.atan(L/1.5*L)" an meine Grenzen, da L ja jetzt nicht mehr definiert ist und eine bestimmte Länge hat.
Danach ist mein Ziel einen Input zu machen, in dem man sowohl L als Variable, als auch eine Zahl für die Länge eingeben kann.
Nach dem Motto "Gebe deine gewünschte Entwurfsgröße ein:" .
Vielleicht versteht ja einer mein Problem
Danke auf jeden Fall schon mal!

Grüße ebassti

[Sirius3]

@ebassti: ich versteh Dein Problem nicht. Du hast eine Länge L, die ist aber nicht definiert, hat trotzdem eine Länge? Häh? Versuch mal Deine Frage zu strukturieren. Was ist gegeben? Was ist gesucht? Wie hast Du versucht, das Ziel zu erreichen? Welche Probleme sind dabei aufgetreten?

[Zizibee]

Den ersten Teil deiner Beschreibung versteh ich nicht, der zweite klingt aber ein bisschen so, als würdest du ein dictionary suchen...

[noisefloor]

Hallo,

in dem man sowohl L als Variable, als auch eine Zahl für die Länge eingeben kann

Die Länge ist doch eine Variable...

Wenn du im Verlauf des Programms `L` an zwei unabhängigen Stellen brauchst und z.B. bei dem einen den original Wert von `L`, bei dem anderen aber mit `L`rechnest und damit `L`änderst, musst du halt _vorher_ `L` in einen weitere Variable kopieren. Dazu gibt's das `copy` Modul.

Gruß, noisefloor

[ebassti]

Sorry,

Ich versuch's nochmal;)
Ich habe bisher eine Länge L einfach per Input abfragen lassen, um später durch Matrizenrechnung auf eine Verschiebung des Systems zu kommen. In den Matrizen stehen Steifigkeiten einer Brücke. Also will ich als Zielgröße die Verschiebung an bestimmten Stellen haben.
Dazu habe ich Steifigkeitsmatrizen implementiert, die abhängig von L sind.

Jetzt möchte ich den ganzen Code so abändern, dass man sowohl ein L eingeben kann, um eine bestimmte Verschiebung zu erhalten, als auch ein L als Unbekannte. Das Ergebnis kann dann sowohl einen Wert haben, als auch immer noch abhängig von L ausgegeben werden.
Ich hoffe jetzt ist es klarer.

Grüße ebassti

[BlackJack]

@ebassti: Ein bisschen klarer, aber IMHO immer noch nicht so wirklich ganz. Sagen wir mal der Benutzer gibt für die Länge 5 ein, dann würde Dein Programm für β so ungefähr 1,51 ausgeben. Aber wie sieht denn die gewünschte Ausgabe aus wenn der Benutzer statt dessen 'L' eingibt? Da kann man ja kein konkretes β ausrechnen‽

[ebassti]

Schlussendlich will ich die Brücke ja optimieren anhand des Eingabeparameters L.
Somit bräuchte ich das ganze immer noch abhängig von dem Parameter am Ende meines Codes, um damit dann einen plot oder weitere Berechnungen durchzuführen.
Also sowohl in der Winkelberechnung, als auch in den Matrizen die multipliziert werden.
Bei ß=atan(L/1.5L) müsste sich ja auch einfach das L herauskürzen, oder ich kürze es einfach gleich raus. Aber im weiteren Verlauf kommen Steifigkeiten der Brücke, die den Faktor 1/L^2 beinhalten vor. Da kann ich in den Matrizen L nicht herauskürzen.

Grüße ebassti

[BlackJack]

@ebassti: Mir ist immer noch nicht klar was Du als Ergebnis haben möchtest. Was ist denn „das ganze” was Du haben haben willst nachdem der Benutzer 'L', also den Namen und keine Zahl, eingegeben hat und wie unterscheidet sich das von dem was Du hattest bevor er 'L' eingegeben hat?

Letztendlich hast Du doch eine Funktion wo `L` als Argument vorkommt, und da wirst Du um einen konkreten Wert auszurechnen immer eine Zahl für übergeben müssen. Und die gibt der Benutzer entweder ein, oder eben nicht. *Dann* ist die Frage wo die konkreten Zahlen die dafür eingesetzt werden, denn herkommen sollen wenn der Benutzer keine konkrete Zahl eingibt. Wenn da ein Plot in Abhängigkeit von dem Wert erstellt werden soll, dann muss die Funktion mit vielen Werten für L aufgerufen werden um die nötigen Datenpunkte zu bekommen. Also hätte man in dem Fall einen Bereich von Eingabewerten und die Frage ist wie der bestimmt wird. Kann man den Bereich vom Benutzer als Unter- und Obergrenze und eventuell Anzahl oder Schrittweite abfragen? Oder lässt der sich anders bestimmen oder berechnen?

Den Benutzer eine Zahl oder einen String eingeben zu lassen macht also nicht wirklich Sinn, weil zum Rechnen für konkrete Einzelwerte oder Werte für einen Plot, immer konkrete Zahlen als Eingabe für die Funktion(en) benötigt werden. Es ist also eher die Wahl zwischen: der Benutzer gibt ein konkretes L als Zahl ein oder entweder nichts, und die sinnvollen Werte für `L` können irgendwie berechnet werden, oder der Benutzer gibt den Wertebereich für `L` ein. Was man zu Wertebereich für `L` vereinfachen kann, denn ein konkreter Einzelwert ist ja das gleiche wie die gleiche Unter- und Obergrenze festzulegen und nur einen Schritt zu berechnen.

[kbr]

@ebassti: So wie ich es jetzt verstanden haben, hast Du L an vielen Stellen in Deiner Berechnung drin. Wenn Du L überall herauskürzen könntest, wäre die Aufgabe sinnlos, da diese dann keine Funktion von L mehr wäre. Also musst Du einen Wert für L eingeben. Dann kommt auch irgendetwas als Resultat raus. Nun kannst Du diese Berechnung für viele Werte von L wiederholen und die Variation des Resultats betrachten. Das kannst Du dann interpretieren. Vielleicht ist es das was Du meinst – so richtig klar ist mir das nicht. Wichtig ist: erst wenn Du Dein Problem wirklich klar beschreiben kannst, kannst Du es auch lösen.

[ebassti]

Was ist denn „das ganze” was Du haben haben willst

Nach der Eingabe rechnet mein Programm mittels Steifigkeiten die Verschiebungen an einer Brücke aus. Abhängig von den Längen der jeweiligen Felder entstehen verschiedene Verschiebungen. Diese will ich optimieren, also am besten nach der (von L abhängigen) Berechnung mit verschiedenen Kombinationen (Verhältnis L1 zu L2, und L=1-100m usw) testen.

Durch eure Kommentare bin ich jetzt schon so viel schlauer, dass ich gecheckt habe, dass ich auch einfach einen linspace mit Anfangs/Endwert erstellen lassen kann und danach einfach mit einer Schleife durch meine Berechnung gehen kann (ohne erst am Schluss zu testen). Die Schleife muss dann aber z.B über alle Elemente im linspace laufen und auswerten.
Ich kenn's nur aus MATLAB, in Python geht das ganze bisschen anders oder? Was nehme ich da als Laufvariable?

Wichtig ist: erst wenn Du Dein Problem wirklich klar beschreiben kannst, kannst Du es auch lösen.

Das ist mir mittlerweile auch klar geworden

Danke euch

[BlackJack]

@ebassti: Wenn Du `numpy.linspace()` verwendest, dann brauchst Du ja ziemlich sicher keine Schleife in Python sondern nimmst statt *eines* Wertes das Array das `linspace()` liefert. Also zumindest wenn Dein Code so geschrieben ist, dass das geht.

[beertonic]

In Python brauchst du keine Laufvariable um durch eine Liste zu iterieren.

Code: Alles auswählen

for wert in liste:
		rechne
		...

Und für linspace muss du numpy importieren. Ansonsten sollte es kein Problem für dich sein wenn du es in Matlab hinkriegst.
Wenn du noch Fragen hast poste doch mal deinen Code.

[ebassti]

Ansonsten sollte es kein Problem für dich sein wenn du es in Matlab hinkriegst.

Anscheinend schon.

Der letzte Abschnitt meines Codes, bei dem die Matrixmultiplikation usw. stattfindet:

Code: Alles auswählen

L=np.linspace(0.5,30, num=60)
yxc=[]
for länge in L:    
    K[0,0]=k2a[4,4]+ k_global[1,1]+ k2b[1,1]   #Alle Matrizen abhängig von L
    K[1,1]=k2a[5,5]+k2b[2,2]
    K[1,0]=k2a[4,5]+k2b[1,2]
    K[0,1]=k2a[5,4]+k2b[2,1]
    
    F[0]=f2a[4]+f2b[1]
    F[1]=f2a[5]+f2b[2]
    
    Kinv=np.linalg.inv(K)
    U=np.dot(Kinv,F)
    
    yxc.append(U)
  

Eigentlich will ich am Schluss U mit L plotten, aber soweit komme ich nicht mal.
Es werden jedesmal die neuen Einträge den Matrizen hinzugefügt, anstatt immer nur für jede Schleife abzufragen, was die Werte der Matrix für das jeweilige L sind.

[BlackJack]

@ebassti: Du hast eine Schleife über `L` und bindest jeden Wert aus `L` an den Namen `länge`. Nur verwendest Du `länge` dann *in* der Schleife überhaupt nicht. Wenn Du irgend etwas in Abhängigkeit von diesem Wert berechnen willst, dann musst Du den doch auch irgendwie in der Rechnung verwenden‽ Ansonsten berechnest Du da 60 mal einfach immer nur das gleiche (sofern ich ich nicht irgendeine Abhängigkeit übersehen habe die eine Rückkopplung zur Folge hat).

[beertonic]

Code: Alles auswählen

for länge in L:    
    K[0,0]=k2a[4,4]+ k_global[1,1]+ k2b[1,1]   #Alle Matrizen abhängig von L
    ...

Das verstehe ich nicht ganz. Was willst du mit "länge" machen? Jetzt sieht es so aus als würdest du jeden Schleifendurchlauf das gleiche machen.

[ebassti]

Jetzt sieht es so aus als würdest du jeden Schleifendurchlauf das gleiche machen

Genau. An sich mache ich immer das gleiche nur jedes Mal mit anderen Längen, um später die unterschiedlichen Ergebnisse mit den Längen in Beziehung setzen zu können. Es kommen dann Verschiebungen meines Systems raus, welche eben abhängig von den Längen der einzelnen Elemente sind.
Andere Frage an der ich jetzt seit Freitag sitze:

Wenn ich mit sympy arbeite und am Schluss gern ein Ergebnis in einer Variablen gespeichert bekommen würde...wie geht das?
Mein p wird nie eingespeichert, sondern nur durch print() ausgegeben.
Einfaches Beispiel:

Code: Alles auswählen

from sympy import *
x = Symbol('x',real=True)
y = -x**2
yprime = y.diff(x)
p=solve(yprime,x)
print(solve(yprime,x))

[kbr]

An sich mache ich immer das gleiche nur jedes Mal mit anderen Längen, um später die unterschiedlichen Ergebnisse mit den Längen in Beziehung setzen zu können.

Genau das machst Du nicht. Was Du tun musst, ist etwas in der Form:

Code: Alles auswählen

for laenge in laengen:
    result = function(laenge)

Das kommt bei Dir aber nicht vor.

[BlackJack]

@ebassti: Beim `sympy`-Beispiel musst Du vielleicht noch mal deutlicher sagen was Du erwartest und was statt dessen passiert. Denn `p` wird durchaus an die Lösung gebunden, also an genau den gleichen Wert den Du in der nächsten Zeile mit `print()` ausgibst.

[beertonic]

Code: Alles auswählen

p=solve(yprime,x)
print(solve(yprime,x))

Speicher das ganze in einer Liste:

Code: Alles auswählen

liste.append(p)