I&#39;m trying to do some of the [code golf][1] challenges, but they all require the input to be taken from `stdin`. How do I get that in Python?

  [1]: http://en.wikipedia.org/wiki/Code_golf


How do you read from stdin?

If I do the following:

    import subprocess
    from cStringIO import StringIO
    subprocess.Popen([&#39;grep&#39;,&#39;f&#39;],stdout=subprocess.PIPE,stdin=StringIO(&#39;one\ntwo\nthree\nfour\nfive\nsix\n&#39;)).communicate()[0]

I get:

    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in ?
      File &quot;/build/toolchain/mac32/python-2.4.3/lib/python2.4/subprocess.py&quot;, line 533, in __init__
        (p2cread, p2cwrite,
      File &quot;/build/toolchain/mac32/python-2.4.3/lib/python2.4/subprocess.py&quot;, line 830, in _get_handles
        p2cread = stdin.fileno()
    AttributeError: &#39;cStringIO.StringI&#39; object has no attribute &#39;fileno&#39;

Apparently a cStringIO.StringIO object doesn&#39;t quack close enough to a file duck to suit subprocess.Popen.  How do I work around this?


How do I pass a string into subprocess.Popen (using the stdin argument)?

I want to deal with the command line input in Ruby:

    &gt; cat input.txt | myprog.rb
    &gt; myprog.rb &lt; input.txt
    &gt; myprog.rb arg1 arg2 arg3 ...

What is the best way to do it? In particular I want to deal with blank STDIN, and I hope for an elegant solution.

    #!/usr/bin/env ruby
    
    STDIN.read.split(&quot;\n&quot;).each do |a|
       puts a
    end
    
    ARGV.each do |b|
        puts b
    end

Best practices with STDIN in Ruby?

The following Perl script (`my.pl`) can read from either the file in the command line arguments or from [standard input][1] (STDIN):

    while (&lt;&gt;) {
       print($_);
    }

`perl my.pl` will read from standard input, while `perl my.pl a.txt` will read from `a.txt`. This is very handy.

Is there an equivalent in Bash?

  [1]: https://en.wikipedia.org/wiki/Standard_streams#Standard_input_(stdin)


How to read from a file or standard input in Bash

I am rather confused with the purpose of these three files. If my understanding is correct, `stdin` is the file in which a program writes into its requests to run a task in the process, `stdout` is the file into which the kernel writes its output and the process requesting it accesses the information from, and `stderr` is the file into which all the exceptions are entered. On opening these files to check whether these actually do occur, I found nothing seem to suggest so!

What I would want to know is what exactly is the purpose of these files, absolutely dumbed down answer with very little tech jargon!


Confused about stdin, stdout and stderr?

I&#39;m looking to process a text file with node using a command line call like:

`node app.js &lt; input.txt`

Each line of the file needs to be processed individually, but once processed the input line can be forgotten.

Using the on-data listener of the stdin, I get the input steam chunked by a byte size so I set this up.


    process.stdin.resume();
    process.stdin.setEncoding(&#39;utf8&#39;);
    
    var lingeringLine = &quot;&quot;;
    
    process.stdin.on(&#39;data&#39;, function(chunk) {
        lines = chunk.split(&quot;\n&quot;);
    
        lines[0] = lingeringLine + lines[0];
        lingeringLine = lines.pop();
    
        lines.forEach(processLine);
    });
    
    process.stdin.on(&#39;end&#39;, function() {
        processLine(lingeringLine);
    });

But this seems so sloppy. Having to massage around the first and last items of the lines array. Is there not a more elegant way to do this?

How to read from stdin line by line in Node

Is there a way to effectively do this in bash:

    /my/bash/script &lt; echo &#39;This string will be sent to stdin.&#39;

I&#39;m aware that I could pipe the output from the echo such as this:

    echo &#39;This string will be piped to stdin.&#39; | /my/bash/script

Send string to stdin

I have a python script parse.py, which in the script open a file, say file1, and then do something maybe print out the total number of characters. 

    filename = &#39;file1&#39;
    f = open(filename, &#39;r&#39;)
    content = f.read()
    print filename, len(content)

Right now, I am using stdout to direct the result to my output file - output
    
    python parse.py &gt;&gt; output

However, I don&#39;t want to do this file by file manually, is there a way to take care of every single file automatically? Like
    
    ls | awk &#39;{print}&#39; | python parse.py &gt;&gt; output 

Then the problem is how could I read the file name from standardin? 
or there are already some built-in functions to do the ls and those kind of work easily?

Thanks!


How to open every file in a folder

I&#39;m trying to do the opposite of &quot;https://stackoverflow.com/questions/1312922/detect-if-stdin-is-a-terminal-or-pipe-in-c-c-qt&quot;.

I&#39;m running an application that&#39;s changing its output format because it detects a pipe on STDOUT, and I want it to think that it&#39;s an interactive terminal so that I get the same output when redirecting.

I was thinking that wrapping it in an `expect` script or using a `proc_open()` in PHP would do it, but it doesn&#39;t.

Any ideas out there?


How to trick an application into thinking its stdout is a terminal, not a pipe

I&#39;m writing a shell script that should be somewhat secure, i.e., does not pass secure data through parameters of commands and preferably does not use temporary files. How can I pass a variable to the standard input of a command?

Or, if it&#39;s not possible, how can I correctly use temporary files for such a task?


How can pass the value of a variable to the standard input of a command?

Is it possible to compress (create a compressed archive) data while reading from stdin on Linux?


Compress files while reading data from STDIN

When I execute &quot;`python`&quot; from the terminal with no arguments it brings up the Python interactive shell.

When I execute &quot;`cat | python`&quot; from the terminal it doesn&#39;t launch the interactive mode. Somehow, without getting any input, it has detected that it is connected to a pipe.

How would I do a similar detection in C or C++ or Qt?

Detect if stdin is a terminal or pipe?

Is it possible to listen for incoming keystrokes in a running nodejs script?
If I use `process.openStdin()` and listen to its `&#39;data&#39;` event then the input is buffered until the next newline, like so:

    // stdin_test.js
    var stdin = process.openStdin();
    stdin.on(&#39;data&#39;, function(chunk) { console.log(&quot;Got chunk: &quot; + chunk); });

Running this, I get:
   
    $ node stdin_test.js
                    &lt;-- type &#39;1&#39;
                    &lt;-- type &#39;2&#39;
                    &lt;-- hit enter
    Got chunk: 12

What I&#39;d like is to see:
  
    $ node stdin_test.js
                    &lt;-- type &#39;1&#39; (without hitting enter yet)
     Got chunk: 1
 
I&#39;m looking for a nodejs equivalent to, e.g., [`getc` in ruby](http://www.ruby-doc.org/docs/ProgrammingRuby/html/ref_c_io.html#IO.getc)

Is this possible?


nodejs how to read keystrokes from stdin

What is the simplest way to read a full line in a C console program
The text entered might have a variable length and we can&#39;t make any assumption about its content.


How to read a line from the console in C?

Bash allows to use: `cat &lt;(echo &quot;$FILECONTENT&quot;)`

Bash also allow to use: `while read i; do echo $i; done &lt;/etc/passwd`

to combine previous two this can be used: `echo $FILECONTENT | while read i; do echo $i; done`

The problem with last one is that it creates sub-shell and after the while loop ends variable `i` cannot be accessed any more.

My question is:

How to achieve something like this: `while read i; do echo $i; done &lt;(echo &quot;$FILECONTENT&quot;)` or in other words: How can I be sure that `i` survives while loop?

Please note that I am aware of enclosing while statement into `{}` but this does not solves the problem (imagine that you want use the while loop in function and return `i` variable)

How to pipe input to a Bash while loop and preserve variables after loop ends

So a quick Google search for `fflush(stdin)` for clearing the input buffer reveals numerous websites warning against using it. And yet that&#39;s exactly how my CS professor taught the class to do it.

How bad is using `fflush(stdin)`? Should I really abstain from using it, even though my professor is using it and it seems to work flawlessly?

Using fflush(stdin)

How do I use the `fmt.Scanf` function in Go to get an integer input from the standard input?

If this can&#39;t be done using `fmt.Scanf`, what&#39;s the best way to read a single integer?


Reading an integer from standard input

I want to run blender from the command line through a ruby script, which will then process the output given by blender line by line to update a progress bar in a GUI. It&#39;s not really important that blender is the external process whose stdout I need to read.

I can&#39;t seem to be able to catch the progress messages blender normally prints to the shell when the blender process is still running, and I&#39;ve tried a few ways. I always seem to access the stdout of blender *after* blender has quit, not while it&#39;s still running.

Here&#39;s an example of a failed attempt. It does get and print the first 25 lines of the output of blender, but only after the blender process has exited:

    blender = nil
    t = Thread.new do
      blender = open &quot;| blender -b mball.blend -o //renders/ -F JPEG -x 1 -f 1&quot;
    end
    puts &quot;Blender is doing its job now...&quot;
    25.times { puts blender.gets}

**Edit:**

To make it a little clearer, the command invoking blender gives back a stream of output in the shell, indicating progress (part 1-16 completed etc). It seems that any call to &quot;gets&quot; the output is blocked until blender quits. The issue is how to get access to this output while blender is still running, as blender prints it&#39;s output to shell.

Continuously read from STDOUT of external process in Ruby

How can I *intercept* &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;C&lt;/kbd&gt; (which normally would kill the process)
in a CLI (command line interface) Java application?

Does a multi-platform solution exist (Linux, Solaris, Windows)?

I&#39;m using `Console`&#39;s `readLine()`, but if necessary, I could use some other method
to read characters from standard input.

How can I &quot;intercept&quot; Ctrl+C in a CLI application?

I&#39;m trying to write a Python script that starts a subprocess, and writes to the subprocess stdin. I&#39;d also like to be able to determine an action to be taken if the subprocess crashes.

The process I&#39;m trying to start is a program called `nuke` which has its own built-in version of Python which I&#39;d like to be able to submit commands to, and then tell it to quit after the commands execute. So far I&#39;ve worked out that if I start Python on the command prompt like and then start `nuke` as a subprocess then I can type in commands to `nuke`, but I&#39;d like to be able to put this all in a script so that the master Python program can start `nuke` and then write to its [standard input][1] (and thus into its built-in version of Python) and tell it to do snazzy things, so I wrote a script that starts `nuke` like this:

    subprocess.call([&quot;C:/Program Files/Nuke6.3v5/Nuke6.3&quot;, &quot;-t&quot;, &quot;E:/NukeTest/test.nk&quot;])

Then nothing happens because `nuke` is waiting for user input. How would I now write to standard input?

I&#39;m doing this because I&#39;m running a plugin with `nuke` that causes it to crash intermittently when rendering multiple frames. So I&#39;d like this script to be able to start `nuke`, tell it to do something and then if it crashes, try again. So if there is a way to catch a crash and still be OK then that&#39;d be great.

  [1]: https://en.wikipedia.org/wiki/Standard_streams#Standard_input_.28stdin.29


How do I write to a Python subprocess&#39; stdin?

Can someone tell me why this does not work? I&#39;m playing around with file descriptors, but feel a little lost.

    #!/bin/bash
    echo &quot;This&quot;
    echo &quot;is&quot; &gt;&amp;2
    echo &quot;a&quot; &gt;&amp;3
    echo &quot;test.&quot; &gt;&amp;4

The first three lines run fine, but the last two error out. Why?

How do file descriptors work?

What is the slickest way to programatically read from stdin or an input file (if provided) in Perl?

Programmatically read from STDIN or input file in Perl

What is the required syntax to redirect standard input/output on Windows PowerShell?

On Unix, we use:

    $./program &lt;input.txt &gt;output.txt

How do I execute the same task in PowerShell?


Redirecting standard input\output in Windows PowerShell

I found the very useful syntax

    parser.add_argument(&#39;-i&#39;, &#39;--input-file&#39;, type=argparse.FileType(&#39;r&#39;), default=&#39;-&#39;)

for specifying an input file or using stdin—both of which I want in my program. However, the input file is not always required. If I&#39;m not using `-i` or redirecting input with one of

    $ someprog | my_python_prog
    $ my_python_prog &lt; inputfile

I don&#39;t want my Python program to wait for input. I want it to just move along and use default values.

Optional stdin in Python with argparse

What I want to do is the following:

 1. read in multiple line input from `stdin` into variable `A`
 2. make various operations on `A`
 3. pipe `A` without losing delimiter symbols (`\n`,`\r`,`\t`,etc) to another command

The current problem is that, I can&#39;t read it in with `read` command, because it stops reading at newline.

I can read stdin with `cat`, like this:

    my_var=`cat /dev/stdin`

, but then I don&#39;t know how to print it. So that the newline, tab, and other delimiters are still there.

My sample script looks like this:

    #!/usr/local/bin/bash
    
    A=`cat /dev/stdin`
    
    if [ ${#A} -eq 0 ]; then
            exit 0
    else
            cat ${A} | /usr/local/sbin/nextcommand
    fi



How to read mutliline input from stdin into variable and how to print one out in shell(sh,bash)?

In Python, how do you check if `sys.stdin` has data or not?

I found that `os.isatty(0)` can not only check if stdin is connected to a TTY device, but also if there is data available.

But if someone uses code such as

    sys.stdin = cStringIO.StringIO(&quot;ddd&quot;)

and after that uses `os.isatty(0)`, it still returns True.  What do I need to do to check if stdin has data?

How do I check if stdin has some data?

I&#39;ve written a command line utility that uses getopt for parsing arguments given on the command line. I would also like to have a filename be an optional argument, such as it is in other utilities like grep, cut etc. So, I would like it to have the following usage

    tool -d character -f integer [filename]

How can I implement the following?

- if a filename is given, read from the file.
- if a filename is not given, read from STDIN.

Read from File, or STDIN

Is it possible to synchronously read from stdin in node.js? Because I&#39;m writing a brainfuck to JavaScript compiler in JavaScript (just for fun). Brainfuck supports a read operation which needs to be implemented synchronously.

I tried this:

    const fs = require(&#39;fs&#39;);
    var c = fs.readSync(0,1,null,&#39;utf-8&#39;);
    console.log(&#39;character: &#39;+c+&#39; (&#39;+c.charCodeAt(0)+&#39;)&#39;);

But this only produces this output:

    fs:189
      var r = binding.read(fd, buffer, offset, length, position);
                  ^
    Error: EAGAIN, Resource temporarily unavailable
        at Object.readSync (fs:189:19)
        at Object.&lt;anonymous&gt; (/home/.../stdin.js:3:12)
        at Module._compile (module:426:23)
        at Module._loadScriptSync (module:436:8)
        at Module.loadSync (module:306:10)
        at Object.runMain (module:490:22)
        at node.js:254:10





node.js: readSync from stdin?

Is it possible for Eclipse to read stdin from a file?

Eclipse reading stdin (System.in) from a file

I know PHP is usually used for web development, where there _is_ no standard input, but PHP claims to be usable as a general-purpose scripting language, if you do follow it&#39;s funky web-based conventions. I know that PHP prints to `stdout` (or whatever you want to call it) with `print` and `echo`, which is simple enough, but I&#39;m wondering how a PHP script might get input from `stdin` (specifically with `fgetc()`, but any input function is good), or is this even possible?

PHP standard input?

I am reading bunch of integers separated by space or newlines from the standard in using `Scanner(System.in)`.

Is there any faster way of doing this in Java?

What&#39;s the fastest way to read from System.in in Java?

**Situation:**

I want to get a password entry from the `stdin` console - *without echoing what the user types*. Is there something comparable to `getpasswd` functionality in Go?

**What I tried:**

I tried using `syscall.Read`, but it echoes what is typed.

getpasswd functionality in Go?

I am trying to spawn an external process `phantomjs` using node&#39;s `child_process` and then send information to that process after it was initialized, is that possible?

I have the following code:

    var spawn = require(&#39;child_process&#39;).spawn,
        child = spawn(&#39;phantomjs&#39;);

    child.stdin.setEncoding = &#39;utf-8&#39;;
    child.stdout.pipe(process.stdout);

    child.stdin.write(&quot;console.log(&#39;Hello from PhantomJS&#39;)&quot;);

But the only thing I got on the stdout is the initial prompt for phantomjs console.

    phantomjs&gt; 

So it seems the `child.stdin.write` is not making any effect.

I am  not sure I can send additional information to phantomjs ater the initial spawn.

thanks in advance.

Nodejs Child Process: write to stdin from an already initialised process

I&#39;m writing a program in Node.js that (in some situations) wants to act as a simple filter: read everything from stdin (up to end of file), do some processing, write the result to stdout.

How do you do the &#39;read everything from stdin&#39; part? The closest solutions I&#39;ve found so far, seem to work either for one line at a time from the console, or else only work when stdin is a file not a pipe.

Read all text from stdin to a string

I am attempting to accept input from the console in Kotlin but it is difficult because I am not too sure about the syntax. 

I begin with the main 

    fun main(args: Array&lt;String&gt;) {
    
    }

WHAT should I enter after this? I am aware that the `println()` and `readline()` are involved but I do not know how to structure them. 

Objective: prompt user to enter a number, the number entered is multiplied by 6, program returns the result to the console display. 

Reading console input in Kotlin

The code below almost works, but it&#39;s not what I really meant:

    ob_start();
    echo &#39;xxx&#39;;
    $contents = ob_get_contents();
    ob_end_clean();
    file_put_contents($file,$contents);

Is there a more natural way?

how to redirect STDOUT to a file in PHP?

I have a large tar file I `split`. Is it possible to `cat` and untar the file using pipeline.  

Something like:

    cat largefile.tgz.aa largefile.tgz.ab | tar -xz

instead of:

    cat largefile.tgz.aa largfile.tgz.ab &gt; largefile.tgz
    tar -xzf largefile.tgz

I have been looking around and I can&#39;t find the answer. I wanted to see if it was possible.

How to extract tar archive from stdin?

How can I make grep read the **expression** from standard input (stdin)?

For example (the following doesn&#39;t work):

    grep -i -f &amp;0 /path/to/text/file &lt; &quot;/regexp/&quot;


Read expression for grep from standard input

I want to do something like this:

    $ [mysql query that produces many lines] | php parse_STDIN.php

In `parse_STDIN.php` file I want to be able to parse my data line by line from stdin.

Reading line by line from STDIN

I have a program that interacts with the user (acts like a shell), and I want to run it using the Python subprocess module interactively.
That means, I want the possibility to write to standard input and immediately get the output from standard output. I tried many solutions offered here, but none of them seems to work for my needs.

The code I&#39;ve written is based on *https://stackoverflow.com/questions/11457931/running-an-interactive-command-from-within-python*.

    import Queue
    import threading
    import subprocess
    def enqueue_output(out, queue):
        for line in iter(out.readline, b&#39;&#39;):
            queue.put(line)
        out.close()

    def getOutput(outQueue):
        outStr = &#39;&#39;
        try:
            while True: # Adds output from the queue until it is empty
                outStr += outQueue.get_nowait()

        except Queue.Empty:
            return outStr

    p = subprocess.Popen(&quot;./a.out&quot;, stdin=subprocess.PIPE, stout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize = 1)
    #p = subprocess.Popen(&quot;./a.out&quot;, stdin=subprocess.PIPE, stout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False, universal_newlines=True)

    outQueue = Queue()
    errQueue = Queue()

    outThread = Thread(target=enqueue_output, args=(p.stdout, outQueue))
    errThread = Thread(target=enqueue_output, args=(p.stderr, errQueue))

    outThread.daemon = True
    errThread.daemon = True

    outThread.start()
    errThread.start()

    p.stdin.write(&quot;1\n&quot;)
    p.stdin.flush()
    errors = getOutput(errQueue)
    output = getOutput(outQueue)

    p.stdin.write(&quot;5\n&quot;)
    p.stdin.flush()
    erros = getOutput(errQueue)
    output = getOutput(outQueue)

The problem is that the queue remains empty, as if there is no output.
Only if I write to standard input all the input that the program needs to execute and terminate, then I get the output (which is not what I want). For example, if I do something like:

    p.stdin.write(&quot;1\n5\n&quot;)
    errors = getOutput(errQueue)
    output = getOutput(outQueue)

Is there a way to do what I want to do?

&lt;hr/&gt;

The script will run on a Linux machine. I changed my script and deleted the universal_newlines=True + set the bufsize to 1 and flushed standard input immediately after write. Still I don&#39;t get any output.

**Second try:**

I tried this solution and it works for me:

    from subprocess import Popen, PIPE

    fw = open(&quot;tmpout&quot;, &quot;wb&quot;)
    fr = open(&quot;tmpout&quot;, &quot;r&quot;)
    p = Popen(&quot;./a.out&quot;, stdin = PIPE, stdout = fw, stderr = fw, bufsize = 1)
    p.stdin.write(&quot;1\n&quot;)
    out = fr.read()
    p.stdin.write(&quot;5\n&quot;)
    out = fr.read()
    fw.close()
    fr.close()


All Stdin Solutions on Gang of Coders

Total of 40 Stdin Solutions