Python: Guia Completo para Iniciantes e Intermediários

Python é uma das linguagens de programação mais populares e acessíveis do mundo. Sua sintaxe clara e sua grande versatilidade fazem dela uma excelente escolha tanto para iniciantes quanto para desenvolvedores experientes. Este guia apresenta os conceitos fundamentais de Python e como utilizá-los de forma eficaz em seus projetos.

Por que escolher Python?

Python se destaca por várias características que explicam sua popularidade crescente:

• Sintaxe clara e legível: Projetado para ser fácil de ler e de escrever
• Versátil: Usado em desenvolvimento web, análise de dados, IA, automação, etc.
• Grande comunidade: Uma vasta comunidade de desenvolvedores e recursos abundantes
• Rico em bibliotecas: Milhares de pacotes para estender suas funcionalidades
• Interpretado: Não é preciso compilar o código, o que acelera o desenvolvimento
• Multiplataforma: Funciona em Windows, macOS, Linux e muitos outros sistemas

Instalação do Python

Para começar com Python, você precisa primeiro instalá-lo em seu sistema:

Windows

# Baixar em https://www.python.org/downloads/
# Ou instalar com winget
winget install Python.Python.3.11

macOS

# Com Homebrew
brew install python

# Ou baixar em https://www.python.org/downloads/

Linux (Ubuntu/Debian)

# Instalar Python 3
sudo apt update
sudo apt install python3 python3-pip python3-venv

Ambientes virtuais

Usar ambientes virtuais é uma boa prática para isolar as dependências dos seus projetos:

# Criação de um ambiente virtual
python -m venv mon_env

# Ativação do ambiente virtual
# No Windows
mon_env\Scripts\activate

# No macOS/Linux
source mon_env/bin/activate

# Instalação de pacotes
pip install numpy pandas matplotlib

Sintaxe básica e tipos de dados

Variáveis e atribuição

# Variáveis
nom = "Alice"
age = 30
taille = 1.75
est_developpeur = True

# Exibição de variáveis
print(f"Je m'appelle {nom}, j'ai {age} ans.")

Tipos de dados fundamentais

# Strings (str)
texte = "Bonjour, monde !"
multiple_lignes = """Ceci est un texte
sur plusieurs lignes."""

# Números (int, float)
entier = 42
decimal = 3.14159

# Booleanos (bool)
vrai = True
faux = False

# Verificação de tipo
print(type(entier))  # <class 'int'>

Coleções

# Listas (mutáveis, ordenadas)
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = [1, "deux", 3.0, True]

# Acesso aos elementos (indexação começa em 0)
premier_fruit = fruits[0]  # pomme
dernier_fruit = fruits[-1]  # orange

# Modificação
fruits[1] = "fraise"
fruits.append("kiwi")
fruits.extend(["mangue", "ananas"])
fruits.remove("pomme")

# Tuplas (imutáveis, ordenadas)
coordonnees = (10, 20)
rgb = (255, 0, 128)

# Dicionários (pares chave-valor)
personne = {
    "nom": "Dupont",
    "prenom": "Jean",
    "age": 30,
    "competences": ["Python", "JavaScript", "SQL"]
}

# Acesso aos valores
print(personne["nom"])
print(personne.get("adresse", "Non spécifiée"))

# Conjuntos (elementos únicos, não ordenados)
couleurs = {"rouge", "vert", "bleu"}
couleurs.add("jaune")

Estruturas de controle

Condições

# If, elif, else
age = 20
if age < 18:
    print("Mineur")
elif age < 21:
    print("Majeur, mais pas aux USA")
else:
    print("Majeur partout")

# Operadores de comparação
# ==, !=, <, >, <=, >=

# Operadores lógicos
# and, or, not
if age >= 18 and age <= 65:
    print("En âge de travailler")

Laços

# Laço for
for fruit in fruits:
    print(fruit)

# Range
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 8, 2):  # 2, 4, 6
    print(i)

# Enumeração
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Laço while
compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1

# Break e continue
for i in range(10):
    if i == 3:
        continue  # Passa para a próxima iteração
    if i == 7:
        break  # Sai do laço
    print(i)

Funções

# Definição de função
def saluer(nom):
    """Cette fonction salue la personne passée en paramètre."""
    return f"Bonjour, {nom} !"

# Chamada de função
message = saluer("Bob")
print(message)

# Parâmetros padrão
def saluer_formellement(nom, titre="M./Mme"):
    return f"Bonjour, {titre} {nom} !"

print(saluer_formellement("Dupont"))
print(saluer_formellement("Dupont", "Dr."))

