Самый БЫСТРЫЙ стандартный цикл Python − Интеграция с языком Си

⭐ Курс ООП и Приват канал: www.zproger-school.com/?...
⭐ Телеграм канал: t.me/+5MtrfQnCi4Q1Yjlh
В данном видео мы узнаем какой цикл в Python самый быстрый.
Рассмотрим что быстрее: for или while?
Найдем причину и также ускорим циклы по максимуму используя технологии из видео.
📁 Github: github.com/Zproger
📁 Все плейлисты с уроками: bit.ly/39GaY89
📁 Связаться со мной: [e-mail]
📁 Поддержать криптовалютой: github.com/Zproger/donate

[@drimmwald4483]

Хочешь ускорить python, пиши на С, как то так я понял это видео)

[@zproger]

=)

[@Grey_Slime]

Или на ассемблер

[@artemnemcov448]

Видео по ctypes будет круто увидеть! Годный контент, давно была идея объединить с и Пайтон, но казалось сложной затеей, спасибо!

[@m0Ray79]

Welcome to Cython. У меня есть пара видосиков на эту тему.

[@user-di7jx3or6f]

Разница все же небольшая есть в начальных циклах while и for: - в цикле while выполняется увеличение значения переменной "result" на 1 - в цикле for выполняется увеличение значения переменной "result" на значение переменной "num" Другими словами, функции loop1() и loop2() вернут разные значения.

[@chinchita5532]

И в первой функции 2 сложения, когда во второй одно

[@guiterenzog2723]

Тоже не понял, в чем суть. Пару раз пересмотрел, пытаясь понять, что я не так понял. Оказывается, все я правильно понял.

[@01011968Desgner]

@@chinchita5532 + там еще на каждой итерации - операция проверки условия num < value

[@64dusk]

Для получения одинакового значения нужно изменить: num += 1 result += num

[@zproger]

Да есть такое, только сейчас заметил что случайно эту переменную подставил 😐

[@munzamt]

Quick review: самый быстрый способ итерировать в пайтон - не итерировать в пайтон. Ты использовал разные функции: где-то ты считал сумму чисел до ста миллионов, а где-то количество чисел до ста миллионов. Вещи разные, и потому как интерпритатор пайтон, так и компилятор gcc будут по разному оптимизировать код. С большой долей вероятности, gcc съел весь твой цикл, так как увидел константные литералы и цикл по ним, и выдал предкомпилированный ответ.

[@jetbrain9115]

Слушай, реально)

[@Anatolii_V_Novikov]

Да, потому что надо сумму в конце выводить на экран, и тогда он не съест. Плюс не забыть поставить опцию компиляции -O2 :)

[@MihailOnuchin]

Не хватает действительно самого быстрого варианта - суммы арифметической прогрессии )

[@user-hp4xw2oe9t]

Легко делается

[@blackcatdevel0per]

Ещё можно сделать низкоуровневых цикл бинарными операторами(но я в этом особо не шарю 😅)

[@artemetra3262]

@@blackcatdevel0per разве что заменить деление на два на >>

[@Fleshvinn]

Щас бы в первом цыкле увеличивать на 1 а во втором на арефметичческую прогресию ... автор гений

[@Fleshvinn]

ну и далее по тексту: зачем в первом цыкле переменная num если тебе не важна какая итерация - while result

[@artemqqq7153]

Мне кажется в первом цикле он допустил опечатку: он имел ввиду result+=num

[@user-bw5in2yo7s]

Попробуйте return (i * (i - 1)) // 2 Numpy - очень крутая библиотека. Лежит в основе кучи фреймворков для дата-аналитики и ML. Вот только arange(100000000) аллоцирует соответственно бооооольшой блок в памяти. А для быстрых вычислений, кстати, можно ещё Numba или что-то другое с JIT-компиляцией использовать. А если ещё и с распределенными вычислентями на видеокарте... Мммм пушка-гонка))

[@user-yk2zc8vy6u]

