Как создать программу на pascal abc: 404-Ошибка: 404

Шаблон 2:

 А
B B
С С С
Д Д Д Д
E E E E E 

Образец 2 похож на образец 1, только разница в символах.Вы можете видеть pattern2, символы меняются только на следующей итерации внешнего цикла. Таким образом, вы можете просто использовать «i - 1» при создании символов вместо «j» ( «i - 1», потому что «i» начинается с 1 ).

  пусть n = 5;
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Шаблон 3:

 А
ДО Н.Э
D E F
G H I J
К Л М Н О 

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

  пусть n = 5; // вы можете вводить данные, используя подсказку, или изменять значение
let string = "";
пусть count = 0;
// Внешний цикл
для (пусть i = 1; i  

Схема 4:

В этом шаблоне просто управляйте внутренним циклом, например, он выполняется «N» раз в первой итерации внешнего цикла, «N - 1» раз во второй итерации и т. Д.Чтобы получить эту переменную инициализации (j) меньше 'n - i + 1' . Теперь используйте переменную инициализации внутреннего цикла для увеличения символа.

  пусть n = 5; // вы можете вводить данные, используя подсказку, или изменять значение
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Шаблон 5:

Этот шаблон такой же, как и pattern4, с той лишь разницей, что вместо того, чтобы начинать символ с 'A', это символ со значением ASCII 'N - 1 + 65', где 'N' - высота шаблона.

Для этого используйте 'N - 1 - j' для создания символа и добавьте к нему 65 (65 - это значение ASCII для A).

  пусть n = 5; // вы можете вводить данные, используя подсказку, или изменять значение
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Шаблон 6:

Этот шаблон аналогичен шаблону 4, с той лишь разницей, что в шаблоне 4 начальным символом является «А», но в этом шаблоне конечный символ - «А» в каждой строке.

Для этого используйте 'N - i - j' для создания символа и добавьте к нему 65 (65 - это значение ASCII для A).

  пусть n = 5; // вы можете вводить данные, используя подсказку, или изменять значение
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Узор 7: узор пирамиды

 А
   ABC
  ABCDE
 ABCDEFG
ABCDEFGHI 

Это узор пирамиды с использованием алфавита, мы создали узор пирамиды с использованием звезд в последнем разделе.Используя ту же технику, создайте узор и вместо того, чтобы печатать звезды, напечатайте алфавиты, используя String.fromCharCode .

  пусть n = 5;
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Шаблон 8: Пирамида

 А
   BCD
  EFGHI
 JKLMNOP
QRSTUVWXY 

Этот шаблон аналогичен шаблону 7, только алфавиты увеличиваются на каждой итерации.

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

  пусть n = 5;
let string = "";
пусть count = 0;
// Внешний цикл
для (пусть i = 1; i  

Образец 9: Образец обратной пирамиды

 ABCDEFGHI
 ABCDEFG
  ABCDE
   ABC
    A 

Это обратная пирамида с использованием алфавитов.Просто управляйте формированием пространств и созданием звезд в обратном порядке. См. Код ниже, чтобы понять.

Сравните коды пирамиды и обратной пирамиды для лучшего понимания.

  пусть n = 5;
let string = "";
// Внешний цикл
для (пусть i = 1; i  

Узор 10: Ромбовидный узор

 А
   ABC
  ABCDE
 ABCDEFG
ABCDEFGHI
 ABCDEFG
  ABCDE
   ABC
    A 

Ромбовидный узор представляет собой комбинацию букв пирамиды и обратной пирамиды.

  пусть n = 5;
let string = "";
// Пирамида
для (пусть i = 1; i  

Выкройка 11: Выкройка песочных часов

 ABCDEFGHI
 ABCDEFG
  ABCDE
   ABC
    А
   ABC
  ABCDE
 ABCDEFG
ABCDEFGHI 

«Песочные часы» - это комбинация перевернутой пирамиды и пирамидального алфавита.

  пусть n = 5;
let string = "";
// Обратная пирамида
для (пусть i = 1; i  

Паттерн 12: Паттерн Паскаля

 А
AB
ABC
ABCD
ABCDE
ABCD
ABC
AB
A 

Паскаля такой же, как ромбовидный узор, только удаляет пробелы и меняет условия во внутренних циклах.

  пусть n = 5;
let string = "";
// Пирамида
для (пусть i = 1; i  

Заключение

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

на создание комедии, ориентированной на голосование, специально для ABC - срок

Мишель Обама и ее организация «Когда мы все голосуем» будут сотрудничать с ATTN, чтобы внести некоторую комедию в преддверии выборов 2020 года.В среду ABC объявила, что Обама и ATTN: объединятся в своей специальной комедии в прайм-тайм VOMO: Vote or Miss Out , которую ведет Кевин Харт.

«Мы несем ответственность перед обществом за участие в демократии в нашей стране», - сказал Том Вернер. «Эта беспартийная специальная комедия побудит людей проголосовать в ноябре этого года».

Часовой специальный выпуск, который выйдет в эфир 14 сентября, побудит зрителей выполнить свой гражданский долг и проголосовать на предстоящих в ноябре президентских выборах. Во время одноразового комедийного сериала появятся Тиффани Хаддиш, Скарлетт Йоханссон, Уилл Феррелл, Джей Лено, Джейден Смит и Уиллоу Смит. Также к нам присоединились Тим Аллен, Уитни Каммингс, Кайя Гербер, Charlamagne tha God, Cristela Alonzo, 2 Chainz и Lil Baby.

Связанная история

Крайний срок сейчас: Мишель Обама разрывает Дональда Трампа в речи Национального комитета Демократической партии, и президент дал озадачивающий ответ на пресс-конференции

В то время как должно появиться множество развлекательных личностей, политические деятели также зайдут.В специальной комедии Мишель Обамы присоединятся бывший губернатор Арнольд Шварценеггер, губернатор Ларри Хоган, Энн Ромни и Синди Маккейн.

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

«Участие избирателей заложено в ДНК ATTN :, и мы надеемся, что сможем организовать мероприятие, которое будет обращено ко всем поколениям, молодым и старым, таким образом, чтобы показать им, что, участвуя в политическом процессе, мы получаем исключительные возможность, чтобы наши голоса и ценности были отражены на всех уровнях правительства », - сказал соучредитель ATTN Мэтью Сигал.

ВОМО будет выходить в эфир на канале ABC с 10 до 23 часов. 14 сентября. Комедийное шоу знаменует собой очередное сотрудничество ATTN: и бывшей первой леди.

Специальная комедия ABC была создана ATTN :, Sara + Tom, производственной компанией, основанной исполнительными продюсерами The Conners Сарой Гилберт и Томом Вернером; Когда мы все голосуем и продюсерская компания Done + Dusted.

HOWTO по функциональному программированию - документация Python 3.9.5

Автор

А.М. Кучлинг

Выпуск

0,32

В этом документе мы познакомимся с функциями Python, подходящими для реализация программ в функциональном стиле. После введения в концепции функционального программирования, мы рассмотрим особенности языка, такие как итераторы и генераторы и соответствующие библиотечные модули, такие как itertools и functools .

Введение

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

Языки программирования поддерживают декомпозицию задач несколькими способами:

• Большинство языков программирования процедурные : программы - это списки инструкции, которые говорят компьютеру, что делать с вводом программы. C, Паскаль и даже оболочки Unix - это процедурные языки.

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

• Объектно-ориентированные программы управляют коллекциями объектов. Объекты имеют внутреннее состояние и методы поддержки, которые запрашивают или изменяют это внутреннее состояние в каким-то образом. Smalltalk и Java - объектно-ориентированные языки. C ++ и Python это языки, которые поддерживают объектно-ориентированное программирование, но не заставляют использование объектно-ориентированных функций.

• Функциональное программирование разбивает проблему на набор функций. В идеале функции принимают только входные данные и производят выходные данные и не имеют никаких внутреннее состояние, которое влияет на вывод, произведенный для данного ввода. Хорошо известный функциональные языки включают семейство ML (Standard ML, OCaml и другие варианты) и Haskell.

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

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

Некоторые языки очень строгие к чистоте и даже не имеют назначения такие как a = 3 или c = a + b , но избежать всех побочные эффекты.Печать на экран или запись в файл на диске - боковые эффекты, например. Например, в Python вызов print () или time.sleep () функции не возвращают никакого полезного значения; они нужны только для их побочные эффекты: отправка текста на экран или приостановка выполнения для второй.

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

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

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

Формальная доказуемость

Теоретическое преимущество состоит в том, что проще построить математическое доказательство того, что функциональная программа верна.

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

Метод, используемый для доказательства правильности программ, заключается в записи инвариантов , свойства входных данных и переменных программы, которые всегда правда.Затем для каждой строки кода вы показываете, что если инварианты X и Y верны С до строка выполняется, немного разные инварианты X ’и Y’ истина после строка выполняется. Это продолжается до тех пор, пока вы не дойдете до конца программа, после чего инварианты должны соответствовать желаемым условиям на выходе программы.

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

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

Модульность

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

Простота отладки и тестирования

Тестировать и отлаживать программы функционального стиля проще.

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

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

Совместимость

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

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

Итераторы

Я начну с рассмотрения одной из важных функций языка Python. основа для написания программ функционального стиля: итераторы.

Итератор - это объект, представляющий поток данных; этот объект возвращает данные по одному элементу за раз.Итератор Python должен поддерживать метод, называемый __next __ () , который не принимает аргументов и всегда возвращает следующий элемент потока. Если в потоке больше нет элементов, __next __ () должен вызвать исключение StopIteration . Однако итераторы не обязательно должны быть конечными; вполне разумно написать итератор, который производит бесконечный поток данных.

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

Можно поэкспериментировать с итерационным интерфейсом вручную:

 >>> L = [1, 2, 3]
>>> it = iter (L)
>>> это
<... объект-итератор в ...>
>>> it .__ next __ () # то же, что и next (it)
1
>>> далее (оно)
2
>>> далее (оно)
3
>>> далее (оно)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
StopIteration
>>>
 

Python ожидает итерируемых объектов в нескольких разных контекстах, наиболее важным является для заявления .В выписке для X в Y , Y должен быть итератором или каким-то объектом, для которого iter () может создать итератор. Эти два утверждения эквивалентны:

 для i в iter (obj):
    печать (я)

для я в obj:
    печать (я)
 

Итераторы могут быть материализованы в виде списков или кортежей с помощью list () или tuple () функций конструктора:

 >>> L = [1, 2, 3]
>>> итератор = iter (L)
>>> t = кортеж (итератор)
>>> т
(1, 2, 3)
 

Распаковка последовательности также поддерживает итераторы: если вы знаете, что итератор вернет N элементов, вы можете распаковать их в N-кортеж:

 >>> L = [1, 2, 3]
>>> итератор = iter (L)
>>> a, b, c = итератор
>>> а, б, в
(1, 2, 3)
 

Встроенные функции, такие как max () и min () могут принимать аргумент итератора и вернет самый большой или самый маленький элемент. "в" и «не в» операторы также поддерживают итераторы: X в итераторе истинно, если X находится в потоке, возвращаемом итератором. Вы столкнетесь с очевидным проблемы, если итератор бесконечен; макс. () , мин. () никогда не вернется, и если элемент X никогда не появляется в потоке, в операторах « и » не в «» тоже не вернутся.

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

Типы данных, поддерживающие итераторы

Мы уже видели, как списки и кортежи поддерживают итераторы. Фактически любой Python тип последовательности, такой как строки, автоматически поддерживает создание итератор.

Вызов iter () в словаре возвращает итератор, который будет перебирать ключи словаря:

 >>> m = {'Янв': 1, 'Фев': 2, 'Мар': 3, 'Апрель': 4, 'Май': 5, 'Июнь': 6,
... «июль»: 7, «август»: 8, «сен»: 9, «октябрь»: 10, «ноя»: 11, «декабрь»: 12}
>>> для ввода m:
... print (клавиша, m [клавиша])
1 января
2 февраля
3 марта
4 апреля
5 мая
6 июн
7 июл
8 августа
9 сен
10 октября
11 ноя
12 декабря
 

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

Применение iter () к словарю всегда проходит по ключам, но в словарях есть методы, возвращающие другие итераторы. Если вы хотите повторить над значениями или парами ключ / значение, вы можете явно вызвать values ​​() или items () методов для получения подходящего итератор.

Конструктор dict () может принимать итератор, который возвращает конечный поток. из (ключ, значение) кортежей:

 >>> L = [('Италия', 'Рим'), ('Франция', 'Париж'), ('США', 'Вашингтон, округ Колумбия')]
>>> dict (iter (L))
{'Италия': 'Рим', 'Франция': 'Париж', 'США': 'Вашингтон, округ Колумбия'}
 

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

 для строки в файле:
    # сделать что-нибудь для каждой строки
    ...
 

Наборы могут брать свое содержимое из итерируемого объекта и позволять вам перебирать элементы:

 S = {2, 3, 5, 7, 11, 13}
для i в S:
    печать (я)
 

Генератор выражений и понимание списков

Две общие операции на выходе итератора: 1) выполнение некоторой операции для каждого элемента, 2) выбор подмножества элементов, удовлетворяющих некоторому условию.Например, учитывая список строк, вы можете удалить завершающие пробел из каждой строки или извлеките все строки, содержащие данную подстрока.

Составление списков и выражения генератора (краткая форма: «listcomps» и «Genexps») - краткое обозначение таких операций, заимствованное из язык функционального программирования Haskell (https://www.haskell.org/). Вы можете раздеться все пробелы из потока строк со следующим кодом:

 line_list = ['строка 1 \ n', 'строка 2 \ n',...]

# Генератор выражения - возвращает итератор
stripped_iter = (line.strip () для строки в line_list)

# Понимание списка - возвращает список
stripped_list = [line.strip () для строки в line_list]
 

Вы можете выбрать только определенные элементы, добавив условие "if" :

 stripped_list = [line.strip () для строки в line_list
                 если строка! = ""]
 

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

Выражения генератора заключены в круглые скобки («()») и перечислены понимания заключаются в квадратные скобки («[]»). Генератор выражений имеют вид:

 (выражение для expr в последовательности1
             если условие1
             для expr2 в последовательности2
             если условие2
             для expr3 в последовательности3...
             если условие3
             для exprN в последовательностиN
             если условиеN)
 

Опять же, для понимания списка отличаются только внешние скобки (квадратные скобки вместо скобок).

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

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

 obj_total = sum (obj.count для obj в list_all_objects ())
 

Предложения for ... in содержат последовательности, по которым нужно выполнить итерацию. В последовательности не обязательно должны быть одинаковой длины, потому что они повторяются из слева направо, , а не параллельно. Для каждого элемента в последовательности 1 , последовательность2 зацикливается с начала. последовательность3 затем зацикливается over для каждой результирующей пары элементов из sequence1 и sequence2 .

Другими словами, выражение для понимания списка или генератора эквивалентно следующему коду Python:

 для expr1 в последовательности1:
    если нет (условие1):
        continue # Пропустить этот элемент
    для expr2 в последовательности2:
        если нет (условие2):
            continue # Пропустить этот элемент
        ...
        для exprN в последовательностиN:
            если нет (условиеN):
                continue # Пропустить этот элемент

            # Вывести значение
            # выражение.

Это означает, что при наличии нескольких for ... в статьях , но нет , если предложений, длина результирующего вывода будет равна произведению длины всех последовательностей. Если у вас есть два списка длиной 3, вывод список состоит из 9 элементов:

 >>> seq1 = 'abc'
>>> seq2 = (1, 2, 3)
>>> [(x, y) для x в seq1 для y в seq2]
[('а', 1), ('а', 2), ('а', 3),
 ('b', 1), ('b', 2), ('b', 3),
 ('c', 1), ('c', 2), ('c', 3)]
 

Чтобы избежать двусмысленности в грамматике Python, если выражение при создании кортежа он должен быть заключен в круглые скобки.Первый список понимание ниже - это синтаксическая ошибка, а вторая правильная:

 # Синтаксическая ошибка
[x, y для x в seq1 для y в seq2]
# Верный
[(x, y) для x в seq1 для y в seq2]
 

Генераторы

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

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

Вот простейший пример функции генератора:

 >>> def generate_ints (N):
... для i в диапазоне (N):
... выход я
 

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

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

Вот пример использования генератора generate_ints () :

 >>> gen = generate_ints (3)
>>> gen
<объект-генератор generate_ints в...>
>>> следующий (генерал)
0
>>> следующий (генерал)
1
>>> следующий (генерал)
2
>>> следующий (генерал)
Отслеживание (последний вызов последний):
  Файл "stdin", строка 1, в 
  Файл "stdin", строка 2, в generate_ints
StopIteration
 

Вы также можете записать для i в generate_ints (5) или a, b, c = генерировать_интс (3) .

Внутри функции генератора возвращаемое значение вызывает StopIteration (значение) быть поднятым из метода __next __ () .Как только это произойдет, или достигается нижняя часть функции, последовательность значений заканчивается и генератор не может дать никаких других значений.

Вы можете добиться эффекта генераторов вручную, написав свой собственный класс и сохранение всех локальных переменных генератора как переменных экземпляра. Для Например, вернуть список целых чисел можно, установив для self.count значение 0, а метод __next __ () увеличивает self.count и верни это.Однако для умеренно сложного генератора написание соответствующего класса может быть намного сложнее.

Набор тестов, включенный в библиотеку Python, Lib / test / test_generators.py, содержит ряд более интересных примеров. Вот один генератор, реализующий рекурсивный обход дерева с использованием генераторов.

 # Рекурсивный генератор, который по порядку генерирует листья дерева.
def inorder (t):
    Если T:
        для x в порядке (t.left):
            доход x

        урожай т.метка

        для x в порядке (справа):
            доход x
 

Два других примера в test_generators.py производят решения для N-Queens проблема (размещение N ферзей на шахматной доске NxN, чтобы ни один ферзь не угрожал другой) и Рыцарский тур (поиск маршрута, который приведет рыцаря к каждому квадрат шахматной доски NxN без двойного посещения любого квадрата).

Передача значений в генератор

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

В Python 2.5 есть простой способ передать значения в генератор. yield стал выражением, возвращающим значение, которое может быть присвоено переменная или иным образом оперированная:

Я рекомендую вам всегда заключать в круглые скобки выражение yield когда вы что-то делаете с возвращенным значением, как в приведенном выше примере.Скобки не всегда нужны, но их всегда проще добавить вместо того, чтобы помнить, когда они нужны.

( PEP 342 объясняет точные правила, которые заключаются в том, что выражение yield должно всегда заключаться в круглые скобки, кроме случаев, когда это встречается в выражении верхнего уровня на правая часть задания. Это означает, что вы можете написать val = yield i но нужно использовать круглые скобки, когда есть операция, как в val = (yield i) + 12 .)

Значения отправляются в генератор путем вызова его метода send (value) . Этот метод возобновляет код генератора и yield выражение возвращает указанное значение. Если регулярный __next __ () вызывается, yield возвращает None .

Вот простой счетчик, который увеличивается на 1 и позволяет изменять значение внутренний счетчик.

 (максимум):
    я = 0
    пока я <максимум:
        val = (доход i)
        # Если значение указано, изменить счетчик
        если val не равно None:
            я = val
        еще:
            я + = 1
 

А вот пример смены счетчика:

 >>> it = counter (10)
>>> далее (оно)
0
>>> далее (оно)
1
>>> это.отправить (8)
8
>>> далее (оно)
9
>>> далее (оно)
Отслеживание (последний вызов последний):
  Файл "t.py", строка 15, в 
    it.next ()
StopIteration
 

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

Помимо send () , есть еще два метода на генераторы:

• throw (type, value = None, traceback = None) используется для вызвать исключение внутри генератора; исключение вызвано возвращает выражение , в котором выполнение генератора приостанавливается.

• close () вызывает исключение GeneratorExit внутри генератор для завершения итерации. Получив это исключение, код генератора должен либо вызывать GeneratorExit , либо StopIteration ; поймать исключение и сделать что-нибудь еще незаконно и вызовет RuntimeError . закрыть () также будет вызываться сборщиком мусора Python, когда генератор сборщик мусора.

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

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

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

Встроенные функции

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

Две встроенные функции Python, map () и filter () дублируют особенности генератора выражений:

map (f, iterA, iterB, ...) возвращает итератор по последовательности

f (iterA [0], iterB [0]), f (iterA [1], iterB [1] ), f (iterA [2], iterB [2]), ... .

 >>> def верх:
... return s.upper ()
 

 >>> список (карта (верхняя, ['предложение', 'фрагмент']))
['ЧАСТЬ ПРЕДЛОЖЕНИЯ']
>>> [верхние (и) буквы s в ['предложение', 'фрагмент']]
['ЧАСТЬ ПРЕДЛОЖЕНИЯ']
 

Конечно, вы можете добиться того же эффекта с пониманием списка.

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

 >>> def is_even (x):
... return (x% 2) == 0
 

 >>> список (фильтр (is_even, диапазон (10)))
[0, 2, 4, 6, 8]
 

Это также можно записать в виде списка:

 >>> список (x вместо x в диапазоне (10), если is_even (x))
[0, 2, 4, 6, 8]
 

enumerate (iter, start = 0) считает элементы в итерация, возвращающая 2-кортежи, содержащие счетчик (от до ) и каждый элемент.

 >>> для элемента в перечислении (['субъект', 'глагол', 'объект']):
... печать (элемент)
(0, 'тема')
(1, 'глагол')
(2, 'объект')
 

enumerate () часто используется при просмотре списка и записи индексы, при которых выполняются определенные условия:

 f = открытый ('data.txt', 'r')
для i, строка в enumerate (f):
    если line.strip () == '':
        print ('Пустая строка в строке #% i'% i)
 

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

 >>> импорт случайный
>>> # Генерация 8 случайных чисел от [0, 10000)
>>> rand_list = random.sample (диапазон (10000), 8)
>>> rand_list
[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]
>>> отсортировано (rand_list)
[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]
>>> отсортировано (rand_list, reverse = True)
[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]
 

(Для более подробного обсуждения сортировки см. Сортировка КАК.)

Встроенные модули any (iter) и all (iter) значения истинности содержимого итеративного объекта. any () возвращает True , если какой-либо элемент в итерируемом объекте - истинное значение, а all () возвращает True , если все элементы являются истинными значениями:

 >>> любое ([0, 1, 0])
Правда
>>> любой ([0, 0, 0])
Ложь
>>> любой ([1, 1, 1])
Правда
>>> все ([0, 1, 0])
Ложь
>>> все ([0, 0, 0])
Ложь
>>> все ([1, 1, 1])
Правда
 

почтовый индекс (iterA, iterB,...) берет по одному элементу из каждой итерации и возвращает их в кортеже:

 zip (['a', 'b', 'c'], (1, 2, 3)) =>
  ('а', 1), ('б', 2), ('в', 3)
 

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

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

 почтовый индекс (['a', 'b'], (1, 2, 3)) =>
  ('а', 1), ('б', 2)
 

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

Модуль itertools

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

Функции модуля делятся на несколько широких классов:

• Функции, которые создают новый итератор на основе существующего итератора.

• Функции для обработки элементов итератора как аргументов функции.

• Функции для выбора частей вывода итератора.

• Функция для группировки вывода итератора.

Создание новых итераторов

itertools.count (start, step) возвращает бесконечное поток равномерно расположенных значений. При желании вы можете указать начальный номер, который по умолчанию равен 0, и интервал между числами, который по умолчанию равен 1:

 itertools.count () =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count (10) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
itertools.count (10, 5) =>
  10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...
 

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

 itertools.cycle ([1, 2, 3, 4, 5]) =>
  1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
 

itertools.repeat (elem, [n]) возвращает предоставленный элемент n раз, или возвращает элемент бесконечно, если n не предоставлено.

 itertools.repeat ('abc') =>
  abc, abc, abc, abc, abc, abc, abc, abc, abc, abc, ...
itertools.repeat ('abc', 5) =>
  abc, abc, abc, abc, abc
 

itertools.цепочка (iterA, iterB, ...) принимает произвольный количество итераций в качестве входных данных и возвращает все элементы первого итератор, затем все элементы второго и так далее, пока все итераторы исчерпаны.

 itertools.chain (['a', 'b', 'c'], (1, 2, 3)) =>
  а, б, в, 1, 2, 3
 

itertools.islice (iter, [start], stop, [step]) возвращает поток, являющийся частью итератора. С одним аргументом stop он вернет первые стоп-элементов .Если вы предоставите начальный индекс, вы получить стоп-старт элементов, и если вы укажете значение для шага , элементы будут пропущены соответственно. В отличие от Python для нарезки строк и списков, вы не можете используйте отрицательные значения для start , stop или step .

 itertools.islice (диапазон (10), 8) =>
  0, 1, 2, 3, 4, 5, 6, 7
itertools.islice (диапазон (10), 2, 8) =>
  2, 3, 4, 5, 6, 7
itertools.islice (диапазон (10), 2, 8, 2) =>
  2, 4, 6
 

itertools.tee (iter, [n]) копирует итератор; Это возвращает n независимых итераторов, которые все возвращают содержимое исходный итератор. Если вы не укажете значение для n , по умолчанию будет 2. Репликация итераторов требует сохранения некоторого содержимого исходного итератора, поэтому это может потреблять значительный объем памяти, если итератор большой и один из новых итераторов потребляется больше, чем другие.

 itertools.tee (itertools.count ()) =>
   iterA, iterB

где iterA ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,...

и iterB ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
 

Вызов функций на элементах

Оператор Модуль содержит набор функций, соответствующих Python операторы. Некоторые примеры: operator.add (a, b) (добавляет два значения), operator.ne (a, b) (то же, что и a! = b ) и operator.attrgetter ('id') (возвращает вызываемый объект, который выбирает атрибут .id ).

itertools.starmap (func, iter) предполагает, что iterable вернет поток кортежей и вызовет функцию func , используя эти кортежи как аргументы:

 itertools.starmap (os.path.join,
                  [('/ bin', 'python'), ('/ usr', 'bin', 'java'),
                   ('/ usr', 'bin', 'perl'), ('/ usr', 'bin', 'ruby')])
=>
  / bin / python, / usr / bin / java, / usr / bin / perl, / usr / bin / ruby
 

Выбор элементов

Другая группа функций выбирает подмножество элементов итератора на основе предикат.

itertools.filterfalse (предикат, iter) - это напротив filter () , возвращая все элементы, для которых предикат возвращает false:

 itertools.filterfalse (is_even, itertools.count ()) =>
  1, 3, 5, 7, 9, 11, 13, 15, ...
 

itertools.takewhile (предикат, iter) возвращает элементы до тех пор, пока предикат возвращает истину. Как только предикат возвращается false, итератор сигнализирует об окончании своих результатов.

 по умолчанию less_than_10 (x):
    вернуть x <10

itertools.takewhile (less_than_10, itertools.count ()) =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9

itertools.takewhile (is_even, itertools.count ()) =>
  0
 

itertools.drop while (предикат, iter) отбрасывает элементов, в то время как предикат возвращает истину, а затем возвращает остальную часть результаты iterable.

 itertools.drop while (less_than_10, itertools.count ()) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...

itertools.drop while (is_even, itertools.count ()) =>
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
 

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

 itertools.compress ([1, 2, 3, 4, 5], [True, True, False, False, True]) =>
   1, 2, 5
 

Комбинаторные функции

itertools.combinations (итерация, r) возвращает итератор, дающий все возможные комбинации r -элемент элементы, содержащиеся в итерируемом .

 itertools.combinations ([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 3), (2, 4), (2, 5),
  (3, 4), (3, 5),
  (4, 5)

itertools.combinations ([1, 2, 3, 4, 5], 3) =>
  (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5),
  (2, 3, 4), (2, 3, 5), (2, 4, 5),
  (3, 4, 5)
 

Элементы в каждом кортеже остаются в том же порядке, что и итерация вернула их.Например, цифра 1 всегда стоит перед 2, 3, 4 или 5 в приведенных выше примерах. Аналогичная функция, itertools.permutations (итерируемый, r = None) , снимает это ограничение порядка, возвращая все возможные устройства длиной r :

 itertools.permutations ([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 1), (2, 3), (2, 4), (2, 5),
  (3, 1), (3, 2), (3, 4), (3, 5),
  (4, 1), (4, 2), (4, 3), (4, 5),
  (5, 1), (5, 2), (5, 3), (5, 4)

itertools.перестановки ([1, 2, 3, 4, 5]) =>
  (1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5),
  ...
  (5, 4, 3, 2, 1)
 

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

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

 itertools.permutations ('aba', 3) =>
  ('a', 'b', 'a'), ('a', 'a', 'b'), ('b', 'a', 'a'),
  ('b', 'a', 'a'), ('a', 'a', 'b'), ('a', 'b', 'a')
 

Идентичный кортеж ('a', 'a', 'b') встречается дважды, но два ‘a’ струны пришли с разных позиций.

itertools.combinations_with_replacement (итерация, r) функция ослабляет другое ограничение: элементы могут повторяться в одном кортеже. Концептуально выбирается элемент для первая позиция каждого кортежа, а затем заменяется перед второй выбран элемент.

 itertools.combinations_with_replacement ([1, 2, 3, 4, 5], 2) =>
  (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 2), (2, 3), (2, 4), (2, 5),
  (3, 3), (3, 4), (3, 5),
  (4, 4), (4, 5),
  (5, 5)
 

Группирующие элементы

Последняя функция, о которой я расскажу, itertools.groupby (iter, key_func = None) - самый сложный. key_func (elem) - это функция который может вычислять значение ключа для каждого элемента, возвращаемого итерируемым. если ты не предоставляют ключевой функции, ключ - это просто каждый элемент сам по себе.

groupby () собирает все последовательные элементы из базовая итерация, имеющая то же значение ключа и возвращающая поток 2-кортежи, содержащие значение ключа и итератор для элементов с этим ключом.

 city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
             ('Анкоридж', 'АК'), ('Ном', 'АК'),
             ('Флагстафф', 'Аризона'), ('Феникс', 'Аризона'), ('Тусон', 'Аризона'),
             ...
            ]

def get_state (city_state):
    вернуть city_state [1]

itertools.groupby (city_list, get_state) =>
  ('AL', итератор-1),
  ('AK', итератор-2),
  ('AZ', итератор-3), ...

где
итератор-1 =>
  ('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
итератор-2 =>
  ('Анкоридж', 'АК'), ('Ном', 'АК')
итератор-3 =>
  ('Флагстафф', 'Аризона'), ('Феникс', 'Аризона'), ('Тусон', 'Аризона')
 

groupby () предполагает, что содержимое нижележащего итеративного объекта будет уже отсортированы по ключу.Обратите внимание, что возвращенные итераторы также используют базовая итерация, поэтому вы должны использовать результаты итератора-1 перед запрашивает итератор-2 и соответствующий ему ключ.

Модуль functools

Модуль functools в Python 2.5 содержит некоторые функции высшего порядка. Функция высшего порядка принимает одну или несколько функций в качестве входных данных и возвращает новая функция. Самый полезный инструмент в этом модуле - это functools.partial () функция.

Для программ, написанных в функциональном стиле, иногда может понадобиться построить варианты существующих функций с заполненными некоторыми параметрами. Рассмотрим функцию Python f (a, b, c) ; вы можете захотеть создать новую функцию g (b, c) , что эквивалентно f (1, b, c) ; вы заполняете значение для один из параметров f () . Это называется «частичное применение функции».

Конструктор для partial () принимает аргументы (функция, аргумент1, аргумент2,..., kwarg1 = значение1, kwarg2 = значение2) . Результирующий объект является вызываемым, поэтому вы можете просто вызвать его, чтобы вызвать функцию с заполненные аргументы.

Вот небольшой, но реалистичный пример:

 import functools

def log (сообщение, подсистема):
    "" "Записать содержимое 'message' в указанную подсистему." ""
    print ('% s:% s'% (подсистема, сообщение))
    ...

server_log = functools.partial (журнал, подсистема = 'сервер')
server_log ('Невозможно открыть сокет')
 

functools.уменьшить (func, iter, [начальное_значение]) кумулятивно выполняет операцию над всеми элементами итерации и, следовательно, не может применяться к бесконечным итерациям. func должна быть функцией который принимает два элемента и возвращает одно значение. functools.reduce () берет первые два элемента A и B, возвращенные итератором, и вычисляет функция (A, B) . Затем он запрашивает третий элемент, C, вычисляет func (func (A, B), C) , объединяет этот результат с возвращенным четвертым элементом, и продолжается до тех пор, пока итерация не будет исчерпана.Если итерация возвращает no значений, возникает исключение TypeError . Если начальное значение поставляется, он используется в качестве отправной точки, а func (initial_value, A) - это первый расчет.

 >>> оператор импорта, functools
>>> functools.reduce (operator.concat, ['A', 'BB', 'C'])
"ABBC"
>>> functools.reduce (operator.concat, [])
Отслеживание (последний вызов последний):
  ...
TypeError: reduce () пустой последовательности без начального значения
>>> functools.уменьшить (operator.mul, [1, 2, 3], 1)
6
>>> functools.reduce (operator.mul, [], 1)
1
 

Если вы используете operator.add () с functools.reduce () , вы сложите все элементы повторяемого. Этот случай настолько распространен, что существует особый встроенная функция sum () для ее вычисления:

 >>> import functools, оператор
>>> functools.reduce (operator.add, [1, 2, 3, 4], 0)
10
>>> sum ([1, 2, 3, 4])
10
>>> сумма ([])
0
 

Для многих применений functools.reduce () , но может быть проще просто напишите очевидное для цикла :

 import functools
# Вместо:
product = functools.reduce (operator.mul, [1, 2, 3], 1)

# Ты можешь написать:
product = 1
для i в [1, 2, 3]:
    продукт * = я
 

Связанная функция - itertools.accumulate (iterable, func = operator.add) . Он выполняет тот же расчет, но вместо возвращая только окончательный результат, Accumulate () возвращает итератор, который также дает каждый частичный результат:

 itertools.накопить ([1, 2, 3, 4, 5]) =>
  1, 3, 6, 10, 15

itertools.accumulate ([1, 2, 3, 4, 5], operator.mul) =>
  1, 2, 6, 24, 120
 

Операторский модуль

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

Некоторые из функций этого модуля:

• Математические операции: add () , sub () , mul () , floordiv () , abs () ,…

• Логические операции: not_ () , true () .

• Побитовые операции: and _ () , or_ () , invert () .

• Сравнения: eq () , ne () , lt () , le () , gt () и ge () .

• Идентификатор объекта: is_ () , is_not () .

Полный список см. В документации операторского модуля.

Маленькие функции и лямбда-выражение

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

Если есть встроенная функция Python или подходящая функция модуля, вы не нужно вообще определить новую функцию:

 stripped_lines = [line.strip () для строки в строках]
существующие_файлы = фильтр (os.path.exists, список_файлов)
 

Если нужной функции не существует, ее нужно написать. Один способ написать small functions - использовать выражение lambda . лямбда принимает количество параметров и выражение, объединяющее эти параметры, и создает анонимная функция, которая возвращает значение выражения:

 сумматор = лямбда x, y: x + y

print_assign = имя лямбда, значение: name + '=' + str (значение)
 

Альтернативой является использование оператора def и определение функции в обычный способ:

 def сумматор (x, y):
    вернуть x + y

def print_assign (имя, значение):
    вернуть имя + '=' + str (значение)
 

Какая альтернатива предпочтительнее? Это вопрос стиля; мой обычный курс - это избегайте использования лямбда .

Одна из причин, по которой я предпочитаю, заключается в том, что лямбда довольно ограничена в функции, которые он может определять. Результат должен быть вычислим как один выражение, которое означает, что у вас не может быть multiway if ... elif ... else сравнения или попробуйте ... кроме операторов. Если вы попытаетесь сделать слишком много в лямбда , вы получите слишком сложное выражение, которое трудно читать. Быстро, что делает следующий код?

 import functools
total = functools.reduce (лямбда a, b: (0, a [1] + b [1]), items) [1]
 

Разобраться можно, но нужно время, чтобы распутать выражение, чтобы понять из того, что происходит. Использование коротких вложенных операторов def делает вещи немного лучше:

 import functools
def комбинировать (a, b):
    вернуть 0, a [1] + b [1]

total = functools.reduce (объединить, элементы) [1]
 

Но было бы лучше всего, если бы я просто использовал для петли :

 всего = 0
для a, b в пунктах:
    итого + = b
 

Или встроенная функция sum () и выражение генератора:

 = сумма (b для a, b в пунктах)
 

Многие виды использования функций .reduce () понятнее, если записать его как для циклов .

Фредрик Лунд однажды предложил следующий набор правил для рефакторинга использования лямбда :

1. Запишите лямбда-функцию.

2. Напишите комментарий, объясняющий, что, черт возьми, делает лямбда.

3. Изучите комментарий некоторое время и придумайте имя, которое отражает суть комментария.

4. Преобразуйте лямбда в оператор def, используя это имя.

5. Удалить комментарий.

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

История изменений и благодарности

Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь в различных черновиках этой статьи: Ян Бикинг, Ник Коглан, Ник Эфффорд, Рэймонд Хеттингер, Джим Джуэтт, Майк Крелл, Леандро Ламейро, Юсси Салмела, Коллин Винтер, Блейк Винтон.

Версия 0.1: опубликовано 30 июня 2006 г.

Версия 0.11: опубликовано 1 июля 2006 г. Исправлены опечатки.

Версия 0.2: опубликовано 10 июля 2006 г. Разделы genexp и listcomp объединены в один. Исправления опечаток.

Версия 0.21: Добавлены дополнительные ссылки, предлагаемые в список рассылки репетиторов.

Версия 0.30: Добавляет раздел о функциональном модуле , написанный Коллином. Зима; добавляет короткий раздел на операторском модуле; несколько других правок.

Список литературы

Для Python

http: // gnosis.cx / TPiP /: первая глава книги Дэвида Мерца. Обработка текста в Python обсуждает функциональное программирование для обработки текста в разделе «Использование функций высшего порядка в Обработка текста ».

Мертц также написал серию из трех статей по функциональному программированию. для сайта IBM DeveloperWorks; видеть часть 1, часть 2, и часть 3,

Документация Python

Документация для модуля itertools .

Документация для модуля functools .

Документация для модуля оператора .

PEP 289 : «Генератор выражений»

PEP 342 : «Сопрограммы через расширенные генераторы» описывает новый генератор. функции в Python 2.5.

Определение вашей собственной функции Python - Настоящий Python

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

Из этого руководства вы узнаете:

• Как функции работают в Python и почему они полезны
• Как определить и вызвать вашу собственную функцию Python
• Механизмы передачи аргументов вашей функции
• Как вернуть данные из вашей функции обратно в вызывающую среду

Функции в Python

Возможно, вы знакомы с математической концепцией функции .Функция - это связь или отображение между одним или несколькими входами и набором выходов. В математике функция обычно представлена ​​так:

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

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

  >>> s = 'foobar'
>>> id (s)
56313440
  

len () возвращает длину переданного ему аргумента:

  >>> a = ['foo', 'bar', 'baz', 'qux']
>>> len (а)
4
  

any () принимает в качестве аргумента итерацию и возвращает Истина , если какой-либо из элементов в итерации является истинным, и Ложь в противном случае:

  >>> любое ([Ложь, Ложь, Ложь])
Ложь
>>> любое ([False, True, False])
Правда

>>> any (['bar' == 'baz', len ('foo') == 4, 'qux' в {'foo', 'bar', 'baz'}])
Ложь
>>> any (['bar' == 'baz', len ('foo') == 3, 'qux' in {'foo', 'bar', 'baz'}])
Правда
  

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

1. Какие аргументов (если есть) нужно
2. Какие значения (если есть) он возвращает

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

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

Примечание: В этом случае вы будете знать, где находится код и как именно он работает, потому что вы его написали!

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

Важность функций Python

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

• Подпрограммы
• Процедуры
• Методы
• Подпрограммы

Итак, зачем вообще определять функции? Есть несколько очень веских причин.Давайте пройдемся по нескольким.

Абстракция и возможность повторного использования

Предположим, вы пишете код, который делает что-то полезное. По мере продолжения разработки вы обнаружите, что задача, выполняемая этим кодом, вам часто требуется во многих различных местах вашего приложения. Что вы должны сделать? Что ж, вы можете просто копировать код снова и снова, используя возможность копирования и вставки вашего редактора.

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

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

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

Абстракция функциональности в определение функции является примером принципа «не повторяйся» (DRY) при разработке программного обеспечения.Это, пожалуй, самая сильная мотивация для использования функций.

Модульность

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

  # Основная программа

# Код для чтения файла в
<заявление>
<заявление>
<заявление>
<заявление>

# Код для обработки файла
<заявление>
<заявление>
<заявление>
<заявление>

# Код для записи файла
<заявление>
<заявление>
<заявление>
<заявление>
  

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

В качестве альтернативы вы можете структурировать код примерно так:

  def read_file ():
    # Код для чтения файла в
    <заявление>
    <заявление>
    <заявление>
    <заявление>

def process_file ():
    # Код для обработки файла
    <заявление>
    <заявление>
    <заявление>
    <заявление>

def write_file ():
    # Код для записи файла
    <заявление>
    <заявление>
    <заявление>
    <заявление>


# Основная программа
read_file ()
process_file ()
write_file ()
  

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

Примечание: Ключевое слово def вводит новое определение функции Python. Вы все об этом узнаете очень скоро.

В жизни вы делаете такие вещи все время, даже если не думаете об этом явно.Если бы вы захотели переместить несколько полок, заполненных вещами, из одной стороны гаража в другую, то, надеюсь, вы не станете просто стоять и бесцельно думать: «Ой, блин. Мне нужно перевезти все это туда! Как я это сделал???" Вы бы разделили задание на управляемые шаги:

1. Уберите все с полок.
2. Разъедините полки.
3. Перенесите части полки через гараж на новое место.
4. Снова соберите полок.
5. Отнесите вещей через гараж.
6. Положите вещей обратно на полки.

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

Разделение пространств имен

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

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

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

Надеюсь, вы достаточно убедились в достоинствах функций и хотите их создать! Посмотрим как.

Вызовы функций и определение

Обычный синтаксис для определения функции Python следующий:

  def <имя_функции> ([<параметры>]):
    <заявление (я)>
  

Компоненты определения поясняются в таблице ниже:

Последний элемент, , называется телом функции.Тело - это блок операторов, который будет выполняться при вызове функции. Тело функции Python определяется отступом в соответствии с правилом off-side. Это то же самое, что и кодовые блоки, связанные со структурой управления, например, if или while statement.

Синтаксис для вызова функции Python следующий:

  <имя_функции> ([<аргументы>])
  

<аргументы> - значения, переданные в функцию.Они соответствуют <параметры> в определении функции Python. Вы можете определить функцию, которая не принимает никаких аргументов, но круглые скобки по-прежнему необходимы. И определение функции, и вызов функции всегда должны включать круглые скобки, даже если они пусты.

Как обычно, вы начнете с небольшого примера, а затем добавите сложности. Помня освященную веками математическую традицию, вы вызовете свою первую функцию Python f () . Вот файл сценария foo.py , который определяет и вызывает f () :

  1def f ():
 2 s = '- Внутри f ()'
 3 отпечатка (ов)
 4
 5print ('Перед вызовом f ()')
 6f ()
 7print ('После вызова f ()')
  

Вот как работает этот код:

1. Строка 1 использует ключевое слово def , чтобы указать, что функция определяется. Выполнение оператора def просто создает определение f () . Все следующие строки с отступом (строки 2–3) становятся частью тела f () и сохраняются как его определение, но еще не выполняются.

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

3. Строка 5 - это первый оператор без отступа, поскольку он не является частью определения f () . Это начало основной программы.Когда выполняется основная программа, этот оператор выполняется первым.

4. Линия 6 - это звонок на номер f () . Обратите внимание, что пустые круглые скобки всегда требуются как в определении функции, так и при ее вызове, даже если нет параметров или аргументов. Выполнение переходит к f () , и выполняются операторы в теле f () .

5. Строка 7 - это следующая строка, выполняемая после завершения тела f () .Выполнение возвращается к этому оператору print () .

Последовательность выполнения (или потока управления ) для foo.py показана на следующей диаграмме:

Когда foo.py запускается из командной строки Windows, результат будет следующим:

  C: \ Users \ john \ Documents \ Python \ doc> python foo.py
Перед вызовом f ()
- Внутри f ()
После вызова f ()
  

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

  >>> def f ():
...     проходить
...
>>> f ()
  

Как видно выше, вызов функции-заглушки синтаксически допустим, но ничего не делает.

Передан аргумент

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

Позиционные аргументы

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

  >>> def f (кол-во, шт., Цена):
... print (f '{qty} {item} cost $ {price: .2f}')
...
  

При вызове функции указывается соответствующий список аргументов:

  >>> f (6, 'бананы', 1.74)
6 бананов стоят 1,74 доллара
  

Параметры ( кол-во , предмет и цена ) ведут себя как переменные , которые определены локально для функции.Когда функция вызывается, переданные аргументы ( 6 , «бананы» и 1.74 ) привязывают к параметрам по порядку, как если бы путем присвоения переменной:

В некоторых текстах по программированию параметры, указанные в определении функции, называются формальными параметрами , а аргументы в вызове функции называются фактическими параметрами :

Хотя позиционные аргументы являются наиболее простым способом передачи данных в функцию, они также обеспечивают наименьшую гибкость. Во-первых, порядок аргументов в вызове должен соответствовать порядку параметров в определении.Конечно, ничто не мешает вам указывать позиционные аргументы не по порядку:

  >>> f ('бананы', 1.74, 6)
бананы 1.74 стоят $ 6.00
  

  >>> # Слишком мало аргументов
>>> f (6, 'бананы')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    f (6, 'бананы')
TypeError: f () отсутствует 1 обязательный позиционный аргумент: 'цена'
  

  >>> # Слишком много аргументов
>>> f (6, 'бананы', 1.74, кумкваты)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    f (6, «бананы», 1,74, «кумкват»)
TypeError: f () принимает 3 позиционных аргумента, но было дано 4
  

  >>> f (кол-во = 6, товар = 'бананы', цена = 1,74)
6 бананов стоят 1,74 доллара
  

  >>> f (qty = 6, item = 'bananas', cost = 1.74)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: f () получил неожиданный аргумент ключевого слова 'стоимость'
  

  >>> f (item = 'bananas', price = 1.74, qty = 6)
6 бананов стоят 1 доллар.74
  

  >>> # Еще слишком мало аргументов
>>> f (кол-во = 6, элемент = 'бананы')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    f (кол-во = 6, элемент = 'бананы')
TypeError: f () отсутствует 1 обязательный позиционный аргумент: 'цена'
  

  >>> f (6, цена = 1.74, item = 'bananas')
6 бананов стоят 1,74 доллара

>>> f (6, 'бананы', цена = 1,74)
6 бананов стоят 1,74 доллара
  

  >>> f (6, item = 'bananas', 1.74)
SyntaxError: позиционный аргумент следует за аргументом ключевого слова
  

  >>> def f (qty = 6, item = 'bananas', price = 1.74):
... print (f '{qty} {item} cost $ {price :.2f} ')
...
  

  >>> f (4, 'яблоки', 2.24)
4 яблока стоят 2,24 доллара.
>>> f (4, 'яблоки')
4 яблока стоят 1,74 доллара

>>> f (4)
4 банана стоят 1,74 доллара
>>> f ()
6 бананов стоят 1,74 доллара

>>> f (item = 'кумкват', кол-во = 9)
9 кумкватов стоят 1,74 доллара
>>> f (цена = 2,29)
6 бананов стоят 2,29 доллара
  

  >>> def f (my_list = []):
... my_list.append ('###')
... вернуть my_list
...
  

  >>> f (['foo', 'bar', 'baz'])
['foo', 'bar', 'baz', '###']

>>> f ([1, 2, 3, 4, 5])
[1, 2, 3, 4, 5, '###']
  

  >>> f ()
['###', '###']
>>> f ()
['###', '###', '###']