Das deutsche Python-Forum

Leonidas hat geschrieben:Wie wäre es ein Script zu machen, die Bash das Script ausführen zu lassen und den stdout abfragen?

import popen2
o.i.e=popen2.popen3('/bin/bash /home/user/sub.sh')
out=o.read()
print out
HELLO

  
#!/bin/bash
echo HELLO

import popen2
o.i.e=popen2.popen3('/bin/bash')
i.write('echo HELLO')
out=o.read()
ZzzZZzz

Anonymous hat geschrieben:du meinst so

Code: Alles auswählen

import popen2
o.i.e=popen2.popen3('/bin/bash /home/user/sub.sh')
out=o.read()
print out
HELLO

sub.sh

Code: Alles auswählen

  
#!/bin/bash
echo HELLO

das läuft wunderbar.

ich muss aber genau das gegenteil erreichen..
also ein Skript zeilenweise ausführen

Anonymous hat geschrieben:bei read() gibt es dann einen Deadlock weil die Shell selber ständig auf eingabe wartet?

Q: Why not just use a pipe (popen())?

A: A pipe works fine for getting the output to non-interactive programs. If you just want to get the output from ls, uname, or ping then this works. Pipes do not work very well for interactive programs and pipes will almost certainly fail for most applications that ask for passwords such as telnet, ftp, or ssh.

There are two reasons for this.

First an application may bypass stdout and print directly to its controlling TTY. Something like SSH will do this when it asks you for a password. This is why you cannot redirect the password prompt because it does not go through stdout or stderr.

The second reason is because most applications are built using the C Standard IO Library (anything that uses #include <stdio.h>). One of the features of the stdio library is that it buffers all input and output. Normally output is line buffered when a program is printing to a TTY (your terminal screen). Everytime the program prints a line-feed the currently buffered data will get printed to your screen. The problem comes when you connect a pipe. The stdio library is smart and can tell that it is printing to a pipe instead of a TTY. In that case it switches from line buffer mode to block buffered. In this mode the currently buffered data is flushed when the buffer is full. This causes most interactive programs to deadlock. Block buffering is more efficient when writing to disks and pipes. Take the situation where a program prints a message "Enter your user name:\n" and then waits for you type type something. In block buffered mode, the stdio library will not put the message into the pipe even though a linefeed is printed. The result is that you never receive the message, yet the child application will sit and wait for you to type a response. Don't confuse the stdio lib's buffer with the pipe's buffer. The pipe buffer is another area that can cause problems. You could flush the input side of a pipe, whereas you have no control over the stdio library buffer.