Если расскажешь о методах ускорения питона с помощью си это будет огонь! Не знал, что можно писать свои модули на си, теперь появилось много разных мыслей/идей Спасибо!)

[@m0Ray79]

Гораздо проще на Pyrex/Cython. Я рассказал.

[@user-yk2zc8vy6u]

@@m0Ray79 спасибо за инфу, надо изучить)

[@nekomantia]

Спасибо! Про подключение сишных библиотек очень интересно

[@WS_Coder]

Глубокомысленно, хорошо, интересно Спасибо

[@user-kv5oh9ex4f]

В цикле while Вы не вычисляете sum(range(value), Вы только увеличиваете rezult+=1, а в цикле for Вы действительно вычисляете sum(range(value). Сравнение не совсем корректно.

[@SeregaE75]

Хороший контент👍 Спасибо!

[@zproger]

😉

[@stepan109]

Очень нужно видео о том, как передавать/забирать из си переменные в питон

[@ukrainetoday960]

Кидай через файлы)

[@nickolayarbuzov6149]

это очень круто ! спасибо за видео

[@zproger]

😉

[@artemqqq7153]

В первом цикле опечатка (10 строка), вы наверное имели ввиду result+=num чтобы там была прогрессия

[@vlad3c]

Забавное видео, я не знаком с питоном совсем, чего не скажу про си. Так вот разница в них в том, что питон это интерпретируемый язык, а си - компилируемый. И скорость выполнения циклов такая потому что в си есть компилятор и такие циклы он оптимизирует на раз, даже без флага -o3 (максимальная оптимизация), т.е. весь цикл фактически уменьшился до строчки result = value. поэтому время выполнения и занимало 0-1с, никакой магии тут нет. чтобы программа честно пробегала миллион итераций можно добавить спецификатор volatile для переменной result или i, это укажет компилятору, что эта переменная может измениться вне программы и оптимизировать ее нельзя, т.е. программа каждый раз будет вызывать эту переменную из ПАМЯТИ при каждом обращении, что усложняет задачу и сравнивать такой цикл с питоновским неверно, т.к. итераторы скорее всего программа будет держать в регистре, а не в памяти, что так же увеличивает скорость работы программы! И да нет разницы между циклами for и while в целом (на Асемблере) и в частности в си, в самом начале языка Си цикла for не было вообще и не зря надо написать for(;;) чтобы запустить бесконечный цикл, я думаю это типо глобального макроса, который раскрывается в while по итогу, и при переводе на ассемблер команды не меняются ни при for ни при while, меняется лишь "интерфейс" для программиста. Дальше идут мои предположения, не претендующие на истину в 10 инстанции! В питоне разница же происходит, как ты правильно сказал за счет того, что range написан на Си, т.е. на строго типизированном языке, поэтому команды num += 1 на Си и Питоне будут выполняться за разное время, т.к. на Си это всегда переменная определенного типа, а в питоне нет, поэтому под капотом команды num +=1 интерпретатор сначала смотрит что за тип был, какой тип мы плюсуем и выполняет команду и в цикле while он делает это каждый раз для двух переменных num и result, в цикле for он это делает 1 раз для переменной num, и каждый раз для переменной result. Хотя могу ошибаться тут, т.к. питон не изучал...

[@Filmy_HD]

Круто!)

[@vlatterran]

Как сказал ещё mCoding: Самый быстрый способ писать циклы в питоне - не писать циклы в питоне Если вам нужна скорость в питоне - не используйте питон

[@domochevsky4703]

Реально крутые видосы Смотрю с удовольствием

[@master8920]

Написал комент на средине, но когда досмотрел до конца это просто огненно 🔥 Продолжай 👊🤝

[@zproger]

Спасибо 🔥

[@NirrBell]

def loop1(num = value): result = 0 while num: result += num num -=1 return result print(t()) на 28% быстрее вашего whil'a считает

[@vladimirastrelin1719]

круто...спасибо !

[@user-lp1ir6qr2w]

