Por que este guia importa

O Git é a base do fluxo de trabalho moderno de desenvolvimento. Conhecer os comandos essenciais e saber quando usá‑los reduz erros, acelera entregas e facilita colaboração. Abaixo você encontra os comandos organizados por categoria, exemplos práticos e scripts que a Herez usa em repositórios e pipelines.

Resumo rápido dos comandos

Comandos básicos com exemplos práticos

git init

O que faz: inicializa um repositório Git local.

mkdir meu-projeto
cd meu-projeto
git init
# cria .git e prepara o repositório local

git clone

O que faz: clona um repositório remoto para sua máquina.

git clone git@servidor:herez/projeto.git
cd projeto

git status

O que faz: mostra arquivos modificados, staged e não rastreados.

git status --short
# M indica modificado, ?? indica não rastreado

git add

O que faz: adiciona alterações à área de preparação (staging).

git add arquivo.py
git add .  # adiciona todas as alterações

git commit

O que faz: cria um commit com as alterações staged.

git commit -m "Corrige bug no parser de CSV"

Sincronização com repositórios remotos

git remote add

O que faz: adiciona um remoto ao repositório local.

git remote add origin git@servidor:herez/projeto.git
git remote -v

git fetch

O que faz: baixa referências e objetos do remoto sem mesclar.

git fetch origin
git log HEAD..origin/main --oneline

git pull

O que faz: busca e mescla alterações do remoto na branch atual.

git pull origin main

git push

O que faz: envia commits locais para o remoto.

git push origin feature/minha-feature
# para criar upstream:
git push -u origin feature/minha-feature

Trabalhando com branches

git branch

O que faz: listar, criar ou excluir branches.

git branch            # lista branches locais
git branch nova-branch # cria nova branch
git branch -d antiga   # exclui branch local

git switch

O que faz: muda para outra branch.

git switch nova-branch
# alternativa antiga: git checkout nova-branch

git merge

O que faz: mescla outra branch na atual.

git switch main
git merge feature/minha-feature

git branch -d

O que faz: exclui branch local já mesclada.

git branch -d feature/minha-feature

Comandos avançados e fluxo limpo

git log –oneline –graph –all

O que faz: exibe histórico compacto e visual em árvore.

git log --oneline --graph --all --decorate

git stash

O que faz: guarda alterações temporariamente sem commit.

git stash save "WIP: ajuste parser"
git stash list
git stash pop

git rebase

O que faz: reaplica commits sobre outra base para manter histórico linear.

git switch feature
git fetch origin
git rebase origin/main
# resolver conflitos, depois:
git rebase --continue

git cherry-pick

O que faz: aplica um commit específico em outra branch.

git switch hotfix
git cherry-pick a1b2c3d4

Desfazer alterações com segurança

git restore

O que faz: desfaz alterações em arquivo (worktree).

git restore arquivo.txt
# para restaurar versão do commit:
git restore --source=HEAD~1 arquivo.txt

git reset HEAD

O que faz: remove arquivo da área de preparação sem perder alterações locais.

git reset HEAD arquivo.txt

git revert

O que faz: cria um novo commit que reverte outro commit (seguro para histórico público).

git revert a1b2c3d4
# cria commit que desfaz as mudanças do commit especificado

Ajuda e documentação

git <comando> –help

O que faz: exibe manual do comando com opções e exemplos.

git commit --help
git --help --all

Boas práticas Herez para uso de Git

• Mensagens claras: use convenções (tipo: escopo — descrição) e ferramentas de lint para commits.
• Branches curtas: mantenha branches de feature pequenas e com PRs frequentes.
• Rebase local, não remoto: reescreva histórico apenas antes de compartilhar; evite rebase em branches públicas.
• Proteja branches principais: use políticas de merge, revisão obrigatória e CI verde antes de mergear.
• Automatize: hooks, CI e pipelines para testes, lint e deploy reduzem erros humanos.
• Documente: mantenha um CONTRIBUTING.md com fluxo Git recomendado pela equipe.

Checklist rápido para operações comuns

• Iniciar projeto: git init, criar .gitignore, primeiro commit.
• Trabalhar em feature: git switch -c feature/x, commits pequenos, git push -u origin feature/x.
• Atualizar branch: git fetch, git rebase origin/main ou git merge origin/main conforme política.
• Corrigir emergência: git switch hotfix, aplicar correção, git cherry-pick se necessário.
• Desfazer com segurança: git revert para histórico público; git reset ou git restore para trabalho local.

Como usar este post

Este guia apresenta cada biblioteca com exemplos práticos, incluindo scripts completos e reproduzíveis que Herez usou em projetos reais. Use os trechos para aprender a coletar dados de páginas estáticas e dinâmicas, montar crawlers e processar HTML/XML com XPath.

Resumo rápido

Bibliotecas detalhadas com exemplos completos

Requests

O que é: biblioteca simples e elegante para fazer requisições HTTP em Python.

# Instalação
pip install requests

import requests

