I’m assuming you mean from the command-line. I’ve never seen initial values for command line prompts, they’re usually of the form:

Folder [default] : 

which in code is simply:

res = raw_input('Folder [default] : ')
res = res or 'default'

Alternatively, you can try to do something using the curses module in Python.

If you do that, the user would have to delete the existing word. What about providing a default value if the user hits “return”?

>>> default_folder = "My Documents"
>>> try: folder = input("folder name [%s]:" %default_folder)
... except SyntaxError: folder = default_folder

I think that the best (the easiest and most portable) solution is a combination of @rlotun and @Stephen answers:

default = '/default/path/'
dir = raw_input('Folder [%s]' % default)
dir = dir or default

This works in windows.

import win32console

_stdin = win32console.GetStdHandle(win32console.STD_INPUT_HANDLE)

def input_def(prompt, default=''):
    keys = []
    for c in unicode(default):
        evt = win32console.PyINPUT_RECORDType(win32console.KEY_EVENT)
        evt.Char = c
        evt.RepeatCount = 1
        evt.KeyDown = True
        keys.append(evt)

    _stdin.WriteConsoleInput(keys)
    return raw_input(prompt)

if __name__ == '__main__':
    name = input_def('Folder name: ')
    print
    print name

Not the best aproach but for the sake of sharing…
You could use Javascript to get all sort of inputs in IPython Notebook.

from IPython.display import HTML
newvar = ""
htm = """
<input id="inptval" style="width:60%;" type="text" value="This is an editable default value.">
<button onclick="set_value()" style="width:20%;">OK</button>

<script type="text/Javascript">
    function set_value(){
        var input_value = document.getElementById('inptval').value;
        var command = "newvar = '" + input_value + "'";
        var kernel = IPython.notebook.kernel;
        kernel.execute(command);
    }
</script>
"""
HTML(htm)

On the next cell you can use the new variable:

print newvar

This is not a very Good Answer but it is a work around for windows. As hard as I tried, I could not get Readline or pyReadline to work on my Windows10 computer with Python Ver 3.5. So I wrote this instead. Not the best code in the world since I’ve only been using Python for 3 months. But it works.

    import os

    def note_input(defaultvalue):
        #Create a textfile
        txtfile = open("txtfile.txt", "w")
        #
        # populate it with the default value
        txtfile.write(defaultvalue)
        txtfile.close()
        #
        # call Notepad
        os.system("notepad.exe txtfile.txt") 
        # input("Just holding until notepad is close : ") (did not need this line) 
        #
        # get the Value Entered/Changed in Notepad
        txtfile = open("txtfile.txt", "r")
        func_value = txtfile.read()
        txtfile.close()
        return func_value
    # END DEF

Notepad stopped the program from running until it was closed, so the input() line below it was not needed. Once notepad was opened the first time and placed where I wanted it on the screen, It was like a popup input window. I assume you can use any text editor like Notepad++ or Scripe or Code Writer, etc.

We can use Tkinter and use a StringVar to do this. The limitation is that the input is through a Tkinter window.

from tkinter import Tk, LEFT, BOTH, StringVar
from tkinter.ttk import Entry, Frame


class Example(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        self.initUI()

    def initUI(self):
        self.parent.title("Entry")
        self.pack(fill=BOTH, expand=1)
        self.contents = StringVar()
        # give the StringVar a default value
        self.contents.set('test')
        self.entry = Entry(self)
        self.entry.pack(side=LEFT, padx=15)
        self.entry["textvariable"] = self.contents
        self.entry.bind('<Key-Return>', self.on_changed)

    def on_changed(self, event):
        print('contents: {}'.format(self.contents.get()))
        return True


def main():
    root = Tk()
    ex = Example(root)
    root.geometry("250x100+300+300")
    root.mainloop()


if __name__ == '__main__':
    main()

I would like to suggest using the clipboard to solve this problem. Paste the clipboard into the input line, edit as required, press enter. Variable clpstack is used to protect existing clipboard contents. This code is for Windows. Linux could use import clipboard.

import pyperclip as clp
clpstack=clp.paste()
clp.copy("192.168.4.1")
HOST = input("Enter telnet host: ")
clp.copy(clpstack)

I like this, It works on window

def inputWdefault(prompt, default):
    bck = chr(8) * len(default)
    ret = input(prompt + default + bck)
    return ret or default

I finally found a simple alternative that works on Windows and Linux. Essentially, i’m using the pyautogui module to simulate the user’s input. in practice, it looks like this:

from pyautogui import typewrite

print("enter folder name: ")
typewrite("Default Value")
folder = input()

A Word of Warning:

1. Theoretically, the user can insert characters in the middle of the “default” input by pressing a key before typewrite finishes.
2. pyautogui is notoriously unreliable on headless systems, so make sure to provide a backup solution in case the import fails. If you run into No module named 'Xlib', try to install the python3-xlib or python-xlib package (or the xlib module). Running over ssh can also be a problem.

An example fallback implementation:

Since a missing X-server can logically only happen on linux, here’s an implementation that uses sth’s answer as fallback:

try:
    from pyautogui import typewrite
    autogui = True
except (ImportError, KeyError):
    import readline
    autogui = False

def rlinput(prompt, prefill=''):
    if autogui:
        print(prompt)
        typewrite(prefill)
        return input()
    else:
        readline.set_startup_hook(lambda: readline.insert_text(prefill))
        try:
            return input(prompt)
        finally:
            readline.set_startup_hook()

I found PyInquirer to be very helpful, especially when building interactive console applications frequently. Prompting a user with a default modifiable value would look as follows:

from PyInquirer import prompt

question = [
    {
        'type': 'input',
        'name': 'first_name',
        'message': 'Name please',
        'default': 'Max'
    }
]

answer = prompt(question)
print('Hello {}'.format(answer['first_name']))

I liked the approach taken by @MCO so I refactored the code. I tested it on X Windows and Microsoft Windows 10 WSL 2 using Microsoft Terminal:

def input_with_default(prompt, prefill=''):
    try:
        from pyautogui import typewrite
        print(prompt)
        typewrite(prefill)
        return input()
    except (ImportError, KeyError):
        import readline
        readline.set_startup_hook(lambda: readline.insert_text(prefill))
    try:
        return input(prompt)
    finally:
        readline.set_startup_hook()

Recently faced this problem. None of the above answers seem to be flawless. So I did some research, and found the following solution to be the easiest, and works both for Windows and Linux:

import keyboard

def input_with_default(prompt_, default_):
    keyboard.write(default_)
    return input(prompt_)

if __name__ == "__main__":
    print(input_with_default("Please enter: ", "hello world"))

If you are writing a CLI, you might want to consider using the python-click library for this.

You would achieve your goal with the following code:

import click

user_input = click.prompt(text="Folder name", default="Download")
print(f"{user_input=}")

If you run this code, and type in nothing, then you get:

$ python3 cli_code.py
Folder name [Download]: 
user_input='Download'

If you run this code, and type in ‘my-dir’, then you get:

$ python3 cli_code.py
Folder name [Download]: my-dir
user_input='my-dir'

Try using an "f-string" and "or" combination, say:

default_name = "that_folder"

this_folder = input(f"Folder name: ({default_name}) ") or default_name
print(this_folder)

If you hit Return without typing in the folder name, the default_name will be assumed.