Intro ao Python

Intro

Embora o Python tenha sido conceituado no final da década de 1980 e, após sua implementação em 1989, tenha emergido como uma nova plataforma de linguagem multiparadigma com o advento do Big Data. Python inclui várias estruturas de dados, bibliotecas padrão com a implementação de análise de sentimento e código de ciência de dados.

Fonte da figura acima: The Top Programming Languages 2024: Typescript and Rust are among the rising stars, IEEE Spectrum, 22 Aug 2024.

Na busca por uma boa linguagem de programação na qual muitos aplicativos de ciência de dados possam ser desenvolvidos, o python surgiu como uma solução de programação completa. Devido à baixa curva de aprendizado e flexibilidade do Python, ele se tornou uma das linguagens que mais crescem. As bibliotecas em constante evolução do Python o tornam uma boa escolha para análise de dados [Nagpal & Gabrani, 2019].

Python é uma linguagem interpretada que se tornou mais comumente usada em aplicativos HPC (High-Performance and Scientific Computing). O Python se beneficia da capacidade de escrever módulos de extensão em C, que podem usar ainda mais bibliotecas otimizadas que foram escritas em outras linguagens compiladas. Para usuários de HPC, duas das extensões mais comuns são NumPy e mpi4py (MPI = Multiple Processes Instructions ou Programação Paralela) [Smith, 2016].

IEEE Spectrum: What Software Engineers Should Know About AI Jobs Today Stanford’s 2023 AI Index, mostra como estava o mercado de IA até final de 2022 (reportagem de Abril de 2023). Ressaltando os países que mais estavam oferecendo colocações da área de IA:

Setores onde a demanda crescia (aprendizado de máquina) e outros diminuia (robótica):

E apontava Python como a linguagem mais escolhida:

Um prática boa e eficaz associada com o aprendizado de uma linguagem de programação está relacionada com uso eficaz de fluxogramas como ferramenta de aprendizado. A capacidade dos alunos de resolver problemas usando fluxogramas é um bom preditor de sua capacidade de resolver problemas com Python. Isso significa que a maioria dos alunos que têm um bom desempenho usando fluxogramas terá um bom desempenho em Python. A maioria dos alunos achou o fluxograma mais fácil do que o Python (63%) e relatou que o fluxograma os ajudou a entender como escrever programas em Python (73%) [Cabo, 2018].

Mais sobre fluxogramas? Miro: Fluxogramas, Lucidchart: O que é um fluxograma? ou Wikipedia: Fluxograma.

Parallel Computing in Python using mpi4py (Stephen Weston, Yale Center for Research Computing, 2017).

Uso da biblioteca mpi4py-fft para cálculo da FFT (Fast Fourier Transform)

Python continua seu domínio como uma das principais linguagens de programação, mas é notório por ser lento, então alguns desenvolvedores de software recorrem a perfis - ferramentas que executam programas para determinar quais partes do código são lentas.

