interne Befehlsausführung

[Domperle]

Hallo,
ich habe ein ganz ungewöhnliches Anliegen.
Um moderner zu werden schreibe ich Programme, die ich einmal in Rexx geschrieben habe nach Python um.
Bei der CNC-Programmierung von der HEIDENHAIN-Steuerung gibt es um einen Kreis zu fräsen folgenden Befehl:

CR X+50 Y+45 R+Q30 DR- F20
Q30 wird über eine Parameterdatei geliefert in folgender Form Q30=20.
Um der Wert 20 in Q30 zu bekommen gibt es in Rexx den Befehl 'Interpret', der intern die Zuweisung der 20 nach Q30 durchführt.
Die Frage ist nun:
Gibt es in Python eine solche Möglichkeit der internen Befehlsausführung?

[noisefloor]

Hallo,

Um moderner zu werden schreibe ich Programme, die ich einmal in Rexx geschrieben habe nach Python um.

Musste erst Mal googlen, was Rexx ist - ok, letzte Version ist von 1996. Damals habe ich meine HP48G programmiert.

Ich verstehe dein Frage nicht wirklich... was meinst du mit "interne Zuweisung" genau?

In Python gibt es jedenfalls Dictionaries, die Schlüssel-Werte-Paare abbilden:

Code: Alles auswählen

>>> d =  {}
>>> d['d30']=20
>>> d['foo']='bar'
>>> d
{'d30': 20, 'foo': 'bar'}
>>> d['d30']
20
>>>

Dicts gehören zu den grundlegenden Datenstrukturen in Python. Falls du Dicts noch nicht kennst wäre jetzt eine gute Gelegenheit, das Python Tutorial durchzuarbeiten: https://docs.python.org/3/tutorial/index.html

Gruß, noisefloor

[__blackjack__]

@Domperle So etwas hat in sauberen Programmen nichts zu suchen.

@noisefloor: Das ist die Frage nach ”berechneten Variablen” oder noch allgemeiner: wie führe ich den Inhalt dieser dynamisch zusammengefrickelten Zeichenkette aus als wäre sie Python-Code der genau hier steht.

[nezzcarth]

Für mich klingt das so, als versucht du im Prinzip eine Art Konfigurationsdatei einzulesen, richtig? Es gibt mehrere Möglichkeiten, das in Python zu bewerkstelligen. Eine gängige Variante wäre, dass du eines der dafür geeigneten Module aus der Standardbibliothek verwendest, z.B. configparser. Das liefert dir die enthaltenen Werte dann, ähnlich wie noisefloor auch schon meinte, als Objekt bzw. in einer geeigneten Datenstruktur.

Außerdem sollte man möglichst sprechende Namen verwenden; Q30 usw. ist komplett kryptisch.

[noisefloor]

Hallo,

Q30 usw. ist komplett kryptisch.

Wobei Programm für CNC Maschinen je nach Maschine bzw. Sprache, die die Maschine versteht, schon so aussehen (können).

Was natürlich nicht heißt, dass man sein Variablen in Python so benennen sollte

Gruß, noisefloor

[Domperle]

hey noisefloor, nezzcarth,

was die Q-Prameter betrifft, so bin ich an die CNC-Steuerung gebunden., in diesem Fall(Heidenhain). Siemens , Mazack usw. haben hierfür wahrscheinlich andere Bezeichnungen.
Da ich den Steuerungscode von Heidenhain in eine andere in CNC-Steuerung konvertiere brauche ich den tatsächlichen Wert des Q-Parameters.
Ich lese also aus meiner Parameterdatei den string ' Q30 = 20' ein.
Wenn ich jetzt Q30 ausgebe so steht in Q30 logischer weise nichts drin
in Rexx führe ich jetzt folgenden Befehl aus:
interpret 'Q30 = 20'
Wenn ich jetzt Q30 ausgebe so steht in Q30 die 20.
Eine solche Möglichkeit brauche ich jetzt in Python.
Ich hoffe, ich habe es jetzt etwas verständlicher beschrieben

