---
title: "Git para Desenvolvedores Python: Guia"
url: "https://python.dev.br/guias/python-e-git-iniciantes/"
markdown_url: "https://python.dev.br/guias/python-e-git-iniciantes.MD"
description: "Aprenda Git do zero para projetos Python. Comandos essenciais, branches, .gitignore, GitHub e fluxo de trabalho para iniciantes"
date: "2025-11-30"
author: ""
---

# Git para Desenvolvedores Python: Guia

Aprenda Git do zero para projetos Python. Comandos essenciais, branches, .gitignore, GitHub e fluxo de trabalho para iniciantes


## Introdução

Git é o sistema de controle de versão mais usado no mundo. Ele registra cada alteração no seu código, permite colaborar com outros desenvolvedores e facilita reverter mudanças que causaram problemas. Para quem programa em Python, saber usar Git é tão importante quanto conhecer a linguagem em si.

Neste guia, vamos aprender Git do zero com foco em projetos Python, cobrindo desde os comandos básicos até o fluxo de trabalho com GitHub.

## Instalando o Git

### Linux (Ubuntu/Debian)

```bash
sudo apt update
sudo apt install git
```

### macOS

```bash
brew install git
```

Ou instale o Xcode Command Line Tools:

```bash
xcode-select --install
```

### Windows

