Python

Операторы

Набор операторов достаточно традиционен.

• Условный оператор if (если). При наличии нескольких условий и альтернатив применяется необязательный блок elif(сокращение от else if), который может повторяться в коде неограниченное число раз. Если ни одно из условий не было соблюдено, то выполняется необязательный блок else (иначе).
• Оператор цикла while.
• Оператор итерации for.
• Операторы обработки исключений try — except — else — finally.
• Оператор определения класса class.
• Оператор определения функции, метода или генератора def. Внутри возможно применение return (возврат) для возврата из функции или метода, а в случае генератора — yield (давать).
• Оператор сопоставления с образцом match — case.
• Операторы вызова исключений raise и assert.
• Оператор pass ничего не делает. Используется для пустых блоков кода.

Система отступов

Одной из интересных синтаксических особенностей языка является выделение блоков кода с помощью отступов (пробелов или табуляций), поэтому в Python отсутствуют операторные скобки begin/end, как в языке Паскаль, или фигурные скобки, как в Си. Такой «трюк» позволяет сократить количество строк и символов в программе и приучает к «хорошему» стилю программирования. С другой стороны, поведение и даже корректность программы может зависеть от начальных пробелов в тексте. Тем, кто привык программировать на языках с явным выделением начала и конца блоков, такое поведение поначалу может показаться неинтуитивным и неудобным.

Сам Гвидо писал^[83]:

Наверное, самой спорной особенностью Python является использование отступов для группировки операторов, что взято непосредственно из ABC. Это одна из особенностей языка, которая дорога моему сердцу. Это делает код Python более читабельным двумя способами. Во-первых, использование отступов уменьшает визуальное нагромождение и делает программы короче, тем самым сокращая объём внимания, необходимого для восприятия базовой единицы кода. Во-вторых, это даёт программисту меньше свободы в форматировании, тем самым делая возможным более единообразный стиль, что облегчает чтение чужого кода (сравните, например, три или четыре различных соглашения о размещении фигурных скобок в Си, каждое из которых имеет сильных сторонников).

Оригинальный текст (англ.)

Perhaps Python's most controversial feature is its use of indentation for statement grouping, which derives directly from ABC. It is one of the language's features that is dearest to my heart. It makes Python code more readable in two ways. First, the use of indentation reduces visual clutter and makes programs shorter, thus reducing the attention span needed to take in a basic unit of code. Second, it allows the programmer less freedom in formatting, thereby enabling a more uniform style, which makes it easier to read someone else's code. (Compare, for instance, the three or four different conventions for the placement of braces in C, each with strong proponents.)

Выражения

Состав, синтаксис, ассоциативность и приоритет операций достаточно привычны для языков программирования и призваны минимизировать употребление скобок. Если сравнивать с математикой, то приоритеты операторов зеркалируют соответствующие в математике, при этом оператор присвоения значения = соответствует типографскому ←. Хотя приоритеты операций позволяют не использовать скобки во многих случаях, на анализ больших выражений может тратиться лишнее время, в результате чего в таких случаях выгоднее явно расставлять скобки^[34].

Отдельно стоит упомянуть операцию форматирования для строк (работает по аналогии с функцией printf() из Си), которая использует тот же символ, что и взятие остатка от деления:

>>> str_var = "world"
>>> print("Hello, %s" % str_var)
Hello, world

В версии 3.6 были добавлены форматированные строковые литералы, или f-строки, которые делают код более читаемым и лаконичным:

>>> str_var = "world"
>>> print(f"Hello, {str_var}") # вывод с использованием f-строки
Hello, world

Python имеет удобные цепочечные сравнения:

1 <= a < 10 and 1 <= b < 20

Кроме того, логические операции (or и and) являются ленивыми: если для вычисления значения операции достаточно первого операнда, этот операнд и является результатом, в противном случае вычисляется второй операнд логической операции. Это основывается на свойствах алгебры логики: например, если один аргумент операции «ИЛИ» (or) является истиной, то и результат этой операции всегда является истиной. В случае, если второй операнд является сложным выражением, это позволяет сократить издержки на его вычисление. Этот факт широко использовался до версии 2.5 вместо условной конструкции:

a < b and "меньше" or "больше или равно"

Встроенные типы данных, как правило, имеют особый синтаксис для своих литералов (записанных в исходном коде констант):

"строка и Юникод-строка одновременно"
'строка и Юникод-строка одновременно'
"""тоже строка и Юникод-строка одновременно"""
True or False  # булевы литералы
3.14  # число с плавающей запятой
0b1010 + 0o12 + 0xA  # числа в двоичной, восьмеричной и шестнадцатеричной системах счисления
1 + 2j  # комплексное число
[1, 2, "a"]  # список
(1, 2, "a")  # кортеж
{'a': 1, 'b': 'B'}  # словарь
{'a', 6, 8.8}  # множество
lambda x: x**2  # анонимная функция
(i for i in range(10)) # генератор