[sparrow]

@Domperle: Das wird so nichts. Du musst dich davon trennen, was du bereits kennst. Denn sonst ist die Antwort eigentlich ziemlich logisch: Nimm dieses Rexx. Wenn es genau alles so macht, wie du möchtest, dann ist das die ideale und naheliegende Wahl.

Ansonsten musst du einen Schritt von deinem Problem zurück treten und erklären, was du tun willst. Also der größere Prozess drumherum. Woher kommen Daten, wohin sollen die, was wird damit gemacht, etc. Nicht der detaillierte Vorgang im Detail, dessen Lösung, die dir vor schwebt, falsch ist (weil unter falschen Annahmen getroffen).

[__blackjack__]

@Domperle: Im Grunde hat noisefloor schon die Antwort gegeben: Wörterbücher. Und Du musst die eingelesene Zeile halt selbst entsprechend verarbeiten.

Code: Alles auswählen

#!/usr/bin/env python3


def main():
    key_to_value = {}

    line = "Q30 = 20"
    key, equals, value_text = line.partition("=")
    if equals != "=":
        raise ValueError(f"expected '=' in {line!r}")

    key_to_value[key.strip()] = int(value_text)

    print(key_to_value)
    print(key_to_value["Q30"])


if __name__ == "__main__":
    main()

Statt `key_to_value`, `key` nach Möglichkeit treffendere Namen wählen.

Ausgabe:

Code: Alles auswählen

{'Q30': 20}
20

[Domperle]

Das ist ja nicht schlecht!!!
Also baue ich mir einen eigenen "interpret" Befehl
Vielen Dank an alle, besonders an _blackjack_ für Eure Unterstützung.
An sparrow noch eine kleine Anmerkug: 1. möchte ich moderner werden, zum 2. Rexx ist auch eine Interpretersprache, gibt mir aber nicht die Möglichkeit eine .exe zu erstellen und 3. habe ich festgestellt, daß Python Möglichkeiten bietet, die Rexx eben nicht hat und das mit wesentlich weniger code.

[noisefloor]

Hallo,

Also baue ich mir einen eigenen "interpret" Befehl

Nein, du nutzt ein Dictionary. Da ist etwas _sehr_ anderes, als eine "interpret" Befehl nachbauen. Das Ergebnis mag für dich das gleiche sein, aber der Weg ist sehr anders.

gibt mir aber nicht die Möglichkeit eine .exe zu erstellen

#
Kann Python auch nicht, jedenfalls nicht mit Bordmitteln. Der der Bytecode von Python zur Laufzeit interpretiert wird geht das auch nicht so wie bei kompilierenden Sprachen. Es gibt Tools, um ausführbare Dateien mit Python Programmen zu erzeugen. Da wird aber die komplette Laufzeitumgebung und alle zugehörigen Module in einer ausführbare Datei verpackt. Da ist vom Prinzip komplett anders, als wenn du z.B. ausführbare Dateien mit Go oder Rust oder C oder so erstellst.

Gruß, noisefloor

[nezzcarth]

Also baue ich mir einen eigenen "interpret" Befehl

Nein. 'Interpret' ist ja scheinbar Rexx' Gegenstück zu eval, also eine Möglichkeit, eine Zeichenkette als validen Code der Programmiersprache auszuwerten/auszuführen. Und diese Vorgehensweise gilt (zumindest als Faustregel für 99% aller Fälle, in denen man im ersten Moment auf die Idee kommt, so etwas zu brauchen) als absolut nicht empfehlenswert, schlechter Stil und gefährlich. Zumal es bessere Alternativen gibt. Zum Beispiel, in dem du deine "Parameterdatei" in ein gängiges Konfigurationsformat bringst und mit einem existierenden Parser auswertest oder eben – notfalls – selbst ausliest und in einer geeigneten Struktur ablegst.

[noisefloor]

