Синтаксис и семантика Python - Python syntax and semantics

В синтаксис из Язык программирования Python - это набор правил, определяющих, как программа Python будет написана и интерпретирована (как система времени выполнения и читателями-людьми). Язык Python во многом похож на Perl, C, и Ява. Однако между языками есть определенные различия.

Философия дизайна

Python был разработан, чтобы быть легко читаемым языком.^[1] Он имеет относительно лаконичный визуальный макет и часто использует ключевые слова на английском языке, тогда как другие языки используют знаки препинания. Python стремится быть простым и последовательным в дизайне своего синтаксиса, заключенного в мантре «Должен быть один - и желательно только один - очевидный способ сделать это», от «Дзен Python ".^[2]

Эта мантра сознательно противопоставляется Perl и Рубин мантра, "есть несколько способов сделать это ".

Ключевые слова

У Python есть эти 35 ключевых слов или зарезервированные слова; они не могут использоваться в качестве идентификаторов.^[3][4]

• и
• в качестве
• утверждать
• асинхронный^{[примечание 1]}
• Ждите^{[примечание 1]}
• перемена
• учебный класс
• Продолжить
• def
• дель
• Элиф
• еще
• Кроме
• Ложь^{[заметка 2]}
• наконец-то
• за
• из
• Глобальный
• если
• импорт
• в
• является
• лямбда
• Никто
• нелокальный^{[заметка 2]}
• нет
• или же
• проходить
• поднимать
• возвращаться
• Истинный^{[заметка 2]}
• пытаться
• пока
• с
• урожай

Примечания

1. Начиная с Python 3.5, асинхронный и Ждите были представлены.^[5]
2. Начиная с Python 3, ключевые слова Истинный, Ложь и нелокальный были представлены.

Отступ

Python использует пробел разграничивать поток управления блоки (после вне игры ). Python заимствует эту функцию у своего предшественника. ABC: вместо знаков препинания или ключевых слов он использует отступ для обозначения выполнения блока.

В так называемых языках "свободного формата", которые используют блочную структуру, полученную из АЛГОЛ - блоки кода выделяются фигурными скобками ({ }) или ключевые слова. В большинстве соглашений о кодировании для этих языков программисты обычно делают отступ внутри блока, чтобы визуально отделить его от окружающего кода (красивая печать ).

Рассмотрим функцию, фу, которому передается одиночный параметр, Икс, и если параметр равен 0, вызовет бар и баз, иначе он вызовет qux, прохождение Икс, а также вызывать себя рекурсивно, передавая х-1 в качестве параметра. Вот реализации этой функции как на C, так и на Python:

фу функционировать в C с Стиль отступа K&R:

пустота фу(int Икс){    если (Икс == 0) {        бар();        баз();    } еще {        qux(Икс);        фу(Икс - 1);    }}

фу функция в Python:

def фу(Икс):    если Икс == 0:        бар()        баз()    еще:        qux(Икс)        фу(Икс - 1)

Python требует соглашения, в котором программисты АЛГОЛ часто следуют языки стиля. Код с неправильным отступом может быть понят читателем иначе, чем компилятор или интерпретатор.

Этот пример иллюстрирует ошибку, вызванную неправильным отступом:

def фу(Икс):    если Икс == 0:        бар()        баз()    еще:        qux(Икс)    фу(Икс - 1)

Здесь, в отличие от указанного выше Python фу например, вызов функции foo (х - 1) всегда выполняется, что приводит к бесконечной рекурсии. Такая ошибка отступа (например, случайное удаление отступа в последней строке) возможна только в языках программирования, которые не отмечают блоки отдельными маркерами, такими как фигурные скобки в C.В данном конкретном случае даже не редактор с автоматическим отступом может предотвратить ошибочное поведение этого кода Python. Эта непреднамеренная ошибка может легко перейти в кодовую базу, не замечая ее заранее. В большинстве других языков программирования это было бы невозможно (удаление маркера конца блока в C привело бы к ошибке компилятора), и это делает синтаксис Python менее надежным, чем в большинстве других языков.

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

Многие популярные редакторы кода без проблем обрабатывают соглашения Python об отступах, иногда после включения параметра конфигурации.

Структуры данных

Поскольку Python - это динамически типизированный язык, Python значения, не переменные, тип переноса. Это имеет значение для многих аспектов функционирования языка.

Все переменные в Python содержат ссылки на объекты, и эти ссылки передаются функциям; функция не может изменить значение ссылок на переменные в своей вызывающей функции (но см. исключения ниже). Некоторые люди (в том числе Гвидо ван Россум сам) назвали эту схему передачи параметров «Вызов по ссылке на объект». Ссылка на объект означает имя, а переданная ссылка является «псевдонимом», то есть копией ссылки на тот же объект, как и в C / C ++. В вызываемой функции значение объекта можно изменить с помощью «псевдонима», например:

>>> список = ['а', 'b', 'c']>>> def my_func(аль):...     аль.добавить('Икс')...     Распечатать(аль)...>>> my_func(список)['а', 'b', 'c', 'Икс']>>> список['а', 'b', 'c', 'Икс']

Функция my_func изменил значение список с формальным аргументом аль, который является псевдонимом список. Однако любая попытка оперировать самим псевдонимом не повлияет на исходный объект. В Python все доступные имена, не являющиеся внутренними локальными и не объявленными глобальными, являются псевдонимами.

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

Базовые типы

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

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

Типы коллекций

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

Упорядоченные последовательные типы - это списки (динамические массивы ), кортежи, и струны. Все последовательности индексируются позиционно (от 0 до длина - 1), и все, кроме строк, могут содержать любой тип объекта, включая несколько типов в одной последовательности. И строки, и кортежи неизменяемы, что делает их идеальными кандидатами на ключи словаря (см. Ниже). Списки, с другой стороны, изменяемы; элементы можно вставлять, удалять, изменять, добавлять или сортировать на месте.

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

Словари также занимают центральное место во внутреннем устройстве языка, поскольку они находятся в основе всех объектов и классов Python: сопоставления между именами переменных (строками) и значениями, на которые ссылаются имена, хранятся как словари (см. Система объектов ). Поскольку эти словари доступны напрямую (через объектный __dict__ атрибут), метапрограммирование это простой и естественный процесс в Python.

А набор Тип коллекции был добавлен в основной язык в версии 2.4. Набор - это неиндексированная, неупорядоченная коллекция, не содержащая дубликатов и реализующая теоретико-множественный такие операции, как союз, пересечение, разница, симметричная разница, и подмножество тестирование. Есть два типа наборов: набор и морозильникс той лишь разницей, что набор изменчив и морозильник неизменен. Элементы в наборе должны быть хешируемыми. Так, например, морозильник может быть элементом регулярного набор тогда как обратное неверно.

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

Система объектов

В Python все является объектом, даже классы. Классы, как объекты, имеют класс, который известен как их метакласс. Python также поддерживает множественное наследование и миксины.

Язык поддерживает обширные самоанализ типов и классов. Типы можно читать и сравнивать - типы являются экземплярами тип. Атрибуты объекта можно извлечь в виде словаря.

Операторы могут быть перегружены в Python, определяя специальные функции-члены, например, определяя __Добавить__ на классе позволяет использовать + оператор для членов этого класса.

Литералы

Струны

Python имеет различные виды строковые литералы.

Обычные строковые литералы

Для заключения строк в кавычки можно использовать одинарные или двойные кавычки. В отличие от языков оболочки Unix, Perl или языки с влиянием Perl, такие как Рубин или же Groovy, одинарные кавычки и двойные кавычки работают одинаково, т.е. нет строковой интерполяции $ foo выражения. Однако интерполяция может выполняться разными способами: с помощью "f-строк" (начиная с Python 3.6^[6]), с использованием формат метод или старый % Оператор строкового формата.

Например, оператор Perl:

Распечатать "Я только что распечатал $ num страниц на принтере $ printer"

эквивалентно любому из этих операторов Python:

Распечатать(ж"Я только что напечатал {число} страницы на принтер {принтер}")Распечатать("Я только что напечатал {} страницы на принтер {}".формат(число, принтер))Распечатать("Я только что напечатал {0} страницы на принтер {1}".формат(число, принтер))Распечатать("Я только что напечатал {число} страницы на принтер {принтер}".формат(число=число, принтер=принтер))Распечатать("Я только что напечатал % s страницы на принтер % s" % (число, принтер))Распечатать("Я только что напечатал % (число) с страницы на принтер % (принтер) s" % {"число": число, "принтер": принтер})

Многострочные строковые литералы

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

Простой пример с переменная интерполяция (с использованием формат метод) это:

Распечатать("""Уважаемый {получатель},Я желаю тебе покинуть Саннидейл и больше никогда не возвращаться.Не совсем любовь,{отправитель}""".формат(отправитель="Баффи истребительница вампиров", получатель="Шип"))

Необработанные струны

Наконец, входят все ранее упомянутые строковые типы "сырой "разновидности (обозначаются буквой р перед вступительной цитатой), которые не используют обратную косую черту и, следовательно, очень полезны для обычные выражения; сравнивать "@ -quoting" в C #. Исходные строки изначально были включены специально для регулярных выражений. Из-за ограничений токенизатора необработанные строки могут не иметь обратной косой черты в конце.^[7] Создание необработанной строки, содержащей Windows Путь, заканчивающийся обратной косой чертой, требует некоторого обходного пути (обычно используется прямая косая черта вместо обратной, поскольку Windows принимает и то, и другое).