5:50 если совсем коротко, в Си for появился просто для упрощения работы программистов (синтаксический сахар), на деле же грубо говоря это просто обёртка цикла while. Ну, не с помощью LOOP циклы реализовываем, и на том спасибо)

[@c1vgk]

Спасибо за твои видосы, да было бы хорошо посмотреть про библеотеку numpy

[@lllbenderlll]

Цикл фор в си сделай по другому: for(int i=big_num; i; --i){ /*do your stuff*/ } так будет на 10-20% быстрее Все дело в том что на ассемблере у тебя генерится сравнение в виде операции cmp которая автоматически генерит флаг состояния по все видам сравнения (> < и ТД и та) и потом генерится код с необходимым джампом. Если по моему то просто проверка на (не ноль) при флаге -О3. Есть ещё более извратный вариант: for(int i=big_num/4; i; --i){ /*do your stuff 1*/ /*do your stuff 2*/ /*do your stuff 3*/ /*do your stuff 4*/ } for(int i=big_num%4; i; --i){ /*do your stuff*/ } итоговая производительность должна возрасти в 2раза минимум Насчёт ситайпс - сделай. Развлекайся)))

[@user-zg2pf5rt7q]

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

[@Minas__Morgul]

вот прям спасибо!

[@zproger]

😉

[@user-pf3qw1nf6e]

Круто!

[@zproger]

😉

[@artembagachkov933]

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

[@zproger]

😎

[@CalmVideo]

Очень полезно

[@zproger]

Благодарю!

[@Anatolii_V_Novikov]

На С неважно for или while, все примерно одинаково работают по скорости выполнения. Но чтобы на С корректно замерить время выполнения цикла, надо итоговую сумму в конце вывести на экран, тогда компилятор сделает честный код. При этом важно поставить опцию компиляции -O2 (можно и -O3). Однако, если у Вас простейший инкремент, то умный компилятор может свернуть его самостоятельно вне зависимости от вывода результата на печать :) Возможно, лучше тестировать сумму арифметической прогрессии, чтобы компилятор не смог распознать зависимость. На С/С++ легко наступить на грабли и требуется некоторое время на составление корректного теста.

[@user-pg8ry1tm3t]

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

[@user-yi5vj9kn5s]

Если посмотреть итоговое значение, которое выдаётся при использовании цикла с модулем Numpy, то оно отличается от того, что выдают первоначальные (имеются ввиду циклы в которых рассматривается именно арифметическая прогрессия), если понизить число итераций со 100000000 до 10000, то всё будет работать так как задумывалось автором изначально. Такие вещи нужно проверять на практике, а не слепо верить, что показанный вам материал в подобных видео, будет работать как часы.

[@kozlovsg70]

Точно, по умолчанию он считает элементы int32 поэтому у него будет происходить переполнение НО при этом никаких ошибок не выходит. Чтоб правильно считалось нужно записать так numpy.arange(100_000_000, dtype=numpy.int64) время при этом практически не меняется. Но это не единственная проблема, смотри мой самый свежий комментарий.

[@zluka7951]

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

[@zproger]

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

[@predatel_rodini]

Если работаешь с питоном на работе то конечно пайчарм выручает. Особенно прошка

[@howl3440]

да кстати у питона есть API для С поэтому можно что-то написать на С а потом использовать в питоне благодаря чему некоторые библиотеки фреймворки написаны на C, C++ а какая у тебя тема в VS code? понравилась довольно приятная

[@zproger]

Тема: Dracula. На счет Си это да, важные компоненты можно на нем писать, особенно тот код, который надо защитить.

[@howl3440]

@@zproger благодарю

[@stupiddudelive1893]

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

[@darksniper407]

Так или иначе полезная инфа Помню о numpy с ML, но в таких скоростях нет необходимости)

[@Iva666ka]

Вывод времени ровно 0 секунд или ровно 1 секунду или ровно 2 секунды намекает, что код обрабатывает разницу между промежутками времени как int, поэтому точность измерения до 0,9(9) секунд.

[@Legantmar]

