Если с механикой порядок, проверяют электрические характеристики. Для этого потребуется прибор, способный точно измерить постоянное напряжение величиной 12 – 16 В. Причем шкала (или цифровой индикатор) на этом пределе измерения должна показывать значения с десятыми долями, иначе замеры бессмысленны. Годится и стрелочный тестер, и мультиметр.

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

Измерительные щупы лучше зафиксировать на клеммах. Можно воспользоваться услугами помощника, но использовать зажимы типа «крокодил» удобнее. Главное требование – чтобы при старте мотора (он при этом дергается) зажимы не отключились самопроизвольно.

До запуска двигателя фиксируем напряжение аккумулятора. Оно должно быть в пределах 12,5 – 12,7 В, в зависимости от степени его зарядки, а вся нагрузка при этом отключается. Не забудьте, что при открытии дверей в салоне зажигается свет, а это – хоть небольшая, но нагрузка. Если напряжение ниже 12 В, то лучше перед тестом зарядить аккумулятор. Исправный регулятор сильно задерет напряжение, пытаясь исправить ситуацию и поскорее зарядить аккумулятор. А вы сделаете из этого неверные выводы о его неисправности.

Теперь запускаем двигатель, прогреваем его, чтобы число оборотов в минуту равнялось оборотам холостого хода для вашей модели (обычно – в пределах 800). Контролируем напряжение на батарее, можно начать поглядывать на шкалу прибора еще в процессе прогрева. Измеренная величина должна лежать в пределах от 13,5 до 14 В. И так – на всех режимах работы.

Если на холостых оборотах напряжение ниже 13,0 В, то проблемы могут быть следующими:

Неисправности, связанные с нарушением контактов

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

Контактные соединения, которые стоит проверить в случае низкого напряжения заряда:

• Плюсовой вывод: от батареи до генератора;
• Минусовой вывод: от батареи до корпуса автомобиля; от корпуса автомобиля – до корпуса двигателя.

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

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

Неисправности аккумулятора

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

Если при работе генератора напряжение на аккумуляторе больше 14 В, то либо он сильно разряжен, либо неисправен регулятор напряжения.

Диагностика работы регулятора напряжения

Задача регулятора напряжения – поддержание напряжения на батарее в диапазоне от 13,5 до 14 В на всех режимах работы двигателя и при любой нагрузке. Критерии его работоспособности:

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

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

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

Проверка щеток генератора

Для подробного обследования генератора его снимают с автомобиля. Затем очищают его от загрязнений. Снимают щеточный аппарат, при необходимости – регулятор напряжения. Щетки должны быть изношены равномерно (длина их – одинакова, а выработка от колец ротора – симметрична относительно продольной оси). Остаточная длина щеток должна быть больше 4,5 мм (нормой считается 8-10 мм). Если эти параметры не соблюдены – щетки меняют, даже если неисправность кроется не в них.

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

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

Проверка выпрямителя

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

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

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

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

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

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

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

А вот замыкания на корпус случаются чаще. Для их выявления измеряют сопротивление между любым выводом обмотки и корпусом. Используют самый большой предел мультиметра для измерения сопротивления. Лучше использовать специальный прибор – мегаомметр, но только при условии, что выдаваемое им напряжение не будет превышать 100 В. Рабочее напряжение генератора – 12-16 В, использование для проверки мегаомметров на большее напряжение приведет к повреждению изоляции.

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

Диагностика ротора генератора

При осмотре ротора обращают внимание на:

• выработку на контактных кольцах: не должно быть борозд, образовавшихся под щетками;
• цвет обмотки: однородный, отличный от черного (черный цвет – обмотка сгорела).

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

Для диагностики обмотки ротора измеряют ее сопротивление мультиметром или тестером. У разных моделей генераторов эта величина колеблется от 2,3 до 5,1 Ома.

Подшипники генератора

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

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

Оцените качество статьи:

Есть ли функция Python, которая проверяет, запущен ли генератор?

спросил 9 лет, 6 месяцев назад

Изменено 5 лет, 3 месяца назад

Просмотрено 2к раз