# Argumentos nomeados
def calculer_prix(montant, taxe=0.2, reduction=0):
    return montant * (1 + taxe) - reduction

prix = calculer_prix(100, reduction=20, taxe=0.1)

# *args e **kwargs
def info_personne(nom, *hobbies, **caracteristiques):
    print(f"Nom: {nom}")
    print("Hobbies:")
    for hobby in hobbies:
        print(f"- {hobby}")
    print("Autres caractéristiques:")
    for cle, valeur in caracteristiques.items():
        print(f"- {cle}: {valeur}")

info_personne("Alice", "lecture", "natation", "vélo", 
              age=28, profession="Ingénieure", ville="Paris")

# Funções lambda
carre = lambda x: x * x
print(carre(5))  # 25

Programação Orientada a Objetos

# Definição de classe
class Personne:
    """Classe représentant une personne."""
    
    # Variável de classe
    espece = "Humain"
    
    # Construtor
    def __init__(self, nom, age):
        # Atributos de instância
        self.nom = nom
        self.age = age
        self._adresse = None  # Atributo semiprivado
    
    # Método de instância
    def se_presenter(self):
        return f"Je m'appelle {self.nom} et j'ai {self.age} ans."
    
    # Property
    @property
    def adresse(self):
        return self._adresse
    
    @adresse.setter
    def adresse(self, nouvelle_adresse):
        if isinstance(nouvelle_adresse, str):
            self._adresse = nouvelle_adresse
        else:
            raise TypeError("L'adresse doit être une chaîne de caractères")
    
    # Método estático
    @staticmethod
    def est_majeur(age):
        return age >= 18
    
    # Método de classe
    @classmethod
    def creer_depuis_annee_naissance(cls, nom, annee_naissance):
        from datetime import date
        age = date.today().year - annee_naissance
        return cls(nom, age)

# Criação de instâncias
alice = Personne("Alice", 30)
print(alice.se_presenter())

bob = Personne.creer_depuis_annee_naissance("Bob", 1990)

# Herança
class Employe(Personne):
    def __init__(self, nom, age, poste, salaire):
        super().__init__(nom, age)
        self.poste = poste
        self.salaire = salaire
    
    def se_presenter(self):
        presentation = super().se_presenter()
        return f"{presentation} Je travaille comme {self.poste}."

# Polimorfismo
personnes = [alice, Employe("Charlie", 35, "Développeur", 50000)]
for personne in personnes:
    print(personne.se_presenter())

Manipulação de arquivos

# Leitura de arquivo
with open("exemple.txt", "r", encoding="utf-8") as fichier:
    contenu = fichier.read()
    print(contenu)

# Leitura linha por linha
with open("exemple.txt", "r", encoding="utf-8") as fichier:
    for ligne in fichier:
        print(ligne.strip())

# Escrita de arquivo
with open("sortie.txt", "w", encoding="utf-8") as fichier:
    fichier.write("Bonjour, monde !\n")
    fichier.write("Ceci est un exemple d'écriture de fichier en Python.")

# Adição ao final de um arquivo
with open("sortie.txt", "a", encoding="utf-8") as fichier:
    fichier.write("\nCette ligne est ajoutée à la fin.")

Tratamento de exceções

# Try-except básico
try:
    nombre = int(input("Entrez un nombre: "))
    resultat = 10 / nombre
    print(f"10 / {nombre} = {resultat}")
except ValueError:
    print("Erreur: Veuillez entrer un nombre valide.")
except ZeroDivisionError:
    print("Erreur: Division par zéro impossible.")
except Exception as e:
    print(f"Une erreur inattendue s'est produite: {e}")
else:
    print("Aucune exception levée.")
finally:
    print("Ce bloc s'exécute toujours, qu'il y ait eu une exception ou non.")

# Lançar exceções
def verifier_age(age):
    if not isinstance(age, int):
        raise TypeError("L'âge doit être un nombre entier")
    if age < 0:
        raise ValueError("L'âge ne peut pas être négatif")
    return True

# Criar suas próprias exceções
class MajesteException(Exception):
    """Exception levée quand on manque de respect à Sa Majesté."""
    pass

def adresser_roi(message):
    if "votre majesté" not in message.lower():
        raise MajesteException("Il faut s'adresser au roi avec respect !")
    return "Le roi vous écoute."

Módulos e pacotes

# Importação de módulo
import math
racine = math.sqrt(16)

# Importação específica
from datetime import datetime, timedelta
maintenant = datetime.now()
demain = maintenant + timedelta(days=1)