A IEEE Spectrum em Python Profiler Links to AI to Improve Code cita o uso do Scalene que identifica ineficiências num código Python requisitando sugestões ao GPT-4 (implica uso de uma API: OpenAI key, para seu uso). Você pode testar um demo de uso em [https://plasma-umass.org/scalene-gui/]. O Scalene, um perfil Python que não apenas identifica ineficiências no código, mas também recomenda como esse código pode ser melhorado, com a ajuda da IA. O Scalene traça simultaneamente o uso de três componentes de hardware: CPU, GPU e memória. Além disso, o perfilador de memória do Scalene emprega um algoritmo de amostragem que distingue entre o consumo de memória derivado de uma biblioteca de código nativo subjacente versus o próprio interpretador Python. Este processo revela instâncias em que os codificadores podem mudar para código nativo para melhorar o desempenho. O perfilador de memória identifica automaticamente linhas de Python ou código nativo que provavelmente resultarão nos chamados vazamentos de memória. Um vazamento de memória acontece quando um programa aloca memória, a usa e depois deixa de livrá-la. Isso pode afetar o desempenho de um programa, reduzindo a quantidade de memória disponível. Outra métrica chamada volume de cópia também é rastreada. Ele detecta operações de cópia caras e muitas vezes inadvertidas que ocorrem quando o Python converte entre representações de dados nativas e Python. O que faz a Scalene se destacar de seus pares é sua integração com a IA. Por meio de sua interface de usuário baseada na Web, o perfil Python mostra um detalhamento de nível de linha e por função do uso de CPU e memória e, com o clique de um botão, envia o código para o modelo de linguagem grande GPT-4 do OpenAI, solicitando que ele produza uma versão otimizada do código.

Qual é a idéia do Python?

A principal ideia por trás da linguagem de programação Python é legibilidade, simplicidade e produtividade. Guido van Rossum, o criador do Python (1998), projetou a linguagem com os seguintes princípios em mente:

1. Código legível e limpo – Python usa indentação obrigatória e uma sintaxe clara para tornar o código mais fácil de ler e escrever.
2. Produtividade – A linguagem permite resolver problemas com menos código em comparação a linguagens como C++ ou Java.
3. Multiparadigma – Python suporta programação procedural, orientada a objetos (OOP) e funcional, embora não seja estritamente limitada a qualquer um desses paradigmas.
4. Tipagem dinâmica e forte – Variáveis não precisam ser declaradas com um tipo, mas os tipos são verificados em tempo de execução.
5. Bibliotecas incluídas – A biblioteca padrão do Python é extensa e oferece módulos para tarefas comuns, reduzindo a necessidade de código externo.

"Jeito Python" de programas (Pythonic)

O "jeito Python" de programar é guiado por princípios conhecidos como "Pythonic", que refletem a filosofia do Python, resumida no documento "The Zen of Python" (acessível digitando import this no interpretador). Seguem-se os conceitos-chave:

1. Princípios do Código Pythonico

a) Legibilidade acima de tudo

• Nomes claros para variáveis/funções (ex.: total_vendas em vez de tv).

• Uso de indentação obrigatória (sem {}).

• Exemplo:

  ​x
  # Jeito NÃO Pythonic
  if x>0:print(x)
  ​
  # Jeito Pythonic
  if x > 0:
      print(x)
  

b) "Explícito é melhor que implícito"

• Evitar "mágica" oculta. Preferir código autoexplicativo.

c) "Simple is better than complex"

• Soluções diretas são valorizadas. Exemplo:

  xxxxxxxxxx
  # Jeito NÃO Pythonic (loop manual)
  lista = []
  for i in range(10):
      lista.append(i * 2)
  ​
  # Jeito Pythonic (list comprehension)
  lista = [i * 2 for i in range(10)]
  

d) "Don’t reinvent the wheel"

• Use funções embutidas e bibliotecas padrão. Exemplo:

  xxxxxxxxxx
  # Jeito Pythonic (usando enumerate)
  for indice, valor in enumerate(['a', 'b', 'c']):
      print(indice, valor)
  

2. Abstração em Objetos

Em Python, tudo é objeto (inteiros, strings, funções, módulos, etc.), e a linguagem incentiva o uso de OOP, mas não força seu uso exclusivo.

a) Variáveis como Objetos

• Até tipos "primitivos" têm métodos:

  xxxxxxxxxx
  nome = "python"
  print(nome.upper())  # Objeto string com método upper()
  

b) Estruturas de Dados como Objetos

• Listas, dicionários, etc., são classes com métodos embutidos:

  xxxxxxxxxx
  numeros = [1, 2, 3]
  numeros.append(4)  # Método da classe list
  

c) Duck Typing

• O tipo é definido pelo comportamento (métodos), não pela classe:

  xxxxxxxxxx
  class Pato:
      def nadar(self):
          print("Nadando!")
  ​
  def acao(objeto):
      if hasattr(objeto, 'nadar'):  # Se tem o método, é um "pato"
          objeto.nadar()
  ​
  acao(Pato())  # Funciona!
  

