Функция any() в python, хотя бы один элемент true

Что такое генератор и как он работает?

• Генератор — это объект, который сразу при создании не вычисляет значения всех своих элементов.
• Он хранит в памяти только последний вычисленный элемент, правило перехода к следующему и условие, при котором выполнение прерывается.
• Вычисление следующего значения происходит лишь при выполнении метода next(). Предыдущее значение при этом теряется.

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

Рассмотрим пример: создадим объект-генератор gen с помощью так называемого генераторного выражения. Он будет считать квадраты чисел от 1 до 4 — такую последовательность создаёт функция range(1,5).

Когда мы выведем на консоль переменную gen, то увидим лишь сообщение, что это объект-генератор.

При четырёх вызовах метода next(a) будут по одному рассчитываться и выводиться на консоль значения генератора: 1, 4, 9, 16. Причём в памяти будет сохраняться только последнее значение, а предыдущие сотрутся.

Когда мы попытаемся вызвать next(gen) в пятый раз, генератор сотрёт из памяти последний элемент (число 16) и выдаст исключение StopIteration.

Что лучше?

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

Краткое и последовательное использование отступов Python.
В языках программирования, которые не используют правило off‑side, отступ кода полностью не зависит от определения блока и функции кода. Можно написать код с отступом, который на самом деле не соответствует тому, как выполняется код, создавая тем самым ошибочное впечатление, когда человек просто смотрит на него. Такого рода ошибки практически невозможно сделать в Python.
Использование отступов для определения блоков заставляет Вас поддерживать стандарты форматирования кода, которые вы, вероятно, должны использовать в любом случае.

Недостатки:

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

Нравится вам это или нет, но если вы программируете на Python, вы застряли с правилом off‑side. Все структуры управления в Python используют его.

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

Условные операторы

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

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

<expr1> if <conditional_expr> else <expr2>

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

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

raining = False
print("Let's go to the", 'beach' if not raining else 'library')

raining = True
print("Let's go to the", 'beach' if not raining else 'library')


age = 12
s = 'minor' if age < 21 else 'adult'
s


'yes' if ('qux' in ) else 'no'

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

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

Вы можете использовать стандартный оператор с предложением :

if a > b:
    m = a
else:
    m = b

Но условный оператор короче и, возможно, более читабельнее:

m = a if a > b else b

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

В следующем примере оператор + связывается более плотно, чем условное выражение, поэтому сначала вычисляются +x и y + 2, а затем условное выражение. Скобки во втором случае не нужны и результат не меняется:

x = y = 40

z = 1 + x if x > y else y + 2
z


z = (1 + x) if x > y else (y + 2)
z

Если вы хотите, чтобы условное выражение было вычислено первым, вам нужно окружить его группирующими скобками. В следующем примере сначала вычисляется (x, если x > y, иначе y). В результате получается y, который равен 40, поэтому присваивается z 1 + 40 + 2 = 43:

x = y = 40

z = 1 + (x if x > y else y) + 2
z

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

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

В выражении , если иначе :

Если <conditional_expr> правда, <expr1> и <expr2> не вычисляется.
Если <conditional_expr> имеет значение false, то возвращается <expr2> и <expr1> не вычисляется.

Вы можете проверить это, используя термины, которые вызвали бы ошибку:

'foo' if True else 1/0

1/0 if False else 'bar'

В обоих случаях условия 1/0 не оцениваются, поэтому никаких исключений не возникнет.

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

s = ('foo' if (x == 1) else
     'bar' if (x == 2) else
     'baz' if (x == 3) else
     'qux' if (x == 4) else
     'quux'
)
s

Неясно, имеет ли это какое-либо существенное преимущество перед соответствующим оператором , но это синтаксически правильно для Python.

Операторы¶

Кратко рассмотрим операторы и их применение:

Обратите внимание, вычислить значения выражений, данных в примерах, можно также
используя интерпретатор интерактивно. Например, для проверки выражения
воспользуйтесь интерактивной командной строкой интерпретатора Python:

>>> 2 + 3
5
>>> 3 * 5
15

Операторы и их применение

Оператор
Название
Объяснение
Примеры

Сложение
Суммирует два
объекта

даст ;
даст

Вычитание
Даёт разность
двух чисел;
если первый
операнд
отсутствует,
он считается
равным нулю

даст отрицательное число,
а даст .

Умножение
Даёт
произведение
двух чисел или
возвращает
строку,
повторённую
заданное число
раз.

даст .
даст .

Возведение
в степень
Возвращает
число ,
возведённое в
степень

даст
(т.е. )
Деление
Возвращает
частное от
деления
на

даст .

Целочисленное
деление
Возвращает
неполное
частное от
деления

даст .
даст .

Деление по
модулю
Возвращает
остаток от
деления

даст .
даст .

Сдвиг влево
Сдвигает биты
числа влево на
заданное
количество
позиций. (Любое
число в памяти
компьютера
представлено в
виде битов —
или двоичных
чисел, т.е.
0 и 1)

даст .
В двоичном виде представляет
собой . Сдвиг влево на 2 бита
даёт , что в десятичном
виде означает .

Сдвиг вправо
Сдвигает биты
числа вправо на
заданное число
позиций.

даст .
В двоичном виде представляется
как , что будучи смещённым на
1 бит вправо, даёт , а это, в
свою очередь, не что иное как
десятичное

Побитовое И
Побитовая
операция И над
числами

даёт .

Побитовое ИЛИ
Побитовая
операция ИЛИ
над числами

даёт

Побитовое
ИСКЛЮЧИТЕЛЬНО
ИЛИ
Побитовая
операция
ИСКЛЮЧИТЕЛЬНО
ИЛИ

даёт

Побитовое НЕ

Побитовая
операция НЕ для
числа
соответствует

даёт .

Меньше
Определяет,
верно ли, что
меньше

Все
операторы
сравнения
возвращают
или
.
Обратите
внимание на
заглавные буквы
в этих словах.

даст ,
а даст .
Можно составлять произвольные цепочки
сравнений: даёт .

Больше

Определяет,
верно ли, что
больше

даёт .
Если оба операнда — числа, то перед
сравнением они оба преобразуются к
одинаковому типу. В противном случае
всегда возвращается .

Меньше или
равно
Определяет,
верно ли, что
меньше
или равно

даёт
.

Больше или
равно
Определяет,
верно ли, что
больше
или равно

даёт
.

Равно
Проверяет,
одинаковы ли
объекты

даёт
.
даёт
.
даёт
.

Не равно
Проверяет,
верно ли, что
объекты не
равны

даёт
.

Логическое НЕ
Если
равно ,
оператор вернёт

Если
же равно
,
получим
.

даёт .

Логическое И

даёт ,
если
равно
, в противном
случае
возвращает
значение

возвращает , поскольку x равно
. В этом случае Python не
станет проверять значение , так
как уже знает, что левая часть
выражения ‘and’ равняется ,
что подразумевает, что и всё выражение
в целом будет равно ,
независимо от значений всех остальных
операндов. Это называется укороченной
оценкой булевых (логических) выражений.

Логическое
ИЛИ
Если
равно ,
в результате
получим
, в
противном
случае получим
значение

даёт
. Здесь также может
производиться укороченная оценка
выражений.

Изменяемые и неизменяемые типы данных

Только почему операторы is и == одинаково сравнивают неименованные значения intи string (например, 5 и «example»). Но при этом не ведут себя так же с неименованными списками (например, )?

В Python есть две разновидности типа данных:

• Изменяемые — те, которые можно изменять
• Неизменяемые – остаются неизменными (имеют одинаковое расположение в памяти, что is и проверяет) после их создания.

Изменяемые типы данных: list, dictionary, set и определяемые пользователем классы. Неизменяемые типы данных: int, float, decimal, bool, string, tuple, и range.

