• Flush the standard input with Ctrl+d
• alternatively use input() or raw_input()
• check the docs >>> help(sys.stdin.read)

So you have used Python's "pre built in functions", presumably like this:

file_object = open('filename')
for something in file_object:
    some stuff here

This reads the file by invoking an iterator on the file object which happens to return the next line from the file.

You could instead use:

file_object = open('filename')
lines = file_object.readlines()

which reads the lines from the current file position into a list.

Now, sys.stdin is just another file object, which happens to be opened by Python before your program starts. What you do with that file object is up to you, but it is not really any different to any other file object, its just that you don't need an open.

for something in sys.stdin:
    some stuff here

will iterate through standard input until end-of-file is reached. And so will this:

lines = sys.stdin.readlines()

Your first question is really about different ways of using a file object.

Second, where is it reading from? It is reading from file descriptor 0 (zero). On Windows it is file handle 0 (zero). File descriptor/handle 0 is connected to the console or tty by default, so in effect it is reading from the keyboard. However it can be redirected, often by a shell (like bash or cmd.exe) using syntax like this:

myprog.py < input_file.txt 

That alters file descriptor zero to read a file instead of the keyboard. On UNIX or Linux this uses the underlying call dup2(). Read your shell documentation for more information about redirection (or maybe man dup2 if you are brave).

stdin.read(1) reads one character from stdin. If there was more than one character to be read at that point (e.g. the newline that followed the one character that was read in) then that character or characters will still be in the buffer waiting for the next read() or readline().

As an example, given rd.py:

from sys import stdin

x = stdin.read(1)
userinput = stdin.readline()
betAmount = int(userinput)
print ("x=",x)
print ("userinput=",userinput)
print ("betAmount=",betAmount)

... if I run this script as follows (I've typed in the 234):

C:\>python rd.py
234
x= 2
userinput= 34

betAmount= 34

... so the 2 is being picked up first, leaving the 34 and the trailing newline character to be picked up by the readline().

I'd suggest fixing the problem by using readline() rather than read() under most circumstances.

Use the fileinput module:

import fileinput

for line in fileinput.input():
    pass

fileinput will loop through all the lines in the input specified as file names given in command-line arguments, or the standard input if no arguments are provided.

Note: line will contain a trailing newline; to remove it use line.rstrip().

sys.stdin.read() will read stdin until it hits EOF. Normally, this happens when that stream is closed by the other end (i.e. by whatever provides input).

This works if you run your program like cat inputfile.txt | your_program. But it will just keep reading endlessly in interactive mode when stdin is connected to your terminal, so the only way to close it from the other end is to close the terminal.

Strictly speaking, you can make read() stop by inputting a EOF character on a line by itself which is Ctrl-D in Unix and Ctrl-Z in Windows -- and this works in a regular Python console. But in IPython, this technique doesn't work: here in Windows, I see Ctrl-D as \x04 and Ctrl-Z as a blank line and neither stops the read (whether this is a bug or by design is another question).

So,

• Use input() instead to input a single line, or

• if you require multiple lines of input, use something that puts a limit on how much is read from stdin:

  ll=[]        
  while True:
      l = input()    # or sys.stdin.readline().rstrip()
      if not l: break
      ll.append(l)
  

  This way, you're able to stop the program from asking for more input by entering a blank line.

• finally, there's sys.stdin.isatty() which allows you do invoke different code depending on whether the input is interactive (but for your task, this is probably an overkill).

Problem is probably due to flushing of stdin since the \n lingers on.

as an alternative, use raw_input

while True:
    c = raw_input('please enter a character: ')
    print 'you entered', c

For the flushing part, see this

@Adar70
EOF is not a character you can send, it's a state/condition, which is true when end of file is detected. For a process sending the data (as opposed to reading from a file) that requires either to terminate/exit the sending process (your QProcess) --- which will mean it won't be there to read the response back in your case --- or you must close stdout, QProcess::closeWriteChannel() --- which will mean you won't be able to send any further messages to the subprocess, which may or may not be acceptable in your situation.

However, better, I will bet my bottom dollar that Python has a way of reading from stdin which does not require EOF. That is down to your statements like sys.stdin.read(), which is a Python question. You want some kind of "unbuffered" and "return immediately with what is there". That is for you to look up. I don't think you should read from sys.stdin.buffer, that is likely to be buffered. Why don't you start with os.read(0, 5) --- read 5 bytes from file descriptor 0, which is stdin, and should be unbuffered --- and see if that works?

Failing that you might try sending a \n at the end of your message, if Python's stdin is line-buffered that may work. If you had sent the data from Pythion via print(..., flush=True) that would have added a \n and I believe that would allow reader to use e.g. for line in sys.stdin (or equivalent for one line) and receive the line immediately. However, your data looks like arbitrary binary data, not text, so the whole idea of inserting a \n or reading "lines" may not be appropriate here.

You might also temporarily try writing the sender side in Python too while you get it working.

in Python the

EOFError: EOF when reading a line 

there is 2 reason for this error

1.reading the file in the wrong way/format

 import sys
 for line in sys.stdin:
     print (line)

this how we can read using "sys.stdln"

2.there is another chance for the same error if the file is corrupted