3. Padrões Pythonicos Comuns

a) Context Managers (with)

• Gerenciamento limpo de recursos (arquivos, conexões):

  xxxxxxxxxx
  with open('arquivo.txt', 'r') as file:  # Fecha automaticamente
      conteudo = file.read()
  

b) List Comprehensions

• Substitui loops para criar listas de forma concisa:

  xxxxxxxxxx
  quadrados = [x ** 2 for x in range(10)]
  

c) F-strings (formatação elegante)

• Mais legível que .format() ou %:

  xxxxxxxxxx
  nome = "Alice"
  print(f"Olá, {nome}!")
  

d) Desempacotamento

• Atribuição múltipla e desestruturação:

  xxxxxxxxxx
  a, b = (1, 2)  # Tupla desempacotada
  

4. Quando Usar OOP em Python

• Use classes para encapsular lógica complexa ou estados. Exemplo:

  xxxxxxxxxx
  class Cliente:
      def __init__(self, nome, email):
          self.nome = nome
          self.email = email
  ​
      def enviar_mensagem(self, mensagem):
          print(f"Enviando '{mensagem}' para {self.email}")
  

• Evite OOP excessivo para problemas simples (Python permite funções isoladas).

5. Exemplo Comparativo

Problema: Calcular média de notas.

• Jeito NÃO Pythonic:

  xxxxxxxxxx
  notas = [7.5, 8.0, 6.5]
  soma = 0
  for i in range(len(notas)):
      soma += notas[i]
  media = soma / len(notas)
  

• Jeito Pythonic:

  xxxxxxxxxx
  notas = [7.5, 8.0, 6.5]
  media = sum(notas) / len(notas)
  

Resumo jeito Pythonic

O "jeito Python" combina:

1. Legibilidade (código claro e explícito).
2. Abstração orientada a objetos (tudo é objeto, mas OOP não é obrigatório).
3. Utilização de recursos da linguagem (comprehensions, funções embutidas, context managers).

Python permite multi-paradigma, mas o estilo "Pythonic" prioriza simplicidade e elegância.

Python foi concebida desde o início para ser orientada a objetos?

Não exatamente. Python foi criada para ser uma linguagem multiparadigma, permitindo programação procedural, funcional e orientada a objetos. No entanto, o suporte a OOP foi incorporado desde o início, e quase tudo em Python é um objeto (como veremos abaixo). A linguagem não força o uso de OOP, mas facilita seu uso quando necessário.

Todos os dados e variáveis são considerados objetos?

Sim! Em Python, tudo é um objeto. Isso inclui:

• Números (inteiros, floats, etc.)
• Strings
• Listas, dicionários, tuplas, conjuntos
• Funções
• Classes e instâncias
• Módulos

Até mesmo tipos primitivos, como int e float, são objetos em Python, com métodos associados (ex.: (5).bit_length()).

Exemplo demonstrando que tudo é objeto:

xxxxxxxxxx
# Números são objetos
x = 10
print(x.bit_length())  # Saída: 4 (método do objeto 'int')
​
# Strings são objetos
s = "python"
print(s.upper())  # Saída: 'PYTHON'
​
# Funções são objetos
def hello():
    print("Olá!")
​
hello.msg = "Mundo!"
print(hello.msg)  # Saída: 'Mundo!'

Resumo:

• Python foi projetada para ser simples, legível e versátil.
• Não foi criada exclusivamente para OOP, mas suporta (e incentiva) esse paradigma.
• Tudo em Python é objeto, seguindo uma filosofia de design consistente.

Linguagem Interpretada

Mesmo sendo uma linguagem interpretada, Python é amplamente utilizado em projetos grandes e complexos. Existem mecanismos permitem que Python seja eficiente mesmo em código extensos.

1. Interpretação vs. Execução em Python

• Python é interpretado no sentido de que o código-fonte (.py) é traduzido para bytecode e executado linha a linha pelo interpretador (CPython, PyPy, etc.).
• Porém, não é puramente interpretado como shell scripts: o código é compilado para um bytecode intermediário (.pyc) antes da execução, o que acelera processos repetitivos.