Я пытаюсь определить функцию генератора mycount() , которую можно сбросить с помощью функции генератора отправить(0) как в примере ниже. Все работает нормально, за исключением случаев, когда я использую send(0) для нового объекта-генератора, который еще не запущен. В этом случае он дает TypeError . Есть ли какая-либо функция, которая проверяет, запущен ли генератор, или мне нужно поймать TypeError и создать новый объект генератора с mycount(0) в таком случае?

 по определению мой счет (значение):
    пока верно:
        v = доходность
        если v == Нет:
            значение = значение + 1
        еще:
            значение = v
г = мой счет (3)
print(следующий(г)) # печатает 3
print(следующий(g)) # печатает 4
print(g. send(0)) # печатает 0
print(следующий(g)) # печатает 1
print(следующий(g)) # печатает 2
g2 = мой счет (3)
g2.отправить(0)
# TypeError: невозможно отправить значение, отличное от None, в только что запущенный генератор
 

• питон
• генератор

0

Чтобы избежать отправки значения, отличного от None , в только что запущенный генератор, сначала необходимо вызвать next или send(None) . Я согласен с другими, что декоратор сопрограммы Дэвида Бизли (в python 3.x вам нужно вызывать функцию __next__() вместо next() ) является отличным вариантом. Хотя этот конкретный декоратор прост, я также успешно использовал библиотеку copypes, которая является хорошей реализацией многих утилит из презентаций Бизли, включая сопрограмму.

Что касается того, можно ли проверить, запущен ли генератор — в Python 3 вы можете использовать inspect. getgeneratorstate. Это недоступно в Python 2, но реализация CPython — это чистый Python и не полагается ни на что новое для Python 3, поэтому вы можете проверить себя таким же образом:

, если генератор.gi_running:
    вернуть GEN_RUNNING
если генератор.gi_frame равен None:
    вернуть GEN_CLOSED
если генератор.gi_frame.f_lasti == -1:
    вернуть GEN_CREATED
вернуть GEN_SUSPENDED
 

В частности, g2 запускается, если inspect.getgeneratorstate(g2) != inspect.GEN_CREATED .

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

Вы могли бы поймать TypeError и свернуть оттуда:

 #...
    пытаться:
        g2.отправить(0)
    кроме TypeError:
        #Теперь вы знаете, что это не началось и т. д.
        g2.send(Нет)
 

В любом случае его нельзя использовать для «сброса» генератора, его нужно просто переделать.

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

В частности, вы можете найти способ использовать декоратор Consumer , описанный на стр. I-131 «Generator Tricks» Дэвида Бизли, на которую Дж. Гвин предоставил ссылку:

 def Consumer(func):
    старт защиты (* аргументы, ** kwargs):
        c = func(*args,**kwargs)
        c.следующий()
        вернуться с
    обратный старт
 

Я использую нечто подобное в своем коде.

Обратите внимание, что , если v равно None предпочтительнее , если v == None .

2

Вот полная реализация подпрограммы, совместимой с Python2, getgeneratorstate(gtor) с тестовым кодом.

 импорт юниттест
импортировать перечисление
класс GtorState (enum.Enum):
    GEN_RUNNING = 'GEN_RUNNING'
    GEN_CLOSED = 'GEN_CLOSED'
    GEN_CREATED = 'GEN_CREATED'
    GEN_SUSPENDED = 'GEN_SUSPENDED'
    @статический метод
    def getgeneratorstate (gtor):
        если gtor. gi_running:
            вернуть GtorState.GEN_RUNNING
        если gtor.gi_frame равен None:
            вернуть GtorState.GEN_CLOSED
        если gtor.gi_frame.f_lasti == -1:
            вернуть GtorState.GEN_CREATED
        вернуть GtorState.GEN_SUSPENDED
    #end-def
определение coro000():
    """ сопрограмма, которая мало что делает
    """
    print('-> запущена сопрограмма')
    х = доходность
    print('-> получена сопрограмма ', x)