Das E-Wort ging mir beim Verfassen meines Post von 13.27 auch durch den Kopf - konnte aber unterdrücken, es zu schreiben

Gruß, noisefloor

[Domperle]

Ich beschäftige mich immer noch mit meinem s.g. INTERPRET-Befehl aus Rexx.
Zur Anmerkung: Ich bin totaler Anfänger, was Python betrifft, somit sind mir manche Sachen noch nicht so klar.
Nun habe ich folgendes entdeckt:

a = Tab_99[18]"
exec(a)
print(Q80)
>>> 3

Das wäre genau das was ich erreichen möchte.
Nun habe ich aber alle Q-Werte in nachfolgender Tabelle:
{0: 'Q32 = 3 ', 1: 'Q33 = 5 ', 2: 'Q34 = 63 ', 3: 'Q35 = 55 ', 4: 'Q36 = 100 ', 5: 'Q39 = 0 ', 6: 'Q45 = 2 ', 7: 'Q46 = 0 ', 8: 'Q47 = 25 ', 9: 'Q50 = 120 ', 10: 'Q51 = 10 ', 11: 'Q52 = 20 ', 12: 'Q53 = 59.5 ', 13: 'Q54 = 49.5 ', 14: 'Q55 = 1 ', 15: 'Q64 = 1 ', 16: 'Q68 = 100 ', 17: 'Q69 = 800 ', 18: 'Q80 = 3 '}
Ich möchte nun, dass in einer for-Schleife alle Tabellenplätze durchlaufen werden und der jeweilige Q-Wert gesetzt wird., also wenn ich z.B. Q33 benötige so erhalte ich die 5 oder Q53 benötige so erhalte ich den Wert 59.5.
Bisher ist mir das noch nicht gelungen.

[Domperle]

Noch eine kleine Anmerkung: Wie kann ich den Programmcde so darstellen wie unter 'Code: Alles auswählen'

[sparrow]

Nimm einfach ein Python dict, dann funktioniert das einfach so und du musst gar nichts durchlaufen.

Code: Alles auswählen

values = {'Q32': 3, 'Q33': 5, ...}
print(values['Q32'])

Zur Anmerkung: code tags
Die ercheinen automatisch, wenn du in "Vollständiger Editor & Vorschau" den </> Button drückst.

Und ich denke auch erneut, dass du mit exec auf dem falschen Weg bist.
Ich habe ja bereits im zweiten Beitrag geschrieben, dass du bei der alten Programmiersprache bleiben solltest, wenn du die nachprogrammieren willst - oder wirklich Python zu programmieren. Aber da besteht wohl wenig Interesse.

[__blackjack__]

@Domperle: Die Tabelle selbst ist schon in der falschen Datenstruktur. Ein Wörterbuch mit von 0 an aufsteigenden, zusammenhängenden Schlüsseln ist kein Wörterbuch, sondern sollte einfach eine Liste sein.

Code: Alles auswählen

In [212]: mapping
Out[212]: 
{0: 'Q32 = 3 ',
 1: 'Q33 = 5 ',
 2: 'Q34 = 63 ',
 3: 'Q35 = 55 ',
 4: 'Q36 = 100 ',
 5: 'Q39 = 0 ',
 6: 'Q45 = 2 ',
 7: 'Q46 = 0 ',
 8: 'Q47 = 25 ',
 9: 'Q50 = 120 ',
 10: 'Q51 = 10 ',
 11: 'Q52 = 20 ',
 12: 'Q53 = 59.5 ',
 13: 'Q54 = 49.5 ',
 14: 'Q55 = 1 ',
 15: 'Q64 = 1 ',
 16: 'Q68 = 100 ',
 17: 'Q69 = 800 ',
 18: 'Q80 = 3 '}

In [213]: list(mapping) == list(range(len(mapping)))
Out[213]: True