2. Mecanismos que viabilizam projetos grandes em Python

a) Modularização e Pacotes

• Python permite (e incentiva) a divisão do código em módulos (arquivos .py) e pacotes (diretórios com __init__.py).

• Exemplo de estrutura para um projeto grande:

  xxxxxxxxxx
  meu_projeto/
  │
  ├── pacote_principal/
  │   ├── __init__.py
  │   ├── modulo1.py
  │   └── subpacote/
  │       ├── __init__.py
  │       └── modulo2.py
  │
  ├── tests/
  │   └── test_modulo1.py
  │
  └── main.py
  

• Vantagem: Organização clara, reuso de código e manutenção facilitada.

b) Namespaces e Escopo

• Variáveis e funções têm escopo definido (global, local, não-local), evitando conflitos em projetos grandes.

• Exemplo:

  xxxxxxxxxx
  # modulo1.py
  var_global = 10
  ​
  def funcao():
      var_local = 20
      return var_global + var_local
  

c) Orientação a Objetos (OOP)

• Classes, herança e polimorfismo ajudam a encapsular lógica complexa.

• Exemplo:

  xxxxxxxxxx
  class Cliente:
      def __init__(self, nome):
          self.nome = nome
  ​
  class ClienteVIP(Cliente):
      def __init__(self, nome, desconto):
          super().__init__(nome)
          self.desconto = desconto
  

d) Ferramentas de Gestão de Dependências

• pip + virtualenv/venv: Isolam ambientes e gerenciam bibliotecas externas.
• requirements.txt ou pyproject.toml (Poetry/Pipenv) listam dependências.

e) Documentação e Type Hints

• Docstrings padrão (Google, NumPy, etc.) e type hints (PEP 484) melhoram a legibilidade:

  xxxxxxxxxx
  def calcular_imposto(valor: float, taxa: float) -> float:
      """Calcula o imposto sobre um valor.
      
      Args:
          valor (float): Valor base.
          taxa (float): Taxa em porcentagem (0-100).
      
      Returns:
          float: Valor do imposto.
      """
      return valor * (taxa / 100)
  

f) Testes e Debugging

• Frameworks como unittest, pytest, e doctest permitem testes automatizados.

• Exemplo com pytest:

  xxxxxxxxxx
  # test_modulo1.py
  def test_soma():
      assert 1 + 1 == 2
  

g) Compilação para Bytecode/Cython

• Para otimizar performance, trechos críticos podem ser:

  • Compilados para bytecode (.pyc).
  • Reescritos em Cython (Python + C) ou integrados com C/C++ via ctypes.

3. Desafios e Mitos

• "Interpretado = Lento":

  • Verdade para cálculos intensivos, mas contornável com:

    • Bibliotecas otimizadas em C (NumPy, Pandas).
    • Uso de multiprocessamento (multiprocessing).

• "Scripts não escalam":

  • Prova contrária: Instagram, Spotify, Dropbox usam Python em larga escala.

4. Exemplo de Projeto Grande em Python

• Django (framework web) e Pandas (análise de dados) são exemplos de projetos massivos escritos em Python, com:

  • Centenas de módulos.
  • Hierarquia complexa de pacotes.
  • Integração com outras linguagens.

Django

Django é um framework Python de alto nível, projetado para o desenvolvimento rápido de aplicações web seguras e escaláveis. Ele segue o princípio "Baterias incluídas" (oferece tudo o que você precisa "de fábrica") e o padrão MVT (Model-View-Template), uma variação do MVC (Model-View-Controller).

Django é usado principalmente para:

a) Desenvolvimento Web Backend

• Criação de APIs REST (com Django REST Framework).
• Sites dinâmicos (como blogs, e-commerces, portais de notícias).

b) Aplicações com Banco de Dados

• Seu ORM permite trabalhar com bancos (PostgreSQL, MySQL, SQLite) sem escrever SQL manualmente.

