Transcription
Всем привет!
Добро пожаловать на стрим. Помашите мне ручкой в чат. Скажите, что вы меня видите, что вы меня слышите. Как ваши делишки с прошлого стрима? Кто-нибудь остался вообще живой? Там есть кто живой?
Так, всё, лайк идёт. Давайте я проверю, что звук есть, что всё есть. Так, выглядит как звук есть, всё с кайфом.
Друзья, как ваши делишки? Как ваши успехи? Вообще, что кого там? Как там вообще дела?
Сегодня мы будем кодить. Короче, смотрите, кодить будем. Это Питон с нуля, часть два. Это значит, что ты типа первую часть якобы посмотрел, ну или собираешься посмотреть позже, или типа там как-то в каком-то порядке. В общем, что-то типа шаришь, что-то не шаришь, уже какую-то бяку получается умеешь.
Давайте отметьте с в чате, что писать не умеем, что ли. Давайте ещё раз в чат ТГ сейчас напишу тогда ещё раз.
Так, а ну и мы с вами продолжим. Значит, смотрите, в прошлый раз прошли все элементы базового синтаксиса. Это что означает вообще? Элементы базы учесть, как работают цикл for, как работает цикл while, как работает ветвление if, там все вот эти вот штуки.
И сегодня, значит, мы пройдём чуть дальше. Поехали! Значит, вспомним, во-первых, концово начало. Конец того стрима будет началом этого стрима.
Что в предыдущих сериях? Вот так вот заводим цикл for, запускаем, например, for i in range 5, пишем "Hello, world". Такая программа выведет "Hello, world" пять раз, потому что это цикл for, который перебирает счётчиком i 0, 1, 2, 3, 4.
Мы в прошлый раз научились выводить с вами таблицу квадратов, например, i и i квадрат. for range, например, 100, выдаёт нам вот такой результат.
Ну, видим вот такие вот результаты, ответ вот такие. Всё, кайфуем, короче. Да, что мы ещё научились делать? Мы запускаем какой-нибудь цикл range, например, 1000, и, например, в этом range мы условия какие-нибудь накладываем, типа if какой-нибудь там как-нибудь там себя ведёт.
О, привет! Зашибись! Помните с прошлый раз? Если i делится, например, на 100, и при этом i, например, не делится на 3, то вот такое i тогда пишем, остальные не пишем.
Вот 100, 200, 400, 500, 700, 800. Перебрал я все числа вообще от нуля до 999, но проверил на условия какие-то такие числа. То есть вот такую конструкцию мы с вами научились делать.
Ещё мы с вами пороли конструкцию под названием "поиск количества". Это давайте вот так вот сделаем и в конце напишем print k.
А вот print и закомментить. В итоге это действие не выполняется, оно просто закомментировать слово. Вот шесть, которое получилось, это k увеличилось до шести. То есть оно увеличивалось на единичку много-много раз, пока не стало равным шести.
Это что означает? Значит, что k было ноль, а потом такое 1, 2, 3, 4, 5, и в итоге k стало равным 6. И вот всё, конец, по победили, как бы. Ну, на этом всё и закончилось.
Идея здесь в том, что переменная k отвечает как бы как счётчик. Она типа начинает с нуля и доходит до шести увеличением на единицу. Ну, за каждую операцию, соответственно, то, что мы на выходе получили, это количество чисел, удовлетворяющих условия.
Данный алгоритм мы будем использовать миллион раз. Обратите внимание на детали k.
Ну, в начале k, пра 1, в середине и print k. Ну, соответственно, вот такой вот алгоритм. Типа начинаем с нуля, увеличиваем на единицу внутри какого-то if, который проверяет условия, и потом print.
Каждый раз, когда вы такое видите, это значит, что это подсчёт количества. Какие ещё существуют такие же стандартные линейные алгоритмы, когда надо пройти по набору чисел и что-то с ними сделать, кроме подсчёта количества?
Значит, давайте я это запишу как "подсчёт количества". Подсчёт количества. И затем всю эту часть для того, чтобы что происходит.
Вот так, затем эту всю часть, чтобы дальше писать другое. Давайте теперь вычисление максимума, поиск максимума напишем. Я засл сразу, что я буду делать.
Но на самом деле, короче, давайте так, я начну с какой-то переменной, равно, например, минус. Ну, давайте начнём с нуля. Просто взял переменную, сделал.
Ну вот, тоже запустил цикл, который проверяет какие-то числа. Но на самом деле это не очень интересно. Интереснее проход по массиву. Мы в прошлый раз с вами прошли, что такое массивы тоже.
Поэтому давайте 10, 12, 13, 100, 11, 15, 107. И задача будет такая: найти максимальное чётное число среди элементов массива.
А какая длина массива? А, да фиг его знает, как-то лениво даже думать. Поэтому я буду использовать len функцию for i in range n, то есть от нуля до длины массива.
Я буду print. Программа вопрос, наверное, к Камилю. Но вообще хотелось бы, чтобы все, кто сейчас онлайн, смотрят эту трансляцию, написали что-нибудь в чат.
Друзья, товарищи, напишите в чат. Давайте мы с вами как-то по взаимодействуем. Ну, типа я веду стрим, что-то объясняю, а вам влом даже в чатик написать.
Мне не влом было трансляцию запустить. Вот, всё, чинить. Здорово, Кирилл! С кайфом, что будет выводить данная программа?
Привет, Екатерина! Лайк вам за то, что вы отчаялись написать, и вы светили своё имя. Я могу к вам теперь обратиться по имени и сказать, выведет все элементы массива, кроме 107.
А почему кроме 107? Давайте посмотрим. 107 тоже выведено. А почему? Так, почему 107 тоже выведено? А потому что, почему бы ему не быть выведенным?
Типа у нас n - это 1, 2, 3, 4, 5, 6, 7. n = 7. Следовательно, то, что я увижу в итоге, будет элементами массива от нулевого до шестого.
Нулевой, первый, второй, третий, четвёртый, пятый, шестой. То есть n - это 7, i in range 7 - это 0, 1, 2, 3, 4, 5, 6.
То есть нулевой, первый. Давайте прямо выведем i, зап. ai и увидим, что на нулевом шаге выведено 10, на единичном выведено 12, на двоечке выведено 13, шестёрочка выведена на 107.
Ну, такая штука. А знаете, что я ещё придумал? Я ещё придумал чат, а спрятать часть чата.
Потому что верхушка чата бесполезная, и внизу вот это вот "авторизуйтесь, чтобы написать в чат" тоже бесполезное. Вот что я хочу сделать. Я хочу спрятать кусок чата.
Для этого я у него высоту увеличу до 800. Вот так вот сделаю. Gen, правда, вот так вот сделаю и вот так вот его подниму.
ВС! Теперь ничего лишнего не видно, правда? Прекрасно! Но теперь видос торчит из-под чата. Вот так всё.
Зато чат работает. Сегодня, прикиньте, починил, разобрался, доделал. Тупая была ошибка, как собственно всегда в программировании. Ошибки максимально тупые.
От, ну до 6 значит 10, 12, 13, 11, 15, 107. Вывели все элементы. То есть a - это сами элементы.
Ну давайте, что пускаю, вижу ответы 100, 144, 169. Это я взял элементы массива, которые я перебираю циклом, и вот у меня получается эти элементы в квадрате.
Вот 107 к. Давайте ещё одна проверочка. Если a про 2 ра. Ну, print a.
Что я увижу на экране, когда запущу данную программу? Просто проверяем, как предыдущий вебинар усвоен вообще, урок или не усвоен. Как там делишки вообще?
Кого там успехи у вас там? Вот это всё интересно. Давайте напишите, напишите в чат, напишите, что произойдёт в таком случае. Чётные элементы массива.
Да, Екатерина, только чётные элементы массива, потому что a делится на 2. Я к тому, что мы внутри цикла можем обращаться к элементам массива с помощью вот такой вот формулы.
А и т, где А - это название массива. Название массива может быть любым. Например, оно может тогда, мы будем здесь обращаться к Екатерине.
Екатерина, Рина в Екатерина. Вот значит, мы запускаем, где я, а вот здесь я, Екатерина.
Тоже меня интересует длина массива Екатерина. Вот, то есть название массива может быть любым. Название переменных может быть любой набор букв.
Вот и так, собственно. Но на самом деле потом в будущем надо будет учиться называть массивы правильным образом. То есть называть их так, чтобы они несли в своём названии смысл того, какую роль они выполняют.
Вот, соответственно, сейчас мы не называем массивы каким-то особым способом, потому что у нас как будто бы тренировочные упражнения.
Сейчас просто типа А, X, там все переменные это просто А и прочее. Всё супер, с этим разобрались. Тогда, соответственно, подсчёт количества элементов в массиве.
Да, выполняется. Вот так вот, к. В данный момент у нас переменная M никак не использована.
Ну зато вот мы научились, например, считать количество чётных чисел. Их три. Прекрасно! Давайте теперь решим задачу про поиск максимального чётного числа среди элементов массива.
А на самом деле это даже не массив, это называется список, но без разницы. В нашем смысле массив и список - это пока что одно и то же.
Мы потом научимся различать массивы и списки, когда будем уже проходить непосредственно Python массивы из библиотеки, нам array, вот эти вот штуки.
Пока можно их называть массивами в том смысле, что они идентичны по смыслу массивам из C++. Дале, в плане нашего использования на низком таком уровне, пока знания.
Итак, если a[i] чётная, то вот мы в этом разделе будем что-то делать, потому что надо найти не просто максимальное, а максимальное чётное.
А теперь смотрите фокус. Следующий, если a[i] превысила, то вот именно этот код. Потратьте несколько минут, ну или не несколько минут, а полминуты, давайте точно скажу, чтобы понять, почему этот код вывел максимальное число среди чётных.
Среди чётных. Понятно? Седьмая строчка ограничила перебор только на чётные. А вот почему восьмая и девятая обеспечили выбор максимума.
Это интересно. Выведите плюс, как только осознаете. Мне нужно, чтобы вы поняли, почему данная прога выводит максимальное число. Как так получается?
Так, Кирилл, плюнул. Екатерина тоже красавчики. Камиль тоже. А есть у нас ещё кто-то сейчас в лайве, кто ещё не написал, себя не спалил? Спали не переживай, я не буду тебе писать в личку.
Вообще я друг, я тебя не обижу. Давай сидеть и смотреть друг на друга, пока наши глаза не устанут.
Итак, если a[i] больше чем m, равно a[i]. Как это вообще привело к результату? Как понять?
Смотри, я взял, оно у нас 10 или 12 или 13. Ну, короче, постепенно меняется элемент. Я говорю, если очередное a больше чем изначально.
Но давай поймём, как эта прога работает. Для того чтобы понять, как она работает, я сейчас сделаю ужасную вещь. Я сейчас запущу дебаг.
Я остановку, точку останова поставил на пятой строке. Я вот здесь вот справа сверху выбираю вот такого жучка. Значит, дебаг. Я запустил функции.
Я сейчас нахожусь в функции a, которую я отслеживал. Ну вот, короче, давайте посмотрим. У нас есть переменная a, это массив, она уже создана.
Есть переменная, равная нулю, она уже тоже создана. И сейчас мы находимся на строке номер п. Это то место, где я поставил точку останова.
Для того чтобы дойдя до неё, дальше делать все шаги программы вручную. Я буду использовать step over.
Вот здесь есть несколько step into и так далее, и так далее. Но я внутри своей программы делаю просто шаги действия и так далее.
Я сейчас, короче, сделаю вот это действие. У меня появится переменная n, и она будет равна n. У нас это se, поэтому у меня появится переменная, равная сем.
В ран тайме моей программы нажимаю на кнопку, получается n = 7. Да, они же ещё дети, а я уже показываю дебаггер.
Да, ну второй урок уже пора, что уж там. Нажимаю сейчас на эту кнопку, у меня появится переменная i, которая начнёт отслеживать цикл.
То есть вот эта синяя строчка демонстрирует, как бы, где мы сейчас находимся и какую сейчас строчку собирается выполнить моя программа.
Безумно удобный инструмент. Жучок нарисован, потому что по-английски слово "баг" означает жучок. А "дебаг" соответственно избавление от жучков.
Каких жучков? А дело в том, что самые первые компьютеры были огромными такими механизмами, которые целую комнату занимали.
И там стоял просто дофига железяк, и ошибки в коде возникали из-за того, что жуки заползали на микросхемы, их дёргал током, происходило короткое замыкание, и не работала программа так, как она должна.
Потому что, ну, реально жук заполз просто, и вот сгорел там. И, собственно, исторически с тех пор так повелось, что ошибки в программе называют багами.
Даже если они уже произошли не по внешней причине, не из-за того, что кто-то там типа жука подсадил куда-то или ещё что-то такое.
Но баги - это ошибки, потому что это жуки по сути. Вот, а только теперь мы багами называем ошибки, которые прокрадываются в компьютер.
Жучок, но потому что я там не знаю, тупанул, ошибку не там, где-то на допустил знак перепутка или ещё что-то такое.
Вообще да, это вот жуки. Значит, дебаг - это типа "де баг" избавление от жуков. Типа ты такой знаешь, как это, как опрыскиваю.
Вот тоже самое. Вот мы сейчас занимаемся дебаггингом. Это не всегда типа исправление ошибок. Иногда это, например, я буду использовать для демонстрации вам просто пошаговой проверки кода.
Это очень удобно, потому что вы начинаете лучше понимать, как вообще мыслит программа. Вот у неё цикл, я запустил его.
Я, кстати, намеренно не показывал на прошлом, чтобы вы делали то же самое, что сейчас дебаггер делает, но в уме. Когда там типа я просил вас, что выведет программа с лом или с определённым формом или ещё что-то, чтобы у вас не было этого инструмента.
Теперь есть. Значит, следующая кнопка, я запускаю, у меня i становится равным нулю, и я захожу в цикл.
И a[i] процент 2 равно равно нулю. Как понять, что такое a[i]? У нас есть a, у нас есть i.
О, здорово, круто! Лайк, если есть a и есть i, и рав. Ну, соответственно, a[i] - это a нулевое, то есть 10.
Но это неудобно, да, соединять массив номер счётчика и так далее. Знаете, что можно сделать? Можно добавить вот в этот списочек ещё одно выражение, которое я хочу отслеживать.
Я кликнул правой кнопкой и нажимаю new watch. Наверное, не только в правой кнопке, где-то тут ещё есть кнопочка.
Ну, короче, ладно, новое выражение. Какое выражение я собираюсь добавить? Я собираюсь добавить вот такое выражение a[i]. Я хочу отслеживать a[i].
У меня получилось a[i] - это int и 10. То есть это целое число, и оно равно 10, потому что a - это вот такой список, и i - это ноль.
Список, вот лист, лист se, лист размером сем. То есть тут всё понятно. Надо не бояться вот этих всех значков и читать их, потому что они друг, они нас не обидят.
Они разве что предложат, ну, сесть и смотреть друг на друга, пока глаза не устанут. Но в остальном они прекрасно себя ведут.
Совершенно вот этот 10 - это 10, соответственно, a[i] - это 10. 10%2 равно нулю или нет?
Ну, я не знаю, чтобы проверить, я могу, например, завести вот такой ещё один watch. a%2, вот такое выражение отслеживать a%2.
Но оно равно, ну да, могу ещё более сложный завести. a%2 равно нулю. Оно сейчас, вот это выражение, всё булевое, то есть логическое, и оно равно.
Значит, данное выражение сработает. Как делаем переход и видим, что она зашла в этот if. Но это уже на самом деле делают.
Есть обы такие выражения, не отслеживают. Яда, выражения 10, чтобы типа не подставлять самому.
Итак, 10 больше чем 10, больше чем, да, больше. Значит, мы заходим в этот if, и m становится равным 10.
Что произошло, кстати? Оно ещё для удобства показывает мне, чему равно вот здесь, а чему a равно вот здесь.
Короче, 10, всё по кайфу, идём дальше. Следующая a - это 12, потому что следующее i равно там чему-то, бла-бла-бла.
Соответственно, мы заходим, a не делится на 2, поэтому мы проигнорируем. Теперь a - это 100.
100 делится на 2, да, делится, заходим. 100 больше чем 12? Да, больше, заходим, заменяем 12 на 100.
В итоге у нас в переменной m хранится 100. Потом три раза числа будут нечётные, поэтому мы даже вот в этот if не зайдём.
Тем более вот сюда мы не будем углубляться. Соответственно, наша программа при пошаговом выполнении всё это демонстрирует.
Мы видим, что она не заходит в if. В конце print m у нас, ну, а у нас всё ещё там равно 107.
Но это неважно. Важно то, что у нас теперь есть число 100. Конец. То есть мы в итоге получили ответ, что за ответ ещё раз это получилось максимальное чётное число среди элементов списка.
А вот вы уже поставили плюсик на понимание. Я вам просто ещё раз супер подробно объяснил.
Давайте мы ещё массив наполним, как мы умеем. Давайте мы наполним его n элементами. n будет считано с клавиатуры.
Пользователь даст количество, и массив будет состоять из ноликов. А потом мы создадим в коде, заполним инпутом.
Теперь у нас массив состоит из чего? Из элементов, которые пользователь введёт с клавиатуры. Например, 5, 100, 200, 202, 303 и 407.
Пять элементов, максимальная чётная из них 202. Мы научились решать вот такую вот задачу для произвольного объёма входных данных.
Мы научились считать количество с помощью переменной какой-то. Но это может быть любая переменная на самом деле.
Любое название. Я просто буду в основном первое время использовать одинаковое название для переменных с одинаковым смыслом, чтобы вы привыкали.
Вообще обычно для таких переменных используют название типа counter, а для переменной m обычно что-нибудь типа maximum или что-то такое.
Maximum там number или что-нибудь такое. Мам, короче, какое-то название, которое как-то хотя бы по смыслу отражает.
Вот, но я просто пока использовал m. Внимание, вопрос, что надо поменять в этой программе, чтобы она вместо максимума стала искать минимум?
То есть задача, новая задача - найти минимальное чётное число среди элементов списка a. Давайте мы пока сохраним поиск, поиск чёт максимума.
Камиль предлагает, и Кирил тоже предлагает, зна заменить на знак меньше. Достаточно ли будет такого изменения, чтобы программа нашла минимальный чётный элемент среди элементов массива a?
Данная часть - это у нас считывание длины массива, а затем самого массива. Больше на меньше.
Но m изначально надо изменить. Да, если m изначально не изменить, то что выведет данная программа?
Если я, например, напишу ей пять чисел и дам ей пять чисел, то минимальная чётная из них - это 2, правильно?
А она выдаёт ноль. Почему ноль? Потому что m изначально равно нулю, и получается, ни в какой момент вот это не сработает.
А и меньшем просто никогда не работает. А вот если сделать m вот таким, то первое же чётное a[i] подойдёт.
Оно будет меньше, чем вот это вот m. Тут лучше не писать так много ноликов, просто написать 10 в девяносто, или там типа в восемнадцатый, заведомо больше, чем тебе в задаче дали.
Да, по размеру. Ты знаешь, что числа могут быть до миллиона, например. Ну, сделай тогда 10 в шестой, чтобы там максимальное число было заведомо больше, чем числа, которые тебе даны.
Ну или там 10 седьмой, немножко с запасом. А так 10 в ноль обычно подходит всем.
Вот, а ну и вот, например, для такого кода у нас уже будет найдено минимальное чётное число.
Ну, на самом деле для поиска максимума надо начинать тоже не с нуля, а с m1 вво, потому что числа бывают иногда отрицательные.
И найти максимальное число - это обычно плохо заканчивается, если ты начал с нуля, а тебе дали все числа отрицательные.
Но максимальное число будет тоже отрицательным, а твоя программа этот ноль не заменит ни на что другое.
Давай отследи, покажу тебе этом с. Ну, Мари, давай давать отрицательные числа на вход, и ты увидишь, как эта программа плохо работает.
Поставлю вот здесь точку останова и дам ей очень много. Так, я сейчас буду её не запускать. Я сейчас запущу дебаг.
Дебаг запускаю, он в консоли просит числа. Я дам пять чисел. Числа будут такие: -10, -20, -30, -35 и -7.
Максимальная чётность среди них - это m1. Наша программа дошла вот до этого. У нас есть вот такой вот a, который ввёл максимально отчётный.
Ещё раз -10. Вот я сейчас буду запускать эту программу, посмотрим, как она себя ведёт. Запускаем цикл, проходим, выбираем первое число.
a -10, -10 чётное? Да, чётное. -10 больше чем m? Нет, не больше. -10 больше чем ноль? Нет, не больше. Игнорируем.
Заходим снова. -20 больше чем? Нет. -3 больше чем? Нет. -35 даже не является чётным. -7 тоже не является чётным.
Таким образом, мы ни разу не зашли внутрь if, который a[i] больше чем m. Таким образом, ни разу не поменяли m.
Таким образом, m по итогу будет равно нулю. То есть наша программа просто выписывает ноль, несмотря на то, что это куча отрицательных чисел.
Это тупо. А по-хорошему вам надо получается для поиска максимума инициализировать m очень маленьким числом.
Стартовать с очень маленького числа. Вот так вот можно объединить оба этих условия. Я просто сейчас их специально разделил, чтобы видеть, на каком шаге дебаггер выбирает либо э, либо это.
Вообще можно объединить оба условия, потому что вам надо для перезаписи, чтобы одновременно число было чётным и чтобы оно было больше, чем.
Таким образом, можно объединить эти условия через знак. То есть первое и второе. Очень хорошо вы отметили.
Да, итак, поиск чётного максимума. Вот такой сонно. Поиск чётного минимума - это аналогичный код, только начало с очень большого числа.
А дальше, если a меньше, да, давайте мы сейчас Кирилла по фактам разнесём люто. Берём a нулевое и пишем следующий алгоритм для поиска, например, максимума.
Да, давайте вот такой вот алгос. Ничего не меняю. А придумайте тест, на котором у Кирилла алгоритм сломается.
Задача - найти чётный максимум. Тогда уж не a нулевое, а первое чётное число в списке.
Но это вы, господин М Баташев, сразу пишете. В чём ошибка? Попрошу прочитать следующее сообщение.
А так это при условии, что l больше. Ну да, l больше, ну просто означает, что количество чисел положительно.
Так что да, прежде чем писать тест, который завалит рение, прочи следующее сообщение Кирилла.
И давайте только тесты, в которых длина массива a больше. Ну, Кирилл, хорош, кстати, добавил. Добавил условия, благодаря которому на одной тупой ошибке его тест не сломается.
Его прога не сломается, но всё ещё существует тест, который ломает прогу Кирилла. Вот я сейчас её написал. Я предлагаю вам придумать этот тест.
То есть давайте так, чтобы было больше. Ну, я предлагаю придумать тест, в котором будет именно p чисел.
Уже сам понял, да, в чём ошибка? Забыл про чётность. Смотрите, тест следующий: 107, 1, 2, 3, 4.
Что должна вывести эта программа? По логике она должна вывести максимальное чётное число. Да, чётный максимум.
Чётный максимум в этом массиве 4. Ну что, четы, самое большое отчётное число, что выведет эта программа?
Она прочитала n = 5, потом она прочитала пять чисел: 107, 1, 2, 3, 4. 107 - это a нулевое, стало равным a нулевому, то есть сразу стало равным 107.
А потом, когда мы проверяем его на чётность, и всё вот это делаем, оно в итоге не сработает.
То есть если бы забыли мы условия про чётности, не использовали бы, тогда такой подход работал бы.
Тогда мы в качестве инициализации для максимума выбрали бы самый первый элемент массива и сказали бы, ну как бы в крайнем случае выведем первый элемент массива, если мы не найдём ничего больше него.
То есть первый элемент тоже подойдёт в качестве максимума. Ну а так забили на него.
Но если у нас есть какое-то дополнительное условие, например, чётность или нечётность, то мы так уже не можем сделать.
Вот такая штука. Можно убрать m, а использовать a[i] и a[i + 1]. Не знаю, как записать следующий элемент массива.
Хорошо, кстати, правильно записала следующий элемент массива. А если ты будешь использовать a[i] и a[i + 1], то как ты в итоге, убрав m, справишься?
Вот это интересный вопрос. Куда ты хочешь записывать промежуточный добытый максимум?
На самом деле мы с вами сейчас знакомимся сразу ещё с такой темой, как динамика потом в алгоритмах. Она будет очень вам полезна.
Дофига вы будете про неё узнавать и так далее. Но мы сейчас написали самый первый, самый простейший динамический алгоритм, в котором первый вариант поиска максимума - это сравнить все со всеми и найти самого большого.
Ну, типа как работает поиск максимума? Например, у нас есть, не знаю, 20 человек в классе. Как найти человека с максимальным ростом?
Мы каждому говорим: "Сравни свой рост со всеми другими в классе". Все так сделали. Дальше мы говорим: "У кого сейчас получилось число 19? Кто 19 раз оказался выше своих друзей?"
И там кто-то найдётся: "Я 19 раз выше всех своих друзей". Мы такие: "Ну, прекрасно! Значит, у тебя самый большой рост".
Но это требовало сравнений всех со всеми. Это долго, муторно и не очень эффективно.
Гораздо логичнее было бы сравнивать. Взять первого и сказать: "Ну, ты самый большой, всё прекрасно". Берём второго: "О, ты побольше. Значит, теперь ты самый большой".
Берём третьего: "О, ты поменьше, значит, иди на фиг". Берём четвёртого: "О, ты опять поменьше, иди на фиг".
Берём пятого: "О, опять высокий, ещё выше, чем второй, которого мы в руках держим". Мы тогда такие: "Всё, пятый, пошёл на фиг, шестого берём в руки".
Вот тот, кого мы держим в руках, самый высокий на данный момент - это m. Это текущий максимум.
Если входные данные вот эти вот циклы for in range в какой-то момент оборву неожиданно, то мы скажем: "Ну и ладно, нет других больше".
Ну всё, кончились дети. Как бы поток внезапно остановился. Тогда самый высокий на текущий момент - это m.
То есть m по сути отвечает на вопрос, какой максимум на префиксе от нуля до i. Вот на стартовом кусочке.
И это динамическое решение, потому что вместо того, чтобы перебирать и всех со всеми сравнивать, мы упростили наш перебор за счёт того, что храним в голове какие-то необходимые данные.
Когда новый человек приходит, для того чтобы эффективно вычислять максимальный элемент, нам не надо нового человека сравнивать со всеми предыдущими.
Нам достаточно нового человека сравнить только с максимальным предыдущим, а максимальный предыдущий так уж удобно, мы его не отпустили, он у нас всё ещё сидит там в спортзале, и мы можем сравнивать.
Да, как вот в школе на физкультуре самого высокого мы находим. Вот такая вот конструкция.
Я не понимаю, что вы хотите, Екатерина, использовать a[i] и a[i + 1] для поиска максимума. Каким образом?
То есть вы говорите, можно ли убрать m и использовать a + 1? Типа вы как переменные хотите использовать a + 1?
Вот m равна a[0]. Дальше, если какой-то элемент i больше чем a[i - 1], то вы тогда, получается, найдёте только такие m, у которых a[i] больше чем предыдущий.
То есть смотри, например, такой вот тест. Если я запущу, будет p элементов, дальше будет 106.
Это ответ будет самый большой чётный. Потом будет, например, 107, но вы его, допустим, проигнорируете, потому что он нечётный.
Потом будет вот так вот 2, 4, 6. У вас тогда 4 больше чем 2, и вы четвёрку перезаписи в ответ.
Это неправильно, потому что 106 - это самое большое число. Если вы будете сравнивать a[i] со своим предыдущим или со следующим, то у вас программа вот на таком тесте будет падать.
Ну вот 4 же больше чем 2. Да, ну всё, как бы он запишет четвёрку как ответ.
А на самом деле 106 - это ответ. То есть вот в такой программе ответ будет 106.
Ну, кстати, здесь программа Кирилла нормально работает, потому что a нулевое сразу оказалось чётным.
Но программа Кирилла ломается, если a нулевое будет нечётным. Вот так что так не работает.
Тут можно было бы, чтобы типа первое чётное. То есть по идее можно было бы что-нибудь типа рано ничего.
Да, пока никакого ния нет. Потом можно было бы так прочитать одно значение, а потом сказать: "Так, пока x не является чётным, заменять x на следующий элемент".
Давайте начнём с нулевого, скажем, что i равно нулю и возьмём a[i]. Вот так вот.
Или давайте даже так, возьмём i равно нулю, пока a[i] нечётное, мы будем i увеличивать на единицу.
Тогда в какой-то момент a[i] станет чётным, и в этот момент можем сказать: "Ра, a[i], взяли первое чётное число".
Но тогда и здесь надо не цикл делать, а говорить: "Пока i меньше чем n, на каждом шаге увеличивать".
И, видите, как много на преобразовании кода из-за одной маленькой проблемы. Гораздо приятнее эту конструкцию всю не делать, а просто взять m равное -10 в де и не париться вообще.
Как бы вот так вот начать и всё. Это этого хватит. Так, утверждаете? Да, сейчас есть тест такой, например, тест, в котором вообще нет максимального чётного в массиве.
Вот, потому что я запускаю программу в поиска чётного максимума, который типа есть. Если его нет, то понятно, что моя прога падает, потому что она просто увеличивает, увеличивает, увеличивает.
Потом выходит за границы массива в какой-то момент, если так нет ни разу чётного числа в массиве вообще.
Вот, ну если мы здесь ещё добавим условие про то, что n[i] меньше чем n, и если мы вот здесь m равно a, то это всё можно делать только если у нас нормальные результаты.
То есть если типа в итоге i меньше чем n, и мы дошли до конца цикла, и вылетели из него не из-за этого условия, то всё нормально.
А вот если i равно n и добежала до n и из-за этого вынула из цикла while, то print числа в последовательности не обнаружено.
Типа вот такая штука. Мы пока предполагаем, что по функциям делить программу на логические куски не умеем.
Да, мы пока ничего такого не делаем, функции не используем и такие вещи не делаем. Мы сейчас про функции, мы просто пока не заика.
Вообще у нас пока всё в мене один сплошной код. И вот я по сути разделил на логические куски, да.
Но типа как это зачатки у этой идеи уже есть. Вот как видите, проверку на n тоже хорошая идея.
То есть начать с равного ничему и в итоге такую штуку делать. Типа возьмём равно ничего, дальше запустим цикл 4.
Это специальная переменная, которая обозначает ничего. Это не целое число, это вообще ничего. Её можно принтовать, например.
Вот, у нас сейчас там числа вводятся. Давайте три числа 1, 2, 3, и вот она - это ничего. Это типа как или истина, или ложь.
Вот это вообще абсолютная пустота, ничего, вакуум, короче, отсутствие. Вот, соответственно, я запускаю цикл, который переберёмся, сравнить число и nan.
Самый первый момент это неприятно. Давайте эту конструкцию вот так проверю. Покажу вам, должен найти число 500.
В итоге у меня ошибка больше не поддерживается между m и nan type. И ничего друг с другом не дружат.
Целое число не может сравниваться с не целым каким-то флом. Nan type - какое-то неприятное, непонятное.
Соответственно, что я вместо этого буду делать? Я запишу так, а в этом месте я добавлю проверку.
Если [музыка] получилось, что у меня никакое, то получается, я добрался до первого чётного числа, но при этом m у меня сейчас пока никакое.
Ну, значит, я пока не шёл ни на одного чётного числа. Значит, первое чётное число, которое я сейчас имею, вот и запишем его.
Этот цикл при этом оставим без проверок, без изменений, потому что теперь m не является nan, теперь m является целым числом.
А i, каким-то, ну и a[i] будет не больше чем m. Даже если будет, то, ну, ещё раз пере запишем.
Ра, и такая разница. Вот, всё готово. Таким образом, данная программа работает. Пять чисел: 100, 102, 103, 101, 107. Максимально чётная - это 102.
Вот оно найдено, всё прекрасно, без каких-то ошибок, при этом без танцев с бубнами, с -10 в де, с плю 10 в де и так далее.
Это мы с вами углубились в технические подробности и проблемки в написании кода, которые могут возникать.
Я скажу вам сразу, как программист программисту. Давайте по душам. Это неприятная часть процесса программирования.
Если вам сейчас это не понравилось, то это нормально. Прекрасно, абсолютно разделяю ваши чувства, разделяю ваши эмоции.
Так и должно было не понравится. Это та часть, с которой придётся столкнуться.
Ну, она гадостей происходит. Если вам эта часть понравилась, ну, поздравляю, это значит, что вам вообще люто подходит профессия программиста.
Если вам даже это понравилось, вот ещё это одновременно означает, что у вас диагноз есть какой-то.
Ну, типа готов продиагностировать вас через камеру, если вам понравилась сейчас вот эта часть с ковырянием, с инициализацией и так далее и так далее.
То я диагностирую человека. По какой-то причине вам нравится что-то, что не должно вообще людям нравиться в здравом уме.
Вот, значит, да, короче, это всякие типа проблемы. Ваш код по какой-то причине ковыряется вот с каким-то флом неприятным.
Вот такая вот есть конструкция. Соответственно, а, но суть алгоритма при этом простейшая. Поиск максимума.
И суть алгоритма сосредоточена вот в этих вот строчках. Ну, то есть вот так, например, а неплохо об этом думать.
Ну и раз уж мы с вами разобрались с поиском максимума, минимума, бла-бла-бла, давайте я вам покажу одну прекраснейшую функцию.
Функция называется, так, я сейчас пока оставлю вот эти количество, максимум, минимум и так далее. Значит, функции, даже метод, правильно называется append.
Append - это метод, применяемый к списку, чтобы добавить в него элемент. Используется следующим образом: берём какой-то список, это типа 10, 20, кошка, собака и ещё что-нибудь, число какое-нибудь.
Какое? Да, давайте число 18. Потом я так делаю и добавляю в него. Будет выглядеть массив a после того, как я сделал append.
Ну вот так вот. Плюсик в чат, если вам понятно, как работает метод append, или если вы его знали до этого.
О, ни фига себе, я камеру пнул люто. Давайте подвинем. Теперь её вот так вот. Оба, хоба, хоба. Хорошо.
Плюс-минус говорит Екатерина. Ну смотри, я использовал a и написал тут hello. Теперь hello тоже в массиве находится.
Изначально массив не содержал hello, теперь содержит. Вот такая вот конструкция. Hello, hello, hello, hello.
Тут вместо hello напишу 17, а тут напишу fse hello 17 fs hello. Вот так работает append. Он добавляет элементы к массиву.
Ну, типа что выведет? Да, всегда последним, именно последним. Да, да, да, это важно.
Это важно, он всегда в конце прибавляет. Потому что так работает выделение памяти в массиве.
У нас есть массив, и в нём есть, а типа вот сколько-то памяти просто выделено, и в конце свободное место, куда можно засовывать.
Если оно переполнит, то он просто говорит: "Окей, берём всё, что вот тут у вас написано, копируем в другое место в памяти и выделяем в два раза больше места".
И получается опять куча свободного места. То есть если у вас, например, было выделено, не знаю, там 100 ячеек, и вы заполнили все 100, то питон просто выделит ещё 200 и скажет: "Окей, 101, 102, заполняйте".
Да, без проблем, там, ну, всё по единичке тратит времени и сил на то, чтобы заполнить новые элементы.
А когда вы переполните выделенную память, он скажет: "Окей, окей, всё, там дальше нельзя".
Дальше ваша память может задевает какие-то другие элементы, которые, например, там операционная система может какие-то куски памяти кушать, ещё что-то такое.
Да, нет, я не буду рассказывать про сейчас инсерты и экстен. Это просто не нужно. Мы пока оставим это на потом.
Это нам сейчас не надо. Мы пока научились добавлять в массив, который раньше состоял из ничего.
Давайте создадим массив, состоящий только из числа 10, и увидим, что для него это тоже прекрасно работает.
Давайте создадим массив, состоящий из вообще ничего, и увидим, что для него это тоже прекрасно работает.
А давайте создадим массив, в котором нет ничего, а потом я в него добавлю число 17 и ещё раз число 17. Получился массив из двух элементов.
Окей, давайте создадим массив, в который я добавлю нуль. Вот это я увидел на экране 0, 1, 4, 9. Почему?
Что произошло, собственно? Можете мне объяснить или не очень? Я взял n равное 4, я запустил цикл 4 in range 40, 1, 2, 3.
И в массив a добавлял числа, которые получаются при возведении i в k. Это 0, 1, 4, 9. То есть я создал массив квадратов.
Окей, давайте я вот так ещё сдвину, и вы увидите, как именно работал a на каждом шаге. Вот так вот.
Давайте n сделаем 10, и мы увидим очень красивую картинку, как массив наполнялся числами прямо по мере того, как мы в него делали эти a.
Окей, плюсик в чат, если эта конструкция понятна, проблем не вызывает. Бахте плюсик в чат, пожалуйста.
Спасибо, есть один плюсик. Прекрасно. Ну, ещё один плюсик, ещё один плюсик. Четыре плюса. Прекрасно, красотища.
Так вот, это зачем было? Сейчас я напишу просто лютый алгоритм поиска максимума среди чётных чисел.
Сейчас вы офигеете. Нет, давайте сначала количество посчитать. Количество чётных чисел в массиве.
Значит, массив, как мы его считываем с клавиатуры, сейчас покажу вот так вот. Всё, массив счита.
Давайте убедимся в этом. Давайте даже не так, в этом убедимся. Давайте вот так убедимся. 10 чисел: 17, 18, 23, 45.
Видите, как массив наполняется? Да, 9, 99, 153. Я добавляю в массив с помощью a, инпуты.
То есть помните, мы на прошлом занятии прошли, как считывает строчку? Как работает inp? Считывает строчку с помощью и переделывает её в число с помощью in.
Как работает строчка с помощью inp? Переделывает её в число с помощью in и добавляет её к массиву с помощью.
Ну, то есть просто такая трёхэтажная. Ну, на самом деле не очень трёхэтажная, довольно простая конструкция.
Да, 18, 2, 100. Готово, понятно? Да, это я просто массив наполнил.
А теперь сделаем кое-что поинтереснее. Поем количество в массиве. Для этого я сейчас заведу ещё один массив b.
А Макс, а вот спрашивает Кирилл, Макс, а выдаст нужный результат или нет? Вот такая вот программа, а функция Макс на массиве ищет максимум в массиве.
Давайте я напишу тест, вы поймёте, почему программа, которую я сейчас написал, не работает. Возможно, Кирилл задумывал что-то другое.
Сразу была про максимум в массиве. А, да, да, про максимум. Ещё раз давайте максимум чётный среди чётных чисел в массиве.
Вот такой вопрос. Вот такая программа тоже в итоге не будет работать. Я хочу максимум с условия.
Сразу вот, короче, смотри, такой тест. Правильный ответ на этом тесте 80. Вот наша программа выдаёт 107.
Почему? Что мы нашли? Просто максимум в массиве без каких-то условий. Как найти максимум в массиве с условиями?
Вот мой вопрос. Максимум в массиве с условиями. Чтобы найти максимум в массиве с условиями, мне нужно, ну, другой массив создать, в который я фильтрую элементы по условию.
Но я же уже теперь знаю, как работает добавление элементов в массив. Поэтому смотрите, я создаю вспомогательный пустой массив, запускаю цикл и говорю: "Если a[i] чётная, то в массив b можно добавить a[i]".
И print получившийся массив b. Даю пять чисел: 107, 80, 45, 40, 13. Массив b состоит только из чётных чисел из массива a.
Как посчитать теперь максимум среди чётных чисел в массиве? Вот так вот. Я выбрал только чётные числа. Плюсик в чат, если это прям кристально ясно, никаких проблем не вызывает.
Вызывает только ощущение лёгкого такого кайфа, да? Понятно? Окей. Можно же сразу максимуме искать.
Так, ещё раз. Нет, смотри, Кирилл, если я просто напишу print max a, такая штука не работает на другом тесте.
Max находит максимум во всём массиве a, не находит максимум среди тех элементов, которые являются чётными.
Или ты имеешь в виду, что раз уж мы так написали, то сразу уж тут можно тогда и сделать типа поиск максимума классический.
Типа раз уж мы такую бяку сделали, да, то мы такие: "Давайте просто тогда добавим a больше m и всё".
Уже, ну как бы и в переменную m сохранять. Че, мы целые массив завели, да? Э, ну да.
Всё, я понял. Без сохранения целого массива. Да, я написал более затратную по памяти конструкцию.
Если там, например, у меня миллион чисел, то кроме миллиона чисел в массиве a мне ещё приходится и миллион чисел в массиве b.
Какая лютая ч. Но если уж мы с вами экономим память по массиву, а тоже не надо тратить.
Вот это всё вообще не нужно. Прочитали число, сразу запустили цикл, переменную a не используем, сразу считываем переменную.
То, что мы сделали в i, сразу с i работаем. Если чётный, то записываем x.
А потом смотрите, я вообще без массивов эту задачу решил. Не потратил памяти даже чуть-чуть.
Ну там, понятно, and сейчас and считанный x больше чем переменная m. Всё, вот я найду чётный максимум по итогу.
Вот, ну не нулю. Да, мы там договорились с вами -10 в 1 делать. Никакого массива я вообще не использовал здесь.
Да, вот понятная конструкция. Вот, но то, что я сейчас показываю, это на самом деле подводок к следующему типу решения задач.
Смотрите, вот эта штука - это на самом деле хитрый трюк. Я взял массив a и фильтрую из него только чётные числа.
И у меня есть теперь массив b, состоящий только из чётных чисел. Я могу с ними сейчас по прикольному всяко поработать.
Например, количество чётных, например, максимум. Да, то есть сейчас задача превратилась просто в простое оперирование с массивом b.
Типа 5, 100, 130, 117, 131 и 48. В итоге массив b состоит только из чисел 100, 130 и 48.
Максимальный из них 130, минимальный из них там 48. Если надо количество - это просто длина массива b.
Так вот, сейчас знайте, к чему я это всё сделаю. Запомните вот так.
Запомнили? Мы сейчас ближе к концу вебка разберём тему под названием генератор. Внезапно.
А только я не буду показывать сами генераторы. Я буду показывать, как эти генераторы уже преобразуются в списочные выражения.
Типа сгенерированные выражения. Это я сейчас сразу просто для душнил поправочка сделал.
А так-то ребята, которые вообще ни разу это слово не слышали, вы сейчас люто кайфандра. Генераторов нужен пристальный взгляд вот в такую вот конструкцию.
Давайте 12 и 20. Вот поставьте плюсик в чат, если из этого кода вам всё стало ясно и выглядит удивительно удобно.
То, что я написал справа от знака равно, это называется генератор. Ну, на самом деле нет, но давайте пока называть это генератором.
Квадратные скобки делают это как бы не генератором, а списочном. Екатерина, рано, вы минус поставили.
Вы посмотрите ещё, посмотрите. Попробуйте перевести с английского на русский слева направо. Прочитайте a равно какому-то там списку.
Какому-то там списку, и в этом списке будут x квадраты для x, перебираю 9, 12, 20.
Так, Камиль поставил плюс. Екатерина тоже поставила плюс. Ну, в принципе, мне хватит на сегодня.
Пока смотрите, значит, ну это x к 4, x in 9, 12, 20. Прекрасно.
А теперь давайте побалуемся, что выведет данная программа. Это к вам вопрос. Надо в чат написать, продемонстрировать, что вы поняли, как работает генератор.
Да, не, не надо писать, да, спасибо. 10, 12, 20. И 21. Ну, только не 12, а 13.
Да, это вы чисто, я надеюсь, опечатали. Я надеюсь, что ошибка такая. Да, 13, хорошо.
10, 13, 21. То есть это будет список из трёх элементов. Эти три элемента получены из элементов 9, 12, 20 путём вычисления формул x + 1.
Хорошо, а давайте ещё что-нибудь посложнее. Вот такая вот программа. Что выведет?
Извините за звуки, просто не могу остановиться. Ручка кручения. Это, к сожалению, такая вот у меня есть привычка.
Может быть, хорошая, плохая, как скажешь, как пойдёт. 91, 88 и 80.
Хорошо, а вот такая вот программа. Что выведет? 100. 100 действительно.
9, 12, 20. Нет, нет, нет, нет. 100. 100, 100. 100.
А, а вот такая программа. Что выведет? Ну, это я уже совсем изю. Обычно так не пишут, но я просто для того, чтобы синтаксис и механику поняли.
И делает. Ну, а будет состоять из чисел 100 для x, перебираю числа 9, 12 и 20.
То есть когда x равен 9, элемент получается равный 100, потому что это тупое выражение. Его даже вычислять не надо.
Когда x = 12, тоже получается 100. И когда x = 20, тоже получается 100.
Там даже не надо делать 100 - x + x, просто 100. Программа просто говорит 100, 100, 100.
Ну, то есть эта программа ничем не отличается от вот такого вот. Это то же самое, тоже 100, 100, 100.
Хорошо, вот такая программа. Что выведет? Подозрительно, очень. Да, ну просто довожу вас в итоге до того, что вот если так написать, то сотен тоже.
Ну, три соточки получится. Вот такая программа, чего выводит? 9120. Действительно, прекрасно.
Хорошо, давайте побольше сделаем. А, ну только давайте это число будет не 138, а 4. Вот так.
Хорошо, и мы вот такую прогу сейчас запустим. Значит, и видим вот такой ответ.
А теперь мы запустим вот такую прогу и посмотрим на неё. И поставьте плюс, если вы поняли, что произошло.
Ну, как-то интуитивно очевидно, да? Приятная конструкция. Правда?
Ну, хорошо. Ну, а теперь, собственно, давайте не забывать модер.
Ну и, например, вот такую вот штуку сделаем. Ну или давай вот такую штуку сделаем.
Вот это сейчас программа для поиска максимального чётного числа в массиве. Создал массив в начале, потом нашёл из него максимальное чётное.
Вторая строчка выбирает из данного нам массива, составляет новый массив, состоящий только из чётных элементов оригинального массива.
Фильтрация происходит прикольно, удобно. Много можно делать с помощью такой конструкции. Дополнять что-то, изменять, вычислять на ходу, что-то там менять и так далее.
Давайте, например, такую вот штуку сделаем. А, смотрите, что произошло интересное. Что я сейчас сделал?
Можете сказать, что во второй строчке произошло? Как-то вот объясните, что там вообще такое было? Чёрная магия?
Да ладно, смотри, доска белая. Я белый, видишь, у меня даже мод для пенспиннинга белый.
Почему чёрная? Это магия белая только. Чат чёрный, и тема в питоне чёрная. Специальное цветовое решение by, потому что это красиво.
На мой взгляд, как говорится, белый - это элегантно. Элегантность. Это я вчера мем увидел первый раз в жизни.
Оказывается, это старый мем. Белый - это элегантность. Вот так перебрали элементы массива и написали каждый дважды.
Да, мы не просто элементы массива перебрали, мы перебрали элементы строки и умножили эти элементы на два.
А что такое элементы строки? Это буквы. Вообще прекрасно. Хорошо, ну давайте ладно.
А 1, 3, 4, 5, 9. Просто разбил строчку от на цифры. Да, давайте поумнее сделаем.
Возьмём число 1, 3, 4, 5, 9, а перебирать будем строчку на основе этого числа.
Давайте назм его. То есть возьмём число, возьмём s, которое будет строчкой числа n и будем перебирать вот эту строчку s по цифрам s.
То есть каждую цифру по отдельности у нас получится массив a. Давайте теперь покруче сделаем.
Давайте цифры переделаем обратно в числа. Теперь это числа 1, 3, 4, 5, 9. А теперь sum.
Что делает данная программа? Спасибо, Айдар! Привет, добро пожаловать, подписывайтесь на канал, всё такое.
Я тут рассказываю какие-то, ну, штуки по проге, что-то объясняю. Что делает данная программа? Объясните вообще, господа и дамы.
Не забывайте подписываться. Когда вы подписываетесь, вы становитесь подписчиками. А подписчик - это звучит гордо.
Тут правда в ВК видео и в этом ВК лайве вместо слова "подписываться" использовать слово "отслеживать". Странная штука, но отслеживайте канал, пожалуйста.
Это позволяет людям потом другим находить этот канал. Я тут, нци, тут всякие геймерские трансляции, ещё что-то такое.
А в категории саморазвития реально немного. Предлагаю привнести побольше саморазвития на площадку.
Что, подписывайтесь, приходите. Люди на стримы, давайте, давайте заставим ВК подсовывать меня в рекомендации.
Люд число в строчку перебирает, строки переводит в числа, выводит сумму этих чисел. Да, да.
Что происходит здесь? Оно переводит, получается, эту строчку числа, переводит в строчку, потом перебирает цифры отдельности в этой строчке.
И в итоге спрашивает: "Ну, сумму всех цифр числа". Называется сумма цифр числа. Прекрасно.
Ну давайте, например, напишем такую программу интересную. n будет не равно какому-то числу.
n будет перебираться for n in range, давайте от нуля до 1000. И давайте вот число. Вот его сумма цифр.
Итак, вспоминаем математику из школы. Признак делимости. А, давайте равно остаточность при делении на 9.
Он звучит следующим образом: число и его сумма цифр дают одинаковый остаток от деления на 9. Напишите программу для проверки этого правила.
Назовём его правило рано остаточности. Проверка будет следующая: берём n процент 9 и берём результат нашей программы.
Это сумма цифр числа, а то есть мы должны сравнить, что n процент 9 равно процент 9. Запускаем и видим, что это всегда так.
Давайте так, если вдруг так сложилось, что n9 не равно процент 9, print "правило нарушено".
И тогда получается, что правила ни разу не нарушены, даже если первый миллион чисел перебрать. Проверили, получается, написали программу для проверки этого правила.
Интересно, прикольно то, что мы сделали это за, ну, то есть сделали это очень быстро. На самом деле вот даже вот здесь надо было написать просто n и не использовать эту штуку.
Да, и на самом деле вот здесь надо было сразу не sum, а писать вот так вот sum вот этого вот всего. Вот так написали и всё.
И это сразу lt, да. На самом деле даже в if надо было сразу вот это запихать вот так вот. Запускаем, ну всё работает.
Да, на самом деле даже это можно было сделать уже сразу генератор. То есть всё вот это вот вычисление, вот этого вот значения, надо было сделать for n in range 1000, например.
Тогда вот это можно убрать, и вот это выражение вычислить, и написать b равно вот этому.
И тогда должно полностью состоять из всех lсов. Правильно? Правильно, правильно, правильно.
Ну, мы тогда тут получается одну штуку сделаем. Да, типа скажем так, если сумма всех элементов равна нулю, давайте скажем, что правило работает.
Запускаем, правило работает. Все элементы равны нулю, сам массив полностью состоит из лсов, одних только лсов.
Делать так, конечно же, не надо. Это ясь. Ние на этом мы закончим этот стрим.
А следующий стрим я буду объявлять в беседе в телеграме. Вступайте в беседу в ТГ, задавайте вопросы и все штуки.
Делайте вообще, учитесь, прога, кодить и так далее и так далее. Вот бесплатный курс по Питону можно забрать по ссылочке в описании.
Вводный курс, научиться кодить, что-то делать. Вот если я понятно объяснял вам на этом видосе, то подумайте, как понятно я объясняю на тех видосах.
Ну, типа так же. Йоу, ты всё поймёшь, будешь вообще с кайфом проходить, изучать прогу, кодить и так далее и так далее и так далее.
Добро пожаловать на канал, обязательно подписывайтесь. Вот, ла трансляции проходят на live.vk.com/vovpython.
Это типа Pon, а вотяков - это моя фамилия. Вот, собственно, я тут веду уроки по Питону. Приходите, всё такое.
Пум, да, добро пожаловать и рад вас видеть всегда. И это мы как бы только начинаем. Это первые вообще стримы на этом канале, и будет просто ор дофига контента.
Дайте, давайте тут ботать прогу. Вот план такой, план капка получается. Я тебя поймал, и ты теперь мой подписчик.
Я надеюсь, это серьёзное заявление. Всё, лайки, да, ставим вообще на всё, на всё лайки ставим.
По жизни лайки ставить не забываем. Всё, пакет, я погнал на со звонк и до новых встреч!