Einbindung von Python3 Code in eine bash Datei

[Susann.M.23]

Wie kann ich am Beispiel folgenden Python Codes, in eine bash Datei Python einfügen und das Ergebnis in bash per echo einer Variable ausgeben ? Folgend mein Entwurf:

Python Code, der beispielhaft in unten stehenden bash Code rein soll:

Code: Alles auswählen

# import the random module 
import random 
  
# determining the values of the parameters 
mu = 100
sigma = 50
  
# using the normalvariate() method 
print(random.normalvariate(mu, sigma)) 

Bash Datei Rohling, in den ich gerne als Beispiel für mich, obigen Python Code hätte um das dann für mich als Vorlage für mehrere andere ähnlich gelagerte Fälle nehmen zu können:

Code: Alles auswählen

#!/bin/bash

## Anfang Python Bereich
ausgabewert_des_python_bereichs=$(python -c " hier muss vmtl. irgend wie der Python Code hinein ")

## Ende Python Bereich

echo $ausgabewert_des_python_bereichs

read -p "Zum Beenden Enter drücken oder Ctl + C"

[Susann.M.23]

Nach meinem Versuch und Irrtum Verfahren, ist bei meinem Versuch, Python Code in eine bash Date zu packen und in dieser ein Ergebnis von Python verfügbar zu machen, bzw. aus zu geben, foolgendes bei heraus gekommen:

Code: Alles auswählen

#!/bin/bash