спасибо интересно. сравнил у себя Python 3 loop1 - 7.2 loop2 - 4.5 Python 2.7.18 loop1 - 5.5 loop2 - 9.8 loop2 - 8.2 (если вместо range использовать xrange) IronPython 2.7.3 loop1 - 4 loop2 - 9 (если вместо range использовать xrange)

[@rokot]

Сравнил с PyPy, у меня первый цикл выполняется практически мгновенно loop1: 0.1593255. Ведь "PyPy is 4.5 times faster than CPython"

[@glebgurzhiy1055]

Невероятно крутой видос

[@MrVovak85]

Отличное видео👍 Жду Numpy

[@zproger]

😉

[@Alcoholdehydrogenas]

Я не силен в программировании, но вроде как функции loop1 и loop2 вернут разные значения. О каком сравнении идет речь? И какой линукс используется?

[@mrd_a_r_kcode494]

Интересно видео 100% нигде его не видел:)

[@user-us8de9yk2c]

Неоднозначное видео. Автор, естественно, не врёт, особенно если понять, что во второй функции просто небольшая опечатка. Там нужно убрать у result += num знак плюса, вы получите похожие значения. Т.е. название видео полностью оправданно, при работе с пайтоном нужно помнить, где можно сэкономить время. Но с другой стороны важно понимать принципиальную разницу двух циклов. В данной ситуации вы просто пытаетесь использовать цикл while взамен цикла for. Однако они имеют разное значение в программировании. While изначально не подразумевает работу с такими большими значениями, и он работает непосредственно с true и false, т.е. входные параметры можно сделать любые, сравнивать хоть текст, хоть логическое, хоть цифру. А цикл с параметром изначально задуман как счётчик. Можно ли заменять эти циклы друг другом? Да. Но зачем? В теории можно ходить на руках и брать ногами вилку. Но есть ли в этом смысл? Не думаю.

[@mndtr0]

2:15 Увы это совсем не образно : (. Отличный видос и информация полезная! А что у вас за дистрибутив стоит?

[@ZA_CCCP]

Привет. Можешь рассказать зачем нужен файл __init__.py ?

[@m0Ray79]

Настоящая интеграция с C - это Pytex/Cython. Питоновский код транслируется в C и компилируется gcc, а синтаксическое надмножество Pyrex имеет плюшки вроде статической типизации, структур и указателей.

[@a.osethkin55]

Спасибо

[@zproger]

😉

[@Hahal85]

Извините за тупой вопрос (не давно начал изучать Пайтон), но как поставить стрелочку, в место "->"

[@serafimgrubas2070]

Замеры скорости работы функции в С вызывает большие сомнения, неужели она выполняется ровно 1 сек или 2 сек с точностю до 6 знака? Там ведь что-то точно округляется, и невозможно сравнить скорость с суммой из Numpy. А в целом, я думаю было бы круто ещё сравнить с Just-In-Time compilation из библиотеки Numba.

[@01in93]

Да, в C можно сделать так: #include #include clock_t begin, end; double elapsed; begin = clock(); /* Код, время выполнения которого мы хотим замерить */ end = clock(); elapsed = (double)(end - begin) / CLOCKS_PER_SEC; printf("Elapsed %lf sec ", elapsed);

[@predatel_rodini]

Блин. Вот это реально полезное видео. Хотя конечно если твой сервис начинает нуждаться в таком то походу твоя программа спроектирована как-то не правильно.

[@zproger]

Ну бывают разные задачи, в некоторых моментах без такой либы на Си будет трудно

[@rokot]

Почитал новости, оказывается, началась работа над ускорением CPython. Версия 3.11 будет в разных случаях от 10% до 60% быстрее, чем 3.10. Что было сделано: 1) Faster Runtime. 2) Inlined Python function calls 3) Specializing Adaptive Interpreter Собираются в течение пару лет прикрутить JIT, что уже сделано на PyPy

[@user-hk4bq8be1d]