Python обрабатывает неизменяемые типы данных иначе. То есть сохраняет их в памяти только один раз.

Применим Python-функцию id(), которая вызывает уникальный идентификатор для каждого объекта:

s = "example"
print("Id of s: " + str(id(s)))
print("Id of the String 'example': " + str(id("example")) + " (note that it's the same as the variable s)")
print("s is 'example': " + str(s is "example"))

print("Change s to something else, then back to 'example'.")
s = "something else"
s = "example"
print("Id of s: " + str(id(s)))
print("s is 'example': " + str(s is "example"))
print()

list1 = 
list2 = list1
print("Id of list1: " + str(id(list1)))
print("Id of list2: " + str(id(list2)))
print("Id of : " + str(id()) + " (note that it's not the same as list1!)")
print("list1 == list2: " + str(list1 == list2))
print("list1 is list2: " + str(list1 is list2))

print("Change list1 to something else, then back to the original () value.")
list1 = 
list1 = 
print("Id of list1: " + str(id(list1)))
print("list1 == list2: " + str(list1 == list2))
print("list1 is list2: " + str(list1 is list2))

Выполнение кода выдаст следующий результат:

Id of s: 22531456
Id of the String 'example': 22531456 (note that it's the same as the variable s)
s is 'example': True
Change s to something else, then back to 'example'.
Id of s: 22531456
s is 'example': True

Id of list1: 22103504
Id of list2: 22103504
Id of : 22104664 (note that it's not the same as list1!)
list1 == list2: True
list1 is list2: True
Change list1 to something else, then back to the original () value.
Id of list1: 22591368
list1 == list2: True
list1 is list2: False

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

Но не возвращает тот же объект, значение которого равно . При этом создается новый объект, даже если он имеет то же значение, что и первый .

При выполнении кода вы получите разные идентификаторы для объектов, но они будут одинаковыми.

Типы данных и преобразование типов

Перечислим основные типы данных в Python, которые понадобятся на ближайших уроках:

• int – целочисленные значения;float – вещественные (дробные) значения;bool – логические значения — истина (True) или ложь (False);str – символьная строка или единичный символ.

Рассмотрим примеры использования основных типов в Python:Целые числа (int):

num = 13
print(num)  # 13
 
num = 
print(num)  # 0
 
num = -10
print(num)  # -10
 
num = 500_000_000  # для удобства чтения
print(num) # 500000000

Вещественные числа (float):

num = 13.4
print(num) # 13.4
 
num = 0.0
print(num) # 0.0
 
num = -15.2
print(num) # -15.2
 
num = 100_000.000_002 # для удобства чтения
print(num) # 100000.000002
 
num = 1.7e2 # 1.7 умножить на 10 в степени 2
print(num) # 170

Логический тип (bool):

print(15 == 15) # True
 
print(1 != 3) # True
 
print(3 > 4) # False
 
print(3 <= 3) # True
 
print(6 >= 6) # True
 
print(6 < 5) # False
 
x = 2
print(1 < x < 3) # True

Строки (str):

example_string = "Очень интересно"
print(example_string) # Очень интересно
 
example_string = 'Пьеса "На дне"'
print(example_string) # Пьеса "На дне"
 
example_string = "Пьеса \"На дне\"
print(example_string) # Пьеса "На дне"
 
example_string = "Как " \
                 "разбить " \
                 "объявление длинной строки"
print(example_string) # Как разбить объявление длинной строки
 
example_string = """
                 Как  
                 оставить сроку
                 в несколько строк
                 """
print(example_string) 
# Как  
# оставить сроку
# в несколько строк

# Как объединить две строки в одну
print("Можно их" + " сложить") # Можно их сложить 
 
print("Можно и так!" * 3) # Можно и так!Можно и так!Можно и так!

Рассмотрим примеры того, как используется преобразование типов в Питон:

• преобразование в символьную строку:

1
2
3

a = 1.7
a=str(a)
print(a) # '1.7'

преобразование в целое:

1
2
3

x = 1.7
x=int(x)
print(x) # 1

преобразование в вещественное:

1
2
3

y=1
y=float(y)
print(y) # 1.0

Сравнение функции с методом

• Функция Python является частью файла сценария Python, в котором она определена, тогда как методы определены внутри определения класса.
• Мы можем вызвать функцию напрямую, если она находится в том же модуле. Если функция определена в другом модуле, мы можем импортировать модуль, а затем вызвать функцию напрямую. Нам нужен класс или объект класса для вызова методов.
• Функция Python может обращаться ко всем глобальным переменным, тогда как методы класса Python могут обращаться к глобальным переменным, а также к атрибутам и функциям класса.
• Тип данных функций Python — это «функция», а тип данных методов Python — «метод».

Давайте посмотрим на простой пример функций и методов в Python.

class Data:
    def foo(self):
        print('foo method')


def foo():
    print('foo function')


# calling a function
foo()

# calling a method
d = Data()
d.foo()

# checking data types
print(type(foo))
print(type(d.foo))

Вывод:

foo function
foo method
<class 'function'>
<class 'method'>

Преимущества

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

Python для систем счисления

• bin(y) — целое число преобразовывается в двоичную строку.
• hex(y) — целое число преобразовывается в шестнадцатеричную строку.
• oct(y) — целое число преобразовывается в восьмеричную строку.

Рассмотрим примеры работы с системами счисления:

bin(17) # '0b10001'
oct(17) # '0o21'
hex(17) # '0x11'

Задание Python 1_2: Даны две переменные. Запросить их значение. Выполнить основные арифметические действия с переменными, целочисленное деление, возведение в квадрат. Осуществить перевод в системы счисления (в 8-ю и 16-ю). Вывести результат.

Задание Python 1_3: Найти длину окружности L и площадь круга S заданного радиуса R:

L=2*pi*R, S=pi*R2.

В качестве значения использовать 3.14.

* Из задачника М. Э. Абрамян

Задание Python 1_4: Даны три точки A, B, C на числовой оси. Найти длины отрезков AC и BC и их сумму.
* Из задачника М. Э. Абрамян

Пример: Дано двузначное число. Найти сумму и произведение его цифр.
* Из задачника М. Э. Абрамян

Решение:

import math
print('Введите двузначное число: ')
A = int(input())
Res = (A // 10) + math.fmod(A, 10)
print('Сумма его цифр равна: ', int(Res))
Res = (A // 10) * math.fmod(A, 10)
print('Произведение его цифр равно: ', int(Res))

Задание Python 1_5: Дано двухзначное целое число. Вывести сначала его правую цифру, а затем левую.

** Сделайте задание повышенной сложности: необходимо поменять местами цифры числа и вывести результирующее число (вывести не отдельные цифры, а именно число). Например, число , а результат — число .

* Из задачника М. Э. Абрамян

Битовые операторы Python

Побитовый оператор работает с битами и выполняет побитовую операцию. Предположим, если а = 60; и б = 13; Теперь в двоичном формате их значения будут 0011 1100 и 0000 1101 соответственно. В следующей таблице перечислены побитовые операторы, поддерживаемые языком Python, с примером каждого из них, мы используем две вышеупомянутые переменные (a и b) в качестве операндов —

а = 0011 1100

b = 0000 1101

——————

A & B = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

Существуют следующие побитовые операторы, поддерживаемые языком Python

Python: все дело в отступе

Python следует условности, известной как правило off‑side, термин, придуманный британским ученым-компьютерщиком Питером Дж. Языки, которые придерживаются правила off‑side, определяют блоки отступом. Python — один из небольшого набора автономных языков.

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

Таким образом, составной оператор в Python выглядит следующим образом:

if <expr>:
    <statement>
    <statement>
    ...
    <statement>
<following_statement>

Здесь все операторы на соответствующем уровне отступа (строки 2‑5) считаются частью одного блока. Весь блок выполняется, если <expr> имеет значение true, или пропускаются, если <expr> имеет значение false. В любом случае выполнение продолжается с <following_statement> (строка 6).

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

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

Рассмотрим этот скрипт foo.py:

if 'foo' in :
    print('Выражение истина')
    print('Выполнение инструкции')
    print('...')
    print('Готово')

После старта foo.py производит данный вывод:

C:\Users\john\Documents>python foo.py
After conditional

Четыре оператора print () в строках 2-5 имеют отступы на одном уровне. Они составляют блок, который был бы выполнен, если бы условие было истинным. Но это ложь, поэтому все утверждения в блоке пропускаются. После завершения сложного оператора (независимо от того, выполняются ли операторы в блоке в строках 2-5 или нет) выполнение переходит к первому оператору с меньшим уровнем отступа: оператору print() в строке 6.

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

Вот более сложный файл сценария под названием blocks.py:

# Does line execute?                        Да    Нет
#                                           ---    --
if 'foo' in :        #  x
    print('Условие имеет значение истина')      #  x

    if 10 > 20:                           #  x
        print('Внутреннее состояние')        #        x

    print('Между внутренними условиями')     #  x

    if 10 < 20:                           #  x
        print('Внутренние состояние 2')        #  x

    print('Окончание внешнего состояния')       #  x
print('Через внешнее состояние')            #  x

Выходные данные, сгенерированные при запуске этого скрипта, показаны ниже:

C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition

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

Сложные логические выражения

Логические выражения типа являются простыми, так как в них выполняется только одна логическая операция. Однако, на практике нередко возникает необходимость в более сложных выражениях. Может понадобиться получить ответа «Да» или «Нет» в зависимости от результата выполнения двух простых выражений. Например, «на улице идет снег или дождь», «переменная news больше 12 и меньше 20″.

В таких случаях используются специальные операторы, объединяющие два и более простых логических выражения. Широко используются два оператора – так называемые логические И (and) и ИЛИ (or).

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

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

Допустим, переменной x было присвоено значение 8 (), переменной y присвоили 13 (). Логическое выражение будет выполняться следующим образом. Сначала выполнится выражение . Его результатом будет . Затем выполнится выражение . Его результатом будет . Далее выражение сведется к , что вернет .

>>> x = 8
>>> y = 13
>>> y < 15 and x > 8
False

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

В случае с оператором второе простое выражение проверяется, если первое вернуло ложь, и не проверяется, если уже первое вернуло истину

Так как для истинности всего выражения достаточно единственного , неважно по какую сторону от оно стоит

>>> y < 15 or x > 8
True

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

>>> not y < 15
False

Здесь возвращает . Отрицая это, мы получаем .

>>> a = 5
>>> b = 0
>>> not a
False
>>> not b
True

Число 5 трактуется как истина, отрицание истины дает ложь. Ноль приравнивается к . Отрицание дает .

И чем помогут генераторы в наших задачах?

Для этого сначала рассмотрим упрощённый способ создания генератора — с помощью генераторного выражения.

Генераторные выражения позволяют создавать объект-генератор в одну строчку. В общем случае их пишут по шаблону:

(выражение for j in итерируемый объект if условие)

Где for, in, if — ключевые слова, j — переменная.

Пример генераторного выражения мы рассмотрели выше. Теперь посмотрим, как можно применить его для обработки большого файла.

Перед нами задача: на сервере есть огромный журнал событий log.txt, в котором хранятся сведения о работе какой-то системы за год. Из него нужно выбрать и обработать для статистики данные об ошибках — строки, содержащие слово error.

Такие строки можно выбрать и сохранить в памяти с помощью списка:

Здесь path — путь к файлу log. В результате сформируется список вида:

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

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

Рассмотрим следующий код:

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

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