Для списков (и других последовательностей) Python предлагает набор операций над срезами. Особенностью является индексация, которая может показаться новичку странной, но раскрывает свою согласованность по мере использования. Индексы элементов списка начинаются с нуля. Запись среза s[N:M] означает, что в срез попадают все элементы от N включительно до M, не включая. При этом индекс можно не указывать. Например, запись s[:M] означает, что в срез попадают все элементы с самого начала; запись s[N:] означает, что попадают все элементы до конца среза; запись s[:] означает, что попадают все элементы с начала и до конца.

Имена

Имя (идентификатор) может начинаться с буквы любого алфавита в Юникоде любого регистра или подчёркивания, после чего в имени можно использовать и цифры. В качестве имени нельзя использовать ключевые слова (их список можно узнать по import keyword; print(keyword.kwlist)) и нежелательно переопределять встроенные имена. Имена, начинающиеся с символа подчёркивания, имеют специальное значение^[84].

В каждой точке программы интерпретатор имеет доступ к трём пространствам имён (то есть отображениям имён в объекты): локальному, глобальному и встроенному.

Области видимости имён могут быть вложенными друг в друга (внутри определяемой функции видны имена из окружающего блока кода). На практике с областями видимости и связыванием имён связано несколько правил «хорошего тона», о которых можно подробнее узнать из документации.

Строки документации

Python предлагает механизм документирования кода pydoc. В начало каждого модуля, класса, функции вставляется строка документации — docstring. Строки документации остаются в коде на момент времени исполнения, и в язык встроен доступ к документации^[85] (переменная __doc__), что используется современными IDE.

В интерактивном режиме можно получить помощь, сгенерировать гипертекстовую документацию по целому модулю или даже применить doctest для автоматического тестирования модуля.

Объектно-ориентированное программирование

Дизайн языка Python построен вокруг объектно-ориентированной модели программирования (ООП). Реализация ООП в Python является хорошо продуманной, но вместе с тем достаточно специфической по сравнению с другими объектно-ориентированными языками. В языке всё является объектами — либо экземплярами классов, либо экземплярами метаклассов. Исключением является базовый встроенный метакласс type. Таким образом, классы на самом деле являются экземплярами метаклассов, а производные метаклассы являются экземплярами метакласса type. Метаклассы являются частью концепции метапрограммирования и предоставляют возможность управления наследованием классов, что позволяет создавать абстрактные классы, регистрировать классы или добавлять в них какой-либо программный интерфейс в рамках библиотеки или фреймворка^[2].

Классы по своей сути представляют план или описание того, как создать объект, и хранят в себе описание атрибутов объекта и методов для работы с ним. Парадигма ООП основывается на инкапсуляции, наследовании и полиморфизме^[90]. Инкапсуляция в Python представлена возможностью хранения публичных и скрытых атрибутов (полей) в объекте с предоставлением методов для работы с ними^[90], при этом на самом деле все атрибуты являются публичными, но для пометки скрытых атрибутов существует соглашение об именовании^[91]. Наследование позволяет создавать производные объекты без необходимости повторного написания кода, а полиморфизм заключается в возможности переопределения любых методов объекта (в Python все методы являются виртуальными^[91]), а также в перегрузке методов и операторов. Перегрузка методов в Python реализуется за счёт возможности вызова одного и того же метода с разным набором аргументов^[90]. Особенностью Python является возможность модифицировать классы после их объявления, добавляя в них новые атрибуты и методы^[34], также можно модифицировать и сами объекты, в результате чего классы могут использоваться как структуры для хранения произвольных данных^[91].

В Python поддерживается множественное наследование^[92]. Само по себе множественное наследование является сложным, и его реализации сталкиваются с проблемами разрешения коллизий имён между родительскими классами и с возможным повторным наследованием от одного и того же класса в иерархии^[92]. В Python методы вызываются согласно порядку разрешения методов (MRO), который основан на алгоритме C3-линеаризации^[92], в обычных случаях при написании программ не требуется знать принцип работы данного алгоритма, понимание же может потребоваться при создании нетривиальных иерархий классов^[93].

Возможности и особенности, специфичные для Python:

• Специальные методы, управляющие жизненным циклом объекта: конструкторы, деструкторы.
• Перегрузка операторов (всех, кроме is, '.', '=' и символьных логических).
• Свойства (имитация поля с помощью функций).
• Управление доступом к полям (эмуляция полей и методов, частичный доступ, и т. п.).
• Методы для управления наиболее распространёнными операциями (истинностное значение, len(), глубокое копирование, сериализация, итерация по объекту, …).
• Полная интроспекция.
• Классовые и статические методы, классовые поля.
• Классы, вложенные в функции и классы.
• Возможность модифицировать объекты во время исполнения программы.

Обобщённое программирование

Языки с поддержкой динамической типизации и объектно-ориентированного программирования обычно не рассматриваются в рамках обобщённого программирования, поскольку задачи обобщённого программирования решаются за счёт отсутствия ограничений на типы данных^[19][20]. В Python обобщённое программирование со строгой типизацией достигается использованием средств языка совместно со внешними анализаторами кода^[94], такими как Mypy^[95].

Функциональное программирование

Несмотря на то, что Python изначально не задумывался как язык функционального программирования^[96], он поддерживает функциональный стиль программирования, в частности^[97]:

• функция является объектом первого класса,
• функции высших порядков,
• рекурсия,
• фокус на работу со списками,
• аналог замыканий,
• частичное применение функции с помощью метода partial(),
• возможность реализации других средств на самом языке (например, карринг).

Однако, в отличие от большинства языков, непосредственно ориентированных на функциональное программирование, Python не является чистым языком программирования и код не защищён от побочных эффектов^[97][98].

В стандартной библиотеке Python существуют специальные пакеты operator и functools для функционального программирования^[96].

Метапрограммирование

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (8 февраля 2023)

Python поддерживает метапрограммирование^[99][2].

Асинхронное программирование

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (9 октября 2023)
Комментарий: Асинхронное программирование на Python

Python, начиная с 3.5, стал поддерживать асинхронное программирование. Появились операторы async и await, а также библиотека asyncio^[3]

import asyncio

async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')

asyncio.run(main())

async является атрибутом, который создаёт асинхронную функцию^[3].

await позволяет выполнять асинхронные генераторы^[3].

Модули и пакеты

Программное обеспечение (приложение или библиотека) на Python оформляется в виде модулей, которые в свою очередь могут быть собраны в пакеты. Модули могут располагаться как в каталогах, так и в ZIP-архивах. Модули могут быть двух типов по своему происхождению: модули, написанные на «чистом» Python, и модули расширения (extension modules), написанные на других языках программирования. Например, в стандартной библиотеке есть «чистый» модуль pickle и его аналог на Си: cPickle. Модуль оформляется в виде отдельного файла, а пакет — в виде отдельного каталога. Подключение модуля к программе осуществляется оператором import. После импорта модуль представлен отдельным объектом, дающим доступ к пространству имён модуля. В ходе выполнения программы модуль можно перезагрузить функцией reload().

Интроспекция

Python поддерживает полную интроспекцию времени исполнения^[100]. Это означает, что для любого объекта можно получить всю информацию о его внутренней структуре.

Применение интроспекции является важной частью того, что называют Pythonic style, и широко применяется в библиотеках и фреймворках Python, таких как PLY, Cherry, Django и др., значительно экономя время использующего их программиста.