класс Test_Coro (unittest.TestCase):
    деф test_coro000 (я):
        my_coro000 =coro000()
        self.assertEqual(GtorState.getgeneratorstate(my_coro000), GtorState.GEN_CREATED)
        next(my_coro000) # печатает '-> сопрограмма запущена'
        self.assertEqual(GtorState.getgeneratorstate(my_coro000), GtorState.GEN_SUSPENDED)
        пытаться:
            my_coro000.send(42) # печатает '-> сопрограмма получила 42
            self.assertEqual(GtorState.getgeneratorstate(my_coro000), GtorState.GEN_SUSPENDED)
            self.fail('должен был вызвать StopIteration')
        кроме StopIteration:
            self. assertTrue(True, 'При выходе сопрограмма вызовет StopIteration')
            self.assertEqual(GtorState.getgeneratorstate(my_coro000), GtorState.GEN_CLOSED)
 

Зарегистрируйтесь или войдите в систему

Зарегистрируйтесь с помощью Google

Зарегистрироваться через Facebook

Зарегистрируйтесь, используя электронную почту и пароль

Опубликовать как гость

Электронная почта

Обязательно, но не отображается

Опубликовать как гость

Электронная почта

Требуется, но не отображается

python — Как узнать, пуст ли генератор с самого начала?

Задавать вопрос

спросил 13 лет, 10 месяцев назад

Изменено 3 месяца назад

Просмотрено 112 тысяч раз

Есть ли простой способ проверить, нет ли в генераторе элементов, например peek , hasNext , isEmpty , что-то в этом роде?

• питон
• генератор

6

Предложение:

 def peek(итерируемый):
    пытаться:
        первый = следующий (итерируемый)
    кроме StopIteration:
        возврат Нет
    вернуться первым, itertools. chain([first], iterable)
 

Использование:

 res = peek(mysequence)
если res равно None:
    # последовательность пуста. Делай вещи.
еще:
    во-первых, mysequence = res
    # Может быть, сделать что-нибудь с first?
    # Затем перебираем последовательность:
    для элемента в mysequence:
        # и т. д.
 

8

Простой ответ на ваш вопрос: нет, простого пути нет. Есть много обходных путей.

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

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

11

Простой способ — использовать необязательный параметр для next(), который используется, если генератор исчерпан (или пуст). Например:

 _exhausted = объект()
если next(some_generator, _exhausted) _exhausted:
    print('генератор пуст')
 

9

Быстрое решение:

next(генератор, None) не None

Или замените None любым значением, которое вы знаете, это не в вашем генераторе.

Редактировать : Да, это пропустит 1 элемент в генераторе. Однако иногда я проверяю, является ли генератор пустым, только для целей проверки, а затем не использую его на самом деле. Или иначе я делаю что-то вроде:

 def foo(self):
    если next(self.my_generator(), None) равно None:
        вызвать исключение ("Не инициировано")
    для x в self.my_generator():
        ...
 

То есть это работает, если ваш генератор исходит из функции , например my_generator() .

5

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

 thing_generated = False
# Здесь ничего не потеряно. если ничего не генерируется,
# блок for не выполняется. Часто это единственная проверка
# вам нужно сделать. Это можно сделать в ходе выполнения
# работа, которую вы все равно хотели выполнить в сгенерированном выводе.
для вещи в my_generator():
    вещь_генерированная = Истина
    делать_работу (вещь)
 

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

, если не thing_generated:
    print "Аваст, цинговая собака!"
 

4

Только что попал в эту тему и понял, что не хватает очень простого и легко читаемого ответа:

 def is_empty(generator):
    для элемента в генераторе:
        вернуть ложь
    вернуть Истина
 

Если мы не предполагаем потреблять какой-либо элемент, нам нужно повторно ввести первый элемент в генератор:

 def is_empty_no_side_effects(generator):
    пытаться:
        элемент = следующий (генератор)
        определить мой_генератор():
            элемент доходности
            выход из генератора
        вернуть my_generator(), Ложь
    кроме StopIteration:
        return (_ для _ в []), True
 

Пример:

 >>> g=(i вместо i в [])