# Importação com alias
import numpy as np
tableau = np.array([1, 2, 3, 4, 5])

# Criação de módulo
# arquivo: mon_module.py
def saluer(nom):
    return f"Bonjour, {nom} !"

class MaClasse:
    pass

# Em outro arquivo
from mon_module import saluer, MaClasse

Bibliotecas populares

Análise de dados

# Pandas para manipulação de dados
import pandas as pd

# Criação de um DataFrame
df = pd.DataFrame({
    'Nom': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Ville': ['Paris', 'Lyon', 'Marseille']
})

# Seleção de dados
personnes_paris = df[df['Ville'] == 'Paris']

# Operações estatísticas
age_moyen = df['Age'].mean()

# NumPy para computação científica
import numpy as np

# Criação de um array
tableau = np.array([[1, 2, 3], [4, 5, 6]])

# Operações matemáticas
somme = np.sum(tableau)
moyenne = np.mean(tableau)

Visualização de dados

# Matplotlib
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [10, 15, 7, 12, 9]

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-o', linewidth=2, markersize=8)
plt.title('Mon Graphique')
plt.xlabel('Axe X')
plt.ylabel('Axe Y')
plt.grid(True)
plt.savefig('graphique.png')
plt.show()

# Seaborn
import seaborn as sns

# Definir um estilo
sns.set_theme(style="whitegrid")

# Criar um gráfico
tips = sns.load_dataset("tips")
sns.boxplot(x="day", y="total_bill", data=tips)
plt.title('Distribution des factures par jour')
plt.show()

Desenvolvimento web

# Flask
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def accueil():
    return render_template('index.html', titre='Mon Application Web')

@app.route('/utilisateur/<nom>')
def utilisateur(nom):
    return f'Bonjour, {nom} !'

if __name__ == '__main__':
    app.run(debug=True)

# Django (estrutura de projeto)
# mysite/
# ├── manage.py
# └── mysite/
#     ├── __init__.py
#     ├── settings.py
#     ├── urls.py
#     └── wsgi.py

Boas práticas em Python

Convenções de nomenclatura

• Variáveis e funções: snake_case (exemplo: ma_variable, calculer_moyenne)
• Classes: PascalCase (exemplo: MaClasse, GestionnaireDeConnexion)
• Constantes: UPPER_CASE (exemplo: PI, MAX_TAILLE)
• Módulos: snake_case (exemplo: mon_module.py)
• Variáveis “privadas”: prefixo _ (exemplo: _variable_interne)

Estilo de código (PEP 8)

• Usar 4 espaços para indentação (sem tabulações)
• Limitar as linhas a 79 caracteres
• Deixar 2 linhas em branco entre as definições de classes e funções de nível superior
• Cercar os operadores com espaços: x = 1 + 2
• Não usar espaços antes dos parênteses de funções: print(x)
• Adicionar docstrings às suas funções e classes

Documentação

def calculer_moyenne(nombres):
    """
    Calcule la moyenne d'une liste de nombres.
    
    Args:
        nombres (list): Une liste de nombres (int ou float)
        
    Returns:
        float: La moyenne des nombres
        
    Raises:
        TypeError: Si l'argument n'est pas une liste
        ValueError: Si la liste est vide
    """
    if not isinstance(nombres, list):
        raise TypeError("L'argument doit être une liste")
    if not nombres:
        raise ValueError("La liste ne peut pas être vide")
    return sum(nombres) / len(nombres)

Testes

# test_calculs.py
import unittest
from calculs import calculer_moyenne

class TestCalculs(unittest.TestCase):
    def test_calculer_moyenne(self):
        self.assertEqual(calculer_moyenne([1, 2, 3, 4, 5]), 3.0)
        self.assertEqual(calculer_moyenne([0, 0, 0]), 0.0)
        
    def test_calculer_moyenne_erreurs(self):
        with self.assertRaises(TypeError):
            calculer_moyenne("pas une liste")
        with self.assertRaises(ValueError):
            calculer_moyenne([])

if __name__ == '__main__':
    unittest.main()

Conclusão

Python é uma linguagem poderosa e flexível que pode ser usada em diversas áreas. Ao dominar seus fundamentos, você poderá:

• Automatizar tarefas repetitivas
• Analisar e visualizar dados
• Criar aplicações web
• Desenvolver modelos de inteligência artificial
• Construir ferramentas e utilitários

Para ir além, explore as diversas bibliotecas especializadas do Python e participe da comunidade ativa que continua fazendo essa linguagem versátil e acessível evoluir.