How to read users input using Python

If you’ve ever built a Python program, you know that sooner or later you’ll need to ask your users for input. Whether it’s a simple name prompt, a secure password, or structured data from a file, Python gives you plenty of ways to capture information. The trick is knowing which method to use — and how to avoid common pitfalls.

In this guide, we’ll walk through all the major input techniques, show you real examples, highlight mistakes beginners often make, and share best practices to make your code more professional.

Command Line Input (Interactive):

This is the classic and simple example of how to use the input() function to ask the user for their name and print a personalized greeting: The input() function reads a line of text from the standard input (usually the keyboard) and returns it as a string.

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print(f"Hello {name}, you are {age} years old.")

When you run above program, it will display the message “Enter your name: ” on the screen and wait for you to enter your name. Once the user has entered their name and pressed Enter, the program will again prompt for user to enter your age. Once the age is entered, it will then print a personalized greeting.

• Best for: Interactive scripts.
• Gotcha: input() always returns a string — don’t forget to convert types.
• Pro tip: Wrap conversions in try/except so your program doesn’t crash if someone types “abc” instead of a number.

You can also use the input() function in conjunction with loops and conditionals to create interactive programs that respond to user input. Here is an example that uses a loop to ask the user for a series of numbers and prints the sum of those numbers:

sum = 0
while True:
    num = input("Enter a number (or 'q' to quit): ")
    if num == 'q':
        break
    sum += int(num)
print("The sum is " + str(sum))

In this example, the program repeatedly asks the user for a number until the user enters the letter ‘q’. Each time the user enters a number, it is added to a running total. When the user enters ‘q’, the loop exits and the program prints the sum of the numbers.

Command Line Arguments (via sys.argv or argparse):

You can also read input from the command line by passing arguments to the Python script. Here’s an example. In this example, the first command-line argument is stored in the name variable and used to print a personalized greeting.

import sys
name = sys.argv[1]
print("Hello, " + name + "!")

For professional scripts, always try using argparse instead

import argparse

parser = argparse.ArgumentParser(description="Demo script")
parser.add_argument("filename", help="File to process")
parser.add_argument("--verbose", action="store_true", help="Enable detailed output")
args = parser.parse_args()

print(f"Processing {args.filename}, verbose={args.verbose}")

• Best for: Command-line tools.
• Why: It automatically generates help messages and validates input.

Standard Input Redirection / Piping:

sys.stdin.readline(): This function reads a line from the standard input stream (stdin) and returns it as a string. Here’s an example: In this example, the strip() method is used to remove any trailing whitespace from the input.

import sys

for line in sys.stdin:
    print(f"Received: {line.strip()}")

• Best for: When input is piped from another program.
• Example: cat data.txt | python script.py

Environment Variables

Environment variables allow Python applications to access configuration and secret data without hardcoding them into the source code. This is particularly useful for credentials, API keys, or environment-specific settings (like development vs. production). Using os.getenv(), you can safely retrieve environment variables, providing default values if necessary to avoid runtime errors. This method keeps sensitive data secure and makes applications more flexible across different environments.

import os

api_key = os.getenv("API_KEY", "default_key")
print(f"Using API key: {api_key}")

• Best for: Configurations and sensitive data.
• Tip: Never hardcode passwords or API keys.

Reading from Files:

File input is a fundamental way to ingest data in Python, often used for processing structured data like CSV, JSON, or text files. Using the built-in open() function combined with methods like .read(), .readlines(), or iteration, you can efficiently load file contents into your program.

with open("data.txt", "r") as f:
    for line in f:
        print(line.strip())

In this example, the open() function is used to open the file input.txt for reading. The with statement ensures that the file is properly closed when the block of code is finished. The for loop reads each line of the file and prints it to the screen after removing any trailing whitespace.

• Best for: Batch data processing.
• Tip: Always use with open() to avoid leaving files open.

Secure Input for Passwords

getpass.getpass(): This function prompts the user to enter a password without echoing the characters on the screen. Here’s an example:

import getpass

password = getpass.getpass("Enter your password: ")
print("Password received securely. Your password is " + password)

In this example, the getpass() function prompts the user to enter a password without displaying the characters on the screen. The password is then stored in the password variable.

Advanced Inputs

Python makes structured data easy:

##### JSON ########
import json
with open("config.json") as f:
    data = json.load(f)
print(data["username"])

###### CSV ##########
import csv
with open("data.csv") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

###### YAML ##########

import yaml
with open("config.yaml") as f:
    data = yaml.safe_load(f)
print(data["settings"])

Best Practices

• Validate and sanitize all input.
• Use argparse for command-line tools.
• Handle errors gracefully with try/except.
• Keep secrets out of code.
• Use context managers for files.
• Be clear with prompts.
• Support automation with sys.stdin.
• Document expected input clearly.

From simple input() prompts to advanced JSON configs, Python gives you flexible ways to handle user input. By practicing these techniques, avoiding common mistakes, and following best practices, you’ll write code that’s not only functional but also secure, professional, and user-friendly.

The codes (if any) mentioned in this post can be downloaded from github.com. Share the post with someone you think can benefit from the information