Ich würde noch einen Schritt weitergehen als Sparrow: Wenn die Schlüssel *alle* mit einem "Q" anfangen und danach eine Zahl haben, dann sollte das eine Abbildung von diesen Zahlen auf die Werte sein, denn das "Q" ist dann ja redundant.

Code: Alles auswählen

In [218]: q_to_value
Out[218]: 
{32: 3,
 33: 5,
 34: 63,
 35: 55,
 36: 100,
 39: 0,
 45: 2,
 46: 0,
 47: 25,
 50: 120,
 51: 10,
 52: 20,
 53: 59.5,
 54: 49.5,
 55: 1,
 64: 1,
 68: 100,
 69: 800,
 80: 3}

In [219]: q_to_value[33]
Out[219]: 5

[noisefloor]

Hallo,

Ich beschäftige mich immer noch mit meinem s.g. INTERPRET-Befehl aus Rexx.
Zur Anmerkung: Ich bin totaler Anfänger, was Python betrifft, somit sind mir manche Sachen noch nicht so klar.
Nun habe ich folgendes entdeckt:

Du machst einen ziemlichen Fehler: du lässt dich nicht aus Python ein, sondern versuchst, dass was du aus Rexx kannst, darauf abzubilden. Das wird nicht gut gehen.

Wenn du eine neue Programmiersprache lernst musst du dich auf deren Idiome und "best practice" einlassen, sonst stehst du dir selber im Weg. Wenn man das nicht kann oder will sollte man halt aufhören. Das gilt nicht nur für Python, sondern für jede Programmiersprache.

Gruß, noisefloor

[Domperle]

Hey noisefloor,
was ich nicht so gerne mag, sind Belehrungen oder so gut gemeinte Ratschläge, wobei die Betonung auf Schläge beruht.
Zu meiner Person. Ich bin 78 Jahre alt, komme aus der "alten EDV" nicht aus der "Neuen Welt".
Computersprachen die ich gelernt und mit denen ich Projekte realisiert habe sind:
1968 während meines Studiums Algol
1974 PL/1, Fortran, Assembler
1976 Basic, Cobol
1978 Delphi(Pascal) programmier ich heute noch
1985 Rexx und diverse CNC-Sprachen
2023 Jetzt möchte ich mich in Python einarbeiten
Dass man Parallelen zu bisher Erlerntem zieht ist selbstverständlich. Sind wir in der Software-Entwicklung nicht alle daran interssiert so effizient und elegant wie möglich zu programmieren.

[noisefloor]

Hallo,

Dass man Parallelen zu bisher Erlerntem zieht ist selbstverständlich.

Methodik übertragen ist völlig ok und richtig. Ideome übertragen wollen ist halt falsch.

Und was ich auch immer für eine total schlappe Ausrede halte ist "ich bin X Jahre als, darum muss ich das nicht mehr lernen" oder auch andersherum "ich bin X Jahre alt, ich kann das noch nicht lernen". "Älter" und "anders" sind nicht Synonym. Mal abgesehen davon, dass die nicht weißt, wie alte die anderen so sind, die hier aktiv sind.

Gruß, noisefloor

[snafu]

@Domperle
Idiomatisches Python ist etwas komplett anderes als die Programmierung von Fräsmaschinen. Die von dir angeführten Beispiele zeigen, dass du bisher nicht wirklich Berührungspunkte zu objektorientierter Programmierung hattest. Du bist offensichtlich den prozeduralen Ansatz gewöhnt und denkst relativ "maschinennah". Ob man davon mit 78 Jahren noch wegkommt, möchte ich nicht abschließend beurteilen, bin jedoch skeptisch. Jedenfalls, wenn du nicht bereit bist, dich auf die Sprache Python einzulassen und tatsächlich gute Ratschläge als eine Art von Besserwisserei abtust, dann wirst du hier im Forum auf wenig Gegenliebe stoßen. Und meistens moppern Typen dieser Art ein paar Wochen hier herum und verschwinden dann wieder in der Versenkung. Ich bin gespannt, ob das auch auf dich zutrifft...