Необходимые для интроспекции данные хранятся в специальных атрибутах. Так, например, получить все пользовательские атрибуты большинства объектов можно из специального атрибута — словаря (или другого объекта, предоставляющего интерфейс dict) __dict__

 >>> class x(object):pass
 ....
 >>> f = x()
 >>> f.attr = 12
 >>> print(f.__dict__)
 {'attr': 12}
 >>> print(x.__dict__)       # т.к. классы тоже являются экземплярами объекта type
                            # то и они поддерживают этот тип интроспекции
 {'__dict__': <attribute '__dict__' of 'x' objects>, '__module__'.......

Есть также другие атрибуты, имена и назначение которых зависят от объекта:

 >>> def f():pass
 ....
 >>> f.func_code.co_code    # получение байтокода функции
 'd\x00\x00S'
 >>> f.__class__            # специальный атрибут - ссылка на класс данного объекта
 <type 'function'>

Подавляющее большинство атрибутов, поддерживающих интроспекцию, является классовым, и их, в свою очередь, можно получить из obj.__class__.__dict__. Часть информации, унаследованную от базового класса, все объекты используют совместно, что позволяет экономить память.

Для удобства получения интроспективной информации в Python есть модуль inspect^[101].

 >>> def f(x,y = 10,**mp):pass
 ...
 >>> inspect.getargspec(f)
 (['x', 'y'], None, 'mp', (10,))

С помощью модуля new возможен обратный процесс — построения объекта из составных частей на этапе исполнения

 >>> def f(i): return j + i
 ....
 >>> j = 2
 >>> f(1)
 3
 >>> import new
 >>> g = new.function(f.func_code, {'j': 23})
 >>> g(1)
 24

Обработка исключений

Обработка исключений поддерживается в Python посредством операторов try, except, else, finally, raise, образующих блок обработки исключения. В общем случае блок выглядит следующим образом:

try:
    # Здесь код, который может вызвать исключение
    raise Exception("message")  # Exception, это один из стандартных типов исключения (всего лишь класс),
                                # может использоваться любой другой, в том числе свой
except (Тип исключения1, Тип исключения2, …) as Переменная:
    # Код в блоке выполняется, если тип исключения совпадает с одним из типов
    # (Тип исключения1, Тип исключения2, …) или является наследником одного
    # из этих типов.
    # Полученное исключение доступно в необязательной Переменной.
except (Тип исключения3, Тип исключения4, …) as Переменная:
    # Количество блоков except не ограничено
    raise  # Сгенерировать исключение "поверх" полученного; без параметров - повторно сгенерировать полученное
except:
    # Будет выполнено при любом исключении, не обработанном типизированными блоками except
else:
    # Код блока выполняется, если не было поймано исключений.
finally:
    # Будет исполнено в любом случае, возможно после соответствующего
    # блока except или else

Совместное использование else, except и finally стало возможно только начиная с Python 2.5. Информация о текущем исключении всегда доступна через sys.exc_info(). Кроме значения исключения, Python также сохраняет состояние стека вплоть до точки возбуждения исключения — так называемый traceback.

В отличие от компилируемых языков программирования, в Python использование исключения не приводит к значительным накладным расходам (а зачастую даже позволяет ускорить исполнение программ) и очень широко используется. Исключения согласуются с философией Python (10-й пункт «дзена Python» — «Ошибки никогда не должны умалчиваться») и являются одним из средств поддержки «утиной типизации».

Иногда вместо явной обработки исключений удобнее использовать блок with (доступен, начиная с Python 2.5).

Итераторы

В программах на Python широко используются итераторы. Цикл for может работать как с последовательностью, так и с итератором. Большинство коллекций предоставляет итераторы, итераторы могут также определяться пользователем для собственных объектов. Модуль itertools стандартной библиотеки содержит средства работы с итераторами.

Генераторы

Одной из интересных возможностей языка являются генераторы — функции, сохраняющие внутреннее состояние: значения локальных переменных и текущую инструкцию (см. также: сопрограммы). Генераторы могут использоваться как итераторы для структур данных и для ленивых вычислений.

При вызове генератора функция немедленно возвращает объект-итератор, который хранит текущую точку исполнения и состояние локальных переменных функции. При запросе следующего значения (посредством метода next(), неявно вызываемого в цикле for) генератор продолжает исполнение функции от предыдущей точки остановки до следующего оператора yield или return.

В Python 2.4 появились генераторные выражения — выражения, дающие в результате генератор. Генераторные выражения позволяют сэкономить память там, где иначе требовалось бы использовать список с промежуточными результатами:

>>> sum(i for i in range(1, 100) if i % 2 != 0)
2500

В этом примере суммируются все нечётные числа от 1 до 99.

Начиная с версии 2.5, Python поддерживает полноценные сопроцедуры: теперь в генератор можно передавать значения с помощью метода send() и возбуждать в его контексте исключения с помощью метода throw().

Также Python поддерживает вложенные генераторы. Например, для создания двумерного массива нужно разместить генератор списка, являющегося строкой, внутри генератора всех строк: [[0 for j in range(m)] for i in range(n)]

Управление контекстом выполнения

В Python 2.5 появились средства для управления контекстом выполнения блока кода — оператор with и модуль contextlib. См.: пример.

Оператор может применяться в тех случаях, когда до и после некоторых действий должны обязательно выполняться некоторые другие действия, независимо от возбуждённых в блоке исключений или операторов return: файлы должны быть закрыты, ресурсы освобождены, перенаправление стандартного ввода вывода закончено и т. п. Оператор улучшает читаемость кода, а значит, помогает предотвращать ошибки.

Декораторы

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (8 февраля 2023)

Декораторы функций — вызываемые объекты, которые принимают другую функцию в качестве аргумента. Декораторы функций могут производить операции с функцией и возвращают либо саму функцию, либо другую заменяющую её функцию или вызываемый объект. То есть, если в коде ранее был прописан декоратор, названный decorate, то следующий код^[102]:

@decorate
def target():
    print('running target()')

эквивалентен этому^[102]:

def target():
    print('running target()')
target = decorate(target)

Это позволяет сократить использование кода.

Пример использования декоратора функции^[102]:

>>> def deco(func):
...     def inner():
...         print('running inner()')
...     return inner
…
>>> @deco
... def target():
...     print('running target()')
>>> target()
running inner()
>>> target
<function deco.<locals>.inner at 0.10063b598>

Существуют декораторы классов^[103].

Регулярные выражения

Формат регулярных выражений унаследован из Perl с некоторыми отличиями. Для их использования требуется импортировать модуль re^[104], являющийся частью стандартной библиотеки.

C++ и Java

Python сравнивается с C++/Java с точки зрения лаконичности, простоты и гибкости Python^[112]. Можно сравнить «Hello, world»-программы, записанные на каждом из языков^[112].

#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
    return 0;
}