Примеры включают:

>>> # Путь Windows, даже необработанные строки не могут заканчиваться обратной косой чертой>>> р"C: FooBarBaz"  Файл "", линия 1    р"C: FooBarBaz"                     ^Синтаксическая ошибка: EOL при сканировании строкового литерала>>> dos_path = р"C: FooBarBaz" # избегает ошибки, добавляя>>> dos_path.полоса()              # и удаление конечного пробела'C:  Foo  Bar  Baz '>>> quoted_dos_path = р'"{}"'.формат(dos_path)>>> quoted_dos_path'"C:  Foo  Bar  Baz "'>>> # Регулярное выражение, соответствующее строке в кавычках с возможным цитированием обратной косой черты>>> повторно.матч(р'"(([^"]|.)*)"', quoted_dos_path).группа(1).полоса()'C:  Foo  Bar  Baz '>>> код = 'foo (2, bar)'>>> # Обратить аргументы в вызове функции с двумя аргументами>>> повторно.суб(р'(([^,]*?),([^ ,]*?))', р'(2, 1)', код)'foo (2, bar)'>>> # Обратите внимание, что это не сработает, если в любом из аргументов есть скобки или запятые.

Объединение соседних строковых литералов

Строковые литералы (с использованием, возможно, различных соглашений о кавычках), появляющиеся подряд и разделенные только пробелом (включая новые строки), разрешены и объединяются в одну более длинную строку.^[8]Таким образом

заглавие = "Один хороший поворот:"         'Естественная история отвертки и винта'

эквивалентно

заглавие = «Один хороший поворот: естественная история отвертки и винта»

Числа

Числовые литералы в Python имеют обычный вид, например 0, -1, 3.4, 3,5e-8.

Python имеет целые числа произвольной длины и автоматически увеличивает размер хранилища по мере необходимости. До версии Python 3 существовало два вида целых чисел: традиционные целые числа фиксированного размера и «длинные» целые числа произвольного диапазона. Преобразование в «длинные» целые числа при необходимости выполнялось автоматически, и поэтому программисту обычно не нужно было знать о двух целочисленных типах. В новых языковых версиях целые числа фиксированного размера полностью отсутствуют.

Python поддерживает нормальные плавающая точка числа, которые создаются, когда точка используется в литерале (например, 1.1), когда в выражении используются целое число и число с плавающей запятой, или в результате некоторых математических операций («истинное деление» через / оператор или возведение в степень с отрицательной экспонентой).

Python также поддерживает сложные числа изначально. Комплексные числа обозначаются значком J или же j суффикс, например 3 + 4j.

Списки, кортежи, множества, словари

Python имеет синтаксическую поддержку для создания типов контейнеров.

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

список = [1, 2, 3, "собака"]

или используя обычное создание объекта

a_second_list = список()a_second_list.добавить(4)a_second_list.добавить(5)

Кортежи (учебный класс кортеж) - неизменяемые последовательности элементов произвольных типов. Также существует специальный синтаксис для создания кортежей

a_tuple = 1, 2, 3, "четыре"

Хотя кортежи создаются путем разделения элементов запятыми, вся конструкция обычно заключена в круглые скобки для повышения удобочитаемости. Пустой набор обозначается ().

Наборы (учебный класс набор) являются изменяемыми контейнерами хешируемых элементов^[9] произвольных типов, без дубликатов. Элементы не упорядочены, но наборы поддерживают итерацию по элементам. Синтаксис для создания набора появился в Python 2.7 / 3.0

some_set = {0, (), Ложь}

В более ранних версиях Python наборы создавались бы путем инициализации класса набора аргументом списка. Наборы Python очень похожи на математические наборы, и поддерживать такие операции, как set пересечение и союз.

Python также имеет морозильник класс для неизменяемых множеств.

Словари (учебный класс диктовать) являются изменяемыми сопоставлениями, связывающими ключи и соответствующие значения. Python имеет специальный синтаксис для создания словарей ({ключ: значение})

словарь = {"ключ 1": "значение 1", 2: 3, 4: []}

Синтаксис словаря аналогичен заданному синтаксису, отличие заключается в наличии двоеточий. Пустой литерал {} приводит к пустому словарю, а не к пустому набору, который вместо этого создается с использованием нелитерального конструктора: набор().

Операторы

Арифметика

Python включает +, -, *, /, % (модуль ), и ** (возведение в степень ) операторами с их обычными математический приоритет.

Традиционно х / у выполнила целочисленное деление если оба Икс и у были целыми числами (возвращали нижнее значение частного) и возвращали число с плавающей запятой, если какое-либо из них было числом с плавающей запятой. Однако, поскольку Python - это язык с динамической типизацией, не всегда было возможно определить, какая операция выполняется, что часто приводило к незаметным ошибкам. Например, с