url = 'https://example.com'
resp = requests.get(url, timeout=10)
if resp.status_code == 200:
    with open('example.html', 'w', encoding='utf-8') as f:
        f.write(resp.text)
    print('Página salva em example.html')
else:
    print('Erro', resp.status_code)

BeautifulSoup

O que é: parser de HTML que facilita navegar e extrair elementos do DOM com uma API intuitiva.

# Instalação
pip install beautifulsoup4
# opcionalmente instalar lxml para performance
pip install lxml

import requests
from bs4 import BeautifulSoup

url = 'https://example.com/news'
resp = requests.get(url, timeout=10)
soup = BeautifulSoup(resp.text, 'lxml')
articles = []
for item in soup.select('article h2 a'):
    title = item.get_text(strip=True)
    link = item['href']
    articles.append({'title': title, 'link': link})
print(articles)

Scrapy

O que é: framework completo para crawling e scraping em escala, com gerenciamento de filas, middlewares e exportadores.

# Instalação
pip install scrapy

# myspider.py
import scrapy

class NewsSpider(scrapy.Spider):
    name = 'news'
    start_urls = ['https://example.com/news']

    def parse(self, response):
        for article in response.css('article'):
            yield {
                'title': article.css('h2 a::text').get(),
                'link': article.css('h2 a::attr(href)').get()
            }

Selenium

O que é: automação de navegadores que permite renderizar páginas com JavaScript, preencher formulários e interagir com elementos dinâmicos.

# Instalação
pip install selenium
# requer driver do navegador (ex: chromedriver) compatível com a versão do navegador

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from bs4 import BeautifulSoup

options = Options()
options.add_argument('--headless')
driver = webdriver.Chrome(options=options)
driver.get('https://example.com/dynamic')
html = driver.page_source
soup = BeautifulSoup(html, 'lxml')
titles = [h.get_text(strip=True) for h in soup.select('.post-title')]
print(titles)
driver.quit()

lxml

O que é: parser rápido e robusto para HTML/XML com suporte a XPath e XSLT, ideal para extração precisa e performance.

# Instalação
pip install lxml

import requests
from lxml import html

resp = requests.get('https://example.com/catalog', timeout=10)
doc = html.fromstring(resp.content)
items = []
for node in doc.xpath('//div[@class="product"]'):
    name = node.xpath('.//h3/text()')[0].strip()
    price = node.xpath('.//span[@class="price"]/text()')[0].strip()
    items.append({'name': name, 'price': price})
print(items)

Boas práticas Herez para Web Scraping

• Respeite termos e robots.txt: verifique políticas do site e limite taxa de requisições para evitar bloqueios.
• Use headers e rotação de user agents: simule navegadores reais e evite padrões que disparem bloqueios.
• Cache e reuso: armazene páginas baixadas para evitar requisições repetidas durante desenvolvimento.
• Trate erros e retries: implemente backoff exponencial e logging para robustez.
• Proteja credenciais: nunca versionar senhas; use cofres de segredos para logins automatizados.
• Escalabilidade: para grandes volumes, prefira Scrapy com pipelines assíncronos e filas; monitore desempenho e custos.
• Repositórios Herez: exemplos completos, spiders, scripts de login e pipelines usados em projetos reais da Herez estão disponíveis nos repositórios GitHub e GitLab da Herez.

Comparação rápida

Aspectos legais e éticos

Web scraping pode envolver restrições legais e de uso. Sempre verifique os termos do site, respeite limites técnicos e éticos, e prefira APIs oficiais quando disponíveis. Herez aplica revisão legal e políticas internas antes de executar crawlers em produção.

Último post da série

Este foi o último artigo e encerramos aqui a série sobre este resumo comparativo contendo um checklist de adoção para times que desejam padronizar bibliotecas Python em projetos de dados e engenharia.

Como usar este post

Use este guia para escolher a biblioteca certa, copiar trechos de código e rodar jogos simples localmente. Todos os exemplos foram testados em projetos reais da Herez; os repositórios contêm código-fonte, assets e instruções de execução.

Resumo rápido

Bibliotecas detalhadas com jogos simples completos

PyGame

O que é: biblioteca clássica para desenvolvimento de jogos 2D em Python, com suporte a gráficos, som, entrada e temporização.

# Instalação
pip install pygame

import pygame, random, sys
pygame.init()
W, H = 640, 480
screen = pygame.display.set_mode((W,H))
clock = pygame.time.Clock()
player = pygame.Rect(W//2-25, H-60, 50, 50)
balls = []
score = 0
FONT = pygame.font.SysFont(None, 36)

while True:
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            pygame.quit(); sys.exit()
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]: player.x -= 5
    if keys[pygame.K_RIGHT]: player.x += 5
    if random.random() < 0.02:
        balls.append(pygame.Rect(random.randint(0,W-20), -20, 20, 20))
    for b in balls[:]:
        b.y += 5
        if b.colliderect(player):
            score += 1; balls.remove(b)
        elif b.y > H:
            balls.remove(b)
    screen.fill((30,30,40))
    pygame.draw.rect(screen, (200,50,50), player)
    for b in balls: pygame.draw.ellipse(screen, (50,200,50), b)
    screen.blit(FONT.render(f'Score: {score}', True, (255,255,255)), (10,10))
    pygame.display.flip()
    clock.tick(60)

