What Is Python?

Which problems Python is built for

Before any syntax, it helps to know what kind of work this language is aimed at. Python is a high-level, interpreted programming language suited to scripting and rapid application development. In practice that means two situations: a computer task that should be automated, and a first working version that should exist quickly rather than after a long build cycle.

The introductory documentation names the jobs directly:

Those six jobs look unrelated, yet they share a shape. Each one is either work a person is doing by hand and should stop doing by hand, or work whose first draft is being delayed by the write, compile, test and re-compile cycle.

That is the honest way to decide whether Python fits a problem. Ask what the input is, what output is wanted, and how often it must happen. If the answer is "often, and the rule is easy to state", the task belongs to a program. If the answer is "once, and I only need to move a file", a shell command may still be the shorter route.

More than a shell script, simpler than C

You could write a Unix shell script or a Windows batch file for some of these tasks. Shell scripts are best at moving files around and changing text data, and they are weak once the job becomes a graphical application or a game. You could also write a C, C++ or Java program, but getting even a first-draft program can take a lot of development time.

Python sits between those two options, and stays a real programming language while doing so.

Two properties do most of the work in that middle position.

• Python provides more structure and support for large programs than shell scripts or batch files. Programs can be split into named units instead of growing into one long file.
• Python supplies high-level built-in data types, including flexible arrays and dictionaries, that help express complex operations compactly. Because its data types are general, Python applies to a much wider problem domain than tools such as Awk or Perl, while many of the same things stay at least as easy.

Python also offers much more error checking than C. "Simple to use" is not the same as "limited": the same language covers the small automation job and the program it grows into.

Why the development loop is short

Python is an interpreted language, and Python programs do not require a separate compilation and linking step before the interpreter can run them. For development, that changes the rhythm of the day. An edit can be tried immediately, so a wrong assumption is discovered in seconds instead of after a build.

The second half of that benefit is the interactive prompt. The interpreter can also be used interactively to experiment with language features, create throw-away programs, and test functions during development. It doubles as a handy desk calculator.

Put together, the two properties turn development into a conversation rather than a series of builds. A function can be written, called with one awkward value, corrected and called again before it ever becomes part of a program. That is what bottom-up development means in practice: the small pieces are known to work before the whole is assembled.

Programs that stay short and readable

Programs written in Python are typically much shorter than equivalent C, C++ or Java programs. Three properties explain most of that difference, and all three are worth recognizing early because they shape how Python code looks.

• High-level data types can express complex operations in one statement, so a loop and a temporary structure often collapse into a single line.
• Indentation groups statements, instead of beginning and ending brackets. Layout and meaning are the same thing.
• Variables and arguments need no declarations, so a small experiment can be written without ceremony.

Shorter is not weaker here. Error checking is stronger than in C, and the language still offers modules, classes and exceptions when the program needs them.

One language across your machines

Python is available on Windows, macOS, and Unix operating systems. For a small tool that has to work on a colleague's laptop, your own machine and a server, that availability is the difference between one program and three platform-specific rewrites.

Portability is a property of the language and its interpreter, not a promise that every detail of an operating system disappears. What it does guarantee is that the program itself, and everything you learn about writing it, travels between those systems.

Portability is only useful if the program can actually reach the system it runs on, and that is the job of the modules that come with Python. Python's standard modules include facilities for file input and output, system calls, sockets, and graphical user interfaces — including interfaces to toolkits such as Tk. Those modules can serve as the basis of your programs, or simply as examples while learning.

The practical effect is that a first version rarely has to invent common machinery. Reading a file, talking to the operating system or opening a socket is already available, which is a large part of why the first draft arrives quickly.

Working with code that is not Python

A project rarely starts from nothing. There may be a C library that must stay where it is, or an application that needs to become programmable. Python can be extended with functions or modules implemented in C or C++, and its interpreter can be embedded in another application as an extension or command language.

Those are two directions of the same door:

Embedding is the case that answers the very first motivation on the list: a program that could use an extension language, whose author does not want to design and implement a whole new one for it.

Extending answers a different worry. Choosing Python for the program as a whole does not mean giving up existing native code — a vendor-specific graphics library available only in binary form, or an operation that must run at maximum speed, can stay in C and be reached from Python. The high-level language and the low-level code cooperate instead of competing for the whole project.

Key takeaways

Choosing a language is a judgement, not a slogan, so it is worth stating when Python is the right answer and when it is not. Python fits when a task benefits from readable code, quick experimentation, automation, portability across the major desktop operating systems, or reuse through modules. A shell script may remain appropriate for narrowly moving files or changing text data, and a lower-level compiled language may be chosen under other constraints.

• Python combines high-level programming structure with interpreted execution for scripting and rapid application development. It is chosen when readable code, quick experimentation, automation, portability or reuse through modules matter.
• The interactive interpreter supports experimentation and function testing without a separate compile-and-link cycle, so ideas can be validated before they become maintained programs.
• Python spans automation, reusable programs, and extensible applications on Windows, macOS, and Unix. One language carries the small job and the program it becomes.
• The built-in reach — file input and output, system calls, sockets, graphical interfaces — plus extension and embedding in C means a program can grow beyond its first expression without recreating every common facility.