def иметь в виду(seq):    возвращаться сумма(seq) / len(seq)

Звонок в среднее ([3.0, 4.0]) вернет 3,5, но среднее ([3, 4]) вернет 3. Если это не предполагаемое поведение, необходимо использовать обходной путь, например

def иметь в виду(seq):    возвращаться плавать(сумма(seq)) / len(seq)

Чтобы избежать этой проблемы, предложение был сделан, чтобы изменить поведение оператора деления Python. В Python 2.2 новый оператор // был введен для деления полов, как для целочисленных аргументов, так и для аргументов с плавающей запятой. В / Оператор был изменен так, что частное двух целых чисел возвращало число с плавающей запятой, но для обратной совместимости это поведение нужно было явно запрашивать до Python 3.0.

Операторы сравнения

Основные операторы сравнения, такие как ==, <, >=и т. д. используются для всевозможных значений. Можно сравнивать числа, строки, последовательности и сопоставления. Хотя разрозненные типы (например, ул и int) определены как имеющие согласованный относительный порядок, это считается исторической особенностью дизайна и больше не будет разрешено в Python 3.0.

Связанные выражения сравнения, такие как а <Ь <с имеют примерно то же значение, которое они имеют в математике, а не необычный смысл, найденный в C и подобные языки. Сроки оцениваются и сравниваются по порядку. Операция семантика короткого замыкания, что означает, что оценка гарантированно остановится, как только будет вынесен вердикт: если а <б ложно, c никогда не оценивается, поскольку выражение больше не может быть истинным.

Для выражений без побочных эффектов а <Ь <с эквивалентно a . Однако есть существенная разница, когда выражения имеют побочные эффекты. а <е (х) <Ь оценит f (x) ровно один раз, тогда как a оценит его дважды, если значение а меньше чем f (x) и еще раз иначе.

Логические операторы

Python 2.2 и более ранние версии не имеют явного логического типа. Во всех версиях Python логические операторы обрабатывают нулевые или пустые значения, например "", 0, Никто, 0.0, [], и {} как ложь, в то время как в целом непустые и ненулевые значения обрабатываются как истинные. В Python 2.2.1 логические константы Истинный и Ложь были добавлены к языку (разделены на 1 и 0). Операторы двоичного сравнения, такие как == и > вернуться либо Истинный или же Ложь.

Булевы операторы и и или же использовать минимальная оценка. Например, y == 0 или x / y> 100 никогда не вызовет исключение деления на ноль. Эти операторы возвращают значение последнего вычисленного операнда, а не Истинный или же Ложь. Таким образом, выражение (4 и 5) оценивает 5, и (4 или 5) оценивает 4.

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

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

Понимания

Основная статья: Понимание списка

Одна из таких конструкций - понимание списка, который можно выразить в следующем формате:

L = [mapping_expression за элемент в source_list если filter_expression]

Использование понимания списка для вычисления первых пяти степеней двойки:

powers_of_two = [2**п за п в классифицировать(1, 6)]

В Быстрая сортировка Алгоритм можно элегантно (хотя и неэффективно) выразить с помощью списков:

def qsort(L):    если L == []:        возвращаться []    вращаться = L[0]    возвращаться (qsort([Икс за Икс в L[1:] если Икс < вращаться]) +            [вращаться] +            qsort([Икс за Икс в L[1:] если Икс >= вращаться]))

Python 2.7+^[10] также поддерживает установленные понимания^[11] и понимание словаря.^[12]

Первоклассные функции

В Python функции первый класс объекты, которые можно создавать и передавать динамически.

Ограниченная поддержка Python для анонимные функции это лямбда построить. Примером является анонимная функция, которая возводит свой ввод в квадрат, вызываемая с аргументом 5:

ж = лямбда Икс: Икс**2ж(5)

Лямбды могут содержать только выражение скорее, чем заявления, хотя поток управления все еще может быть реализован менее элегантно в лямбда за счет короткого замыкания,^[13] и более идиоматично с условными выражениями.^[14]

Закрытие

Python поддерживает лексические замыкания начиная с версии 2.2. Вот пример:

def производная(ж, dx):    "" "Вернуть функцию, которая приближает производную f    используя интервал dx, который должен быть соответственно малым.    """    def функция(Икс):        возвращаться (ж(Икс + dx) - ж(Икс)) / dx    возвращаться функция

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

Обратите внимание, что привязка имени к некоторому значению в замыкании не может быть изменена изнутри функции. Данный:

>>> def фу(а, б):...     Распечатать('а: %р' % а)...     Распечатать('b: %р' % б)...     def бар(c):...         б = c...         Распечатать('b *: %р' % б)...     бар(а)...     Распечатать('b: %р' % б)>>> фу(1,2)а: 1Би 2b *: 1Би 2

и вы можете видеть это б, как видно из области действия замыкания, сохраняет свое значение; измененная привязка б внутри внутренняя функция не распространилась наружу. Способ обойти это - использовать нелокальный b заявление в бар. В Python 2 (в котором отсутствует нелокальный) обычным обходным путем является использование изменяемого значения и изменение этого значения, а не привязки. Например, список с одним элементом.

Генераторы

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

Это пример ленивой генерации простых чисел:

из itertools импорт считатьdef generate_primes(останавливаться на=0):    простые числа = []    за п в считать(2):        если 0 < останавливаться на < п:            возвращаться # вызывает исключение StopIteration        составной = Ложь        за п в простые числа:            если нет п % п:                составной = Истинный                перемена            Элиф п ** 2 > п:                перемена        если нет составной:            простые числа.добавить(п)            урожай п

Чтобы использовать эту функцию, просто вызовите, например:

за я в generate_primes():  # перебирать ВСЕ простые числа    если я > 100:        перемена    Распечатать(я)

Определение генератора похоже на определение функции, за исключением ключевого слова урожай используется вместо возвращаться. Однако генератор - это объект с постоянным состоянием, который может многократно входить и выходить из одной и той же области. Затем вызов генератора можно использовать вместо списка или другой структуры, элементы которой будут повторяться. Когда бы за цикл в примере требует следующего элемента, вызывается генератор и выдает следующий элемент.

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

Генератор выражений

Дальнейшая информация: Понимание списка

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

из itertools импорт Isliceprimes_under_million = (я за я в generate_primes() если я < 1000000)two_thousandth_prime = Islice(primes_under_million, 1999, 2000).следующий()

Большая часть памяти и времени, необходимых для генерации такого количества простых чисел, не будет использоваться, пока не будет получен доступ к необходимому элементу. К сожалению, вы не можете выполнить простую индексацию и нарезку генераторов, но должны использовать itertools модули или «сверните свои» петли. Напротив, понимание списка функционально эквивалентно, но жадный при выполнении всех работ:

primes_under_million = [я за я в generate_primes(2000000) если я < 1000000]two_thousandth_prime = primes_under_million[1999]

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

Словарь и набор понятий

В то время как списки и генераторы имели понимания / выражения, в версиях Python старше 2.7 другие встроенные типы коллекций Python (dicts и sets) должны были быть объединены с использованием списков или генераторов:

>>> диктовать((п, п*п) за п в классифицировать(5)){0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python 2.7 и 3.0 объединяют все типы коллекций, вводя интерпретации dict и set, аналогичные пониманию списков:

>>> [п*п за п в классифицировать(5)]  # регулярное понимание списка[0, 1, 4, 9, 16]>>>>>> {п*п за п в классифицировать(5)}  # установить понимание{0, 1, 4, 9, 16}>>>>>> {п: п*п за п в классифицировать(5)}  # dict понимание{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Объекты

Python поддерживает большинство методов объектно-ориентированного программирования. Это позволяет полиморфизм не только в иерархия классов но также утка печатать. Любой объект можно использовать для любого типа, и он будет работать, если у него есть соответствующие методы и атрибуты. И все в Python - это объект, включая классы, функции, числа и модули. Python также поддерживает метаклассы, продвинутый инструмент для улучшения функциональности классов. Естественно, наследование, включая множественное наследование, поддерживается. Он имеет ограниченную поддержку частных переменных, использующих искажение имени. Видеть раздел "Классы" учебника Тем не менее, многие пользователи Python не испытывают потребности в частных переменных. Для описания такого отношения используется слоган «Мы все здесь ответственные пользователи».^[16]Некоторые считают скрытие информации быть непифонический, в том смысле, что он предполагает, что рассматриваемый класс содержит неэстетичные или плохо спланированные внутренние элементы. Однако самым сильным аргументом в пользу искажения имен является предотвращение непредсказуемой поломки программ: введение новой общедоступной переменной в суперклассе может сломать подклассы, если они не используют «частные» переменные.

Из учебника: Как и в случае с модулями, классы в Python не ставят абсолютный барьер между определением и пользователем, а скорее полагаются на вежливость пользователя, чтобы не «нарушить определение».

Доктрины ООП, такие как использование методов доступа для чтения элементов данных, не применяются в Python. Так же, как Python предлагает конструкции функционального программирования, но не пытается требовать ссылочная прозрачность, он предлагает объектную систему, но не требует ООП-поведения. Более того, всегда можно переопределить класс, используя характеристики так что когда определенная переменная устанавливается или извлекается в вызывающем коде, она действительно вызывает вызов функции, так что spam.eggs = тост действительно может вызвать spam.set_eggs (тост). Это сводит на нет практическое преимущество функций доступа и остается ООП, потому что свойство яйца становится законной частью интерфейса объекта: он не обязательно должен отражать детали реализации.

В версии Python 2.2 были введены классы «нового стиля». С классами нового стиля были унифицированы объекты и типы, что позволило создавать подклассы типов. Можно определять даже совершенно новые типы с настраиваемым поведением для инфиксных операторов. Это позволяет делать многие радикальные вещи синтаксически внутри Python. Новый порядок разрешения метода за множественное наследование также был принят с Python 2.3. Также возможно запускать собственный код при доступе к атрибутам или их установке, хотя детали этих методов менялись между версиями Python.

С заявлениями

Оператор with обрабатывает ресурсы.^[17] Одна функция вызывается при входе в область видимости, а другая при выходе. Это предотвращает забвение удаления ресурса, а также обрабатывает более сложные ситуации, такие как исключения.

Характеристики

Свойства позволяют вызывать специально определенные методы для экземпляра объекта с использованием того же синтаксиса, который используется для доступа к атрибутам. Примером класса, определяющего некоторые свойства, является:

учебный класс Мой класс:    def __в этом__(себя):        себя._a = Никто    @свойство    def а(себя):        возвращаться себя._a    @a.сеттер  # делает свойство доступным для записи    def а(себя, ценить):        себя._a = ценить

Дескрипторы

Класс, определяющий один или несколько специальных методов __get __ (я, экземпляр, владелец), __set __ (себя, экземпляр, значение), __delete __ (сам, экземпляр) может использоваться как дескриптор. Создание экземпляра дескриптора как члена класса второго класса делает этот экземпляр свойством второго класса.

Класс и статические методы

Python позволяет создавать методы класса и статический метод с помощью @classmethod и @staticmethod декораторы. Первым аргументом метода класса является объект класса, а не ссылка на сам экземпляр. Статический метод не имеет специального первого аргумента. Ни экземпляр, ни объект класса не передаются статическому методу.

Исключения

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

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

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

Исключения часто используются как альтернатива если-блок, особенно в резьбовой ситуации. Часто упоминаемый девиз - EAFP, или «Проще просить прощения, чем разрешения».^[18] который приписывается Грейс Хоппер.^[19][20] Альтернатива, известная как LBYL, или «Посмотрите, прежде чем прыгать», явно проверяет наличие предварительных условий.^[21]

В этом первом примере кода, следуя подходу LBYL, есть явная проверка атрибута перед доступом:

если hasattr(спам, 'яйца'):    ветчина = спам.яйцаеще:    handle_error()

Этот второй пример следует парадигме EAFP:

пытаться:    ветчина = спам.яйцаКроме AttributeError:    handle_error()

Эти два примера кода имеют одинаковый эффект, хотя будут различия в производительности. Когда спам имеет атрибут яйца, образец EAFP будет работать быстрее. Когда спам не имеет атрибута яйца («исключительный» случай) образец EAFP будет работать медленнее. Питон профайлер может использоваться в конкретных случаях для определения рабочих характеристик. Если исключительные случаи редки, то версия EAFP будет иметь более высокую средняя производительность чем альтернатива. Кроме того, он избегает всего класса от времени проверки до использования (TOCTTOU) уязвимости, прочее условия гонки,^[20][22] и совместим с утка печатать. Недостатком EAFP является то, что его можно использовать только с операторами; исключение не может быть обнаружено в выражении генератора, понимании списка или лямбда-функции.

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

У Python есть два способа аннотировать код Python. Один из них - использовать комментарии, чтобы указать, что делает какая-то часть кода. Однострочные комментарии начинаются с символа решетки ("#") и заканчиваются концом строки. Комментарии, охватывающие более одной строки, достигаются путем вставки многострочной строки (с """ в качестве разделителя на каждом конце), который не используется в присваивании или иным образом оценивается, но находится между другими операторами.

Комментируя фрагмент кода:

def Getline():    возвращаться sys.стандартный ввод.строка чтения()  # Получите одну строку и верните ее

Комментируя фрагмент кода из нескольких строк:

def Getline():    возвращаться sys.стандартный ввод.строка чтения()    "" "эта функция                                      получает одну строчку                                      и возвращает "" "

Строки документации (строки документации), то есть строки, которые расположены отдельно без назначения в качестве первой строки с отступом в модуле, классе, методе или функции, автоматически устанавливают свое содержимое как атрибут с именем __doc__, который предназначен для хранения удобочитаемого описания назначения, поведения и использования объекта. Встроенный помощь функция генерирует свой вывод на основе __doc__ атрибуты. Такие строки могут быть разделены " или же ' для однострочных строк или может охватывать несколько строк, если они разделены """ или же ''' это обозначение Python для указания многострочных строк. Однако в руководстве по стилю для языка указано, что тройные двойные кавычки (""") предпочтительны как для однострочных, так и для многострочных строк документации.

Однострочная строка документации:

def Getline():    "" "Получить одну строку из стандартного ввода и вернуть ее." ""    возвращаться sys.стандартный ввод.строка чтения()

Многострочная строка документации:

def Getline():    "" "Получить одну строчку       из стандартного ввода       и верните его. "" "    возвращаться sys.стандартный ввод.строка чтения()

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

Доступны инструменты, которые могут извлекать строки документации для создания API документация из кода. Документацию по строкам документов можно также получить из интерпретатора с помощью помощь() функции, или из оболочки с Pydoc команда Pydoc.

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

Аннотации функций

Аннотации функций определены в PEP 3107. Они позволяют прикреплять данные к аргументам и возвращать функцию. Поведение аннотаций не определяется языком и предоставляется сторонним фреймворкам. Например, можно написать библиотеку для обработки статической типизации:^[23]

def тянуть(элемент: Транспортировка, *варги: PackAnimal) -> Расстояние

Декораторы

Смотрите также: Совет (информатика)

Декоратор - это любой вызываемый объект Python, который используется для изменения определения функции, метода или класса. Декоратору передается исходный определяемый объект и он возвращает измененный объект, который затем привязывается к имени в определении. Декораторы Python были частично вдохновлены Аннотации Java, и имеют аналогичный синтаксис; синтаксис декоратора чистый синтаксический сахар, с помощью @ как ключевое слово:

@viking_chorusdef пункт меню():    Распечатать("спам")

эквивалентно

def пункт меню():    Распечатать("спам")пункт меню = viking_chorus(пункт меню)

Декораторы - это форма метапрограммирование; они усиливают действие функции или метода, который они украшают. Например, в приведенном ниже примере viking_chorus может вызвать пункт меню выполнить 8 раз (см. Эскиз спама ) каждый раз, когда он вызывается:

def viking_chorus(myfunc):    def inner_func(*аргументы, **kwargs):        за я в классифицировать(8):            myfunc(*аргументы, **kwargs)    возвращаться inner_func

Каноническое использование декораторов функций предназначено для создания методы класса или же статические методы, добавление атрибутов функции, отслеживание, параметр предварительно и постусловия, и синхронизация,^[24] но может использоваться для гораздо большего, в том числе устранение хвостовой рекурсии,^[25] мемоизация и даже улучшение написания декораторов.^[26]

Декораторы можно объединить в цепочку, разместив несколько на соседних строках:

@invincible@любимый цвет("Синий")def черный рыцарь():    проходить

эквивалентно

def черный рыцарь():    проходитьчерный рыцарь = непобедимый(любимый цвет("Синий")(черный рыцарь))

или, используя промежуточные переменные

def черный рыцарь():    проходитьblue_decorator = любимый цвет("Синий")Decorated_by_blue = blue_decorator(черный рыцарь)черный рыцарь = непобедимый(Decorated_by_blue)

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

def любимый цвет(цвет):    def декоратор(func):        def обертка():            Распечатать(цвет)            func()        возвращаться обертка    возвращаться декоратор

Затем это украсит черный рыцарь функция такая, что цвет, "Синий", будет напечатан до черный рыцарь функция работает. Закрытие гарантирует, что аргумент цвета доступен для самой внутренней функции-оболочки, даже когда он возвращается и выходит за пределы области видимости, что позволяет декораторам работать.

Несмотря на название, декораторы Python не являются реализацией декоратор шаблон. Шаблон декоратора - это шаблон дизайна используется в статически типизированный объектно-ориентированные языки программирования чтобы разрешить добавление функциональности к объектам во время выполнения; Декораторы Python добавляют функциональность к функциям и методам во время определения и, таким образом, представляют собой конструкцию более высокого уровня, чем классы шаблонов декораторов. Сам шаблон декоратора тривиально реализуем в Python, потому что язык утка напечатана, и поэтому обычно не рассматривается как таковой.^{[требуется разъяснение ]}

пасхальные яйца

Пользователи языки программирования с фигурными скобками, Такие как C или же Ява, иногда ожидают или хотят, чтобы Python следовал соглашению о разделителях блоков. Синтаксис блоков, разделенных фигурными скобками, неоднократно запрашивался и постоянно отклонялся разработчиками ядра. Интерпретатор Python содержит пасхальное яйцо который суммирует мнения разработчиков по этому поводу. Код from __future__ импортные скобки вызывает исключение SyntaxError: не шанс. В __будущее__ модуль обычно используется для предоставить функции из будущих версий Python.

Еще одно скрытое сообщение, Дзен Python (краткое изложение Философия Python ) отображается при попытке импортировать это.

Сообщение Привет, мир! печатается, когда оператор импорта импорт __hello__ используется. В Python 2.7 вместо Привет, мир! это печатает Привет, мир....

An антигравитационный модуль был добавлен в Python 2.7 и 3.0. При его импорте в веб-браузере открывается xkcd комический 353 который изображает юмористическое вымышленное использование такого модуля, предназначенное для демонстрации легкости, с которой модули Python включают дополнительные функции.^[27] В Python 3.0 этот модуль также содержит реализацию алгоритма «геохеш», ссылку на xkcd комический 426.^[28]

Рекомендации

1. «Читаемость имеет значение». - PEP 20 - Дзен Python В архиве 2014-12-05 в Wayback Machine
2. «PEP 20 - Дзен Python». Фонд программного обеспечения Python. 2004-08-23. В архиве из оригинала от 03.12.2008. Получено 2008-11-24.
3. «2. Лексический анализ». Документация Python v3.4.0a1. Docs.python.org. В архиве из оригинала от 17.09.2013. Получено 2013-08-16.
4. «2. Лексический анализ». Документация Python v2.7.5. Docs.python.org. В архиве с оригинала от 23.10.2012. Получено 2013-08-16.
5. "Новые ключевые слова". Документация Python v3.5. Docs.python.org. В архиве из оригинала от 18.06.2016. Получено 2016-06-01.
6. «PEP 498 - Интерполяция буквальной строки». Что нового в Python 3.6. 2016-12-23. В архиве из оригинала от 30.03.2017. Получено 2017-03-29.
7. «2. Лексический анализ». Документация Python v2.7.5. Docs.python.org. В архиве с оригинала от 23.10.2012. Получено 2013-08-16.
8. «2. Лексический анализ». Документация Python v2.7.5. Docs.python.org. В архиве с оригинала от 23.10.2012. Получено 2013-08-16.
9. Хэшируемые элементы обычно неизменяемы, но не обязательно по определению. Видеть python.org/3/glossary.htm
10. «Архивная копия». В архиве из оригинала от 27.01.2016. Получено 2016-01-19.
11. «Архивная копия». В архиве из оригинала от 26.01.2016. Получено 2016-01-19.
12. «Архивная копия». В архиве из оригинала от 26.01.2016. Получено 2016-01-19.
13. Дэвид Мертц. «Функциональное программирование на Python». IBM developerWorks. Архивировано из оригинал на 2007-02-20. Получено 2007-08-27.
14. «PEP 308 - Условные выражения». В архиве из оригинала от 13.03.2016. Получено 2016-04-14.
15. В нелокальный ключевое слово было принято PEP 3104 В архиве 2014-12-02 в Wayback Machine
16. «Руководство по стилю Python». docs.python-guide.org. В архиве из оригинала от 09.03.2015. Получено 2015-03-08.
17. «Архивная копия». В архиве из оригинала 14.12.2014. Получено 2014-08-15.
18. EAFP В архиве 2012-10-26 на Wayback Machine, Глоссарий Python
19. Гамблен, Дайан. «Только пределы нашего воображения: эксклюзивное интервью с RADM Грейс М. Хоппер». Журнал «Информационные технологии ВМФ». Архивировано из оригинал 14 января 2009 г.. Получено 2007-01-31.
20. Вкратце о Python, Алекс Мартелли, п. 134
21. LBYL В архиве 2018-01-21 в Wayback Machine, Глоссарий Python
22. Алекс Мартелли (19 мая 2003 г.). "EAFP против LBYL". список рассылки python-list. В архиве из оригинала 14 июля 2012 г.. Получено 18 июля 2011.
23. «Архивная копия». В архиве из оригинала от 06.01.2015. Получено 2014-08-15.
24. «Декораторы Python 2.4: сокращение дублирования кода и консолидация знаний». Доктора Добба. 2005-05-01. В архиве из оригинала от 06.02.2007. Получено 2007-02-08.
25. "Новый декоратор рекурсии хвоста". ASPN: Поваренная книга Python. 2006-11-14. В архиве из оригинала от 09.02.2007. Получено 2007-02-08.
26. «Модуль декоратора». В архиве из оригинала от 10 февраля 2007 г.. Получено 2007-02-08.
27. cpython: язык программирования Python, Python, 15.10.2017, в архиве из оригинала на 2017-09-15, получено 2017-10-15
28. «Еще одно спрятанное сокровище. · Python / cpython @ b1614a7». GitHub. Получено 2017-10-15.

внешняя ссылка

• Учебник по Python написано автором Python Гвидо ван Россумом.