Python Brasil —...
Voltar ao Glossario
Glossario Python

Git: O que É e Como Funciona | Python Brasil

Aprenda Git para projetos Python: comandos essenciais, branching, .gitignore, fluxos de trabalho e boas praticas de controle de versao para desenvolvedores.

O que e Git?

Git e um sistema de controle de versao distribuido que permite rastrear alteracoes em arquivos, colaborar com outros desenvolvedores e manter um historico completo de cada modificacao em um projeto. Para desenvolvedores Python, Git e uma ferramenta essencial — praticamente todo projeto open-source, biblioteca e framework usa Git para gerenciar seu codigo-fonte. Plataformas como GitHub, GitLab e Bitbucket sao construidas sobre o Git.

Git foi criado por Linus Torvalds em 2005 e se tornou o padrao da industria para controle de versao, substituindo ferramentas anteriores como SVN e Mercurial na maioria dos projetos.

Comandos Essenciais

# Configuracao inicial
# git config --global user.name "Seu Nome"
# git config --global user.email "seu@email.com"

# Iniciar um repositorio
# git init

# Clonar repositorio existente
# git clone https://github.com/usuario/projeto.git

# Ver status dos arquivos
# git status

# Adicionar arquivos ao staging
# git add arquivo.py
# git add .                    # adiciona todos os modificados

# Criar commit
# git commit -m "Adiciona funcao de autenticacao"

# Ver historico
# git log --oneline
# git log --graph --oneline --all

# Enviar para repositorio remoto
# git push origin main

# Atualizar do repositorio remoto
# git pull origin main

.gitignore para Python

O arquivo .gitignore define quais arquivos e pastas o Git deve ignorar. Para projetos Python, existe um padrao bem estabelecido.

# .gitignore para projetos Python

# Bytecode
# __pycache__/
# *.py[cod]
# *$py.class

# Ambientes virtuais
# .venv/
# venv/
# env/

# Distribuicao
# dist/
# build/
# *.egg-info/

# IDEs
# .vscode/
# .idea/
# *.swp

# Testes e cobertura
# .pytest_cache/
# htmlcov/
# .coverage

# Variaveis de ambiente
# .env
# .env.local

# Banco de dados local
# *.db
# *.sqlite3

Branching e Merging

# Criar e trocar para nova branch
# git checkout -b feature/nova-funcionalidade

# Listar branches
# git branch

# Trocar de branch
# git checkout main

# Merge (incorporar mudancas)
# git checkout main
# git merge feature/nova-funcionalidade

# Deletar branch apos merge
# git branch -d feature/nova-funcionalidade

Automacao com Python e Git

# Usando subprocess para interagir com Git
import subprocess

def obter_ultimo_commit():
    """Retorna a mensagem do ultimo commit."""
    resultado = subprocess.run(
        ['git', 'log', '-1', '--format=%H %s'],
        capture_output=True,
        text=True,
    )
    return resultado.stdout.strip()

def listar_arquivos_modificados():
    """Lista arquivos modificados no working directory."""
    resultado = subprocess.run(
        ['git', 'diff', '--name-only'],
        capture_output=True,
        text=True,
    )
    return resultado.stdout.strip().split('\n')

print(obter_ultimo_commit())
print(listar_arquivos_modificados())

Pre-commit Hooks com Python

# Instalacao: pip install pre-commit

# .pre-commit-config.yaml
# repos:
#   - repo: https://github.com/pre-commit/pre-commit-hooks
#     rev: v4.5.0
#     hooks:
#       - id: trailing-whitespace
#       - id: end-of-file-fixer
#       - id: check-yaml
#       - id: check-added-large-files
#
#   - repo: https://github.com/psf/black
#     rev: 24.1.0
#     hooks:
#       - id: black
#
#   - repo: https://github.com/pycqa/isort
#     rev: 5.13.0
#     hooks:
#       - id: isort
#
#   - repo: https://github.com/pycqa/flake8
#     rev: 7.0.0
#     hooks:
#       - id: flake8

# Instalar hooks: pre-commit install
# Rodar manualmente: pre-commit run --all-files

Fluxo de Trabalho Git Flow

# Exemplo de script para automacao de release
import subprocess
import sys

def criar_release(versao: str):
    """Cria uma branch de release seguindo Git Flow."""
    comandos = [
        f'git checkout -b release/{versao} develop',
        f'git commit --allow-empty -m "Inicia release {versao}"',
    ]
    for cmd in comandos:
        resultado = subprocess.run(cmd.split(), capture_output=True, text=True)
        if resultado.returncode != 0:
            print(f'Erro: {resultado.stderr}')
            sys.exit(1)
    print(f'Release {versao} criada com sucesso')

# Fluxo tipico:
# main          — codigo em producao
# develop       — integracao de features
# feature/xxx   — desenvolvimento de funcionalidades
# release/x.y.z — preparacao de release
# hotfix/xxx    — correcoes urgentes

Versionamento Semantico

# setup.py ou pyproject.toml usa versionamento semantico
# MAJOR.MINOR.PATCH
# 1.0.0 -> 1.0.1 (patch: correcao de bug)
# 1.0.0 -> 1.1.0 (minor: nova funcionalidade compativel)
# 1.0.0 -> 2.0.0 (major: mudanca incompativel)

# Exemplo com __version__ no codigo
__version__ = '1.2.3'

# Lendo versao do Git tag
import subprocess

def obter_versao_git():
    """Obtem a versao a partir da tag Git mais recente."""
    try:
        resultado = subprocess.run(
            ['git', 'describe', '--tags', '--abbrev=0'],
            capture_output=True,
            text=True,
        )
        return resultado.stdout.strip()
    except Exception:
        return '0.0.0'

Erros Comuns

O erro mais perigoso e fazer commit de segredos como senhas, chaves de API ou arquivos .env — uma vez no historico do Git, sao dificeis de remover completamente. Outro erro frequente e fazer commits muito grandes com multiplas mudancas nao relacionadas, dificultando a revisao e o rastreamento de bugs. Tambem e comum esquecer de criar um .gitignore adequado, incluindo no repositorio arquivos como __pycache__, ambientes virtuais e bancos de dados locais.

Boas Praticas

Escreva mensagens de commit claras e descritivas que expliquem o “por que” da mudanca. Faca commits pequenos e frequentes, cada um com uma unica responsabilidade. Configure um .gitignore completo para Python desde o inicio do projeto. Use branches para desenvolver funcionalidades e correccoes. Instale pre-commit hooks para garantir qualidade do codigo antes de cada commit. Nunca faca commit de segredos — use variaveis de ambiente e ferramentas como git-secrets.

Quando Usar

Git deve ser usado em todo projeto de software, independente do tamanho. Mesmo para projetos pessoais ou scripts simples, o controle de versao protege contra perda de codigo, permite experimentar sem medo e mantem um historico completo de decisoes. Para trabalho em equipe, Git e absolutamente indispensavel.

Ver Glossario Completo