public class HelloClass {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

print("Hello, world!")

Касательно ООП, в Python, в отличие от C++ и Java, отсутствуют модификаторы доступа к полям и методам класса, атрибуты и поля у объектов могут создаваться на лету в ходе исполнения программы, а все методы являются виртуальными. По сравнению с Java Python позволяет также перегружать операторы, что даёт возможность использовать выражения, близкие к естественным^[112]. В совокупности подход к ООП в Python упрощает программирование, делает код более понятным и одновременно добавляет гибкости языку^[112]. С другой стороны, скорость выполнения кода на Python (как и других интерпретируемых языков) значительно ниже, чем скорость выполнения аналогичного кода на C++^[113] и обычно ожидается ниже, чем в Java^[114]. Код на C++ получается производительнее Python, при этом занимает больше строк. Согласно исследованиям алгоритмов, применяемых в биоинформатике, Python показал себя более гибким, чем C++, а Java оказалась компромиссным решением между производительностью C++ и гибкостью Python^[111].

В Java и Python все объекты создаются в куче, в то время как C++ позволяет создавать объекты как в куче, так и на стеке, в зависимости от используемого синтаксиса^[115]. На производительность также влияет способ доступа к данным в памяти. В C++ и Java доступ к данным происходит по постоянным смещениям в памяти, в то время как в Python — через хеш-таблицы. Использование указателей в C++ может быть довольно сложным для понимания среди новичков, и овладение навыками правильного использования указателей может занять некоторое время^[111].

Go

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (9 октября 2023)

Go и Python — кардинально различающиеся языки, тем не менее, они часто сравниваются один с другим из-за общей ниши — бэкэнда веб-приложений. По выражению Джейсона Кинкэйда, Go объединяет «производительность и безопасность компилируемых языков, таких как C++, со скоростью разработки на динамических языках, таких как Python»^[116]. В какой-то мере это действительно так: Go изначально разработан как строго статически типизированный компилируемый язык, поддерживающий максимум возможностей динамических языков, при котором ещё можно обеспечить эффективную компиляцию и сохранить производительность компилируемых программ. Общими для обоих языков является использование автоматического управления памятью, наличие встроенных динамических коллекций (массивов и словарей), поддержка срезов, развитый механизм модулей, простой и минималистичный синтаксис. Различий гораздо больше, и не всегда можно однозначно указать, в пользу какого из языков они говорят.

Динамические возможности.

Если Python является полностью динамическим языком и практически любые элементы программы могут меняться во время исполнения, включая конструирование «на лету» новых типов и модификацию существующих, то Go — статический язык с достаточно ограниченными возможностями рефлексии, работающей только в отношении созданных при разработке типов данных. В некоторой мере заменой динамических возможностей в Go является кодогенерация, обеспечиваемая простотой синтаксиса и наличием необходимых инструментов и системных библиотек. Также в Go 1.18 добавили поддержку средств обобщённого программирования (generics)^[117].

Perl

Оба языка являются интерпретируемыми, компилируются в промежуточное представление, которое затем отправляется на исполнение. В случае Python генерируется промежуточный байт-код, а компилятор Perl генерирует синтаксическое дерево. Управление памятью в обоих языках автоматическое, а сами языки используются как скриптовые и хорошо подходят для написания веб-приложений. Подход в написания кода Python предполагает лучшее понимание листинга программы в ущерб производительности, тогда как в Perl больше свободы в синтаксисе, что может привести к тому, что программы на Perl становятся нечитабельны для программистов, не работающих с данным языком^[111].

MATLAB и R

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (8 февраля 2023)

Python, MATLAB и R используются в обработке данных и в обучении студентов основам математики и статистики. R является языком для выполнения статистических расчётов, в то время как MATLAB может считаться языком программирования наряду с Python^[118].

Языки, на которые повлиял Python

Python, как весьма популярный язык программирования, повлиял на следующие языки:

• CoffeeScript имеет синтаксис, вдохновлённый Python^[119].
• ECMAScript/JavaScript заимствовал итераторы и генераторы из Python^[120].
• Go, при сильнейших идеологических различиях, заимствовал у динамических языков, таких как Python, встроенные словари, динамические массивы, срезы.
• Groovy был создан с мотивацией привнести философию Python на Java^[121].
• Julia была задумана как «такая же пригодная для общего программирования, как и Python»^[122].
• Nim использует систему отступов и аналогичный синтаксис^[123].
• Ruby — Юкихиро Мацумото, создатель языка, сказал: «Я хотел скриптовый язык, который был бы более мощным, чем Perl, и более объектно-ориентированным, чем Python. Вот почему я решил создать свой собственный язык»^[124].
• Swift во время разработки брал идеи структуры языка из Python, а также из Objective-C, Rust, Haskell, Ruby, C#, CLU^[125].

Низкое быстродействие

Классический Python имеет общий со многими другими интерпретируемыми языками недостаток — сравнительно невысокую скорость выполнения программ^[126]. В некоторой степени ситуацию улучшает кеширование байт-кода (расширения .pyc и, до версии 3.5, .pyo), которое позволяет интерпретатору не тратить время на синтаксический разбор текста модулей при каждом запуске.

Существуют реализации языка Python, вводящие высокопроизводительные виртуальные машины в качестве бэкенда компилятора. Примерами таких реализаций может служить PyPy, базирующийся на RPython, более ранней инициативой является проект Parrot. Ожидается, что использование виртуальной машины типа LLVM приведёт к тем же результатам, что и использование аналогичных подходов для реализаций языка Java, где низкая вычислительная производительность в основном преодолена^[127]. Однако нельзя забывать, что динамический характер Python делает неизбежными дополнительные накладные расходы при исполнении программ, что ограничивает производительность Python-систем независимо от применяемых технологий. Вследствие этого для написания критических участков кода используются низкоуровневые языки, интеграция с которыми обеспечивается множеством программ и библиотек.

Тем не менее, Python портирован на некоторые относительно малопроизводительные платформы^[128].

Глобальная блокировка интерпретатора (GIL)

Интерпретатор Python в CPython (а также Stackless и PyPy^[129]) использует потоко-небезопасные данные, во избежание разрушения которых при совместной модификации из разных потоков применяется глобальная блокировка интерпретатора — GIL (Global Interpreter Lock)^[130]: в ходе исполнения кода поток интерпретатора блокирует GIL, выполняет в течение фиксированного времени (по умолчанию 5 миллисекунд^{[К 2]}) некоторое количество инструкций, после чего освобождает блокировку и приостанавливается, давая возможность работать другим потокам. GIL также освобождается во время ввода-вывода, изменения и проверки состояния синхронизирующих примитивов, при исполнении кода расширений, не обращающихся к данным интерпретатора, например, NumPy/SciPy. Таким образом, в каждый момент времени в одном процессе интерпретатора Python может исполняться только один поток кода на Python, независимо от числа доступных процессорных ядер.

Потери производительности от GIL зависят от характера программ и архитектуры системы. Большинство программ является однопоточными либо запускает всего несколько потоков, из которых часть в каждый конкретный момент простаивает в ожидании. Персональные компьютеры обычно имеют небольшое количество процессорных ядер, которые загружены параллельно исполняющимися в системе процессами, так что реальные потери производительности на персональных компьютерах из-за GIL невелики. Но в серверных приложениях может быть удобно использовать десятки и сотни (а то и больше) параллельных потоков (например, в системах массового обслуживания, где каждый поток обрабатывает данные для отдельного пользовательского запроса), а серверы на конец 2010-х годов нередко имеют десятки и даже сотни процессорных ядер, то есть технически могут обеспечить этим потокам физически одновременное исполнение; в таких условиях GIL может приводить к действительно значительному снижению общей производительности, так как лишает программу возможности полноценно использовать ресурсы многоядерных систем.

Гвидо ван Россум говорил, что GIL «не так уж и плох» и он будет в CPython до тех пор, пока «кто-то другой» не представит реализацию Python без GIL, с которой бы однопоточные скрипты работали так же быстро^[133][134].

В задачи разработки входит работа по оптимизации GIL^[135]. Планируется отказ от GIL, есть черновой вариант PEP 703^[136], но на данный момент есть следующие варианты избавления от GIL:

• Вариант интерпретатора с синхронизацией доступа к отдельным объектам вместо глобальной блокировки^[137] из-за частых захватов/освобождений блокировок оказался слишком медленным.
• Реализация потоков через процессы ОС, например, модуль multiprocessing^[138].
• Отказ от совместного использования изменяемых данных и вызовов внешнего кода. При этом данные дублируются в потоках и их синхронизация (если таковая нужна) лежит на программисте^[139].
• Библиотеки, обеспечивающие собственную организацию поддержки потоков.
• Есть черновой PEP по отказу от GIL в CPython^[136]

9 января 2023 года был принят PEP 703, в котором было предложено сделать GIL опциональным^[136]. В Python 3.13, выход которого запланирован на октябрь 2024 года, добавлена экспериментальная опция для отключения GIL на этапе сборки интерпретатора^[140]. В ближайшие несколько релизов будут формироваться две сборки интерпретатора Python — с включённым и отключённым GIL (с несовместимыми ABI), но в будущем планируется добавить возможность отключать GIL на этапе выполнения^[136].

Синтаксис и семантика

Несмотря на то, что одним из заявленных принципов дизайна Python является принцип наименьшего удивления, критики отмечают целый ряд архитектурных решений, которые могут вводить в заблуждение или вызывать недоумение у программистов, привыкших к другим распространённым языкам^[141]. В их числе:

• Отличие в принципе работы оператора присвоения по сравнению со статически-типизированными языками. В Python при присвоении значения копируется ссылка на объект, а не значение. При работе с простыми неизменяемыми типами возникает ощущение изменения значения переменной при присваивании ей значения, однако фактически присваивается ссылка на другое значение, например, при увеличении значения переменной типа int на 1 меняется ссылка, а не увеличивается значение по ссылке. Однако при работе с изменяемыми типами их содержимое можно менять по ссылке, поэтому при присвоении одной переменной ссылки на другую и последующем изменении значения в одной из двух переменных оно изменится в обеих переменных, что хорошо заметно при работе со списками^[141][142]. При этом кортежи хоть и являются неизменяемыми, но могут хранить ссылки на изменяемые объекты, поэтому по факту кортежи тоже можно менять^[143];
• Отличие в поведении на некоторых типах «сокращённых» операторов, таких как += и их развёрнутой записи, хотя в большинстве языков «сокращённый» вариант — это просто краткая запись полного, и семантически они абсолютно эквивалентны. Пример с использованием x +=:

  >>> x = [1, 2]
  >>> y = x
  >>> x += [3, 4]
  >>> x
  [1, 2, 3, 4]
  >>> y
  [1, 2, 3, 4]
  

  Аналогичный пример с использованием x = x +:

  >>> x = [1, 2]
  >>> y = x
  >>> x = x + [3, 4]
  >>> x
  [1, 2, 3, 4]
  >>> y
  [1, 2]
  

• Жёсткая трактовка лексической области видимости, подобная используемой в JavaScript: даже если переменная получает значение в последней строке функции, её областью видимости является вся функция.
• Путаница между полями класса и полями объекта: текущее значение поля класса инициализирует одноимённое поле объекта, но не при создании объекта, а при первой записи значения в данное поле.

  class Colored:
      color = "red"
  
  obj1 = Colored()
  print(obj1.color)        # выводится исходное значение поля КЛАССА
  Colored.color = "green"  # изменение поля КЛАССА
  print(obj1.color)        # выводится значение поля КЛАССА
  obj1.color = "blue"      # изменяется поле ОБЪЕКТА и фиксируется его значение
  Colored.color = "yellow" # изменение поля КЛАССА, которое уже не отразится на объекте
  print(obj1.color)        # выводится поле ОБЪЕКТА
  
  # Скрипт выведет: 
  red
  green
  blue
  

В примере выше три раза выводится поле color объекта obj1 класса Colored. При этом пока не выполнена запись в это поле, выводится текущее значение поля класса, и в третий раз — значение поля объекта. Такое сохранение связи между полем объекта и класса до первой перезаписи может стать причиной неожиданного эффекта: если в программе меняется значение поля класса, то все объекты, одноимённые поля которых ещё не перезаписаны, окажутся неявно изменены.

• Интуитивно трудно предсказуемое поведение параметров со значением-объектом по умолчанию. Если в качестве инициализатора для параметра по умолчанию указать конструктор объекта, это приведёт к созданию статического объекта, ссылка на который и будет передаваться по умолчанию в каждый вызов^[144]. Это может повлечь трудно уловимые ошибки.

Невозможность модификации встроенных классов

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (9 октября 2023)

По сравнению с Ruby и некоторыми другими языками, в Python отсутствует возможность модифицировать встроенные классы^[145], такие, как int, str, float, list и другие.

CPython

CPython является основной реализацией языка. Он написан на языке Си и является переносимым на разные платформы. В основе управления памятью лежит использование комбинации счётчиков ссылок и сборщика мусора, ответственного за поиск циклических захватов ссылок^[30]. Хотя язык считается интерпретируемым, на самом деле он компилируется в промежуточный высокоуровневый байт-код^[146][147], который затем исполняется через стековую виртуальную машину^[30]. Например, вызов функции print() может быть представлен в следующем виде^[147]:

  0           0 RESUME                   0
  1           2 PUSH_NULL
              4 LOAD_NAME                0 (print)
              6 LOAD_CONST               0 ('Hello World!')
              8 PRECALL                  1
             12 CALL                     1
             22 RETURN_VALUE

Имена в языке имеют позднее связывание, в результате чего можно писать обращения к переменным, методам и атрибутам, которых ещё нет, но они должны быть объявлены на момент исполнения кода, использующего их. Каждый объект в Python имеет словарь, представленный хеш-таблицей, через который происходит сопоставление названий атрибутов их значениям. Глобальные переменные также сопоставляются через словарь. Одно обращение к методу или атрибуту может сопровождаться поочерёдным поиском в нескольких словарях^[30].

PyPy

PyPy — реализация Python, написанная на RPython (подмножество Python, имеющее намного меньше динамических возможностей). Позволяет легко проверять новые возможности. В PyPy, кроме стандартного CPython, включены возможности Stackless, Psyco, модификация AST «на лету» и многое другое. В проект интегрированы возможности анализа Python-кода и трансляция в другие языки и байт-коды виртуальных машин (Си, LLVM, Javascript, .NET с версии 0.9.9). Начиная с 0.9.0, возможна полностью автоматическая трансляция RPython в Си, в результате чего достигается скорость, приемлемая для использования (в 2—3 раза ниже, чем CPython при отключённом JIT для версии 0.9.9). По умолчанию PyPy поставляется со встроенным JIT-компилятором, с помощью которого он способен работать намного быстрее, чем CPython.

Jython

Этот раздел нужно дополнить.

Пожалуйста, улучшите и дополните раздел. (8 февраля 2023)

Jython — реализация Python, компилирующая код на Python в байт-код Java, который может быть выполнен JVM. Также может использоваться для импорта класса, исходный код которого был написан на Java в качестве модуля для Python^[148].

Другие реализации

Существуют также другие реализации.

• Numba^[англ.] — Jit-компилятор на основе LLVM с поддержкой NumPy.
• PyS60^[149] — реализация языка для смартфонов фирмы Nokia на платформе Series 60. Не поддерживается
• IronPython — Python для .NET Framework и Mono. Компилирует Python программы в MSIL, таким образом предоставляя полную интеграцию с .NET-системой^[150].
• Stackless — также написанная на Си реализация Python. Это не полноценная реализация, а патчи к CPython. Предоставляет расширенные возможности многопоточного программирования и значительно большую глубину рекурсии.
• Python for .NET^[151] — ещё одна реализация Python для .NET. В отличие от IronPython эта реализация не компилирует Python код в MSIL, а только предоставляет интерпретатор, написанный на C#. Позволяет использовать .NET-сборки из Python кода.
• Jython — реализация Python, использующая JVM в качестве среды исполнения. Позволяет прозрачно использовать Java-библиотеки.
• TinyPy^[152] — минималистическая версия Python. Часть возможностей CPython не реализована.
• MicroPython — реализация Python 3 для встроенных систем с малым объёмом оперативной памяти^[153].
• Brython^[154] — реализация языка на клиентском JavaScript, позволяющая писать браузерные скрипты на Python 3.
• QPython^[155] — реализация Python для Android. Проект всё ещё на стадии тестирования, однако на QPython уже портированы некоторые самые необходимые библиотеки. Позволяет и работать в интерактивном режиме. Существует также Qpython3.

Интерактивный режим

Подобно Lisp и Prolog, Python может использоваться в интерактивном режиме, при котором введённые с клавиатуры операторы сразу же выполняются, а результат выводится на экран (REPL). Этот режим удобен как при изучении языка, так и в процессе профессиональной разработки — для быстрого тестирования отдельных фрагментов кода, — так как обеспечивает немедленную обратную связь. Также он позволяет использовать интерпретатор в качестве калькулятора с большим набором функций.

• Эталонная реализация Python имеет встроенный интерактивный интерпретатор, работающий в режиме текстового терминала и позволяющий выполнять все основные операции. В интерактивном режиме доступен отладчик pdb и система помощи (вызывается по help()), работающая для всех модулей, классов и функций, которые содержат строки документации:

>>> from math import * # импорт математических функций
>>> help(cos) # помощь по функции cos
Help on built-in function cos in module math:

cos(x, /)
    Return the cosine of x (measured in radians).

• IPython^[160] — выходящая под BSD-лицензией кросс-платформенная интерактивная оболочка, предоставляющая расширенную интроспекцию и дополнительные команды. В частности, позволяет передавать исполняемому коду на Python результаты выполнения команд системной командной оболочки. Поддерживает подсветку кода и автоматическое дополнение.
• BPython^[161] — расширение стандартной командной оболочки Python с помощью ряда дополнительных модулей. Реализует подсветку синтаксиса, автоматическое дополнение кода с предложением вариантов, автоматическое выравнивание, интеграция с Pastebin, сохранение ввода в файл, восстановление удалённой строки, предложение параметров для функций.

Почти все IDE для Python поддерживают REPL для быстрого тестирования.

IDE

Существует несколько специализированных IDE для разработки на Python.

• Eric — полнофункциональный редактор Python и IDE, написанный на Python. Он базируется на кросс-платформенном фреймворке Qt, в качестве компонента редактирования используется QScintilla. Eric предоставляет возможности ведения проектов, отладки, профилирования, рефакторинга кода, взаимодействия с популярными системами управления версиями, такими как Subversion и Git. Расширяется через механизм плагинов. Репозиторий плагинов доступен прямо из среды разработки. Распространяется бесплатно, лицензия GNU GPL v3.
• PyCharm — полнофункциональная IDE для Python от JetBrains, доступна на платформах Windows, macOS и Linux, существует в бесплатном (Community) и платном (Professional) вариантах.
• Wing IDE^[англ.] — линейка Python-IDE от американской фирмы Wingware, включает три варианта: «Wing 101», «Wing Personal», «Wing Pro», из которых первые два бесплатны, последний — платный. Версия Pro обладает всеми необходимыми средствами для профессиональной разработки, включая поддержку проектов, работу с системами управления версиями, расширенные возможности навигации по коду и анализа кода, рефакторинг, поддержка использования Django. Бесплатные версии предоставляют меньше функций и не выходят за пределы возможностей, доступных в других бесплатных IDE для Python.
• Spyder — IDE с открытым исходным кодом для Python под лицензией MIT, бесплатная, доступна на платформах Windows, Mac OS X и Linux. Особенностью является то, что IDE ориентирована на data science, в ней удобно работать с библиотеками типа SciPy, NumPy, Matplotlib. Spyder поставляется в комплекте с менеджером пакетов Anaconda. В целом обладает качествами стандартной IDE, имеет редактор с подсветкой синтаксиса, автоматическое дополнение кода, обозреватель документации.
• Thonny — многоплатформенная бесплатная IDE, выпускается под лицензией MIT, поддерживается Институтом информатики Тартуского университета в Эстонии. Позиционируется как «Python IDE для новичков», полностью, включая интерпретатор Python, ставится «из коробки» пользователем без административных прав, сразу после установки может использоваться без дополнительных настроек. Предназначена для обучения, имеет улучшенную визуализацию порядка вычисления выражений и вызова функций, динамическую подсветку синтаксических ошибок, простой менеджер пакетов. Для профессионального применения возможностей недостаточно, например, нет поддержки проектов и интеграции с системами управления версиями.
• IDLE^[162] — встроенный в Python IDE. Очень простой и малофункциональный.

Помимо этого, существуют плагины для поддержки программирования на Python для универсальных IDE Eclipse^[163], KDevelop^[164], Visual Studio Code^[165] и Microsoft Visual Studio^[166], а также имеется поддержка подсветки синтаксиса, авто дополнения кода и подключения средств отладки и запуска приложений для целого ряда распространённых текстовых редакторов.

Комментарии

Источники