[править] Шаблон класса std :: bit_not

 namespace std {
  template  struct bit_not {
    constexpr T оператор () (const T & x) const;
  };

  шаблон <> struct bit_not  {
    шаблон <класс T> constexpr auto operator () (T && t) const
      -> decltype (~ std :: forward  (t));

    using is_transparent = / * не указано * /;
  };
} 

[править] Шаблон класса std :: identity

 namespace std {
  struct identity {
    шаблон <класс T>
      constexpr T && оператор () (T && t) const noexcept;

    using is_transparent = / * не указано * /;
  };
} 

[править] Шаблон класса std :: is_bind_expression

 namespace std {
  шаблон <класс T> struct is_bind_expression;
} 

[править] Шаблон класса std :: is_placeholder

 namespace std {
  шаблон <класс T> struct is_placeholder;
} 

[править] Класс std :: bad_function_call

 namespace std {
  class bad_function_call: общедоступное исключение {
  общественность:
    // см. [исключение] для спецификации специальных функций-членов
    const char * what () const noexcept override;
  };
} 

[править] Класс std :: function

 namespace std {
  шаблон <класс> функция класса; // не определен

  шаблон <класс R, класс... ArgTypes>
  class function  {
  общественность:
    используя result_type = R;

    // построить / скопировать / уничтожить
    function () noexcept;
    функция (nullptr_t) noexcept;
    функция (константная функция &);
    функция (функция &&) noexcept;
    шаблон <класс F> функция (F);

    функция & оператор = (константная функция &);
    функция & оператор = (функция &&);
    функция & оператор = (nullptr_t) noexcept;
    шаблон <класс F> функция & оператор = (F &&);
    шаблон <класс F> function & operator = (reference_wrapper ) noexcept;

    ~ функция ();

    // модификаторы функции
    недействительный своп (функция &) noexcept;

    // емкость функции
    явный оператор bool () const noexcept;

    // вызов функции
    Оператор R () (Типы аргументов...) const;

    // доступ к цели функции
    const type_info & target_type () const noexcept;
    template  T * target () noexcept;
    шаблон <класс T> const T * target () const noexcept;
  };

  шаблон <класс R, класс ... ArgTypes>
    function (R (*) (ArgTypes ...)) -> function ;

  шаблон <класс F> функция (F) -> функция ;

  // функции сравнения нулевого указателя
  шаблон <класс R, класс ... ArgTypes>
    bool operator == (const function  &, nullptr_t) noexcept;

  // специализированные алгоритмы
  шаблон <класс R, класс ... ArgTypes>
    void swap (function  &, function  &) noexcept;
} 

[править] Шаблон класса std :: default_searcher

 namespace std {
  шаблон <класс ForwardIter1, класс BinaryPredicate = equal_to <>>
    class default_searcher {
    общественность:
      constexpr default_searcher (ForwardIter1 pat_first, ForwardIter1 pat_last,
                                 BinaryPredicate pred = BinaryPredicate ());

      шаблон <класс ForwardIter2>
        constexpr пара 
          operator () (сначала ForwardIter2, затем ForwardIter2) const;

    частный:
      ForwardIter1 pat_first_; // только экспозиция
      ForwardIter1 pat_last_; // только экспозиция
      BinaryPredicate pred_; // только экспозиция
  };
} 

[править] Шаблон класса std :: boyer_moore_searcher

 namespace std {
  шаблон <класс RandomAccessIter1,
           class Hash = hash  :: value_type>,
           класс BinaryPredicate = equal_to <>>
    class boyer_moore_searcher {
    общественность:
      boyer_moore_searcher (RandomAccessIter1 pat_first,
                           RandomAccessIter1 pat_last,
                           Хэш hf = Хеш (),
                           BinaryPredicate pred = BinaryPredicate ());

      шаблон <класс RandomAccessIter2>
        пара 
          operator () (сначала RandomAccessIter2, затем RandomAccessIter2) const;

    частный:
      RandomAccessIter1 pat_first_; // только экспозиция
      RandomAccessIter1 pat_last_; // только экспозиция
      Хэш hash_; // только экспозиция
      BinaryPredicate pred_; // только экспозиция
    };
} 

[править] Шаблон класса std :: boyer_moore_horspool_searcher

 namespace std {
  шаблон <класс RandomAccessIter1,
           class Hash = hash  :: value_type>,
           класс BinaryPredicate = equal_to <>>
    class boyer_moore_horspool_searcher {
    общественность:
      boyer_moore_horspool_searcher (RandomAccessIter1 pat_first,
                                    RandomAccessIter1 pat_last,
                                    Хэш hf = Хэш (),
                                    BinaryPredicate pred = BinaryPredicate ());

      шаблон <класс RandomAccessIter2>
        пара 
          operator () (сначала RandomAccessIter2, затем RandomAccessIter2) const;

    частный:
      RandomAccessIter1 pat_first_; // только экспозиция
      RandomAccessIter1 pat_last_; // только экспозиция
      Хэш hash_; // только экспозиция
      BinaryPredicate pred_; // только экспозиция
  };
} 

