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

составные высказывания состоят из одного или нескольких пунктов.’ Пункт состоит из заголовка и люкс.'Заголовки предложений конкретного составной оператор-все на том же уровне отступа. Каждый пункт заголовок начинается с однозначного определения ключевого слова и заканчивается двоеточие. Набор-это группа операторов, управляемых предложением. A люкс может быть один или несколько простые операторы, разделенные точкой с запятой та же строка, что и заголовок, после двоеточия заголовка, или это может быть один или несколько отступов в последующих строках. Только последний форма пакета может содержать вложенные составные операторы; ниже незаконно, в основном потому, что не было бы ясно, к какому пункту if a следующее предложение else будет принадлежать:

if test1: if test2: print x

также обратите внимание, что точка с запятой связывается более плотно, чем двоеточие в этом контекст, так что в в следующем примере либо все, либо ни один из выполняются операторы печати:

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

подведение итогов:

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 использует ; как разделитель, а не терминатор. Вы также можете использовать их в конце строки, что делает их посмотреть как Терминатор оператора, но это законно только потому, что пустые операторы являются законными в Python-строка, содержащая точку с запятой в конце, - это два оператора, второй-пустой.

точка с запятой в переводчик

прочитав ответы, я все еще пропускаю один важный аспект использования точек с запятой, возможно, единственный, где это действительно имеет значение...

когда вы работаете в интерпретаторе REPL (интерактивная оболочка Python, IDLE, ipython), значение последнего выражения выводится на экран, и обычно это предполагаемое поведение.

используя выражение для побочных эффектов

но в некоторых случаях вы хотите оценить выражение только для его побочных эффектов, например, чтобы увидеть результаты вашего моделирования, построенные matplotlib.

в этом случае вы (вероятно) не хотите видеть полный экран reprС matplotlib объекты, которые иногда возвращаются при вызове matplotlib функция и одна из возможностей у вас есть, чтобы добавить точку с запятой в излишне многословен утверждение, которое сразу же состоит из двух выражений, то matplotlib вызов и значение null оператор, так что значение составного выражения None и ничего не печатается на экране переводчика (другая возможность -задание, а в _ = plot(...) но я нахожу это немного более навязчивый).

личное замечание

IMHO, использование точки с запятой для подавления нежелательного вывода в интерпретаторе стало более актуальным после введения ноутбука IPyton, что позволяет сохранить вход и выход, включая графический вывод, сеанс интерпретатора для документации и возможного повторного использования.

как все остальные заметили, вы можете использовать точку с запятой для разделения операторов. Ты же не есть и это не привычный стиль.

Что касается того, почему это полезно, некоторые люди любят помещать два или более действительно тривиальных коротких утверждения в одну строку (лично я думаю, что это превращает несколько тривиальных легко просматриваемых строк в одну сложную линию и затрудняет понимание того, что это тривиально).

но это почти требование, когда вы вызываете Python one liners из оболочки с помощью python -c '<some python code>'. Вот ты не могу используйте отступ для разделения операторов, поэтому, если ваш однострочный действительно двухстрочный, вам нужно будет использовать точку с запятой. И если вы хотите использовать другие аргументы в одном лайнере, вам придется импортировать sys получить в sys.argv, что требует отдельного import заявление. например,

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

цитата из "Когда Питоны Нападают"

не завершайте все ваши заявления точкой с запятой. Это технически законно сделать это в Python, но совершенно бесполезно, если вы не размещаете более одного оператора в одной строке (например, x=1; y=2; z=3).

несколько операторов в одной строке могут содержать точки с запятой в качестве разделителей. Например:http://docs.python.org/reference/compound_stmts.html в вашем случае это позволяет легко вставлять точку для взлома отладчика.

также, как упоминал Марк лутц в Изучение Книги Python, это технически законно (хотя ненужно и раздражает), чтобы прекратить все ваши заявления с точками с запятой.

Python позволяет использовать точку с запятой для обозначения конца оператора, если вы включаете более одного оператора в строке.

точки с запятой можно использовать в одной строке две или более команд. Они не должны использоваться, но они не ограничены.

точка с запятой (;) допускает несколько операторов в одной строке, учитывая, что ни один оператор не запускает новый блок кода.

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

точки с запятой (как точки, запятые и круглые скобки), как правило, вызывают религиозные войны. Тем не менее, они (или некоторые подобные символы) полезны в любом языке программирования по разным причинам.

• практически: способность положить несколько коротких команд которые принадлежат концептуально совместно на такую же линию. Текст программы, который выглядит как узкая змея, имеет противоположный эффект от того, что предназначено для новых строк и отступов, которые выделяются структура.

• Conceptual: разделение проблем между чистым синтаксисом (в данном случае для последовательности команд) от представления (например, новой строки), в старые времена называлось "pretty-printing".

наблюдение: для выделения структуры отступ может быть увеличен/заменен вертикальными линиями очевидным образом, служа "визуальной линейкой", чтобы увидеть, где начинается и заканчивается отступ. Различные цвета (например, следуя цветовому коду для резисторы) могут компенсировать скученность.

точки с запятой являются частью допустимый синтаксис: 8. Составные операторы (Ссылка На Язык Python)

Я понимаю, что я предвзят, как старый программист C, но бывают случаи, когда различные соглашения Python делают вещи трудно следовать. Я нахожу отступ конвенции немного раздражает время от времени.

иногда, ясность, когда оператор или блок заканчивается очень полезно. Стандартный код C часто будет читать что-то вроде этого:

for(i=0; i<100; i++) {
    do something here;
    do another thing here;
}

continue doing things;

где вы используете пробелы для большей ясности-и легко увидеть, где заканчивается цикл.

Python позволяет вы завершаете с (необязательной) точкой с запятой. Как отмечалось выше, это не означает, что существует оператор для выполнения, за которым следует оператор 'null'. Так, например,

print(x);
print(y);

это то же самое, что

print(x)
print(y)

если вы считаете, что первый имеет нулевой оператор в конце каждой строки, попробуйте-как было предложено-сделать это:

print(x);;

это вызовет синтаксическую ошибку.

лично я нахожу точку с запятой, чтобы сделать код более читабельным, когда вы есть много вложенности и функций с большим количеством аргументов и / или длинных именованных аргументов. Так что, на мой взгляд, это намного яснее, чем другие варианты:

if some_boolean_is_true:
    call_function(
        long_named_arg_1,
        long_named_arg_2,
        long_named_arg_3,
        long_named_arg_4
    );

так как, для меня, это позволяет вам знать, что последний ') 'заканчивается некоторым 'блоком', который пробежал по многим строкам.

я лично думаю, что есть много, чтобы многое сделано из руководящих принципов стиля PEP, IDE, которые их применяют, и вера в то, что есть "только один Питонический способ делать вещи". Если вы верите в последнее, посмотрите, как форматировать числа: по состоянию на теперь, Python поддерживает четыре различные способы сделать это.

Я уверен, что меня будут сжигать некоторые несгибаемые, но компилятор/интерпретатор не заботится о том, имеют ли аргументы длинные или короткие имена, и - но для соглашения об отступах в Python - не заботится о пробелах. Самая большая проблема с кодом - дать ясность другому человеку (и даже самому себе после нескольких месяцев работы), чтобы понять, что происходит, где все начинается и заканчивается и т. д.