Reading Input From the Keyboard

Programs often need to obtain data from users, typically throughkeyboard input. In Python, one way to collect user input from the keyboard is by calling theinput() function:

Theinput() function pauses program execution to allow you to type in a line of input from the keyboard. Once you press theEnter key, all characters typed are read and returned as astring, excluding the newline character generated by pressingEnter.

If you add text in between the parentheses, effectively passing a value to the optionalprompt argument, theninput() displays the text you entered as a prompt:

>>>name=input("Please enter your name: ")Please enter your name: John Doe>>>name'John Doe'

Adding a meaningful prompt will assist your user in understanding what they’re supposed to input, which makes for a better user experience.

Theinput() functionalways reads the user’s input as a string. Even if you type characters that resemble numbers, Python will still treat them as a string:

 1>>>number=input("Enter a number: ") 2Enter a number: 50 3 4>>>type(number) 5<class 'str'> 6 7>>>number+100 8Traceback (most recent call last): 9  File"<python-input-1>", line1, in<module>10number+10011~~~~~~~^~~~~12TypeError:can only concatenate str (not "int") to str

In the example above, you wanted to add100 to the number entered by the user. However, the expressionnumber + 100 on line 7 doesn’t work becausenumber is a string ("50") and100 is an integer. In Python, you can’t combine a string and an integer using the plus (+) operator.

You wanted to perform a mathematical operation using two integers, but becauseinput() always returns a string, you need a way toread user input as a numeric type. So, you’ll need toconvert the string to the appropriate type:

>>>number=int(input("Enter a number: "))Enter a number: 50>>>type(number)<class 'int'>>>>number+100150

In this updated code snippet, you useint() to convert the user input to an integer right after collecting it. Then, you assign the converted value to the namenumber. That way, the calculationnumber + 100 has two integers to add. The calculation succeeds and Python returns the correct sum.

Theinput() function lets you collect information from your users. But once your program has calculated a result, how do you display it back to them? Up to this point, you’ve seen results displayed automatically as output in theinteractive Python interpreter session.

However, if you ran the same code from a file instead, then Python would still calculate the values, but you wouldn’t see the results. To display output in the console, you can use Python’sprint() function, which lets you show text and data to your users.

Writing Output to the Console

In addition to obtaining data from the user, a program will often need to present data back to the user. In Python, you can display data to the console with theprint() function.

To display objects to the console, you pass them as a comma-separated list of arguments toprint().By default, the output thatprint() produces separates objects by a single space and appends a newline to the end of the output:

>>>first_name="John">>>last_name="Doe">>>print("Name:",first_name,last_name)Name: John Doe

You can specify any type of object as an argument toprint(). If an object isn’t a string, thenprint() converts it to an appropriatestring representation before displaying it:

>>>numbers=[1,2,3]>>>print(numbers)[1, 2, 3]>>>age=42>>>print(age)42>>>name={"first":"John","last":"Doe"}>>>print(name){'first': 'John', 'last': 'Doe'}>>>print(len)<built-in function len>

As you can see, you can display complex types likelists,dictionaries, and evenfunctions to the console withprint().

Combining Python Input and Output in a Practical Example

Now that you know how to read input from users withinput() and display output withprint(), you can combine these tools to create a small two-line program that greets a user by their name.

The program will start by prompting the user to enter their name and capture that input usinginput().Then, you can useprint() to output a personalized greeting that includes the entered name:

 1name=input("Please enter your name: ") 2print("Hello",name,"and welcome!")

The script introduces a small interaction with your user. When the program runs, it temporarily pauses, awaiting input from the user. Once the user provides their name and presses theEnter key, the program immediately responds with a warm greeting:

Note thatprint() automatically adds spaces between arguments whenconcatenating multiple arguments into a single string.

The small program ingreeter.py collects user input and responds with console output in only two lines of code:

• Line 1 prompts the user with a helpful message. Theinput() function then collects the user’s response as a string, which you assign to thename variable.

• Line 2 assembles a custom greeting using hardcoded strings and the value stored inname. Theprint() function combines the greeting with the user’s input and displays it to the console.

This example brings together theinput() andprint() functions to accomplish a specific purpose, using the strengths of each function:

• input() gathers user data, making the program interactive and adaptable to different users.
• print() displays feedback based on that data, which allows the program to communicate its response to the user in a friendly, personalized way.

In a real-world application, these basic tools can support more complex workflows. For example, after welcoming a user, your program might offer further options or prompt them for more specific input to guide them through a process.

Expand the collapsible section below to continue practicing with a slightly more complex example:

importrandomnumber=random.randint(1,10)

importrandomnumber=random.randint(1,10)guess=int(input("Guess a number between 1 and 10: "))ifguess==number:print("You got it!")else:print("Sorry, the number was",number)

If you’ve successfully built the guess-the-number game and you want another challenge, then you can expand the collapsible section below for a second task:

importrandomhealth=5enemy_health=3whilehealth>0andenemy_health>0:# Normalize input to handle extra spaces and case variations.action=input("Attack or Run? ").strip().lower()ifactionnotin{"attack","run"}:print("Invalid choice. Please type 'Attack' or 'Run'.")continueifaction=="attack":enemy_health-=1print("You hit the enemy!")# Implement a 50% chance that the enemy strikes back.enemy_attacks=random.choice([True,False])ifenemy_attacks:health-=2print("The enemy strikes back!")else:print("You ran away!")breakprint(f"Your health:{health}, Enemy health:{enemy_health}")print("Victory!"ifenemy_health<=0else"Game Over")

Collecting user input and displaying data back to the user comes in handy in many scenarios. Can you think of another practical use case? If you do, share your thoughts in the comments section below.

Reading Input With Advanced Features

In the previous sections, you explored how theinput() function allows your program to pause and wait for the user to provide information. However, depending on the operating system andshell that you’re working with, the standardinput() may have some limitations that can affect user experience.

In some configurations, specifically on UNIX-like systems and Windows versions before Windows 10, you’ll notice that you can’t use arrow keys for navigating through typed characters or to recall previously entered commands:

This can become cumbersome in interactive programs where users might want to correct mistakes or quickly repeat commands.

There’s a straightforward way to improve input functionality just by importing an additional module. The module that you can use depends on whether you’re on a UNIX-like system or on Windows, so make sure to select your operating system from the options below:

• Windows
• Linux + macOS

PS>py-mpipinstallpyreadline3

To activate the improved input functionality in your input interface, you only need toimportreadline:

importreadlinewhile(user_input:=input("> ")).lower()!="exit":print("You entered:",user_input)

Try running the code snippet above, which drops you into aninfinite loop that allows you to test input editing and history recall:

• Use theLeft andRight arrow keys to navigate within the input line.
• UseCtrl+A andCtrl+E to move to the beginning and end of the input line, respectively.
• Recall previous inputs using theUp andDown arrow keys.

You can exit the loop that you set up inimproved_input.py and end the example program by typingexit.

Integrating enhanced input features can significantly improve the user experience, especially in interactive applications like command-line tools or games:

This enhancement is particularly valuable in scenarios where users are expected to input commands frequently or make complex entries with frequent edits.

It’s important to note that the features provided byreadline andpyreadline3 are natively supported only in console environments and may not work in allIntegrated Development Environments (IDEs). IDEs often handle input differently from standard terminal environments.Additionally, some key bindings and functionalities may vary depending on the system configuration and the specific implementation of the module.

By extending the capabilities ofinput(), your programs can offer a more robust and user-friendly interface, accommodating smoother data entry and manipulation processes.

In the next section, you’ll continue to explore how you can refine output appearance and formatting using some advanced features ofprint().

Printing Output With Advanced Features

Theprint() function takes additional arguments that provide some control over the format of the output. Each of these is a special type of argument called akeyword argument.

Keyword arguments have the form<keyword>=<value>. You need to pass them at the end, after the list of objects that you want to display.

In this section, you’ll see how the following keyword arguments affect the console output thatprint() produces:

• sep: This argument allows you to specify how to separate multiple objects when they are printed.
• end: Use this argument to set what Python prints at the end of aprint() call.
• file: This allows you to redirect the output to any file-like object.
• flush: Use this argument toflush the output stream, effectively bypassing any buffering.

Adding the keyword argumentsep=<str> causes Python toseparate objects by<str> instead of by the default single space:

>>>print("input","output")input output>>>print("input","output",sep="/")input/output>>>print("input","output",sep="...")input...output>>>person={"first_name":"John","last_name":"Doe"}>>>forkey,valueinperson.items():...print(key,value,sep=" -> ")...first_name -> Johnlast_name -> Doe

In these examples, you’ve used different strings, such as"/","...", and" -> " to separate the objects that you’re askingprint() to display. You can use thesep keyword to specify any arbitrary string as the separator:

>>>print("input","output",sep="Real Python")inputReal Pythonoutput

However, passing a string such as"Real Python" as the separator will rarely make a lot of sense. In practice, you’ll probably want to stick with passing a well-readable separator symbol like in the previous examples.

To squish objects together without any space between them, you specify an empty string ("") as the separator:

>>>print("input","output",sep="")inputoutput

Finally, you can add a linebreak in between each item by passing the newline character (\n) tosep:

>>>print("input","output",sep="\n")inputoutput

Separating objects with a newline character displays each of them on an individual line, which can be helpful when you need to inspect more complex objects. Sometimes, you may even want to separate them with two consecutive newline characters (\n\n) to group your output better and make it more readable.

The keyword argumentend=<str> causes Python toterminate the output by<str> instead of by the default newline:

>>>first="John">>>last="Doe">>>print(first,last,end="!")John Doe!>>>

In this example, you’ve replaced the default newline end character with an exclamation mark. Notice how this breaks the usual neat way that callingprint() drops you into a new empty line. Now you get to see an exclamation mark followed directly by Python’s input prompt (>>>) because you toldprint() not to write a newline character.

You can also pass an empty string to this parameter to side-step the default newline functionality.For example, assume that you’re displaying values in a loop:

>>>fornumberinrange(10):...print(number)...0123456789

For such small values, you might want to display all values on one line, rather than on individual lines. You can accomplish this withend:

>>>fornumberinrange(10):...print(number,end=" ")...0 1 2 3 4 5 6 7 8 9 >>>

Note that your prompt slid back up into the output line again because you’re not using a newline as the output terminator. By callingprint() without any arguments just after the loop, you can avoid that, too:

>>>fornumberinrange(10):...print(number,end=" ")...print()...0 1 2 3 4 5 6 7 8 9>>>

When you don’t provide any values toprint(), it outputs a newline character, effectively moving the cursor to the next line. Alternatively, you can achieve the same effect with a bit of logic wrapped in aconditional expression:

>>>fornumberinrange(10):...print(number,end=(" "ifnumber<9else"\n"))...0 1 2 3 4 5 6 7 8 9>>>

Just like withsep, you can use any string as an argument to theend keyword, but some strings will make more sense than others as output terminators.

Theprint() function accepts two additional keyword arguments,file andflush, both of which affect how the function handles the output stream. If you want to learn how to work with these two additional keyword arguments, then you can read the in-depth guide aboutPython’sprint() function.

Conclusion

Now you know how to handle basic input and output operations in Python using theinput() andprint() functions. You’ve explored how to gather user input from the keyboard, process that input, and display it back to the user in a meaningful way. Additionally, you delved into some advanced features of theprint() function, such as formatting output with separators and controlling the newline character.

Understanding input and output is crucial for any Python developer, as these operations form the backbone of interacting with users and external systems. Knowing how to work with these tools allows you to create programs that are interactive, user-friendly, and capable of handling real-world data processing tasks.

In this tutorial, you’ve learned how to:

• Take user input from the keyboard withinput()
• Display output to the console withprint()
• Usereadline toimprove the user experience when collecting input on UNIX-like systems
• Format output using thesep andend keyword arguments ofprint()

With basic input and output handling skills, you can build interactive Python applications that efficiently communicate with users and process input data. This foundational knowledge prepares you for more advanced tasks, such as creatingcommand-line tools orGUI applications.

Take the Quiz: Test your knowledge with our interactive “Basic Input and Output in Python” quiz. You’ll receive a score upon completion to help you track your learning progress:

---

Interactive Quiz

Basic Input and Output in Python

In this quiz, you'll test your understanding of Python's built-in functions for user interaction, namely input() and print(). These functions allow you to capture user input from the keyboard and display output to the console, respectively.