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

Как упоминалось выше, еще одной сильной стороной 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]

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

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

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