<?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 not eisenheim on Medium]]></title>
        <description><![CDATA[Stories by not eisenheim on Medium]]></description>
        <link>https://medium.com/@noteisenheim?source=rss-a67d2e998aab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*wbHBDBROJ9zUGr02.jpg</url>
            <title>Stories by not eisenheim on Medium</title>
            <link>https://medium.com/@noteisenheim?source=rss-a67d2e998aab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 13:27:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@noteisenheim/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[Обзор библиотеки Datatable в Python]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BE%D0%B1%D0%B7%D0%BE%D1%80-%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B8-datatable-%D0%B2-python-d66a2f0f32e4?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/d66a2f0f32e4</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[datatables]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Sun, 04 Aug 2019 17:26:01 GMT</pubDate>
            <atom:updated>2019-08-04T17:26:01.656Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GypbjX6YUBu51sMApoaDlQ.jpeg" /></figure><blockquote>“В период до 2003 года в мире было создано пять эксабайтов информации. Сейчас же каждые два дня появляются новые пять эксабайтов”, — Эрик Шмидт</blockquote><p>Если вы пользовались языком R, то, скорее всего, вы уже работали с пакетом <a href="https://cran.r-project.org/web/packages/data.table/data.table.pdf">data.table</a>. В R это расширение пакета <a href="https://www.rdocumentation.org/packages/base/versions/3.6.0/topics/data.frame">data.frame</a>. Для пользователей R он полезен в обработке больших объёмов данных (например, около 100 ГБ в RAM).</p><p>data.table в R — многофункциональный пакет с высокой производительностью. Он лёгок в использовании, удобен и быстр. Конечно, он очень известен: у него более 400 тысяч скачиваний каждый месяц и его используют почти 650 пакетов CRAN и Bioconductor.</p><p>А что делать тем, кто использует Python? Хорошие новости: для этого языка существует библиотека datatable, которая поддерживает большие данные, датасеты как внутри динамической памяти, так и вне, мультипотоковые алгоритмы и обеспечивает высокую производительность.</p><h3>datatable</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/446/1*CDs0obGYV8BO5SrJWcsm4w.png" /></figure><p>Современные программы с использованием машинного обучения должны уметь обрабатывать огромное количество данных и создавать несколько признаков. Это нужно для создания моделей с высокой точностью. Модуль datatable был создан как раз для этого. Он поддерживает данные размером до 100 ГБ на одном вычислительном узле на максимальной скорости вычислений. Разработка библиотеки спонсировалась <a href="https://www.h2o.ai/">H2O.ai</a> и впервые использовалась в <a href="https://www.h2o.ai/driverless-ai/">Driverless.ai</a>.</p><p>В некоторой степени библиотека похожа на <a href="https://github.com/pandas-dev/pandas">pandas</a> с тем лишь отличием, что она больше сфокусирована на данных больших размеров и скорости вычислений. К тому же datatable помогает пользователю понятными сообщениями об ошибках. Сейчас вы и сами увидите, в чём эта библиотека превосходит pandas.</p><h3>Установка</h3><p>На MacOS установка производится при помощи pip:</p><pre>pip install datatable</pre><p>На Linux — при помощи бинарного пакета:</p><pre># Если у вас Python 3.5<br>pip install <a href="https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp35-cp35m-linux_x86_64.whl">https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp35-cp35m-linux_x86_64.whl</a></pre><pre># Если у вас Python 3.6<br>pip install <a href="https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp36-cp36m-linux_x86_64.whl">https://s3.amazonaws.com/h2o-release/datatable/stable/datatable-0.8.0/datatable-0.8.0-cp36-cp36m-linux_x86_64.whl</a></pre><p><em>К сожалению, пока библиотека не работает на Windows, но ведётся работа для создания поддержки и этой ОС.</em></p><p>Для более подробной инструкции обращайтесь к <a href="https://datatable.readthedocs.io/en/latest/install.html">документации</a>.</p><p>Код, использованный в этой статье, можно найти на <a href="https://github.com/parulnith/An-Overview-of-Python-s-Datatable-package">Github</a>.</p><h3>Считывание данных</h3><p>Датасет — <a href="https://www.kaggle.com/wendykan/lending-club-loan-data#loan.csv">Lending Club Loan Data</a> — взят с Kaggle. Он содержит информацию обо всех займах в период с 2007 по 2015 год: статус займа (текущий, выплачен в срок, выплачен позже срока) и информацию об оплате. Файл состоит из <strong>2,26 миллионов строк</strong> и <strong>145 столбцов</strong>. Размер датасета идеален для демонстрации возможностей библиотеки.</p><pre># Импортируем библиотеки</pre><pre>import numpy as np<br>import pandas as pd<br>import datatable as dt</pre><p>Загрузим данные в объект Frame. Это фундаментальная единица анализа в библиотеке datatable — почти то же самое, что и pandas dataframe или таблица SQL: данные содержатся в форме двумерного массива.</p><h4>datatable</h4><pre>%%time<br>datatable_df = dt.fread(&quot;data.csv&quot;)<br>____________________________________________________________________</pre><pre>CPU times: user 30 s, sys: 3.39 s, total: 33.4 s                                <br>Wall time: 23.6 s</pre><p>Функция fread() одновременно и мощная, и быстрая. Она может автоматически распознавать и считывать большинство текстовых форматов, загружать данные из .zip архивов или ссылок, считывать файлы Excel.</p><p>К тому же парсер datatable:</p><ul><li>автоматически распознаёт сепараторы, заголовки, типы столбцов и тому подобное;</li><li>может считывать данные из многих ресурсов: файлов, ссылок, текстов, архивов, программных оболочек и масок;</li><li>позволяет проводить многопоточное чтение файла;</li><li>показывает полосу загрузки больших файлов;</li><li>считывает как <a href="https://tools.ietf.org/html/rfc4180">RFC4180</a>-совместимые, так и несовместимые файлы.</li></ul><h4>pandas</h4><p>Теперь посмотрим на то, как с задачей загрузки справляется pandas.</p><pre>%%time<br>pandas_df= pd.read_csv(&quot;data.csv&quot;)<br>___________________________________________________________</pre><pre>CPU times: user 47.5 s, sys: 12.1 s, total: 59.6 s<br>Wall time: 1min 4s</pre><p>Результаты показывают, что datatable работает гораздо быстрее: считывание заняло меньше минуты.</p><h3>Преобразование объекта Frame</h3><p>Существующий объект Frame можно преобразовать в массив numpy или pandas dataframe:</p><pre>numpy_df = datatable_df.to_numpy()<br>pandas_df = datatable_df.to_pandas()</pre><p>Давайте преобразуем наши данные в объект pandas dataframe и сравним время со считыванием в pandas.</p><pre>%%time<br>datatable_pandas = datatable_df.to_pandas()<br>___________________________________________________________________<br>CPU times: user 17.1 s, sys: 4 s, total: 21.1 s<br>Wall time: 21.4 s</pre><p><strong>Получается, что для работы с объектом </strong><strong>pandas dataframe гораздо эффективнее считать данные при помощи </strong><strong>datatable, а затем преобразовать их в </strong><strong>pandas dataframe.</strong></p><pre>type(datatable_pandas)<br>___________________________________________________________________<br>pandas.core.frame.DataFrame</pre><h3>Свойства Frame</h3><p>Давайте рассмотрим основные свойства этого класса. Кстати, они схожи со свойствами pandas dataframe.</p><pre>print(datatable_df.shape)       # (строки, столбцы)<br>print(datatable_df.names[:5])   # названия первых пяти столбцов<br>print(datatable_df.stypes[:5])  # типы первых пяти столбцов<br>______________________________________________________________</pre><pre>(2260668, 145)</pre><pre>(&#39;id&#39;, &#39;member_id&#39;, &#39;loan_amnt&#39;, &#39;funded_amnt&#39;, &#39;funded_amnt_inv&#39;)</pre><pre>(stype.bool8, stype.bool8, stype.int32, stype.int32, stype.float64)</pre><p>Также можно использовать команду head для того, чтобы вывести несколько первых строк датасета:</p><pre>datatable_df.head(10)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/671/1*64byY9K1c6TtfKhcpFLM3Q.png" /><figcaption>Первые 10 строк датасета</figcaption></figure><p>Цвет показывает тип данных: красный — строки, зелёный — целые числа, синий — числа с плавающей точкой.</p><h3>Сводная статистика</h3><p>В pandas подсчёт сводной статистики — достаточно ресурсозатратный процесс. С datatable же всё гораздо удобнее. Для каждого столбца можно вычислить следующие значения:</p><pre>datatable_df.sum()      datatable_df.nunique()<br>datatable_df.sd()       datatable_df.max()<br>datatable_df.mode()     datatable_df.min()<br>datatable_df.nmodal()   datatable_df.mean()</pre><p>Давайте вычислим <strong>среднее значение </strong>столбцов, используя эти две библиотеки.</p><h4><strong>datatable</strong></h4><pre>%%time<br>datatable_df.mean()<br>_______________________________________________________________<br>CPU times: user 5.11 s, sys: 51.8 ms, total: 5.16 s<br>Wall time: 1.43 s</pre><h4><strong>pandas</strong></h4><pre>pandas_df.mean()<br>__________________________________________________________________<br>Throws memory error.</pre><p>Как видим, для такого размера данных с pandas это сделать невозможно, так как происходит ошибка памяти.</p><h3>Обработка данных</h3><p>datatable — столбчатая структура данных, как и dataframe. Все обращения происходят при помощи <strong>квадратных скобок</strong>, как и в обычных матрицах, но с большим функционалом.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/723/1*iSwJw9xPQNu90lAMtJfJCg.png" /></figure><p>Такая же нотация DT[i, j] используется в математике при работе с матрицами, в C/C++, R, pandasи numpy. Давайте посмотрим, что мы можем делать с данными в datatable.</p><h4>Выбор подмножества строк/столбцов</h4><p>Нижеприведённый код выбирает весь столбецfunded_amnt датасета.</p><pre>datatable_df[:,&#39;funded_amnt&#39;]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/149/1*gqtt8FPlX3jJP0Ge-sfY7w.png" /></figure><p>А вот так мы можем выбрать первые пять строк и три столбца:</p><pre>datatable_df[:5,:3]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/213/1*_V71gWvQEhaRelnDe1_pRg.png" /></figure><h4>Сортировка датасета</h4><p>Отсортируем его по значению funded_amnt_inv при помощи обеих библиотек и сравним время работы.</p><h4><strong>datatable</strong></h4><pre>%%time<br>datatable_df.sort(&#39;funded_amnt_inv&#39;)<br>_________________________________________________________________<br>CPU times: user 534 ms, sys: 67.9 ms, total: 602 ms<br>Wall time: 179 ms</pre><h4><strong>pandas</strong></h4><pre>%%time<br>pandas_df.sort_values(by = &#39;funded_amnt_inv&#39;)<br>___________________________________________________________________<br>CPU times: user 8.76 s, sys: 2.87 s, total: 11.6 s<br>Wall time: 12.4 s</pre><p>И вновь мы видим преимущество datatable.</p><h4>Удаление строк/столбцов</h4><p>Вот так можно удалить столбец с названием member_id:</p><pre>del datatable_df[:, &#39;member_id&#39;]</pre><h4>Группирование</h4><p>Как и pandas, datatable поддерживает функцию groupby. Давайте найдём среднее значение столбца funded_amount, сгруппированного по значению grade.</p><h4><strong>datatable</strong></h4><pre>%%time<br>for i in range(100):<br>    datatable_df[:, dt.sum(dt.f.funded_amnt), dt.by(dt.f.grade)]<br>____________________________________________________________________<br>CPU times: user 6.41 s, sys: 1.34 s, total: 7.76 s<br>Wall time: 2.42 s</pre><h4><strong>pandas</strong></h4><pre>%%time<br>for i in range(100):<br>    pandas_df.groupby(&quot;grade&quot;)[&quot;funded_amnt&quot;].sum()<br>____________________________________________________________________<br>CPU times: user 12.9 s, sys: 859 ms, total: 13.7 s<br>Wall time: 13.9 s</pre><p><strong>Что такое </strong><strong>.f?</strong></p><p>f это frame proxy, который позволяет нам обращаться к объекту Frame. То есть в нашем примере dt.f — это то же самое, что и datatable_df.</p><h4>Фильтрация строк</h4><p>Синтаксис похож на groupby. Давайте выберем только те строки loan_amnt, для которых значения loan_amntбольше, чем funded_amnt.</p><pre>datatable_df[dt.f.loan_amnt&gt;dt.f.funded_amnt,&quot;loan_amnt&quot;]</pre><h3>Сохранение</h3><p>Содержимое объекта Frame можно записать в файл csv для дальнейшего использования.</p><pre>datatable_df.to_csv(&#39;output.csv&#39;)</pre><p>Если у вас есть вопросы по использованию библиотеки, то обращайтесь к <a href="https://datatable.readthedocs.io/en/latest/using-datatable.html">документации</a>.</p><h3>Заключение</h3><p>Модуль datatable определённо ускоряет работу с данными по сравнению с pandas, что очень полезно при работе с большими датасетами. С другой стороны, библиотека проигрывает pandas в функциональности. Но работа над библиотекой до сих пор ведётся, поэтому в будущем надеемся на расширение функционала.</p><h3>Ссылки</h3><ul><li><a href="https://github.com/Rdatatable/data.table/wiki">data.table</a> в R</li><li><a href="https://datatable.readthedocs.io/en/latest/index.html">Документация datatable</a></li><li><a href="https://www.kaggle.com/sudalairajkumar/getting-started-with-python-datatable">Примеры Kaggle работы с datatable</a></li></ul><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@parulnith"><em>Parul Pandey</em></a><em>: </em><a href="https://towardsdatascience.com/an-overview-of-pythons-datatable-package-5d3a97394ee9"><em>An Overview of Python’s Datatable package</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d66a2f0f32e4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BE%D0%B1%D0%B7%D0%BE%D1%80-%D0%B1%D0%B8%D0%B1%D0%BB%D0%B8%D0%BE%D1%82%D0%B5%D0%BA%D0%B8-datatable-%D0%B2-python-d66a2f0f32e4">Обзор библиотеки Datatable в 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[Python: статические методы, методы класса и экземпляра класса]]></title>
            <link>https://medium.com/nuances-of-programming/python-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0-%D0%B8-%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%B0-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0-3e8529d24786?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/3e8529d24786</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python-programming]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Thu, 01 Aug 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-08-01T17:01:01.261Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-jWOgP1Dh0sF8Uxa.jpg" /></figure><p>Согласно <a href="https://docs.python.org/3.5/reference/datamodel.html#types">модели данных Python</a>, язык предлагает три вида методов: <em>статические</em>, <em>класса</em> и <em>экземпляра класса</em>. Давайте посмотрим, что же происходит за кулисами каждого из видов методов. Понимание принципов их работы поможет в создании красивого и эффективного кода. Начнём с самого простого примера, в котором демонстрируются все три вида методов.</p><pre>class ToyClass:<br>    def instancemethod(self):<br>        return &#39;instance method called&#39;, self<br>    <br>    @classmethod<br>    def classmethod(cls):<br>        return &#39;class method called&#39;, cls</pre><pre>    @staticmethod<br>    def staticmethod():<br>        return &#39;static method called&#39;</pre><h3>Методы экземпляра класса</h3><p>Это наиболее часто используемый вид методов. Методы экземпляра класса принимают объект класса как первый аргумент, который принято называть self и который указывает на сам экземпляр. Количество параметров метода не ограничено.</p><p>Используя параметр self , мы можем менять состояние объекта и обращаться к другим его методам и параметрам. К тому же, используя атрибут self.__class__ , мы получаем доступ к атрибутам класса и возможности менять состояние самого класса. То есть <strong>методы экземпляров класса позволяют менять как состояние определённого объекта, так и класса</strong>.</p><p>Встроенный пример метода экземпляра — str.upper():</p><pre>&gt;&gt;&gt; &quot;welcome&quot;.upper()   # &lt;- вызывается на строковых данных<br>&#39;WELCOME&#39;</pre><h3>Методы класса</h3><p>Методы класса принимают класс в качестве параметра, который принято обозначать как cls. Он указывает на класс <em>ToyClass</em>, а не на объект этого класса. При декларации методов этого вида используется декоратор classmethod.</p><p>Методы класса привязаны к самому классу, а не его экземпляру. <strong>Они могут менять состояние класса, что отразится на всех объектах этого класса, но не могут менять конкретный объект.</strong></p><p>Встроенный пример метода класса — dict.fromkeys()— возвращает новый словарь с переданными элементами в качестве ключей.</p><pre>dict.fromkeys(&#39;AEIOU&#39;)  # &lt;- вызывается при помощи класса dict<br>{&#39;A&#39;: None, &#39;E&#39;: None, &#39;I&#39;: None, &#39;O&#39;: None, &#39;U&#39;: None}</pre><h3>Статические методы</h3><p>Статические методы декларируются при помощи декоратора staticmethod. Им не нужен определённый первый аргумент (ни self, ни cls).</p><p>Их можно воспринимать как методы, которые “не знают, к какому классу относятся”.</p><p><strong>Таким образом, статические методы прикреплены к классу лишь для удобства и не могут менять состояние ни класса, ни его экземпляра.</strong></p><p>С теорией достаточно. Давайте разберёмся с работой методов, создав объект нашего класса и вызвав поочерёдно каждый из методов: <em>instancemethod</em>, <em>classmethod</em> and <em>staticmethod.</em></p><pre>&gt;&gt;&gt; obj = ToyClass()<br>&gt;&gt;&gt; obj.instancemethod()<br>(&#39;instance method called&#39;, ToyClass instance at 0x10f47e7a0&gt;)</pre><pre>&gt;&gt;&gt; ToyClass.instancemethod(obj)<br>(&#39;instance method called&#39;, ToyClass instance at 0x10f47e7a0&gt;)</pre><p>Пример выше подтверждает то, что метод <em>instancemethod </em>имеет доступ к объекту класса<em> ToyClass</em> через аргумент self. Кстати, вызов функции obj.instancemethod() используется лишь для удобства, то есть можно использовать и ToyClass.instancemethod(obj).</p><p>Теперь давайте вызовем метод класса:</p><pre>&gt;&gt;&gt; obj.classmethod()<br>(&#39;class method called&#39;, &lt;class  ToyClass at 0x10f453a10&gt;)</pre><p>Мы видим, что метод класса <em>classmethod() </em>имеет доступ к самому классу <em>ToyClass</em>, но не к его конкретному экземпляру объекта. Запомните, в Python всё является объектом. Класс тоже объект, который мы можем передать функции в качестве аргумента.</p><p>Заметьте, что self и cls — не обязательные названия и эти параметры можно называть иначе.</p><pre>def instancemethod(self, ...)<br>def classmethod(cls, ...)</pre><pre>-------то же самое, что и----------</pre><pre>def instancemethod(my_object, ...)<br>def classmethod(my_class, ...)</pre><p>Это лишь общепринятые обозначения, которым следуют все. Тем не менее они должны находиться первыми в списке параметров.</p><p>Вызовем статический метод:</p><pre>&gt;&gt;&gt; obj.staticmethod()<br>static method called</pre><p>Да, это может вас удивить, но статические методы можно вызывать через объект класса. Вызов через точку нужен лишь для удобства. На самом же деле в случае статического метода никакие аргументы (self илиcls) методу не передаются.</p><p>То есть статические методы не могут получить доступ к параметрам класса или объекта. Они работают только с теми данными, которые им передаются в качестве аргументов.</p><p>Теперь давайте вызовем те же самые методы, но на самом классе.</p><pre>&gt;&gt;&gt; ToyClass.classmethod()<br>(&#39;class method called&#39;, &lt;class ToyClass at 0x10f453a10&gt;)</pre><pre>&gt;&gt;&gt; ToyClass.staticmethod()<br>&#39;static method called&#39;</pre><pre>&gt;&gt;&gt; ToyClass.instancemethod()<br>TypeError: unbound method instancemethod() <br>must be called with ToyClass instance as <br>first argument (got nothing instead)</pre><p>Метод класса и статический метод работают, как нужно. Однако вызов метода экземпляра класса выдаёт <em>TypeError</em>, так как метод не может получить на вход экземпляр класса.</p><p>Теперь, когда вы знаете разницу между тремя видами методов, давайте рассмотрим реальный пример для понимания того, когда и какой метод стоит использовать. Пример взят <a href="https://www.geeksforgeeks.org/class-method-vs-static-method-python/">отсюда</a>.</p><pre>from datetime import date</pre><pre>class Person:<br>    def __init__(self, name, age):<br>        self.name = name<br>        self.age = age</pre><pre>@classmethod<br>    def from_birth_year(cls, name, year):<br>        return cls(name, date.today().year - year)</pre><pre>@staticmethod<br>    def is_adult(age):<br>        return age &gt; 18</pre><pre>person1 = Person(&#39;Sarah&#39;, 25)<br>person2 = Person.from_birth_year(&#39;Roark&#39;, 1994)</pre><pre>&gt;&gt;&gt; person1.name, person1.age<br>Sarah 25</pre><pre>&gt;&gt;&gt; person2.name, person2.age<br>Roark 24</pre><pre>&gt;&gt;&gt; Person.is_adult(25)<br>True</pre><h3>Когда использовать каждый из методов?</h3><p>Выбор того, какой из методов использовать, может показаться достаточно сложным. Тем не менее с опытом этот выбор делать гораздо проще.</p><p>Чаще всего <strong>метод класса используется тогда, когда нужен генерирующий метод, возвращающий объект класса</strong>. Как видим, метод класса from_birth_year используется для создания объекта класса Person по году рождения, а не возрасту.</p><p><strong>Статические методы в основном используются как вспомогательные функции</strong> и работают с данными, которые им передаются.</p><h4>Запомнить</h4><ul><li>Методы экземпляра класса получают доступ к объекту класса через параметр self и к классу через self.__class__.</li><li>Методы класса не могут получить доступ к определённому объекту класса, но имеют доступ к самому классу через cls.</li><li>Статические методы работают как обычные функции, но принадлежат области имён класса. Они не имеют доступа ни к самому классу, ни к его экземплярам.</li><li>Даже если вы программируете только ради интереса, изучение ООП в Python поможет писать код так, чтобы в дальнейшем было легче искать ошибки и использовать его повторно.</li></ul><p><em>Перевод статьи </em><a href="https://medium.com/@rachittayal7"><em>Rachit Tayal</em></a><em>: </em><a href="https://medium.com/python-features/pythons-instance-class-and-static-methods-e9097f07829b"><em>Python’s Instance, Class and Static Methods</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3e8529d24786" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/python-%D1%81%D1%82%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B5-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D1%8B-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0-%D0%B8-%D1%8D%D0%BA%D0%B7%D0%B5%D0%BC%D0%BF%D0%BB%D1%8F%D1%80%D0%B0-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D0%B0-3e8529d24786">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%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B-%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B5-%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD-%D0%B7%D0%BD%D0%B0%D1%82%D1%8C-%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9-%D1%81%D0%BF%D0%B5%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D1%81%D1%82-%D0%BF%D0%BE-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B5-%D0%B8-%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D1%83-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-8ffb944850cc?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ffb944850cc</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Thu, 01 Aug 2019 07:01:01 GMT</pubDate>
            <atom:updated>2019-08-01T07:01:01.036Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*X_GeTm4CcnPCYD8XD61DfA.jpeg" /></figure><p>В последние годы алгоритмы для решения задач <a href="https://ru.wikipedia.org/wiki/%D0%90%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%B8_%D0%B4%D0%B8%D1%81%D0%BF%D0%B5%D1%82%D1%87%D0%B5%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F">автоматического планирования и диспетчеризации</a> стали вновь популярными в области машинного обучения. Понимание принципов их работы поможет увеличить производительность ваших моделей. К тому же, благодаря разработке таких мощных вычислительных технологий, как квантовых компьютеров, вскоре вновь будет использоваться искусственный интеллект, основанный на поиске.</p><h3>Что такое алгоритм поиска в искусственном интеллекте?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/777/1*JrFAvOPCVsx7_i7N8ktVfg.png" /><figcaption>Алгоритм поиска — это не то же, что и поисковая служба</figcaption></figure><p><strong>Поиск</strong> в рамках искусственного интеллекта — это процесс перемещения из <strong>исходного состояния</strong> в <strong>целевое</strong> через <strong>промежуточные</strong>.</p><p>Почти любая задача в рамках искусственного интеллекта может быть сформулирована при помощи этих терминов:</p><ul><li><strong>Состояние</strong> — потенциальные исходы в задаче.</li><li><strong>Переход</strong> — смена одного состояния другим.</li><li><strong>Исходное состояние</strong> — состояние системы на момент начала поиска. С него мы начинаем поиск.</li><li><strong>Промежуточное состояние</strong> — состояние, в которое совершается переход на пути от исходного к целевому.</li><li><strong>Целевое состояние </strong>— состояние, при достижении которого поиск останавливается.</li><li><strong>Область поиска</strong> — множество состояний.</li></ul><h3>Неинформированный поиск</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*d9fRPZao-wEaY7njfR9Pgw.png" /></figure><p>Неинформированный поиск используется в том случае, когда нет информации о стоимости перехода из одного состояния в другое.</p><p>Существует три главных классических алгоритма неинформированного поиска:</p><ul><li><a href="https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D0%B3%D0%BB%D1%83%D0%B1%D0%B8%D0%BD%D1%83"><strong>Поиск в глубину</strong></a><strong> </strong>— обходит область поиска, используя <a href="https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA">LIFO-стек</a> для определения следующей вершины.<br><strong>Преимущества:</strong> хорошо работает в глубоких графах, эффективен по памяти.<br><strong>Недостатки:</strong> есть вероятность зацикливания.</li><li><a href="http://www.rriai.org.ru/poisk-v-glubinu-s-iterativnyim-uglubleniem.html"><strong>Поиск в глубину с итеративным углублением</strong></a>— обходит область поиска, используя <a href="https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D0%B5%D0%BA">LIFO-стек</a> для определения следующей вершины. Когда алгоритм достигает заранее заданной глубины, он очищает стек, увеличивает счётчик достижения предельной глубины и запускает поиск заново из текущей вершины.</li><li><a href="https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2_%D1%88%D0%B8%D1%80%D0%B8%D0%BD%D1%83"><strong>Поиск в ширину</strong></a><strong> </strong>— обходит область поиска, используя <a href="https://ru.wikipedia.org/wiki/%D0%9E%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)">FIFO-очередь</a> для определения следующей вершины.</li></ul><h3>Информированный поиск</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*_XmSnHzJK9LGExcm5kZMNw.png" /></figure><p>Информированный поиск используется в том случае, когда мы знаем точную стоимость или же оценку стоимости смены состояний.</p><ul><li><strong>UCS</strong> — обходит область поиска, используя <a href="https://ru.wikipedia.org/wiki/%D0%9E%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C_%D1%81_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%BE%D0%BC_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)">очередь с приоритетом</a> и текущий счёт. Текущий счёт для каждого состояния — стоимость достижения состояния из его родителя, то есть, из предыдущего состояния.</li><li><a href="https://ru.wikipedia.org/wiki/A*"><strong>A*</strong></a><strong> </strong>— обходит область поиска, используя <a href="https://ru.wikipedia.org/wiki/%D0%9E%D1%87%D0%B5%D1%80%D0%B5%D0%B4%D1%8C_%D1%81_%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%B8%D1%82%D0%B5%D1%82%D0%BE%D0%BC_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)">очередь с приоритетом</a> и текущий счёт. Текущий счёт для каждого состояния — стоимость достижения состояния через его родителя в пути и эвристическая оценка стоимости перехода из текущей вершины в целевую.<br><em>Допустимое значение эвристической оценки</em> должно удовлетворять следующим двум условиям: во-первых, эвристическая оценка должна быть меньше минимальной стоимости перехода из текущей вершины в целевую; во-вторых, она должна быть меньше эвристической оценки каждой из родительских вершин и стоимости достижения состояния в текущем пути.</li><li><a href="https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0#IDA*"><strong>IDA*</strong></a><strong> </strong>— версия поиска A* с итеративным углублением.</li></ul><h3>Локальный поиск</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*qCrIcS2tRXGqyG5qeqaw0w.gif" /></figure><p>Алгоритмы локального поиска используются в том случае, когда существует несколько возможных целевых состояний, но некоторые из них лучше других, то есть, возникает необходимость найти лучший из нескольких. Они довольно часто используются для оптимизации алгоритмов машинного обучения.</p><ul><li><a href="https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%B8%D1%81%D0%BA_%D0%B2%D0%BE%D1%81%D1%85%D0%BE%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5%D0%BC_%D0%BA_%D0%B2%D0%B5%D1%80%D1%88%D0%B8%D0%BD%D0%B5"><strong>Поиск восхождением к вершине</strong></a> — жадный итеративный алгоритм, выбирающий следующим состоянием наименее затратное, пока оно не достигнет локального максимума.</li><li><a href="https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%B8%D0%BC%D0%B8%D1%82%D0%B0%D1%86%D0%B8%D0%B8_%D0%BE%D1%82%D0%B6%D0%B8%D0%B3%D0%B0"><strong>Алгоритм имитации отжига</strong></a> — имитирует физический процесс, восходя к вершине, пока не достигнет локального максимума. При его достижении используется функция “температуры”, которая определяет: стоит ли окончить поиск или продолжать его в попытке найти лучшее решение.</li><li><a href="https://en.wikipedia.org/wiki/WalkSAT"><strong>GSAT</strong></a><strong> </strong>— алгоритм поиска восхождением к вершине на конъюнктивной нормальной форме. Для каждого возможного параметра подбирается случайное множество булевых значений. Если эти значения удовлетворяют предусловиям целевого состояния, то работа алгоритма завершена. Если же нет, то значения инвертируются таким образом, чтобы выражение соответствовало максимальному числу предусловий. Процесс повторяется заново с новым случайным множеством значений для ранее инвертированных переменных.</li><li><a href="https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%BD%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC"><strong>Генетический алгоритм</strong></a><strong> </strong>— генерируется исходная популяция состояний, из которой выбирается часть с наибольшим значением функции приспособленности. Оставшиеся состояния рандомно объединяются, немного мутируют, а затем вновь производится отбор лучших решений в следующее поколение.</li><li><a href="http://www.rriai.org.ru/lokalnyiy-luchevoy-poisk.html"><strong>Лучевой поиск</strong></a><strong> </strong>— UCS с сохранением значений правдоподобной вероятности значений текущего и предыдущего шага модели. На каждом шаге алгоритм отбирает N наиболее вероятных состояний для дальнейшего поиска.</li><li><a href="https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9C%D0%BE%D0%BD%D1%82%D0%B5-%D0%9A%D0%B0%D1%80%D0%BB%D0%BE"><strong>Метод Монте-Карло</strong></a><strong> </strong>— рандомизированный алгоритм поиска, который возвращает лучшее приближение верного результата поиска. Он довольно быстрый, но не точный.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*A9f0Jzeq9cPfD1VJEUjEJg.png" /></figure><ul><li><a href="https://ru.wikipedia.org/wiki/%D0%9B%D0%B0%D1%81-%D0%92%D0%B5%D0%B3%D0%B0%D1%81_(%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC)"><strong>Лас-Вегас</strong></a><strong> </strong>— как и предыдущий, рандомизированный алгоритм, однако он прекращает свою работу лишь в том случае, если найден верный результат. Таким образом, алгоритм всегда точный, но зачастую медленный.</li></ul><pre><em>// алгоритм Лас-Вегас</em><br>repeat:<br>    k = RandInt(n)<br>    <strong>if</strong> A[k] == 1,<br>        <strong>return</strong> k;</pre><ul><li><strong>Атлантик Сити</strong> — ограниченный вероятностный алгоритм поиска с полиномиальным временем работы. Он объединяет в себе сильные и слабые стороны алгоритмов Монте-Карло и Лас-Вегас.</li></ul><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@aribornstein"><em>Aaron (Ari) Bornstein</em></a><em>: </em><a href="https://towardsdatascience.com/ai-search-algorithms-every-data-scientist-should-know-ed0968a43a7a"><em>AI Search Algorithms Every Data Scientist Should Know</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ffb944850cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B-%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B5-%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD-%D0%B7%D0%BD%D0%B0%D1%82%D1%8C-%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9-%D1%81%D0%BF%D0%B5%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D1%81%D1%82-%D0%BF%D0%BE-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B5-%D0%B8-%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D1%83-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-8ffb944850cc">Алгоритмы поиска, которые должен знать каждый специалист по обработке и анализу данных</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[Визуализация данных и веб-отчёты в Angular]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%B2%D0%B8%D0%B7%D1%83%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B8-%D0%B2%D0%B5%D0%B1-%D0%BE%D1%82%D1%87%D1%91%D1%82%D1%8B-%D0%B2-angular-63c22f6be79c?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/63c22f6be79c</guid>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Wed, 31 Jul 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-07-31T17:01:01.379Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uuwFB6j1BT63pAizQ1RIVg.png" /></figure><p>Недавно я столкнулась со следующей проблемой: мне нужно было найти полностью настраиваемые веб-компоненты, с которыми несложно взаимодействовать и которые могут использоваться как встроенные BI-инструменты для <strong>анализа</strong>, <strong>отчётов</strong> и <strong>визуализации</strong> в моём приложении.</p><p>Из всех таких компонентов я выбрала Angular. Ни один его потенциальный конкурент не может сравниться с ним. Думаю, я не одна столкнулась с такой проблемой, поэтому хочу поделиться своим опытом использования Angular.</p><p>Как преданный пользователь Angular, я бы хотела в первую очередь рассказать о его преимуществах. Затем перейду к работе с аналитикой в приложениях Angular и созданию отчётов при помощи сводной сетки JavaScript и библиотеки для построения графиков.</p><p>К тому же мы сделаем несложный отчёт, который поможет в дальнейшем анализе.</p><p>Для тех, кто не хочет читать: перейдите к секции с полезными ссылками, которые позволят попрактиковаться.</p><h3>Почему Angular?</h3><p>Начну с того, почему я считаю фреймворк Angular лучше аналогов и как он помогает упростить и ускорить процесс разработки.</p><p>Создание динамических клиентских приложений (как одностраничных, так и многостраничных) с Angular имеет ряд преимуществ:</p><ul><li>Взаимодействовать с компонентами приложения легко благодаря <strong>модульному дизайну</strong> кода. Код более организован и удобен для чтения.</li><li>Несвязанные компоненты.</li><li>Упрощённая <strong>MVC-архитектура</strong>.</li><li><strong>Статичная типизация</strong> TypeScript (на которой был написан фреймворк) обеспечивает безопасность типов. Это упрощает поддержку и перепроектирование кода.</li><li><strong>Мощный интерфейс командной строки</strong> упрощает создание приложения.</li><li>Большое сообщество разработчиков.</li></ul><p>Именно эти свойства повышают продуктивность в создании мобильных, десктопных и веб-приложений.</p><p>Есть и недостатки: Angular достаточно сложный для изучения, особенно по сравнению с React.</p><p>Теперь поговорим о <em>создании веб-отчётов</em>. Я использовала два компонента: Flexmonster и Google Charts. Сейчас я расскажу о них.</p><h3>Что такое Flexmonster?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*zYF7MkACFwmPZtUvBFO_Og.gif" /></figure><p><a href="https://www.flexmonster.com/?r=cd3">Flexmonster</a> —компонент сводной таблицы, написанный на JavaScript. Он хорош в создании веб-отчётов и проведении анализа. Также этот инструмент имеет обёртку Angular, что было немаловажно для моей задачи.</p><p>После добавления Flexmonster вы можете использовать все встроенные свойства и функции для создания своего отчёта. В конце работы таблица может быть экспортирована в Excel, PDF, Image и HTML.</p><p>Давайте посмотрим на список полезных для создания отчётов свойств.</p><h4>Аналитические функции</h4><ul><li>Агрегатные функции (16 встроенных; можно создавать свои).</li><li>Сортировка, группирование и фильтрация признаков.</li><li>Можно преобразовывать поля из столбцов в строки и наоборот при помощи drag-and-drop.</li><li>Возможность разбиения таблиц на меньшие составляющие.</li></ul><h3>Как интегрировать сводную таблицу в Angular?</h3><p>Процесс довольно простой. Для начала нужно создать приложение Angular в командной строке:</p><pre>ng new PROJECT-NAME<br>cd PROJECT-NAME</pre><p>Затем добавить пакет Flexmonster и модуль Flexmonster Angular:</p><pre>npm i ng-flexmonster --save</pre><p>В файл angular.json добавить следующие строчки:</p><pre>&quot;styles&quot;: [ <br>	&quot;styles.css&quot;, <br>	&quot;/node_modules/flexmonster/flexmonster.min.css&quot; <br>],<br>&quot;scripts&quot;: [ &quot;/node_modules/flexmonster/flexmonster.full.js&quot; ]</pre><p>Включить FlexmonsterPivotModule в app.module.ts. Этот файл находится внутри папки PROJECT-NAME/src/app :</p><pre>import { FlexmonsterPivotModule } from &#39;ng-flexmonster&#39;;<br><br>@NgModule({<br>  ...<br>  imports: [FlexmonsterPivotModule],<br>  ...<br>})</pre><p>Добавить директиву fm-pivot туда, где должна быть таблица. licenseKey — лицензионный ключ или ключ пробной версии:</p><pre>&lt;fm-pivot <br>  [licenseKey]=&quot;&#39;XXXX-XXXX-XXXX-XXXX-XXXX&#39;&quot;<br>  [report]=&quot;&#39;https://cdn.flexmonster.com/reports/report.json&#39;&quot;&gt;<br>&lt;/fm-pivot&gt;</pre><p>Запустить приложение из командной строки:</p><pre>ng serve</pre><p>Подробную инструкцию можно найти <a href="https://www.flexmonster.com/doc/integration-with-angular/?r=cd3">здесь</a>.</p><h3>Панель инструментов и визуализация данных</h3><p>Если нужно не только группировать данные, но и визуализировать их, пригодится информационная панель. Аналитики любят её использовать, потому что она помогает отслеживать изменения бизнес-метрик и принимать решения на основе данных. Но, как разработчики, вы, вероятно, знаете, что её настройка требует большого количества времени и усилий.</p><p>Поэтому перейдём к следующему инструменту, который позволит сохранить ваше время и визуализировать данные.</p><h3>Что такое Google Charts?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9TwG_yQHVQ4cPScyVDxExQ.gif" /></figure><p><a href="https://developers.google.com/chart/?r=cd3">Google Charts</a> — лучший бесплатный веб-сервис для создания графиков и схем. Для взаимодействия с ним не нужно взаимодействовать с DOM-элементами, можно просто использовать API от Google Charts. Для анимации данных нужно включить в приложение Google Loader и добавить объект класса DataTable в JavaScript. Таблице передаются данные и определяется функция для построения графика.</p><h3>Как передать данные графику?</h3><p>Для получения данных можно использовать Datasource или сводную таблицу Flexmonster. Первый поддерживает протокол Chart Tools Datasource и позволяет отправлять SQL-запросы сервису для получения таблицы (объекта класса DataTable), заполненной данными. Второй же инструмент можно использовать как провайдер данных для клиентской стороны. Этот компонент использует коннекторы JavaScript, которые избавляют нас от необходимости писать код для обработки данных для создания простых графиков. Но, конечно, при необходимости вы можете применить пользовательскую логику.</p><h3>Google Charts в приложении Angular</h3><p>Google Charts совместимы с Angular — обёртку можно найти на <a href="https://www.npmjs.com/">npm</a>.</p><p>Вот моя информационная панель, в которой я соединила Flexmonster и Google Charts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*1uwl_ZhhfPQsxRSFNhcwPQ.gif" /></figure><p>Можно увидеть, что вместе таблица и график заиграли новыми красками. Это совмещение позволяет связывать результаты анализа между собой.</p><h3>Заключение</h3><p>Я указала преимущества Angular как платформы для создания динамических веб-приложений, но не стоит забывать, что при разработке каждого приложения нужно выбирать именно тот фреймворк, который лучше всего подходит для целей конкретно этого приложения.</p><h3>Полезные ссылки</h3><ul><li><a href="https://6v2q2lkj7w.codesandbox.io/">Таблица и график на Angular</a></li><li><a href="https://codesandbox.io/s/6v2q2lkj7w">Код</a></li><li><a href="https://www.flexmonster.com/doc/integration-with-angular/?r=cd3">Инструкция по интеграции Flexmonster и Angular</a></li><li><a href="https://developers.google.com/chart/interactive/docs/gallery?r=cd3">Галерея Google Charts</a></li><li><a href="https://www.npmjs.com/package/angular-google-charts?r=cd3">Обёртка Angular для Google Charts</a></li></ul><p><em>Перевод статьи </em><a href="https://codeburst.io/@tetianahryshko"><em>Tetiana</em></a><em>: </em><a href="https://codeburst.io/data-visualization-and-web-reporting-with-angular-98de59bf1cfc"><em>Data Visualization and Web Reporting with Angular</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=63c22f6be79c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B2%D0%B8%D0%B7%D1%83%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B8-%D0%B2%D0%B5%D0%B1-%D0%BE%D1%82%D1%87%D1%91%D1%82%D1%8B-%D0%B2-angular-63c22f6be79c">Визуализация данных и веб-отчёты в Angular</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[Как выбрать язык программирования, который стоит изучить в 2019?]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B2%D1%8B%D0%B1%D1%80%D0%B0%D1%82%D1%8C-%D1%8F%D0%B7%D1%8B%D0%BA-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B9-%D1%81%D1%82%D0%BE%D0%B8%D1%82-%D0%B8%D0%B7%D1%83%D1%87%D0%B8%D1%82%D1%8C-%D0%B2-2019-27e795fc4193?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/27e795fc4193</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Sun, 21 Jul 2019 07:01:01 GMT</pubDate>
            <atom:updated>2019-07-21T07:01:01.118Z</atom:updated>
            <content:encoded><![CDATA[<h3>Какой язык программирования выбрать в 2019?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*i3LejSB9HuxLuLfG0bIcVA.jpeg" /></figure><p>Благодаря интернету весь мир имеет доступ к ресурсам для обучения программированию: как платным, так и бесплатным. Каждый щелчок мыши ведёт к новой статье, новому уроку или видео. И это создает определенные проблемы.</p><p>Я работаю в <a href="https://www.microverse.org/">Microverse</a>, онлайн-школе, которая бесплатна до тех пор, пока ты нигде не работаешь — вне зависимости от страны и города. Значительная часть наших учеников пришла к нам из-за того, что была напугана количеством доступных ресурсов. Эти ученики перескакивали с темы на тему, начинали изучать одновременно несколько языков, но не преуспели ни в одном.</p><p>Лучший способ не теряться в таком количестве ресурсов — это сосредоточиться на изучении одного языка. Почему? Я работал с начинающими разработчиками из более чем 50 стран и могу уверенно сказать, что хорошее знание одного языка программирования даёт большие шансы найти работу, нежели поверхностное знание десяти разных языков.</p><p>Не знаете, какой язык изучить? Вам повезло, эта статья как раз для вас.</p><h3>С чего начать? Выучите универсальный язык</h3><p>Я советую всем начинающим разработчикам, не определившимся с языком, начать с изучения одного из универсальных языков программирования. Они хороши тем, что могут использоваться почти в любой сфере.</p><h4>Python</h4><p>Благодаря простому синтаксису этот язык стал универсальным для изучения. Он обладает динамической типизацией, автоматическим управлением распределения памяти и поддерживает несколько парадигм программирования: объектно-ориентированное, функциональное и императивное программирование. Одна лишь стандартная библиотека позволяет использовать этот язык в различных сферах.</p><p>Веб и десктопные приложения, серверы, машинное обучение и искусственный интеллект используют Python. Он год за годом попадает в топ языков программирования. В 2018 Python получил награду “Лучший язык программирования года” в <a href="https://www.tiobe.com/tiobe-index/">TIOBE Programming Community Index</a> за наибольший рост рейтинга. В 2019, как мне кажется, этот рейтинг возрастёт ещё больше.</p><p>Сейчас на <a href="https://www.indeed.com/jobs?q=python+&amp;l=">Indeed.com</a> можно найти более 66 тысяч вакансий для Python-разработчиков.</p><h4>JavaScript</h4><p>Как показал ежегодный опрос разработчиков на <a href="https://insights.stackoverflow.com/survey/2018/#technology">Stack Overflow</a>, более 70% разработчиков используют JavaScript. Он гибкий, может использоваться в любой области разработки программного обеспечения, является одним из главных языков фронтенда всемирной сети. К тому же этот язык позволяет создавать интерактивные веб-страницы, и поэтому важен для большинства веб-приложений.</p><p>JavaScript поддерживает как объектно-ориентированное, так и функциональное программирование. Вдобавок к этому язык может похвастаться постоянно расширяющимся количеством библиотек. JavaScript настолько популярен, что его фреймворки есть и там, где он не очень эффективен, например, в разработке игр и виртуальной реальности.</p><p>Сейчас на <a href="https://www.indeed.com/q-javascript-jobs.html">Indeed.com</a> более 40 тысяч вакансий для JavaScript-разработчиков.</p><h4>Ruby</h4><p>Этот язык также поддерживает объектно-ориентированное, функциональное и императивное программирование. В нём присутствует динамическая типизация и автоматическое распределение памяти. Чаще всего Ruby используется в веб-приложениях с фреймворком Ruby on Rails и в бэкенде серверов и баз данных.</p><p>Его преимущество заключается в легкости для изучения новичками. Он лёгок, потому что синтаксис довольно близок к натуральному языку. Ruby может сделать за пару строчек кода то, для чего в других языках понадобится 20 строчек.</p><p>Сейчас на <a href="https://www.indeed.com/jobs?q=ruby+engineer&amp;ts=1555624884836&amp;rs=1">Indeed.com</a> более 9 тысяч вакансий для Ruby-разработчиков.</p><h4>Java</h4><p>Слоган этого языка — “написано однажды, работает везде и всегда”, потому что программы работают на любой платформе с поддержкой Java. Это один из самых известных языков среди начинающих разработчиков и второй по популярности на Stack Overflow.</p><p>Это основанный на классах объектно-ориентированный язык программирования. Он разрабатывался таким образом, чтобы иметь как можно меньше зависимостей. Благодаря его структуре область его применения довольно широка. Наиболее известное применение — создание Android-приложений. Помимо этого, язык используется в десктопных и веб-приложениях, серверах и сетях. Синтаксис поначалу может показаться сложным, но, освоив его, вы гарантированно найдёте работу.</p><p>Сейчас на <a href="https://www.indeed.com/q-java-jobs.html">Indeed.com</a> более 68 тысяч вакансий для Java-разработчиков.</p><h3>Определились с областью работы?</h3><p>Если вы уверены в том, что хотите заняться машинным обучением, стать разработчиком мобильных приложений или присоединиться к стартапу, то лучше выбирать язык, наиболее подходящий для конкретной цели.</p><h4>Машинное обучение</h4><p>Согласно <a href="https://github.blog/2019-01-24-the-state-of-the-octoverse-machine-learning/">заметке на GitHub</a>, в 2018 году Python являлся самым используемым языком в этой области. Совместите ваши знания Python и умение работать с библиотекой TensorFlow и вы станете отличным кандидатом на работу, связанную с машинным обучением.</p><p>Ещё одним неплохим выбором будет язык R. Он очень эффективен в обработке и анализе данных для статистических целей. Как и Python, этот язык имеет несколько пакетов, облегчающих имплементацию алгоритмов машинного обучения.</p><h4>Разработка мобильных приложений</h4><p>Для начала вам нужно определиться, под какую платформу вы хотите разрабатывать приложения: Android или iOS.</p><p>Для разработки под Android отличным выбором будет Java. Мобильная разработка на этом языке отличается от обычной разработки из-за ограничений смартфонов. Например, обычная программа, написанная на Java, будет выполняться до тех пор, пока вы вручную не прервёте её выполнение, тогда как приложение Android может быть закрыто в любой момент.</p><p>Если же ваш выбор — iOS, то я рекомендую изучить Swift, официальный язык Apple для iOS, macOS и других продуктов компании Apple. Возможно, кто-то порекомендует Objective-C, потому что в нём можно создавать графический интерфейс пользователя и фреймворки с огромным количеством возможностей.Но всё же я настаиваю на Swift, потому что он легче поддается изучению, пониманию и одобрен Apple.</p><p>Ещё один язык для мобильной разработки — JavaScript. Совместив его с HTML и CSS, можно создавать приложения, которые можно конвертировать в нативные при помощи Cordova. Также можно использовать .NET-языки для создания и конвертации приложений с помощью Xamarin. Это ещё раз демонстрирует значимость универсальных языков.</p><h3>Стартапы</h3><p>Если вы уверены в том, что вы хотите создать свой или присоединиться к уже существующему стартапу, то нет ничего лучше Ruby и Ruby on Rails. Этот язык легко осваивают начинающие и с его помощью можно быстро создавать прототипы приложений.</p><p>В Microverse курсы устроены таким образом, чтобы увеличить шансы учеников на получение работы, так как мы не получаем плату до тех пор, пока они не трудоустроятся. Поэтому для тех, кто хочет работать в сфере стартапов, мы предлагаем изучение JavaScrip, React, Ruby и Ruby on Rails.</p><h3>Каких языков избегать?</h3><p>Существует огромное количество языков программирования. Списки самых популярных сейчас включают в себя Go, Scala, TypeScript, C++ и Rust.</p><p>Однако если вы начинающий в сфере разработки ПО, то следует избегать большинство из них. Они неоправданно сложные или имеют слишком узкую спецификацию.</p><h3>Заключение</h3><ol><li>Сосредоточьтесь на оттачивании мастерства в одном языке, а не на параллельном изучении нескольких.</li><li>Если не знаете, с какого языка начать, то выберите один из универсальных.</li></ol><p>Не пугайтесь того, что нужно делать выбор. Для каждого языка найдётся работа. Что действительно важно — ваша мотивация, целеустремлённость и умение сосредоточиться на изучении выбранного языка.</p><p>Успехов!</p><p><em>Перевод статьи </em><a href="https://medium.freecodecamp.org/@arielcamus"><em>Ariel Camus</em></a><em>: </em><a href="https://medium.freecodecamp.org/how-to-choose-which-programming-language-you-should-learn-in-2019-60abef241012"><em>How to choose which programming language you should learn in 2019</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27e795fc4193" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BA%D0%B0%D0%BA-%D0%B2%D1%8B%D0%B1%D1%80%D0%B0%D1%82%D1%8C-%D1%8F%D0%B7%D1%8B%D0%BA-%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D0%B9-%D1%81%D1%82%D0%BE%D0%B8%D1%82-%D0%B8%D0%B7%D1%83%D1%87%D0%B8%D1%82%D1%8C-%D0%B2-2019-27e795fc4193">Как выбрать язык программирования, который стоит изучить в 2019?</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[Возможности C++, о которых должен знать каждый разработчик]]></title>
            <link>https://medium.com/nuances-of-programming/%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8-c-%D0%BE-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D1%85-%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD-%D0%B7%D0%BD%D0%B0%D1%82%D1%8C-%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%87%D0%B8%D0%BA-77bf21afc8c8?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/77bf21afc8c8</guid>
            <category><![CDATA[nuances-of-programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Thu, 18 Jul 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-07-18T17:01:01.150Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*0rrSTx3rs6zNKKGJedYJug.jpeg" /></figure><p>С момента своего появления C++ очень хорошо развился как язык программирования.</p><p>Конечно, это не произошло моментально. Когда-то этому языку не доставало динамичности. В то время было довольно сложно пользоваться им.</p><p>Но всё изменилось, когда комитет по стандартизации C++ решил, что нужно двигаться вперёд.</p><p>С 2011 года C++ стал популярным динамическим современным языком программирования.</p><p>Не думайте, что язык стал проще. Он до сих пор является одним из самых сложных языков программирования, если не самым сложным из широко используемых. Но, определённо, он стал гораздо проще своих предыдущих версий.</p><p>В этой статье мы рассмотрим новые функции этого языка (начиная с C++11, которому уже восемь лет), о которых должен знать каждый разработчик.</p><h3>Ключевое слово auto</h3><p>Жизнь стала гораздо проще, когда в C++11 появилось ключевое слово <strong>auto</strong>.</p><p>Суть этого ключевого слова в том, что оно даёт возможность автоматически определять тип данных на этапе компиляции программы. То есть, вам не нужно каждый раз объявлять, какого типа та или иная переменная. Это очень удобно при объявлении типов данных вроде <strong>map&lt;string,vector&lt;pair&lt;int,int&gt;&gt;&gt;</strong>.</p><pre>auto an_int = 26; //Тип распознаётся компилятором как int<br>auto a_bool = false; //bool<br>auto a_float = 26.04; //float<br>auto ptr = &amp;a_float; //Указатель<br>auto data; //Разве так можно? Нет.</pre><p>Обратите внимание на пятую строчку. Вы не можете объявить переменную таким образом без её инициализации. Логично. Компилятор не знает, какой тип данных вы будете использовать для этой переменной.</p><p>Изначально возможности <strong>auto</strong> были довольно ограничены, но с каждой новой версией языка они расширяются.</p><pre>auto merge(auto a, auto b) { //Параметры функции и тип, возвращаемый функцией, также могут быть определены при помощи auto<br>    std::vector&lt;int&gt; c = do_something(a, b);<br>    return c;<br>}</pre><pre>std::vector&lt;int&gt; a = {...}; //Какие-то данные<br>std::vector&lt;int&gt; b = {...}; //Ещё какие-то данные<br>auto c = merge(a, b); //Тип переменной будет определён в зависимости от аргументов, передаваемых функцией</pre><p>В седьмой и восьмой строчке при инициализации вектора используются скобки. Это новая функция, добавленная в C++11.</p><p>Не забывайте, что при использовании <strong>auto</strong> необходимо оставлять подсказки для компилятора для определения типа данных.</p><p>А теперь интересный вопрос: что произойдет, если мы напишем <strong>auto a = {1, 2, 3}</strong>? Компилятор выдаст ошибку? Или определит тип как <strong>vector</strong>?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*dGG0Bq82KUw0vRU1LQnjxA.jpeg" /></figure><p>В C++11 появился новый тип данных <strong>std::initializer_list&lt;type&gt;</strong>. При использовании для декларации переменной ключевого слова <strong>auto</strong> и инициализации списка при помощи скобок будет использоваться этот контейнер.</p><p>И последнее: как я упомянул ранее, использование этого ключевого слова крайне полезно, если у вас сложные структуры данных:</p><pre>void populate(auto &amp;data) { //<br>    data.insert({&quot;a&quot;, {1, 4}});<br>    data.insert({&quot;b&quot;, {3, 1}});<br>    data.insert({&quot;c&quot;, {2, 3}});<br>}</pre><pre>auto merge(auto data, auto upcoming_data) { //Зачем опять использовать длинные названия типов, если есть auto?<br>    auto result = data;<br>    for(auto it: upcoming_data) {<br>        result.insert(it);<br>    }<br>    return result;<br>}</pre><pre>int main() {<br>    std::map&lt;std::string, std::pair&lt;int, int&gt;&gt; data;<br>    populate(data);</pre><pre>    std::map&lt;std::string, std::pair&lt;int, int&gt;&gt; upcoming_data;<br>    upcoming_data.insert({&quot;d&quot;, {5, 3}});</pre><pre>    auto final_data = merge(data, upcoming_data);</pre><pre>    for(auto itr: final_data) {<br>        auto [v1, v2] = itr.second; //Структурная привязка, о которой я расскажу позже<br>        std::cout &lt;&lt; itr.first &lt;&lt; &quot; &quot; &lt;&lt; v1 &lt;&lt; &quot; &quot; &lt;&lt; v2 &lt;&lt; std::endl;<br>    }<br>    return 0;<br>}</pre><p>Обратите внимание на 25 строчку! Выражение <strong>auto [v1,v2] = itr.second</strong> — новая функция C++17. Такие выражения называются <strong>структурными привязками</strong>. В предыдущих версиях языка нужно было получать значение для каждой переменной отдельно. Теперь же структурные привязки позволяют делать это более удобным способом.</p><p>К тому же, если вы хотите получить данные при помощи ссылки, нужно лишь добавить амперсанд ( &amp;): <strong>auto &amp;[v1,v2] = itr.second</strong>.</p><h3>Лямбда-выражения</h3><p>В C++11 появились лямбда-выражения. Они похожи на анонимные функциональные выражения в JavaScript. Это безымянные функции, для которых можно определять видимость переменных. Также их можно присваивать переменным.</p><p>Лямбда-выражения полезны, если вам нужно сделать что-то внутри вашего кода, но создание для этого отдельной функции усложнит программу. Довольно часто они используются как функции-компараторы.</p><pre>std::vector&lt;std::pair&lt;int, int&gt;&gt; data = {{1, 3}, {7, 6}, {12, 4}}; //Упрощённая инициализация вектора<br>std::sort(begin(data), end(data), [](auto a, auto b) { //auto для типов параметров<br>    return a.second &lt; b.second;<br>});</pre><p>В примере выше есть достаточно много моментов, которые стоит упомянуть.</p><p>Во-первых, заметьте, как инициализация вектора при помощи фигурных скобок упрощает жизнь. Затем идут обобщённые функции <strong>begin()</strong> и <strong>end()</strong>, которые, к слову, тоже появились лишь в C++11. Потом в качестве компаратора передаётся лямбда-выражение. Типы параметров функции задаются ключевым словом <strong>auto</strong>, которое появилось в C++14. До этого мы не могли использовать его для параметров функции.</p><p>Обратите внимание на то, что мы начинаем лямбда-выражение с квадратных скобок <strong>[]</strong>. Они определяют область видимости нашей функции — авторитет функции над локальными переменными и объектами.</p><p>Как определено в репозитории C++:</p><ul><li><strong>[] </strong>— внутри функции вы можете использовать только параметры, локальные переменные не будут видны.</li><li><strong>[=] </strong>— позволяет использовать значения локальных объектов внутри функции, но не позволяет их изменять.</li><li><strong>[&amp;]</strong> — позволяет как использовать, так и менять локальные объекты.</li><li><strong>[this]</strong> — передаёт указатель <strong>this</strong> как значение.</li><li><strong>[a, &amp;b]</strong> — передаёт объект <strong>a</strong> как значение и объект <strong>b </strong>как ссылку.</li></ul><p>Таким образом, если вы хотите менять уже существующие данные внутри лямбда-выражения, установите её авторитет над локальными объектами. Например:</p><pre>std::vector&lt;int&gt; data = {2, 4, 4, 1, 1, 3, 9};<br>int factor = 7;<br>for_each(begin(data), end(data), [&amp;factor](int &amp;val) { //Ссылка на factor в области видимости лямбда-выражения<br>    val = val * factor;<br>    factor--; //Так можно делать, потому что мы разрешили лямбда-выражению менять эту переменную<br>});</pre><pre>for(int val: data) {<br>    std::cout &lt;&lt; val &lt;&lt; &#39; &#39;; //14 24 20 4 3 6 9<br>}</pre><p>В примере выше, если бы вы передали локальную переменную по значению (<strong>[factor]</strong>), то в пятой строчке вы не смогли бы изменить её значение. У вас просто-напросто нет прав на это. Помните о своих правах!</p><p>Заметьте, что параметр функции <strong>val</strong> — ссылка на объект. Таким образом, мы будем уверены в том, что лямбда-выражение действительно изменит вектор.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*PrqMVsKkbTFcZl6AiT5kRg.jpeg" /><figcaption>Они несказанно рады тому, что узнали об этих возможностях C++!</figcaption></figure><h3>init внутри if и switch</h3><p>Эта возможность C++17 мне полюбилась сразу же, как только я узнал о ней.</p><pre>std::set&lt;int&gt; input = {1, 5, 3, 6};</pre><pre>if(auto it = input.find(7); it == input.end()) { //Часть до точки с запятой - инициализация, после - условие<br>    std::cout &lt;&lt; 7 &lt;&lt; &quot; not found!&quot; &lt;&lt; std::endl;<br>}<br>else {<br>    //Область видимости it распространяется и на else<br>    std::cout &lt;&lt; 7 &lt;&lt; &quot; is there!&quot; &lt;&lt; std::endl;<br>}</pre><p>Теперь вы можете инициализировать переменные и проверять условия сразу же внутри блоков <strong>if</strong> и <strong>switch</strong>. Это помогает сохранять код понятным и чистым. Общий синтаксис таков:</p><pre>if( init-statement(x); condition(x)) {<br>    // Сделать что-то<br>} <br>else { //Внутри else видна переменная x <br>    //Сделать ещё что-то<br>}</pre><h3>Сделай это при компиляции: constexpr</h3><p><strong>constexpr </strong>— это классно!</p><p>Допустим, у вас есть выражение, значение которого нужно вычислить и которое не будет меняться после этого. Вы можете вычислить значение заранее и использовать его как макрос. Или, как предлагает C++11, вы можете использовать <strong>constexpr</strong>.</p><p>Программисты сокращают время работы программы насколько возможно. Например, некоторые операции перекладываются на компилятор.</p><pre>constexpr double fib(int n) { //Функция задекларирована как constexpr<br>    if(n == 1) return 1;<br>    return fib(n - 1) * n;<br>}</pre><pre>int main() {<br>    const long long bigval = fib(20);<br>    std::cout &lt;&lt; bigval &lt;&lt; std::endl;<br>}</pre><p>Код выше — довольно частый пример использования <strong>constexpr</strong>.</p><p>Так как мы объявили функцию вычисления чисел Фибоначчи как <strong>constexpr</strong>, компилятор вычислит значение <strong>fib(20)</strong> во время компиляции. Тогда после компиляции строка <strong>const long long bigval = fib(20);</strong> будет заменена на <strong>const long long bigval = 2432902008176640000;</strong></p><p>Заметьте, что передаваемый аргумент имеет квалификатор <strong>const</strong>. Это один из немаловажных моментов использования функций с флагом <strong>constexpr</strong>. Аргументы такой функции также должны быть <strong>constexpr</strong> или <strong>const</strong>. В противном случае функция будет вести себя, как совершенно обыкновенная, то есть, вычисления не будут выполнены во время компиляции.</p><p>Спецификатор <strong>constexpr</strong> может применяться и к переменным. В этом случае переменная должна однозначно вычисляться во время компиляции, или программа выдаст ошибку компиляции.</p><p>Кстати, в C++17 появились ещё и такие ключевые слова, как <strong>constexpr-if</strong> и <strong>constexpr-lambda</strong>.</p><h3>Кортеж — tuple</h3><p>Как и <strong>pair</strong>, <strong>tuple</strong> — коллекция значений различных типов данных конкретного размера.</p><pre>auto user_info = std::make_tuple(&quot;M&quot;, &quot;Chowdhury&quot;, 25); //Используйте auto для автоматического определения типа</pre><pre>//Получить данные<br>std::get&lt;0&gt;(user_info);<br>std::get&lt;1&gt;(user_info);<br>std::get&lt;2&gt;(user_info);</pre><pre>//В C++11 для структурных привязок используется tie</pre><pre>std::string first_name, last_name, age;<br>std::tie(first_name, last_name, age) = user_info;</pre><pre>//конечно, в C++17 всё стало гораздо проще<br>auto [first_name, last_name, age] = user_info</pre><p>В некоторых случаях вместо <strong>tuple</strong> удобнее использовать <strong>std::array</strong>. Это обычный массив с некоторыми функциями стандартной библиотеки C++, который был добавлен в C++11.</p><h3>Вывод параметра шаблона класса</h3><p>Довольно странное название функции, да? Её суть в том, что с C++17 компилятор может сам определять типы аргументов конструкторов стандартных классов. Раньше же это работало лишь для функций.</p><pre>std::pair&lt;std::string, int&gt; user = {“M”, 25}; // раньше<br>std::pair user = {“M”, 25}; // C++17</pre><p>Для кортежей всё становится ещё проще:</p><pre>// раньше<br>std::tuple&lt;std::string, std::string, int&gt; user (“M”, “Chy”, 25);<br>// предугадывание в действии!<br>std::tuple user2(“M”, “Chy”, 25);</pre><p>Для того, чтобы осознать удобство этой функции, нужно быть знакомыми с конструкторами классов в C++.</p><h3>Умные указатели</h3><p>Указатели могут быть ужасны.</p><p>Из-за свободы, которую вам даёт C++, довольно часто бывает удивительно легко загнать себя в ловушку. И во многих случаях в этом виноваты указатели.</p><p>К счастью, в C++11 появились умные указатели. Работать с ними на порядок удобнее, нежели с обычными указателями. Они предотвращают утечку памяти, так как сами освобождают себя, если они не нужны. К тому же они обеспечивают устойчивость к исключениям.</p><p>Я хотел бы написать ещё больше об умных указателях, но я не умещу здесь все важные детали.</p><p>Это всё на сегодня. С каждой версией в C++ появляются новые функции. Если вам интересно, можете узнать о них больше в <a href="https://github.com/rigtorp/awesome-modern-cpp">этом репозитории</a>.</p><p><em>Перевод статьи </em><a href="https://medium.com/@mottakin"><em>M Chowdhury</em></a><em>: </em><a href="https://www.freecodecamp.org/news/some-awesome-modern-c-features-that-every-developer-should-know-5e3bf6f79a3c/"><em>Some awesome modern C++ features that every developer should know</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77bf21afc8c8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B2%D0%BE%D0%B7%D0%BC%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8-c-%D0%BE-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D1%8B%D1%85-%D0%B4%D0%BE%D0%BB%D0%B6%D0%B5%D0%BD-%D0%B7%D0%BD%D0%B0%D1%82%D1%8C-%D0%BA%D0%B0%D0%B6%D0%B4%D1%8B%D0%B9-%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D1%87%D0%B8%D0%BA-77bf21afc8c8">Возможности C++, о которых должен знать каждый разработчик</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[Создание анимации Gapminder двумя строчками кода с помощью Plotly Express]]></title>
            <link>https://medium.com/nuances-of-programming/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B0%D0%BD%D0%B8%D0%BC%D0%B0%D1%86%D0%B8%D0%B8-gapminder-%D0%B4%D0%B2%D1%83%D0%BC%D1%8F-%D1%81%D1%82%D1%80%D0%BE%D1%87%D0%BA%D0%B0%D0%BC%D0%B8-%D0%BA%D0%BE%D0%B4%D0%B0-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-plotly-express-ea88ec7c8e3d?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea88ec7c8e3d</guid>
            <category><![CDATA[data-analytics]]></category>
            <category><![CDATA[data-visualization]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Sat, 06 Jul 2019 17:01:00 GMT</pubDate>
            <atom:updated>2019-07-06T17:01:00.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iK4KAhQ9EypQO7kKi0aAlQ.png" /></figure><blockquote>Дисклеймер: мною использовался новый модульplotly_express, сама анимация Gapminder не создавалась с нуля всего двумя строчками.</blockquote><p>Один из значимых моментов в истории визуализации данных — презентация Гансом Рослингом знаменитой анимации Gapminder на <a href="https://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen">TED</a>, которое вскоре получило огромное число просмотров. С этого момента создание такой же анимации стало показателем мастерства в области визуализации данных наравне с работами Эдварда Тафти или Нейта Сильвера.</p><p><a href="https://twitter.com/plotlygraphs/status/1108395986626494467">Недавно</a> <strong>Plotly</strong> (известная дополнением для интерактивной визуализации для R и Python) выпустила новое расширение/модуль/библиотеку под названием <a href="https://github.com/plotly/plotly_express"><strong>Plotly Express</strong></a>. Как понятно из названия, цель plotly express — стать высокоуровневым, лёгким и быстрым в использовании API для создания интерактивной визуализации.</p><p>Иерархия примерно такова:</p><blockquote><em>Plotly Express:Plotly.py :: Seaborn:Matplotlib</em></blockquote><p>Вдохновлённая ggplot2 для R и seaborn для Python, plotly express максимально проста. Все операции выполняются лишь в одну строчку. В этой статье я покажу, как создать анимацию, похожую на знаменитую анимацию Gapminder, используя только plotly express.</p><h4>Установка</h4><p>pip3 install plotly_express</p><h4>Импорт библиотеки с сокращением названия:</h4><p>import plotly_express as px</p><h3>Анимация пузырькового графа или анимация Gapminder</h3><pre>px.scatter(px.data.gapminder(), x=&quot;gdpPercap&quot;, y=&quot;lifeExp&quot;, animation_frame=&quot;year&quot;, animation_group=&quot;country&quot;,<br>           size=&quot;pop&quot;, color=&quot;country&quot;, hover_name=&quot;country&quot;, <br>           log_x = True, <br>           size_max=45, range_x=[100,100000], range_y=[25,90])</pre><p>Функция px.scatter() довольно незамысловатая. Она получает данные из px.data.gapminder() и определяет оси через параметры x и y. Параметр для кадров определяется через animation_frame. В нашем случае это год, значение которого увеличивается с каждым последующим кадром. При помощи ещё нескольких аргументов, передаваемых функции, мы украшаем график (определяем размер и цвета пузырьков) и он готов!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FEK5mGvUKf14%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DEK5mGvUKf14&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FEK5mGvUKf14%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d2287e5f13bfd1dbbca1b4572d95a870/href">https://medium.com/media/d2287e5f13bfd1dbbca1b4572d95a870/href</a></iframe><h4>Заключение</h4><p>Цель этого поста — рассказать миру о plotly_express, которая является отличной библиотекой для создания красивых интерактивных визуализаций (схожая с highcharter в R).</p><h3>Ресурсы</h3><ul><li><a href="https://github.com/amrrs/blogpost_codes/blob/master/gapminder_animation_plotly_express.ipynb">Код, использовавшийся в статье</a></li><li><a href="https://medium.com/@plotlygraphs/introducing-plotly-express-808df010143d">Введение в Plotly Express</a> (на английском)</li><li><a href="https://plotly.github.io/plotly_express/">Документация Plotly</a></li></ul><p><em>Перевод статьи </em><a href="https://towardsdatascience.com/@amrwrites"><em>AMR</em></a><em>: </em><a href="https://towardsdatascience.com/recreating-gapminder-animation-in-2-lines-of-python-with-plotly-express-2060c73bedec"><em>Recreating Gapminder Animation in 2 lines of Python with Plotly Express</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea88ec7c8e3d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B0%D0%BD%D0%B8%D0%BC%D0%B0%D1%86%D0%B8%D0%B8-gapminder-%D0%B4%D0%B2%D1%83%D0%BC%D1%8F-%D1%81%D1%82%D1%80%D0%BE%D1%87%D0%BA%D0%B0%D0%BC%D0%B8-%D0%BA%D0%BE%D0%B4%D0%B0-%D1%81-%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E-plotly-express-ea88ec7c8e3d">Создание анимации Gapminder двумя строчками кода с помощью Plotly Express</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%BB%D1%8F-%D1%87%D0%B5%D0%B3%D0%BE-%D0%BD%D1%83%D0%B6%D0%BD%D1%8B-%D1%81%D1%82%D0%B5%D0%BA%D0%B8-cf1019829f0?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf1019829f0</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[stack]]></category>
            <category><![CDATA[undo]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Wed, 03 Jul 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-07-03T17:01:01.290Z</atom:updated>
            <content:encoded><![CDATA[<p>Когда я узнал, что такое стек, мне стало интересно его практическое применение. Оказалось, что чаще всего эта структура используется для имплементации операции “Отмена” ( то есть, <strong>⌘</strong>+<strong>Z</strong> или <strong>Ctrl</strong>+<strong>Z</strong>).</p><p>Чтобы понять, как это работает, разберемся с определением стека.</p><h3>Что такое стек?</h3><p>Стек — список элементов, который может быть изменён лишь с одной стороны, называющейся <strong>вершиной</strong> стека.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*wDknaVQVfDhSIRyOWJZWzQ.jpeg" /></figure><p>Представьте приспособление для раздачи тарелок, в котором тарелки стоят в стопке. Новые тарелки можно добавлять только поверх уже имеющихся, а брать можно лишь сверху. Таким образом, чем позже тарелку положат в стопку, тем раньше её оттуда возьмут. В рамках структур данных это называется LIFO-принципом (последним пришёл — первым ушёл).</p><p>Если использовать терминологию, то стек поддерживает операции добавления (<strong>push</strong>) и удаления (<strong>pop</strong>) элементов на его вершине.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/399/1*M-SFLjxOM9mKOkXI04lf1Q.png" /></figure><h3>Зачем использовать стек для отмены?</h3><p>Потому что обычно мы хотим отменить последнее действие.</p><p>Стек позволяет <strong>добавлять</strong> элементы к его <strong>вершине </strong>и <strong>удалять</strong> тот элемент, который был последним.</p><blockquote>Что произойдёт, если ни одно действие не будет отменено? Стек ведь станет огромным!</blockquote><p>Верно. Если не удалять элементы из <strong><em>стека отмены</em></strong>, то есть не использовать операцию отмены, то он станет очень большим. Именно поэтому такие приложения, как Adobe Photoshop, с увеличением времени работы над файлом используют всё больше и больше оперативной памяти. <strong><em>Стек отмены</em></strong> хранит все действия, произведённые над файлом, в памяти до тех пор, пока вы не сохраните и не закроете файл.</p><h3>Имплементация стека</h3><p>Стек можно реализовать, используя либо связные списки, либо массивы. Я приведу пример реализации стека на обеих структурах на Python и расскажу о плюсах и минусах каждой.</p><h4>Стек на связном списке:</h4><pre>from LinkedList import LinkedList<br># LinkedList.py можно найти здесь: https://gist.github.com/nsafai/01395dc3d5fb48680fc0f14686f4b24e<br><br>class LinkedStack(object):<br><br>    def __init__(self, iterable=None):<br>        &quot;&quot;&quot;Инициализация стека и добавление в него элементов, если они есть.&quot;&quot;&quot;<br>        self.list = LinkedList() # Инициализация связного списка для наследования методов<br>        if iterable is not None:<br>            for item in iterable:<br>                self.push(item)<br><br>    def push(self, item):<br>        &quot;&quot;&quot;&quot;Добавление элементов в вершину стека<br>        Сложность: O(1), потому что мы меняем первый элемент списка&quot;&quot;&quot;<br>        self.list.prepend(item)<br>    <br>    def peek(self):<br>        &quot;&quot;&quot;Возвращает верхний элемент стека, не удаляя его,<br>        или None, если стек пустой.&quot;&quot;&quot;<br>        head = self.list.head<br>        return None if head is None else head.data<br>    <br>    def pop(self):<br>        &quot;&quot;&quot;Удаляет и возвращает верхний элемент, если он есть, иначе выдаёт ValueError<br>        Сложность: O(1), потому что мы меняем первый элемент списка&quot;&quot;&quot;<br>        head = self.peek()<br>        self.list.delete(head)<br>        return head</pre><h4>Стек на массиве:</h4><pre>class ArrayStack(object):<br><br>    def __init__(self, iterable=None):<br>        &quot;&quot;&quot;Инициализация стека и добавление в него элементов, если они есть.&quot;&quot;&quot;<br>        self.list = list() # Инициализация списка (встроенного в Python динамического массива) для хранения элементов<br>        if iterable is not None:<br>            for item in iterable:<br>                self.push(item)<br>    <br>    def push(self, item):<br>        &quot;&quot;&quot;&quot;Добавление элементов на вершину стека<br>        Сложность: O(1), пока мы не заполним всю выделенную память, затем O(n)&quot;&quot;&quot;<br>        self.list.append(item)<br><br>    def peek(self):<br>        &quot;&quot;&quot;Возвращает верхний элемент стека, не удаляя его,<br>        или None, если стек пустой.&quot;&quot;&quot;<br>        last_item_idx = len(self.list) - 1<br>        return None if last_item_idx &lt; 0 else self.list[last_item_idx]<br>    <br>    def pop(self):<br>        &quot;&quot;&quot;Удаляет и возвращает верхний элемент, если он есть, иначе выдаёт ValueError<br>        Сложность: O(1), так как нужно удалить лишь последний элемент&quot;&quot;&quot;<br>        if self.peek() == None:<br>            raise ValueError(&quot;list is empty&quot;)<br>        else:<br>            return self.list.pop()</pre><h3>Что лучше?</h3><p>В коде я указал сложность каждой из операций, используя “О” большое. Как видите, имплементации мало чем отличаются.</p><p>Однако есть некоторые нюансы, которые стоит учесть.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*IG7o9EOsEvB0EjFGPjh05w.jpeg" /></figure><h4>Массив</h4><p>Это непрерывный блок памяти. Из-за этого при маленьком размере стека массив будет занимать лишнее место. Ещё один недостаток в том, что каждый раз при увеличении размера массива придётся копировать все уже существующие элементы в новую ячейку памяти.</p><h4>Связный список</h4><p>Он состоит из отдельных блоков в памяти и может увеличиваться бесконечно. Поэтому, с одной стороны, имплементация стека с использованием этой структуры <strong>немного лучше с точки зрения сложности алгоритма</strong>. С другой стороны, каждый элемент должен хранить адреса предыдущего и следующего элемента, что <strong>требует больше памяти</strong>.</p><h4>Заключение</h4><p>Так как динамический массив увеличивается в два раза при заполнении очереди, необходимость выделить дополнительную память будет возникать всё реже и реже. Кроме того, так как указатели не занимают много места, дополнительные данные в связных списках не критичны.</p><p>Как видим, между этими двумя реализациями стека практически нет различий — используйте ту, что нравится вам.</p><p><em>Перевод статьи </em><a href="https://medium.com/@nicolaisafai"><em>Nicolai Safai</em></a><em>: </em><a href="https://medium.com/@nicolaisafai/what-are-stacks-useful-for-79668042e12b"><em>What are Stacks useful for?</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf1019829f0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%B4%D0%BB%D1%8F-%D1%87%D0%B5%D0%B3%D0%BE-%D0%BD%D1%83%D0%B6%D0%BD%D1%8B-%D1%81%D1%82%D0%B5%D0%BA%D0%B8-cf1019829f0">Для чего нужны стеки?</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%D0%BE%D1%87%D0%B5%D0%BC%D1%83-%D0%BB%D1%8E%D0%B4%D0%B8-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%BB%D0%B8%D0%B2%D0%B0%D1%8E%D1%82-%D1%81%D0%BE%D0%B1%D0%B5%D1%81%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BF%D0%BE-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0%D0%BC-%D0%B8-%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0%D0%BC-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B2-%D0%BA%D1%80%D1%83%D0%BF%D0%BD%D1%8B%D1%85-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F%D1%85-7575d92ac89e?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/7575d92ac89e</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[jobs]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Tue, 02 Jul 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-07-02T17:01:01.315Z</atom:updated>
            <content:encoded><![CDATA[<h3>Почему люди проваливают собеседования по алгоритмам и структурам данных в крупных компаниях?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*fAZ0YUIwSZuQChHu-DmX6Q.jpeg" /></figure><p>Компьютерные науки — это область с огромными возможностями. Миллионы студентов всего мира мечтают построить карьеру в этой сфере. Но возникает неожиданная проблема: несмотря на то, что существует огромное количество обучающих ресурсов, большинству студентов не удаётся стать хорошими специалистами и удачно пройти собеседование. Опираясь на свой опыт работы более чем с тысячей учеников, в этой статье я хотел бы обратить внимание на пять основных трудностей в изучении компьютерных наук.</p><blockquote><strong>«</strong>Умение решать задачи есть искусство, приобретающееся практикой, подобно, скажем, плаванию. Мы овладеваем любым мастерством при помощи подражания и опыта <strong>»,</strong> — Дьёрдь Пойа.</blockquote><p><strong>Но перед тем, как перейти к трудностям, я хотел бы поведать вам одну историю.</strong></p><p>До поступления в Индийский институт технологий я ни разу не использовался компьютерами. На первом курсе я получал низкие оценки по курсу языков программирования. Тогда я попросил о помощи старшекурсников, но они не смогли мне понятно все объяснить. Я заставил себя смириться с тем, что точно не смогу работать в области компьютерных наук. Но, как говорил Стив Джобс:</p><blockquote>«Ты не можешь соединить ключевые точки своей жизни наперёд; но можешь всё связать воедино, оглядываясь назад».</blockquote><p>На третьем курсе один из моих друзей объяснял рекурсивный алгоритм нахождения n-ного числа Фибоначчи. Он сказал, что рекурсия в этом случае — не лучший метод, так как при больших значениях n компьютеру могут понадобиться годы на вычисление.</p><p>Я сказал: “Правда? Как так?”</p><p>Он ответил: “Сложность этого алгоритма — экспоненциальная функция от n”. Мой друг сразу же объяснил мне, что такое сложность алгоритма и привел доказательство.</p><p>Я удивился и спросил: “Почему тогда на экзамене на первом курсе студенты писали именно этот код?”</p><p>Друг улыбнулся и ответил: “Потому что они просто запомнили его и даже не думали о его производительности”. Затем он объяснил мне более эффективный метод решения с использованием динамического программирования.</p><p>Я впервые приблизился к пониманию значимости алгоритмов. В тот момент они меня настолько заинтересовали, что я изучил книгу “Алгоритмы: построение и анализ” дважды за сто дней!</p><p>Решение задач при помощи алгоритмов и структур данных — моя страсть. Я верю в то, что персональный подход к каждому ученику поможет в преодолении сложностей в обучении и достижении успехов. И вот, наконец: пять сложностей, которые я выявил за четыре года преподавания:</p><ol><li><strong>Отсутствие структурированного обучения:</strong> обучение программированию должно проходить согласно определённому плану, в котором темы идут последовательно: от простых к сложным. Студенты часто путаются из-за непоследовательности тем и сложных примеров, затрагивающих ещё не пройденные материалы. В конце концов, они просто зубрят решения рассмотренных задач, что оказывается совершенно бесполезным на собеседованиях.</li><li><strong>Необходимость применения различных навыков:</strong> учащиеся должны уметь понимать условие задачи, разрабатывать подходящий алгоритм для каждого случая и писать его реализацию. Кстати, понимание применения алгоритма в реальной жизни способствует выработке долгосрочного интереса к его изучению.</li><li><strong>Предубеждения:</strong> большое количество учащихся уверено в том, что решение задач на применение алгоритмов — это сложно. Такое мнение передаётся по цепочке. Таким образом складывается ложное впечатление о сложности предмета.</li><li><strong>Недостаток взаимопомощи:</strong> в самом начале обучения учащиеся не могут понять, какие вопросы стоит задавать знакомым, уже разбирающимся в этой теме, и нужно ли их вообще задавать.</li><li><strong>Неопределённый план карьеры:</strong> обучение программированию помогает получить высокооплачиваемую работу, однако большинство учащихся во время обучения не задумываются о том, какие умения нужны для их будущего карьерного роста. Поэтому немаловажно найти заранее конкретную компанию и позицию для того, чтобы определить индивидуальный план обучения необходимым навыкам.</li></ol><p>Знание этих проблем может помочь вам их избежать. Удачи в обучении и прохождении собеседований!</p><p><em>Перевод статьи </em><a href="https://medium.com/@shubhamkumargautam"><em>Shubham Gautam</em></a><em>: </em><a href="https://medium.com/afteracademy/why-do-students-fail-in-algorithms-and-data-structure-interviews-for-top-companies-4fcca7ce7580"><em>Why do students fail in Algorithms and Data Structure Interviews for Top Companies?</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7575d92ac89e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BF%D0%BE%D1%87%D0%B5%D0%BC%D1%83-%D0%BB%D1%8E%D0%B4%D0%B8-%D0%BF%D1%80%D0%BE%D0%B2%D0%B0%D0%BB%D0%B8%D0%B2%D0%B0%D1%8E%D1%82-%D1%81%D0%BE%D0%B1%D0%B5%D1%81%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F-%D0%BF%D0%BE-%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0%D0%BC-%D0%B8-%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0%D0%BC-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85-%D0%B2-%D0%BA%D1%80%D1%83%D0%BF%D0%BD%D1%8B%D1%85-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B0%D0%BD%D0%B8%D1%8F%D1%85-7575d92ac89e">Почему люди проваливают собеседования по алгоритмам и структурам данных в крупных компаниях</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%D0%B8%D1%88%D0%B5%D0%BC-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%83%D1%8E-%D1%81%D0%B5%D1%82%D1%8C-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D0%B0%D1%8F-%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D0%BA%D0%B0%D0%B7%D1%8B%D0%B2%D0%B0%D0%BB%D0%B0-%D0%B1%D1%8B-%D1%80%D0%B0%D0%BA-%D0%B3%D1%80%D1%83%D0%B4%D0%B8-%D0%B7%D0%B0-%D0%BF%D1%8F%D1%82%D1%8C-%D0%BC%D0%B8%D0%BD%D1%83%D1%82-3285c9d659d0?source=rss-a67d2e998aab------2</link>
            <guid isPermaLink="false">https://medium.com/p/3285c9d659d0</guid>
            <category><![CDATA[cancer]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[not eisenheim]]></dc:creator>
            <pubDate>Sun, 30 Jun 2019 17:01:01 GMT</pubDate>
            <atom:updated>2019-06-30T17:01:01.062Z</atom:updated>
            <content:encoded><![CDATA[<h3>Пишем нейронную сеть, предсказывающую рак груди, за пять минут</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*zLEDO7CtvwRnSVzozKLObg.png" /><figcaption>Не тратьте время на прочтение этой надписи, ведь урок рассчитан всего на пять минут!</figcaption></figure><h3>Минута первая: вступление</h3><p>Этот высокоуровневый урок рассчитан на новичков в машинном обучении и искусственном интеллекте. Для того, чтобы успешно создать нейронную сеть, необходимы:</p><ol><li>Установленный Python второй или третьей версии.</li><li>Как минимум начальный уровень программирования.</li><li>Пять минут свободного времени.</li></ol><p>Мы пропустим огромное количество деталей работы нейронной сети, не будем углубляться в теоретическую часть и сфокусируемся на предсказании рака всего лишь за 5 минут!</p><p>Для построения предсказаний будем использовать имплементацию нейронной сети из библиотеки scikit-learn. Сами же предсказания будут основаны на данных из датасета Калифорнийского университета в Ирвайн “Breast Cancer Wisconsin” (рак груди, Висконсин). На вход нейронной сети подаются свойства клеточных ядер новообразования (например, строение), а на выходе мы получаем предсказание: злокачественное или доброкачественное новообразование.</p><h3>Минута вторая: начало работы</h3><p>Если у вас не установлена библиотека scikit-learn, то запустите команду pip install scikit-learn в терминале, которая установит библиотеку и все её зависимости.</p><p>Откройте среду разработки и создайте новый файл под названием, например, neuralnet.py. Теперь мы загрузим имплементацию нейронной сети, обучающие данные и функцию для разделения наших данных на тренировочный и тестовый наборы для нейронной сети.</p><pre># Имплементация нейронной сети<br>from sklearn.neural_network import MLPClassifier<br># Функция для загрузки датасета<br>from sklearn.datasets import load_breast_cancer<br># Функция для разделения датасета<br>from sklearn.model_selection import train_test_split</pre><p>Ссылки на документации используемых методов и датасетов scikit-learn (на английском):</p><ol><li><a href="https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html">Документация датасета с данными о раке груди (</a><a href="https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html">load_breast_cancer)</a></li><li><a href="https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html">Документация для функции предобработки данных (</a><a href="https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html">train_test_split)</a></li><li><a href="https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier">Документация для имплементации нейронной сети (</a><a href="https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier">MLPClassifier)</a></li></ol><h3>Минута третья: предварительная обработка</h3><p>Прежде чем приступить к обучению нейронной сети на датасете, необходимо обработать данные. Для начала загрузим данные и выделим в attributes свойства новообразований (двумерный список, содержащий численные значения), а в labels — целевые переменные, метки злокачественности или доброкачественности новообразования (список из нулей и единиц). Содержимое каждого из списков соответствует содержимому другого списка под тем же индексом, то есть, к примеру, labels[0] определяет значение целевой переменной для признаков, хранящихся в attributes[0].</p><pre>data = load_breast_cancer() # Загружаем и сохраняем датасет<br>attributes = data.data # Свойства клеточных ядер <br>labels = data.target # Метки злокачественности</pre><p>Теперь мы разделяем данные на тренировочные (для обучения нейронной сети) и тестовые (для проверки корректности ее работы). Тренировочный набор данных состоит из attributes_train и labels_train, тестовый — изattributes_test и labels_test. Треть наших данных будет составлять тестовый сет, оставшиеся две трети — обучающий.</p><pre>attributes_train, attributes_test, labels_train, labels_test = train_test_split(attributes, labels, test_size=0.33)</pre><h3>Минута четвёртая: нейронная сеть</h3><p>Теперь, когда наши данные разделены на обучающий и тестовый сеты, мы можем обучить нашу нейронную сеть! Для начала нужно создать нейронную сеть с многослойным перцептроном. Затем обучаем её на наших данных при помощи функции fit, измеряем её точность при помощи функции score и выводим эту точность.</p><pre>neuralnet = MLPClassifier() # Инициализация нейронной сети<br>neuralnet.fit(attributes_train, labels_train) # Обучение сети<br>accuracy = neuralnet.score(attributes_test, labels_test) # Измерение точности работы сети<br>print(str(accuracy * 100) + &quot;% accuracy&quot;) # Вывод значения точности в процентах</pre><p>Попробуйте запустить нейронную сеть через терминал командой python neuralnet.py примерно десять раз (можете заменить neuralnet.py на название вашего скрипта) и сравните результаты.</p><h3>Минута пятая: оптимизация результата</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/471/1*GCHXYIzkfkt6_Lq2N_Gd9g.png" /><figcaption>Результаты работы классификатора</figcaption></figure><p>Есть вероятность, что разница в измерениях точности нейронной сети будет большой. Когда мы разделяли данные на обучающий и тестовый сеты, данные были перемешаны случайно, что и объясняет изменения результатов. В нашем датасете всего лишь 569 объектов, и модель обучается на 379 его объектах-представителях, что приводит к переобучению, так как данных слишком мало.</p><p>К тому же мы создавали нейронную сеть при помощи конструктора neuralnet = MLPClassifier(), которому не передали ни одного аргумента. Это значит, что сеть была построена с использованием параметров по умолчанию, то есть, она не оптимизирована.</p><p>Мы можем исправить ситуацию либо обучая сеть на большем наборе данных, либо настраивая параметры датасета.</p><p>Я выбрал второй вариант и переключил solver с adam (по умолчанию) наlbfgs. В документации было сказано, что этот параметр позволяет оптимизировать сеть на маленьких наборах данных. Также я изменил активационную функцию с relu на logistic и экспериментальным путём установил, что значения alpha от 0.0001 до 10.0 предотвращают переобучение.</p><pre># Замените предыдущую строку инициализации нейронной сети на эту<br>neuralnet = MLPClassifier(solver=&#39;lbfgs&#39;, activation=&#39;logistic&#39;, alpha=10.0)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/465/1*3B4P2Wcu_9Ugsl2vTTOJxA.png" /><figcaption>Результаты работы оптимизированного классификатора</figcaption></figure><p>Теперь это выглядит гораздо лучше! Точность до сих пор не так высока, как хотелось бы, однако разница между показателями значительно уменьшилась. И это не все изменения, которые можно было бы сделать. Вы можете разобраться в документации и продолжить процесс оптимизации.</p><h3>Заключение</h3><p>То, чему мы научились, применимо к любому датасету и к любому алгоритму машинного обучения, реализованному в scikit-learn. Я выбрал нейронную сеть для предсказания рака груди, потому что эти две темы сейчас являются одними из самых обсуждаемых в сфере точных наук.</p><p>Для того, чтобы применить другой алгоритм, нужно просто изменить импортируемый алгоритм и вызвать его конструктор, например:</p><pre># Имплементация случайного леса<br>from sklearn.ensemble import RandomForestClassifier<br><br># Предобработка данных<br><br># Инициализация случайного леса<br>randomforest = RandomForestClassifier()<br><br># Обучение и тестирование модели</pre><p>Если вы заинтересовались машинным обучением, то в интернете имеется множество курсов на эту тему, например, на Coursera, которые помогут разобраться в работе алгоритмов.</p><p><em>Перевод статьи </em><a href="https://medium.freecodecamp.org/@andrewyinli"><em>Andrew Li</em></a><em>: </em><a href="https://medium.freecodecamp.org/how-to-program-a-neural-network-to-predict-breast-cancer-in-only-5-minutes-23289d62a4c1"><em>How to program a neural network to predict breast cancer in only 5 minutes</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3285c9d659d0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/nuances-of-programming/%D0%BF%D0%B8%D1%88%D0%B5%D0%BC-%D0%BD%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D1%83%D1%8E-%D1%81%D0%B5%D1%82%D1%8C-%D0%BA%D0%BE%D1%82%D0%BE%D1%80%D0%B0%D1%8F-%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D0%BA%D0%B0%D0%B7%D1%8B%D0%B2%D0%B0%D0%BB%D0%B0-%D0%B1%D1%8B-%D1%80%D0%B0%D0%BA-%D0%B3%D1%80%D1%83%D0%B4%D0%B8-%D0%B7%D0%B0-%D0%BF%D1%8F%D1%82%D1%8C-%D0%BC%D0%B8%D0%BD%D1%83%D1%82-3285c9d659d0">Пишем нейронную сеть, которая предсказывала бы рак груди, за пять минут</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>