Поигрался с циклами, действительно Пи очень медленный, и на нем еще написано большинство современного софта ( ( .. Придется С вспоминать) Спасибо за gcc

[@rpstudio-9455]

Привет, как обновить питон в Zorin OS 16?

[@hawchik6921]

расскажи про cython и формат файлов .pyx

[@MrPyps11]

Python написали что бы не писать на С, а давайте писать на С - Python медленный 😅

[@kozlovsg70]

Маленькое дополнение по NumPy после моих экспериментов с ним: 1. У автора вычисляется НЕ верная сумма, т.к. он использовал arange по умолчанию, а по умолчанию он считает элементы int32 поэтому у него будет происходить переполнение НО при этом никаких ошибок не выходит. Чтоб правильно считалось нужно записать так numpy.arange(100_000_000, dtype=numpy.int64) время при этом практически не меняется. 2. У всего есть цена и у arange она тоже есть, и это то что в отличии от range он СОЗДАЕТ ВЕСЬ массив в памяти, т.е. все эти 100 миллионов элементов! Когда я попытался создать больший массив на 10 миллиардов он вывел ошибку что памяти не хватает и нужно 74Гб оперативки!!! Кстати 70% времени работы уходит на создание этого массива, само суммирование за остальные 30%. Т.е если бы не создавался массив, можно было бы в 2 раза еще ускорить, но я не знаю возможно ли это в NumPy,. Это точно не numpy.sum т.к. он ждет на вход только массив.

[@kozlovsg70]

уточнение: numpy.sum берёт объект range() и память при этом не захватывает, но и работает примерно тоже время что цикл for, т.е. в 30 раз медленнее.

[@kozlovsg70]

NumPy в данном случае не подходит, а вот использование numba даёт просто колоссальное ускорение. Тот же цикл ускорился так что не фиксируется таймером, пришлось поставить 4_000_000_000 и summa считать во float, только тогда время выполнения стало 0.3 секунды. Память вообще не расходуется.

[@user-fk2cq4ff4k]

Видео крутое.!

[@lmaootakedh]

спс, полезно

[@zproger]

Спасибо

[@Sadownick]

Жаль, что можно поставить только один лайк 👍

[@zproger]

Действительно жаль =) Спасибо

[@sergo5918]

если в первом случае в def loop1() убрать (не нужный) result+=num то скорость сравняется со вторым вариантом, где используется range более того, если в def loop2() нагрузить первым бессмысленным действием (result+=num) то и скорость выполениея с range будет примерно такой же как и без range вывод : первые два примера имеют разницу в быстродействии аж 13% ( что имхо малосущественно ), остальные ещё не смотрел, но по общему мнению(что тоже требует проверки) numpy быстрее обычного питона на порядок, что уже существенно

[@APfOHx5Q]

В си (или си++) можно реализовать блок через ассемблер и будет ещё быстрей😀

[@zproger]

это да)

[@darksniper407]

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

[@kutsokon]

Видео крутое и очень информативное! Только почему нельзя было вывести точное время выполнения в C, а не округлять?

[@vlad3c]

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

[@blowyourbra1n233]

привет, подскажи пожалуйста, что это за стрелочки после функции? для чего они нужны и как их писать?

[@andrewantoniuk525]

Это называется тайп хинты (type hint). Они нужны чтобы подсказать програмисту и среде разработки какой тип данных возвращает данная функция. Чисто для удобства существует. Записывается: def my_function() -> :

[@predatel_rodini]

@@andrewantoniuk525 используется не только для удобства. Также можно линтером проверить типы перед коммитом например. А fast api например по ним тебе автоматически генрит документацию сваггер. Но да, сами хинты на содержимое объектов никак не влияют к сожалению.

[@andrewantoniuk525]

@@predatel_rodini ну это уже немного дебри. Я объяснил поверхостно и просто

[@mammadalimammadaliyev6105]

Где-то я видел это видео)

[@zproger]

😉

[@dazzle529]

Попробовал с Go (просто цикл, без какой либо оптимизации) 100 000 000 - 42 ms 1 000 000 000 - 318 ms

