Замена коллектора на генераторе: Как поменять токосъемные кольца на роторе генератора

Марка	Walfront
Материал	Пластик
Размеры изделия ДхШхВ	3. 15 x 2,76 x 2,36 дюйма
Материал ручки	Пластик, металл
Вес изделия	0,08 Килограмм

• Убедитесь, что он подходит, введя номер своей модели.
• — Контактное кольцо капсулы является стандартным серийным продуктом серийного производства, в котором используются золотые контакты на вращающемся интерфейсе.Подводящие провода с цветовой кодировкой используются как на статоре, так и на роторе для упрощения электрических соединений.
• — Антивибрационная и пыленепроницаемая конструкция с хорошими характеристиками может удовлетворить ваши основные рабочие потребности
• — Многоканальная передача сигнала, защита от помех
• — Устойчивость к низким температурам, широкий диапазон рабочих температур, возможность адаптации к большему разница температур в рабочей среде
• — Напряжение: 0-600В; Рабочая скорость: 150 об / мин; Рабочая температура: -30 ℃ ~ 80 ℃; Относительная влажность при эксплуатации: 0-85%

Горизонтальные вызовы — Nuclear Engineering International

Парогенераторы, применяемые на реакторах ВВЭР, имеют ряд преимуществ перед другими типами парогенераторов. Трунов Н., Денисов В., Драгунов Ю.

Конструкция горизонтального парогенератора (ПГ) ВВЭР основана на геометрии, отличной от используемой на Западе, а материал трубы — нержавеющая сталь марки 08Х28Н10Т. Преимущества этой конструкции:

• Большой запас воды и плавное поведение при переходных процессах.

• Эффективное удаление неконденсирующихся газов при авариях для обеспечения естественной циркуляции.

• Поверхность парогенератора находится под умеренной нагрузкой и имеет простую схему разделения.

• Низкие скорости на вторичной стороне уменьшают повреждения от вибрации и ударов посторонних предметов.

• Имеется хороший доступ к трубке как с первичной, так и со вторичной стороны.

• Есть место, где может скапливаться ил.

• Горизонтальная труба устойчива к разрушению.

• Ступенчатое испарение эффективно для удаления примесей.

• Трубки редко разрываются, так как обладают высокой несущей способностью.

На сегодняшний день дольше всего эксплуатируются ПГ на Нововоронежской 3, пущенной в 1971 году.

Парогенераторы, основанные на этой философии, используются на ВВЭР-440 (ПГВ-440, иногда обозначаются как ПГВ-4 или ПГВ-213) и ВВЭР-1000 (ПГВ-1000). Было сделано несколько обновлений, но изменения были разными для каждого блока, и процесс обновления все еще продолжается. В таблице на стр. 16 приведены основные технические данные ПГ на каждом реакторе.

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

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

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

Разделительные устройства выполнены в виде решетчатых решеток, слегка наклоненных от горизонтали. В оригинальной конструкции устройств для балансировки паровой нагрузки нет.Позднее парогенераторы (на Ровно 1 и 2) были оснащены местными перфорированными листами в области горячего коллектора, в результате чего было меньше набухание в зоне максимальной паровой нагрузки и отсутствие затопления сепаратора. Фланцевое соединение, которое может подвергнуться коррозии от загрязнений, также защищено от влаги. Подобные листы использовались и в Дукованах.

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

• На Ровно 1 и 2 модифицированный коллектор питательной воды находится над пучком труб, и питательная вода распределяется, в основном, в сторону емкости. Распределительные форсунки расположены неравномерно, распределяя питательную воду с соблюдением профиля выпуска пара.

• В Ловиизе коллектор питательной воды имеет J-образные распределительные форсунки. Их цель — предотвратить расслоение потока питательной воды (приводящее к гидроударам), когда вода с температурой 20 ° C попадает в главный коллектор питательной воды из аварийных резервных резервуаров с водой, которые являются особенностью установки.

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

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

Большой запас прочности конструкции позволил модернизировать электростанцию ​​- например, в Ловиисе 9% -ная модернизация увеличила тепловую нагрузку каждого генератора до 250 МВт.