• Exemplo:

  xxxxxxxxxx
  from django.db import models
  ​
  class Produto(models.Model):
      nome = models.CharField(max_length=100)
      preco = models.DecimalField(max_digits=10, decimal_places=2)
  

  Isso cria uma tabela Produto no banco de dados automaticamente.

c) Sistemas com Painel Administrativo

• O módulo admin gera uma interface gráfica para gerenciar dados sem precisar codificar:

  xxxxxxxxxx
  from django.contrib import admin
  from .models import Produto
  ​
  admin.site.register(Produto)
  

  

• Django admin site.

d) Projetos que Priorizam Segurança

• Protege contra vulnerabilidades comuns (SQL injection, CSRF, XSS) por padrão.

Conclusão

Python é perfeitamente viável para projetos grandes graças a:

1. Modularização eficiente (módulos/pacotes).
2. Ferramentas modernas (venv, pytest, type hints).
3. Comunidade ativa (boas práticas, PEPs).
4. Performance gerenciável (Cython, bibliotecas em C).

Se organizado corretamente, um sistema em Python pode ser tão robusto quanto em linguagens compiladas, com a vantagem da produtividade e legibilidade.

Para programadores em C, Pascal ou Matlab

Para programadores vindos de C, Pascal ou Matlab, a transição para Python pode apresentar desafios específicos devido às diferenças de paradigmas, sintaxe e filosofia de design. Abaixo estão as maiores dificuldades categorizadas por linguagem de origem.

1. Para Programadores de C (Baixo Nível/Estruturas Rígidas)

a) Gerenciamento Automático de Memória

• C: Alocação/desalocação manual (malloc, free).

• Python: Coletor de lixo (GC = Garbage Collector) gerencia memória automaticamente (deleta objetos quando eles não estão mais em uso. Mais info? Ver: Alura: O que é Garbage Collector, StackOverflow: O que é Garbage Collector e Garbage Collection and Memory Management in Python.

• Dificuldade:

  • Vício de querer controlar memória manualmente.
  • Estranheza com vazamentos de memória indiretos (ex.: referências cíclicas).

b) Tipagem Dinâmica vs. Estática

• C: Tipos explícitos (int, float).

• Python: Tipos inferidos em tempo de execução. Mais? Ver W2Schools: Python Data Types ou Documentação oficial: Data Types.

• Dificuldade:

  • Erros de tipo só aparecem durante a execução (ex.: "10" + 5 → TypeError).

c) Ausência de Ponteiros e Aritmética de Memória

• C: Manipulação direta de endereços.

• Python: Tudo é referência, sem aritmética de ponteiros.

• Dificuldade:

  • Abstrair estruturas como listas (que são dinâmicas) no lugar de arrays estáticos.

d) Performance

• C: Código compilado e otimizado.

• Python: Interpretado, mais lento em operações intensivas.

• Dificuldade:

  • Resistência a confiar em Python para tarefas críticas de performance (requer uso de Cython ou bibliotecas como NumPy).

• NumPy.

• Matlab: NumPy for MATLAB users.

2. Para Programadores de Pascal (Estruturada/Fortemente Tipada)

a) Sintaxe Mais Permissiva

• Pascal: Estrutura rígida (begin/end, var).

• Python: Indentação como delimitador de blocos.

• Dificuldade:

  • Adaptação à ausência de palavras-chave como end ou ;.

b) Orientação a Objetos (OOP) Opcional

• Pascal (Clássico): Programação procedural.

• Python: Multiparadigma (OOP não é obrigatório, mas ubíqua).

• Dificuldade:

  • Ajuste ao uso de classes para organizar código (ex.: métodos de listas como lista.append()).

c) Tipagem Forte, mas Dinâmica

• Pascal: Tipos declarados explicitamente.

• Python: Tipos associados a valores, não a variáveis.

• Dificuldade:

  • Estranheza com variáveis que mudam de tipo (x = 10 → x = "texto").

3. Para Programadores de Matlab (Científico/Matricial)

