How To Make Beautiful Command-Line Interfaces In Python?

Python provides several powerful libraries for creating beautiful and user-friendly command-line interfaces. We'll explore argparse, Click, and Docopt ? three popular approaches for building CLIs with different strengths and syntax styles.

Why Python for CLIs?

Python is an excellent choice for building command-line interfaces because of its clean, readable syntax and extensive library ecosystem. Python's cross-platform compatibility means your CLI will work on Windows, Linux, and macOS without modification. The language offers several specialized libraries that handle argument parsing, help generation, and user interaction seamlessly.

Using argparse

The argparse module is Python's built-in solution for parsing command-line arguments. It provides robust argument handling with type checking, help messages, and support for positional and optional arguments.

Example

import argparse

def main():
    parser = argparse.ArgumentParser(description='Add some integers.')
    parser.add_argument('integers', metavar='N', type=int, nargs='+', 
                       help='integer list')
    parser.add_argument('--sum', action='store_const', const=sum, 
                       default=max, help='sum the integers (default: find the max)')
    
    args = parser.parse_args()
    result = args.sum(args.integers)
    print(result)

if __name__ == '__main__':
    main()

This script accepts multiple integers and either finds the maximum (default) or sums them when the --sum flag is used. Running python script.py 1 2 3 4 returns 4, while python script.py 1 2 3 4 --sum returns 10.

Using Click

Click offers a more elegant approach with decorators and automatic help generation. First install it with pip install click.

Simple Click Example

import click

@click.command()
def main():
    click.echo("This is a CLI built with Click ?")

if __name__ == "__main__":
    main()

This is a CLI built with Click ?

Interactive Click Example

import click

@click.command()
@click.option('--name', prompt='Your name', help='The person to greet.')
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--verbose', is_flag=True, help='Print verbose output.')
def hello(name, count, verbose):
    """Simple program that greets NAME for a total of COUNT times."""
    for i in range(count):
        greeting = f'Hello, {name}!'
        if verbose:
            greeting += f' ({i+1}/{count})'
        click.echo(greeting)

if __name__ == '__main__':
    hello()

Running python script.py --name TutorialsPoint --count 3 --verbose produces:

Hello, TutorialsPoint! (1/3)
Hello, TutorialsPoint! (2/3)
Hello, TutorialsPoint! (3/3)

Using Docopt

Docopt takes a unique approach by parsing arguments based on usage patterns written in natural language. Install with pip install docopt.

Example

"""My CLI Tool

Usage:
  script.py hello <name>
  script.py goodbye <name>
  script.py --version

Options:
  --version     Show version.
"""

from docopt import docopt

def main(args):
    if args['--version']:
        print('My CLI Tool Version 1.0')
    elif args['hello']:
        print(f'Hello, {args["<name>"]}!')
    elif args['goodbye']:
        print(f'Goodbye, {args["<name>"]}!')

if __name__ == '__main__':
    args = docopt(__doc__, version='My CLI Tool Version 1.0')
    main(args)

Running python script.py hello TutorialsPoint outputs:

Hello, TutorialsPoint!

Comparison

Conclusion

Choose argparse for simple CLIs without external dependencies, Click for feature-rich applications with complex command structures, and Docopt when you want your usage documentation to drive the interface design. All three libraries enable you to create professional, user-friendly command-line tools in Python.