Основные конструктивные различия между PGV-440 и PGV-1000 — и его модификациями, PGV-1000M и PGV-1000M + — связаны с большей удельной тепловой нагрузкой и жесткими требованиями к габаритным размерам (из-за транспортных ограничений).В ПГВ-1000 для коллекторов использовалась перлитная сталь (вместо низкопрочной аустенитной стали) и схема разделения с уравновешиванием паровой нагрузки с помощью погружной перфорированной пластины (СПП).

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

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

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

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

Конструктивные изменения были направлены на повышение надежности работы коллектора теплоносителя после выявления случаев их повреждения.

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

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

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

Новые разработки

Наряду с семейством PGV-440 и PGV-1000, конструкции SG находятся на разных стадиях разработки. Например, ПГВ-640 предназначен для промежуточного энергоблока.

Следующая ступень в горизонтальной ПГ — модификация ПГВ-1000 с увеличенным диаметром корпуса. ПГВ-1000 был рассчитан на транспортировку железнодорожным транспортом, поэтому требовался шахматный пучок труб. Увеличение диаметра емкости до 4200 мм позволит использовать вместо нее коридорный пучок труб. Тепловые и гидравлические характеристики не изменились, поэтому ПГ большей мощности можно использовать на ВВЭР-1000 без модификации установки. Оптимизация расположения трубок увеличит объем пучка на 20% и даст другие преимущества:

• Улучшенная циркуляция в пучке труб.

• Уменьшение скопления шлама в НКТ.

• Улучшенные условия для химической и механической очистки, а также для визуального контроля.

Это повысит надежность эксплуатации НКТ и даст возможность оправдать срок службы ПГ 50 и более лет. Потребуются новые транспортные средства.

При проектировании ВВЭР-1500 были предусмотрены горизонтальные ПГ, расчетный срок службы которых составляет 50 лет. Основные конструктивные особенности аналогичны действующим ПГ, но конструкция и трубопроводы оптимизированы на основе экспериментальных и теоретических исследований с учетом доступного пространства защитной оболочки.Преимущества новой конструкции:

• Повышенная надежность НКТ и улучшенная циркуляция.

• Упрощенная очистка и удаление шлама.

• Улучшенный доступ со стороны вторичной стороны для проверки НКТ.

• Лучшие условия для вихретокового контроля (увеличенный радиус изгиба трубы).

Опыт эксплуатации

Работа коллектора теплоносителя ПГВ-1000

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

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

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

С 1991 года ни одна ПГ не заменялась из-за растрескивания коллектора, хотя они проработали до 120 000 часов (Калинин 1).

Исправность трубок

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

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

На установках, где поддерживается качество водно-химического режима и проводится регулярная химическая очистка, повреждение трубок минимально. Например, на Хмельницком 1 химическая очистка проводится ежегодно на одной или нескольких ПГ во время расхолаживания.Только 10 труб были закупорены из-за коррозии с 1988 года.

Трубки ПГ ВВЭР в настоящее время закупориваются со скоростью 0,096% в год, по сравнению с 0,6%, ремонтируемыми ежегодно для вертикальных ПГ.

Растрескивание коллектора ПГВ-440

С 1975 года возникли проблемы с растрескиванием в зоне сварного шва коллектора, расположенной под защитным кожухом из стали 08Х28Н10Т. На Нововоронежской 3, Грайфсвальде и Козлодуе в металле коллектора были обнаружены трещины, возникающие со стороны вторичного контура, глубиной от 28 мм до сквозных трещин.Установлено, что повреждение возникло в результате коррозионного растрескивания хлоридов со стороны вторичного контура. Это было вызвано ненадлежащей проверкой герметичности под кожухом, позволяющей воде проникать. Проблема была решена после заполнения герметичного пространства корпусов азотом и контроля давления.

При эксплуатации ПГВ-440 произошло коррозионное растрескивание шпилек и отверстий под шпильки в верхней части коллекторов первичной стороны. Для разных энергоблоков характер и места образования трещин несколько различались.

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

• Высокие эксплуатационные напряжения.

• Коррозионное воздействие смазки шпилек на основе дисульфида молибдена.

• Воздействие щелочной среды из-за утечки с первичной стороны через обе прокладки фланцевого соединения.