a) Índices Começando em 0 vs. 1

• Matlab: Índices iniciam em 1.

• Python: Índices iniciam em 0.

• Dificuldade:

  • Erros frequentes ao acessar posições (array[0] vs. array(1)).

b) Operações Matriciais sem Sintaxe Dedicada

• Matlab: Operações com matrizes usando A * B (multiplicação matricial).

• Python: Requer NumPy para similaridade (A @ B).

• Dificuldade:

  • Necessidade de aprender NumPy para cálculos científicos.
  • Site oficial NumPy.

c) Ambiente Interativo Diferente

• Matlab: IDE integrada com ferramentas gráficas.

• Python: Uso de Jupyter Notebook ou scripts .py.

• Dificuldade:

  • Adaptação a ferramentas como matplotlib (https://matplotlib.org) para plotagem (similar, mas com sintaxe distinta).

4. Desafios Comuns a Todos

a) Filosofia "Pythonica"

• Dificuldade:

  • Abandonar vícios como loops excessivos (em favor de list comprehensions) ou otimizações prematuras.

b) Bibliotecas e Ecossistema

• Dificuldade:

  • Navegar no vasto ecossistema de bibliotecas (pip) sem um "core" unificado como em Matlab.

c) Tratamento de Exceções vs. Verificações Rígidas

• C/Pascal: Verificação manual de erros.

• Python: Uso de try/except como padrão.

• Dificuldade:

  • Aceitar que "é mais fácil pedir perdão que permissão" (EAFP vs. LBYL).

Exemplo Prático: Soma de Elementos (C vs. Python)

• C:

  xxxxxxxxxx
  int soma = 0;
  for (int i = 0; i < n; i++) {
      soma += array[i];
  }
  

• Python:

  xxxxxxxxxx
  soma = sum(array)  # Jeito Pythonic
  

Como Superar Essas Dificuldades?

1. Para programadores C:

   • Estudar o modelo de objetos do Python (tudo é referência).
   • Use ctypes ou Cython para integrar código C.

2. Para programadores Pascal:

   • Praticar OOP com classes simples.
   • Aproveitar a legibilidade do Python (similar ao Pascal).

3. Para programadores Matlab:

   • Dominar NumPy e pandas para substituir operações matriciais.

   • Adotar Jupyter para um fluxo interativo.

     • Site oficial Jupyter.

Livro recomendado: Fluent Python (Ramalho, 2022) para entender o "jeito Python" avançado.

Resumo

A maior barreira não é a sintaxe, mas a mudança de mentalidade:

• De controle rígido (C/Pascal) para abstração e produtividade.
• De operações matriciais nativas (Matlab) para bibliotecas especializadas.
• Aceitar que "simples é melhor que complexo" (Zen of Python).
• Easter Egg ☞ >>> import this.

Referências

• Python para Iniciantes (site oficial do Python: PSF = Python Software Foundation): informa sobre IDEs (Integrated Development Envirnments), Editores de Texto sugeridos (Bluefish: multiplataforma, Notepad++: Windows olny, TextMate for macOS, Sublime Text: Multiplataforma ) e Livros Introdutórios, incluindo sugestão de uma página web introduzindo a linguagem de programação Python: PyFlo, que propõe uma sequência de estudo seguindo um "grafo":

  

➡︎ Livros bastante interessantes podem ser baixados à partir de: FreeComputerBooks.com. Em especial, sugiro uma "espiada" no tópico Top Free Books.

Por exemplo:

• João Ventura, Full Speed Python (apostila), 39 pp. 2018.

➡︎ Página WEB interessante: The Hitchhiker´s Guide to Pyton (disponível em pt-BR). Do livro O Guia do Mochileiro para Python (ver mais abaixo). 😃

➡︎ Documentação oficial Python, ou Documentação Python 3.8.20 (pt-BR).

Outras Sugestões:

• Luciano Ramalho, Fluent Python: Clear, Concise, and Effective Programming (English Edition), O'Reilly Media; 2º edição, 1016 pp., 10 maio 2022. 4.7 ⭑⭑⭑⭑⭑ (580 aval) Obs.: Livro não indicado para iniciantes em Python! Para iniciantes é recomendado o livro "Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming", de 2023.

• Luciano Ramalho, Python Fluente: Programação Clara, Concisa e Eficaz, Novatec Editora, 1a.ed, 800 pp., 2015 - 4.8 ⭑⭑⭑⭑⭑ (790 aval)

• Eric Matthens, Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming, No Starch Press, 552 pp., 3ª edição (10 janeiro 2023). 4.7 ⭑⭑⭑⭑⭑ (1519 aval)

  Abrange Django, matplotlib e plotly, e pygame.

• Kenneth Reitz, Tanya Schlusser, O Guia do Mochileiro para Python!, Novatec Editora, 360 pp., 1ª edição (16 fevereiro 2017) - 4.7 ⭑⭑⭑⭑⭑ (122 aval)

  • Página WEB com seções do livro. ⬅︎ Bastante interessante! 😳

• Dane Hillard, Practices of the Python Pro, Manning, Manning; First Edition, January 14, 2020. 4.2 ⭑⭑⭑⭑⭒ (49 aval) Resumo: Os desenvolvedores profissionais conhecem os muitos benefícios de escrever um código de aplicativo limpo, bem organizado e fácil de manter. Ao aprender e seguir padrões estabelecidos e melhores práticas, você pode levar seu código e sua carreira a um novo nível. Com o Practices of the Python Pro, você aprenderá a projetar um software de nível profissional, limpo e de fácil manutenção em escala usando a linguagem de programação incrivelmente popular, Python. Você encontrará exemplos fáceis de usar pseudocódigo e Python para introduzir as melhores práticas de desenvolvimento de software, juntamente com dezenas de técnicas instantaneamente úteis que o ajudarão a codificar como um profissional.

• Stirling Hale, Wizardry Press, Absolute Beginner's Guide to Python Programming: Master Coding Quickly with Hands-On, Real-World Projects, Step-By-Step Guidance, and Comprehensive Learning for All Ages (Absolute Beginner's Guides), Wizardry Press, 216 pp, 2024. 4.8 ⭑⭑⭑⭑⭑ (379 aval)

• Al Swigart, Automate the Boring Stuff with Python, 2nd Edition: Practical Programming for Total Beginners, No Starch Press, 2nd edition, 2019, 552 pp., 4.7 ⭑⭑⭑⭑⭑ (3334 aval).

  Abrange trabalhar com arquivos em massa, automatizar e-mails e textos, raspar a web e muito mais.

• C. Cabo, "Eficácia do Fluxograma como uma Ferramenta de Andaime para Aprender Python", 2018 IEEE Frontiers in Education Conference (FIE), San Jose, CA, EUA, 2018, pp. 1-7, doi: 10.1109/FIE.2018.8658891. Palavras-chave: Python; Flowcharts; Profissão de programação; Ferramentas;Resolução de problemas; Flowgrama, Python, compreensão de programas, geração de programas, programadores novatos, educação em ciência da computação}. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp? tp=&arnumber=8658891&isnumber=8658371.

• R. Smith, "Performance of MPI Codes Written in Python with NumPy and mpi4py," 2016 6th Workshop on Python for High-Performance and Scientific Computing (PyHPC), Salt Lake City, UT, USA, 2016, pp. 45-51, doi: 10.1109/PyHPC.2016.010. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7836843&isnumber=7836833

• A. Nagpal e G. Gabrani, "Python para Análise de Dados, Aplicações Científicas e Técnicas", Conferência Internacional Amity de Inteligência Artificial (AICAI), Dubai, Emirados Árabes Unidos, 2019, pp. 140-145, doi: 10.1109/AICAI.2019.8701341. URL: https://ieeexplore.ieee.org/stamp/stamp.jsp? tp=&arnumber=8701341&isnumber=8701225.

Fernando Passold, em 05/04/2025