## Anfang Python Bereich
ausgabewert_des_python_bereichs=$(python -c " 

# import the random module 
import random 
  
# determining the values of the parameters 
mu = 100
sigma = 50
  
# using the normalvariate() method 
print(random.normalvariate(mu, sigma)) 

")
## Ende Python Bereich

echo $ausgabewert_des_python_bereichs

read -p "Zum Beenden Enter drücken oder Ctl + C"

Obiges macht erst einmal das was ich möchte. Ist das eher Zufall oder sollte man das lieber irgend wie anders machen ?

Bei der Gelegenheit möchte ich gleich auch noch mal heraus bekommen, wie man das in obigen Fall schreiben müsste, wenn man den Python Code in eine .py Datei packt und diese dann von der Syntax her, von einer bash Datei aufrufen könnte. Dazu habe ich aber bisher noch nichts gefunden.

[__blackjack__]

@Susann.M.23: Kann man so machen, sieht halt etwas sinnfrei und übermässig kompliziert aus. Und ``python`` sollte Python 3 sein. Und das ``read`` am Ende sieht verdächtig überflüssig bis nervig aus. Und `ausgabewert_des_python_bereichs` ist natürlich kein guter Name. Die Kommentare bringen keinen Mehrwert.

Letztlich lässt sich die Funktionalität als "Shell"-Skript auch so ausdrücken (sh reicht, braucht keine Bash zu sein):

Code: Alles auswählen

#!/bin/sh
python3 -c 'import random; print(random.normalvariate(100, 50))'

Und von da ist es dann nur ein kleiner Schritt zu:

Code: Alles auswählen

#!/usr/bin/env python3
import random

print(random.normalvariate(100, 50))

Und schon ist man den zusätzlichen Shell-Prozess auch noch los.

[sparrow]

@Susann.M.23: Warum sollte man Python-Code so in ein bash-Script einbinden? Was ist dein eigentliches Problem und was möchtest du erreichen? Das was du dort mit dem bash-Script tust, ist so als würdest du ein Auto an Moped binden, auf das Moped steigen, damit das Auto ziehen und das dann für Autofahren halten. Könnte sein - für jeden Autofahrer aber klar erkennbar wenig sinnvoll.

[Susann.M.23]

@Susann.M.23: Warum sollte man Python-Code so in ein bash-Script einbinden? Was ist dein eigentliches Problem und was möchtest du erreichen? Das was du dort mit dem bash-Script tust, ist so als würdest du ein Auto an Moped binden, auf das Moped steigen, damit das Auto ziehen und das dann für Autofahren halten. Könnte sein - für jeden Autofahrer aber klar erkennbar wenig sinnvoll.

Ich habe halt ein paar bash Scripte, bei denen ich testweise ein paar Passagen durch .py realisieren möchte. Sozusagen, das Sammeln erster Erfahrungen am lebenden Objekt. Eventuell weite ich das später noch ein wenig aus.

Im Moment suche ich eine Quelle die mir zeigt, wie ich als nächste Realisierungsvariante, py Code der sich ein eine .py Datei befindet, von einer bash Datei aus aufrufe und wie man in der .py Datei verwendete Variabeln in der .sh Datei verwenden kann. Vom Prinzip her in etwa so etwas:

aufrufende_bash_datei.sh

Code: Alles auswählen

#!/bin/bash

mu = 
sigma=
aufgerufene_py_datei.py

read -p "Zum Beenden Enter drücken oder Ctl + C"

aufgerufene_py_datei.py

Code: Alles auswählen

#!/usr/bin/env python3

# import the required libraries  
import random  
import matplotlib.pyplot as plt  
    
# store the random numbers in a   
# list  
nums = []  
# mu = 500
# sigma = 50
    
for i in range(100):  
    temp = random.normalvariate(mu, sigma) 
    nums.append(temp)  
        
# plotting a graph  
plt.plot(nums) 
plt.show()
 
varialble = input ("Zum Beenden Enter drücken oder Ctl + C")

[sparrow]

Das klingt sehr seltsam.

Wenn du Python programmieren möchtest, dann solltest du Programm in Python schreiben. So Python in Bash-Scripte einzubinden ist mindestens ungewöhnlich. Und wenn die Bash-Scripte funktionieren, warum sollte man Dinge darin so platzieren?

Den Vergleich mit dem "lebenden Objekt" finde ich gut. Mein Gedanken bei dieser "Art" der Einbindung erinnert mich eher an Frankenstein.

[Susann.M.23]

Das klingt sehr seltsam ... Und wenn die Bash-Scripte funktionieren, warum sollte man Dinge darin so platzieren?

Das bietet die Möglichkeit, bei der Etablierung zusätzlicher Features für bestehende bash Scripte, diese in .py realisieren zu können. Und somit ermöglicht mir dieser Weg, auch in einer frühen Lernphase, Erfahrungen mit .py am lebenden Objekt zu sammeln.

[sparrow]

Mein Rat: Schreib deine Bash-Scripte in Python neu. Komplett. Das ist ein sinnvoller Weg wirklich Erfahrung zu sammeln.

[Sirius3]

Aber dazu schreibt man doch ein Python-Programm in einer eigenen .py-Datei und ruft die im Shell-Skript auf, und packt den Code nicht in eine .sh-Datei.

[Susann.M.23]

Aber dazu schreibt man doch ein Python-Programm in einer eigenen .py-Datei und ruft die im Shell-Skript auf, und packt den Code nicht in eine .sh-Datei.

Zu dem wie man .py code in eine .sh Datei packt habe ich ja nun ein funktionierendes Beispiel. Dieser Punkt ist erledigt und funktioniert bestens.

Nun suche ich zu selben Code eine Quelle die mir zeigt, wie ich als nächste Realisierungsvariante, py Code der sich ein eine .py Datei befindet, von einer bash Datei aus aufrufe und wie man in der .py Datei verwendete Variabeln in der .sh Datei verwenden kann. Vom Prinzip her in etwa so etwas:

aufrufende_bash_datei.sh

Code: Alles auswählen

#!/bin/bash

mu = 500
sigma= 50
aufgerufene_py_datei.py

read -p "Zum Beenden Enter drücken oder Ctl + C"

aufgerufene_py_datei.py

Code: Alles auswählen

#!/usr/bin/env python3

# import the required libraries  
import random  
import matplotlib.pyplot as plt  
    
# store the random numbers in a   
# list  
nums = []  
# mu = 500
# sigma = 50
    
for i in range(100):  
    temp = random.normalvariate(mu, sigma) 
    nums.append(temp)  
        
# plotting a graph  
plt.plot(nums) 
plt.show()
 
varialble = input ("Zum Beenden Enter drücken oder Ctl + C")

[pillmuncher]

Wenn du den Rat befolgen würdest, der dir hier gegeben wurde, und einfach ein Python-Programm schreiben würdest, das dein Problem löst, statt mit einer Mischung aus Bash und Python irgendwas völlig Undurchsuchtiges zusammen zu basteln, dann müsstest du nicht solche Fragen stellen. Aber wenn du dir dein Leben lieber kompliziert machen willst, von mir aus.

[Susann.M.23]

Wenn du den Rat befolgen würdest, der dir hier gegeben wurde, und einfach ein Python-Programm schreiben würdest, das dein Problem löst, statt mit einer Mischung aus Bash und Python irgendwas völlig Undurchsuchtiges zusammen zu basteln, dann müsstest du nicht solche Fragen stellen. Aber wenn du dir dein Leben lieber kompliziert machen willst, von mir aus.

Nicht jedes über Jahre gewachsene bash Script, lässt sich von jedem in kurzer Zeit in einer fremden Sprache, in diesem Fall .py über Nacht neu schreiben. Daher mein Wunsch, erst einmal nur neue Features in der für mich neuen Sprache .py in bash ein zu binden.

[Sirius3]

@Susann.M.23: um Parameter von einem Shell-Skript in ein Python-Programm zu übergeben, gibt es Commandozeilenargumente, das ist ja nicht anders also von einem Shell-Skript zum anderen.
Für die Rückgabe hast Du ja schon ein Beispiel, wie stdout zu parsen.

[Susann.M.23]

@Susann.M.23: um Parameter von einem Shell-Skript in ein Python-Programm zu übergeben, gibt es Commandozeilenargumente, das ist ja nicht anders also von einem Shell-Skript zum anderen.
Für die Rückgabe hast Du ja schon ein Beispiel, wie stdout zu parsen.

Inder folgenden Art geht schon mal der Aufruf und die Ausgabe im Terminal (ohne Übergabe von Ein und Ausgabewert)

Code: Alles auswählen

#!/bin/bash

# mu = 500
# sigma= 50

python3 aufgerufene_py_datei.py
# echo $ausgabewert_aus_aufgerufene_py_datei

read -p "Zum Beenden Enter drücken oder Ctl + C"

Jetzt muss ich mal sehen wie ich die Eingabewerte und den Ausgabewert übergeben bekomme.

[Susann.M.23]

Jetzt muss ich mal sehen wie ich die Eingabewerte und den Ausgabewert übergeben bekomme.

Nach dem folgenden Muster, geht das was ich machen möchte vermutlich. Allerdings weiß ich es bisher nicht auf meinen Beispielcode an zu wenden:

If not, you can use in-built python module sys to pass arguements to python script and print results directly on terminal.

Code: Alles auswählen

import sys

def func(arg1, arg2):
    # do_somehing
arg1, arg2 = sys.argv[1], sys.argv[2]
print(func(arg1, arg2))

Then you will use it directly on bash

Code: Alles auswählen

python script_name.py arg1 arg1

[__blackjack__]

Das ist ja jetzt nicht wirklich etwas spezielles zwischen Bash und Python. In der Bash rufst Du das Python-Programm so auf wie Du auch jedes andere Programm aufrufen würdest, egal in welcher Programmiersprache das geschrieben ist:

Code: Alles auswählen

#!/bin/bash

./aufgerufene_py_datei.py 500 50

Und Python ist das auch völlig wurscht in welcher Programmiersprache das Programm geschrieben ist, von dem aus es aufgerufen wurde. Argumente stehen in der Sequenz `sys.argv` als Zeichenketten. Von da geht es ganz normal mit Python weiter:

Code: Alles auswählen

#!/usr/bin/env python3
import random
import sys

import matplotlib.pyplot as plt


def main():
    mean, standard_deviation = map(float, sys.argv[1:3])
    plt.plot(
        [random.normalvariate(mean, standard_deviation) for _ in range(100)]
    )
    plt.show()


if __name__ == "__main__":
    main()

[nezzcarth]

Ich habe halt ein paar bash Scripte, bei denen ich testweise ein paar Passagen durch .py realisieren möchte. Sozusagen, das Sammeln erster Erfahrungen am lebenden Objekt. Eventuell weite ich das später noch ein wenig aus.

Ich verstehe zwar die Idee, aber ich halte das für keinen guten Ansatz. Wenn du Python verwenden möchtest, ist es aus meiner Sicht zielführender, das dann auch konsequent zu machen. Solche Hybrid-Lösungen sind echt problematisch und damit es überhaupt funktioniert, fängst du an, dir Patterns anzueignen, die dich später, wenn in Python flüssiger bist, möglicherweise davon abhalten, "schöne" Programme zu schreiben.

Wenn du eine Programmiersprache möchtest, die deutlich von Shell-Scripten beeinflusst, aber mächtiger ist, nimm Perl. Das ist zwar nicht mehr besonders angesagt, aber aus meiner Sicht in dem konkreten Fall alle mal besser, als irgendwelche Python-Bash-Mischungen. In Perl kann man dann auch mit wenig Aufwand Skripte schreiben, die im Wesentlichen aus Shell-Aufrufen bestehen wenn man es denn unbedingt möchte.

[Susann.M.23]

Das ist ja jetzt nicht wirklich etwas spezielles zwischen Bash und Python. In der Bash rufst Du das Python-Programm so auf wie Du auch jedes andere Programm aufrufen würdest, egal in welcher Programmiersprache das geschrieben ist:

Code: Alles auswählen

#!/bin/bash

./aufgerufene_py_datei.py 500 50

Und Python ist das auch völlig wurscht in welcher Programmiersprache das Programm geschrieben ist, von dem aus es aufgerufen wurde. Argumente stehen in der Sequenz `sys.argv` als Zeichenketten. Von da geht es ganz normal mit Python weiter:

Code: Alles auswählen

#!/usr/bin/env python3
import random
import sys

import matplotlib.pyplot as plt


def main():
    mean, standard_deviation = map(float, sys.argv[1:3])
    plt.plot(
        [random.normalvariate(mean, standard_deviation) for _ in range(100)]
    )
    plt.show()


if __name__ == "__main__":
    main()

Besten Dank !!! Aber es sieht für mich so aus als ob ich zu blöd dafür bin. Schon folgendes gelingt mir nicht in die gewünschte Form um zu wandeln:

Das sollte so ok sein:
#!/bin/bash

Code: Alles auswählen

./aufzurufene_py_datei.py 100 50

Hier gelingt mir nicht die entsprechende Anpassung:
aufzurufene_py_datei.py

Code: Alles auswählen

#!/usr/bin/env python3
import random 
print(random.normalvariate(mu, sigma))

[Sirius3]

Und woher soll der Computer wissen, was mu und sigma sind?
Du mußt doch sehen, dass bei Deinem Programm einiges fehlt, was das Programm von __blackjack__ hat.

[Susann.M.23]

Und woher soll der Computer wissen, was mu und sigma sind?
Du mußt doch sehen, dass bei Deinem Programm einiges fehlt, was das Programm von __blackjack__ hat.

Ja das muss irgend wie in die folgende Form:

Code: Alles auswählen

import sys

def func(arg1, arg2):
    # do_somehing
arg1, arg2 = sys.argv[1], sys.argv[2]
print(func(arg1, arg2))

Evtl. so:

Code: Alles auswählen

#!/bin/bash
./aufzurufene_py_datei.py 100 50

Code: Alles auswählen

#!/usr/bin/env python3
import random 
def func(arg1, arg2):
arg1, arg2 = sys.argv[1], sys.argv[2]
print(random.normalvariate(mu, sigma))