• Влияние воды на стороне второго контура в нерасчетных условиях (попадание воды на фланцевое соединение из водного пространства ПГ).

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

• Улучшение процедуры затяжки шпилек без превышения расчетных напряжений.

• Изменение типа смазки для шпилек.

• Модернизация шпилек и компонентов фланцевых соединений.

• Использование прокладок из вспененного графита вместо прокладок из никеля для уменьшения усилия затяжки шпильки.

С 1993 года трещин на шпильках и деталях фланцевых соединений не зафиксировано. С 1999 года прокладки из вспененного графита использовались на нескольких заводах, что позволило снизить усилие шпилек в 1,5 раза.

Коррозия коллектора питательной воды

В процессе эксплуатации на ряде ВВЭР-440 и ВВЭР-1000 наблюдался коррозионно-эрозионный износ коллекторов питательной воды, изготовленных из углеродистой стали.На ряде агрегатов выявлен сквозной износ коллекторов.

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

Проблема решается заменой коллекторов на новые из нержавеющей стали. Это было выполнено на большинстве ВВЭР-1000 и на ряде ВВЭР-440.

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

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

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

• Температурные поля как в пространстве вторичной стороны, так и в коллекторах первичной стороны.

• Колебания трубного пучка и коллекторов теплоносителя.

• Распределение примесей в водном пространстве и эффективность продувки.

• Характеристики разделения по измерению влажности пара в паровом пространстве ПГ.

• Граница фактического уровня и его поведение по периметру ПГ, в том числе при переходных процессах.

• Циркуляционные характеристики.

• Значения среднего и местного качества пара.

• Гидродинамические условия над и под погруженным перфорированным листом, включая степень перфорации.

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

Результаты исследований и опыт эксплуатации являются богатым материалом как для разработки горизонтальных ПГ следующего поколения, так и для всех ПГ АЭС.

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

Solar Thermal Electricity — обзор

15.2 Жидкие теплоносители

Наиболее распространенными теплоносителями являются вода (под давлением), пар (насыщенный и перегретый) и термомасла. Появляются новые жидкости, такие как расплавленные соли, воздух и CO ₂ .

Обычные LFR были предложены [1–3] для производства воды или насыщенного пара для рабочих температур до 270 ° C.Они обычно связаны с циклом Ренкина для производства электроэнергии [1,3] или с прямым тепловым применением, таким как технологическое тепло, кондиционирование / охлаждение и опреснение, как в случае [2].

ПТ также использовались для всех этих приложений. В случае производства электроэнергии наиболее распространенными HTF являются термомасла, доставляющие энергию при температуре до 390 ° C, что обеспечивает гораздо более высокую эффективность преобразования солнечной энергии в электрическую [4]. В районах южной части Пиренейского полуострова годовая эффективность преобразования этих систем может составлять около 15%, в то время как упомянутые выше LFR могут иметь около 8–9%.

Термомасло в качестве HTF обычно требует теплообменника, как в применениях солнечно-термического электричества (STE) для производства пара для цикла Ренкина (паровая турбина).

На рис. 15.1 показана типичная конфигурация всей системы.

Рисунок 15.1. Схема обычной солнечно-тепловой электростанции с накопителем.

На этом рисунке также показана другая характеристика [5] многих существующих солнечных электростанций для STE: накопитель тепловой энергии (в данном случае с расплавленными солями в конфигурации с двумя резервуарами), подключенный к контуру термомасляного масла с помощью теплообменник.Накопление энергии — это очень желательная функция, которая полностью отличает STE от производства электроэнергии PV. Таким образом можно обеспечить многочасовое хранение, что позволяет обеспечить номинальную выработку электроэнергии в течение многих часов по запросу, даже при отсутствии солнечного света: таким образом, STE считается действительно управляемым.

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

Следовательно, почему бы не использовать расплавленные соли непосредственно в качестве HTF и как средство для хранения энергии, преобразовав схему на рис. 15.1 в схему на рис. 15.2?

Рисунок 15.2. Солнечная система, работающая с расплавом солей в качестве HTF и в качестве теплоносителя.