Baixe o instalador em [git-scm.com](https://git-scm.com/) e siga o assistente. Recomendo manter as opções padrão.

## Configuração inicial

Após instalar, configure seu nome e email (usados nos commits):

```bash
git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"
```

Configure o editor padrão (opcional):

```bash
git config --global core.editor "code --wait"  # VS Code
```

Verifique as configurações:

```bash
git config --list
```

## Criando seu primeiro repositório

Vá até a pasta do seu projeto Python e inicialize o Git:

```bash
mkdir meu-projeto-python
cd meu-projeto-python
git init
```

O comando `git init` cria uma pasta oculta `.git/` que armazena todo o histórico do projeto.

## Entendendo o fluxo básico

O Git tem três áreas principais:

1. **Working Directory**: seus arquivos no disco
2. **Staging Area (index)**: arquivos preparados para o próximo commit
3. **Repository**: histórico de commits salvo

O fluxo é: editar arquivos, adicionar ao staging e fazer commit.

## Comandos essenciais

### git status

Mostra o estado atual dos arquivos:

```bash
git status
```

### git add

Adiciona arquivos ao staging:

```bash
# Adicionar um arquivo especifico
git add app.py

# Adicionar todos os arquivos modificados
git add .
```

### git commit

Salva as alterações do staging no histórico:

```bash
git commit -m "Adicionar funcao de calculo de media"
```

Escreva mensagens de commit descritivas. Evite mensagens genéricas como "update" ou "fix".

### git log

Visualiza o histórico de commits:

```bash
# Log completo
git log

# Log resumido
git log --oneline

# Log com grafico de branches
git log --oneline --graph
```

### git diff

Mostra as alterações feitas:

```bash
# Alteracoes nao adicionadas ao staging
git diff

# Alteracoes no staging
git diff --staged
```

## O .gitignore para projetos Python

O `.gitignore` define quais arquivos o Git deve ignorar. Para projetos Python, crie na raiz do projeto:

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

# Cache do Python
__pycache__/
*.pyc
*.pyo
*.pyd

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

# IDEs
.vscode/
.idea/
*.swp

# Variaveis de ambiente
.env

# Banco de dados local
db.sqlite3

# Jupyter
.ipynb_checkpoints/

# pytest
.pytest_cache/

# Coverage
htmlcov/
.coverage
```

Adicione o `.gitignore` antes do primeiro commit para evitar rastrear arquivos indesejados.

## Trabalhando com branches

Branches permitem trabalhar em funcionalidades novas sem afetar o código principal:

```bash
# Criar e mudar para uma nova branch
git checkout -b nova-funcionalidade

# Listar branches
git branch

# Mudar entre branches
git checkout main

# Criar branch sem mudar
git branch correcao-bug
```

### Fluxo com branches

```bash
# 1. Crie uma branch para a tarefa
git checkout -b adicionar-autenticacao

# 2. Faca alteracoes e commits
git add .
git commit -m "Implementar login de usuarios"

# 3. Volte para a main
git checkout main

# 4. Faca merge da branch
git merge adicionar-autenticacao

# 5. Apague a branch (opcional)
git branch -d adicionar-autenticacao
```

## Resolvendo conflitos

Conflitos acontecem quando duas branches alteram a mesma parte de um arquivo. O Git marca as áreas em conflito:

```python
<<<<<<< HEAD
def calcular_total(itens):
    return sum(item.preco for item in itens)
=======
def calcular_total(itens, desconto=0):
    total = sum(item.preco for item in itens)
    return total * (1 - desconto)
>>>>>>> nova-branch
```

Para resolver, edite o arquivo mantendo o código correto, remova os marcadores (`<<<<`, `====`, `>>>>`) e faça um commit.

## Trabalhando com GitHub

### Criando um repositório remoto

1. Crie uma conta em [github.com](https://github.com/)
2. Clique em **New repository**
3. Nomeie o repositório e clique em **Create repository**

### Conectando seu projeto ao GitHub

```bash
git remote add origin https://github.com/seu-usuario/meu-projeto.git
git branch -M main
git push -u origin main
```

### Enviando e recebendo alterações

```bash
# Enviar commits para o GitHub
git push

# Baixar alteracoes do GitHub
git pull
```

### Clonando um repositório existente

```bash
git clone https://github.com/usuario/projeto.git
cd projeto
```

## Pull Requests

Pull Requests (PRs) são a forma de propor alterações em projetos no GitHub:

1. Crie uma branch e faça seus commits
2. Faça push da branch: `git push origin minha-branch`
3. No GitHub, clique em **Compare & pull request**
4. Descreva as alterações e solicite revisão
5. Após aprovação, faça o merge

Este fluxo é padrão em equipes profissionais e projetos de código aberto.

## Desfazendo alterações

```bash
# Descartar alteracoes em um arquivo (antes do add)
git checkout -- arquivo.py

# Remover do staging (depois do add, antes do commit)
git reset HEAD arquivo.py

# Desfazer o ultimo commit (mantendo as alteracoes)
git reset --soft HEAD~1

# Criar um commit que reverte outro
git revert abc1234
```

## Boas práticas para projetos Python

- Faça commits pequenos e frequentes, cada um com uma mudança lógica
- Escreva mensagens de commit claras no imperativo: "Adicionar", "Corrigir", "Remover"
- Sempre use `.gitignore` adequado para Python
- Nunca faça commit de senhas, tokens ou arquivos `.env`
- Use branches para novas funcionalidades
- Faça pull antes de push para evitar conflitos
- Revise suas alterações com `git diff` antes de commitar

## Conclusão

Git é uma ferramenta essencial para qualquer desenvolvedor Python. Ele protege seu código contra perdas, facilita a colaboração e é requisito em praticamente todas as vagas de emprego. Comece com os comandos básicos apresentados neste guia e, à medida que se sentir confortável, explore funcionalidades mais avançadas como rebase, stash e cherry-pick. A prática diária é a melhor forma de dominar o Git.

Git é universal em todas as linguagens. Veja como desenvolvedores <a href="https://golang.com.br/blog/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {source: 'python.dev.br', target: 'golang.com.br', content: 'python-e-git-iniciantes'})">Go organizam repositórios</a> e como a comunidade <a href="https://rustlang.com.br/blog/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', {source: 'python.dev.br', target: 'rustlang.com.br', content: 'python-e-git-iniciantes'})">Rust utiliza Git e Cargo juntos</a> para gerenciar projetos open source.