[@rokot]

В PyPy первый луп ещё быстрее 15 ms

[@aleksandrdemidov6058]

Хочу ctype! ) и если можно написание библиотек на Си для питона?

[@AlexandrSpirit]

Си конечно мощно. Но проще всё же на Rust ускорить пайтон. За два года коммерческой разработки бекенда, ни разу не потребовались мощные вычисления в коде. Всё до боли банально - достать из БД или положить/обновить в БД запись. Хотя. Если в главном сервисе делать агрегацию данных, т.е. полученные по шине данные из разных сервисов сложить в один json, то наверное можно и написать на Си/Раст. П.С. Была задача по расчету количества потомков у животного до 4 колена. Но это нереально делать в коде, т.к. 5млн записей в БД занимает много места. Получить запросом и обработать не выйдет. Тут опять же нужно на SQL делать. В общем, непонятно где может пригодиться.

[@user-rh4fe2ce1d]

🔥

[@zproger]

😉

[@nazarmakarenko-games5855]

А какой у вас Linux? Крутой видос

[@zproger]

Zorin OS

[@nazarmakarenko-games5855]

@@zproger спасибо:)

[@bairshirapov3449]

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

[@dsShadega]

Измерения через функцию time() в С или C++ некорректны, т.к. точность этого метода только лишь до секунды. Нужно использовать более точные функции, а не time(). Т.к. у Вас какая-то linux образная ОС, то можно было бы использовать clock_gettime(). Ну либо стандартную clock() уже... А то, что у Вас получалось либо 0 либо 1 секунда, то это лишь потому, что момент запуска совпадал с переходом с предыдущей секунды на следующую...

[@toktarov1984]

кроме numpy ещё numba увеличивает скорость :)

[@zproger]

Это да, но для неё отдельное видео =)

[@valarg5756]

Ждём новое видео

[@zproger]

😉

[@rexby]

Чтобы посмотреть время работы программы, можно запускать так: time ./main. И тогда не нужно это реализовывать в коде.

[@zproger]

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

[@rexby]

@@zproger Да, выводит время работы программы. Но если программа состоит из одной функции, то получится то, что надо.

[@gilman2056]

Все очень интересно, но ничего не ясно. Так по видео же сравнивается арифмитические операции суммировани, а не сами циклы как таковые. Допустим какая польза мне от sum() если мне нужно перебрать словарь? А вот видос как прикрутить C к python для ускорения будет полезно

[@eugenex8892]

Тыщу лайков, хмм... ну лан лайкану, мне понравился хинт что в питоше можно int записать как 100_000_000.. Я не очень знаю питон, но отлично знаю Си. По поводу numpi скажу, что стоило-бы проверить ещё ударную по потокам процессора... Сисадмины очень часто жалуются на эту либу что она глушит процак. Итерация с сложением в Си скорее не милисикунды, скорее всего это наносекунды. В конечном итоге это скорее всего 8 команд асемблера, что для процессора вообще раз плюнуть.

[@zproger]

Благодарю, полезная информация

[@user-ry5oh3qt2u]

Самый лучший способ оптимизировать pyton программу-написать ее на С++

[@zproger]

🤔

[@0xsadcat92]

Спасибо автору, всегда ненавидел питон, любил С++, теперь понял что ошибался, видно грамотного человека

[@user-lp1ir6qr2w]

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

[@user-ni9oh7en4d]

Какой плагин используется для такой темы?

[@zproger]

Material UI

[@degree777]

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

[@zproger]

Благодарю!

[@invisinotofficial]

Мало кто знает, но самый быстрый способ выполнить программу в питоне - это не использовать питон, а перейти на что-то более менее адекватное.

[@zproger]

🤔

[@MDFireX5]

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

[@fedor_ado]

Видео о ctypes нужно.

[@zproger]

Ок, сделаю =)

[@johannesgarin6559]

