http://docs.python.org/reference/compound_stmts.html

Compound statements consist of one or more ‘clauses.’ A clause
consists of a header and a ‘suite.’ The clause headers of a particular
compound statement are all at the same indentation level. Each clause
header begins with a uniquely identifying keyword and ends with a
colon. A suite is a group of statements controlled by a clause. A
suite can be one or more semicolon-separated simple statements on the
same line as the header, following the header’s colon, or it can be
one or more indented statements on subsequent lines. Only the latter
form of suite can contain nested compound statements; the following is
illegal, mostly because it wouldn’t be clear to which if clause a
following else clause would belong:

if test1: if test2: print x

Also note that the semicolon binds tighter than the colon in this
context, so that in the following example, either all or none of the
print statements are executed:

if x < y < z: print x; print y; print z 

Summarizing:

compound_stmt ::=  if_stmt

                   | while_stmt

                   | for_stmt

                   | try_stmt

                   | with_stmt

                   | funcdef

                   | classdef

                   | decorated

suite         ::=  stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT

statement     ::=  stmt_list NEWLINE | compound_stmt

stmt_list     ::=  simple_stmt (";" simple_stmt)* [";"]

Python uses the ; as a separator, not a terminator. You can also use them at the end of a line, which makes them look like a statement terminator, but this is legal only because blank statements are legal in Python -- a line that contains a semicolon at the end is two statements, the second one blank.

Semicolon in the interpreter

Having read the answers, I still miss one important aspect of using semicolons, possibly the only one where it really makes a difference...

When you're working in an interpreter REPL (the Python interactive shell, IDLE, ipython) the value of the last expression is printed to the screen and usually this is the intended behavior.

Using an expression for side effects

But in some cases you want to evaluate an expression for its side effects only, e.g., to see the results of your simulation plotted by matplotlib.

In this cases you (probably) don't want to see the screenful of reprs of matplotlib objects that are sometimes returned by a call to a matplotlib function and one of the possibilities you have is to append a semicolon to the overly verbose statement, that immediately is composed by two expressions, the matplotlib invocation and a null statement, so that the value of the compound expression is None and nothing is printed to the screen by the interpreter
(the other possibility being assignment, as in _ = plot(...) but I find that a bit more intrusive).

Personal remark

IMHO, the use of the semicolon to suppress not desired output in the interpreter has become more relevant following the introduction of the IPyton notebook, that permits to save the input and the output, including graphical output, of an interpreter session for documentation and eventual reuse.

As everyone else has noted, you can use semicolons to separate statements. You don't have to, and it's not the usual style.

As for why this is useful, some people like to put two or more really trivial short statements on a single line (personally I think this turns several trivial easily skimmed lines into one complex-looking line and makes it harder to see that it's trivial).

But it's almost a requirement when you're invoking Python one liners from the shell using python -c '<some python code>'. Here you can't use indentation to separate statements, so if your one-liner is really a two-liner, you'll need to use a semicolon. And if you want to use other arguments in your one-liner, you'll have to import sys to get at sys.argv, which requires a separate import statement. e.g.

python -c "import sys; print ' '.join(sorted(sys.argv[1:]))" 5 2 3 1 4

1 2 3 4 5

A quote from "When Pythons Attack"

Don't terminate all of your statements with a semicolon. It's technically legal to do this in Python, but is totally useless unless you're placing more than one statement on a single line (e.g., x=1; y=2; z=3).

Multiple statements on one line may include semicolons as separators. For example: http://docs.python.org/reference/compound_stmts.html In your case, it makes for an easy insertion of a point to break into the debugger.

Also, as mentioned by Mark Lutz in the Learning Python Book, it is technically legal (although unnecessary and annoying) to terminate all your statements with semicolons.

Semicolons are part of valid syntax: 8. Compound statements (The Python Language Reference)

Python does let you use a semi-colon to denote the end of a statement if you are including more than one statement on a line.

Semicolons can be used to one line two or more commands. They don't have to be used, but they aren't restricted.

The semicolon ( ; ) allows multiple statements on the single line given that neither statement starts a new code block.

http://www.tutorialspoint.com/python/python_basic_syntax.htm

Semicolons (like dots, commas and parentheses) tend to cause religious wars. Still, they (or some similar symbol) are useful in any programming language for various reasons.

• Practical: the ability to put several short commands that belong conceptually together on the same line. A program text that looks like a narrow snake has the opposite effect of what is intended by newlines and indentation, which is highlighting structure.




• Conceptual: separation of concerns between pure syntax (in this case, for a sequence of commands) from presentation (e.g. newline), in the old days called "pretty-printing".

Observation: for highlighting structure, indentation could be augmented/replaced by vertical lines in the obvious way, serving as a "visual ruler" to see where an indentation begins and ends. Different colors (e.g. following the color code for resistors) may compensate for crowding.

I realize I am biased as an old C programmer, but there are times when the various Python conventions make things hard to follow. I find the indent convention a bit of an annoyance at times.

Sometimes, clarity of when a statement or block ends is very useful. Standard C code will often read something like this:

for(i=0; i<100; i++) {

    do something here;

    do another thing here;

}



continue doing things;

where you use the whitespace for a lot of clarity - and it is easy to see where the loop ends.

Python does let you terminate with an (optional) semicolon. As noted above, that does NOT mean that there is a statement to execute followed by a 'null' statement. SO, for example,

print(x);

print(y);

Is the same as

print(x)

print(y)

If you believe that the first one has a null statement at the end of each line, try - as suggested - doing this:

print(x);;

It will throw a syntax error.

Personally, I find the semicolon to make code more readable when you have lots of nesting and functions with many arguments and/or long-named args. So, to my eye, this is a lot clearer than other choices:

if some_boolean_is_true:

    call_function(

        long_named_arg_1,

        long_named_arg_2,

        long_named_arg_3,

        long_named_arg_4

    );

since, to me, it lets you know that last ')' ends some 'block' that ran over many lines.

I personally think there is much to much made of PEP style guidelines, IDEs that enforce them, and the belief there is 'only one Pythonic way to do things'. If you believe the latter, go look at how to format numbers: as of now, Python supports four different ways to do it.

I am sure I will be flamed by some diehards, but the compiler/interpreter doesn't care if the arguments have long or short names, and - but for the indentation convention in Python - doesn't care about whitespace. The biggest problem with code is giving clarity to another human (and even yourself after months of work) to understand what is going on, where things start and end, etc.