Pyglet

O que é: biblioteca leve para multimídia e jogos, com integração direta a OpenGL e suporte a áudio, janelas e eventos.

# Instalação
pip install pyglet

import pyglet, random
window = pyglet.window.Window(640,480)
batch = pyglet.graphics.Batch()
player = pyglet.shapes.Rectangle(300,20,40,40,color=(50,150,255),batch=batch)
asteroids = []
label = pyglet.text.Label('Score: 0', x=10, y=450)
score = 0

@window.event
def on_draw():
    window.clear()
    batch.draw()
    label.draw()

def update(dt):
    global score
    if random.random() < 0.02:
        asteroids.append(pyglet.shapes.Circle(random.randint(0,640),480,10,color=(200,50,50),batch=batch))
    for a in asteroids[:]:
        a.y -= 200*dt
        if a.y < 0:
            asteroids.remove(a)
            a.delete()
        if a.x > player.x and a.x < player.x+40 and a.y < 60:
            score += 1
            asteroids.remove(a)
            a.delete()
    label.text = f'Score: {score}'

pyglet.clock.schedule_interval(update, 1/60.0)
pyglet.app.run()

PyOpenGL

O que é: bindings Python para OpenGL, permitindo controle direto do pipeline gráfico para criar gráficos 3D customizados.

# Instalação
pip install PyOpenGL PyOpenGL_accelerate

from OpenGL.GL import *
from OpenGL.GLUT import *
angle = 0.0

def display():
    global angle
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()
    glRotatef(angle, 0, 0, 1)
    glBegin(GL_TRIANGLES)
    glColor3f(1,0,0); glVertex2f(0,0.6)
    glColor3f(0,1,0); glVertex2f(-0.6,-0.6)
    glColor3f(0,0,1); glVertex2f(0.6,-0.6)
    glEnd()
    glutSwapBuffers()
    angle += 0.5

glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
glutInitWindowSize(600,600)
glutCreateWindow(b'Rotating Triangle')
glutDisplayFunc(display)
glutIdleFunc(display)
glutMainLoop()

Arcade

O que é: biblioteca moderna para jogos 2D com API simples, boa performance e integração com OpenGL via pyglet.

# Instalação
pip install arcade

import arcade
SCREEN_W, SCREEN_H = 800, 600

class MyGame(arcade.Window):
    def __init__(self):
        super().__init__(SCREEN_W, SCREEN_H, "Space Shooter")
        self.player = arcade.SpriteSolidColor(50,30,arcade.color.BLUE)
        self.player.center_x = SCREEN_W//2; self.player.center_y = 50
        self.bullets = arcade.SpriteList()
    def on_draw(self):
        arcade.start_render()
        self.player.draw()
        self.bullets.draw()
    def on_update(self, dt):
        self.bullets.update()
        for b in self.bullets:
            b.center_y += 5
            if b.center_y > SCREEN_H: b.kill()
    def on_key_press(self, key, modifiers):
        if key == arcade.key.SPACE:
            bullet = arcade.SpriteSolidColor(5,10,arcade.color.YELLOW)
            bullet.center_x = self.player.center_x; bullet.center_y = self.player.center_y+20
            self.bullets.append(bullet)

if __name__ == '__main__':
    game = MyGame()
    arcade.run()

Panda3D

O que é: engine 3D completa com renderização, física básica, sistema de cenas e ferramentas para jogos e simulações interativas.

# Instalação
pip install panda3d

from direct.showbase.ShowBase import ShowBase
from panda3d.core import AmbientLight, DirectionalLight

class MyApp(ShowBase):
    def __init__(self):
        super().__init__()
        self.scene = self.loader.loadModel('models/box')
        self.scene.reparentTo(self.render)
        self.scene.setPos(0, 10, 0)
        self.taskMgr.add(self.spin, 'spinTask')
    def spin(self, task):
        self.scene.setH(task.time * 60 % 360)
        return task.cont

app = MyApp()
app.run()

Comparação prática

Boas práticas Herez para desenvolvimento de jogos em Python

• Comece simples: valide mecânicas com um protótipo 2D antes de investir em 3D.
• Organize assets: mantenha sprites, sons e níveis em pastas versionadas; use formatos otimizados para deploy.
• Ambientes e dependências: use ambientes virtuais e registre versões em requirements.txt para reprodutibilidade.
• Performance: profile o jogo; mova lógica crítica para C/C++ ou use bibliotecas aceleradas quando necessário.
• Testes e CI: automatize testes de integração e builds; inclua smoke tests que executem o loop principal por alguns frames.
• Repositórios Herez: jogos completos, assets e instruções de execução usados em projetos reais da Herez estão disponíveis nos repositórios GitHub e GitLab da Herez.

Próximo post da série

No próximo artigo cobriremos bibliotecas Python para Web Scraping, com exemplos práticos, estratégias éticas e pipelines para transformar dados brutos em insights.