[править] См. Также

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

Автор

А. М. Кучлинг

Выпуск

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 () или раз.обе функции sleep () не возвращают полезного значения; они нужны только для их побочные эффекты: отправка текста на экран или приостановка выполнения на второй.

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

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

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

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

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

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

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

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

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

Модульность

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

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

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

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

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

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

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

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

Итераторы

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

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

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

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

 >>> L = [1, 2, 3]
>>> it = iter (L)
>>> это
<...iterator объект в ...>
>>> 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 , sequence2 зацикливается с начала. sequence3 затем зацикливается 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.Когда вы вызываете функцию, она получает частное пространство имен, в котором ее локальные переменные созданы. Когда функция достигает оператора return , локальный переменные уничтожаются, а значение возвращается вызывающей стороне. Позже звонок к той же функции создает новое частное пространство имен и свежий набор локальных переменные. Но что, если бы локальные переменные не были выброшены при выходе из функция? Что, если бы вы могли позже возобновить функцию с того места, где она была остановлена? Этот это то, что предоставляют генераторы; их можно рассматривать как возобновляемые функции.

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

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

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

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

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

 (максимум):
    я = 0
    пока я <максимум:
        val = (yield 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 в ['предложение', 'фрагмент']]
['ФРАГМЕНТ ПРЕДЛОЖЕНИЯ']
 

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

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

 >>> 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]
 

(Более подробное обсуждение сортировки см. В документе Sorting HOW TO.)

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

 >>> любое ([0, 1, 0])
Истинный
>>> любой ([0, 0, 0])
Ложь
>>> любой ([1, 1, 1])
Истинный
>>> все ([0, 1, 0])
Ложь
>>> все ([0, 0, 0])
Ложь
>>> все ([1, 1, 1])
Истинный
 

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

 почтовый индекс (['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’ струны пришли с разных позиций.

The itertools.combinations_with_replacement (iterable, 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 () принимает аргументы (функция, arg1, arg2,..., kwarg1 = значение1, kwarg2 = значение2) . Результирующий объект является вызываемым, поэтому вы можете просто вызвать его, чтобы вызвать функцию с заполненные аргументы.

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

 импортных функций

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 () , но может быть проще просто напишите очевидное для цикла :

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

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

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

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

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

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

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

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

 импортных функций
total = functools.reduce (лямбда a, b: (0, a [1] + b [1]), items) [1]
 

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

 импортных функций
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.

Функциональное недержание мочи: симптомы, причины, лечение

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

Причины и симптомы функционального недержания мочи

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

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

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

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

Диагностика и лечение функционального недержания

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

Лечение также требует учета факторов окружающей среды для улучшения доступности.

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

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

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

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

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

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

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

Функциональный фитнес-тренинг: подходит ли он вам?

Функциональный фитнес-тренинг: подходит ли он вам?

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

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

Что такое функциональная фитнес-тренировка?

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

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

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

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

Каковы преимущества функциональной фитнес-тренировки?

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

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

Какие есть примеры функциональных фитнес-упражнений?

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

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

• Разнонаправленные выпады
• Постоянный ряд
• Приседания

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

Подойдут ли функциональные фитнес-упражнения каждому?

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

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

Вознаграждение за функциональную пригодность

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

1. Feito Y, et al. Функциональная тренировка высокой интенсивности (HIFT): определение и результаты исследований для улучшения физической формы. Виды спорта. 2018; 6: E76.
2. Cortell-Tormo J, et al. Влияние тренировок с функциональным сопротивлением на физическую форму и качество жизни у женщин с хронической неспецифической болью в пояснице. Журнал реабилитации спины и опорно-двигательного аппарата. 2018; 31: 95.
3. Фальк Нето JH, et al.Мультимодальный характер высокоинтенсивных функциональных тренировок: возможности применения для улучшения спортивных результатов. Виды спорта. 2019; 7: E33.
4. Haddock CK, et al. Преимущества высокоинтенсивных программ функциональной подготовки военнослужащих. Военная медицина. 2016; 181: e1508.
5. Ofei-Dodoo S, et al. Влияние активного образа жизни на уровень функциональной подготовленности пожилых женщин. Журнал прикладной геронтологии. 2018; 37: 687.
6. Peterson JA. Десять важных фактов о функциональной тренировке.Журнал здоровья и фитнеса ACSM. 2017; 21: 52.
7. Gothe NP, et al. Йога так же хороша, как и упражнения на растяжку в улучшении функциональной пригодности: результаты рандомизированного контролируемого исследования. Журналы геронтологии: медицинские науки. 2016; 71: 406.
8. Рекомендации по физической активности для американцев. 2-е изд. Министерство здравоохранения и социальных служб США. https://health.gov/paguidelines/second-edition. По состоянию на 8 мая 2019 г.
9. Ласковский Е.Р. (заключение эксперта).Клиника Мэйо, Рочестер, Миннесота, 23 мая 2019 г.