>>> g,empty=is_empty_no_side_effects(g)
>>> пустой
Истинный
>>> g=(i для i в диапазоне (10))
>>> g,empty=is_empty_no_side_effects(g)
>>> пустой
ЛОЖЬ
>>> список(г)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 

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

 определение do_something_with_item(item):
    элемент печати
пустой_маркер = объект()
пытаться:
     первый_элемент = мой_генератор. следующий()
кроме StopIteration:
     print 'Генератор был пуст'
     first_item = пустой_маркер
если first_item не пустой_маркер:
    do_something_with_item(first_item)
    для элемента в my_generator:
        do_something_with_item (предмет)
 

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

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

 класс
    def __init__(я, итер):
        self.source = итер
        самосохраненный = []
    защита __iter__(я):
        вернуть себя
    защита __bool__(я):
        если self.stored:
            вернуть Истина
        пытаться:
            self.stored.append (следующий (self.source))
        кроме StopIteration:
            вернуть ложь
        вернуть Истина
    деф толчок (я, значение):
        self. stored.append (значение)
    заглянуть (сам):
        если self.stored:
            вернуть self.stored[-1]
        значение = следующее (self.source)
        self.stored.append (значение)
        возвращаемое значение
    деф __следующий__(сам):
        если self.stored:
            вернуть self.stored.pop()
        вернуть следующий (self.source)
 

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

Вот класс-оболочка, который можно добавить к существующему итератору, чтобы добавить тест __nonzero__ , чтобы вы могли видеть, пуст ли генератор, с помощью простого if . Вероятно, его также можно превратить в декоратор.

 класс GenWrapper:
    def __init__(я, итер):
        self.source = итер
        self.stored = Ложь
    защита __iter__(я):
        вернуть себя
    защита __nonzero__(я):
        если self. stored:
            вернуть Истина
        пытаться:
            self.value = следующий (self.source)
            самосохраненный = Истина
        кроме StopIteration:
            вернуть ложь
        вернуть Истина
    def __next__(self): # использовать «далее» (без подчеркивания) для Python 2.x
        если self.stored:
            self.stored = Ложь
            вернуть self.value
        вернуть следующий (self.source)
 

Вот как его использовать:

 с open(filename, 'r') как f:
    f = GenWrapper (f)
    если ф:
        напечатать «Не пусто»
    еще:
        напечатать «Пусто»
 

Обратите внимание, что вы можете проверить наличие пустот в любое время, а не только в начале итерации.

3

Я понимаю, что на данный момент этому сообщению уже 5 лет, но я нашел его, когда искал идиоматический способ сделать это, и не увидел опубликованного моего решения. Итак для потомков:

 импорт itertools
защита get_generator():
    """
    Возвращает (логическое значение, генератор), где логическое значение истинно, если и только если генератор не пуст. 
    """
    gen = (i для i в [0, 1, 2, 3, 4])
    а, б = itertools.tee(gen)
    пытаться:
        а.следующий()
    кроме StopIteration:
        возврат (ложь, б)
    возврат (Правда, б)
 

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

2

Извините за очевидный подход, но лучше всего сделать:

 для элемента в my_generator:
     элемент печати
 

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

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

4

 >>> gen = (i вместо i в [])
>>> следующий(ген)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
    следующее поколение)
Остановить итерацию
 

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

еще одна вещь, которую вы можете сделать, это:

 >>> gen = (i вместо i в [])
>>> если не список(ген):
    print('пустой генератор')
 

3

Я нашел только это решение, которое работает и для пустых итераций.

 по определению is_generator_empty (генератор):
    a, b = itertools.tee (генератор)
    пытаться:
        следующий (а)
    кроме StopIteration:
        вернуть Истина, б
    вернуть ложь, б
is_empty, генератор = is_generator_empty (генератор)
 

Или, если вы не хотите использовать исключение для этого, попробуйте использовать

 определение is_generator_empty (генератор):
    a, b = itertools.tee (генератор)
    для элемента в:
        вернуть ложь, б
    вернуть Истина, б
is_empty, генератор = is_generator_empty (генератор)
 

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

 def get_empty_generator():
    в то время как Ложь:
        урожайность
генератор = get_empty_generator()
 

