<?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 Evandro Vieira on Medium]]></title>
        <description><![CDATA[Stories by Evandro Vieira on Medium]]></description>
        <link>https://medium.com/@evanVieira?source=rss-636c618f3f6d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VFls4TWaH1sUp66NDP79yw@2x.jpeg</url>
            <title>Stories by Evandro Vieira on Medium</title>
            <link>https://medium.com/@evanVieira?source=rss-636c618f3f6d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 14:15:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@evanVieira/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[F-strings: Um crash course sobre um dos melhores recursos do Python (e o que há de novo nele)]]></title>
            <link>https://medium.com/@evanVieira/f-strings-um-crash-course-sobre-um-dos-melhores-recursos-do-python-e-o-que-h%C3%A1-de-novo-nele-084bf497c381?source=rss-636c618f3f6d------2</link>
            <guid isPermaLink="false">https://medium.com/p/084bf497c381</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tecnologia]]></category>
            <category><![CDATA[inovação]]></category>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Evandro Vieira]]></dc:creator>
            <pubDate>Mon, 04 Mar 2024 17:24:45 GMT</pubDate>
            <atom:updated>2024-03-04T17:25:15.206Z</atom:updated>
            <content:encoded><![CDATA[<h3>F-strings: Falando sobre um dos melhores recursos básicos do Python (e o que há de novo nele)</h3><h4>Muito se fala do mais avançado em Machine Learning, GPU, API e Programação em geral, com o básico ficando pra trás. E nada melhor do que trazer o básico novamente a tona através das f-strings</h4><blockquote>⚠️ <strong>Disclaimer </strong>⚠️<strong>:</strong></blockquote><blockquote>Este artigo foi feito com base em vários links, documentações (citadas na referência bibliográfica) e teve inspiração no artigo “Mastering 100 Python F-Strings from Basic to Advanced, Novel Tricks and Cheat Sheets” do <a href="https://ravi-m.medium.com/">Ravi M</a>.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*onF_2JHXZ1LPw4uqvlWBSw.jpeg" /><figcaption>Imagem: <a href="https://pt.pngtree.com/freebackground/closeup-of-3d-rendered-flexible-copper-wires-for-electrical-applications_5597277.html">https://pt.pngtree.com/freebackground/closeup-of-3d-rendered-flexible-copper-wires-for-electrical-applications_5597277.html</a></figcaption></figure><p>Uma das primeiras coisas na programação que aprendemos a fazer, seja em cursos pela internet ou em bacharelados na área de tecnologia, é o famoso “hello, world”. Chamamos algum método/função/etc chamada <em>print</em> (ou as suas variantes, mas que passam a mesma ideia) e, dentro dos parêntesis e dentro de aspas, escrevemos <em>olá mundo</em> ou <em>hello world</em> — inclusive há a lenda do azar que cai sob o programador quando se esquece de fazer isso. E fazemos esse <em>hello world</em> através de algo chamado <em>string</em> (que é uma coleção de caracteres — a definição é mais ampla e profunda, o importante é saber apenas isso no momento). Simples, não? E é.</p><p>Passado isso, vamos para tópicos cada vez mais avançados dentro da programação — desde atribuição de variáveis até construção de APIs, construção de modelos com séries temporais, programação em Assembly, arquitetura de computadores; A lista é longa, o espectro do que podemos aprender é abissal. Entendam: É o fluxo natural das coisas.</p><h4>Strings: A volta dos que não foram</h4><p>E a medida que vamos na direção do complexo, o simples fica pra trás. Manipulação de strings, por exemplo, é um assunto que é dado bem no início de muitos cursos de programação e acaba sendo mais extenso do que aparenta. Vejamos um exemplo de string, para termos um contexto:</p><pre>variavel_string = “Isso aqui é uma string!”</pre><p>Agora, vamos ver algo chamado <em>concatenação,</em> que é quando juntamos duas ou mais strings, ou quando juntamos strings com variáveis de outros tipos, etc. A grosso modo:</p><pre>string_1 = &quot;Isso aqui é uma string. &quot;<br>string_2 = &quot;Aprenderam?&quot;<br><br>string_pronta = string1 + string2</pre><p>Podemos fazer algo além, que é definir uma string e, dentro dessa string, chamar uma outra variável qualquer. Em Python, há algumas formas de fazer esse tipo de concatenação:</p><pre># Variáveis definidas<br>idade = 26<br>nome = &quot;Evandro&quot;<br><br>nome = &quot;Evandro&quot;<br>idade = 27<br><br># concatenação &quot;convencional&quot;:<br>string_nova = &quot;Nome: &quot; + nome + &quot;\nIdade: &quot; + idade<br><br># concatenação usando &quot;.format()&quot;<br>&quot;Nome: {}\nIdade: {}&quot;.format(nome,idade)<br><br># concatenação utilizando o &quot;%&quot;<br>&quot;Nome: %s, Idade: %d&quot; % (nome, idade)</pre><p>O Python permite o uso de mais de uma forma para concatenação, só que se utilizarmos muitas variáveis ou precisarmos fazer formatações nos valores, o código acaba ficando poluído e desorganizado. Para resolver esse problema, foram criadas as f-strings.</p><h4>F-strings: Uma explicação rápida</h4><p>Introduzida a partir do Python 3.6 — ou seja, lá pra 2016 — , as f-strings são uma forma dinâmica de manipularmos e exibirmos strings no Python. Quem já mexeu um pouco em outras linguagens, percebeu que tanto com o operador $ antes da string (C# ou JS) ou com o \ e parêntesis (no Swift) é possível realizar essa manipulação de strings de forma eficiente e direta.</p><p>A sintaxe básica é a seguinte:</p><pre>f_string = f&quot;Isso aqui é uma string formatada pela f-string!&quot;</pre><p>No caso do Python, utilizamos o f antes das aspas que abrem a string e utilizamos {} para inserir uma variável ou informação dentro delas, para que a informação fique armazenada e/ou seja formatada adequadamente ali dentro. Bem simples e bem prático. Ela pode ser usada também na hora de realizar algum print na tela, o que torna o código bem mais sucinto:</p><pre>idade = 27<br>nome = &quot;Evandro&quot;<br>altura = 1.75<br><br># concatenação usando f-strings<br>print(f&quot;Meu nome é {nome}, tenho {idade} anos e {altura} de altura.&quot;)<br><br># concatenação utilizando format, por exemplo<br>print(&quot;Meu nome é {}, tenho {} anos e {} de altura&quot;.format(nome, idade, altura))</pre><h4>Aplicações das f-strings</h4><p>Como eu disse antes, as f-strings são um recurso poderoso. <strong>VIOLENTAMENTE PODEROSO.</strong> Elas tem todo tipo de aplicação possível, desde as mais simples até as mais complexas. Vamos a algumas delas:</p><h4>1. Expressões dentro dos colchetes</h4><p>Você pode realizar operações diretamente de dentro dos colchetes</p><pre>nome = &quot;Evandro&quot;<br>idade = 26<br><br>print(f&quot;{nome} faz {idade + 1} no ano que vem.&quot;)<br><br>#Output: Evandro faz 27 anos no ano que vem.</pre><h4>2. Chamar funções</h4><p>Chame funções diretamente dos colchetes da f-string para uma formatação mais dinâmica das strings.</p><pre>def cumprimentar(nome):<br>    return f&quot;Olá, {nome}!&quot;<br><br>print(f&quot;{cumprimentar(&#39;Evandro&#39;)}&quot;)</pre><h4>3. Especificadores de formato</h4><p>Use especificadores de formato para alterar o formato da saída, como por exemplo a quantidade de decimais após o ponto flutuante</p><pre>preço = 49.99<br>print(f&quot;O preço é de R$ {preço:.2f}&quot;)</pre><h4>4. Valores em dicionários</h4><p>Acesse diretamente valores em dicionários através das f-strings, com a mesma sintaxe usual.</p><pre>pessoa = {&#39;nome&#39;: &#39;Evandro&#39;, &#39;idade&#39;: 26}<br>print(f&quot;{pessoa[&#39;nome&#39;]} terá {pessoa[&#39;idade&#39;] + 1} anos em 2025.&quot;)</pre><h4>5. Formatação de datas</h4><p>Em conjunto com a biblioteca datetime, formate datas diretamente nas f-strings.</p><pre>from datetime import datetime<br><br>agora = datetime.now()<br>print(f&quot;Pelo horário de Brasília, são {agora:%Y-%m-%d %H:%M}.&quot;)</pre><h4>6. F-strings multilinhas</h4><p>Crie uma string com várias linhas sem perder a funcionalidade das f-strings</p><pre>nome = &quot;Evandro&quot;<br>profissao = &quot;desenvolvedor&quot;<br><br>bio = (f&quot;Name: {nome}\n&quot;<br>       f&quot;Profession: {profissao}&quot;)<br><br>print(bio)</pre><h4>7. Uso de expressões condicionais</h4><p>F-strings permitem o uso de expressões condicionais dentro dos seus colchetes</p><pre>idade = 18<br>status = &quot;adulto&quot; if idade &gt;= 18 else &quot;menor&quot;<br><br>print(f&quot;Você é {status}.&quot;)</pre><h4>8. Aninhando F-strings</h4><p>Aninhe f-strings para cenários onde a formatação pode acabar ficando complexa</p><pre>from math import pi<br>precisao = 2<br><br>print(f&quot;Pi arredondado para {precisao} casas decimais: {pi:.{precision}f}.&quot;)</pre><h4>9. Exibindo colchetes dentro da f-string</h4><p>Para inserir colchetes dentro da f-string, literalmente, duplique elas na hora de escreve-las.</p><pre>print(f&quot;{{Olá}}&quot;)<br><br># Output: &quot;{Olá}&quot;</pre><h4>10. Depuração com F-strings (Python 3.8 pra frente)</h4><p>Inclua o nome da variável juntamente com seu valor para facilitar a depuração</p><pre>nome = &quot;Evandro&quot;<br>print(f&quot;{nome=}&quot;)<br><br># Output: nome=&#39;Evandro&#39;</pre><h4>11. Alinhamento e preenchimento</h4><p>Você pode alinhar texto e adicionar preenchimento diretamente em uma f-string.</p><pre>nome = &quot;Alice&quot;<br># Alinhamento a direita com preenchimento<br>print(f&quot;{nome:&gt;10}&quot;)<br># Alinhamento a esquerda com preenchimento<br>print(f&quot;{nome:&lt;10}&quot;)<br># Alinhamento central com preenchimento<br>print(f&quot;{nome:^10}&quot;)</pre><h4>12. Separador de milhar</h4><p>Formate números grandes com vírgulas como separador de milhar para melhor legibilidade.</p><pre>numero = 1000000<br>print(f&quot;{numero:,}&quot;)</pre><h4>13. Especificadores dinâmicos de formato</h4><p>Especifique as opções de formatação dentro das f-strings utilizando variáveis</p><pre>largura = int(input()) # input: 10<br>precisao = int(input()) # input: 5<br>numero = 12.34567<br>print(f&quot;Resultado: {numero:{largura}.{precisao}}&quot;)</pre><h4>14. Usos em POO (Programação Orientada a Objetos)</h4><p>Acesse diretamente atributos e métodos de objetos</p><pre>class Pessoa:<br>    def __init__(self, nome, idade):<br>        self.nome = nome<br>        self.idade = idade<br>    def cumprimentar(self):<br>        return f&quot;Olá, meu nome é {self.nome}!&quot;<br><br><br>pessoa = Pessoa(&quot;Alice&quot;, 30)<br>print(f&quot;{pessoa.cumprimentar()} Tenho {pessoa.idade} anos de idade.&quot;)</pre><h4>15. Formatação em binário, octal e hexadecimal</h4><p>Faça a conversão de decimais para binário, octal e hexadecimal.</p><pre>number = 255<br>print(f&quot;Binary: {number:b}, Hex: {number:x}, Octal: {number:o}&quot;)</pre><h4>16. Funções Lambda</h4><p>F-strings permitem o uso de funções Lambda.</p><pre>print(f&quot;Quadrado de 5: {(lambda x: x*x)(5)}&quot;)</pre><h4>17. Formatação de números complexos</h4><p>Formate números complexos acessando tanto as suas partes reais quanto imaginárias.</p><pre>complexo = 3 + 4j<br>print(f&quot;Parte real: {complexo.real}\n&quot;<br>      f&quot;Parte imaginária: {complexo.imag}&quot;)</pre><h4>18. Formatando porcentagens</h4><p>Formate facilmente porcentagens com o operador “%”</p><pre>progresso = 0.756<br>print(f&quot;Andamento: {progresso:.2%} completa.&quot;)</pre><h4>19. Interpolação segura de strings com o str.format()</h4><p>Não sendo um recurso direto das f-strings e sendo um tanto quanto redundante faze-lo, combinar os dois recursos garante mais segurança contra injeção de código.</p><pre>user_input = &quot;{nome} tem {idade} anos de idade.&quot;<br><br># interpolação segura<br>print(f&quot;{user_input}&quot;.format(nome=&quot;Evandro&quot;, idade=30))</pre><h4>20. Reusing Calculated Values in F-strings</h4><p>Utilizando uma função lambda, valores podem ser calculados e reutilizados dentro da mesma f-string.</p><pre>resultado = (lambda x: (x, x**2))(3)<br><br>print(f&quot;Número: {resultado[0]}\n&quot; <br>      f&quot;Número elevado ao quadrado: {resultado[1]}&quot;)</pre><h4>21. Formatando caminhos e arquivos</h4><p>F-strings podem ser bem úteis para gerar caminhos de arquivos ou URLs de forma dinâmica e simples.</p><pre>nome_do_arquivo = &quot;relatório&quot;<br>data = &quot;28-02-2024&quot;<br>print(f&quot;./data/{filename}_{date}.txt&quot;)</pre><h4>22. Incorporando expressões para instanciação de objetos</h4><p>Instancie objetos diretamente dentro de uma f-string.</p><pre>class Coordenada:<br>    def __init__(self, x, y):<br>        self.x = x<br>        self.y = y<br>    def __str__(self):<br>        return f&quot;Coordenada ({self.x}, {self.y})&quot;<br><br><br>print(f&quot;Nova coordenada: {Point(1, 2)}&quot;)</pre><h4>23. Formatando exceções</h4><p>Use f-strings para facilitar e deixar mais claras as suas mensagens de erro.</p><pre>try:<br>    # Potentially problematic code<br>    x = 1 / 0<br>except Exception as e:<br>    print(f&quot;An error occurred: {e}&quot;)</pre><h4>24. Preenchimento dinâmico</h4><p>Controle o preechimento e alinhamento de strings dinamicamente utilizando variáveis com valores atribuídos.</p><pre>name = &quot;Alice&quot;<br>pad = 20<br>print(f&quot;{name:&gt;{pad}}&quot;)</pre><h4>25. Usando F-strings com “.map()” e “.filter()”</h4><p>F-strings podem ser usadas dentro dos métodos map() e/ou filter(), o deixando mais legível em muitos casos.</p><pre>names = [&quot;Alice&quot;, &quot;Bob&quot;, &quot;Charlie&quot;]<br>upper_names = map(lambda x: f&quot;{x.upper()}&quot;, names)<br>print(list(upper_names))</pre><h4>26. Formatação Personalizada de Objetos</h4><p>Defina como seus objetos personalizados devem ser formatados dentro de f-strings implementando o método “.format()”.</p><pre>class Pessoa:<br>    def __init__(self, nome):<br>        self.nome = nome<br>    def __format__(self, format_spec):<br>        if format_spec == &#39;upper&#39;:<br>            return self.nome.upper()<br>        return self.name<br><br><br>pessoa = Pessoa(&quot;Alice&quot;)<br>print(f&quot;{pessoa:upper}&quot;)</pre><h4>27. Comentários Inline</h4><p>Embora não seja uma feature das F-strings em si, você pode usar comentários para esclarecer expressões complexas dentro delas. O ideal mesmo é manter os comentários <strong>fora</strong> das strings; isso é mais para mostrar aplicabilidade.</p><pre># Foco é em clareza, não para execução direta nas f-strings<br>numero = 123456.789<br><br># Formatando com ponto e duas casas decimais após o ponto<br>formatado = f&quot;{numero:,.2f}&quot;  # Comentário: Formatado como string com vírgulas<br>print(formatado)</pre><h4><strong>28. Combinando f-strings com eval() para avaliação dinâmica de expressão</strong></h4><p>F-strings can be dynamically generated and then evaluated. F-strings podem ser geradas e avaliadas dinamicamente.</p><pre>expression = &quot;2 * 3&quot;<br>result = eval(f&quot;{expression}&quot;)<br>print(f&quot;{expression} = {result}&quot;)</pre><blockquote>⚠️<strong>ATENÇÃO </strong>⚠️:</blockquote><blockquote>Usar eval() pode ser perigoso se você estiver avaliando entradas geradas pelo usuário por conta do risco de injeção de código. Tenha em mente boas práticas ao utilizar f-strings com eval().</blockquote><h4>29. Representação avançada de objetos (POO)</h4><p>Utilize __repr__ em classes personalizadas para uma representação mais detalhada do objeto em f-strings</p><pre>class Produto:<br>    def __init__(self, nome, preco):<br>        self.nome = nome<br>        self.preco = preco<br>    def __repr__(self):<br>        return f&quot;&lt;Produto={self.nome} preco={self.preco:.2f}&gt;&quot;<br><br>produto = Produto(&quot;Café&quot;, 3.99)<br>print(f&quot;Detalhes: {produto}&quot;)</pre><h4>30. Geração de formatos dinâmicos de strings</h4><p>Construa formatos complexos de string dinamicamente, útil para criar templates.</p><pre>from datetime import datetime<br><br>formato = &quot;%d-%m-%Y&quot;<br>hoje = datetime.now()<br><br>print(f&quot;Data formatada: {hoje:{formato}}&quot;)</pre><h4>31. Formatação condicional DIRETA em f-strings</h4><p>Aplique diferentes saídas baseadas em condicionais<strong> diretamente</strong> aplicadas nas f-strings.</p><pre>pontos = 85<br>print(f&#39;Sua pontuação é {pontos} ({&#39;Aprovado&#39; if pontos &gt;= 75 else &#39;Reprovado&#39;})&#39;)</pre><h4>32. Combinando strings simples com f-strings</h4><p>Para lidar com caminhos de arquivos ou expressões regulares (o famoso regex), podemos combinar os recursos acima para evitar barras invertidas.</p><pre>arquivo = &quot;data&quot;<br>print(fr&quot;C:\Users\{arquivo}\Documents&quot;)</pre><h4>33. Formatação de floats em notação científica</h4><p>As f-strings permitem que você possa trabalhar com floats em notação científica, tornando mais fácil o trabalho com números muito grandes.</p><pre>numero = 123456789.0<br>print(f&quot;{numero:.2e}&quot;)  # O &#39;e&#39; serve para denotar notação científica</pre><h4>34. Conditional Formatting with Lambdas</h4><p>Você pode utilizar lambdas para formatações condicionais dentro das f-strings, para deixar o código mais conciso.</p><pre>status = True<br>print(f&quot;Status: {&#39;Active&#39; if (lambda x: x)(status) else &#39;Inactive&#39;}&quot;)</pre><h4>35. Realizar encoding de variáveis</h4><p>As vezes precisamos trabalhar com codificações diversas em textos, e as f-strings podem ser usadas in-loco para simplificar as coisas, através do método “<em>.encode(</em>)”</p><pre>nome = &quot;José&quot;<br>print(f&quot;Nome: {nome.encode(&#39;utf-8&#39;)}&quot;)</pre><h3>Novas features das f-strings (versão 3.12)</h3><p>A <a href="https://peps.python.org/pep-0701/">PEP 701</a>, de Novembro/2022, trouxe melhorias no que dizem respeito a sintaxe das f-strings, especialmente ao uso de contrabarra, aninhamento de f-strings e o uso de substrings. Essas melhorias foram implementadas na mais nova versão do Python, lançada em Outubro/2023.</p><p>Vamos a elas:</p><h4>1. Aspas podem ser reutilizadas dentro das f-strings</h4><p>Agora podemos reaproveitar as aspas de expressões embutidas dentro das f-strings para formatações onde o uso das aspas é considerado essencial.</p><pre>employee = {<br>    &quot;name&quot;: &quot;John Doe&quot;,<br>    &quot;age&quot;: 35,<br>    &quot;job&quot;: &quot;Python Developer&quot;,<br>}<br><br># Utilizando aspas duplas para definir a f-string<br># e delimitar a chave do dicionário<br><br>result = f&quot;Employee: {employee[&#39;name&#39;]}&quot;<br>print(result)<br><br># Output: &#39;Employee: John Doe&quot;</pre><h4>2. Contrabarras agora são permitidas dentro das f-strings</h4><p>Antes, não tínhamos como usar contrabarras dentro do recurso — o que era ruim, caso precisássemos utilizar alguma “\n”, por exemplo. Agora, podemos usar livremente.</p><pre>words = [&quot;Hello&quot;, &quot;World!&quot;, &quot;I&quot;, &quot;am&quot;, &quot;a&quot;, &quot;Pythonista!&quot;]<br><br>print(f&quot;{&#39;\n&#39;.join(words)}&quot;)<br># Output: &#39;Hello\nWorld!\nI\nam\na\nPythonista!&#39;<br><br>print(f&quot;{&#39;\n&#39;.join(words)}&quot;)<br><br>&quot;&quot;&quot;Output: Hello<br>World!<br>I<br>am<br>a<br>Pythonista!&quot;&quot;&quot;</pre><h4>3. Comentários agora são permitidos dentro das f-strings</h4><p>A nova implementação de Python permite, agora, que as f-strings recebam comentários e a extensão das mesmas podem ser definidas indefinidamente.</p><pre>employee = {<br>    &quot;name&quot;: &quot;John Doe&quot;,<br>    &quot;age&quot;: 35,<br>    &quot;job&quot;: &quot;Python Developer&quot;,<br>}<br><br># Expressão f-string com múltiplas linhas e comentário em linha<br>result = f&quot;&quot;&quot;Storing employee&#39;s data: {<br>    employee[&#39;name&#39;].upper()<br>}&quot;&quot;&quot;<br><br>print(result)<br><br># Output: &quot;Storing employee&#39;s data: JOHN DOE&quot;</pre><h4>4. Aninhamento profundo de f-strings</h4><p>É o tipo de recurso que DEVE ser utilizado com parcimônia, para evitar que haja confusão nas suas linhas de código. Porém, agora é permitido este tipo de aninhamento nos códigos da versão 3.12 em diante.</p><pre>Arbitrary Levels of F-String Nesting Possible<br>As a result of allowing quote reuse, the new f-string implementation allows arbitrary levels of nesting. The usefulness of this feature is limited because many levels of nesting may make your code hard to read and understand. However, you can get it done:<br><br>&gt;&gt;&gt; f&quot;{<br>...     f&quot;{<br>...         f&quot;{<br>...             f&quot;{<br>...                 f&quot;{<br>...                     f&quot;Deeply nested f-string!&quot;<br>...                 }&quot;<br>...             }&quot;<br>...         }&quot;<br>...     }&quot;<br>... }&quot;<br>&#39;Deeply nested f-string!&#39;</pre><h4>5. Melhores mensagens de erro</h4><p>Entender o erro é o primeiro passo para tratá-lo. As mensagens de erro das versões anteriores eram muitas vezes ambíguas e não apontavam claramente o que poderia ser feito. Agora…</p><pre># Até o Python 3.11...<br> f&quot;{42 + }&quot;<br><br>&quot;&quot;&quot;File &quot;&lt;stdin&gt;&quot;, line 1<br> (42 + )<br>          ^<br>SyntaxError: f-string: invalid syntax&quot;&quot;&quot;<br><br># ...do Python 3.12 em diante<br>f&quot;{42 + }&quot;<br><br><br>&quot;&quot;&quot;File &quot;&lt;stdin&gt;&quot;, line 1<br>    f&quot;{42 + }&quot;<br>          ^<br>SyntaxError: f-string: expecting &#39;=&#39;, or &#39;!&#39;, or &#39;:&#39;, or &#39;}&#39;&quot;&quot;&quot;</pre><h4>Conclusão</h4><p>Um dos melhores recursos da linguagem Python e um dos melhores recursos de linguagens de programação em geral, as f-strings são versáteis e permitem todo tipo de uso nos nossos códigos. Por que utilizar <em>.format()</em> se podemos utilizar as f-strings e melhorar a sintaxe e a clareza do que está escrito?</p><p>Claramente há muitos mais usos para elas, optei por fazer um apanhado envolvendo a motivação para uso, algumas das aplicações e do estado-da-arte envolvendo as f-strings. O artigo original, no qual me inspirei, pode ser encontrado bem no subtítulo do meu próprio artigo.</p><p>Gostou do artigo? Deixe um comentário, dê aplausos, me siga aqui no Medium<a href="https://www.linkedin.com/in/evandrovieiramafort/"> e no LinkedIn</a>. Foi um trabalho considerável este artigo, então nada mais deixaria o escritor que vos fala feliz do que isso. Estou voltando a escrever aos poucos, ao longo do ano teremos mais artigos.</p><p><strong>‘Is we’, pessoal!</strong></p><h4>Bibliografia</h4><ul><li><a href="https://python.plainenglish.io/mastering-100-python-f-strings-from-basic-to-advanced-novel-tricks-and-cheat-sheets-43a582104f21"><em>Mastering 100 Python F-Strings from Basic to Advanced, Novel Tricks and Cheat Sheets, do Ravi M</em></a></li><li><a href="https://realpython.com/python312-f-strings/">Python 3.12 Preview: More Intuitive and Consistent F-Strings</a></li><li><a href="https://www.python.org/downloads/release/python-3120/">Python 3.12 release</a></li><li><a href="https://peps.python.org/pep-0701/">PEP 701</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=084bf497c381" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Dores de cabeça para fazer casting de colunas no Pandas? Não mais.]]></title>
            <link>https://medium.com/data-hackers/dores-de-cabe%C3%A7a-para-fazer-casting-de-colunas-no-pandas-n%C3%A3o-mais-407ba22db4cf?source=rss-636c618f3f6d------2</link>
            <guid isPermaLink="false">https://medium.com/p/407ba22db4cf</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[pandas]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Evandro Vieira]]></dc:creator>
            <pubDate>Mon, 27 Nov 2023 19:16:20 GMT</pubDate>
            <atom:updated>2024-03-19T22:27:19.369Z</atom:updated>
            <content:encoded><![CDATA[<h4>Um artigo expondo brevemente o problema da auto-alocação de tipos no Pandas e a solução para isso, em forma de biblioteca.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oIKSPKgh0Vysq1hHP-cmbg.jpeg" /><figcaption>Não seja um ‘bebel’ das ideias, faça sua dieta de dados!</figcaption></figure><p>Um dos desafios frequentes na vida dos surfistas de planilhas — sejam amadores, profissionais ou aspirantes — é o gerenciamento do consumo de memória durante as operações que abrangem todo o ciclo do ETL (Extração, Transformação e Carregamento). Dataframes seguem uma regra proporcional, assim como tudo na vida: quanto maiores eles são, mais memória demandam da máquina. É lógico que existem diversas boas práticas voltadas para dados que, claro, mitigam a frustração de ver um dataframe sendo processado pela IDE durante meia hora sem que possamos fazer algo a respeito. O Pandas mesmo, que é a biblioteca de manipulação de dados mais usada atualmente, possui seu conjunto de boas práticas.</p><blockquote><a href="https://medium.com/@agusmahari/pandas-best-practices-for-writing-clean-code-in-pandas-5b378ba757af">Aqui mesmo você pode ler um artigo, em inglês, sobre algumas delas! Espero que a sua prática no idioma esteja em dia 😬</a></blockquote><p>Uma dessas práticas envolve a alocação eficiente de memória, considerando os tipos de dados presentes em cada coluna. No contexto do Python, assim como em todas as linguagens de programação, há uma variedade de tipos de dados, e isso não é diferente nas bibliotecas que utilizamos para executar tarefas em Python. O Pandas, por exemplo, possui tipos numéricos e não-numéricos, os quais são úteis para distinguir informações categóricas de numéricas — tipos esses que possuem atribuição padrão.</p><h4>E o que seria essa ‘atribuição padrão’? Notas sobre alocação de memória, bits e Ibuprofeno.</h4><p>Quando criamos um DataFrame Pandas, ele automaticamente infere os tipos de dados presentes. Simples assim. Para números inteiros, ele atribui o tipo ‘int64’. Para números de ponto flutuante, automaticamente temos ‘float64’ atribuído. Para outros tipos, temos a atribuição do tipo ‘object’, que nada mais é do que uma designação de um tipo genérico, já que o interpretador não conseguiu realizar uma atribuição automática adequada.</p><p>Até aí tudo bem. O Pandas fez a atribuição dos tipos e podemos todos trabalhar nos nossos dados sem problema algum. Errr.. <em>not quite. </em>As coisas não são tão simples assim.</p><p>Caso não tenha passado por algum curso superior de computação, vou explicar onde está o problema. Caso tenha passado, vamos revisar juntos: O ‘64’ no final do int e float significa que foram alocados 64 bits para todos os dados da coluna, linha por linha; Se não sabe o que é um bit, não tem problema:</p><p>O bit (<strong>B</strong>inary un<strong>IT)</strong>, a grosso modo,<strong> é a unidade mais básica de informação que temos disponível na computação atualmente. </strong>Literalmente, só 0 e 1. Ou seja, 1 Bit = 2 valores.</p><p>2 bits = 4 valores (já que 2²<em>= 4</em>).</p><p>3 bits = 2³ valores, e assim por diante, sempre em potências de 2.</p><p>E 64 bits? 2⁶⁴ <strong>valores.</strong> <strong>18.446.744.073.709.551.616 valores únicos, pra ser exato</strong>. E isso é alocado para cada linha de cada coluna que tenha o tipo ‘<em>int64</em>’ atribuído. Para as linhas que possuem atribuição <em>float64, temos algo em torno de 2⁵³ </em><strong>valores únicos — </strong>há uma explicação, mas o importante é que você saiba o tamanho da alocação.</p><p>Isso gera um problemão com relação ao consumo de memória. Se você tem um dataframe com muitas colunas (dezenas delas) tendo um tipo de dado que abrigue essa quantidade colossal de números como a citada acima, o interpretador precisa alocar um espaço titânico para cada um desses números em memória. <strong>E não é só para uma linha, é para todas elas. Para todas as colunas com aquele tipo</strong>. Se pensarmos na quantidade absurda de memória desperdiçada por má alocação, com certeza você iria precisar de um Ibuprofeno depois.</p><p>Fora que não mencionei o problema do uso indiscriminado do tipo ‘object’. Para começar, ele não possui um número fixo de bits sendo alocados para cada coluna — trabalha de forma dinâmica, utilizando algo chamado <em>ponteiro</em> para realizar essa alocação de memória. 🌈<strong>MARAVILHOSO, NÃO?</strong>🥳 …<em>Pero no mucho</em>. Isso só é ótimo quando o dado é uniforme (não possui ou quase não possui caracteres misturados). A porrada vem quando o <em>‘object’ </em>recebe todo tipo de informação, como letras maiúsculas com minúsculas, traços, caracteres especiais, etc. Dependendo do caso, uma leitura de caractere por caractere precisa ser feita. A versatilidade da alocação dinâmica vem ao custo do desempenho de memória.</p><blockquote><a href="https://medium.com/permalink-univesp/uma-introdu%C3%A7%C3%A3o-ao-uso-de-ponteiros-na-linguagem-c-636d43659493">Sentiu vontade em saber o que é um ponteiro e o seu funcionamento? Artigo na mão, camarada. E em PT-BR ainda!</a></blockquote><p>Há jeitos de resolver isso? Sim! O mais óbvio seria converter cada coluna para o tipo mais adequado de dado, na esperança de reduzir a carga de memória utilizada pela RAM da máquina. Porém quase sempre todas as colunas são diferentes entre si, possuem tamanhos diferentes ou são muitas colunas (CENTENAS OU MILHARES) para poder tratar caso a caso.</p><p>Sentiu vontade do Ibuprofeno de novo, né? Guarda ele então.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/1*PwfYOK4n_NtqVPUppzjxlw.jpeg" /><figcaption><strong>DOR DE CABEÇA PRA CONVERTER TIPOs DE COLUNAS? SEUS PROBLEMAS ACABARAM!</strong></figcaption></figure><h4>Uma dieta de dados, literalmente</h4><p>Felizmente, há quem pensou e elaborou uma biblioteca para resolver os nossos problemas: <a href="https://www.linkedin.com/in/ianozsvald/">Ian Ozsvald</a>, escritor para a O’Reilly, consultor de ciência de dados e co-criador do<a href="https://pydata.org/london2023/about"> PyData London</a> (uma ONG voltada para ciência de dados e análise de dados) mas que, atualmente, está sob a supervisão do <a href="https://www.linkedin.com/in/noklamchan/">Nok Lam Chan</a>, engenheiro de software de Hong Kong atualmente residindo em Londres, Inglaterra.</p><p>Não há muitas informações explícitas com relação a quando foi criada — as informações de forks e pushs no <a href="https://github.com/noklam/dtype_diet">GitHub</a> datam de uns 3 anos atrás, tendo a última informação uns dois meses, onde podemos ver que a biblioteca está na versão 0.0.2 (ou seja, é uma biblioteca relativamente nova). Mas veremos o porquê dessa biblioteca ser tão boa.</p><p>Ah, o nome dela? <a href="https://noklam.github.io/dtype_diet/"><strong>Dtype_diet. Prazer!</strong></a></p><h4>Getting started!</h4><p>Antes de tudo, é bom informar: <strong>Essa biblioteca só roda do Python 3.7 em diante</strong>. Utiliza versão mais antiga? <strong>Atualize</strong>. Não há suporte para versões mais antigas do nosso Pitão de cada dia. Dito isso, vamos a instalação dela:</p><pre>pip install dtype_diet</pre><p>Instalou? Perfeito!</p><p>Vou usar um exemplo bem básico de dataframe para poder mostrar o que essa biblioteca faz.<strong> Comecemos importando as bibliotecas necessárias (Pandas, Dtype_Diet e Matplotlib) e o dataset em questão</strong> — Eu adotarei uma convenção com a biblioteca, a chamando de <em>‘dtd’</em></p><pre>import pandas as pd<br>import dtype_diet as dtd</pre><pre>df = pd.read_excel(&#39;dataset_eleicoes.xlsx&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*J0-MLZwti06Xl5RM2IO3cw.png" /><figcaption>O DATAFRAME EM QUESTÃO: 80.000 linhas, 10 colunas e quase 20 segundos pra ler tudo.</figcaption></figure><p>Dataframe importado, vamos começar vendo os tipos de dados que as nossas colunas tem:</p><pre>df.info()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/425/1*T_omGEEJw7LJmIVTNyiy3A.png" /></figure><ul><li>São <strong>80 mil linhas</strong> servindo <strong>10 colunas</strong>.</li><li>De 10 colunas, temos 7 sendo <em>‘int64’</em> e 3 sendo <em>‘object’, </em>havendo <strong>apenas dois tipos no dataset todo</strong>.</li><li>Não há dados nulos nas colunas, o que indica <strong>uso máximo de memória pelo dataframe.</strong></li><li><strong>+6 MB de consumo de memória, que podem escalar</strong> a medida que vamos manuseando o notebook e mais dados são gerados.</li></ul><p>A partir dessa informação, vou começar os trabalhos com a nossa biblioteca. Começamos chamando uma variável chamada<em> proposta, </em>que servirá para receber o método <em>‘report_on_dataframe’</em>. Ele possui a seguinte assinatura:</p><pre>proposta = dtd.report_on_dataframe(df:DataFrame, unit:str=&#39;MB&#39;, optimize:str=&#39;memory&#39;)</pre><p>A assinatura do método contém 3 argumentos, um sendo obrigatório e os outros dois opcionais:</p><ul><li><strong>df</strong>, obrigatório, que recebe um objeto <em>DataFrame;</em></li><li><strong>unit</strong><em> — </em>sendo tipo ‘<em>str’ — </em>que serve <strong>para escolher quais unidades serão usadas para expressar as informações de desempenho obtidas</strong>. O default dela é ‘MB’, mas pode ser trocada para ‘GB’;</li><li><strong>optimize</strong><em> — </em>também <em>‘str’ — </em>que serve <strong>para apontar o que deverá ser priorizado no relatório para otimização do dataframe</strong>. O padrão é <em>‘memory’.</em></li></ul><p>Passada a explicação, seguimos. Vou apenas passar o argumento obrigatório, já que o default está definido nos outros dois e isso não é importante no momento:</p><pre>proposta = dtd.report_on_dataframe(df)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MVt0QQTszL24xXa59wR11A.png" /><figcaption>dataframe obtido através do método acima</figcaption></figure><p><strong>Algumas coisas que podemos observar de cara:</strong></p><ul><li>Dos dois tipos originais, subimos para <strong>4 tipos propostos que podem ser usados </strong>(vou falar mais a frente sobre um deles , o <em>‘categories’</em>).</li><li>A queda no consumo de memória é uma coisa assustadora. Nos casos que temos a transição de <em>‘object’</em> para <em>‘categories’</em>, <strong>temos uma redução de 98% do uso de memória. 98%, você não leu errado.</strong></li><li><strong>TODAS</strong> as colunas sofrem uma redução drástica de alocação de bits, sendo que em algumas colunas vamos de 64 bits para 8 — uma senhora estratégia de salvamento de memória.</li></ul><p>Tendo o relatório em mãos, podemos seguir para a próxima etapa.</p><p><em>Mas espera, eu vou ter que fazer alguma gambiarra envolvendo dicionários, listas, tuplas, métodos de conversão como o ‘astype’ ou coisas assim? </em>Até poderia, mas só se você não fosse muito esperto — e se os desenvolvedores do dtype_diet também não fossem. Pra isso, temos o método <em>‘otimize_dtypes’. </em>A assinatura do método:</p><pre>df_otimizado = optimize_dtypes(df, proposta)</pre><p>Ela é mais simples e contém 2 argumentos, <strong>ambos obrigatórios:</strong></p><ul><li><strong>df</strong>, que recebe o dataframe original</li><li><strong>proposed_df</strong>, que recebe como argumento o método <em>‘report_on_dataframe’</em></li></ul><p>A sintaxe de tudo é bem simples, duas linhas de código e a mágica tá feita:</p><pre>proposta = dtd.report_on_dataframe(df)<br>df_otimizado = dtd.optimize_dtypes(df, proposta)</pre><p>Agora, vamos ver o dataframe otimizado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/521/1*prUXQY2Bh4facfqNYADIIQ.png" /></figure><p><strong>E agora?</strong></p><ul><li>Os tipos das colunas estão<strong> mais diversificados.</strong></li><li>O uso de memória caiu pra pelo menos <strong>1/6 do que era consumido antes.</strong></li><li><strong>Não houveram bugs</strong> envolvendo overflow de dados (vou falar disso mais a frente)</li></ul><p><strong>Testes práticos</strong></p><p>Após as mudanças serem feitas, vamos fazer alguns testes envolvendo a velocidade de leitura dos dados. Elaborei um código que executa os trechos em um looping <em>for</em>, umas mil vezes, e por fim obtém o tempo médio das execuções de cada código — poderia ser construída uma função, mas para fins de simplicidade manterei o código como está. Posteriormente, gráficos serão gerados para explicar as diferenças de tempo de execução de cada dataframe em alguns cenários.</p><p>Importante notar que não estou preocupado com boas práticas visando desempenho irrestrito;<strong> estou focando em jogar o pior que eu puder nos dois códigos, dividido em três casos, para entender como eles irão se sair levando em consideração APENAS a otimização de memória</strong>.</p><pre># Este é o looping for utilizado para realizar o benchmark dos códigos<br> <br> num_execucoes = 1000<br> tempos_celula1 = []<br> tempos_celula2 = []<br> <br> for _ in range(num_execucoes):<br> comeco_1 = time.time()<br> # o código otimizado vai aqui<br> final_1 = time.time()<br> execucao_1 = final_1 - comeco_1<br> tempos_celula1.append(execucao_1)<br> <br> comeco_2 = time.time()<br> # o código não otimizado vai aqui<br> final_2 = time.time()<br> execucao_2 = final_2 - comeco_2<br> tempos_celula2.append(execucao_2)<br> <br> <br> # Aqui é onde passo a gerar o gráfico de linha<br> <br> labels = [&#39;df com otimização&#39;, &#39;df sem otimização&#39;]<br> tempos_dataframes = [tempos_celula1, tempos_celula2]<br> <br> plt.figure(figsize=(10, 5))<br> for i, tempos_dataframe in enumerate(tempos_dataframes, start=1):<br> media_dataframe = [np.mean(tempos_dataframe[i:i+50]) for i in range(0, num_execucoes, 50)]<br> plt.plot(range(1, len(media_dataframe) + 1), media_dataframe, marker=&#39;o&#39;, label=labels[i-1])<br> <br> plt.xlabel(&#39;Intervalo de Execuções (50 execuções)&#39;)<br> plt.ylabel(&#39;Tempo de Execução Médio (em segundos)&#39;)<br> plt.title(f&#39;Flutuação nos Tempos de Execução ({num_execucoes} execuções)&#39;)<br> plt.legend()<br> plt.grid(True)<br> <br> plt.show()</pre><ul><li><strong>Caso 1: Realizando alguma query usando o método <em>‘query()’</em></strong></li></ul><pre># Query bem simples, usado de propósito sabendo-se que é um método lento<br> <br> df.query(&#39;ALINHAMENTO != &quot;IRRELEVANTE&quot; <br> and TURNO == 1 <br> and SITUACAO == 1&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EEKC94qQPNVaMIrNOiW_lw.png" /></figure><ul><li><strong>Caso 2: Realizando algumas operações de agrupamento e criação de novas colunas com base em colunas já existentes (ufa)</strong></li></ul><pre>cond = (df[&#39;ALINHAMENTO&#39;] != &#39;IRRELEVANTE&#39;) &amp; (df[&#39;TURNO&#39;] == 1)<br> <br>df_espectro = df[cond]<br>df_espectro = df_espectro.groupby(&#39;ALINHAMENTO&#39;)[&#39;VOTOS&#39;]<br>.sum()<br>.reset_index()<br>.sort_values(by=&#39;VOTOS&#39;, ascending=False)<br>df_espectro[&#39;%&#39;] = ((df_espectro[&#39;VOTOS&#39;] / df_espectro[&#39;VOTOS&#39;].sum()) * 100)<br>.round(1)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ixKjfb57qwmCcX_wzM8hcA.png" /></figure><ul><li><strong>Caso 3: Realizando operações de query com dois tipos de agrupamento — <em>groupby</em> convencional e tabela pivô, depois gerando mais colunas novas a partir de colunas existentes, assim como <em>dataframes</em> em outras variáveis e, por fim, removendo algumas colunas do conjunto de dados principal.</strong></li></ul><pre>cond = ((df[&#39;ALINHAMENTO&#39;] != &#39;IRRELEVANTE&#39;) &amp; (df[&#39;TURNO&#39;] == 1))<br> <br> df_bairro2 = df[cond]<br> df_bairro2 = df_bairro2.groupby([&#39;BAIRRO&#39;, &#39;ALINHAMENTO&#39;])[&#39;VOTOS&#39;] \<br> .sum() \<br> .reset_index()<br> df_bairro2[&#39;%_REL&#39;] = (df_bairro2[&#39;VOTOS&#39;] / df_bairro2.groupby(&#39;BAIRRO&#39;)[&#39;VOTOS&#39;].transform(&#39;sum&#39;) * 100).round(1)<br> <br> df_partidos = df_otimizado[cond]<br> <br> lista_partidos = df_partidos[[&#39;SIGLA&#39;, &#39;ALINHAMENTO&#39;]].drop_duplicates()<br> df_partidos_1 = df_partidos.groupby(&#39;SIGLA&#39;)[&#39;VOTOS&#39;] \<br> .sum() \<br> .reset_index() \<br> .sort_values(by=&#39;VOTOS&#39;, ascending=False)<br> df_partidos_1 = df_partidos_1.merge(lista_partidos[[&#39;SIGLA&#39;, &#39;ALINHAMENTO&#39;]], on=&#39;SIGLA&#39;, how=&#39;left&#39;)<br> <br> topo = df_partidos_1.head(15)<br> fundo = df_partidos_1.tail(15)<br> <br> df_partidos_2 = pd.pivot_table(df_partidos,<br> values=&#39;VOTOS&#39;,<br> index=&#39;BAIRRO&#39;,<br> columns=&#39;ALINHAMENTO&#39;,<br> aggfunc=&#39;sum&#39;,<br> fill_value=0).reset_index()<br> <br> df_auxiliar = df_bairro2.groupby(&#39;BAIRRO&#39;)[&#39;VOTOS&#39;].sum().to_frame().reset_index()<br> df_partidos_2 = df_partidos_2.merge(df_auxiliar, on=&#39;BAIRRO&#39;, how=&#39;left&#39;)<br> <br> df_partidos_2[&#39;%_CEN&#39;] = (df_partidos_2[&#39;CENTRO&#39;] / df_partidos_2[&#39;VOTOS&#39;] * 100).round(1)<br> df_partidos_2[&#39;%_DIR&#39;] = (df_partidos_2[&#39;DIREITA&#39;] / df_partidos_2[&#39;VOTOS&#39;] * 100).round(1)<br> df_partidos_2[&#39;%_ESQ&#39;] = (df_partidos_2[&#39;ESQUERDA&#39;] / df_partidos_2[&#39;VOTOS&#39;] * 100).round(1)<br> <br> colunas = [&#39;VOTOS&#39;,&#39;CENTRO&#39;, &#39;DIREITA&#39;, &#39;ESQUERDA&#39;]<br> df_partidos_2.drop(columns=colunas, inplace=True)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KOLodXdO1AM_6m41_WRAFA.png" /></figure><p><strong>O que os gráficos nos mostram?</strong></p><p>Podemos observar, através dos três casos e dos seus respectivos gráficos, que o algoritmo com os tipos otimizados se saiu muito melhor do que o algoritmo não-otimizado, surpreendendo no caso 2, onde o algoritmo otimizado obteve 1/3 do tempo de execução do algoritmo não otimizado. Mesmo nos picos em cada caso, o algoritmo otimizado manteve uma constância muito maior em resultados, devido ao uso mais coerente de memória.</p><p>É interessante notar que, em nenhum momento, houve uma preocupação em utilizar boas práticas para testar os algoritmos, fazendo com que encarassem situações caóticas de propósito, para que o máximo de memória fosse utilizado nessas situações. E, ainda sim, o algoritmo otimizado se saiu bem em todos os cenários.</p><p>Operações de agrupamento, por exemplo, se tornam bem menos custosas em termos de memória, o que nos leva a entender que essa biblioteca veio para agregar e muito no dia-a-dia do profissional ou entusiasta de dados. Porém, nada é perfeito.</p><p><strong>Sobre as ‘categories’</strong></p><p>Falei ali em cima que o <em>dtd </em>substitui o tipo <em>‘object’</em> por <em>‘category’</em>, mas não expliquei o que são as<em> ‘categories’</em>. Aqui vai:</p><p><em>Categories</em> é um tipo de dado usado para armazenar dados categóricos, que representam valores de categorias, e não números ou letras em si, etc. A diferença fundamental entre <em>‘object’</em> e<em> ‘category’</em> é a forma como os dados são armazenados.</p><p>Enquanto <em>‘object’</em> armazena cada elemento como um objeto individual, <em>‘category’</em> armazena os dados com base em índices categóricos. Acaba sendo uma mão na roda por conta de alguns fatores, como economia de memória, já que os valores são representados por índices inteiros, evitando repetição de alocação de memória, elevando a performance do algoritmo por conta das buscas otimizadas.</p><p>As categories se dão muito bem quando trabalhamos com um conjunto fixo e limitado de categorias, e é por isso também que ela possui algumas limitações, que iremos tratar adiante.</p><p><strong>Drawbacks da biblioteca</strong></p><p>Por não ser uma biblioteca em constante atualização e desenvolvimento, acabou que algumas coisas ainda estão pelo caminho. Traduzindo diretamente da página onde está a documentação dela, temos algumas coisas:</p><ul><li><strong>Há o risco de overflow quando usamos essa biblioteca em certos cenários</strong>. Como a otimização se dá através de casting ‘para baixo’, algumas operações podem ficar comprometidas (como, por exemplo, agrupamentos e somas). O overflow acontece quando realizamos uma operação e o resultado numérico dela excede a capacidade máxima de bits que ela suporta, gerando alguns problemas bem bizarros como output.</li><li><strong>No caso do <em>float</em>, a otimização sofre problemas envolvendo precisão dos cálculos e possível perda de informação</strong> quando o tipo é convertido para <em>‘float16’</em>. Como a arquitetura dos computadores atuais é feita para <em>‘float32’</em> ou<em> ‘float64’</em>, o <em>‘float16’</em> é algo um tanto quanto contraintuitivo — pesquisas e análises que demandem essa ‘sensibilidade’ extrema na flutuação dos dados seriam afetadas.</li><li><strong>Não há uma documentação extensa e o projeto se encontra parado por um bom tempo</strong>, contando apenas com atualizações esporádicas. Talvez o projeto não seja algo prioritário para os seus supervisores, o que dá oportunidades boas para quem quiser colaborar; <a href="https://noklam.github.io/dtype_diet/#Caveats">a documentação da biblioteca se encontra aqui, assim como o contato dos colaboradores da biblioteca.</a></li></ul><p><strong>Recomendações importantes</strong></p><p>Tendo em vista o que foi dito acima, darei algumas recomendações de uso para a biblioteca:</p><ul><li><strong>Entenda bem o objetivo da sua análise: </strong>Tendo isto em mente, você saberá quando e onde aplicar os métodos da biblioteca em questão, evitando conversões desnecessárias e dor de cabeça para voltar ao ponto onde tudo deu errado.</li><li><strong>Na dúvida, duplique: </strong>Ainda sim, se for usar e acabar se deparando com a necessidade de realizar operações no dataframe, opere com uma cópia. Isso reduz o risco de você fazer conversões indevidas que resultem em um overflow, por exemplo.</li><li><strong>Dê às Categories o que é das Categories: </strong>Não invente moda; elas são usadas apenas para reduzir memória em usos onde as variáveis categóricas do seu dataframe são fixas (não irão mudar do começo ao fim) e são limitadas (não há um número certo onde a coisa começa a bagunçar). O seguro morreu de velho, então não abuse!</li></ul><p>Com isso, finalizo por aqui. Essa biblioteca tem um potencial imenso de crescimento, e espero de verdade que mais pessoas possam passar a usar e até contribuir com o projeto.</p><p><strong>Achou que eu não falaria das minhas redes sociais? Achou errado! Gostou do meu artigo? Tem críticas, sugestões de melhoria ou tem algo a contribuir com o artigo? Me dá um toque, oras!</strong></p><p><a href="https://www.linkedin.com/in/evandrovieiramafort/">Meu LinkedIn</a> está aberto para mensagens 24 horas. Pretendo também inserir os códigos que utilizei no artigo no <a href="https://github.com/evandrovieiramafort">meu GitHub</a>, para que todos possam fazer os testes nas suas máquinas. De resto, foi um prazer escrever esse artigo e até mais!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=407ba22db4cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/data-hackers/dores-de-cabe%C3%A7a-para-fazer-casting-de-colunas-no-pandas-n%C3%A3o-mais-407ba22db4cf">Dores de cabeça para fazer casting de colunas no Pandas? Não mais.</a> was originally published in <a href="https://medium.com/data-hackers">Data Hackers</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CRISP-DM ou “Como funciona um projeto de Ciência de Dados?”]]></title>
            <link>https://medium.com/@evanVieira/crisp-dm-ou-como-funciona-um-projeto-de-ci%C3%AAncia-de-dados-7e7238c48d3d?source=rss-636c618f3f6d------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e7238c48d3d</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[dados]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[data-science]]></category>
            <dc:creator><![CDATA[Evandro Vieira]]></dc:creator>
            <pubDate>Wed, 13 Sep 2023 02:04:20 GMT</pubDate>
            <atom:updated>2023-10-11T19:01:58.739Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Su7x0jAHYkxqvT4CAG12aQ.png" /><figcaption><a href="https://jorgeaudy.com/2021/01/29/data-driven-mindset-o-modelo-de-mineracao-crisp-dm/">Créditos</a></figcaption></figure><p>A palavra “Ciência de Dados” nos últimos anos entrou em voga de uma forma que, agora, é uma das profissões mais desejadas por quem ingressa na área de tecnologia. Também é uma das funções que as empresas mais cobiçam em suas fileiras, já que o valor do que é produzido pode auxiliar grandemente tanto a curto quanto a longo prazo.</p><p>Dentro do escopo da área, temos várias palavras “chiques” usadas no dia-a-dia de aprendizes e profissionais:<em> XGBoost, Regressão Linear, Pandas, Scikit-Learn, Boxplot, Data Leakage</em>, e por aí vão. As vejo no Linkedin, em comunidades de DS (Data Science — outra palavra usada bastante) e em diversos lugares. Termos assim não faltam no vocabulário alheio, e nos dizem muito sobre o que a área tem a oferecer.</p><p>Mas havia um assunto que eu não via tanto em voga e que martelou mais na mente depois de uma matéria da faculdade, chamada “Governança de TI”: <strong>Como tocar um projeto, seja lá qual ele for?</strong> Afinal, por mais promissora que a área pareça, os salários sejam atraentes, o impacto seja imenso e a transformação seja profunda, precisamos começar por algum lugar e chegar a algum lugar — caso contrário, todo aspirante a cientista de dados irá correr atrás do próprio rabo e perder tempo quando se deparar com um dataset dos grandes que PEDE para ser investigado.</p><h4>Várias dúvidas, uma resposta — mas cadê a resposta?</h4><p>Depois de pesquisar um tanto pela internet e pesquisar algumas coisas ligadas a como estruturar um projeto de dados (seja ele qual for), topei com uma sigla simpática: O <em>CRISP-DM</em>.</p><p><em>E o que significa essa sigla, rapaz?</em> Então, meu jovem, esta sigla significa “<strong><em>Cross Industry Standard Process for Data Mining”</em> — </strong>traduzindo sai algo como<strong> <em>“Processo Padrão Inter-Indústrias para Mineração de Dados”,</em></strong> se tratando de uma sigla em inglês que descreve como um projeto de dados deve ser feito, desde entender qual é o objetivo do que está sendo feito até a sua implementação e monitoramento, passando pelo tratamento dos dados, a criação do modelo e a validação do mesmo, ainda podendo “retornar” pra qualquer outra fase a qualquer momento. Criada para sanar a dor de uma despadronização na criação de projetos de Ciência de Dados (ainda na época chamada de “Mineração de dados”), atualmente é usada por praticamente todas as empresas que desejam ter seriedade em seus trabalhos que possam resultar em um auxílio na tomada de decisão por dados (o famoso termo <em>data-driven</em>).</p><p>Sendo uma “guideline” de trabalho criada há mais de 25 anos (criado em 1996, publicado em 1999), é natural que hajam atualizações ao longo do tempo. A IBM mesmo criou uma versão “melhorada” do CRISP-DM, chamada de ASUM-DM (<a href="http://i2t.icesi.edu.co/ASUM-DM_External/index.htm">link aqui</a>). Podem haver variações da mesma ferramenta, de acordo com segmentos, necessidades, contextos, etc, mas o CRISP-DM funciona perfeitamente para qualquer trabalho — desde uma análise pequena e local de uma questão até uma obra digna de um Grandmaster do Kaggle, ela serve muito bem.</p><h4>E qual é a “cara” desse CRISP-DM?</h4><p>O CRISP-DM possui a seguinte “cara”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/446/1*o-cMKGc4WrZZhlLfe2TRKQ.jpeg" /><figcaption><a href="http://towardsdatascience.com/crisp-dm-ready-for-machine-learning-project">Créditos</a></figcaption></figure><p>Há 7 fases dentro do fluxo de projeto — vou traduzir o diagrama acima, caso o inglês não esteja tão em dia:</p><ul><li><em>Business Understanding</em>, ou Entendimento do Negócio.</li><li><em>Data Understanding</em>, ou Entendimento dos Dados.</li><li><em>Data Preparation</em>, ou Preparação dos Dados.</li><li><em>Modeling</em>, ou Modelagem.</li><li><em>Evaluation</em>, ou Avaliação.</li><li><em>Deployment</em>, ou Implementação.</li><li><em>Model Management</em>, ou Monitoramento do Modelo.</li></ul><p>Para que não fique uma coisa tão abstrata, vou utilizar um “exemplo prático” para contextualizar cada etapa. Não segue taaaanto a realidade, mas serve para melhorar o entendimento do assunto.</p><h4>1º: Entendimento do negócio</h4><p><em>A fase que </em><strong><em>menos</em></strong><em> tem a ver com codar e codar.</em></p><p>Vamos supor que estamos trabalhando em uma empresa xpto e, em uma bela segunda-feira pós feriado (igual a essa que estou escrevendo), te chamam para uma reunião. A empresa enfrenta um problema envolvendo a debandada de clientes para outras empresas e, no final das contas, cabe a você a tarefa de criar um modelo de machine learning que possa inferir quais clientes tem mais chances de permanecer ou de sair. Modelo esse que será utilizado diariamente pelo setor de vendas para que eles possam elaborar abordagens que aumentem a taxa de retenção de clientes.</p><p>Em outras palavras, uma análise de churn — mas nunca irão te pedir de forma tão clara e concisa (e é aí que entra a <em>Engenharia de Requisitos</em>)<em>.</em></p><p><em>Qual é a atual dor da empresa? Quais são as ferramentas que podem ser usadas para resolver o problema? Quais algoritmos? Quais técnicas?</em> <em>Quais serão os critérios de sucesso para que o projeto seja implementado?</em> <strong>Essas são algumas das perguntas feitas nesta fase</strong>. Como responder? Temos como objetivo reduzir as perdas de clientes, obviamente, tendo como base algumas características dos clientes (data de saída, assiduidade nos pagamentos, etc). A partir disso, podemos analisar a base de dados histórica de clientes para saber quem ainda está conosco e quem migrou, utilizando PostgreSQL (vamos assumir que os dados são SQL) e Python, base esta que vai ser usada para treinar um algoritmo de aprendizado de máquina não supervisionado para prever variáveis discretas (0 e 1 — no caso, quem sai vs quem não sai da empresa). A gestão, depois de uma longa conversa, concordou que o modelo terá como métrica a precisão do mesmo ao prever quem sai e quem não sai da empresa, definida em 80% (ou seja: A cada 10 clientes, o modelo precisa prever corretamente se 8 clientes permanecem ou migram). O levantamento dos requisitos será feito com outros funcionários de outros setores — gerentes, vendedores, quem mais puder responder, e haverá um cronograma de N dias para cada etapa a seguir. Mensalmente, o modelo será checado e se observará a precisão dele. Se cair para 79%, serão necessárias revisões.</p><p>Outros tópicos a serem analisados são: Até aonde podemos ir sem violar a LGPD? Quais são os riscos associados vs os benefícios que podemos obter? Como a documentação será feita? E etc. Se não houver um entendimento SÓLIDO do que fazer aqui, as chances do projeto “dar ruim” são imensas.</p><p>Entendida essa fase, podemos ir pra próxima.</p><h4>2º: Entendimento dos dados</h4><p><em>Entendemos como curar a doença, mas cadê o “paciente”?</em></p><p><em>Onde vamos obter os dados? Eles são consistentes? Há erros nos dados? Como eles estão dispostos? Os dados irão precisar de tratamento?</em><strong> são algumas das perguntas desta fase</strong>. Por se tratar de uma empresa grande, há um data lake gigantesco com dados históricos mas que, por algum motivo, não foram devidamente tratados (vamos assumir que uma parte dos dados veio de um sistema descontinuado, por exemplo, e que a equipe ainda não seja suficientemente madura com relação à engenharia de dados). Uma conversa rápida com o gerente de vendas da empresa deixou claro que muitos clientes simplesmente não preenchem algumas informações em campos que deveriam ser preenchidos. Porém os atributos de cada entidade dentro daquele “universo de trabalho” mantém-se intactos desde o início das atividades da empresa e são atributos tempestivos (ou seja: os dados ali são o que são de acordo com o mundo real, sem distorções contextuais). Será necessário um trabalho de limpeza e ajuste dos dados para o modelo que será desenvolvido, mas nada que implique uma dor de cabeça tremenda ou um possível retorno para a fase de Entendimento de Negócios.</p><p><em>Mas é possível ir para a fase anterior?</em> Sim. Se houver um problema que entrave completamente esta fase de modo que não dê pra pensar em uma saída adequada que não distorça os dados, será preciso rever todo o entendimento do negócio. E aí haverão MUITOS atrasos. Por isso que é importante seguir em cada fase com cautela.</p><p>Assim que tudo relacionado aos dados for devidamente entendido, partiu pra próxima fase.</p><h4>3º: Preparação dos Dados</h4><p><em>“Mãos a obra!”</em></p><p>Essa é a fase que eu particularmente amo. E é a fase onde FINALMENTE encostamos no teclado para poder importar a base de dados, que investigamos como os dados se comportam, que fazemos as medições estatísticas (desde testes simples, envolvendo média, mediana e moda, até testes mais sofisticados, como o “teste t”) e outras avaliações de inferência em cima da base de dados para extrair mais insights.</p><p>Tem outlier? Tem campos nulos? Tem uma cacetada de colunas (chamadas “features”) que não iremos usar? Tem campos não padronizados, como por exemplo datas? Tem dados desbalanceados? A resposta pra todas as perguntas é uma só:<strong> Com certeza</strong>. É aqui que a EDA (<em>exploratory data analysis </em>ou análise exploratória de dados) começa. A missão de cada profissional de dados, antes de tudo, é de faxineiro. Pra cada problema, há uma solução e cabe a você aplicar cada conceito em seu devido quadrado.</p><p>Se houver problema aqui, então a solução é dar um passo pra trás e ver o que está acontecendo. Faltou alguma informação? A base de dados está com algum problema fora do seu alcance pra resolver? Temos que voltar a entender os dados totalmente para prosseguir.</p><h4>4º: Modelagem</h4><p><em>É aqui que a verdadeira diversão começa.</em></p><p>Tratamento dos dados feitos, validação feita e separação dos dados entre dados de treinamento, teste e validação realizada, partimos para a parte de modelagem, onde o estudo é de fato feito e, dependendo do outcome, partimos para a fase de avaliação e implementação.</p><p>Não existe receita de bolo pra modelar. O uso das ferramentas e das técnicas varia de caso pra caso, sendo uma verdadeira <em>arte </em>o produto final. Vários modelos são testados, o feature engineering é posto a prova, tudo tendo em mente a criação do modelo mais preciso para ser implementado.</p><p>É importante notar que é uma fase onde o cuidado precisa ser redobrado. Overfitting, underfitting, data leakage, dentre outros problemas que afetam a precisão do modelo — seja para mais ou para menos — são ocorrências que PRECISAM E DEVEM ser evitadas a todo custo. Imagina só, gastar bastante tempo em cima de um modelo que, no final, possua uma precisão assustadora demais pra ser verdade ou que seja “viciado”? Simplesmente não pode.</p><p>Algum problema aconteceu e comprometeu o modelo? Volte uma casa.</p><h4>5º: Avaliação</h4><p><em>“Um ajuste aqui e ali…”</em></p><p>Nosso modelo escolhido e com o melhor resultado — vamos chutar uns 85% de precisão — precisará ser testado devidamente para saber se vai para a implementação. Se houver algum problema aqui, tudo deverá ser devidamente ajustado antes do deadline previsto (láaaa na fase de Entendimento do Negócio).</p><p>Não há muito o que dizer aqui, já que é a fase onde vemos se o modelo passa em todos os critérios que definimos anteriormente. Explicar mais</p><p>Passou? Hora do famoso <em>deploy</em>.</p><h4><strong>6º Implementação e Monitoramento</strong></h4><p><em>“Habemus model!”</em></p><p>Aqui é a fase “final”, <strong>partiu deploy</strong>. Essa fase é bem relativa quanto ao modus operandi. O modelo pode ser disponibilizado <em>in-loco</em> (em sistema próprio da empresa, tarefa que será compartilhada com o time de desenvolvedores), pode ser implementado em site, etc; o importante é que esteja com o acesso disponibilizado e devidamente armazenado em servidores (locais ou em nuvem). Como um exemplo, podemos definir que o modelo será implementado dentro do sistema de atendimento da empresa, a partir de uma aba que mostre um resumo financeiro daquele mesmo cliente e, ao final, exiba se aquele cliente possui chances de “abandonar o barco”, assim dando uma informação útil ao atendente ou vendedor que conversar com aquela pessoa em uma abordagem.</p><p>Sextou? Não.</p><p>Tudo muda e os dados são testemunhas desta mudança. E, com as mudanças, as vezes vem cenários não previstos; cenários que podem impactar na performance do modelo. É aí que o modelo pode “expirar” e uma revisão precisa ser feita com base nos critérios que o fez ser utilizado em primeiro lugar. Alertas, gatilhos, métricas e indicadores podem servir como “termômetro” para monitorar o nosso modelo recém implementado.</p><p>Se a precisão do modelo ficar abaixo do “threshold” indicado como critério de legitimidade do modelo, é necessário voltar a fase de preparação dos dados para que esses novos cenários sejam incluídos no novo modelo, que será criado, avaliado e implementado. É possível também falar sobre a experiência do projeto e o aprendizado que ele trouxe, com viés técnico ou não, via documentação <em>a posteriori, </em>e implementar a expertise adquirida em outros projetos de dados internamente(ou até fora dela, dependendo das políticas de gestão corporativa que a empresa tenha).</p><p><strong>Sextou? Agora sim.</strong></p><h4>Conclusão</h4><p>Vimos que o CRISP-DM atende todas as fases de um projeto de ciência de dados, desde a sua fase conceitual e de levantamento de requisitos até a implementação e monitoramento do mesmo. Toda empresa que possua um volume minimamente considerável de informações que possam ser agrupadas e catalogadas estará bem munida de material para um trabalho do tipo, e todo trabalho do tipo poderá seguir as guidelines da CRISP-DM sem problema algum.</p><p>Espero que o artigo tenha acrescentado ao seu conhecimento. Se leu e gostou, deixe registrado a sua opinião aqui! Seu feedback é MUITO importante para mim e para a minha futura carreira na área de Ciência de Dados! Também tem <a href="http://linkedin.com/in/evandrovieiramafort/">a opção de me procurar via LinkedIn</a>.</p><p>Até a próxima!</p><h4>Bibliografia</h4><ul><li><a href="https://jorgeaudy.com/2021/01/29/data-driven-mindset-o-modelo-de-mineracao-crisp-dm/">https://jorgeaudy.com/2021/01/29/data-driven-mindset-o-modelo-de-</a></li><li><a href="https://blog.mbauspesalq.com/2022/04/12/crisp-dm-as-6-etapas-da-metodologia-do-futuro/">https://blog.mbauspesalq.com/2022/04/12/crisp-dm-as-6-etapas-da-metodologia-do-futuro/</a></li><li><a href="https://www.preditiva.ai/blog/entenda-o-crisp-dm-suas-etapas-e-como-de-fato-gerar-valor-com-essa-metodologia">https://www.preditiva.ai/blog/entenda-o-crisp-dm-suas-etapas-e-como-de-fato-gerar-valor-com-essa-metodologia</a></li><li><a href="https://lxp.triggo.ai/article/Como-medir-a-qualidade-de-dados">https://lxp.triggo.ai/article/Como-medir-a-qualidade-de-dados</a></li><li><a href="https://www.ibm.com/docs/en/spss-modeler/saas">https://www.ibm.com/docs/en/spss-modeler/saas</a></li><li>Jornada Cientista de Dados, da Let’s Data</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e7238c48d3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[“A wild PYTHON has appeared!”]]></title>
            <link>https://medium.com/@evanVieira/a-wild-python-has-appeared-3de6c8e0550a?source=rss-636c618f3f6d------2</link>
            <guid isPermaLink="false">https://medium.com/p/3de6c8e0550a</guid>
            <category><![CDATA[educação]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[pop-culture]]></category>
            <category><![CDATA[programação]]></category>
            <dc:creator><![CDATA[Evandro Vieira]]></dc:creator>
            <pubDate>Wed, 14 Sep 2022 00:45:10 GMT</pubDate>
            <atom:updated>2022-09-14T00:46:04.983Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Ou como uniram uma das maiores paixões da geração Z com o aprendizado em programação.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LtP7iH0yzbePrFV-Y2oQsQ.png" /></figure><p>Quem nasceu lá pelos idos dos anos 90 e, assim como eu, cresceu assistindo vários e vários desenhos animados nas manhãs da emissora de Senor Abravanel com certeza se deparou com as <strong>(intermináveis) </strong>aventuras de um garoto de boné que viajava pelo mundo batalhando contra outras crianças e adultos, sempre <strong>(spoiler)</strong> perdendo a batalha principal no clímax de cada temporada. <em>Prazer, Pokemón!</em></p><p>Lançado em 1º de abril de 1997 (coincidentemente, o ano em que nasci), <em>Pokémon</em> (abreviação para <em>Pocket Monsters) </em>é uma criação de Satoshi Tajiri que tem como trama principal batalhas entre treinadores e os seus <em>“monstros de bolso”</em>, que com o passar do tempo ganham poder e mudam de forma— ou evoluem, na linguagem do desenho — ao passo que vão em várias aventuras com os seus mestres e encaram diversos desafios junto com eles. Uma geração INTEIRA foi marcada por essa animação, que rendeu desde games a <em>tasos</em> em salgadinhos<em> </em>famosos (quem nunca?), dentre outros produtos derivados. A febre de uma geração inteira.</p><p>Agora, já na casa dos 20 ~25 anos de idade, você ouve falar da área de tecnologia (mais especificamente, a área de programação) e se interessa. Várias ferramentas, possibilidades, coisas a aprender. Descobre um curso de lógica de programação e, posteriormente (ou até durante), acaba ouvindo falar de uma linguagem em particular: <em>Python (o</em>u <em>Pitão</em>, para os íntimos).</p><p>Explicação de bolso: <em>Python (</em><a href="https://www.python.org/"><em>python.org</em></a>) é uma linguagem de programação criada em 1989 por Guido Van Rossum, tendo como base as linguagens ABC, Haskell e C. Construída tendo como princípios a fácil sintaxe (<em>põe fácil nisso</em>) e de ser <em>open-source </em>(ou seja: Quer contribui com a linguagem? Você pode!), atualmente é uma das linguagens mais populares do planeta (disputa que fica pau a pau com JavaScript, C#, entre outras), por conta da fácil sintaxe e aplicabilidade bem ampla (que infelizmente não é total: Em algumas áreas, ela não é a melhor opção).</p><p><em>Fun fact: O nome Python não veio da serpente que conhecemos como píton, e sim do humorístico inglês Monty Python, famoso nos anos 70 e 80. </em><strong><em>Plot twist!</em></strong></p><p><em>Voltando: </em>O Python, recém-descoberto, se tornou objeto de estudos e fonte de curiosidade. A sintaxe simples, o fácil uso e as infinitas possibilidades te atraem quase que imediatamente, mas há uma questão no meio. Cursos convencionais podem ser um pouco maçantes pra alguns e você é daquele tipo de pessoa que precisa de um impulso a mais, especialmente em atividades que são naturalmente mecânicas. Interatividade e contexto, além do tradicional <em>aula-exercício-revisão-prova, </em>por assim dizer, seriam legais.</p><p>E onde Python e Pokémon se encontram, afinal? Elas se encontram na Codédex!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/926/1*B2PRzvfd9_0xnpKTc34bqg.jpeg" /><figcaption>Nostalgia + aprendizado = Diversão</figcaption></figure><h3>Prazer, Codédex.</h3><p>Criada em Maio de 2022 por alguns desenvolvedores que também possuem experiência lecionando (Sonny Li, Malcolm Ridenour<strong> e </strong>Dharmarajsinh Jethva; links das redes sociais no final do artigo), a Codédex (<a href="https://www.codedex.io/">codedex.io</a>) é um espaço de aprendizado voltado para quem quer aprender Python de forma leve e descontraída — futuramente disponibilizando conteúdo para HTML e JavaScript. Toda em inglês (espero que esteja com o seu <em>english</em> em dia), as lições cobrem o básico da lógica de programação, como tipos primitivos, inputs e outputs, estruturas condicionais e de repetição e listas — ainda é uma plataforma em crescimento, recebendo conteúdo com o tempo — assim como possui alguns projetos (do iniciante ao avançado) lançados por integrantes da comunidade. O conteúdo de aprendizado é gratuito e acessível, importante destacar.</p><p>Há a possibilidade de contribuir financeiramente com o projeto, sendo membro da comunidade ou participando do workshop (o valor das opções são todos em dólar), sendo que o workshop dura 2 semanas e oferece certificado de conclusão — já sendo membro da comunidade, você tem acesso a comunidade do Discord e preparação para entrevistas de emprego, dentre outros benefícios que são oferecidos para ambas as opções (ou somente em uma delas).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*3zKtnNc_cvwNzQNRQpdlBQ.jpeg" /><figcaption>As opções pagas, com os seus respectivos preços</figcaption></figure><p>As lições em si são muito bem feitas e explicadas, qualquer pessoa pode entendê-las (desde quem mal tem experiência e contato com programação até seniores e pessoas que estão na área a décadas), possuindo exemplos práticos em cada tópico e com o seu progresso sendo salvo a cada lição completada (contanto que você esteja logado na plataforma — a mesma permite o login com o GitHub ou o Google; o login via conta na plataforma é uma feature futura, por enquanto), podendo ganhar medalhas e tendo todas as estatísticas na plataforma sendo disponibilizadas na nostálgica forma dos jogos de Pokémon.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*GQt-ohWMOZ3B-QTqaACNbA.jpeg" /><figcaption>Lição sobre tipos primitivos</figcaption></figure><p>Também há o canal no YouTube e os perfis nas redes sociais, para quem tiver o interesse em segui-los e acompanhar o trabalho dos caras no dia-a-dia (na página principal, os links de todas as redes sociais estarão lá — Twitter, Instagram, TikTok, YouTube, GitHub e Facebook). A plataforma possui crédito entre algumas das maiores instituições dos EUA, tais como a Universidade de Columbia, a Universidade de Nova York, o Lehmann College, dentre outras.</p><p>Unir a nostalgia de uma geração inteira com o aprendizado é uma sacada genial e que poderia ser utilizada em larga escala nas escolas e universidades em Terra Brasilis. Incrementa a experiência de aprender e traz leveza a uma área que, a primeira vista e de forma geral, é técnica e rigorosa com os seus conceitos. No fim das contas, <em>GOTTA CATCH ’EM ALL!</em></p><h3>Links de referência:</h3><p><a href="https://www.alura.com.br/empresas/artigos/linguagens-de-programacao-mais-usadas">https://www.alura.com.br/empresas/artigos/linguagens-de-programacao-mais-usadas</a><br><a href="https://www.northeastern.edu/graduate/blog/most-popular-programming-languages/">https://www.northeastern.edu/graduate/blog/most-popular-programming-languages/</a><br><a href="https://www.historiadetudo.com/pokemon">https://www.historiadetudo.com/pokemon</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3de6c8e0550a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>