<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Артур Хайбуллин on Medium]]></title>
        <description><![CDATA[Stories by Артур Хайбуллин on Medium]]></description>
        <link>https://medium.com/@arturbro97?source=rss-57dbe1752d71------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*T0Ca6LVodVZEKyo-</url>
            <title>Stories by Артур Хайбуллин on Medium</title>
            <link>https://medium.com/@arturbro97?source=rss-57dbe1752d71------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 23:58:37 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@arturbro97/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Как в два счета сделать сайт редактируемым извне с помощью данных Google Sheets]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B2-%D0%B4%D0%B2%D0%B0-%D1%81%D1%87%D0%B5%D1%82%D0%B0-%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C-%D1%81%D0%B0%D0%B9%D1%82-%D1%80%D0%B5%D0%B4%D0%B0%D0%BA%D1%82%D0%B8%D1%80%D1%83%D0%B5%D0%BC%D1%8B%D0%BC-%D0%B8%D0%B7%D0%B2%D0%BD%D0%B5-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-google-sheets-46f5ac4be8cc?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/46f5ac4be8cc</guid>
            <category><![CDATA[google-sheets]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Sun, 07 Mar 2021 12:01:08 GMT</pubDate>
            <atom:updated>2021-03-07T12:01:08.717Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/533/0*6ylnCKGEfvTVLi53.png" /></figure><p>Как-то раз заказчики спросили меня, можно ли сделать так, чтобы события и ярмарки на их сайте мгновенно обновлялись. Сегодня я могу сказать: «Да, и все будет интегрировано с деловой документацией в Google Spreadsheets».</p><p>Цель этого руководства — показать, как сделать некоторые части сайта легко редактируемыми вашими технически не подкованными коллегами или клиентами. Готовы? Поехали!</p><h3>Приступим</h3><p>Первым делом нужно… <a href="https://spreadsheet.new/">создать Google таблицу</a>! В ней должна быть одна строка заголовка (текстовое содержимое ее потом будет использоваться для визуализации данных) и строки с данными. Используем любой формат ячеек (текст, цифры, даты, валюты, выпадающие списки, флажки и т. д.). Подойдут даже URL-адреса (ссылки или фото), которые будут отображаться в HTML. Вот пример:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*GXoUU_lR_Om7Ihk2.png" /></figure><p>После этого жмем на кнопку <strong>Share </strong>(«Поделиться») и в разделе <strong>Get link</strong> («Получить ссылку») нажимаем на <strong>Change to anyone with the link</strong> («Изменить на всех, у кого есть ссылка»), чтобы включить открытый доступ для чтения к таблице. Затем копируем ссылку на таблицу.</p><h3>Добавим websheet.js к сайту</h3><p>Для отображения данных таблицы на сайте будем использовать автономную и легковесную библиотеку JS с открытым исходным кодом <a href="https://websheet.js.org/">websheet.js</a>. Ее нужно просто импортировать:</p><pre><em>&lt;!-- Импортируем websheet.js --&gt;</em><br>&lt;script src=&quot;//cdn.jsdelivr.net/gh/pierreavn/websheetjs/dist/websheet.min.js&quot;&gt;&lt;/script&gt;</pre><pre><em>&lt;!-- Конфигурация Websheet.js --&gt;</em><br>&lt;script&gt;<br>  websheet(&#39;products&#39;, {  <em>// &lt;-- имя источника данных</em></pre><pre>    <em>// URL-адрес таблицы</em><br>    url: &#39;https://docs.google.com/spreadsheets/d/1enj8u4b7WA4Itrw8u5YEzt8MzwtRD1GkJNSWkl9GMK0/edit#gid=0&#39;,</pre><pre>    <em>// Название вкладки таблицы, в которой находятся данные</em><br>    sheet: &#39;Products&#39;,<br>    <br>    <em>// Определяем вновь вычисляемые столбцы на основе имеющихся.</em><br>    <em>// В приведенном ниже примере псевдоним столбца Bread? true для</em><br>    <em>// всех строк, в которых значение столбца Category («Категория») равно Breads («Хлеб»)</em><br>    <em>// (row — это объект, содержащий все данные текущей строки).</em><br>    aliases: {<br>        <em>// &#39;Bread?&#39;: row =&gt; row[&#39;Category&#39;].value === &#39;Breads&#39;,</em><br>    }</pre><pre>  })<br>&lt;/script&gt;</pre><p>После импортирования websheet.js задействуем инициализатор websheet, который принимает два параметра:</p><ul><li>Первый(products) — это имя источника данных. Если вызывать инициализатор websheet неоднократно, то для каждой таблицы надо будет использовать разные имена источников данных.</li><li>Второй параметр — это конфигурация источника данных <strong>(замените значения </strong><strong>url и </strong><strong>sheet своими)</strong>.</li></ul><p>Мы задействовали самый полезный функционал библиотеки. Есть здесь также и много другого, например кэширование, колбэки, запросы (для фильтрации, сортировки и группировки строк) и т. д. Загляните в <a href="https://websheet.js.org/documentation.html">документацию</a>: там все это приводится.</p><h3>Визуализируем данные таблицы</h3><p>Заключительный этап — визуализация данных таблицы, которые мы только что загрузили! Добавляем визуализацию источников данных в любом месте страницы сайта:</p><pre><em>&lt;!-- Этот блок будет дублироваться для каждой строки источника данных products («Продукты») --&gt;</em><br>&lt;div data-websheet=&quot;products&quot;&gt;</pre><pre>    <em>&lt;!-- Отображается только в том случае, если флажок True.<br>         В рассмотренном ранее примере с псевдонимами<br>         используется &lt;div data-websheet-if=&quot;Bread?&quot;&gt; --&gt;</em><br>    &lt;div data-websheet-if=&quot;Display ?&quot;&gt;</pre><pre>        <em>&lt;!-- Отображается значение столбца Product («Продукт») --&gt;</em><br>        &lt;div data-websheet-text=&quot;Product&quot;&gt;&lt;/div&gt;</pre><pre>        <em>&lt;!-- Значение столбца Picture («Изображение») привязывается к атрибуту src --&gt;</em><br>        &lt;img data-websheet-bind:src=&quot;Picture&quot; /&gt;</pre><pre>    &lt;/div&gt;</pre><pre>&lt;/div&gt;</pre><p>В этом примере было использовано несколько средств форматирования:</p><ul><li><strong>data-websheet=&quot;</strong>&lt;dataSourceName&gt;<strong>&quot;</strong>Определяет блок, который будет дублироваться и визуализироваться для каждой строки источника данных.</li><li><strong>data-websheet-if=&quot;</strong>&lt;columnName&gt;<strong>&quot;</strong><br>Отображает элемент только в том случае, если ячейка содержит отмеченный флажок или если это псевдоним, возвращающий true (противоположный эффект будет с data-websheet-unless).</li><li><strong>data-websheet-text=&quot;</strong>&lt;columnName&gt;<strong>&quot;</strong><br>Заполняет текст элемента значением ячейки.</li><li><strong>data-websheet-bind:</strong>&lt;attributeName&gt;<strong>=&quot;</strong>&lt;columnName&gt;<strong>&quot;</strong><br>Заполняет значение данного атрибута значением ячейки, например:<br>&lt;img data-websheet-bind:src=&quot;Picture Column&quot; /&gt;<br>&lt;a data-websheet-bind:href=&quot;Link&quot; data-websheet-bind:text=&quot;Link Text&quot;&gt;&lt;/a&gt;</li></ul><p>После загрузки websheet.js блок будет дублироваться и визуализироваться для каждой строки таблицы:</p><pre>&lt;div&gt;<br>  &lt;div&gt;<br>    &lt;div&gt; Baguette &lt;/div&gt;<br>    &lt;img src=&quot;https://www.boulangerielangelus.com/wp-content/uploads/2015/09/BAGUETTE-CAMPAGNE_ss-ombres-1024x683.png&quot; /&gt;<br>  &lt;/div&gt;<br>&lt;/div&gt;<br>&lt;div&gt;<br>  &lt;div&gt;<br>    &lt;div&gt; Olive Bread &lt;/div&gt;<br>    &lt;img src=&quot;https://www.boulangerielangelus.com/wp-content/uploads/2015/08/CAMUSETTE-OLIVES-01-1-1024x683.png&quot; /&gt;<br>  &lt;/div&gt;<br>&lt;/div&gt;...</pre><p>Опять же задействован самый полезный функционал библиотеки, но есть и много другого: шаблоны, состояния (загрузчики и ошибки) и т. д. Загляните в <a href="https://websheet.js.org/documentation.html">документацию</a>: там все это приводится.</p><h3>Заключение</h3><p>Нам удалось в два счета сделать сайт редактируемым извне: любое изменение в таблице сразу же отображается на сайте. Красота!</p><p>Весь пример/демоверсия вместе с задействованным функционалом <a href="https://websheet.js.org/demo.html">доступен здесь</a> (это меню пекарни). Попробуйте сделать из этого что-то свое, используя рассмотренный функционал и добавляя новый.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*wFBxOPwnjd5XOSGG.png" /></figure><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/8563/">Воссоздание графика вклада GitHub с помощью Flask и Google Sheets</a></li><li><a href="https://nuancesprog.ru/p/10958/">Перевод любого приложения Vue.js за час</a></li><li><a href="https://nuancesprog.ru/p/10210/">Как перейти от Flask к FastAPI</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesproghumor">Telegram</a>, <a href="https://vk.com/nuancesprog">VK</a> и <a href="https://zen.yandex.ru/nuancesprog">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://medium.com/@pierre.avinain?source=post_page-----96cb23d220a6--------------------------------">Pierre A.</a>: <a href="https://codeburst.io/turn-your-website-editable-in-a-snap-by-your-team-using-google-sheets-data-96cb23d220a6">Turn your website editable in a snap by your team using Google Sheets data</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46f5ac4be8cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B2-%D0%B4%D0%B2%D0%B0-%D1%81%D1%87%D0%B5%D1%82%D0%B0-%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C-%D1%81%D0%B0%D0%B9%D1%82-%D1%80%D0%B5%D0%B4%D0%B0%D0%BA%D1%82%D0%B8%D1%80%D1%83%D0%B5%D0%BC%D1%8B%D0%BC-%D0%B8%D0%B7%D0%B2%D0%BD%D0%B5-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-google-sheets-46f5ac4be8cc">Как в два счета сделать сайт редактируемым извне с помощью данных Google Sheets</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Простыми словами о рекурсии]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%BC%D0%B8-%D1%81%D0%BB%D0%BE%D0%B2%D0%B0%D0%BC%D0%B8-%D0%BE-%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B8-61e12c344a41?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/61e12c344a41</guid>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Sat, 19 Dec 2020 16:03:37 GMT</pubDate>
            <atom:updated>2020-12-19T16:03:37.855Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*a1tBPMSQChO4X8Yv.png" /></figure><p>В программировании <strong>рекурсия</strong>, или же рекурсивная функция — это такая функция, которая вызывает саму себя.</p><p>Рекурсию также можно сравнить с матрёшкой. Первая кукла самая большая, за ней идёт точно такая же кукла, но поменьше. Суть матрёшки состоит в том, что вы можете открывать её и доставать из неё точно такую же куклу, только немного меньше. Такой продолжительный процесс длится до тех пор, пока вы не дойдёте до последней куклы, которая и прервёт цикл. Так выглядит визуальная репрезентация рекурсии.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*zqiIc2epyEfGXgOG" /><figcaption>Матрёшка — Gif Tenor</figcaption></figure><h3>Не приведёт ли рекурсивная функция к бесконечному циклу?</h3><p>Да, такой исход вполне возможен. Однако, как и у функции for или while, рекурсию можно прервать условием break, чтобы функция перестала вызывать саму себя.</p><p>Вот пример кода того, как можно реализовать функцию обратного отсчёта с использованием рекурсии:</p><pre>function countDown(n){<br>console.log(n)</pre><pre>if(n &gt; 1){<br>    countDown(n -1) <em>// вызов рекурсии</em><br>} else {<br>    return true <em>// основное действие</em><br>  }<br>}<br>countDown(5)</pre><pre><em>// 5</em><br><em>// 4</em><br><em>// 3</em><br><em>// 2</em><br><em>// 1</em><br>countDown(-1)<br><em>// - 1 </em></pre><pre><em>// true</em></pre><h4>Как прервать рекурсию:</h4><p>Допустим, у нас имеется функция CountDown, которая принимает аргумент (n). Чтобы реализовать обратный отсчёт, нам следует повторить последовательность действий, понижающих значение параметра. Создадим условие вида:</p><p><em>Если </em><em>(n) больше </em><em>1, то вызвать функцию </em><strong><em>CountDown</em></strong><em>и вернуться в начало цикла, затем вычесть единицу и снова проверить, выполняется ли условие </em><em>(n) &gt; 1.</em></p><p>По умолчанию нам нужно создать <strong>базовое условие </strong>функции, возвращающее значение true, чтобы предотвратить попадание в бесконечный цикл. Базовым условием функции здесь будет условие о том, что любое значение больше 1 не вызовет прерывание цикла.</p><p>Проще говоря, рекурсия делает то же, что и код ниже:</p><pre>countDown(5)<br> countDown(4)<br>  countDown(3)<br>   countDown(2)<br>    countDown(1)<br>    return<br>   return<br>  return<br> return<br>return</pre><h3>Плюсы и минусы рекурсивных функций</h3><p>Чтобы правильно описать плюсы и минусы, давайте взглянем на производительность рекурсии.</p><h4>Плюсы:</h4><ul><li><strong>Рекурсивный код снижает время выполнения функции.</strong></li></ul><p>Под этим подразумевается, что рекурсии, в сравнении с циклами, тратят меньше времени до завершения функции. Чем меньше строк кода у нас будет, тем быстрее функция будет обрабатывать вызовы внутри себя. Особенно хорошо это проявляется при буферизации данных, что позволяет оптимизировать и ускорить код.</p><p><em>В программировании </em><strong><em>мемоизация </em></strong><em>— это метод сохранения результатов выполнения функций для предотвращения повторных вычислений. Это один из способов оптимизации, применяемый для увеличения скорости выполнения программ. — </em><a href="https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D0%BC%D0%BE%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F"><em>Википедия</em></a></p><p>И всё же стоит отметить, что рекурсия не всегда выигрывает по скорости по сравнению с циклами.</p><ul><li><strong>Рекурсию легче отлаживать.</strong></li></ul><p>Многие согласятся, что эта причина очень важна. Рекурсия проста в отладке из-за того, что она не содержит сложных и длинных конструкций.</p><h4>Минусы:</h4><ul><li><strong>Рекурсивные функции занимают много места.</strong></li></ul><p>Рекурсивные функции занимают значительный объём памяти во время своего выполнения. Это означает, что при каждом вызове функции в стек будет добавляться новый элемент, который будет занимать место до тех пор, пока функция не завершит работу, найдя ответ, либо пока не дойдёт до выполнения базового условия функции.</p><ul><li><strong>Рекурсивные функции замедляют программу.</strong></li></ul><p>Несмотря на то, что уже было сказано про мемоизацию, наш код можно ускорить, если применить циклы for или while. Помимо того, что функция может быть попросту плохо написана, мы также рискуем переполнить стек, что в конечном итоге приведёт к снижению скорости и программным ошибкам.</p><h3>Что такое «стек»?</h3><p>Стек — это такая структура данных, которая работает по принципу «Last In, First Out» (последним пришёл — первым ушёл). Таким образом, элемент «проталкивается» в стек и добавляется в его конец, а затем «выталкивается» из стека при удалении.</p><p>Стеки замечательны тем, что они очень быстрые. Большое «О» этого алгоритма равно O(1). Такая результативность объясняется тем, что при рекурсиях не используются циклы, вместо них используются функции pop(), push() и empty().</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*ilwY5Yf2pa9310BX.gif" /><figcaption>Визуализация стека</figcaption></figure><h3>Стоит ли использовать рекурсии вместо обычных циклов?</h3><p>Оба этих метода одинаково эффективны для решения задач, однако выбор одного из них зависит от типа проблемы, поставленной перед вами.</p><p>Рекурсии эффективны тогда, когда вы работаете с данными, которые слишком сложны, чтобы пройтись по ним с помощью обычных циклов. Стоит также не забывать о ценности памяти и уменьшении времени, идущем вкупе с рекурсивной функцией, в которой накопилось слишком много элементов.</p><p>Циклы так же эффективны в плане скорости и оптимизации, они занимают меньше памяти в стеке и их легче понять, потому что в теле цикла содержится больше информации о том, что происходит внутри.</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/10274/">Как освоить алгоритмы?</a></li><li><a href="https://nuancesprog.ru/p/3738/">Алгоритмы машинного обучения простым языком. Часть 1</a></li><li><a href="https://nuancesprog.ru/p/10826/">4 принципа успешной поисковой системы и не только</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesproghumor">Telegram</a>, <a href="https://vk.com/nuancesprog">VK</a> и <a href="https://zen.yandex.ru/nuancesprog">Яндекс.Дзен</a></p><p><em>Перевод статьи</em> <a href="https://medium.com/@agreen17">Akiko Green</a>: <a href="https://medium.com/nerd-for-tech/recursion-but-make-it-simplified-bee0a73cc4d3">Recursion!… But Make It Simplified</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61e12c344a41" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%8B%D0%BC%D0%B8-%D1%81%D0%BB%D0%BE%D0%B2%D0%B0%D0%BC%D0%B8-%D0%BE-%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B8-61e12c344a41">Простыми словами о рекурсии</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[7 трюков pandas для науки о данных]]></title>
            <link>https://medium.com/nuances-of-programming/7-%D1%82%D1%80%D1%8E%D0%BA%D0%BE%D0%B2-pandas-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%83%D0%BA%D0%B8-%D0%BE-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-ebd0ec8e2e1f?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebd0ec8e2e1f</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[pandas-dataframe]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Sat, 17 Oct 2020 16:02:19 GMT</pubDate>
            <atom:updated>2020-10-17T16:02:19.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*qZ_MZko8y6SQ6_6k.png" /></figure><h3>1. Анализ образцов датафреймов с помощью df.groupby().__iter__()</h3><p>Обычно исследовать набор данных строка за строкой или группа за группой в блокнотах Jupyter сложнее, чем в Excel. Один из полезных трюков заключается в использовании генератора и комбинации клавиш Ctrl + Enter вместо Shift + Enter, чтобы итеративно просматривать различные образцы в одной ячейке, не создавая беспорядка в вашем блокноте.</p><p>Сначала создайте ячейку с генератором c .groupby () (или .iterrows ()) и добавьте .__iter__():</p><pre>generator = df.groupby([&#39;identifier&#39;]).__iter__()</pre><p>Затем запустите следующую ячейку <strong>столько раз, сколько вам потребуется</strong>, чтобы увидеть необходимые вам данные, используя сочетание клавиш Ctrl + Enter:</p><pre>group_id, grouped_data = generator.__next__()<br>print(group_id)<br>grouped_data</pre><p>На этом примере анализируется набор данных Titanic о пассажирах Титаника, у которых совпадают номера билетов. Так как у вас нет возможности исследовать каждую группу пассажиров по отдельности, вы можете воспользоваться этим несложным методом, чтобы проанализировать одну группу за другой:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*SH5mJBgDs-PFWimQ.gif" /><figcaption>Анализ пассажиров с одинаковым номером билета “ Ticket “ в наборе данных Titanic с помощью df.groupby().__iter__() и сочетания клавиш Ctrl + Enter.</figcaption></figure><h3>2. Профилирование pandas для исследования данных и оценки их качества</h3><p>Как часто бывает в науке о данных, мы обычно пишем код для исследования данных с нуля. Поскольку все наборы данных различны, это кажется логичным. Однако существует волшебный пакет <strong>pandas_profiling</strong>, который доказывает, что в этом нет необходимости. Пакет фактически автоматизирует этапы исследования и оценки качества данных! Взгляните:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*FzExZ_5-Q6YvAxDr.gif" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*yO5crJe8MP_QW_9T.png" /><figcaption>Перейдите в раздел ‘Warnings’ (Предупреждения), чтобы получить доступ к оценке качества ваших данных.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*bzlxA-9NaNfaMiEg.png" /><figcaption>Корреляционный анализ профилирования pandas. Можно выбрать между 5–6 показателями корреляции.</figcaption></figure><p>Похоже на магию!</p><p>Очевидно, что пакет pandas-profiling дает в наше распоряжение только общее приблизительное представление о данных. Например, он не поможет, если в ваших данных есть независимые текстовые переменные. Но начинать анализ любых наборов данных следует именно с этого.</p><h3>3. Цепочка методов</h3><p>Работа с pandas становbтся действительно интересной, как только вы понимаете, что можно объединять несколько операций, используя цепочку методов. По сути, формирование цепочки — это добавление операций в одну и ту же “строку” кода.</p><p>С помощью приведенной ниже строки кода я:</p><ul><li>добавляю новый столбец в мой набор данных (.merge);</li><li>подсчитываю процент пассажиров женского пола (.apply(female_proportion));</li><li>для групп, состоящих более чем из одного пассажира (df.Ticket.value_counts()&gt;1);</li><li>для групп с одинаковым номером билета (.groupby (“Ticket “)).</li></ul><pre>def female_proportion(dataframe):<br>    return (dataframe.Sex==&#39;female&#39;).sum() / len(dataframe)</pre><pre>female_proportion(df)</pre><pre>df.merge(<br>    df.loc[<br>        df.Ticket.isin(<br>            df.Ticket.value_counts().loc[<br>                df.Ticket.value_counts()&gt;1<br>            ].index<br>        )<br>    ].groupby(&#39;Ticket&#39;).apply(female_proportion) \<br>     .reset_index().rename(columns={0:&#39;proportion_female&#39;}),<br>     how=&#39;left&#39;, on=&#39;Ticket&#39;<br>)</pre><p>Мне не пришлось создавать новые датафреймы, новые переменные или что-либо еще. Цепочка методов позволяет “переводить” свои идеи в реальные операции.</p><p>Далее мы можем увидеть еще один хороший пример цепочки методов.</p><h3>4. Визуализация данных</h3><p>Если вы занимаетесь машинным обучением, вы знаете, как нелегко бывает объяснить свою модель машинного обучения доступным языком. Вам может помочь качественная визуализация коэффициентов или оценки важности переменных вашей модели.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*ANNKfnGJrsAfdqxd.png" /><figcaption>Вы можете указать коэффициенты (или важность переменных) в Dataframe, чтобы визуализировать их.</figcaption></figure><p>Я собрал код из нескольких источников, чтобы получить следующую визуализацию, которую я теперь использую постоянно, чтобы не изобретать велосипед:</p><pre>pd.DataFrame({ <br>   &#39;variable&#39;: variables, <br>   &#39;coefficient&#39;: model.coef_[0]<br>}) \  <br>  .round(decimals=2) \  <br>  .sort_values(&#39;coefficient&#39;, ascending=False) \  <br>  .style.bar(color=[&#39;grey&#39;, &#39;lightblue&#39;], align=&#39;zero&#39;)</pre><p>Что дает следующий результат:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*2HsR4e1b7EQnL3PY.png" /><figcaption>Переменные ранжируются в соответствии с коэффициентом (или важностью переменной). Таким образом, цветная полоса позволяет нам быстро определить наиболее важные переменные. Здесь столбец ‘Pclass’ имеет самый большой (отрицательный) коэффициент, который в два раза больше второго по величине коэффициента в абсолютном значении: ‘Embarked_Q’.</figcaption></figure><p>Довольно наглядно, верно?</p><h3>5. sklearn_pandas</h3><p>Если вы сторонник pandas, вы уже не раз замечали, что DataFrame pandas и sklearn не всегда хорошо работают в связке. Но не опускайте руки! Группа энтузиастов создала пакет sklearn_pandas, мост между двумя библиотеками. Он заменяет<strong> ColumnTransformer</strong> от sklearn на удобный для pandas <strong>DataFrameMapper</strong>. Теперь я использую только sklearn_pandas, чем очень доволен. Очень жаль, что я не знал о нем раньше!</p><pre>from sklearn.impute import SimpleImputer<br>from sklearn.preprocessing import OneHotEncoder<br>from sklearn.preprocessing import MinMaxScaler, StandardScaler<br>from sklearn_pandas import DataFrameMapper<br>from category_encoders import LeaveOneOutEncoder </pre><pre>imputer_Pclass = SimpleImputer(strategy=&#39;most_frequent&#39;, add_indicator=True)<br>imputer_Age = SimpleImputer(strategy=&#39;median&#39;, add_indicator=True)<br>imputer_SibSp = SimpleImputer(strategy=&#39;constant&#39;, fill_value=0, add_indicator=True)<br>imputer_Parch = SimpleImputer(strategy=&#39;constant&#39;, fill_value=0, add_indicator=True)<br>imputer_Fare = SimpleImputer(strategy=&#39;median&#39;, add_indicator=True)<br>imputer_Embarked = SimpleImputer(strategy=&#39;most_frequent&#39;)</pre><pre>scaler_Age = MinMaxScaler()<br>scaler_Fare = StandardScaler() </pre><pre>onehotencoder_Sex = OneHotEncoder(drop=[&#39;male&#39;], handle_unknown=&#39;error&#39;)<br>onehotencoder_Embarked = OneHotEncoder(handle_unknown=&#39;error&#39;) </pre><pre>leaveoneout_encoder = LeaveOneOutEncoder(sigma=.1, random_state=2020) </pre><pre>mapper = DataFrameMapper([ <br>   ([&#39;Age&#39;], [imputer_Age, scaler_Age], {&#39;alias&#39;:&#39;Age_scaled&#39;}),<br>   ([&#39;Pclass&#39;], [imputer_Pclass]),  <br>   ([&#39;SibSp&#39;], [imputer_SibSp]),<br>   ([&#39;Parch&#39;], [imputer_Parch]),    <br>   ([&#39;Fare&#39;], [imputer_Fare, scaler_Fare], {&#39;alias&#39;: &#39;Fare_scaled&#39;}), <br>   ([&#39;Sex&#39;], [onehotencoder_Sex], {&#39;alias&#39;: &#39;is_female&#39;}),<br>   ([&#39;Embarked&#39;], [imputer_Embarked, onehotencoder_Embarked]),<br>   ([&#39;Embarked_Pclass_Sex&#39;], [leaveoneout_encoder])<br>], df_out=True) <em># используйте df_out для вывода как датафрейма pandas</em></pre><pre>mapper.fit(X=train, y=train[&#39;Survived&#39;]) <em># вставляете как ColumnTransforme rsklearn</em></pre><p>Вот пример выходных данных после использования метода .fit():</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*eyiXU4Nt7hXZXdAC.png" /></figure><h3>6. tqdm</h3><p>При работе с большими наборами данных на их обработку потребуется какое-то время. Вместо того, чтобы скучать в ожидании неизвестности перед своим блокнотом Jupyter, используйте <strong>tqdm</strong>, чтобы отследить, выполняется ли ваш код, и узнать время, которое потребуется для его обработки. Это также хороший способ прервать сценарий, который выполняется слишком медленно, на ранней стадии.</p><pre>from tqdm import notebook<br>notebook.tqdm().pandas()</pre><p>Теперь во всех датафреймах pandas есть новые методы:</p><ul><li>.progress_apply, .progress_applymap</li><li>.progress_map <em>для столбцов</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*pf_HENGjbTKLXfAj.png" /></figure><p>Они отличаются от apply, applymap и map лишь тем, что графически отображают индикатор выполнения. Очень полезно!</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*4X9Q2KeBemwI-EB5.gif" /><figcaption>Пример индикатора выполнения, генерируемого методом tqdm pandas.</figcaption></figure><h3>7. Метод .to_clipboard () для экспорта в Excel</h3><p>Будучи преданным поклонником Excel, я отточил навыки создания привлекательных графиков и хорошего форматирования, чтобы показывать информацию, полученную из анализа данных. Несмотря на то, что pandas предлагает много дополнительных возможностей, получить аналогичный уровень вывода, практически не используя код, может быть нелегко.</p><p>Мне пришлось потрудиться, чтобы решить эту проблему, но в конечном итоге я нашел выход — экспортировать свои результаты в Excel. Однако вместо метода .to_excel я использую более мягкий метод .to_clipboard (index=False), который копирует данные в буфер обмена. Затем я использую Ctrl + V в Excel, чтобы вставить данные в свою текущую электронную таблицу. Вот и все, теперь вы можете выпустить на волю своего внутреннего зверя Excel!</p><p>Многие специалисты по обработке данных часто забывают, что ученые, не работающие с данными, как правило, хорошо разбираются в Excel. Проще поделиться с ними файлом Excel, чем обычным блокнотом или блокнотом, экспортированным в виде html-файла.</p><p><strong>Спасибо за чтение!</strong></p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/8858/">TextHero — самый простой способ чистки и анализа текста в Pandas</a></li><li><a href="https://nuancesprog.ru/p/9862/">Импорт в Python</a></li><li><a href="https://nuancesprog.ru/p/9637/">Python 3: 3 функции, которые следует помнить</a></li></ul><p>Читайте нас в <a href="https://vk.com/away.php?to=https://t.me/nuancesprog&amp;cc_key=">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://vk.com/away.php?to=https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a&amp;cc_key=">Яндекс.Дзен</a></p><p>Перевод статьи <a href="https://medium.com/@FelixRvrt">Félix Revert</a>: <a href="https://towardsdatascience.com/7-advanced-tricks-in-pandas-for-data-science-41a71632b5d9">7 advanced pandas tricks for data science</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebd0ec8e2e1f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/7-%D1%82%D1%80%D1%8E%D0%BA%D0%BE%D0%B2-pandas-%D0%B4%D0%BB%D1%8F-%D0%BD%D0%B0%D1%83%D0%BA%D0%B8-%D0%BE-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-ebd0ec8e2e1f">7 трюков pandas для науки о данных</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[25 наборов аудиоданных для исследований]]></title>
            <link>https://medium.com/nuances-of-programming/25-%D0%BD%D0%B0%D0%B1%D0%BE%D1%80%D0%BE%D0%B2-%D0%B0%D1%83%D0%B4%D0%B8%D0%BE%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B4%D0%BB%D1%8F-%D0%B8%D1%81%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9-489938a2f0b5?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/489938a2f0b5</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Wed, 07 Oct 2020 12:02:42 GMT</pubDate>
            <atom:updated>2020-10-07T12:02:42.482Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/696/0*YFp5Fu18OA0qH2WW.png" /></figure><h3>Наборы музыкальных данных</h3><h3><a href="https://github.com/mdeff/fma">Free Music Archive</a></h3><p>FMA предназначен для анализа музыки и состоит из полноразмерного HQ-аудио, предварительно вычисленных характеристик, а также метаданных трека и пользовательского уровня. Этот открытый набор данных был создан для оценки нескольких задач поиска музыкальной информации (<a href="https://en.wikipedia.org/wiki/Music_information_retrieval">MIR</a>). Его размер составляет почти 1000 ГБ.</p><h3><a href="https://labrosa.ee.columbia.edu/millionsong/">Million Song Dataset</a></h3><p>Открытая коллекция характеристик и метаданных для миллиона треков. Набор не содержит аудио, а только извлеченные характеристики. Аудиосемплы можно получить из таких сервисов, как 7digital, используя код, предоставленный Колумбийским университетом. Размер набора — около 280 ГБ.</p><h3>Наборы речевых данных</h3><h3><a href="https://github.com/Jakobovski/free-spoken-digit-dataset">Free Spoken Digit Dataset</a></h3><p>Этот открытый набор данных был создан для определения цифр, произносимых в аудиосемплах. На данный момент он содержит: 3 говорящих, 1500 записей (по 50 с каждой цифрой на говорящего), а также вариации английского произношения. Размер пакета — всего около 10 МБ.</p><h3><a href="https://www.openslr.org/12/">LibriSpeech</a></h3><p>Масштабный корпус, включающий около 1000 часов английской речи. Данные взяты из аудиокниг проекта LibriVox, их размер составляет около 60 ГБ.</p><h3><a href="http://www.robots.ox.ac.uk/~vgg/data/voxceleb/">VoxCeleb</a></h3><p>Обширный набор данных размером 150 МБ, состоящий из почти 2000 часов речи и предназначенный для определения личности говорящего. Он содержит около 100 000 высказываний 1251 знаменитости, взятых из видео на YouTube. Данные почти равномерно распределены по полу (мужчины составляют 55%). Знаменитости различаются по акцентам, профессиям и возрасту. Наборы для разработки и тестирования не содержат совпадений.</p><h3><a href="https://nats.gitlab.io/swc/">Spoken Wikipedia Corpora</a></h3><p>Это корпус унифицированных разговорных статей из английской, немецкой и голландской версий Википедии. Сотни часов аудио и аннотаций можно сопоставить с исходным HTML. Размер всего набора — около 38 ГБ.</p><h3><a href="https://groups.csail.mit.edu/sls/downloads/flickraudio/">Flickr Audio Caption Corpus</a></h3><p>Включает 40 000 озвученных подписей к 8 000 изображений, размер которых составляет 4,2 ГБ. Этот корпус был собран в 2015 году в целях исследования мультимодального обучения для неконтролируемого обнаружения речевых шаблонов.</p><h3><a href="https://www.openslr.org/51/">TED-LIUM</a></h3><p>Набор состоит из 1495 аудиозаписей с выступлений TED Talk и их полных расшифровок, созданных компьютерной лабораторией Университета штата Мэн (LIUM).</p><h3><a href="http://ai.googleblog.com/2017/08/launching-speech-commands-dataset.html">Speech Commands Dataset</a></h3><p>Набор данных размером 1,4 ГБ включает 65 000 односекундных высказываний из 30 коротких слов, выполненных тысячами разных людей. Выпущен под лицензией Creative Commons-BY 4.0 и разработан для создания простых, но полезных голосовых интерфейсов с общими словами, такими как «да», «нет», цифры и направления движения.</p><h3><a href="https://www.kaggle.com/mozillaorg/common-voice/home">Common Voice</a></h3><p>Корпус речевых данных размером 12 ГБ. Текст был взят из нескольких публичных источников, таких как блоги, книги и фильмы, и прочитан пользователями веб-сайта <a href="https://voice.mozilla.org/">Common Voice</a>. Его основная цель — предоставить данные для обучения и тестирования систем автоматического распознавания речи.</p><h3><a href="https://github.com/S-Malek/PCVC">Persian Consonant Vowel Combination (PCVC) Speech Dataset</a></h3><p>Персидский речевой корпус для распознавания речи и говорящего. Содержит звуковые аудиосемплы сочетаний гласных и согласных фонем современного персидского языка, каждый из которых включает только одну согласную и одну гласную. В наборе содержится 23 согласных и 6 гласных и представлены все их возможные комбинации (138 семплов на каждого говорящего) — всего 30 000 записей.</p><h3><a href="http://www.voxforge.org/">VoxForge</a></h3><p>Набор данных акцентированного английского языка, который пригодится для создания устойчивости к различным акцентам или интонациям.</p><h3><a href="http://spandh.dcs.shef.ac.uk/chime_challenge/data.html">CHIME</a></h3><p>Этот набор размером около 4 ГБ предназначен для решения задач по распознаванию речи в шумной обстановке. Он содержит реальные, смоделированные и чистые голосовые записи. Реальные представлены 9000 записями 4 говорящих в 4 шумных местах, смоделированные созданы путем наложения нескольких сред поверх речевых высказываний, а чистые записаны без лишних шумов. Скачать этот набор можно <a href="https://archive.org/details/chime-home">здесь</a>.</p><h3><a href="https://catalog.ldc.upenn.edu/LDC2002T43">2000 HUB5 English</a></h3><p>Речевые данные на английском языке, использующиеся в системе Deep Speech от компании Baidu.</p><h3><a href="https://archive.ics.uci.edu/ml/datasets/Parkinson+Speech+Dataset+with++Multiple+Types+of+Sound+Recordings">Parkinson Speech Dataset</a></h3><p>Содержит данные для обучения от 20 пациентов с болезнью Паркинсона и 20 здоровых человек — всего 26 типов звуковых записей размером 20 МБ.</p><h3><a href="https://github.com/bootphon/zerospeech2017">Zero Resource Speech Challenge</a></h3><p>Конечная цель Zero Resource Speech Challenge — построить систему, которая способна с нуля изучить диалог на неизвестном языке лишь с помощью информации, доступной ребенку, изучающему язык. «Нулевой ресурс» («Zero resource») означает отсутствие лингвистических знаний (например, орфографической и лингвистической транскрипции), а не отсутствие информации помимо аудио (визуальные наблюдения, обратная связь и т. д.). Тот факт, что четырехлетние дети способны самостоятельно изучить язык без помощи языковых экспертов, показывает, что эта цель теоретически достижима.</p><h3><a href="https://data.world/uci/isolet">ISOLET DataSet</a></h3><p>Этот набор данных размером 38,7 ГБ применяется для решения простой задачи классификации — предсказания того, какая буква произносится.</p><h3><a href="http://en.arabicspeechcorpus.com/">Arabic Speech Corpus</a></h3><p>Речевой корпус арабского литературного языка (АЯ) размером 1,5 ГБ, который используется для синтеза речи. Он содержит фонетические и орфографические транскрипции более 3,7 часов АЯ-речи, согласованной с записанной речью на уровне фонем. Аннотации включают ударение на отдельных фонемах.</p><p>Корпус был разработан в рамках докторской работы Навара Халабиата (Nawar Halabiat) из Университета Саутгемптона. Записи сделаны на южно-левантийском арабском языке с дамасским акцентом в профессиональной студии. Синтезированная речь, полученная с использованием этого корпуса, представляет собой высококачественный, естественный голос.</p><h3><a href="https://github.com/philipperemy/timit/blob/master/README.md">TIMIT Corpus</a></h3><p>Размер корпуса — 440 МБ. Его данные можно применять для акустико-фонетических исследований, а также для разработки и оценки систем автоматического распознавания речи. TIMIT содержит широкополосные записи 630 носителей восьми основных диалектов американского английского, каждый из которых читает десять предложений с фонетически богатым звучанием. Он включает синхронизированные по времени орфографические, фонетические и словесные транскрипции, а также 16-битный файл речевого сигнала с частотой 16 кГц для каждого высказывания.</p><h3><a href="https://github.com/SenticNet/MELD">Multimodal EmotionLines Dataset (MELD)</a></h3><p>MELD — улучшенная и расширенная версия набора данных EmotionLines. Он содержит те же экземпляры диалогов, что и EmotionLines, а также аудио и визуальную модальность наряду с текстом. В нем можно найти более 1400 диалогов и 13 000 высказываний из сериала «Друзья», каждое из которых содержит метку эмоции: гнев, отвращение, печаль, радость, нейтральность, удивление и страх. Скачать этот набор можно <a href="https://github.com/SenticNet/MELD">здесь</a>.</p><h3>Наборы данных, включающие звуки окружающей среды</h3><h3><a href="https://research.google.com/audioset/">AudioSet</a></h3><p>Содержит 632 класса звуковых событий и коллекцию из 2 084 320 помеченных вручную звуковых клипов длиной по 10 секунд, взятых из видео на YouTube. Чтобы скачать этот набор, перейдите по <a href="https://github.com/audioset/ontology">ссылке на GitHub</a>.</p><h3><a href="http://mivia.unisa.it/datasets/audio-analysis/mivia-audio-events/">Mivia Audio Events Dataset</a></h3><p>Включает 6 000 событий, таких как разбивание стекла, выстрелы и крики, разделенных на обучающий набор из 4200 событий и тестовый — из 1800. Чтобы загрузить этот набор данных, нужно зарегистрироваться на сайте <a href="http://mivia.unisa.it/datasets-request/">Mivia</a>.</p><h3><a href="https://www.cs.tut.fi/~heittolt/datasets">Environmental Audio Datasets</a></h3><p>Страница включает наборы данных для исследования звуков окружающей среды. Помимо открытых наборов, содержит также частные и коммерческие, а в конце перечислено несколько звуковых онлайн-сервисов, которые можно применять для формирования новых наборов данных для особых исследовательских потребностей.</p><p>Наборы разделены на две таблицы:</p><ul><li>Таблица звуковых событий содержит наборы данных, подходящие для исследований в области автоматического обнаружения звуковых событий и автоматической маркировки звуков.</li><li>Таблица акустических сцен включает наборы, которые пригодятся для распознавания контекста на основе звука и классификации акустических сцен.</li></ul><h3><a href="https://datasets.freesound.org/fsd/">FSD</a> &amp; <a href="https://datasets.freesound.org/">Freesound</a></h3><p>Иерархическая коллекция из более чем 600 звуковых классов, дополненная 297 159 аудиосемплами от Freesound. В результате этого объединения было создано 678 511 аннотаций кандидатов, которые отражают потенциальное присутствие источников звука в аудио клипах. FSD включает множество повседневных звуков: человеческая речь, звуки животных, музыка и звуки, издаваемые вещами — и все это под лицензией Creative Commons. Набор данных предназначен для помощи исследованиям, которые позволят машинам слышать и интерпретировать звук подобно людям.</p><p>Freesound — это платформа для совместного создания аудиоколлекций, помеченных вручную и основанных на контенте Freesound.</p><h3><a href="https://www.kaggle.com/pavansanagapati/urban-sound-classification">Urban Sound Classification</a></h3><p>Этот набор данных размером 6 ГБ содержит 8732 помеченных звуковых отрывка из 10 звуковых классов: шум кондиционера, автомобильный гудок, играющие дети, лай собаки, шум бурения и двигателя, выстрел, отбойный молоток, сирена и уличная музыка. Длина каждого — около 4 секунд. Данные содержат такие атрибуты, как ID — уникальный идентификатор звукового отрывка и Class — тип звука.</p><h3><a href="https://urbansounddataset.weebly.com/urbansound.html">Urban Sound Dataset</a></h3><p>Этот набор включает 1302 звуковых записей, в каждой из которых отмечены начало и конец звукового события из 10 классов: шум кондиционера, автомобильный гудок, играющие дети, лай собаки, шум бурения и двигателя, выстрел, отбойный молоток, сирена и уличная музыка. Некоторые записи содержат несколько звуковых событий, но для каждого файла помечены только события из одного класса. Классы взяты из таксономии городских звуков.</p><h3><a href="http://machine-listening.eecs.qmul.ac.uk/bird-audio-detection-challenge/">Bird Audio Detection challenge</a></h3><p>Набор предназначен для создания надежного и масштабируемого алгоритма обнаружения птиц. Для решения этой задачи используются наборы данных размером 5,4 ГБ, взятые из реальных проектов по мониторингу биоакустики, и объективная стандартизированная структура оценки.</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/9851/">Крутые наборы данных для машинного обучения</a></li><li><a href="https://nuancesprog.ru/p/9341/">Как собрать кубик Рубика с помощью генетических алгоритмов</a></li><li><a href="https://nuancesprog.ru/p/9768/">От Spotify к собственной рекомендательной системе</a></li></ul><p>Читайте нас в <a href="https://vk.com/away.php?to=https://t.me/nuancesprog&amp;cc_key=">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://vk.com/away.php?to=https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a&amp;cc_key=">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@cdossman">Christopher Dossman</a>: <a href="https://towardsdatascience.com/a-data-lakes-worth-of-audio-datasets-b45b88cd4ad">Over 1.5 TB’s of Labeled Audio Datasets</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=489938a2f0b5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/25-%D0%BD%D0%B0%D0%B1%D0%BE%D1%80%D0%BE%D0%B2-%D0%B0%D1%83%D0%B4%D0%B8%D0%BE%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B4%D0%BB%D1%8F-%D0%B8%D1%81%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B9-489938a2f0b5">25 наборов аудиоданных для исследований</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Как собрать кубик Рубика с помощью генетических алгоритмов]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D1%81%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D1%8C-%D0%BA%D1%83%D0%B1%D0%B8%D0%BA-%D1%80%D1%83%D0%B1%D0%B8%D0%BA%D0%B0-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-%D0%B3%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2-bcd3740cfa32?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/bcd3740cfa32</guid>
            <category><![CDATA[genetic-algorithm]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Wed, 30 Sep 2020 12:03:43 GMT</pubDate>
            <atom:updated>2020-09-30T12:03:43.391Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*rdW9KZrbruI0NcLy.png" /></figure><h3>Введение</h3><p>В качестве эксперимента я решил собрать кубик Рубика с помощью генетических алгоритмов (ГА). Их основная концепция заключается в том, чтобы найти решение путем имитации естественного отбора и эволюции. В целом, нам потребуется выполнить следующие шаги:</p><ol><li>Создать популяцию вариантов решений (обычно они генерируются случайным образом).</li><li>Определить показатель пригодности для оценки того, насколько близок вариант к достижению цели.</li><li>Оценить все варианты решения и отсортировать их по степени пригодности.</li><li>Определить стратегию развития популяции. Обычно сохраняются лучшие исполнители и вносятся случайные изменения, например небольшое изменение варианта решения или объединение двух решений.</li><li>После появления новой популяции продолжать очистку и повторять шаги до нахождения решения (возврат к шагу 3).</li><li>Порой «генетического пула» недостаточно, чтобы найти решение. В этом случае наиболее распространенный подход — уничтожить популяцию и начать с начала.</li></ol><p>Но прежде чем перейти к деталям реализации, рассмотрим базовую теорию кубика Рубика.</p><h3>Нотация кубика Рубика</h3><ul><li>Вращение отдельных букв выполняется по часовой стрелке.</li><li>Вращения, обозначенные штрихом, выполняются против часовой стрелки.</li><li>Чтобы определить направление вращения, нужно посмотреть прямо на указанную сторону. Например, для D и D’ представьте, что перед вами нижняя сторона.</li><li>U2 аналогично двум вращениям U.</li><li>Обратите внимание, что в некоторых случаях (x, y, z) вращается весь куб, а не только одна сторона.</li></ul><p>UU’U2DD’D2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*DqPLQjpU9ASkGsGI.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*gRjIVkv3wmkrkqht.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*vzu3tsmE_ncKykKw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*YKdDgyNPWu5w6XLn.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*K4b-FgJvT2MEx5EI.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*Mzleq3C-SvGBtkk0.png" /></figure><p>RR’R2LL’L2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*wjBsdeLLSj3aneya.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*KD-wjyUSEa0Iqbf3.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*lUJQnCAbsjHJch-K.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*YqwPloo3SRbgKZNp.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*my7f0hF_40B6xidy.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*k0YvbxajOxUzZO-Z.png" /></figure><p>FF’F2BB’B2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*-0S8STrK80Tw4b-S.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*-ujxixzXcFTs2pfG.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*ypqY_TGR6PciSAB0.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*awTqah774DD-mz67.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*yUxIF2HF2m4zP-vx.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*eYkEwILYf_wbZ4ub.png" /></figure><p>MM’M2EE’E2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*HS0awvaLMDeTSl9f.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*xokAlZj2vq_Vbj6O.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*JrlqecAd4KZL7W_i.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*qZhsjl_sujsyooaq.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*yr9PT0ZKAF8Ctz1u.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*I5fHYmnrSkjMREty.png" /></figure><p>sS’S2xyz</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*tty0ZbW_qmCCHPmQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*lEbDxpG3Neeq4jmX.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*xlP8MIFGHFbTJXrq.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*QprzbyDD9pej4J08.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*GAPv3e_s8_u9kQhS.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*aWWRCOgnqfrbQ5Hh.png" /></figure><h3>Реализация кубика Рубика</h3><h3>Грани</h3><p>Для представления кубика есть множество подходов, но я решил воспользоваться простым словарем, содержащим шесть матриц numpy 3×3 (по одной для каждой грани):</p><pre>self.faces = {<br>    FRONT: np.full((3, 3), GREEN),<br>    LEFT: np.full((3, 3), ORANGE),<br>    RIGHT: np.full((3, 3), RED),<br>    TOP: np.full((3, 3), WHITE),<br>    BOTTOM: np.full((3, 3), YELLOW),<br>    BACK: np.full((3, 3), BLUE),<br>}</pre><p>Для передней грани интуитивно ясно, что [0, 0] будет левым верхним углом. Однако значения back[0, 0], left[0, 0] и bottom[0, 0] зависят от того, с каком стороны вы смотрите на куб. Изображение ниже поможет избежать путаницы. Позиция [0, 0] обозначена фиолетовым. Схема согласована с тем, как определяется способ вращения.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/336/0*8g4mwzaIdkAw597t.png" /></figure><h3>Вращения</h3><p>Numpy включает множество полезных методов, таких как rot90 и flip, которые отлично подходят для реализации вращения куба. В качестве примера проанализируем R:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/144/0*lxdfgBdr3kx43tbA.png" /></figure><p>Как видите, сначала мы выполняем вращение на матрице правой грани, а затем меняем значения нижней, передней, верхней и задней матриц соответственно.</p><pre>def R(self):<br>    self.faces[RIGHT] = np.rot90(self.faces[RIGHT], axes=CLOCKWISE)<br>    # __swap_y получает четыре значения из трехзначных кортежей<br>    # Каждый такой кортеж состоит из:<br>    # - index 0 = грань<br>    # - index 1 = столбец<br>    # - index 2 = перевернутые значения (булевы)<br>    #<br>    # Это означает: <br>    # - переместить столбец &quot;bottom&quot; 2 в столбец &quot;front&quot; 2<br>    # - переместить столбец &quot;front&quot; 2 в столбец &quot;top&quot; 2<br>    # - переместить столбец &quot;top&quot; 2 в столбец &quot;back&quot; 0, перевернув значения<br>    # - переместить столбец &quot;back&quot; 0 в столбец &quot;bottom&quot; 2, перевернув значения<br>    self.__swap_y((BOTTOM, 2, False), (FRONT, 2, False), (TOP, 2, True), (BACK, 0, True))</pre><p>Единственная сложность заключается в том, что при работе с обратной стороной необходимо инвертировать значения, как показано на изображении:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/336/0*ADzLU12zwIE3glul.png" /></figure><pre>TOP[0, 2] -&gt; BACK[2, 0]<br>TOP[1, 2] -&gt; BACK[1, 0]  <br>TOP[2, 2] -&gt; BACK[0, 0]</pre><p>Полную реализацию можно посмотреть в исходном коде.</p><h3>Генетический алгоритм</h3><h3>Создание популяции</h3><p>Как было сказано выше, для этой симуляции нужно создать популяцию кубика Рубика. Мы воспользуемся следующим скремблом, полученным с помощью этого <a href="https://www.worldcubeassociation.org/regulations/history/files/scrambles/scramble_cube.htm">онлайн-скремблера</a>.</p><pre>D’ B2 D2 L2 U’ L R’ F L2 R2 U’ L2 B’ L D’ B2 R2 B’ R F U2 R B2 F’ L’ B2 L2 R F2 L’</pre><p>К слову, для экспериментов, отладки, проверки результатов тестовых случаев, создания изображений и прочего я использовал этот крутой <a href="https://alg.cubing.net/">симулятор куба</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/0*xgaq-aQ-dJXhLpwF.png" /></figure><p>После скремблирования всех кубиков мы рандомизируем их, выполнив два случайных хода, таких как R, L’, U, D2 и т. д.</p><pre># Создание популяции<br>cubes = []<br>for i in range(0, self.population_size):<br>    cube = Cube()<br>    cube.execute(scramble)<br>    # Рандомизация<br>    cube.execute(self.__rnd_single_move())<br>    cube.execute(self.__rnd_single_move())<br>    cubes.append(cube)</pre><h3>Функция пригодности</h3><p>Напоминаю: с помощью функции пригодности определяются наиболее близкие к решению варианты. Один из подходов — подсчитать количество правильно размещенных частей куба. Однако подсчетов будет много. Например, угол следует считать за одну часть, хотя он взаимодействует с тремя гранями. Вместо этого мы можем подсчитать стикеры. Подсчет потерянных стикеров проще, поэтому цель — минимизировать их количество. Другими словами, чем меньше, тем лучше, и если пригодность равна нулю, значит куб решен.</p><pre>def __calculate_fitness(self):<br>    misplaced_stickers = 0</pre><pre>    for k, face in self.faces.items():<br>        <em># Центры закреплены в кубике Рубика</em><br>        center = face[1, 1]</pre><pre>        for i in range(0, 3):<br>            for j in range(0, 3):<br>                if face[i, j] != center:<br>                    misplaced_stickers += 1</pre><pre>    return misplaced_stickers</pre><h3>Стратегия эволюции</h3><p>Мои первые попытки включали случайную генерацию ходов (R, L, U и т. д.), но эта стратегия не принесла результатов. Чтобы понять причину, посмотрим, что происходит при выполнении одного вращения:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/0*NRX4h6xKJpT19Reu.png" /></figure><p>В этом случае изменилось положение 20 стикеров (по 3 на каждой стороне + 8 на верхней грани). У куба 54 стикера, поэтому при каждом вращении состояние куба изменяется на 37%, и это слишком много, чтобы применить эволюционный подход. Что же делать? Можем ли мы найти способ внести меньшие изменения? Да! Для этой цели можно использовать хорошо известные алгоритмы кубика Рубика. Например, <strong>R U’ R U R U R U’ R’ U’ R2</strong> перемещает только три стикера, как показано на изображении ниже.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/0*OqOVVsvC65h9ujmP.png" /></figure><p><strong>F’ L’ B’ R’ U’ R U’ B L F R U R’ U</strong> также вносит небольшое изменение (перестановка двух ребер на верхнем слое).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/0*UMnC7kO-uVFw5HOV.png" /></figure><p>Вот список всех перестановок, которые мы будем использовать:</p><pre>PERMUTATIONS = [<br>    # Перестановка двух ребер: грань U, нижнее и правое ребра<br>    &quot;F&#39; L&#39; B&#39; R&#39; U&#39; R U&#39; B L F R U R&#39; U&quot;,<br>    # Перестановка двух ребер: грань U, нижнее и левое ребра<br>    &quot;F R B L U L&#39; U B&#39; R&#39; F&#39; L&#39; U&#39; L U&#39;&quot;,<br>    # Перестановка двух углов: грань U, нижний левый и нижний правый<br>    &quot;U2 B U2 B&#39; R2 F R&#39; F&#39; U2 F&#39; U2 F R&#39;&quot;,<br>    # Перестановка трех углов: грань U, нижний левый и верхний левый<br>    &quot;U2 R U2 R&#39; F2 L F&#39; L&#39; U2 L&#39; U2 L F&#39;&quot;,<br>    # Перестановка трех углов: грань F, верхний, правый, нижний<br>    &quot;U&#39; B2 D2 L&#39; F2 D2 B2 R&#39; U&#39;&quot;,<br>    # Перестановка трех центров: грань F, верхний, правый левый<br>    &quot;U B2 D2 R F2 D2 B2 L U&quot;,<br>    # Грань U: нижний угол &lt;-&gt; правый угол, нижний правый угол &lt;-&gt; верхний правый угол<br>    &quot;D&#39; R&#39; D R2 U&#39; R B2 L U&#39; L&#39; B2 U R2&quot;,<br>    # Грань U: нижний угол &lt;-&gt; правый угол, нижний правый угол &lt;-&gt; левый правый угол<br>    &quot;D L D&#39; L2 U L&#39; B2 R&#39; U R B2 U&#39; L2&quot;,<br>    # Грань U: верхний угол &lt;-&gt; нижний угол, нижний левый угол &lt;-&gt; верхний правый угол<br>    &quot;R&#39; U L&#39; U2 R U&#39; L R&#39; U L&#39; U2 R U&#39; L U&#39;&quot;,<br>    # Грань U: верхний угол &lt;-&gt; нижний угол, нижний правый угол &lt;-&gt; верхний левый угол<br>    &quot;L U&#39; R U2 L&#39; U R&#39; L U&#39; R U2 L&#39; U R&#39; U&quot;,<br>    # Перестановка трех углов: грань U, нижний правый, нижний левый и верхний левый<br>    &quot;F&#39; U B U&#39; F U B&#39; U&#39;&quot;,<br>    # Перестановка трех углов: грань U, нижний левый, нижний правый и верхний правый<br>    &quot;F U&#39; B&#39; U F&#39; U&#39; B U&quot;,<br>    # Перестановка трех ребер: нижняя часть грани F, верхняя часть грани F, верхняя часть грани B<br>    &quot;L&#39; U2 L R&#39; F2 R&quot;,<br>    # Перестановка трех углов: верхняя часть грани F, верхняя часть грани B, нижняя часть грани B<br>    &quot;R&#39; U2 R L&#39; B2 L&quot;,<br>    # Перестановка H: грань U, меняет местами ребра по горизонтали и вертикали<br>    &quot;M2 U M2 U2 M2 U M2&quot;<br>]</pre><p>Теперь, когда мы можем вносить небольшие и простые изменения, пришло время выбрать способ развития текущей популяции. Эта часть потребовала множества экспериментов, поэтому я просто опишу наиболее эффективную стратегию:</p><ul><li>Продвигаем лучших исполнителей к следующему поколению без изменений (в ГА этот процесс называется элитарностью).</li><li>Отбрасываем оставшиеся варианты решения и заменяем их следующим образом:</li><li>получаем копию случайного лучшего исполнителя;</li><li>случайным образом добавляем перестановки или вращения к копии;</li><li>заменяем вариант решения новой копией.</li></ul><pre><em># Цель - минимизировать функцию пригодности</em><br><em># 0 означает, что куб собран</em><br>    for i in range(0, len(cubes)):<br>    if cubes[i].fitness == 0:<br>        print(&quot;Solution found&quot;)<br>        print(f&quot;{cubes[i].get_algorithm_str()}&quot;)<br>        return</pre><pre>    <em># Элитарность: лучшие исполнители переходят к следующему поколению без изменений</em><br>        if i &gt; self.elitism_num:<br>        <em># Копируем случайный куб с лучшим исполнителем</em><br>        self.__copy(cubes[i], cubes[rnd.randint(0, self.elitism_num)])<br>        evolution_type = rnd.randint(0, 5)</pre><pre>        if evolution_type == 0:<br>            cubes[i].execute(self.__rnd_permutation())<br>        elif evolution_type == 1:<br>            cubes[i].execute(self.__rnd_permutation())<br>            cubes[i].execute(self.__rnd_permutation())<br>        elif evolution_type == 2:<br>            cubes[i].execute(self.__rnd_full_rotation())<br>            cubes[i].execute(self.__rnd_permutation())<br>        elif evolution_type == 3:<br>            cubes[i].execute(self.__rnd_orientation())<br>            cubes[i].execute(self.__rnd_permutation())<br>        elif evolution_type == 4:<br>            cubes[i].execute(self.__rnd_full_rotation())<br>            cubes[i].execute(self.__rnd_orientation())<br>            cubes[i].execute(self.__rnd_permutation())<br>        elif evolution_type == 5:<br>            cubes[i].execute(self.__rnd_orientation())<br>            cubes[i].execute(self.__rnd_full_rotation())<br>            cubes[i].execute(self.__rnd_permutation())</pre><p>Если вы читали исходный код, то заметили такое понятие, как ориентация. По причинам, которые я объясню ниже, лучшие результаты принесло разделение полных вращений куба на две группы: вращения и ориентации:</p><pre>ROTATIONS = [&quot;x&quot;, &quot;x&#39;&quot;, &quot;x2&quot;, &quot;y&quot;, &quot;y&#39;&quot;, &quot;y2&quot;]<br>ORIENTATIONS = [&quot;z&quot;, &quot;z&#39;&quot;, &quot;z2&quot;]</pre><p>Вернемся к перестановкам — в списке у нас есть только два варианта, которые изменяют значения двух ребер:</p><pre># Перестановка двух ребер: грань U, нижнее и правое ребра<br>&quot;F&#39; L&#39; B&#39; R&#39; U&#39; R U&#39; B L F R U R&#39; U&quot;,</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/192/0*FkEDm-lMRf7bi9FD.png" /></figure><pre># Перестановка двух ребер: грань U, нижнее и левое ребра<br>&quot;F R B L U L&#39; U B&#39; R&#39; F&#39; L&#39; U&#39; L U&#39;&quot;,</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/192/0*rK6cYkxIBm326vt9.png" /></figure><p>Но как поменять местами значения двух ребер нижнего или заднего слоя? Один из вариантов — охватить все возможные перестановки, а не только две предыдущие. Однако работы будет много и риск возникновения ошибок слишком велик. Поэтому в стратегии эволюции и появляются вращения и ориентации. Таким образом, если нам нужно поменять местами два ребра на задней грани, вращения и ориентации будет достаточно, чтобы переместить куб в позицию, которая обрабатывается доступными перестановками.</p><p>Для полноты картины добавлю, что в теории ГА есть две важные концепции: мутация и кроссовер. Мутация предполагает изменение части существующего решения. Например:</p><pre>R <strong>L</strong> U2 D B’ R<br>R <strong>R</strong> U2 D B’ R</pre><p>В данном случае добавление ходов — это своего рода мутация.</p><p>Кроссовер же предполагает выбор двух возможных решений и создание потомства путем объединения их «генов». В случае с кубиком Рубика он может выглядеть так:</p><pre>Родитель 1 : <strong>R L U2</strong> D B’ R<br>Родитель 2 : F B R2 <strong>L U’ D</strong><br>Ребенок : <strong>R L U2 L U’ D</strong></pre><p>Однако на практике и для этой конкретной задачи кроссовер не приносил желаемых результатов и приводил к снижению производительности, поскольку состояние куба приходилось пересчитывать. Предполагаю, что если каждый шаг решения зависит от предыдущих, то, применив кроссовер, очень сложно добиться прогресса.</p><p>Что касается параметров, то с этой конфигурацией я получил хорошие результаты. Они означают, что в популяции будет 500 кубиков, 50 из которых мы продвинем к следующему поколению без изменений. Следовательно, оставшиеся 450 кубиков будут заменены мутацией, примененной к 50 случайным лучшим исполнителям. Если через 300 поколений решение не будет найдено, то придется уничтожить популяцию и начать заново (и так до 10 раз).</p><pre>population_size = 500<br>elitism_num = 50<br>max_generations = 300<br>max_resets = 10</pre><p>Если вы захотите поэкспериментировать с этими значениями, учтите, что меньшая численность популяции хоть и ускорит поколения, но также повысит риски застрять на месте из-за нехватки случайности в популяции.</p><h3>Запуск</h3><pre>python -m src.solver</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PF0m3P6Vycq-9YDZ.png" /></figure><p>Проверим правильность решения с помощью<a href="https://alg.cubing.net/"> симулятора куба</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/0*J7VTonNpG6nr8jfD.png" /></figure><p>Получилось! А запустив программу несколько раз, вы заметите, что решения будут различны.</p><h3>Хорошее ли это решение?</h3><p>Чтобы ответить на этот вопрос, понадобится больше теории. <a href="https://www.cube20.org/">Здесь </a>можно прочитать целую статью об этом, но вот самый важный вывод:</p><p><em>«Команда исследователей (при поддержке Google</em>) <em>решила каждую позицию кубика Рубика и установила, что каждая из них занимает не более двадцати ходов».</em></p><p>В предыдущем запуске решение состояло из 276 ходов, что далеко от оптимального. Однако имейте в виду, что в данном случае перестановки вносили постепенные изменения в очень маленькие части куба в качестве требования для работы ГА, поэтому это не очень справедливое сравнение. Для нашего подхода более близки методы, используемые для решения вслепую, а такие решения нередко находятся в диапазоне сотен ходов. Поэтому наше решение, возможно, не такое уж и плохое. 😉</p><p>Итак, какие же недостатки у ГА:</p><ul><li>Трудность нахождения лучшего решения. Обычно генетический алгоритм находит «достаточно хорошее» и продолжает работать над ним.</li><li>Настройка параметров может потребовать много времени и экспериментов.</li><li>Результаты недетерминированы. Вы получите разные решения, и время на их поиск во многих случаях может существенно различаться.</li></ul><h3>Заключение</h3><p>Это был интересный проект, а результаты получились вполне удовлетворительными. Если вы хотите поэкспериментировать или улучшить программу, то ловите <a href="https://www.github.com/rvaccarim/genetic_rubik">исходный код</a> на GitHub.</p><p>Благодарим за чтение!</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/9797/">Безградиентный подход к оптимизации нейронной сети</a></li><li><a href="https://nuancesprog.ru/p/9792/">Поиск с возвратом в решении типичных задач на собеседовании</a></li><li><a href="https://nuancesprog.ru/p/9768/">От Spotify к собственной рекомендательной системе</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://robertovaccari.com/">Roberto Vaccari</a>: <a href="https://robertovaccari.com/blog/2020_07_07_genetic_rubik/">Solving Rubik’s cube using Genetic Algorithms</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bcd3740cfa32" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D1%81%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D1%8C-%D0%BA%D1%83%D0%B1%D0%B8%D0%BA-%D1%80%D1%83%D0%B1%D0%B8%D0%BA%D0%B0-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-%D0%B3%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2-bcd3740cfa32">Как собрать кубик Рубика с помощью генетических алгоритмов</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Как автоматизировать электронную почту с помощью Python]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D1%83%D1%8E-%D0%BF%D0%BE%D1%87%D1%82%D1%83-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-python-a853877593e1?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/a853877593e1</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Tue, 22 Sep 2020 12:02:13 GMT</pubDate>
            <atom:updated>2020-09-22T12:02:13.591Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*AS4OMKxo2VMm1Asy.png" /></figure><p>С помощью Python можно с легкостью автоматизировать ежедневные задачи. Используя комбинацию API и простых для понимания библиотек, можно настроить системы, которые выполняют скрейпинг веб-сайтов, отправляют электронные письма и управляют данными и аналитикой.</p><p>Одной из наиболее распространенных задач, которые необходимо автоматизировать в корпоративной среде, является извлечение открытых государственных данных. Обычно для этого используют такие сайты, как data.gov, и другие конечные точки, в которых содержится информация о здравоохранении, торговле, транспорте, юриспруденции и многом другом.</p><p>В этой статье мы расскажем, как написать скрипт Python, который может скачивать определенный набор правительственных данных, а затем загружать его в электронное письмо и отправлять кому угодно.</p><p><a href="https://requests.readthedocs.io/en/master/">Здесь </a>можно найти документацию, которая поможет разобраться в том, как использовать библиотеку запросов Python, а также API Gmail. Так что если вы хотите автоматизировать электронные письма с помощью Python, то это отличное место для начала.</p><h3>Загрузка файла с помощью Python</h3><p>В первую очередь нам потребуется загрузить файл данных с помощью HTTP-запроса.</p><p>Преимущество Python в том, что большая часть сложности написания кода, такого как HTTP-запросы, была удалена. Вместо этого можно импортировать библиотеку запросов и использовать ее для публикации и получения запросов.</p><p>В этом случае файл, который мы будем загружать, даже получит простую конечную точку по ссылке ниже. Таким образом, вам не нужно использовать такую библиотеку, как Selenium, чтобы нажимать на кнопку загрузки.</p><p>Даже при наличии кнопки загрузки, вам следует проверить, есть ли у нее URL-адрес. Как правило, если есть URL-адрес, файл действительно легко загрузить по ссылке, вместо создания веб-краулера для поиска кнопки, которую нужно нажать.</p><pre><a href="https://data.medicaid.gov/api/views/u72p-j37s/rows.json?accessType=DOWNLOAD">https://data.medicaid.gov/api/views/u72p-j37s/rows.json?accessType=DOWNLOAD</a></pre><p>Этот файл содержит информацию о Медикейд (американская государственная программа медицинской помощи нуждающимся) и отдельных участниках. Она будет полезна для поставщиков медицинских услуг, которые могут использовать ее совместно со своими внутренними данными для лучшего понимания рынка.</p><p>Чтобы скачать файл, мы будем использовать функцию requests.get() для получения данных на указанный нами URL.</p><p>Для примера рассмотрим скрипт ниже:</p><pre># Часть 1: извлекаем данные.</pre><pre># Получаем веб-страницу, сохраняем ее в объекте Response и присваиваем текст.<br># Дополнительная информация: https://requests.readthedocs.io/en/master/api/<em>#requests.Response.</em></pre><pre># Этот URL содержит .csv-файл загрузки для<br># &#39;https://catalog.data.gov/dataset/&#39; \<br>#	&#39;share-of-medicaid-enrollees-in-managed-care&#39;,<br># который используется для отправки на адрес электронной почты.<br>csvFileURL = &#39;https://data.medicaid.gov/api/&#39; \<br>    &#39;views/u72p-j37s/rows.csv?accessType=DOWNLOAD&#39;<br>csvFileRequest = requests.get(csvFileURL)<br>csvFile = csvFileRequest.content</pre><p>Это легкий и быстрый способ, возвращающий CSV как часть запроса, который задан в качестве переменной. Мы будем использовать его позже, когда создадим письмо. А пока нам нужно настроить учетные данные для API Gmail.</p><h3>Настройка API Gmail</h3><p>Google значительно упростил настройку API. Перейдите в <a href="https://console.developers.google.com/">консоль API</a> <a href="https://console.developers.google.com/">Google</a>, затем выберите ENABLE APIS AND SERVICES и выполните поиск API Gmail.</p><p>Консоль API выглядит следующий образом:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_TMMiNHwO6kdFNnf.png" /></figure><p>После нажатия этой кнопки вы получаете поисковую систему, с помощью которой можно искать различные API. Она показана на изображении ниже.</p><p>Вы можете ввести Gmail, и он должен отобразиться только один раз.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kp0uwqXD_KzX9SVQ.png" /></figure><p>Затем выберите API Gmail, и под ним появится кнопка ENABLE.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6W3x6mOQoX3dtx13.png" /></figure><p>После нажатия этой кнопки вы можете загрузить свои учетные данные или использовать ключ API и секрет.</p><p>Наш код будет использовать JSON-загрузку, но затем вы можете преобразовать его в любой желаемый формат.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lkzf4p4K5RTnZhiE.png" /></figure><p>Теперь, когда все настроено, мы можем приступить к созданию функций для настройки, а затем автоматически отправлять электронные письма.</p><h3>Отправка писем с помощью API Gmail</h3><p>Теперь, когда мы нашли способ получить необходимые данные, нам нужно выяснить, как отправить электронное письмо.</p><p>Для этого воспользуемся библиотекой <a href="https://docs.python.org/3/library/email.examples.html">email</a>. С ее помощью можно настроить различные части электронного письма: отправитель, получатель, тема и т. д.</p><p>Мы будем использовать класс <a href="https://docs.python.org/2/library/email.mime.html">MIMEBase</a> в электронной почте, чтобы упростить настройку правильных точек данных и предоставить простой класс, который API Gmail будет использовать в дальнейшем для парсинга.</p><p>Использовать класс MIMEBase действительно просто, так как вы можете инициировать новый класс, а затем ссылаться на многие необходимые компоненты, такие как:</p><pre>message[‘from’] = test@gmail.com</pre><p>Ниже представлена вся функция, в которой установлены эти параметры:</p><pre><em># Функция, необходимая для части 2: отправка электронной почты с помощью API Google.</em><br><em># a) Создание сообщения</em><br>def create_message(sender, to, subject, csv):<br>    <em>#message = MIMEMultipart()</em><br>    message = MIMEMultipart()<br>    message[&#39;from&#39;] = sender<br>    message[&#39;to&#39;] = to<br>    message[&#39;subject&#39;] = subject</pre><pre>    <em># Отправка времени его обновления в качестве тела письма</em><br>    dt_object = datetime.utcnow() - timedelta(hours = 7)<br>    msg = MIMEText(&#39;Hi! Your file was updated.&#39; \<br>        &#39;\nTime of update: &#39; + dt_object.strftime(&#39;%m/%d/%Y, %I:%M:%S %p&#39;) \<br>        + &#39; (Los Angeles Time)&#39;)</pre><pre>    message.attach(msg)</pre><pre>    <em># Прикрепление файла .csv</em><br>    record = MIMEBase(&#39;application&#39;, &#39;octet-stream&#39;)<br>    <em># print(csv)</em><br>    record.set_payload(csv)<br>    encoders.encode_base64(record)<br>    record.add_header(&#39;Content-Disposition&#39;, &#39;attachment&#39;, filename=&#39;medicare.csv&#39;)<br>    message.attach(record)</pre><pre>    <em># Возврат сообщения</em><br>    raw = base64.urlsafe_b64encode(message.as_bytes())<br>    raw = raw.decode()<br>    return {&#39;raw&#39;: raw}</pre><p>Обратите внимание, что в конце мы используем функцию urlsafe_b64encode, которая установит сообщение в байтах. Это делается для упрощения передачи данных электронной почты в API Gmail.</p><p>Теперь пришло время отправить первое автоматическое письмо.</p><h3>Отправка первого автоматического письма с помощью Python</h3><p>После настройки учетных данных API Gmail мы можем отправить наше первое электронное письмо.</p><p>Мы будем использовать сервисную переменную, установленную с API Gmail и учетными данными.</p><p>Этот процесс показан ниже в функции send_message:</p><pre><em># b) Отправка сообщения</em><br>def send_message(service, user_id, message):<br>    try:<br>        message = service.users().messages(). \<br>        send(userId=user_id, body=message).execute()<br>        print(&#39;Message Id: %s&#39; % message[&#39;id&#39;])<br>        return message<br>    except Exception as e:<br>        print(&#39;An error occurred: %s&#39; % e)<br>        return None</pre><p>Теперь все, что нам нужно сделать, — передать сообщение и выполнить код.</p><p>Весь скрипт приведен ниже:</p><pre><em># 1. Получение данных из URL-адреса каждый раз, когда появляется новый набор данных.</em><br><em># 2. Отправка электронного письма с помощью API Google.</em></pre><pre><em># Подготовка:</em><br><em># 1) Создайте проект в консоли API Google в верхнем левом углу GDC</em><br><em># 2) Включите API Gmail, нажав &#39;Library&#39; на левой боковой панели</em><br><em># 3) Создайте учетные данные ID клиента OAuth на верхней боковой панели</em><br><em># 4) Краткое руководство по Python в URL (см. ниже)</em><br><em># 5) pip install --upgrade google-api-python-client \</em><br><em># google-auth-httplib2 google-auth-oauthlib</em><br><em># 6) Доступ к Gmail</em><br><em># 7) Создание электронного письма</em></pre><pre><em># Загрузка текстового файла с последней обновленной датой или даже данных!</em><br><em># Отправка электронного письма, если дата обновлена.</em></pre><pre><em># Требуемые модули для API Google </em><br>from __future__ import print_function<br>import pickle<br>import os.path<br>from googleapiclient.discovery import build<br>from google_auth_oauthlib.flow import InstalledAppFlow<br>from google.auth.transport.requests import Request</pre><pre><em># Возможность загрузить страницу</em><br><em># Возможность чтения файлов без их загрузки,</em><br><em># что позволяет проверять наличие обновлений в режиме реального времени.</em><br>import requests</pre><pre><em># Возможность запуска цикла с использованием модуля time</em><br>import time</pre><pre><em># Возможность конвертировать значение времени в объект datetime</em><br>from datetime import datetime, timedelta<br>import math</pre><pre><em># Возможность создать электронное письмо</em><br>from email import encoders<br>from email.mime.base import MIMEBase<br>from email.mime.multipart import MIMEMultipart<br>from email.mime.text import MIMEText<br>import base64<br>import os</pre><pre><em># При изменении этих областей файл token.pickle удаляется.</em><br><em># Эта область нужна для полного доступа к API Google Mail.</em><br>SCOPES = &#39;https://mail.google.com/&#39;</pre><pre><em># Функция, необходимая для части 2: отправка электронной почты с помощью API Google.</em><br><em># a) Создание сообщения</em><br>def create_message(sender, to, subject, csv):<br>    <em>#message = MIMEMultipart()</em><br>    message = MIMEMultipart()<br>    message[&#39;from&#39;] = sender<br>    message[&#39;to&#39;] = to<br>    message[&#39;subject&#39;] = subject</pre><pre>    <em># Отправка времени его обновления в качестве тела письма</em><br>    dt_object = datetime.utcnow() - timedelta(hours = 7)<br>    msg = MIMEText(&#39;Hi! Your file was updated.&#39; \<br>        &#39;\nTime of update: &#39; + dt_object.strftime(&#39;%m/%d/%Y, %I:%M:%S %p&#39;) \<br>        + &#39; (Los Angeles Time)&#39;)</pre><pre>    message.attach(msg)</pre><pre>    <em># Прикрепление .csv-файла</em><br>    record = MIMEBase(&#39;application&#39;, &#39;octet-stream&#39;)<br>    <em># print(csv)</em><br>    record.set_payload(csv)<br>    encoders.encode_base64(record)<br>    record.add_header(&#39;Content-Disposition&#39;, &#39;attachment&#39;, filename=&#39;medicare.csv&#39;)<br>    message.attach(record)</pre><pre>    <em># Возврат сообщения</em><br>    raw = base64.urlsafe_b64encode(message.as_bytes())<br>    raw = raw.decode()<br>    return {&#39;raw&#39;: raw}</pre><pre><em># b) Отправка сообщения</em><br>def send_message(service, user_id, message):<br>    try:<br>        message = service.users().messages(). \<br>        send(userId=user_id, body=message).execute()<br>        print(&#39;Message Id: %s&#39; % message[&#39;id&#39;])<br>        return message<br>    except Exception as e:<br>        print(&#39;An error occurred: %s&#39; % e)<br>        return None<br></pre><pre><em># Часть 1: извлекаем данные.</em></pre><pre><em># Получаем веб-страницу, сохраняем ее в объекте Response и присваиваем текст.</em><br><em># Дополнительная информация: https://requests.readthedocs.io/en/master/api/#requests.Response.</em></pre><pre><em># Этот URL содержит .csv-файл загрузки для</em><br><em># &#39;https://catalog.data.gov/dataset/&#39; \</em><br><em>#	&#39;share-of-medicaid-enrollees-in-managed-care&#39;,</em><br><em># который используется для отправки на адрес электронной почты.</em><br>csvFileURL = &#39;https://data.medicaid.gov/api/&#39; \<br>    &#39;views/u72p-j37s/rows.csv?accessType=DOWNLOAD&#39;<br>csvFileRequest = requests.get(csvFileURL)<br>csvFile = csvFileRequest.content</pre><pre><em># ПРИМЕЧАНИЕ: часть ниже необходима, если файл не является .csv.</em><br><em># Теперь мы добавим важную команду метаданных SEP.</em><br><em># Она говорит Excel о том, что нужно использовать разделитель.</em><br><em>#decoded = csvFile.decode(&#39;utf-8&#39;)</em><br><em>#decoded = &#39;SEP=,\n&#39; + decoded</em><br><em>#csvFile = decoded.encode(&#39;utf-8&#39;)</em></pre><pre><em># Этот URL-адрес содержит загрузку .json для</em><br><em># &#39;https://catalog.data.gov/dataset/&#39; \</em><br><em>#	&#39;share-of-medicaid-enrollees-in-managed-care&#39;</em><br><em># которая используется для сравнения файлов.</em><br>jsonOfFile = &#39;https://data.medicaid.gov/api/views/u72p-j37s/&#39; \<br>    &#39;rows.json?accessType=DOWNLOAD&#39;</pre><pre>r = requests.get(jsonOfFile)<br>firstJSON = r.text</pre><pre><em># Часть 2: использование API Google для отправки электронного письма с обновленными метаданными.</em></pre><pre><em># Выясните, был ли изменен файл.</em><br><em># Изначально проверялась последняя дата обновления,</em><br><em># но потом мне пришло в голову, что в один день</em><br><em># может быть сделано несколько изменений.</em><br><em># Старый код: print(BeautifulSoup(URL, &#39;html.parser). \</em><br><em># find_all(&#39;td&#39;)[0].get_text())</em><br><em># возвращает дату последнего обновления на основе текущего макета сайта.</em></pre><pre><em># Теперь новый код сравнивает версию файлов .json каждую минуту.</em></pre><pre><em># Этот фрагмент будет запускать код каждые 60 секунд (за исключением первой итерации)</em><br><em># вместо time.sleep(60), который запускает цикл каждые 60 секунд.</em><br><em># В последнем случае коду может потребоваться некоторое время &quot;x&quot; для завершения выполнения,</em><br><em># поэтому общее время было бы 60 + х секунд (что плохо).</em></pre><pre>r = requests.get(jsonOfFile)<br>secondJSON = r.text</pre><pre><em># Если сайт был обновлен или скрипт только начался, произойдет отправка сообщения.</em><br>if firstJSON != secondJSON:</pre><pre>    <em># Создание сообщения</em><br>    sender = &#39;test1@gmail.com&#39;<br>    to = &#39;test2@gmail.com&#39;<br>    subject = &#39;The Medicare metadata has been updated&#39;<br>    message = create_message(sender, to, subject, csvFile)</pre><pre>    <em># Отправка сообщения с помощью API Google </em><br>    creds = None<br>    <em># Файл token.pickle хранит токены доступа и обновления пользователя и</em><br>    <em># создается автоматически при первом завершении потока авторизации.</em><br>    if os.path.exists(&#39;token.pickle&#39;):<br>        with open(&#39;token.pickle&#39;, &#39;rb&#39;) as token:<br>            creds = pickle.load(token)<br>    <em># Если нет доступных (действительных) учетных данных, предоставьте пользователю возможность войти в систему.</em><br>    if not creds or not creds.valid:<br>        if creds and creds.expired and creds.refresh_token:<br>            creds.refresh(Request())<br>        else:<br>            flow = InstalledAppFlow.from_client_secrets_file(<br>                &#39;credentials.json&#39;, SCOPES)<br>            creds = flow.run_local_server(port=0)<br>        <em># Сохранение учетных данных для следующего запуска</em><br>        with open(&#39;token.pickle&#39;, &#39;wb&#39;) as token:<br>            pickle.dump(creds, token)</pre><pre>    service = build(&#39;gmail&#39;, &#39;v1&#39;, credentials=creds)<br>    send_message(service, sender, message)</pre><pre>    <em># Обновление переменной</em><br>    firstJSON = secondJSON</pre><pre>    print(&#39;Message sent&#39;)</pre><h3>Настало время приступить к автоматизации</h3><p>Мы надеемся, что этот скрипт поможет вам автоматизировать электронные письма с помощью Python.</p><p>В приведенных выше примерах скрипт был составлен вручную. Однако, если вы хотите более эффективной автоматизации, вы можете использовать такую среду, как Airflow. Мы не рекомендуем пытаться создать собственный фреймворк автоматизации, особенно когда есть так много отличных вариантов.</p><p>Вот и все, удачной автоматизации!</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/9713/">Статистические типы данных, используемые в машинном обучении</a></li><li><a href="https://nuancesprog.ru/p/9668/">Продвинутый взгляд на рекурсию</a></li><li><a href="https://nuancesprog.ru/p/7518/">Не учите машинное обучение</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://medium.com/@SeattleDataGuy?source=post_page-----386b4e2d5395----------------------">SeattleDataGuy</a>: <a href="https://medium.com/better-programming/how-to-automate-your-emails-with-python-386b4e2d5395">How to Automate Your Emails With Python</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a853877593e1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D0%B7%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C-%D1%8D%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D1%83%D1%8E-%D0%BF%D0%BE%D1%87%D1%82%D1%83-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-python-a853877593e1">Как автоматизировать электронную почту с помощью Python</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Дизайн физического движка]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD-%D1%84%D0%B8%D0%B7%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE-%D0%B4%D0%B2%D0%B8%D0%B6%D0%BA%D0%B0-c29dc854d03?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/c29dc854d03</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[cpp]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Mon, 21 Sep 2020 12:02:21 GMT</pubDate>
            <atom:updated>2020-09-21T12:02:21.549Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/629/1*SASena_zbOTuXRlknXG8RA.png" /></figure><p>Когда <a href="https://www.youtube.com/c/TheChernoProject/videos">The Cherno</a> анонсировал серию игровых движков, я как раз начинал разрабатывать свой собственный. Мне хотелось поскорее узнать мнение профессионала в этом вопросе. Будучи программистом-самоучкой, трудно не сомневаться в себе, постоянно размышляя, правильно ли все сделано или так лишь кажется.</p><p>Недавно он публиковал видео, в которых затронул многие аспекты своего движка, такие как физика и системы компонентов. Эти темы я и хотел изучить на своем опыте. Однако в конечном счете он использовал библиотеки вместо того, чтобы пройтись по внутренним составляющим! Я не против библиотек, но использовать их в самых интересных частях? Я посчитал, что такой подход обнуляет весь смысл создания серии собственных движков.</p><p>Конечно, библиотеки помогают сэкономить много времени, но это был мой первый проект на C++, а главной целью было пройтись по всем основным элементам движка: ввод, графика, физика, компоненты и звук. Я хотел узнать, как все они работают совместно с C++ и дизайном кода в целом.</p><p>Уверен, что некоторые также интересуются тем, как работают эти системы. Все в итоге оказывается намного проще, чем кажется на первый взгляд.</p><h3>Приступаем к созданию движка</h3><p>Физические движки отвечают за определение места нахождения каждого объекта в сцене в определенный промежуток времени. Объекты могут сталкиваться друг с другом, а затем выбирать ответ несколькими способами. Эту общую проблему пользователь может настроить на нескольких уровнях. Есть ли необходимость в коллайдере? Нужно ли реагировать на столкновения? Нужно ли моделировать динамику? Возможно, понадобится динамика, но не гравитация. Здесь требуется четкое планирование и надежный дизайн.</p><p>Я просмотрел способы сортировки движков у <a href="https://github.com/bulletphysics/bullet3">bullet</a> и <a href="https://github.com/erincatto/box2d">box2d</a> и пришел к выводу, что первый более устойчив. Определившись с тем, что мне необходимо, я построил свой дизайн. <a href="https://www.toptal.com/game/video-game-physics-part-i-an-introduction-to-rigid-body-dynamics">Хороших статей</a>, посвященных сложной математике, довольно много, поэтому я сосредоточусь лишь на аспекте дизайна, так как он тоже настоящая головная боль.</p><p>Проблему можно разделить на 3 части: динамика, обнаружение столкновений и реакция на столкновения.</p><h3>Динамика</h3><p>Динамика занимается вычислением новых позиций объектов на основе их скорости и ускорения. Из школьной программы мы знаем четыре кинематических уравнения и три закона Ньютона, которые описывают движение объектов. Нам нужны только первое и третье кинематические уравнения, остальные скорее пригодятся для анализа ситуаций, а не моделирования. Таким образом, мы получаем:</p><p>Мы можем предоставить себе больше контроля, используя 2-й закон Ньютона и исключив ускорение:</p><p>Каждый объект должен хранить три свойства: скорость, массу и результирующую силу. Здесь мы и находим первое решение для дизайна: результирующую силу можно представить как списком, так и единичным вектором. В школе мы составляем диаграммы сил и суммируем их, что предполагает хранение списка. Он дает возможность устанавливать силу, но позже его нужно удалить, что может доставить неудобства пользователю. При дальнейшем размышлении выясняется, что результирующая сила — это полная сила, приложенная в <em>одном </em>кадре, следовательно мы можем использовать вектор и очищать его в конце каждого обновления. При таком подходе пользователь может применять силу, добавив ее, а удаление происходит автоматически. Таким образом, мы не только сокращаем код, но и увеличиваем производительность, поскольку не суммируем силы, а используем промежуточную сумму.</p><p>В этой структуре будет храниться информация об объекте:</p><pre>struct Object {<br>    vector3 Position; <em>// Структура с 3 числами с плавающей запятой для x, y, z или i + j + k</em><br>    vector3 Velocity;<br>    vector3 Force;<br>    float Mass;<br>};</pre><p>Нам нужен способ отслеживать объекты, которые хотим обновить. В классическом подходе используется PhysicsWorld со списком объектов и функцией step, которая выполняет по ним цикл. Ниже пример того, как это может выглядеть (для краткости я опустил файлы header/cpp):</p><pre>class PhysicsWorld {<br>private:<br>    std::vector&lt;Object*&gt; m_objects;<br>    vector3 m_gravity = vector3(0, -9.81f, 0);<br> <br>public:<br>    void AddObject   (Object* object) { <em>/* ... */</em> }<br>    void RemoveObject(Object* object) { <em>/* ... */</em> }<br> <br>    void Step(<br>        float dt)<br>    {<br>        for (Object* obj : m_objects) {<br>            obj-&gt;Force += obj-&gt;Mass * m_gravity; <em>// Применяем силу</em><br> <br>            obj-&gt;Velocity += obj-&gt;Force / obj-&gt;Mass * dt;<br>            obj-&gt;Position += obj-&gt;Velocity * dt;<br> <br>            obj-&gt;Force = vector3(0, 0, 0); <em>// Сбрасываем результирующую силу в конце</em><br>        }<br>    }<br>};</pre><p>Обратите внимание на использование указателей: такой подход переносит ответственность за фактическое хранение объектов на другие системы, предоставляя физическому движку заботы о физике, а не распределении памяти.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FcrKrkn-RIOU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DcrKrkn-RIOU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FcrKrkn-RIOU%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/58b8f59f07cb09b2c7c03284fcd3f092/href">https://medium.com/media/58b8f59f07cb09b2c7c03284fcd3f092/href</a></iframe><p><a href="https://youtu.be/sHZEs-oQTI4">https://youtu.be/sHZEs-oQTI4</a></p><p>Таким образом вы можете моделировать все что угодно: от парящих в воздухе объектов до солнечных систем.</p><h3>Обнаружение столкновений</h3><p>Обнаружение столкновений — более комплексный процесс, но мы можем облегчить его с помощью нескольких хитрых приемов. Давайте подумаем, что нужно найти в первую очередь. Просмотрев некоторые примеры столкновения объектов, можно заметить, что в большинстве случаев на каждой форме есть самая дальняя точка, находящаяся внутри другой.</p><p>Оказалось, этого достаточно, чтобы отреагировать на столкновение. По этим двум точкам мы можем определить нормаль и то, насколько глубоко объекты находятся друг в друге. Этот важный шаг предполагает возможность абстрагироваться от концепции различных форм и беспокоиться только о точках в ответе.</p><p>Перейдем к коду. Нам понадобится несколько вспомогательных структур, которые я упомяну в первую очередь.</p><pre>struct CollisionPoints {<br>    vector3 A; <em>// Самая дальняя точка A в B</em><br>    vector3 B; <em>// Самая дальняя точка B в A</em><br>    vector3 Normal; <em>// Нормализированный BA</em><br>    float Depth;    <em>// Длина BA</em><br>    bool HasCollision;<br>};<br> <br>struct Transform { <em>// Описывает расположение объектов</em><br>    vector3 Position;<br>    vector3 Scale;<br>    quaternion Rotation;<br>};</pre><p>У каждой формы будет свой тип коллайдера, содержащий ее свойства, и база для их сохранения. Коллайдер любого типа должен иметь возможность выполнить проверку на наличие столкновения с любым другим типом, поэтому мы добавляем функции в базу каждого из них. Эти функции будут принимать Transform, поэтому коллайдеры смогут использовать относительные координаты. Я продемонстрирую примеры только со сферами и плоскостями, но код можно повторить для любого количества коллайдеров.</p><pre>struct Collider {<br>    virtual CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const Collider* collider,<br>        const Transform* colliderTransform) const = 0;<br> <br>    virtual CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const SphereCollider* sphere,<br>        const Transform* sphereTransform) const = 0;<br> <br>    virtual CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const PlaneCollider* plane,<br>        const Transform* planeTransform) const = 0;<br>};</pre><p>Создадим оба типа коллайдеров и посмотрим, как они взаимодействуют. Сфера определяется как точка и радиус, а плоскость — как вектор и расстояние. Переопределяем функции из Collider, а о работе пока не беспокоимся.</p><p>Для каждого коллайдера можно выбрать, какие другие коллайдеры он будет обнаруживать, заполнив или оставив пустыми эти функции. В данном случае нам не нужны столкновения между плоскостями, поэтому мы возвращаем пустую CollisionPoints.</p><pre>struct SphereCollider<br>    : Collider<br>{<br>    vector3 Center;<br>    float Radius;<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const Collider* collider,<br>        const Transform* colliderTransform) const override<br>    {<br>        return collider-&gt;TestCollision(colliderTransform, this, transform);<br>    }<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const SphereCollider* sphere,<br>        const Transform* sphereTransform) const override<br>    {<br>        return algo::FindSphereSphereCollisionPoints(<br>            this, transform, sphere, sphereTransform);<br>    }<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const PlaneCollider* plane,<br>        const Transform* planeTransform) const override<br>    {<br>        return algo::FindSpherePlaneCollisionPoints(<br>            this, transform, plane, planeTransform);<br>    }<br>};</pre><p>Мы можем добавить функцию для тестирования основы и использовать технику под названием «<a href="https://en.wikipedia.org/wiki/Double_dispatch">двойная диспетчеризация</a>«. Она использует преимущества системы типов для определения обоих типов коллайдеров с помощью обмена аргументами, определяя первый, а затем второй тип с помощью двух вызовов TestCollision. Это избавляет нас от необходимости знать типы проверяемых коллайдеров, таким образом полностью абстрагируя концепцию различных форм за пределами обнаружения столкновений.</p><pre>struct PlaneCollider<br>    : Collider<br>{<br>    vector3 Plane;<br>    float Distance;<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const Collider* collider,<br>        const Transform* colliderTransform) const override<br>    {<br>        return collider-&gt;TestCollision(colliderTransform, this, transform);<br>    }<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const SphereCollider* sphere,<br>        const Transform* sphereTransform) const override<br>    {<br>        <em>// Повторно используем код сферы</em><br>        return sphere-&gt;TestCollision(sphereTransform, this, transform);<br>    }<br> <br>    CollisionPoints TestCollision(<br>        const Transform* transform,<br>        const PlaneCollider* plane,<br>        const Transform* planeTransform) const override<br>    {<br>        return {}; <em>// Отсутствие столкновения plane-plane</em><br>    }<br>};</pre><p>Cо множеством классов с сетью похожих функций может возникнуть путаница относительно того, где находится фактический код. Очевидно, что Sphere-Sphere будет находиться в файле Sphere.cpp, но Sphere-Plane может быть как в Sphere.cpp, так и в Plane.cpp. Обнаружить его без поиска невозможно, а при наличии большого количества файлов ситуация затрудняется еще сильнее.</p><p>Чтобы обойти эту проблему, создадим пространство имен algo и поместим в него фактическую работу. Нам понадобится функция для каждой пары коллайдеров, которую нужно будет проверить. Я создал Sphere-Sphere и Sphere-Plane, но не Plane-Plane, потому что она вряд ли пригодится. Я не буду подробно описывать эти функции, так как по сути они не являются частью дизайна, но вы можете просмотреть их <a href="https://github.com/IainWinter/IwEngine/blob/master/IwEngine/src/physics/Collision/algo/ManifoldFactory.cpp">исходный код</a>.</p><pre>namespace algo {<br>    CollisionPoints FindSphereSphereCollisionPoints(<br>        const SphereCollider* a, const Transform* ta,<br>        const SphereCollider* b, const Transform* tb);<br> <br> <br>    CollisionPoints FindSpherePlaneCollisionPoints(<br>        const SphereCollider* a, const Transform* ta,<br>        const PlaneCollider* b, const Transform* tb);<br>}</pre><p>Эти коллайдеры можно использовать как сами по себе, так и прикрепить их к объекту. Заменяем Position<em> </em>на Transform<em> </em>в Object. В динамике мы по-прежнему используем только позицию, но при обнаружении столкновений также можем применить масштаб и вращение. Здесь нужно принять непростое решение. На данный момент я собираюсь применить указатель Transform, но мы еще вернемся к этому вопросу и узнаем, почему это не лучший вариант.</p><pre>struct Object {<br>    float Mass;<br>    vector3 Velocity;<br>    vector3 Force;<br> <br>    Collider* Collider;<br>    Transform* Transform;<br>};</pre><p>Хорошая практика дизайна — разделять различные аспекты сложных функций, таких как Step, в отдельные для улучшения читабельности кода. Поэтому давайте добавим еще одну функцию ResolveCollisions в PhysicsWorld.</p><p>Для начала еще одна вспомогательная структура:</p><pre>struct Collision {<br>    Object* ObjA;<br>    Object* ObjB;<br>    CollisionPoints Points;<br>};</pre><p>Повторюсь, у нас есть PhysicsWorld (я сокращаю части, которые мы уже рассмотрели):</p><pre>class PhysicsWorld {<br>private:<br>    std::vector&lt;Object*&gt; m_objects;<br>    vector3 m_gravity = vector3(0, -9.81f, 0);<br> <br>public:<br>    void AddObject   (Object* object) { <em>/* ... */</em> }<br>    void RemoveObject(Object* object) { <em>/* ... */</em> }<br> <br>    void Step(<br>        float dt)<br>    {<br>        ResolveCollisions(dt);<br> <br>        for (Object* obj : m_objects) { <em>/* ... */</em> }<br>    }<br> <br>    void ResolveCollisions(<br>        float dt)<br>    {<br>        std::vector&lt;Collision&gt; collisions;<br>        for (Object* a : m_objects) {<br>            for (Object* b : m_objects) {<br>                if (a == b) break;<br> <br>                if (    !a-&gt;Collider<br>                    || !b-&gt;Collider)<br>                {<br>                    continue;<br>                }<br> <br>                CollisionPoints points = a-&gt;Collider-&gt;TestCollision(<br>                    a-&gt;Transform,<br>                    b-&gt;Collider,<br>                    b-&gt;Transform);<br> <br>                if (points.HasCollision) {<br>                    collisions.emplace_back(a, b, points);<br>                }<br>            }<br>        }<br> <br>        <em>// Решение столкновений</em><br>    }<br>};</pre><p>Код выглядит хорошо, а благодаря двойной диспетчеризации достаточно лишь одного вызова TestCollision. Вызов оператора break в цикле for предоставляет уникальные пары, что исключает проверку одних и тех же объектов дважды.</p><p>Есть лишь один неприятный момент: поскольку порядок объектов неизвестен, иногда вы будете получать проверку Sphere-Plane, а временами — Plane-Sphere. Если бы мы просто вызвали функцию algo для Sphere-Plane, то получили бы реверсивный ответ. Таким образом, нам нужно добавить немного кода в коллайдер плоскости, чтобы поменять порядок CollisionPoints.</p><pre>CollisionPoints PlaneCollider::TestCollision(<br>    const Transform* transform,<br>    const SphereCollider* sphere,<br>    const Transform* sphereTransform) const<br>{<br>    <em>// Повторно вводим код сферы</em><br>    CollisionPoints points = sphere-&gt;TestCollision(sphereTransform, this, transform);<br> <br>    vector3 T = points.A; <em>// У вас может быть алгоритм Plane-Sphere для обмена</em><br>    points.A = points.B;<br>    points.B = T;<br> <br>    points.Normal = -points.Normal;<br> <br>    return points;<br>}</pre><p>Теперь, когда мы обнаружили столкновение, нужно как-то отреагировать на него.</p><h3>Реакция на столкновения</h3><p>Поскольку мы заменили концепцию различных форм на точки, реакция на столкновение — это практически чистая математика. Дизайн относительно прост по сравнению с тем, что рассмотрено выше. А начнем мы с концепции Solver. Он используется для <em>решения </em>проблем в PhysicsWorld и представляет собой импульс от столкновения или изменение исходной позиции — все, что вы захотите реализовать.</p><p>Начнем с интерфейса:</p><pre>class Solver {<br>public:<br>    virtual void Solve(<br>        std::vector&lt;Collision&gt;&amp; collisions,<br>        float dt) = 0;<br>};</pre><p>В PhysicsWorld нам понадобится еще один список для хранения, а также функции для их добавления и удаления. После того, как мы сгенерировали список столкновений, мы можем передать его каждому солверу.</p><pre>class PhysicsWorld {<br>private:<br>    std::vector&lt;Object*&gt; m_objects;<br>    std::vector&lt;Solver*&gt; m_solvers;<br>    vector3 m_gravity = vector3(0, -9.81f, 0);<br> <br>public:<br>    void AddObject   (Object* object) { <em>/* ... */</em> }<br>    void RemoveObject(Object* object) { <em>/* ... */</em> }<br> <br>    void AddSolver   (Solver* solver) { <em>/* ... */</em> }<br>    void RemoveSolver(Solver* solver) { <em>/* ... */</em> }<br> <br>    void Step(float dt) { <em>/* ... */</em> }<br> <br>    void ResolveCollisions(<br>        float dt)<br>    {<br>        std::vector&lt;Collision&gt; collisions;<br>        for (Object* a : m_objects) { <em>/* ... */</em> }<br> <br>        for (Solver* solver : m_solvers) {<br>            solver-&gt;Solve(collisions, dt);<br>        }<br>    }<br>};</pre><p>В предыдущем разделе основное внимание уделялось дизайну, здесь же все зависит от реализуемых солверов. Я создал импульсный и позиционный солверы, которые, кажется, подходят для большинства ситуаций. Для краткости, я не буду останавливаться на математике, но вы можете просмотреть исходный код для импульсного солвера <a href="https://github.com/IainWinter/IwEngine/blob/master/IwEngine/src/physics/Dynamics/ImpulseSolver.cpp">здесь </a>и для позиционного — <a href="https://github.com/IainWinter/IwEngine/blob/master/IwEngine/src/physics/Dynamics/SmoothPositionSolver.cpp">здесь</a>.</p><p>Демо:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FQ_KAqCmEgyA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DQ_KAqCmEgyA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FQ_KAqCmEgyA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/e235d6eacb9ebb431b6dab8ea14af0cc/href">https://medium.com/media/e235d6eacb9ebb431b6dab8ea14af0cc/href</a></iframe><h3>Другие опции</h3><p>Настоящая мощь физических движков заключается в опциях, предоставляемых пользователю. Рассмотрим различные варианты, которые мы можем добавить в этом примере.</p><p>В большинстве игр присутствует сочетание объектов, одни из которых моделируют динамику, а другие представляют собой статические препятствия. Также необходимы триггеры — объекты, не проходящие реакцию на столкновение, но запускающие события, на которые реагируют внешние системы, например флаг окончания уровня. Внесем некоторые незначительные изменения, чтобы упростить настройку этих параметров.</p><p>Самое большое изменение, которое мы можем внести, — это различие между объектами, имитирующими динамику, и теми, что не имитируют динамику. Поскольку динамическим объектам требуется еще много настроек, давайте отделим их от тех элементов, что необходимы для обнаружения столкновений. Мы можем разделить Object на структуры CollisionObject и Rigidbody. Rigidbody будет наследовать от CollisionObject для повторного использования свойств коллайдера и легкости хранения обоих типов.</p><p>Получаем две структуры. dynamic_cast можно использовать, чтобы выяснить, действительно ли CollisionObject является Rigidbody, но в таком случае код немного удлинится. Поэтому я предпочитаю добавлять логический флаг даже несмотря на то, что так делать не советуют. Мы также можем добавить флаг, чтобы объект действовал как триггер, и функцию для обратного вызова. И раз уж такое дело, давайте повысим безопасность, защитив исходные значения.</p><pre>struct CollisionObject {<br>protected:<br>    Transform* m_transform;<br>    Collider* m_collider;<br>    bool m_isTrigger;<br>    bool m_isDynamic;<br> <br>    std::function&lt;void(Collision&amp;, float)&gt; m_onCollision;<br> <br>public:<br>    <em>// Геттеры и сеттеры, отсутствие сеттера для isDynamic</em><br>};</pre><p>В Rigidbody можно добавить еще много настроек. У каждого объекта должна быть собственная гравитация, трение и упругость. Это откроет двери для всевозможных эффектов, основанных на физике. В игре у вас может быть способность на время изменять гравитацию в пространстве. Некоторые объекты могут быть упругими, а другие — более твердыми. Пол можно сделать из льда для скольжения и усложнения испытания.</p><pre>struct Rigidbody<br>    : CollisionObject<br>{<br>private:<br>    vector3 m_gravity;  <em>// Гравитационное ускорение</em><br>    vector3 m_force;    <em>// Результирующая сила</em><br>    vector3 m_velocity;<br> <br>    float m_mass;<br>    bool m_takesGravity; <em>// Если rigidbody заберет у мира гравитацию</em><br> <br>    float m_staticFriction;  <em>// Коэффициент статического трения</em><br>    float m_dynamicFriction; <em>// Коэффициент динамического трения</em><br>    float m_restitution;     <em>// Эластичность столкновений (упругость)</em><br> <br>public:<br>    <em>// Геттеры и сеттеры</em><br>};</pre><p>Также разделим PhysicsWorld на CollisionWorld и DynamicsWorld. Функцию Step можно переместить в DynamicsWorld, а ResolveCollisions — в CollisionWorld. Это избавляет тех, кому динамика не нужна, от необходимости просматривать бесполезные функции.</p><p>Мы можем внести некоторые изменения в функцию ResolveCollisions для исправления работы триггеров. Разделим ее на части для удобства чтения. Если вам нужны события в масштабе всей программы, добавьте в мир обратный вызов.</p><pre>class CollisionWorld {<br>protected:<br>    std::vector&lt;CollisionObject*&gt; m_objects;<br>    std::vector&lt;Solver*&gt; m_solvers;<br> <br>    std::function&lt;void(Collision&amp;, float)&gt; m_onCollision;<br> <br>public:<br>    void AddCollisionObject   (CollisionObject* object) { <em>/* ... */</em> }<br>    void RemoveCollisionObject(CollisionObject* object) { <em>/* ... */</em> }<br> <br>    void AddSolver   (Solver* solver) { <em>/* ... */</em> }<br>    void RemoveSolver(Solver* solver) { <em>/* ... */</em> }<br> <br>    void SetCollisionCallback(std::function&lt;void(Collision&amp;, float)&gt;&amp; callback) { <em>/* ... */</em> }<br> <br>    void SolveCollisions(<br>        std::vector&lt;Collision&gt;&amp; collisions,<br>        float dt)<br>    {<br>        for (Solver* solver : m_solvers) {<br>            solver-&gt;Solve(collisions, dt);<br>        }<br>    }<br> <br>    void SendCollisionCallbacks(<br>        std::vector&lt;Collision&gt;&amp; collisions,<br>        float dt)<br>    {<br>        for (Collision&amp; collision : collisions) {<br>            m_onCollision(collision, dt);<br> <br>            auto&amp; a = collision.ObjA-&gt;OnCollision();<br>            auto&amp; b = collision.ObjB-&gt;OnCollision();<br> <br>            if (a) a(collision, dt);<br>            if (b) b(collision, dt);<br>        }<br>    }<br> <br>    void ResolveCollisions(<br>        float dt)<br>    {<br>        std::vector&lt;Collision&gt; collisions;<br>        std::vector&lt;Collision&gt; triggers;<br>        for (CollisionObject* a : m_objects) {<br>            for (CollisionObject* b : m_objects) {<br>                if (a == b) break;<br> <br>                if (    !a-&gt;Col()<br>                    || !b-&gt;Col())<br>                {<br>                    continue;<br>                }<br> <br>                CollisionPoints points = a-&gt;Col()-&gt;TestCollision(<br>                    a-&gt;Trans(),<br>                    b-&gt;Col(),<br>                    b-&gt;Trans());<br> <br>                if (points.HasCollision) {<br>                    if (    a-&gt;IsTrigger()<br>                        || b-&gt;IsTrigger())<br>                    {<br>                        triggers.emplace_back(a, b, points);<br>                    }<br> <br>                    else {<br>                        collisions.emplace_back(a, b, points);<br>                    }<br>                }<br>            }<br>        }<br> <br>        SolveCollisions(collisions, dt); <em>// Don&#39;t solve triggers</em><br> <br>        SendCollisionCallbacks(collisions, dt);<br>        SendCollisionCallbacks(triggers, dt);<br>    }<br>};</pre><p>Для удобства чтения также разделим функцию Step на части:</p><pre>class DynamicsWorld<br>    : public CollisionWorld<br>{<br>private:<br>    vector3 m_gravity = vector3(0, -9.81f, 0);<br> <br>public:<br>    void AddRigidbody(<br>        Rigidbody* rigidbody)<br>    {<br>        if (rigidbody-&gt;TakesGravity()) {<br>            rigidbody-&gt;SetGravity(m_gravity);<br>        }<br> <br>        AddCollisionObject(rigidbody);<br>    }<br> <br>    void ApplyGravity() {<br>        for (CollisionObject* object : m_objects) {<br>            if (!object-&gt;IsDynamic()) continue;<br> <br>            Rigidbody* rigidbody = (Rigidbody*)object;<br>            rigidbody-&gt;ApplyForce(rigidbody-&gt;Gravity() * rigidbody-&gt;Mass());<br>        }<br>    }<br> <br>    void MoveObjects(<br>        float dt)<br>    {<br>        for (CollisionObject* object : m_objects) {<br>            if (!object-&gt;IsDynamic()) continue;<br> <br>            Rigidbody* rigidbody = (Rigidbody*)object;<br> <br>            vector3 vel = rigidbody-&gt;Velocity()<br>                      + rigidbody-&gt;Force() / rigidbody-&gt;Mass()<br>                      * dt;<br> <br>            rigidbody-&gt;SetVelocity(vel);</pre><pre>            vector3 pos = rigidbody-&gt;Position()<br>                      + rigidbody-&gt;Velocity()<br>                      * dt;<br> <br>            rigidbody-&gt;SetPosition(pos);<br> <br>            rigidbody-&gt;SetForce(vector3(0, 0, 0));<br>        }<br>    }<br> <br>    void Step(<br>        float dt)<br>    {<br>        ApplyGravity();<br>        ResolveCollisions(dt);<br>        MoveObjects(dt);<br>    }<br>};</pre><p>Теперь у нас есть целый набор опций, которые пользователь может настроить для множества различных сценариев с помощью простого, но мощного API.</p><p>Также хочу затронуть еще одну опцию. PhysicsWorld не нуждается в обновлении каждого кадра. Допустим, игра вроде CS:GO рендерится со скоростью 300 кадров в секунду. Она не проверяет физику в каждом кадре. Вместо этого она может работать на частоте 50 Гц. Если бы игра использовала позиции только из физического движка, объекты обновлялись бы каждые 0,02 секунды, что приводило бы к эффекту тряски. И это идеальная скорость. Некоторые игры обновляются с частотой лишь 20 Гц, а интервал между обновлениями составляет 0,05 секунды!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F_-cXkPp-aYw%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D_-cXkPp-aYw&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F_-cXkPp-aYw%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bdf6da24141d4818a449a2540c908798/href">https://medium.com/media/bdf6da24141d4818a449a2540c908798/href</a></iframe><p>Чтобы обойти это, физический мир обычно отделяется от визуализированного. Это легко выполнить с помощью исходного Transform вместо указателя, а также с помощью системы, находящейся вне мира физики, которая интерполирует позицию каждый кадр. Посмотрим, как это можно реализовать.</p><p>Сначала избавляемся от указателя. Нам также нужно добавить последнее преобразование, которое будет установлено непосредственно перед обновлением в MoveObjects.</p><pre>struct CollisionObject {<br>protected:<br>    Transform m_transform;<br>    Transform m_lastTransform;<br>    Collider* m_collider;<br>    bool m_isTrigger;<br>    bool m_isStatic;<br>    bool m_isDynamic;<br> <br>    std::function&lt;void(Collision&amp;, float)&gt; m_onCollision;<br>public:<br>    <em>// Геттеры и сеттеры для всех элементов, отсутствие сеттера для isDynamic</em><br>};</pre><p>Поскольку мы применили геттеры и сеттеры, какой-либо код вне CollisionObject<em> </em>не сломается. Мы можем создать внешнюю систему, которая отслеживает, сколько осталось до обновления физики, и использовать <a href="https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F_%D0%B8%D0%BD%D1%82%D0%B5%D1%80%D0%BF%D0%BE%D0%BB%D1%8F%D1%86%D0%B8%D1%8F">линейную интерполяцию</a> между последней и текущей позицией. Я не буду вдаваться в подробности о том, где разместить эту систему, но она должна обновлять каждый кадр, а не каждое обновление физики.</p><pre>class PhysicsSmoothStepSystem {<br>private:<br>    float accumulator = 0.0f;<br> <br>public:<br>    void Update() {<br>        for (Entity entity : GetAllPhysicsEntities()) {<br>            Transform*       transform = entity.Get&lt;Transform&gt;();<br>            CollisionObject* object    = entity.Get&lt;CollisionObject&gt;();<br> <br>            Transform&amp; last    = object-&gt;LastTransform();<br>            Transform&amp; current = object-&gt;Transform();<br> <br>            transform-&gt;Position = lerp(<br>                last.Position,<br>                current.Position,<br>                accumulator / PhysicsUpdateRate()<br>            );<br>        }<br> <br>        accumulator += FrameDeltaTime();<br>    }<br> <br>    void PhysicsUpdate() {<br>        accumulator = 0.0f;<br>    }<br>};</pre><p>Эта система плавно перемещает объекты между их позициями в физических движках каждый кадр, удаляя все искаженные артефакты из движения.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F0xJ-oRCPRk8%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D0xJ-oRCPRk8&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F0xJ-oRCPRk8%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bf9b87748660f15b062200ee160ea4a4/href">https://medium.com/media/bf9b87748660f15b062200ee160ea4a4/href</a></iframe><p>Вот и финальный результат. Надеюсь, что принципы, описанные в этой статье, помогут улучшить ваше представление о том, как разрабатывать сложные системы или даже создавать свои собственные движки.</p><p>Спасибо за чтение!</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/8738/">Тест рабочего цикла C++ через написание кода для декодера base85</a></li><li><a href="https://nuancesprog.ru/p/9157/">Распознаём 50 видов текста на C++ с Plywood</a></li><li><a href="https://nuancesprog.ru/p/8931/">Шаблон проектирования прототипов в современном C++</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://blog.winter.dev/">Winter’s Blog</a>: <a href="https://blog.winter.dev/2020/designing-a-physics-engine/">Designing a physics engine</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c29dc854d03" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B4%D0%B8%D0%B7%D0%B0%D0%B9%D0%BD-%D1%84%D0%B8%D0%B7%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B3%D0%BE-%D0%B4%D0%B2%D0%B8%D0%B6%D0%BA%D0%B0-c29dc854d03">Дизайн физического движка</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Не учите машинное обучение]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BD%D0%B5-%D1%83%D1%87%D0%B8%D1%82%D0%B5-%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5-%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-2799d41f095a?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/2799d41f095a</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Fri, 18 Sep 2020 16:01:04 GMT</pubDate>
            <atom:updated>2020-09-18T16:01:04.423Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/625/1*lCyrVs3lDwA6DY5X9MxKIw.png" /></figure><p><em>Примечание: следующие рассуждения основаны на моих личных наблюдениях за командами, работающими над машинным обучением, а не академическом обзоре отрасли.</em></p><p>Как разработчик, вы, вероятно, хотя бы немного интересуетесь машинным обучением. Концепция алгоритмов, которые могут научиться делать предсказания, захватывает практически каждого.</p><p>Однако, если вы, решив изучать МО, последовали каноническим рекомендациям по началу работы, то велика вероятность того, что, потратив две недели на изучение линейной алгебры и многомерного математического анализа, вы попросту сдадитесь.</p><p><strong>Причина заключается в том, что большинство вводных материалов по машинному обучению не предназначено для разработчиков. Они ориентированы на исследователей МО, что представляет проблему для разработчиков, которые просто хотят создавать продукты с помощью машинного обучения.</strong></p><h3>Вы хотите создавать продукты или проводить исследования?</h3><p>До конца 2000-х годов машинное обучение в основном использовалось в исследовательских целях. Лишь небольшое количество компаний применяло его на производстве.</p><p>Поэтому многие вводные материалы по машинному обучению рассматривают его с исследовательской точки зрения. Они начинаются с объяснения нейронных сетей с точки зрения математики, а также рассмотрения всех теорий, лежащих в основе МО, таких как метод обратного распространения ошибки и состязательные сети.</p><p>Даже неуниверситетские материалы в некоторой степени придерживаются этого шаблона. Например, этот отрывок взят из руководства «Быстрый старт для новичков» от TensorFlow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xW__JDMOVYQJEvYV.png" /></figure><p><a href="https://www.tensorflow.org/tutorials/quickstart/beginner">Здесь </a>можно просмотреть это руководство полностью.</p><p>Если вы уже знакомы с математическими основами машинного обучения или хотите изучить их, тогда этот подход вам подойдет. Однако, если вы хотите использовать МО для разработки, представленная информация будет не совсем тем, что вы ищете.</p><p>Применительно к программированию этот подход подобен тому, чтобы начать с изучения assembly. Практически ни один разработчик так не поступает.</p><p>Скорее всего, вы научились программировать, написав «hello world» на высокоуровневом языке. Затем, по мере внесения небольших сложностей в свои проекты, вы изучали все более низкоуровневое программирование.</p><p>Этот шаблон обучения пользуется успехом среди разработчиков ПО, поскольку отдает приоритет разработке. Если вы больше заинтересованы в создании рекомендательной системы, чем в публикации статьи, то именно так вы должны подойти к изучению МО.</p><h3>Как изучить МО в процессе создания программного обеспечения?</h3><p>Если вы хотите ознакомиться с разработкой с помощью МО, изучая его в процессе, то воспользуйтесь следующим подходом:</p><ol><li>Определите цель, например: создание текстового автозаполнителя или идентификатора автомобильного номера.</li><li>Найдите предварительно обученную модель, подходящую для вашего проекта. Для ранее упомянутых вариантов подойдут GPT-2 и YOLOv3.</li><li>При желании вы также можете использовать библиотеку, например gpt-2-simple, для точной настройки модели под ваши данные.</li><li>Наконец, разверните модель как микросервис.</li></ol><p>Развернув модель в виде API, вы сможете запрашивать ее, как и любой другой веб-сервис, а также создавать приложения на ее основе.</p><p>С помощью этого подхода вы познакомитесь с различными популярными архитектурами моделей и подходами к машинному обучению, а также узнаете, для создания каких приложений они используются. Помимо этого, вы изучите инфраструктуру МО, которая играет важную роль в создании реальных продуктов из моделей.</p><h3>Освоили разработку с помощью МО? Время переходить к теории!</h3><p>Если вы инженер, то вы, вероятно, уже реализовывали некоторую форму аутентификации, то есть хэшировали пароли.</p><p>Написали ли вы собственный алгоритм хеширования паролей? Потратили ли вы недели на изучение криптографии? Или же просто использовали bcrypt?</p><p>Точно так же при создании своего первого веб-приложения потратили ли вы кучу времени на изучение баз данных? Написали ли вы собственную базу с нуля? Или же использовали любой ORM, встроенный в ваш любимый фреймворк?</p><p>Та же логика применима и к машинному обучению. Если вы любите создавать программное обеспечение, то начните с разработки с помощью МО и позвольте инструментам, предварительно обученным моделям и фреймворкам МО абстрагировать лежащую в основе теорию. Затем, при желании или необходимости добавления большей сложности в проект, углубитесь в основы, чтобы узнать, как работают все эти процессы.</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/9632/">Моделирование связей графа в DynamoDB</a></li><li><a href="https://nuancesprog.ru/p/9603/">Инновационный алгоритм глубокого обучения в Google Translate</a></li><li><a href="https://nuancesprog.ru/p/9573/">Метод опорных векторов: примеры на Python</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@calebkaiser?source=post_page-----8af3cf946214----------------------">Caleb Kaiser</a>: <a href="https://towardsdatascience.com/dont-learn-machine-learning-8af3cf946214">Don’t learn machine learning</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2799d41f095a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BD%D0%B5-%D1%83%D1%87%D0%B8%D1%82%D0%B5-%D0%BC%D0%B0%D1%88%D0%B8%D0%BD%D0%BD%D0%BE%D0%B5-%D0%BE%D0%B1%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5-2799d41f095a">Не учите машинное обучение</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Встроенная база данных Python]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F-%D0%B1%D0%B0%D0%B7%D0%B0-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-python-bb6327b2aab1?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb6327b2aab1</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[sqlite]]></category>
            <category><![CDATA[pandas]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Wed, 26 Aug 2020 16:01:01 GMT</pubDate>
            <atom:updated>2020-08-26T16:01:01.425Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*RfaeyELaMzc6agqrBKxf_w.png" /></figure><p>Если вы разработчик программного обеспечения, то, скорее всего, вы знакомы с невероятно легкой базой данных SQLite или даже уже использовали ее. Она содержит практически все функции реляционной базы данных и представлена всего одним файлом. На официальном сайте можно найти несколько сценариев применения SQLite:</p><ul><li>встроенные устройства и интернет вещей;</li><li>анализ данных;</li><li>передача данных;</li><li>архив файлов и/или контейнер данных;</li><li>внутренние или временные базы данных;</li><li>замена корпоративной базы данных в период демо-версий или тестирования;</li><li>обучение и тестирование;</li><li>экспериментальные расширения языка SQL.</li></ul><p>Если вам нужна SQLite для каких-либо других целей, то обратитесь к <a href="https://www.sqlite.org/whentouse.html">документации</a>.</p><p>Но самое главное — SQLite встроена в библиотеку Python. То есть вам не нужно устанавливать серверное или клиентское ПО и поддерживать работу какого-либо сервиса. Если вы импортировали библиотеку в Python и приступили к работе, значит вы уже используете систему управления реляционными базами данных!</p><h3>Импортирование и использование</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*B8rZYCRjgDAA-9Wl.png" /></figure><p>«Встроенность» предполагает, что вам не нужно запускать pip install для получения библиотеки. Просто импортируйте ее с помощью:</p><pre>import sqlite3 as sl</pre><h3>Создание соединения с БД</h3><p>Не беспокойтесь о драйверах, строках подключения и т.д. Вы можете создать базу данных SQLite и задать такой простой объект подключения, как:</p><pre>con = sl.connect(&#39;my-test.db&#39;)</pre><p>После запуска этой строки кода происходит создание с БД и активируется подключение к ней. Дело в том, что базы данных, к которой мы просим подключиться Python, не существует, поэтому он автоматически создает пустую. Также мы можем ввести точно такой же код для подключения к уже существующей базе данных.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/0*hJVkg6YEBJ4vE8BI.png" /></figure><h3>Создание таблицы</h3><p>Теперь создадим таблицу:</p><pre>with con:<br>    con.execute(&quot;&quot;&quot;<br>        CREATE TABLE USER (<br>            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,<br>            name TEXT,<br>            age INTEGER<br>        );<br>    &quot;&quot;&quot;)</pre><p>Мы добавили три столбца в таблицу USER. Как видите, SQLite действительно легка и при этом поддерживает все основные функции обычной реляционной СУБД, такие как тип данных, обнуляемый тип, первичный ключ и автоинкремент.</p><p>После запуска этого кода создается таблица, но она ничего не выводит.</p><h3>Включение записей</h3><p>Вставим несколько записей в только что созданную таблицу USER, чтобы доказать, что она действительно создана.</p><p>Предположим, мы хотим вставить сразу несколько записей. Выполним:</p><pre>sql = &#39;INSERT INTO USER (id, name, age) values(?, ?, ?)&#39;<br>data = [<br>    (1, &#39;Alice&#39;, 21),<br>    (2, &#39;Bob&#39;, 22),<br>    (3, &#39;Chris&#39;, 23)<br>]</pre><p>Определяем оператор SQL с вопросительными знаками ? в качестве заполнителя. Теперь создадим образцы данных для вставки, а затем вставим их с помощью объекта подключения:</p><pre>with con:&lt;br&gt;<br>    con.executemany(sql, data)</pre><p>После запуска кода не появилось никаких предупреждений, значит все прошло успешно.</p><h3>Запрос к таблице</h3><p>Пришло время удостовериться, что все сделано правильно. Выполним запрос к таблице на возврат образцов строк.</p><pre>with con:<br>    data = con.execute(&quot;SELECT * FROM USER WHERE age &lt;= 22&quot;)<br>    for row in data:<br>        print(row)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/584/0*zP_VRHJyBB_7VxFU.png" /></figure><p>Как видите, все очень просто!</p><p>Более того, несмотря на свою легкость SQLite является широко используемой базой данных, и большинство программного обеспечения клиентов SQL ее поддерживает.</p><p>Чаще всего я использую инструмент DBeaver. Рассмотрим его на примере.</p><h3>Подключение к базе данных SQLite из клиента SQL (DBeaver)</h3><p>Поскольку я использую Google Colab, я буду загружать файл my-test.db на свой компьютер. При запуске Python на локальном компьютере можно использовать клиент SQL для прямого подключения к файлу баз данных.</p><p>Создаем новое соединение в DBeaver и выбираем SQLite в качестве типа БД:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*_TDxteqjsAWXig0A.png" /></figure><p>Затем переходим к файлу БД:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/0*Kn7BpRImkBYQCFDy.png" /></figure><p>Теперь к базе данных можно выполнить любой SQL-запрос, как и в любых других реляционных БД:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*b_GeKjCPom89QVPK.png" /></figure><h3>Непрерывная интеграция с Pandas</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*D5t6GnMNY9xgVS3n.png" /></figure><p>Но это еще не все. Дело в том, что, являясь встроенной функцией Python, SQLite может легко интегрироваться с фреймом данных Pandas.</p><p>Определяем фрейм данных:</p><pre>df_skill = pd.DataFrame({<br>    &#39;user_id&#39;: [1,1,2,2,3,3,3],<br>    &#39;skill&#39;: [&#39;Network Security&#39;, &#39;Algorithm Development&#39;, &#39;Network Security&#39;, &#39;Java&#39;, &#39;Python&#39;, &#39;Data Science&#39;, &#39;Machine Learning&#39;]<br>})</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*PQlkIqf_LIYFYbO3.png" /></figure><p>Затем просто вызываем метод фрейма данных to_sql(), чтобы сохранить его в базе данных:</p><pre>df_skill.to_sql(&#39;SKILL&#39;, con)</pre><p>И это все, что нужно сделать! Вам даже не придется создавать таблицу заранее — типы данных и длина столбцов будут определены автоматически. Конечно, при желании вы также можете определить ее заранее.</p><p>Допустим, мы хотим объединить таблицу USER и SKILL и прочитать результат во фрейме данных Pandas. Это тоже можно выполнить без проблем.</p><pre>df = pd.read_sql(&#39;&#39;&#39;<br>    SELECT s.user_id, u.name, u.age, s.skill <br>    FROM USER u LEFT JOIN SKILL s ON u.id = s.user_id<br>&#39;&#39;&#39;, con)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/569/0*T5P7US2ZCW9kvdPO.png" /></figure><p>Результаты запишем в новую таблицу под названием USER_SKILL:</p><pre>df.to_sql(&#39;USER_SKILL&#39;, con)</pre><p>Теперь мы также можем использовать клиент SQL для получения таблицы:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*o_etv96g6w7n8UOS.png" /></figure><h3>Выводы</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*mU6d5VhCRuc9SwMj.jpeg" /></figure><p>В Python есть множество скрытых сюрпризов. Но скрыты они не специально: дело лишь в том, что в Python настолько много функций «из коробки», что невозможно раскрыть их все сразу.</p><p>В этой статье мы узнали, как использовать встроенную библиотеку Python sqlite3 для создания таблиц и манипулирования ими в базе данных SQLite. Конечно, она также поддерживает обновление и удаление, которые вы можете попробовать самостоятельно.</p><p>Но самое главное, мы можем легко прочитать таблицу из базы данных SQLite во фрейме данных Pandas и наоборот. Такая возможность еще больше упрощает взаимодействие с этой легкой реляционной базой данных.</p><p>Возможно, вы заметили, что в SQLite нет аутентификации. С ней бы данная библиотека перестала быть такой легкой.</p><p>Открывайте для себя еще больше удивительных возможностей Python!</p><p>Весь код из этой статьи находится в моем <a href="https://colab.research.google.com/drive/1Nq6VjezN4Djx5smI0esP8VJ8QCWr73DR?usp=sharing">Google Colab Notebook</a>.</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/9264/">Идиоматический Python для новичков</a></li><li><a href="https://nuancesprog.ru/p/9211/">Пространства имен и области видимости в Python</a></li><li><a href="https://nuancesprog.ru/p/9034/">Работа с панелью индикаторов. Руководство программиста Python. Часть 1</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@qiuyujx?source=post_page-----d553989c87bd----------------------">Christopher Tao</a>: <a href="https://towardsdatascience.com/do-you-know-python-has-a-built-in-database-d553989c87bd">Do You Know Python Has A Built-In Database?</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb6327b2aab1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B2%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F-%D0%B1%D0%B0%D0%B7%D0%B0-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-python-bb6327b2aab1">Встроенная база данных Python</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Использование компонентов между фреймворками]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2-%D0%BC%D0%B5%D0%B6%D0%B4%D1%83-%D1%84%D1%80%D0%B5%D0%B9%D0%BC%D0%B2%D0%BE%D1%80%D0%BA%D0%B0%D0%BC%D0%B8-d8934e38f5d7?source=rss-57dbe1752d71------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8934e38f5d7</guid>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[micro-frontends]]></category>
            <category><![CDATA[typescript]]></category>
            <dc:creator><![CDATA[Артур Хайбуллин]]></dc:creator>
            <pubDate>Sun, 23 Aug 2020 16:01:01 GMT</pubDate>
            <atom:updated>2020-08-23T16:01:01.408Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*KB9SgLueOMatG299rWXANA.png" /></figure><p>Микрофронтенды становятся популярнее с каждым днем. Одна из причин заключается в том, что они предлагают способ выйти за рамки фреймворков. Однако это не единственная (и даже не главная) причина для их использования.</p><p><em>Каким образом можно эффективно создать эту возможность самостоятельно и что нужно учитывать, чтобы получить отличный результат?</em></p><p>В этой статье я хочу поделиться нашим 4-летним опытом создания различных решений для микрофронтендов. Множество извлеченных из этого опыта уроков отразилось в нашем <a href="https://github.com/smapiot/piral">проекте с открытым исходным кодом</a> <a href="https://github.com/smapiot/piral">Piral</a>, который скоро будет выпущен в версии v1.</p><h3>Прочная основа</h3><p>Какими бы ни были ваши цели относительно использования компонентов между фреймворками, для начала необходима мощная архитектура с четко определенными точками взаимодействия. Например, при работе над одностраничным приложением может возникнуть вопрос о том, как будет работать маршрутизация.</p><p>Конечно, в библиотеках и фреймворках, связанных с понятием компонентов, есть ответ на эти вопросы. Некоторые варианты выбора более ограничены (<em>фреймворки</em>), а некоторые предоставляют больше свободы (<em>библиотеки </em>для создания пользовательских интерфейсов).</p><p>Для начала стоит определить точки взаимодействия. Имейте в виду, что нет необходимости подвергать сомнению установленные варианты. Например, если приложение уже использует React повсеместно, значит спокойно используйте для маршрутизации пакет router-router.</p><p>Очень важно, чтобы внедряемый фреймворк хорошо сочетался с React Router, и скоро разберемся почему.</p><p>Другим моментом, который необходимо определить заранее, является степень изоляции. Хотя наличие прямого доступа к компонентам из других фреймворков вполне разумно, <strong>агрегирование компонентов</strong> все-таки может понадобиться.</p><p>Оно позволяет отдельным компонентам использовать компоненты, не зная их источника. Этот подход также обеспечивает слабую связанность, поскольку компонент-агрегатор будет работать с одним или несколькими зарегистрированными компонентами, или даже без них.</p><p><em>В конечном счете этот подход также решает проблему MxN.</em></p><h3>Решение проблемы MxN</h3><p>Проблема MxN появляется во многих местах. К счастью, ее решение также давно известно. Рассмотрим саму проблему и начнем с примера с языками программирования.</p><p>Предположим, у нас есть <em>M </em>языков программирования и <em>N </em>типов машин. Сколько компиляторов нам нужно написать? Очевидно, ответ будет <em>MxN</em>. Кажется, что все довольно просто. Однако математическая часть далеко не самая сложная. Проблема заключается в сохранении масштабирования при добавлении новых типов машин и новых языков программирования.</p><p>Например, взяв <em>4 </em>языка и <em>3 </em>машинные архитектуры, мы получим 12 ребер (<em>MxN</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/448/0*AnuBCGmY50S3oabI.png" /></figure><p>Решить эту проблема очень просто: нужно ввести промежуточный язык (или промежуточное представление). Таким образом, все <em>M </em>языков программирования компилируются в один промежуточный язык, который затем компилируется в целевую архитектуру. Вместо того, чтобы масштабировать <em>MxN</em>, мы получаем <em>M+N</em>. Добавление новой выходной архитектуры так же просто, как добавление компиляции из промежуточного языка в новую архитектуру.</p><p>Посмотрим, как меняется пример диаграммы при добавлении промежуточного представления (intermediate representation — IR). Теперь получаем только 7 ребер (<em>M+N</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/448/0*nhmgYGkU7-qDJmA7.png" /></figure><p>То же самое можно выполнить и для поддержки IDE. Вместо поддержки <em>M </em>языков программирования для <em>N </em>IDE мы используем единый стандарт языковой поддержки (так называемый Language Server Protocol — LSP).</p><p>Это и есть секретный ингридиент, благодаря которому команда TypeScript (как и другие) может поддерживать VS Code, Sublime, Atom и многие другие редакторы. Они просто обновляют реализацию LSP, а остальное происходит само собой. Поддержка новой IDE так же проста, как написание плагина LSP для соответствующей IDE.</p><p>Как эта информация может помочь при использовании компонентов между фреймворками? Если у нас есть <em>M </em>фреймворков, то для обмена компонентами между <em>N </em>из них снова получаем <em>MxN</em>. Решения этой задачи можно достичь с помощью опыта из примеров выше. Нам нужно найти подходящее «промежуточное представление».</p><p>На следующей диаграмме показан пример для 3 фреймворков. Промежуточное представление позволяет конвертировать в различные фреймворки и из них. Всего у нас <em>6 </em>ребер (<em>2N</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/0*LIF5weEzzA8wqI69.png" /></figure><p>А если мы возьмем один из фреймворков в качестве промежуточного представления, то получим 4<em> </em>ребра (<em>2N — 2</em>), сэкономив два конвертера и улучшив производительность в случае, когда для большинства компонентов используется один определенный фреймворк.</p><p>В <a href="https://docs.piral.io/">Piral </a>мы выбрали React в качестве промежуточного решения. Для этого были веские причины:</p><ul><li>React поддерживается во всех основных браузерах, даже в IE11 и выше.</li><li>React имеет очень четко определенную, легкую модель компонента.</li><li>React предоставляет чистый жизненный цикл компонентов.</li><li>Контекст React позволяет с легкостью переносить контекстную информацию.</li><li>Ленивая загрузка и обработка ошибок очень просты в поддержке.</li><li>React был основным выбором для нашего дерева рендеринга, и мы не хотели отдаляться от него.</li></ul><p>Выбор фреймворка зависит от индивидуального случая. Также пользу проекту могут принести веб-компоненты. Мы не обращались к ним по нескольким причинам, в особенности из-за количества полифиллов и отсутствия контекста.</p><h3>Простой враппер</h3><p>Нам нужен четко определенный жизненный цикл компонентов. Полный жизненный цикл можно указать через интерфейс ComponentLifecycle, как показано ниже:</p><pre>interface ComponentLifecycle&lt;TProps&gt; {<br>  <em>/**<br>   * Вызывается при установке компонента.<br>   * @param element - контейнер, содержащий элемент.<br>   * @param props - свойства, которые нужно перенести.<br>   * @param ctx - связанный контекст.<br>   */</em><br>  mount(element: HTMLElement, props: TProps, ctx: ComponentContext): void;<br>  <em>/**<br>   * Вызывается, когда нужно обновить компонент.<br>   * @param element - контейнер, содержащий элемент.<br>   * @param props - свойства, которые нужно перенести.<br>   * @param ctx - связанный контекст.<br>   */</em><br>  update?(element: HTMLElement, props: TProps, ctx: ComponentContext): void;<br>  <em>/**<br>   * Вызывается при отключении компонента.<br>   * @param element - контейнер, в котором находился элемент.<br>   */</em><br>  unmount?(element: HTMLElement): void;<br>}</pre><p>Один этот жизненный цикл не имеет большого смысла. Его нужно подключить к компоненту (в данном случае к компоненту React), чтобы он монтировался в дереве рендеринга.</p><p>Определим простую функцию для создания функционального компонента React, оборачивающего жизненный цикл:</p><pre>function wrap&lt;T&gt;(component: ComponentLifecycle&lt;T&gt;): React.ComponentType&lt;T&gt; {<br>  return (props: T) =&gt; {<br>    const { createPortal, destroyPortal } = useGlobalActions();<br>    const [id] = React.useState(createPortal);<br>    const router = React.useContext(__RouterContext);</pre><pre>    React.useEffect(() =&gt; {<br>      return () =&gt; destroyPortal(id);<br>    }, []);</pre><pre>    return (<br>      &lt;ErrorBoundary&gt;<br>        &lt;PortalRenderer id={id} /&gt;<br>        &lt;ComponentContainer<br>          innerProps={{ ...props }}<br>          $portalId={id}<br>          $component={component}<br>          $context={{ router }}<br>        /&gt;<br>      &lt;/ErrorBoundary&gt;<br>    );<br>  };<br>}</pre><p>Кроме того, можно ввести значения, переносимые контекстом, такие как контекст маршрутизатора (содержащий, помимо прочего, history, location и другие элементы).</p><p>Что такое createPortal и destroyPortal? Это глобальные действия, с помощью которых можно регистрировать или удалять запись в портале. Портал использует дочерний элемент ReactPortal, чтобы проецировать элемент из дерева рендеринга React в другое место в дереве DOM. Следующая диаграмма иллюстрирует этот процесс:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/0*sJayfnlObGcheVeE.png" /></figure><p>Это мощный способ, который работает даже в теневом DOM. Таким образом, промежуточное представление может использоваться (то есть проецироваться) где угодно, например в узле, который визуализируется другим фреймворком, таким как Vue.</p><p>Обработкой ошибок занимается граница ошибок — особо ничем не примечательный компонент, поэтому давайте перейдем сразу к PortalRenderer и ComponentContainer.</p><p>PortalRenderer максимально прост. В конце концов, все сводится к тому, чтобы получить ReactPortal и визуализировать его. Поскольку эти порталы должны быть распространены глобально, мы можем перейти к хранилищу, чтобы извлечь их:</p><pre>const PortalRenderer: React.FC&lt;PortalRendererProps&gt; = ({ id }) =&gt; {<br>  const children = useGlobalState(m =&gt; m.portals[id]);<br>  return &lt;&gt;{children}&lt;/&gt;;<br>};</pre><p>Теперь все движение происходит в ComponentContainer. Для расширенного доступа к полному жизненному циклу React используем класс Component.</p><pre>class ComponentContainer&lt;T&gt; extends React.Component&lt;ComponentContainerProps&lt;T&gt;&gt; {<br>  private current?: HTMLElement;<br>  private previous?: HTMLElement;</pre><pre>  componentDidMount() {<br>    const node = this.current;<br>    const { $component, $context, innerProps } = this.props;<br>    const { mount } = $component;</pre><pre>    if (node &amp;&amp; isfunc(mount)) {<br>      mount(node, innerProps, $context);<br>    }</pre><pre>    this.previous = node;<br>  }</pre><pre>  componentDidUpdate() {<br>    const { current, previous } = this;<br>    const { $component, $context, innerProps } = this.props;<br>    const { update } = $component;</pre><pre>    if (current !== previous) {<br>      previous &amp;&amp; this.componentWillUnmount();<br>      current &amp;&amp; this.componentDidMount();<br>    } else if (isfunc(update)) {<br>      update(current, innerProps, $context);<br>    }<br>  }</pre><pre>  componentWillUnmount() {<br>    const node = this.previous;<br>    const { $component } = this.props;<br>    const { unmount } = $component;</pre><pre>    if (node &amp;&amp; isfunc(unmount)) {<br>      unmount(node);<br>    }</pre><pre>    this.previous = undefined;<br>  }</pre><pre>  render() {<br>    const { $portalId } = this.props;</pre><pre>    return (<br>      &lt;div<br>        data-portal-id={$portalId}<br>        ref={node =&gt; {<br>          this.current = node;<br>        }}<br>      /&gt;<br>    );<br>  }<br>}</pre><p>В этом компоненте-враппере мы также сталкиваемся с такими случаями, как смена хост-узла DOM, поэтому потребуется заново монтировать базовый компонент с помощью заданных функций жизненного цикла.</p><p>Итак, рассмотрим три важнейшие части, которые связаны с жизненным циклом:</p><ol><li>componentDidMount отвечает за монтирование и использует захваченный узел DOM;</li><li>componentDidUpdate выполняет либо повторное монтирование (если узел DOM изменился), либо легкую операцию обновления;</li><li>componentWillUnmount отвечает за отсоединение.</li></ol><p>Атрибут data-portal-id нужен для дальнейшего нахождения хост-узла при использовании ReactPortal.</p><p>Представьте, что мы находимся в дереве, контролируемом таким фреймворком, как Vue, и хотим визуализировать компонент из другого фреймворка. В этом случае нам понадобится промежуточное представление, которое, как уже было определено, также является компонентом React.</p><p>Монтирование этого компонента React в дереве Vue работает через DOM, но будет отображаться через портал. Таким образом мы синхронизируемся с обычным деревом рендеринга React и получаем все преимущества.</p><p>Однако для правильного проецирования нужно определить, какой текущий хост-узел DOM используется в React. К счастью, для этой цели мы добавили атрибут. Нужно только подняться по дереву DOM и найти узел с атрибутом.</p><p>Код будет выглядеть следующим образом:</p><pre>function findPortalId(element: HTMLElement | ShadowRoot) {<br>  const portalId = &#39;data-portal-id&#39;;<br>  let parent: Node = element;</pre><pre>  while (parent) {<br>    if (parent instanceof Element &amp;&amp; parent.hasAttribute(portalId)) {<br>      const id = parent.getAttribute(portalId);<br>      return id;<br>    }</pre><pre>    parent = parent.parentNode || (parent as ShadowRoot).host;<br>  }</pre><pre>  return undefined;<br>}</pre><p>Этот код также можно использовать в теневом DOM, что разумно, если мы также применяем веб-компоненты.</p><h3>Пример</h3><p>Теперь посмотрим, как этот процесс может выглядеть в приложении.</p><p>Допустим, мы определили компонент React для подключения к глобальному состоянию и отображения значения из счетчика.</p><pre>const tileStyle: React.CSSProperties = {<br>  fontWeight: &#39;bold&#39;,<br>  fontSize: &#39;0.8em&#39;,<br>  textAlign: &#39;center&#39;,<br>  color: &#39;blue&#39;,<br>  marginTop: &#39;1em&#39;,<br>};</pre><pre>export const ReactCounter = () =&gt; {<br>  const count = useGlobalState(m =&gt; m.count);<br>  return &lt;div style={tileStyle}&gt;From React: {count}&lt;/div&gt;;<br>};</pre><p>Теперь на него можно ссылаться в другом компоненте. Например, в компоненте Svelte мы можем использовать пользовательский компонент, такой как показан в следующем коде:</p><pre>&lt;script&gt;<br>  export let columns;<br>  export let rows;<br>    export let count = 0;<br>&lt;/script&gt;</pre><pre>&lt;style&gt;<br>  h1 {<br>    text-align: center;<br>  }<br>&lt;/style&gt;</pre><pre>&lt;div class=&quot;tile&quot;&gt;<br>  &lt;h3&gt;Svelte: {count}&lt;/h3&gt;<br>  &lt;p&gt;<br>    {rows} rows and {columns} columns<br>    &lt;svelte-extension name=&quot;ReactCounter&quot;&gt;&lt;/svelte-extension&gt;<br>  &lt;/p&gt;<br>  &lt;button on:click=&#39;{() =&gt; count += 1}&#39;&gt;Increment&lt;/button&gt;<br>  &lt;button on:click=&#39;{() =&gt; count -= 1}&#39;&gt;Decrement&lt;/button&gt;<br>&lt;/div&gt;</pre><p>Имейте в виду, что svelte-extension (в этом примере) — это путь для получения доступа к конвертеру, идущий от промежуточного представления (React) к Svelte.</p><p>Использование этого простого примера в действии выглядит согласно ожиданиям:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/241/0*a5g7_0iSJJStRWLc.gif" /></figure><p>Как определить здесь конвертеры? Особую сложность может представлять соединение с пользовательским элементом. Для этого мы используем событие (под названием render-html), которое запускается после подключения веб-компонента.</p><pre>const svelteConverter = ({ Component }) =&gt; {<br>  let instance = undefined;</pre><pre>  return {<br>    mount(parent, data, ctx) {<br>      parent.addEventListener(&#39;render-html&#39;, renderCallback, false);<br>      instance = new Component({<br>        target: parent,<br>        props: {<br>          ...ctx,<br>          ...data,<br>        },<br>      });<br>    },<br>    update(_, data) {<br>      Object.keys(data).forEach(key =&gt; {<br>        instance[key] = data[key];<br>      });<br>    },<br>    unmount(el) {<br>      instance.$destroy();<br>      instance = undefined;<br>      el.innerHTML = &#39;&#39;;<br>    },<br>  };<br>};</pre><p>Кроме того, Svelte значительно все упрощает. Создание нового экземпляра компонента Svelte фактически прикрепляет его к заданной цели (target).</p><h3>Заключение</h3><p>Использование компонентов между фреймворками является критически важной частью большинства решений для микрофронтендов, однако основную идею и концепции можно применить и ко многим другим решениям. При наличии надежной архитектуры и работающей модели домена реализация также не будет представлять особой сложности.</p><p>Используя компонент-агрегатор, можно эффективно разделить производителей и потребителей. Чтобы охватить все случаи, будет достаточно одного двунаправленного конвертора для каждого фреймворка. Этот подход допускает множество вариантов использования от независящей от фреймворков разработки до быстрого прототипирования или экспериментов с новыми технологиями.</p><p>Читайте также:</p><ul><li><a href="https://nuancesprog.ru/p/8549/">Параллельный режим React — взгляд в будущее</a></li><li><a href="https://nuancesprog.ru/p/8453/">Как скоро хуки вытеснят классы React?</a></li><li><a href="https://nuancesprog.ru/p/8862/">Ох, TypeScript, ты боль моя</a></li></ul><p>Читайте нас в <a href="https://t.me/nuancesprog">Telegram</a>, <a href="https://vk.com/nuancesprog">VK </a>и <a href="https://zen.yandex.ru/profile/editor/id/5ac0d9177ddde86d7b4d096a">Яндекс.Дзен</a></p><p><em>Перевод статьи </em><a href="https://blog.bitsrc.io/@FlorianRappl?source=post_page-----8439d58342e5----------------------">Florian Rappl</a>: <a href="https://blog.bitsrc.io/cross-framework-components-8439d58342e5">Cross-Framework Components</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8934e38f5d7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%BE%D0%B2-%D0%BC%D0%B5%D0%B6%D0%B4%D1%83-%D1%84%D1%80%D0%B5%D0%B9%D0%BC%D0%B2%D0%BE%D1%80%D0%BA%D0%B0%D0%BC%D0%B8-d8934e38f5d7">Использование компонентов между фреймворками</a> was originally published in <a href="https://medium.com/nuances-of-programming">NOP::Nuances of Programming</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>