Если вам нужно узнать до того, как вы воспользуетесь генератором, то нет, простого способа нет. Если вы можете подождать до после вы использовали генератор, есть простой способ:

 was_empty = True
для some_item в some_generator:
    was_empty = Ложь
    сделать_что-то_с (какой-то_элемент)
если было_пусто:
    handle_already_empty_generator_case()
 

Просто оберните генератор с помощью itertools.chain, поместите что-то, что будет представлять конец итерации как вторую итерацию, а затем просто проверьте это.

Пример:

 импорт itertools
g = некоторый_итерируемый
эог = объект()
wrap_g = itertools.chain(g, [eog])
 

Теперь все, что осталось, это проверить значение, которое мы добавили в конец итерации, когда вы его прочитаете, это будет означать конец

 для значения в wrap_g:
    если значение == eog: # ДИН ДИН! Мы только что нашли последний элемент итерируемого
        передать # Сделать что-нибудь
 

2

В моем случае мне нужно было знать, было ли заполнено множество генераторов, прежде чем я передал их функции, которая объединила элементы, т. Е. индекс(...) . Решение похоже, но достаточно отличается от принятого ответа:

Определение:

 def has_items(iterable):
    пытаться:
        вернуть True, itertools.chain([следующий(итерируемый)], итерируемый)
    кроме StopIteration:
        вернуть ложь, []
 

Использование:

 def filter_empty (итерации):
    для итерируемых в итерируемых:
        itr_has_items, iterable = has_items(iterable)
        если itr_has_items:
            доходность итерируемая
def merge_iterables (итерируемые):
    populated_iterables = filter_empty (итерации)
    для элементов в zip(*populated_iterables):
        # Используйте предметы для каждого «среза»
 

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

Используйте функцию просмотра в Cytoolz.

 из импорта цитолз
от ввода import Tuple, Iterable
def is_empty_iterator(g: Iterable) -> Tuple[Iterable, bool]:
    пытаться:
        _, г = заглянуть (г)
        вернуть г, ложь
    кроме StopIteration:
        вернуть г, Истина
 

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

Просто чтобы попытаться помочь с моими «2 центами», я собираюсь описать свой опыт:

У меня есть генератор, который мне нужно разрезать с помощью itertools.islice на маленькие генераторы. Затем, чтобы проверить, пусты ли мои подгенераторы, я просто преобразовываю/использую их в небольшой список и проверяю, пуст этот список или нет.

Например:

 из itertools import islice
генератор защиты (max_yield = 10):
    а = 0
    пока верно:
        а += 1
        если a > max_yield:
            поднять StopIteration()
        дать
тг = генератор ()
метка = 1
пока верно:
    itg = список (islice (tg, 3))
    если не itg: # <-- проверяю, пустой список или нет
        перерыв
    для я в итг:
        печать (f'# {метка} - {я}')
    метка += 1
 

Вывод:

 #1 - 1
№ 1–2
№ 1–3
№ 2 - 4
# 2 - 5
# 2 - 6
№ 3 - 7
№ 3 - 8
№ 3 - 9
№ 4 - 10
 

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

Проверка генератора перед его итерацией соответствует стилю кодирования LBYL. Другой подход (EAFP) состоял бы в том, чтобы перебрать его, а затем проверить, был ли он пустым или нет.

 is_empty = Истина
для элемента в генераторе:
    is_empty = Ложь
    сделать_что-то (предмет)
если is_empty:
    print('Генератор пуст')
 

Этот подход также хорошо работает с бесконечными генераторами.

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

 деф генератор_или_нет (функция):
    """Обернуть функцию генератора, возвращая None, если она пуста."""
    def внутренний (*args, **kwargs):
        # просмотреть первый элемент; вернуть None, если он не существует
        пытаться:
            следующий (функция (* аргументы, ** kwargs))
        кроме StopIteration:
            возврат Нет
        # вернуть исходный генератор, иначе первый элемент будет отсутствовать
        функция возврата (*args, **kwargs)
    вернуться внутрь
 

Использование:

 случайный импорт
@generator_or_none
определение random_length_generator():
 для i в диапазоне (random.