А теперь давайте представим, что есть такая библиотека, как numba и попробуем воспользоваться её функцией njit, в роли декоратора. import timeit import numpy as np from numba import njit value = 100_000_000 def loop1(num=0, result=0) -> int: while num < value: result += num num += 1 return result def loop2(result=0) -> int: for num in range(value): result += num return result def loop3() -> int: return sum((num for num in range(value))) def loop4() -> int: return sum([num for num in range(value)]) def loop5() -> int: return sum(range(value)) def loop6() -> int: return np.sum(np.arange(value)) @njit def loop7(num=0, result=0) -> int: while num < value: result += num num += 1 return result @njit def loop8(result=0) -> int: for num in range(value): result += num return result print(f"loop1: {timeit.timeit(loop1, number=1)}") print(f"loop2: {timeit.timeit(loop2, number=1)}") print(f"loop3: {timeit.timeit(loop3, number=1)}") print(f"loop4: {timeit.timeit(loop4, number=1)}") print(f"loop5: {timeit.timeit(loop5, number=1)}") print(f"loop6: {timeit.timeit(loop6, number=1)}") print(f"loop7: {timeit.timeit(loop7, number=1)}") print(f"loop8: {timeit.timeit(loop8, number=1)}")

[@user-uo6rq1bl5g]

А возможно ли запустить файл питон из другого файла на питоне У меня есть проект игры в которой файлы отделены Код меню отдельно Сама игра отдельно Типо сделать чтобы можно было из меню запустить саму игру по нажатию кнопки P.S Или ООП

[@pr1t349]

import + название файла

[@RuslanKovtun]

7:16 - а если компилировать с флагом оптимизации `-O3` весь цикл сворачивается в формулу. Цикл на 1е15 итераций отрабатывает за 3мс (время запуска, выполнения и завершения программы с выводом результата в консоль). Куда интересней просуммировать последовательность, как в python `sum(range(10**8))`, т.е. `sum += num` а не `sum++`.

[@user-vb9qg4vl1k]

Такое `-O3` тоже свернет в num * (value * (value + 1)) >> 1. Автор, изучи, пожалуйста, опции оптимизации gcc прежде чем бенчмаркать! Используемый метод time имеет точность в секунду, вы не могли не заметить этого, так что замеры там практически бесполезны, можно использовать clock(), в C++ есть вариант получше -- std::chrono

[@user-yo8pq8mu6k]

сто пудовый лай и коммент

[@joehart7382]

теперь понятно как комбинировать 2 языка)

[@zproger]

Это да =)

[@elkins87]

Для чего стрелочки "-> int"в функции loop? Без них функция будет работать по-другому?

[@hilline6394]

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

[@loafius]

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

[@guiterenzog2723]

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

[@MakarenkoSasha]

может тогда в с++ кое-что писать на python

[@zproger]

Можно и так :D

[@nichtverstehen2045]

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

[@zproger]

🤔

[@DepechLyot]

Итерацью на префиксную, не происходит копирования переменной.

[@Alpha_Gamma_Beta]

а на ассемблере будет быстрее?

[@zproger]

Да

[@SoundScape_Hub]

Хз якщо щось довго працює то паралельте процеси або векторизацію використовуйте як у відео якщо довго то проще динамічну компіляцю використовувати там не потрібно знати сі просто одна комада і все якщо ще заморочитися то можна статичну компіляцію зробити тоді сі потрібно знати а так кобінуйте методи стадартно пишете функцію яка рахує щось через векторизацію яка розпаралелена на 4 потока і якщо часто визиваєця компілюєця якщо рекурсії багато то декоратори ставите ще

[@sim9797]

++i работает быстрее i++, ошибка получается

[@vano03voin]

Хочу гайд по num py

[@Salomon_li]

Го видос про numpy!!!!

[@user-eo9td2bj5q]

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

[@geri_freki]

import numpy as np

[@zproger]

=)

[@omcs8996]

А, чтобы Пито работал быстрее нам нужно использовать С… ок

[@MrStockgolm]

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

[@zproger]

Так и сделаю в след.видео, спасибо