Именно это и делается на заводе центрального ресивера Торрессол / Гемасолар [7], как показано на рис. 15.3.

Рисунок 15.3. Установка Gemasolar: 19 МВт, 15 часов хранения (Севилья, Испания), с рабочими температурами до 565 ° C в приемном контуре расплавленной соли (540 ° C / 110 бар для производимого пара). Источник: SENER / Torresol Energy.

Возникает вопрос: можно ли это сделать с помощью технологии линейных концентраторов — PT и LFR?

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

Прежде чем идти дальше, уместно остановиться на других HTF, в частности, о таких газах, как воздух. Использование газов потенциально очень интересно, но создает дополнительную проблему, заключающуюся в существенно меньшем коэффициенте теплопередачи внутри ресивера, требующем более высоких давлений (как и в случае CO ₂ ) и более высоких температур. проявляться только при гораздо более высоких температурах (например, от 600 ° C и выше). Это, вероятно, означает, что они лучше подходят для комбинации с оптикой типа центрального приемника (трехмерной, трехмерной) из-за ее способности обеспечивать значительно более высокие значения концентрации.Сегодня они составляют предмет исследований и разработок в связи с подходящими циклами термодинамического преобразования Брайтона, а также в поисках решений по проблеме подходящего совместимого накопителя энергии.

Следовательно, они не будут более подробно рассматриваться в этой главе, посвященной линейной (двумерной, 2D) технологии, а именно усовершенствованной технологии LFR.

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

Автор

Кухлинг А.М.

Выпуск

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 , но трудно избежать всех побочные эффекты, такие как печать на экране или запись в файл на диске.Другой пример — вызов функции 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)
>>> это
<...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 # Пропустить этот элемент

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

Это означает, что при наличии нескольких для ... в статьях , но нет для предложений, длина результирующего вывода будет равна произведению длины всех последовательностей. Если у вас есть два списка длиной 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 , аналогично выражению возвратит заявление . Большая разница между доходностью и доходностью утверждение состоит в том, что при достижении выхода состояние выполнения генератора равно приостановленные и локальные переменные сохраняются. При следующем звонке в генератор __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 = (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 в ['предложение', 'фрагмент']]
['ЧАСТЬ ПРЕДЛОЖЕНИЯ']
 

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

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

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

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

 import functools

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

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

функций.уменьшить (func, iter, [начальное_значение]) кумулятивно выполняет операцию над всеми элементами итерации и, следовательно, не может применяться к бесконечным итерациям. func должна быть функцией который принимает два элемента и возвращает одно значение. functools.reduce () берет первые два элемента A и B, возвращенные итератором, и вычисляет func (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
 

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

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

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

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

 def adder (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.

Произошла ошибка при установке пользовательского файла cookie

Этот сайт использует файлы cookie для повышения производительности. Если ваш браузер не принимает файлы cookie, вы не можете просматривать этот сайт.

Настройка вашего браузера для приема файлов cookie

Существует множество причин, по которым cookie не может быть установлен правильно.Ниже приведены наиболее частые причины:

• В вашем браузере отключены файлы cookie. Вам необходимо сбросить настройки своего браузера, чтобы он принимал файлы cookie, или чтобы спросить вас, хотите ли вы принимать файлы cookie.
• Ваш браузер спрашивает вас, хотите ли вы принимать файлы cookie, и вы отказались. Чтобы принять файлы cookie с этого сайта, нажмите кнопку «Назад» и примите файлы cookie.
• Ваш браузер не поддерживает файлы cookie. Если вы подозреваете это, попробуйте другой браузер.
• Дата на вашем компьютере в прошлом.Если часы вашего компьютера показывают дату до 1 января 1970 г., браузер автоматически забудет файл cookie. Чтобы исправить это, установите правильное время и дату на своем компьютере.
• Вы установили приложение, которое отслеживает или блокирует установку файлов cookie. Вы должны отключить приложение при входе в систему или проконсультироваться с системным администратором.

Почему этому сайту требуются файлы cookie?

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

Что сохраняется в файле cookie?

Этот сайт не хранит ничего, кроме автоматически сгенерированного идентификатора сеанса в cookie; никакая другая информация не фиксируется.

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