diff --git a/content/01-finquant/index.md b/content/01-finquant/index.md index 80d0a6bef..79e22defb 100644 --- a/content/01-finquant/index.md +++ b/content/01-finquant/index.md @@ -5,7 +5,36 @@ title: " FinQuant" >[!warning] > Se você é membro da dev e quer contribuir com algum material, se liga no **Guia do Hub** disponível na seção Extras: [[../05-guiahub/01-guia-onboarding-hub|Guia do Hub]] -## Destaques recentes: +## O que é a trilha de Finanças Quantitativas (FinQuant)? -(colocar acho que 5 redirecionamentos para os nossos melhores projetos) +A trilha de **Finanças Quantitativas** é o eixo do Hub dedicado à **modelagem quantitativa aplicada a mercados financeiros**, focando em tomada de decisão baseada em **dados, métodos estatísticos e implementação computacional**. +Aqui integramos de forma estruturada: +- **Mercados e produtos financeiros** (Ações, derivativos, criptoativos etc.) +- **Estatística, econometria e séries temporais** (modelagem, inferência, diagnóstico e previsão) +- **Programação científica** (principalmente em Python, com foco em data pipelines, backtesting e automação) +- **Teoria de portfólio, risco e otimização** (alocação ótima, métricas de risco-retorno, restrições e controle de drawdown) + +O objetivo é dar viasibilidade aos projetos criados internamente, juntamente com artigos que sejam capazes de mostrar como se**formula, implementa e valida estratégias quantitativas completas**, desde a construção e tratamento da base de dados até a avaliação rigorosa de desempenho (backtests, métricas de risco-retorno e análise de robustez). + + +--- + +## Pra quem é essa trilha? + +> 👇 Se você se identificou com pelo menos um ponto, esse lugar é seu: + +- Quer **aprender a montar modelos de precificação, risco e portfólio** na prática + +- Gosta de **programar** e quer aplicar isso em finanças + +- Quer entender **como fundos, desks e quants** pensam risco, retorno, drawdown, alavancagem etc. + +- Está se preparando para **estágios/trainees em mercado financeiro, quant, research ou data** + + +Não precisa já saber tudo – o importante é estar disposto a **estudar, testar ideias e compartilhar código**. + +## Como navegar pela trilha + +Use o menu à baixo para acessar os conteúdos de cada semestre: \ No newline at end of file diff --git a/content/02-ia/index.md b/content/02-ia/index.md index 9ed70aa66..a293edb25 100644 --- a/content/02-ia/index.md +++ b/content/02-ia/index.md @@ -4,6 +4,35 @@ title: IA >[!warning] > Se você é membro da dev e quer contribuir com algum material, se liga no **Guia do Hub** disponível na seção Extras: [[../05-guiahub/01-guia-onboarding-hub|Guia do Hub]] -## Destaques Recentes: +## O que é a trilha de Inteligência Artificial (IA)? -(colocar acho que 5 redirecionamentos para os nossos melhores projetos) +A trilha de **Inteligência Artificial (IA)** é o eixo do Hub dedicado à **modelagem preditiva, aprendizado de máquina e deep learning**, com foco em construção de **modelos robustos, reprodutíveis e aplicados a problemas reais** (finanças, economia, ciências sociais, negócios etc.). +Aqui integramos de forma estruturada: + +- **Aprendizado de máquina clássico** + (regressão, árvores, ensembles, SVM, modelos lineares e generalizados) +- **Redes neurais e deep learning** + (MLP, CNN, RNN/LSTM, Transformers, arquiteturas modernas) +- **Aprendizado não supervisionado e representação** + (clustering, redução de dimensionalidade, embeddings, autoencoders) + +O objetivo é dar visibilidade aos projetos criados internamente e organizar materiais que mostrem **como se formula, implementa, avalia e documenta modelos de IA de ponta a ponta** – desde a coleta/tratamento de dados até a escolha de métricas, comparação de modelos e análise de erros. + +--- + +## Pra quem é essa trilha? + +> 👇 Se você se identificou com pelo menos um ponto, essa trilha é pra você: + +- Quer **aprender machine learning e deep learning** +- Gosta de **programar em Python** e quer aplicar isso em problemas quantitativos e de negócio +- Quer entender **como cientistas de dados, engenheiros de ML e quants** projetam, treinam e validam modelos +- Está se preparando para **estágios/trainees em dados, IA, pesquisa aplicada ou áreas quantitativas** + +Não precisa já dominar IA – o importante é estar disposto a **estudar, experimentar modelos diferentes, medir resultados e compartilhar código**. + +--- + +## Como navegar pela trilha + +Use o menu à baixo para acessar os conteúdos de cada semestre: diff --git a/content/03-ciencia-de-dados/2025-s2/introducao-poo-fea-dev.md b/content/03-ciencia-de-dados/2025-s2/introducao-poo-fea-dev.md new file mode 100644 index 000000000..26449ef32 --- /dev/null +++ b/content/03-ciencia-de-dados/2025-s2/introducao-poo-fea-dev.md @@ -0,0 +1,1400 @@ +--- +title: Programação Orientada a Objetos +tags: + - "#trilha/ciencia-de-dados" + - nivel/avancado +--- +_**Autores:** Gabriel Navarro_ +# **Módulo 1 - Introdução a Programação Orientada a Objetos** + +## **1.1 - O que é Programação Orientada a Objetos ?** + +A Programação Orientada a Objetos *(POO)* é um estilo de programação que organiza o código em unidades chamadas objetos. Esses objetos representam entidades do mundo real e possuem características *(dados)* e ações *(comportamentos)*. **Esse modelo facilita a organização do código e torna os programas mais intuitivos e modulares**. + +Em suma, esse paradigma visa aproximar a programação da forma como percebemos o mundo real, onde objetos interagem entre si para realizar tarefas. + +#### **Diferença entre Programação Procedural e Programação Orientada a Objetos** + +A programação procedural, que geralmente é a primeira abordagem que aprendemos, organiza o código em funções e estruturas de controle, mantendo os dados e os procedimentos separados. Por outro lado, a Programação Orientada a Objetos encapsula dados e comportamentos dentro de objetos, promovendo uma estrutura mais modular, facilitando a reutilização e a manutenção do código. + +##### *Exemplo de Programação Procedural* + + +```python +# Procedural: Funções manipulam diretamente os dados +def criar_conta(nome, saldo): + return {"nome": nome, "saldo": saldo} + +def depositar(conta, valor): + conta["saldo"] += valor + +def exibir_saldo(conta): + print(f"Saldo de {conta['nome']}: {conta['saldo']}") + +# Uso +diego = criar_conta("Diego", 1000) +depositar(diego, 500) +exibir_saldo(diego) +``` + + Saldo de Diego: 1500 + + +##### *Exemplo de Programação Orientada a Objetos* + + +```python +# Orientado a Objetos: Criamos uma classe Conta +class Conta: + def __init__(self, nome, saldo): + self.nome = nome + self.saldo = saldo + + def depositar(self, valor): + self.saldo += valor + + def exibir_saldo(self): + print(f"Saldo de {self.nome}: {self.saldo}") + +# Uso +diego = Conta("Diego", 1000) +diego.depositar(500) +diego.exibir_saldo() +``` + + Saldo de Diego: 1500 + + +##### **Benefícios da Programação Orientada a Objetos** + +- Modularidade: O código é dividido em objetos independentes, facilitando a manutenção. + +- Reutilização de Código: Classes podem ser reutilizadas em diferentes partes do projeto. + +- Encapsulamento: Protege os dados do objeto e permite melhor controle de acesso. + +- Flexibilidade e Extensibilidade: É fácil adicionar novas funcionalidades. + +- Facilidade na modelagem: Permite criar representações próximas ao mundo real + +## **1.2 - Definições fundamentais** + +### **Classes** + +#### **Definição intuitiva** + +**Uma classe pode ser entendida como um molde ou projeto.** + +Exemplo intuitivo: +Imagine que você quer construir várias casas. Contudo, antes de começar, precisa de um projeto que detalhe: + +- Número de quartos + +- Localização da porta + +- Tamanho das janelas + +- E outros detalhes importantes + +**Esse projeto não é uma casa de verdade, mas define todas as informações necessárias para construir quantas casas você +quiser. Esse projeto é o que chamamos de classe.** + +#### **Classes na programação** + +Em termos de programação, uma classe funciona da mesma forma. Ela é um projeto que define as características (atributos) +e os comportamentos (métodos) de um tipo específico de elemento. + +Por exemplo, se quisermos representar carros no nosso programa, criamos uma classe chamada Carro. Essa classe vai dizer: + +- Quais informações cada carro terá (cor, modelo, ano de fabricação). + +- Quais ações o carro pode realizar (acelerar, frear, buzinar). + +#### **Outra forma de pensar em uma classe** + +**Uma classe também pode ser vista como a criação de um novo tipo de dado.** + +Em Python, já temos tipos de dados como int *(para números inteiros)*, str *(para textos)* e float *(para números decimais)*. +**Quando você cria uma classe, está definindo seu próprio tipo de dado personalizado, com características e comportamentos únicos**. +Por exemplo: + +Enquanto o tipo int serve para representar números inteiros. A classe Carro pode servir para representar carros, com todas +as informações que você quiser incluir (como marca, cor e velocidade). + + +#### **Exemplo prático** + + +```python +# Vamos começar a criar uma classe para representar carros + +# Primeiro, vamos criar a estrutura base da nossa classe. +# Neste momento, ela é apenas um "projeto" vazio, sem características nem comportamentos. + +class Carro: + pass # Usamos a palavra-chave 'pass' para indicar que a classe está vazia por enquanto. + # Isso evita erros de sintaxe e nos permite continuar desenvolvendo o código depois. +``` + +### **Atributos** + +#### **Definição intuitiva** + + +Depois de entender o que é uma classe (um molde ou projeto), **podemos pensar nos atributos como as características ou propriedades que definimos nesse projeto**. + +Exemplo intuitivo: +Imagine novamente o projeto de uma casa. Esse projeto descreve várias características, como: + +- Número de quartos +- Cor das paredes +- Tamanho das janelas +- E outros detalhes importantes + +Esses detalhes são os atributos da casa. Quando você constrói várias casas com base no mesmo projeto, cada uma pode ter atributos diferentes. + +Por exemplo: + +Uma casa pode ter 3 quartos e paredes azuis. Enquanto outra pode ter 4 quartos e paredes brancas. + +**Ou seja, mesmo que o projeto (classe) seja o mesmo, os atributos permitem que cada casa construída tenha suas próprias características únicas.** + +#### **Atributos na programação** + +**Em termos de programação, atributos são as informações que descrevem algo criado a partir de uma classe.** + +Por exemplo, se temos uma classe chamada Carro, os atributos podem ser: + +- cor (ex: vermelho, azul) +- modelo (ex: Toyota, Ford) +- ano de fabricação (ex: 2020, 2023) +- velocidade atual (ex: 0 km/h, 60 km/h) + +Cada carro que criamos a partir da classe Carro pode ter atributos diferentes. **Assim como no exemplo das casas, o molde é o mesmo, mas os detalhes (atributos) mudam de um carro para outro.** + +#### **Exemplo prático** + + +```python +# 2. Adicionando Atributos + +# Agora vamos definir as características (atributos) que cada carro terá. +# Para isso, usamos uma função especial chamada __init__ +# (explicaremos melhor sobre funções/métodos especiais em tópicos futuros). +# O __init__ é automaticamente executado sempre que criamos um novo carro a partir da nossa classe. +# Ele é responsável por inicializar o carro com as informações que fornecemos, +# ou seja, atribui os valores passados como parâmetros (marca, modelo, ano, cor) +# às características específicas do carro, definindo seus atributos iniciais. + +class Carro: + def __init__(self, marca, modelo, ano, cor): + # Observação importante: + # O parâmetro 'self' representa o próprio carro que está sendo criado. + # Ele é usado para acessar e definir as características (atributos) do carro, + # associando os valores que passamos como parâmetros (marca, modelo, ano, cor) + # às propriedades permanentes do carro (como self.marca, self.modelo, etc.). + + self.marca = marca # 'self.marca' é o atributo do carro, ou seja, a marca que será armazenada no carro. + # 'marca' (sem o self) é o valor que passamos quando criamos o carro. + # Exemplo: se criarmos Carro("Toyota", "Corolla", 2020, "Vermelho"), + # o valor "Toyota" será armazenado em self.marca. + + self.modelo = modelo # 'self.modelo' é o atributo que guarda o modelo do carro. + # 'modelo' é o valor passado quando o carro é criado. + # Exemplo: "Corolla" será armazenado em self.modelo. + + self.ano = ano # 'self.ano' é o atributo que representa o ano de fabricação do carro. + # 'ano' é o valor passado na criação do carro. + # Exemplo: 2020 será armazenado em self.ano. + + self.cor = cor # 'self.cor' é o atributo que guarda a cor do carro. + # 'cor' é o valor fornecido ao criar o carro. + # Exemplo: "Vermelho" será armazenado em self.cor. +``` + +### **Métodos** + +#### **Definição intuitiva** + +Agora que sabemos que uma classe é um projeto e que os atributos são as características desse projeto, **podemos pensar nos métodos como as ações ou comportamentos que algo criado a partir da classe pode realizar**. + +Exemplo intuitivo: +Voltando ao exemplo da casa, imagine que o projeto não define apenas as características (como o número de quartos), mas também o que a casa pode fazer, como: + +- Abrir portas +- Acender luzes +- Trancar janelas + +**Essas ações são os métodos da casa. Cada casa construída a partir do projeto pode realizar essas ações.** + + +#### **Métodos na programação** + +**Na programação, métodos são funções associadas a uma classe. Eles definem o que os objetos (que são criados a partir da classe) podem fazer**. + +Se criarmos uma classe Carro, podemos definir métodos como: + +- acelerar() – para aumentar a velocidade do carro. +- frear() – para reduzir a velocidade. +- buzinar() – para emitir um som de buzina. + +**Os métodos usam ou modificam os atributos do carro**. Por exemplo, o método acelerar() pode aumentar o valor do atributo velocidade atual. + +#### **Exemplo prático** + + +```python +# 3. Adicionando Comportamentos (criando métodos) + +# Agora vamos adicionar comportamentos que o carro pode realizar. +# Para isso, criaremos métodos, que são funções definidas dentro da classe. +# Esses métodos descrevem ações específicas que o carro pode executar, como acelerar, frear ou buzinar. +# Com isso, o carro deixa de ser apenas um conjunto de informações (atributos) e passa a interagir com o ambiente, +# simulando comportamentos do mundo real. + +class Carro: + def __init__(self, marca, modelo, ano, cor): + self.marca = marca + self.modelo = modelo + self.ano = ano + self.cor = cor + self.velocidade = 0 # Começamos com o carro parado + + def acelerar(self, incremento): + # O método acelerar aumenta o valor do atributo 'velocidade' do carro. + # O parâmetro 'incremento' define o quanto a velocidade deve aumentar. + # Por exemplo, se o carro estiver a 20 km/h e o incremento for 10, + # a nova velocidade será 30 km/h. + + self.velocidade += incremento + print(f"O carro acelerou para {self.velocidade} km/h.") + + def frear(self, decremento): + # O método frear reduz o valor do atributo 'velocidade' do carro. + # O parâmetro 'decremento' define o quanto a velocidade deve diminuir. + # Por exemplo, se o carro estiver a 30 km/h e o decremento for 10, + # a nova velocidade será 20 km/h. Se tentar reduzir mais do que a velocidade atual, + # a velocidade será ajustada para 0 km/h. + + self.velocidade = max(0, self.velocidade - decremento) # A função max(0, ...) garante que a velocidade nunca será negativa. + print(f"O carro desacelerou para {self.velocidade} km/h.") + + def buzinar(self): + # O método buzinar simula o som da buzina do carro. + # Quando chamado, ele simplesmente imprime "Bii Bii!". + + print("Bii Bii!") +``` + +#### **Métodos especiais** + +##### **Definição intuitiva** + +Agora que sabemos o que são métodos (as ações que um objeto pode realizar), podemos falar sobre os métodos especiais. + +**Os métodos especiais são ações especiais que a linguagem de programação já reconhece automaticamente**. Em Python, esses métodos têm uma nomenclatura distinta: começam e terminam com dois underlines (por exemplo, __init__). Os mais comuns são: + +- __init__ – Método de inicialização (construtor): + + O __init__ é chamado automaticamente quando criamos uma instância da classe. Ele é conhecido como construtor porque sua função essencial é construir o objeto, ou seja, definir seus atributos iniciais e garantir que o objeto (conceito que exploraremos em breve) esteja pronto para uso. + + Em termos simples, construtores configuram o estado inicial do objeto, estabelecendo os valores dos atributos que o definem. Por exemplo, ao criar um carro, o construtor define sua marca, modelo, ano e cor. Sem o construtor, o objeto seria criado, mas não teria características definidas. + +- __str__ – Método de representação textual: + + Define como o objeto será exibido quando usarmos a função print(). Esse método retorna uma descrição legível do objeto, facilitando a visualização de suas informações. + +##### **Exemplo prático** + + +```python +# 3. Adicionando Comportamentos Especiais (criando métodos especiais) + +# Agora vamos adicionar um comportamento especial com o método __str__, que define como o objeto será representado como texto. +# Também vamos destacar novamente o papel do método especial __init__, responsável por inicializar o objeto. + +class Carro: + def __init__(self, marca, modelo, ano, cor): + # O método __init__ é um método especial, também conhecido como construtor, e é chamado automaticamente + # sempre que criamos uma nova instância da classe Carro (iremos explorar o conceito de instância em breve). + # Construtores, como o __init__, têm a função de inicializar o objeto, configurando seus atributos iniciais. + # Neste caso, o carro é inicializado com as informações fornecidas: marca, modelo, ano, cor e velocidade. + + self.marca = marca + self.modelo = modelo + self.ano = ano + self.cor = cor + self.velocidade = 0 + + def acelerar(self, incremento): + self.velocidade += incremento + print(f"O carro acelerou para {self.velocidade} km/h.") + + def frear(self, decremento): + self.velocidade = max(0, self.velocidade - decremento) + print(f"O carro desacelerou para {self.velocidade} km/h.") + + def buzinar(self): + print("Bii Bii!") + + def __str__(self): + # O método __str__ é chamado automaticamente quando usamos a função print() em um objeto Carro. + # Ele retorna uma string que descreve o carro de forma legível, incluindo marca, modelo, ano, cor e velocidade atual. + + return f"{self.marca} {self.modelo} ({self.ano}), cor {self.cor}, velocidade atual: {self.velocidade} km/h" + +``` + +### **Objetos** + +#### **Definição intuitiva** + +Agora que sabemos o que é uma classe (projeto), o que são atributos (características) e o que são métodos (ações), podemos entender o que é um objeto. + +**Um objeto é um elemento concreto criado a partir da classe (projeto)**. Ele tem atributos definidos e é capaz de realizar ações (métodos). + +Exemplo intuitivo: +**Se a classe é o projeto da casa, o objeto é a casa real construída a partir desse projeto.** + +Por exemplo: + +- Casa 1: 3 quartos, paredes azuis, janelas grandes. +- Casa 2: 4 quartos, paredes brancas, janelas pequenas. + +**Cada casa é um objeto que tem suas próprias características (atributos) e pode realizar ações (métodos), como abrir portas ou acender luzes.** + +#### **Instância de uma classe** + + +**Uma instância é um termo técnico usado para descrever um objeto criado a partir de uma classe.** + +Imagine que você tem o projeto de uma casa. Esse projeto descreve como a casa deve ser: quantos quartos, o tamanho da sala, a cor das paredes, etc. Quando você usa esse projeto para construir uma casa real, essa casa é algo concreto. Cada casa construída a partir desse mesmo projeto é única, mas todas seguem a mesma estrutura. + +Na programação, acontece o mesmo: a classe é o projeto que define as características e comportamentos de algo. Quando criamos algo com base nesse projeto, temos um objeto. Cada objeto criado é uma instância única desse projeto, com suas próprias características. + +Por exemplo, com a classe Carro, podemos criar carro1 e carro2, cada um representando uma instância individual (ou seja, um objeto único criado a partir da classe), com sua própria marca, modelo e cor. + + +#### **Objetos na programação** + +**Na programação, um objeto é uma instância da classe, ou seja, um exemplo específico da estrutura que definimos.** + +Exemplo prático: + +Quando criarmos um carro específico no nosso programa, utilizando a classe Carro que estamos desenvolvendo, faremos algo assim: + +```python +meu_carro = Carro("Toyota", "Corolla", 2020, "vermelho") +``` + +Esse meu_carro é um objeto da classe Carro, ou seja, uma instância da classe Carro. Ele tem: + +Atributos: + +- marca = Toyota +- modelo = Corolla +- ano = 2020 +- cor = vermelho + +Métodos que ele pode realizar: + +- meu_carro.acelerar() – aumenta a velocidade. +- meu_carro.frear() – diminui a velocidade. +- meu_carro.buzinar() – toca a buzina. + +Cada objeto criado a partir da classe Carro representa uma instância individual, com atributos próprios e capaz de realizar as ações definidas nos métodos da classe. + +#### **Exemplo prático** + + +```python +# Relembrando como definimos a nossa classe Carro + +class Carro: + def __init__(self, marca, modelo, ano, cor): + self.marca = marca + self.modelo = modelo + self.ano = ano + self.cor = cor + self.velocidade = 0 # Começamos com o carro parado + + def acelerar(self, incremento): + # O método acelerar aumenta o valor do atributo 'velocidade' do carro. + # O parâmetro 'incremento' define o quanto a velocidade deve aumentar. + # Por exemplo, se o carro estiver a 20 km/h e o incremento for 10, + # a nova velocidade será 30 km/h. + + self.velocidade += incremento + print(f"O carro acelerou para {self.velocidade} km/h.") + + def frear(self, decremento): + # O método frear reduz o valor do atributo 'velocidade' do carro. + # O parâmetro 'decremento' define o quanto a velocidade deve diminuir. + # Por exemplo, se o carro estiver a 30 km/h e o decremento for 10, + # a nova velocidade será 20 km/h. Se tentar reduzir mais do que a velocidade atual, + # a velocidade será ajustada para 0 km/h. + + self.velocidade = max(0, self.velocidade - decremento) # A função max(0, ...) garante que a velocidade nunca será negativa. + print(f"O carro desacelerou para {self.velocidade} km/h.") + + def buzinar(self): + # O método buzinar simula o som da buzina do carro. + # Quando chamado, ele simplesmente imprime "Bii Bii!". + + print("Bii Bii!") + + def __str__(self): + # O método __str__ é chamado automaticamente quando usamos a função print() em um objeto Carro. + # Ele retorna uma string que descreve o carro de forma legível, incluindo marca, modelo, ano, cor e velocidade atual. + + return f"{self.marca} {self.modelo} ({self.ano}), cor {self.cor}, velocidade atual: {self.velocidade} km/h" +``` + + +```python +# 4. Criando um Objeto + +# Agora que temos a classe Carro pronta, com seus atributos e métodos definidos, vamos criar um objeto do tipo Carro. +# Esse objeto é uma instância da classe Carro, representando um carro específico com características definidas. + +# Criando uma instância da classe Carro com marca Toyota, modelo Corolla, ano 2020 e cor Vermelho. +meu_carro = Carro("Toyota", "Corolla", 2020, "Vermelho") + +# Agora vamos utilizar os métodos da classe para ver o comportamento desse objeto em ação: +meu_carro.acelerar(30) # Acelera o carro para 30 km/h. +print(f"Velocidade atual do meu_carro: {meu_carro.velocidade} km/h") # Exibe a velocidade atual após acelerar. + +meu_carro.buzinar() # O carro emite o som da buzina: "Bii Bii!". + +meu_carro.frear(10) # Reduz a velocidade do carro para 20 km/h. +print(f"Velocidade atual do meu_carro após frear: {meu_carro.velocidade} km/h") # Exibe a velocidade após frear. + +print("\n------------------------------------\n") + +# Podemos criar várias outras instâncias da classe Carro, cada uma representando um carro diferente: +carro_azul = Carro("Ford", "Focus", 2018, "Azul") +carro_preto = Carro("Honda", "Civic", 2022, "Preto") + +# Cada instância tem seus próprios atributos e pode executar os mesmos métodos de forma independente: +carro_azul.acelerar(50) # O carro azul acelera para 50 km/h. +print(f"Velocidade atual do carro_azul: {carro_azul.velocidade} km/h") # Exibe a velocidade atual do carro azul. + +carro_preto.buzinar() # O carro preto buzina: "Bii Bii!". + +carro_azul.frear(20) # O carro azul reduz a velocidade para 30 km/h. +print(f"Velocidade atual do carro_azul após frear: {carro_azul.velocidade} km/h") # Exibe a velocidade após frear. + +# Para acessar os atributos dos objetos, basta referenciar o atributo desejado: +print(f"O {meu_carro.marca} {meu_carro.modelo} é da cor {meu_carro.cor} e foi fabricado em {meu_carro.ano}.") +print(f"O {carro_azul.marca} {carro_azul.modelo} é da cor {carro_azul.cor} e foi fabricado em {carro_azul.ano}.") +print(f"O {carro_preto.marca} {carro_preto.modelo} é da cor {carro_preto.cor} e foi fabricado em {carro_preto.ano}.") + +``` + + O carro acelerou para 30 km/h. + Velocidade atual do meu_carro: 30 km/h + Bii Bii! + O carro desacelerou para 20 km/h. + Velocidade atual do meu_carro após frear: 20 km/h + + ------------------------------------ + + O carro acelerou para 50 km/h. + Velocidade atual do carro_azul: 50 km/h + Bii Bii! + O carro desacelerou para 30 km/h. + Velocidade atual do carro_azul após frear: 30 km/h + O Toyota Corolla é da cor Vermelho e foi fabricado em 2020. + O Ford Focus é da cor Azul e foi fabricado em 2018. + O Honda Civic é da cor Preto e foi fabricado em 2022. + + +### **Exercício: Simulando uma Carteira de Investimentos** + +Imagine que você é responsável por desenvolver um sistema simples de controle de investimentos para um investidor iniciante. Esse sistema precisa acompanhar diferentes ativos, como ações e títulos de renda fixa, calculando o valor atual de cada ativo e o retorno obtido. + +#### **Parte 1: Criando a Classe AtivoFinanceiro** + +1. Crie uma classe chamada AtivoFinanceiro com os seguintes **atributos**: + + - **nome**: Nome do ativo (ex: "Ação Petrobras"). + - **valor_investido**: Valor inicial investido no ativo. + - **valor_atual**: Valor atual do ativo. + + +```python +# Seu código aqui +``` + +2. Atualize o código acima criando métodos para: + + - Atualizar o valor atual do ativo. + - Calcular o retorno percentual do ativo: + + $Retorno \ (\%) = \dfrac{Valor \ atual - Valor \ Investido}{Valor \ Investido}*100$ + + + +```python +# Seu código aqui +``` + +#### **Parte 2: Criando Objetos e Testando a Classe** + +1. Utilizando a classe AtivoFinanceiro criada anteriormente, crie dois ativos financeiros distintos: + + - Um ativo de renda variável (ex: "Ação Itaú", valor investido R$ 1000, valor atual R$ 1200). + - Um ativo de renda fixa (ex: "Tesouro Direto", valor investido R$ 2000, valor atual R$ 2050). + +2. Atualize o valor de um dos ativos. + +3. Calcule e imprima o retorno percentual de cada ativo. + + +```python +# Seu código aqui +``` + +#### **Exercício Extra 1** + +Personalize a classe AtivoFinanceiro para exibir informações detalhadas sobre o ativo quando o objeto for impresso. + +Ao utilizar o comando print() em um objeto da classe AtivoFinanceiro, ele deve mostrar: + +- Nome do Ativo +- Valor Investido +- Valor Atual +- Retorno Percentual (lucro ou prejuízo em relação ao valor investido) + +**Dica:** +**Utilize o método especial __str__, que permite definir como o objeto será representado em formato de texto. Esse método é automaticamente chamado quando usamos print() no objeto.** + + +```python +# Seu código aqui +``` + +#### **Parte 3: Criando uma Simples Carteira de Investimentos** + +Agora que você já criou ativos individuais, vamos criar uma Carteira de Investimentos. + +1. Crie uma classe chamada CarteiraInvestimentos. + + - Essa classe deve ter um atributo ativos, que será uma lista de objetos do tipo AtivoFinanceiro. + +2. Crie métodos para: + + - Adicionar um novo ativo à carteira. + - Calcular o valor total investido. + - Calcular o valor atual total. + - Calcular o retorno total da carteira. + + +```python +# Seu código aqui +``` + +#### **Exercício Extra 2** + +Personalize a classe CarteiraInvestimentos para exibir informações detalhadas sobre a carteira quando o objeto for impresso. + +Ao utilizar o comando print() em um objeto da classe CarteiraInvestimentos, ele deve mostrar: + +- Lista de todos os ativos financeiros na carteira, com seus respectivos detalhes (nome do ativo, valor investido, valor atual e retorno percentual). +- Valor Total Investido na carteira. +- Valor Atual Total da carteira. +- Retorno Percentual Total (lucro ou prejuízo considerando todos os ativos da carteira). + +**Dica:** +**Utilize o método especial __str__, que permite definir como o objeto será representado em formato de texto. Esse método é automaticamente chamado quando usamos print() no objeto.** + + +```python +# Seu código aqui +``` + +#### **Parte 4: Testando a Carteira** + +1. Crie uma carteira de investimentos utilizando a classe CarteiraInvestimentos desenvolvida no exercício anterior. + + - Pense na carteira como um portfólio real, onde você gerencia diversos ativos financeiros. + + +2. Adicione à sua carteira os dois ativos financeiros que você criou anteriormente. + - Inclua tanto a ação da empresa quanto o ativo de renda fixa para observar como diferentes tipos de investimentos impactam o desempenho da carteira. + + +3. Calcule e imprima os seguintes resultados: + - Valor Total Investido: A soma do valor inicial aplicado em todos os ativos. + - Valor Atual Total: O valor atual combinado de todos os ativos após as atualizações de mercado. + - Retorno Total da Carteira: O percentual de lucro ou prejuízo da carteira como um todo. + +**Dica: Use o método __str__ que você implementou para exibir os detalhes da carteira de forma clara e organizada. Isso simula um relatório financeiro, como aqueles que investidores e gestores recebem periodicamente!** + + +```python +# Seu código aqui +``` + +# **Módulo 2 - Avançando em Programação Orientada a Objetos** + +## **2.1 - Os 4 Conceitos Fundamentais da Programação Orientada a Objetos** + +### **Abstração** + +#### **Definição intuitiva** + +**Abstração é o processo de esconder detalhes desnecessários e mostrar apenas o que é essencial**. + +Imagine um carro. Quando você dirige, não precisa saber exatamente como o motor funciona internamente, quais circuitos elétricos estão ativados ou como o combustível é processado. Você apenas interage com o carro por meio do volante, pedais e painel de controle. Ou seja, você se preocupa apenas com o que é necessário para dirigir. **Isso é abstração: mostrar apenas as informações relevantes e ocultar os detalhes internos**. + +#### **Abstração na programação** + +Na programação, a abstração funciona da mesma forma. Criamos classes que representam conceitos do mundo real, mas **escondemos os detalhes internos de implementação e mostramos apenas o necessário para quem usa a classe**. + +**Por exemplo, podemos ter uma classe OrdemDeCompra que permite um investidor comprar ações, sem precisar expor os detalhes de como a ordem é processada na bolsa de valores**. + + +```python +class OrdemDeCompra: + def __init__(self, ativo, quantidade, preco): + self.ativo = ativo + self.quantidade = quantidade + self.preco = preco + + def executar(self): + print(f"Enviando ordem de compra: {self.quantidade} ações de {self.ativo} a R$ {self.preco:.2f}") + +# Criando uma ordem de compra +ordem = OrdemDeCompra("PETR4", 100, 32.50) +ordem.executar() # Saída esperada: "Enviando ordem de compra: 100 ações de PETR4 a R$ 32.50" +``` + + Enviando ordem de compra: 100 ações de PETR4 a R$ 32.50 + + +**Aqui, a abstração permite que o usuário envie ordens de compra sem precisar saber como a ordem é roteada para o mercado, como os custos são calculados ou como os dados são armazenados. A classe esconde esses detalhes e expõe apenas o necessário para operar.** + +*Vale destacar que, no exemplo acima, o processo de emissão da ordem de compra não foi efetivamente implementado. O objetivo é apenas ilustrar o conceito de abstração. Mesmo que a lógica real de envio de ordens fosse adicionada, a maneira como o usuário interage com a classe permaneceria a mesma — bastaria chamar o método executar(), sem precisar se preocupar com os detalhes internos. Essa é a essência da abstração na POO.* + +### **Encapsulamento** + +#### **Definição intuitiva** + +**Encapsulamento significa proteger os dados de acesso indevido e garantir que eles só possam ser modificados de maneira controlada**. + +Pense em um cofre de banco. Você não pode simplesmente abrir e pegar o dinheiro sem passar pelos procedimentos adequados. Você precisa de uma chave ou senha para acessar o conteúdo. + +**No mundo da programação, o encapsulamento funciona de maneira semelhante: os atributos e métodos de um objeto podem ser protegidos para que só possam ser acessados ou modificados de maneira controlada**. + +#### **Encapsulamento na programação** + +Em programação, usamos modificadores de acesso para restringir o acesso direto a certos atributos e métodos de uma classe. **Em Python, seguimos uma convenção para diferenciar atributos e métodos públicos, protegidos e privados.** + +Métodos e atributos públicos, protegidos e privados em Python: +- Públicos: Podem ser acessados diretamente de fora da classe. + +- Protegidos (_atributo | _método): Devem ser tratados como internos à classe, mas ainda podem ser acessados fora dela (por convenção, não por restrição técnica). + +- Privados (__atributo | __método): Não podem ser acessados diretamente de fora da classe, pois o Python aplica uma modificação de nome (name mangling). + + + + +```python +class ContaBancaria: + def __init__(self, titular, saldo): + self.titular = titular # Atributo público + self._saldo = saldo # Atributo protegido (_atributo) + self.__senha = "1234" # Atributo privado (__atributo) + + def depositar(self, valor): # Método público + self._saldo += valor + + def sacar(self, valor): # Método público + if valor <= self._saldo: + self._saldo -= valor + else: + print("Saldo insuficiente") + + def get_saldo(self): # Método público + return self._saldo + + def __verificar_senha(self, senha): # Método privado (__método) + return senha == self.__senha + +# Criando um objeto da classe ContaBancaria +minha_conta = ContaBancaria("Gabriel", 1000) + +# Acessando métodos públicos +print(minha_conta.get_saldo()) # Saída esperada: 1000 +minha_conta.sacar(200) +print(minha_conta.get_saldo()) # Saída esperada: 800 + +# Tentando acessar um atributo protegido (possível, mas não recomendado) +print(minha_conta._saldo) # Saída esperada: 800 + +# Tentando acessar um atributo privado (não pode ser acessado diretamente) +# print(minha_conta.__senha) # Isso geraria um erro! +# Porém, devido ao name mangling, podemos acessar manualmente (NÃO RECOMENDADO) +print(minha_conta._ContaBancaria__senha) # Saída esperada: 1234 +``` + + 1000 + 800 + 800 + 1234 + + +#### **Observação** + +**Em Python, não existe efetivamente o conceito de atributos privados e protegidos como em linguagens como Java e C++.** + +Isso acontece porque Python segue a filosofia de "somos todos adultos aqui" (We are all consenting adults here). Ou seja, em vez de impor restrições rígidas, Python confia que os desenvolvedores seguirão as convenções estabelecidas. + +Por exemplo: + +- Atributos protegidos (_atributo) **não são realmente protegidos** — é apenas uma convenção para indicar que devem ser tratados como internos à classe. + +- Atributos privados (__atributo) também **não são verdadeiramente inacessíveis**, pois Python apenas renomeia (name mangling) o atributo, tornando-o acessível por _Classe__atributo. + +**Imagine um cofre com um aviso escrito: "Favor não abrir sem permissão." O cofre está trancado? Não. Mas o aviso deixa claro que você não deveria mexer nele. O encapsulamento em Python funciona da mesma forma: o acesso aos dados não é bloqueado, mas há indicações claras de que certos atributos não devem ser modificados diretamente.** + +### **Herança** + +#### **Definição intuitiva** + +**Herança permite criar novas classes a partir de classes existentes**, aproveitando e reutilizando código. + +Imagine que uma empresa tem diferentes tipos de funcionários: estagiários, analistas e gerentes. Todos compartilham algumas características básicas, como nome e salário, mas têm responsabilidades diferentes. **Em vez de criar classes separadas do zero, podemos definir uma classe geral Funcionario e fazer com que Estagiario, Analista e Gerente herdem suas características básicas, adicionando apenas os detalhes específicos de cada um**. + +#### **Herança na programação** + +**Na programação, a herança permite que uma classe filha (subclasse) herde atributos e métodos de uma classe pai (superclasse). Isso evita duplicação de código e facilita a manutenção.** + + +```python +# Definição da classe pai (superclasse) +class Funcionario: + def __init__(self, nome, salario): + self.nome = nome + self.salario = salario + + def exibir_dados(self): + print(f"Nome: {self.nome}, Salário: R$ {self.salario}") + +# Definição da classe filho (subclasse) +class Analista(Funcionario): # A sintaxe "class Analista(Funcionario)" indica que a subclasse Analista + # herda os atributos e métodos da superclasse Funcionario + + def __init__(self, nome, salario, area): + """ + O método __init__ da subclasse chama o __init__ da superclasse usando super(). + Isso evita a necessidade de reescrever a inicialização dos atributos nome e salario. + """ + + super().__init__(nome, salario) # Chama o construtor da superclasse Funcionario + self.area = area # Adiciona um novo atributo exclusivo da subclasse + + def exibir_dados(self): + """ + O método exibir_dados da subclasse reutiliza o método de mesmo nome da superclasse. + Primeiro, chama super().exibir_dados(), que exibe nome e salário. Depois, adiciona + a exibição da área específica do Analista. + """ + + super().exibir_dados() # Chama o método exibir_dados() da superclasse + print(f"Área: {self.area}") # Adiciona a nova informação exclusiva da subclasse + +# Criando um objeto da classe Analista +ana = Analista("Ana", 5000, "TI") + +# Chamando o método exibir_dados() +ana.exibir_dados() + +# Saída esperada: +# Nome: Ana, Salário: R$ 5000 +# Área: TI + +# No exemplo acima, a classe Analista herda os atributos e métodos da classe Funcionario, +# o que permite reutilizar a funcionalidade já definida. No entanto, ela tem a flexibilidade +# de adicionar novos atributos, como o "area", e personalizar comportamentos, como fizemos +# ao sobrescrever o método "exibir_dados()", para adaptar o comportamento da classe filha às necessidades específicas. +``` + + Nome: Ana, Salário: R$ 5000 + Área: TI + + +#### **Em suma, o que significa herdar algo em POO?** + +**Quando uma classe herda de outra, ela automaticamente recebe os atributos e métodos da classe pai. Isso significa que podemos:** + +- **Criar objetos da subclasse e usar métodos da superclasse sem reimplementá-los**. + +- **Adicionar novos atributos e métodos específicos da subclasse**. + +- **Sobrescrever métodos para personalizar o comportamento da subclasse**. + +Por exemplo, Analista herdou exibir_dados() de Funcionario, mas sobrescreveu esse método para exibir também a área de atuação. *(Esse comportamento de sobrescrever métodos é um exemplo clássico de polimorfismo, que veremos com mais detalhes no próximo tópico)* + +### **Polimorfismo** + +#### **Definição intuitiva** + +**Polimorfismo significa 'muitas formas'. Esse conceito permite que classes relacionadas por herança tenham métodos com o mesmo nome, mas comportamentos diferentes.** + +Imagine que uma empresa tem vários tipos de funcionários: estagiários, analistas e gerentes. Todos recebem salário, mas de formas diferentes: + +- Estagiários recebem bolsa-auxílio. + +- Analistas recebem salário fixo. + +- Gerentes podem ter bônus adicionais. + +Se quisermos calcular o pagamento de qualquer funcionário sem nos preocupar com o tipo específico dele, podemos usar o conceito de polimorfismo. + +#### **Polimorfismo na programação** + +Na programação, polimorfismo permite que métodos com o mesmo nome tenham implementações diferentes em classes relacionadas por herança. Isso torna o código mais flexível e reutilizável. + +Vamos ver na prática: + + +```python +# Definição da classe base (superclasse) +class Funcionario: + def __init__(self, nome, salario): + """ + Inicializa os atributos nome e salario. + """ + + self.nome = nome + self.salario = salario + + def calcular_pagamento(self): + """ + Retorna o salário do funcionário. Este método pode ser sobrescrito em subclasses. + """ + + return self.salario + +# Subclasse Estagiario herdando de Funcionario +class Estagiario(Funcionario): + def __init__(self, nome, bolsa_auxilio): + """ + Chama o construtor da superclasse passando a bolsa_auxilio como salário. + """ + + super().__init__(nome, bolsa_auxilio) + + def calcular_pagamento(self): + """ + Sobrescreve o método calcular_pagamento da superclasse. + Para estagiários, o pagamento é apenas a bolsa_auxilio (salario no contexto da superclasse). + """ + + return self.salario + +# Subclasse Gerente herdando de Funcionario +class Gerente(Funcionario): + def __init__(self, nome, salario, bonus): + """ + Chama o construtor da superclasse e adiciona o atributo bonus. + """ + + super().__init__(nome, salario) + self.bonus = bonus + + def calcular_pagamento(self): + """ + Sobrescreve o método calcular_pagamento da superclasse. + Para gerentes, o pagamento inclui o salário e um bônus adicional. + """ + + return self.salario + self.bonus + +# Criando objetos de diferentes classes +funcionario1 = Funcionario("Carlos", 5000) +estagiario1 = Estagiario("Ana", 2000) +gerente1 = Gerente("Mariana", 8000, 2000) + +# Chamando o mesmo método para diferentes tipos de funcionários +print(funcionario1.calcular_pagamento()) # 5000 +print(estagiario1.calcular_pagamento()) # 2000 +print(gerente1.calcular_pagamento()) # 10000 (salário + bônus) + +# O que aconteceu aqui? +# Mesmo que Funcionario, Estagiario e Gerente tenham o método calcular_pagamento(), +# cada um se comporta de forma diferente. Isso é polimorfismo! +``` + + 5000 + 2000 + 10000 + + +#### **Em Resumo** + +- Polimorfismo permite que diferentes classes tenham métodos com o mesmo nome, mas comportamentos diferentes. + +- Ele torna o código mais genérico e reutilizável, pois podemos tratar objetos de diferentes classes de forma uniforme. + +# **Módulo 3 - Projeto Final, Curiosidades e Conclusões** + +## **Projeto Final** + +### **Contexto** + +#### **📊 O que é uma Estratégia Quantitativa?** + +Uma estratégia quantitativa é uma abordagem de investimento baseada em modelos matemáticos, estatísticos e computacionais para tomar decisões no mercado financeiro. Essas estratégias utilizam dados históricos e algoritmos para identificar padrões e executar operações de compra e venda de ativos de forma sistemática, reduzindo a influência de emoções humanas. + +#### **🔍 O que é um Backtest e Por que Ele é Importante?** + + +Um backtest é o processo de testar uma estratégia de investimento utilizando dados históricos para avaliar seu desempenho antes de aplicá-la no mercado real. Esse processo é essencial para entender como uma estratégia teria se comportado em diferentes cenários do passado. + +#### **✅ Por que fazer um backtest?** + +Realizar um backtest oferece diversas vantagens que ajudam a tomar decisões mais informadas e seguras: + +✔ Permite testar uma estratégia sem arriscar dinheiro real. + +✔ Identifica pontos fortes e fracos do modelo antes da implementação. + +✔ Ajuda a ajustar parâmetros e melhorar a robustez da estratégia. + +✔ Evita decisões baseadas apenas em intuição, utilizando dados e evidências. + +Com esses benefícios em mente, é fundamental contar com ferramentas que tornem o processo de backtesting mais eficiente e preciso. É aqui que entra o **Backtrader**. + +#### **🚀 Como o Backtrader Facilita o Backtest?** + +O Backtrader é uma biblioteca em Python projetada para automatizar o processo de backtesting, permitindo testar múltiplas estratégias com diferentes parâmetros de forma rápida e eficiente. Ele simplifica o trabalho de traders e analistas, tornando o desenvolvimento de estratégias quantitativas mais acessível. + +**Vantagens do Backtrader**: + +✔ Simulação realista → Gerencia a execução de ordens e a gestão de capital automaticamente. + +✔ Suporte a múltiplos ativos → Teste estratégias em diversas ações, moedas e commodities. + +✔ Indicadores embutidos → Inclui dezenas de indicadores como RSI, MACD e Médias Móveis. + +✔ Visualização gráfica → Permite gerar gráficos detalhados com o desempenho da estratégia. + +**Como essa biblioteca se relaciona com POO?** + +- Abstração → O usuário apenas interage com a API sem precisar entender os detalhes internos do funcionamento do backtesting. + +- Encapsulamento → Os dados do mercado e as regras de estratégia são protegidos e acessados apenas por métodos específicos. + +- Herança → Criamos novas estratégias herdando da classe base bt.Strategy, evitando repetição de código. + +- Polimorfismo → Diferentes estratégias podem ser implementadas, e todas interagem com o sistema de backtesting da mesma forma. + +Em suma, o Backtrader transforma o processo de criação e teste de estratégias quantitativas em algo mais fácil, rápido e confiável. Com ele, traders e analistas podem validar suas ideias com dados históricos, ajustá-las conforme necessário e aplicá-las no mercado real com muito mais confiança. + +#### **🔧 Sobre o Backtrader** + +##### **1. bt.Strategy: A Classe Base das Estratégias** + +**O que é?** + +bt.Strategy é a classe base no Backtrader que define como criar estratégias de trading. Para implementar uma estratégia, você deve criar uma nova classe que herda dessa classe base. + +**Por que é importante?** + +Isso permite que você defina suas próprias regras de compra e venda, utilizando os métodos e atributos da classe base sem precisar reescrever toda a lógica do backtest. + +##### **2. __init__: Inicializando a Estratégia** + +**O que é?** + +O método __init__ é usado para inicializar os atributos da sua estratégia, como indicadores técnicos (Médias Móveis, RSI, etc.). É aqui que você define o que será usado para tomar decisões. + +**Exemplo:** + +```python + def __init__(self): + # Inicializa dois indicadores de Média Móvel Simples (SMA). + + # Cria uma média móvel simples de curto prazo (10 períodos) usando o preço de fechamento dos dados fornecidos. + self.ma_short = bt.indicators.SimpleMovingAverage(self.data.close, period=10) + + # Cria uma média móvel simples de longo prazo (30 períodos) usando o preço de fechamento dos dados fornecidos. + self.ma_long = bt.indicators.SimpleMovingAverage(self.data.close, period=30) +``` + +##### **3. next: Definindo a Lógica da Estratégia** + +**O que é?** + +O método next é chamado a cada novo dado (cada candle diário, por exemplo). Aqui você define quando comprar ou vender com base nos seus indicadores. + +**Exemplo:** +```python + def next(self): + if self.ma_short[0] > self.ma_long[0]: # Se a média curta cruzar acima da longa + self.buy() # Comprar + elif self.ma_short[0] < self.ma_long[0]: # Se a média curta cruzar abaixo da longa + self.sell() # Vender +``` + +##### **4. Cerebro: O Cérebro do Backtrader** + +**O que é?** +Cerebro é o motor do Backtrader que executa o backtest. Ele gerencia a estratégia, os dados, a alocação de capital e gera os resultados. + +**Funções principais:** + +- Adicionar a estratégia: cerebro.addstrategy(SuaEstrategia) + +- Adicionar dados: cerebro.adddata(dados) + +- Executar o backtest: cerebro.run() + +- Plotar resultados: cerebro.plot() + +##### **5. Dados: Alimentando o Backtest** + +**O que é?** + +O Backtrader aceita diferentes fontes de dados, como arquivos CSV ou dados do Yahoo Finance. + +**Exemplo (Yahoo Finance):** + +```python + from backtrader.feeds import YahooFinanceData + dados = YahooFinanceData(dataname='AAPL', fromdate=datetime(2020, 1, 1), todate=datetime(2023, 1, 1)) +``` + +##### **6. Indicadores Técnicos no Backtrader** + +**O que é?** +O Backtrader já vem com diversos indicadores técnicos, como Médias Móveis, RSI, MACD, entre outros. + +**Exemplo (Média Móvel):** +```python + self.ma = bt.indicators.SimpleMovingAverage(self.data.close, period=20) +``` + +##### **7. Visualização Gráfica** + +**O que é?** + +O Backtrader gera gráficos automáticos mostrando o desempenho da sua estratégia. + +**Exemplo:** + +```python + cerebro.plot() +``` + +### **📌 Projeto Final: Estratégia de Trading Orientada a Objetos com Backtrader** + +Neste projeto final, desenvolveremos um sistema de backtesting de estratégias de trading utilizando a biblioteca Backtrader. O objetivo é integrar de forma prática e aprofundada os 4 pilares da Programação Orientada a Objetos (POO) — Abstração, Encapsulamento, Herança e Polimorfismo — juntamente com os conceitos fundamentais de Classes, Atributos, Métodos e Objetos. + +#### **🛠️ O que vocês terão que fazer** + +##### **1. Configuração do Ambiente** + +**Instalar o Backtrader** + +Execute o seguinte comando no terminal para instalar a biblioteca: + + +```python +!pip install backtrader +``` + + Defaulting to user installation because normal site-packages is not writeable + Requirement already satisfied: backtrader in /home/user/.local/lib/python3.10/site-packages (1.9.78.123) + + +**Obter Dados Históricos** + +Baixe um dataset de ações de empresas como Apple (AAPL) ou Google (GOOGL) utilizando o Yahoo Finance. Porém, antes disso você precisara instalar essa biblioteca. Para tal, utilize o seguinte comando: + + +```python +!pip install yfinance +``` + + Defaulting to user installation because normal site-packages is not writeable + Requirement already satisfied: yfinance in /home/user/.local/lib/python3.10/site-packages (0.2.52) + Requirement already satisfied: frozendict>=2.3.4 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (2.4.4) + Requirement already satisfied: requests>=2.31 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (2.31.0) + Requirement already satisfied: multitasking>=0.0.7 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (0.0.11) + Requirement already satisfied: html5lib>=1.1 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (1.1) + Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (4.12.3) + Requirement already satisfied: pandas>=1.3.0 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (2.2.3) + Requirement already satisfied: pytz>=2022.5 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (2024.1) + Requirement already satisfied: lxml>=4.9.1 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (5.2.2) + Requirement already satisfied: numpy>=1.16.5 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (1.24.3) + Requirement already satisfied: peewee>=3.16.2 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (3.17.6) + Requirement already satisfied: platformdirs>=2.0.0 in /home/user/.local/lib/python3.10/site-packages (from yfinance) (4.2.0) + Requirement already satisfied: soupsieve>1.2 in /home/user/.local/lib/python3.10/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.5) + Requirement already satisfied: webencodings in /home/user/.local/lib/python3.10/site-packages (from html5lib>=1.1->yfinance) (0.5.1) + Requirement already satisfied: six>=1.9 in /usr/lib/python3/dist-packages (from html5lib>=1.1->yfinance) (1.16.0) + Requirement already satisfied: python-dateutil>=2.8.2 in /home/user/.local/lib/python3.10/site-packages (from pandas>=1.3.0->yfinance) (2.9.0.post0) + Requirement already satisfied: tzdata>=2022.7 in /home/user/.local/lib/python3.10/site-packages (from pandas>=1.3.0->yfinance) (2024.1) + Requirement already satisfied: certifi>=2017.4.17 in /home/user/.local/lib/python3.10/site-packages (from requests>=2.31->yfinance) (2024.12.14) + Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests>=2.31->yfinance) (3.3) + Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/lib/python3/dist-packages (from requests>=2.31->yfinance) (1.26.5) + Requirement already satisfied: charset-normalizer<4,>=2 in /home/user/.local/lib/python3.10/site-packages (from requests>=2.31->yfinance) (3.3.2) + + +**Importação das Bibliotecas Essenciais** + +Na célula abaixo, importem as bibliotecas que considerarem necessárias para o desenvolvimento do projeto. Lembrem que talvez vocês precisem instalar alguma delas. Para começar, já incluímos algumas bibliotecas fundamentais que facilitarão o processo: + + +```python +# Importa o Backtrader, uma biblioteca de backtesting para estratégias de trading +import backtrader as bt + +# Importa o yFinance, utilizado para baixar dados financeiros históricos diretamente do Yahoo Finance +import yfinance as yf + +# Importa a classe datetime para manipulação de datas +from datetime import datetime + +# Importa o pandas, biblioteca essencial para análise e manipulação de dados em formato de DataFrames +import pandas as pd + +# Importa o matplotlib.pyplot, biblioteca para criação de gráficos e visualizações de dados +import matplotlib.pyplot as plt + +``` + +##### **2. Desenvolvimento da Estratégia de Trading com POO** + +**Criar uma Classe para a Estratégia** +Definam uma classe que herde de bt.Strategy, que será o coração do seu projeto. Essa classe deve conter: + +- Atributos: Definam indicadores técnicos, como médias móveis de curto e longo prazo. + +- Métodos: + - __ init __: Inicializa os indicadores e variáveis da estratégia. + - next: Define a lógica de compra e venda baseada nos sinais dos indicadores. + + +**Exemplo:** + + +```python +# Definimos uma classe de estratégia que herda da classe base bt.Strategy do Backtrader. +# Isso é um exemplo de **Herança** em Programação Orientada a Objetos (POO), permitindo que nossa estratégia utilize +# todas as funcionalidades embutidas da classe Strategy, como controle de posições e execução de ordens. +class MovingAverageCrossStrategy(bt.Strategy): + + # O método __init__ é chamado uma vez no início da execução da estratégia. + # Usamos esse método para inicializar os **atributos** da nossa estratégia, como indicadores técnicos. + def __init__(self): + # Criamos um indicador de Média Móvel Simples (SMA) de 10 períodos sobre o preço de fechamento dos dados. + # 'self.ma_short' é um atributo que guarda a média móvel curta, que reage mais rapidamente às mudanças de preço. + self.ma_short = bt.indicators.SimpleMovingAverage(self.data.close, period=10) + + # Criamos outro indicador de Média Móvel Simples (SMA), agora de 30 períodos. + # 'self.ma_long' é um atributo que guarda a média móvel longa, que é mais lenta para reagir às variações do preço. + self.ma_long = bt.indicators.SimpleMovingAverage(self.data.close, period=30) + + # O método next é chamado automaticamente pelo Backtrader a cada novo "candle" ou barra de dados (ex.: diário, horário). + # É aqui que definimos a **lógica de compra e venda** da nossa estratégia. + def next(self): + # Condição para compra: + # Se a média móvel curta (ma_short) cruzar acima da média móvel longa (ma_long), + # e ainda **não temos uma posição aberta** (not self.position), então executamos uma compra. + + # O que é self.position? + # 'self.position' é um atributo do Backtrader que indica se já temos uma posição aberta no ativo. + # Se não houver posição aberta, 'self.position' é avaliado como False (ou 0). + # Se estivermos comprados, 'self.position' é True (ou o número de unidades compradas). + + if self.ma_short[0] > self.ma_long[0] and not self.position: + self.buy() # Método do Backtrader que executa uma ordem de compra. + + # Quanto é comprado? + # Por padrão, o método 'self.buy()' compra 1 unidade do ativo. + # Para comprar uma quantidade específica, podemos passar o argumento 'size', por exemplo: self.buy(size=100). + + # Condição para venda: + # Se a média móvel curta cruzar abaixo da média móvel longa, + # e **já temos uma posição aberta** (self.position), então vendemos. + elif self.ma_short[0] < self.ma_long[0] and self.position: + self.sell() # Método do Backtrader que executa uma ordem de venda. + + # Quanto é vendido? + # Por padrão, 'self.sell()' vende todas as unidades do ativo que foram compradas anteriormente, encerrando a posição. + # Para vender uma quantidade específica (por exemplo, vender parcialmente), podemos usar: self.sell(size=50). + +``` + +##### **3. Executar o Backtest:** + +Com a estratégia pronta, configurem e executem o backtest usando o Cerebro, o motor de execução do Backtrader. + +**Configurar o Cerebro** + +Inicializem o motor Cerebro, adicionem os dados históricos e a estratégia desenvolvida: + + +```python +# Parâmetros relacionados a captura de dados do ticker. +ticker = 'AAPL' +start_date = '2020-01-01' +end_date = '2021-01-01' + +# Baixando os dados do ticker com auto ajuste +data = yf.download(ticker, start=start_date, end=end_date, auto_adjust=True) + +# Verificando e ajustando as colunas para o formato correto +if isinstance(data.columns, pd.MultiIndex): + data.columns = data.columns.get_level_values(0) # Remove o MultiIndex + +# Carregando os dados no Backtrader +data_feed = bt.feeds.PandasData(dataname=data) + +# Inicializando o Cerebro +cerebro = bt.Cerebro() +cerebro.adddata(data_feed) +cerebro.addstrategy(MovingAverageCrossStrategy) +``` + + [*********************100%***********************] 1 of 1 completed + + + + + + 0 + + + +**Executar o Backtest** + +Rodem o backtest e visualizem o desempenho: + + +```python +# Setando o valor inicial a ser investido na estratégia +initial_cash = 15000 + +# Definindo o saldo inicial +cerebro.broker.set_cash(initial_cash) + +# Executando o backtest +cerebro.run() + +# Capturando o saldo final +final_cash = cerebro.broker.getvalue() + +# Exibindo os resultados +print(f'Saldo inicial: ${initial_cash:.2f}') +print(f'Saldo final: ${final_cash:.2f}') +print(f'Lucro/Prejuízo: ${final_cash - initial_cash:.2f}') + +# Plota o gráfico e salva como PNG +fig = cerebro.plot()[0][0] +filename = f'backtest_{ticker}_{start_date}_to_{end_date}.png' +fig.savefig(f'backtest_{ticker}_{start_date}_to_{end_date}.png') +print(f'O gráfico foi salvo como {filename}. \nEsse é um gráfico bastante poluído, mas, se tiver interesse, existem formas de mudá-lo, basta uma rápida pesquisa :)') + +``` + + Saldo inicial: $15000.00 + Saldo final: $15025.05 + Lucro/Prejuízo: $25.05 + + + + + + + +
+ + + O gráfico foi salvo como backtest_AAPL_2020-01-01_to_2021-01-01.png. + Esse é um gráfico bastante poluído, mas, se tiver interesse, existem formas de mudá-lo, basta uma rápida pesquisa :) + + +## **POO na Prática: O Que Você Já Usava Sem Perceber** + +### **1. Pandas e NumPy São Baseados em POO** + +Quando vocês criam um DataFrame no Pandas ou uma matriz no NumPy, estão na verdade instanciando objetos de classes que já foram definidas pelos desenvolvedores dessas bibliotecas! + +🔹 Exemplo: Quando usamos: + +```python + import pandas as pd + + df = pd.DataFrame({"Nome": ["Ana", "Carlos"], "Idade": [25, 30]}) + print(df.shape) # Atributo + print(df.describe()) # Método +``` + +Aqui, df é um objeto da classe DataFrame, e .shape e .describe() são atributos e métodos, exatamente como vocês aprenderam! + +🔹 O mesmo acontece no NumPy: + +```python + import numpy as np + + matriz = np.array([[1, 2], [3, 4]]) + print(matriz.T) # Transposta (método) + print(matriz.shape) # Dimensão (atributo) +``` + +Agora fica claro que tudo isso são apenas classes bem projetadas! + +### **2. Strings, Listas e Dicionários Também São Objetos** + +Vocês já usaram .upper(), .append() e .items() centenas de vezes, certo? Agora vocês sabem que esses são métodos das classes str, list e dict. + +🔹 Exemplo: + +```python + texto = "hello" + print(texto.upper()) # Método da classe str + + lista = [1, 2, 3] + lista.append(4) # Método da classe list + + dicionario = {"chave": "valor"} + print(dicionario.items()) # Método da classe dict +``` + +Cada um desses tipos é uma classe que disponibiliza métodos específicos sem que precisemos nos preocupar com sua implementação interna! + +### **3. Modelos de Machine Learning São Objetos!** + +Se você já usou Scikit-Learn, viu que um modelo precisa ser instanciado, treinado e testado – tudo isso são conceitos de POO. + +🔹 Exemplo: + +```python + from sklearn.linear_model import LinearRegression + + modelo = LinearRegression() # Criando um objeto da classe LinearRegression + modelo.fit(X_train, y_train) # Método para treinar o modelo + y_pred = modelo.predict(X_test) # Método para prever valores +``` + +O modelo é um objeto, e .fit() e .predict() são métodos que manipulam esse objeto! + +### Esses são apenas alguns exemplos, mas o mundo da programação está repleto de aplicações da POO. Frameworks como Django para desenvolvimento web, bibliotecas de visualização como Matplotlib e até ferramentas de automação seguem esses mesmos princípios. Agora que você entende a base por trás dessas estruturas, conseguirá identificar a POO em quase todos os códigos que encontrar. + +## **Conclusão: POO é uma Nova Forma de Pensar Programação** + +Ao longo dessa jornada, exploramos os conceitos fundamentais da Programação Orientada a Objetos (POO) e como eles se aplicam tanto na teoria quanto na prática. Aprendemos que POO não é apenas um conjunto de regras ou palavras-chave, mas sim uma forma diferente de estruturar e organizar nossos programas. + +Através de abstração, encapsulamento, herança e polimorfismo, vimos como é possível criar sistemas modulares, reutilizáveis e mais fáceis de manter. Mais do que isso, percebemos que essas ideias não estão isoladas do nosso dia a dia: bibliotecas que usamos o tempo todo, como Pandas e NumPy, foram construídas seguindo esses princípios. + +Agora que vocês conhecem POO, conseguem enxergar que quase tudo o que usamos em Python segue esse modelo. O conhecimento que vocês adquiriram não serve apenas para criar classes do zero, mas também para entender como as bibliotecas funcionam internamente e até para desenvolver códigos mais eficientes e organizados. 🚀💡 + +POO também não se limita a uma única área. Seja no mercado financeiro, inteligência artificial, desenvolvimento web ou até mesmo em jogos, essa abordagem pode tornar o código mais intuitivo e escalável. Cada problema pode ser resolvido de diferentes formas, e POO nos dá uma maneira poderosa de estruturar nossas soluções. + +Agora que você compreende esses conceitos, vale a pena revisitar códigos antigos e tentar enxergá-los com essa nova perspectiva. Você vai perceber como muitas das ferramentas que já usa são baseadas nesses mesmos princípios! 🚀 diff --git a/content/03-ciencia-de-dados/index.md b/content/03-ciencia-de-dados/index.md index dc0953571..1c4d433ea 100644 --- a/content/03-ciencia-de-dados/index.md +++ b/content/03-ciencia-de-dados/index.md @@ -4,6 +4,36 @@ title: Ciência de dados >[!warning] > Se você é membro da dev e quer contribuir com algum material, se liga no **Guia do Hub** disponível na seção Extras: [[../05-guiahub/01-guia-onboarding-hub|Guia do Hub]] -## Destaques Recentes: +## O que é a trilha de Ciência de Dados? -(colocar acho que 5 redirecionamentos para os nossos melhores projetos) +A trilha de **Ciência de Dados** é o eixo do Hub dedicado à **coleta, organização, tratamento e análise de dados**, com foco em construir **pipelines robustos, reprodutíveis e bem documentados**. +Aqui integramos de forma estruturada: + +- **ETL / ELT e engenharia de dados “de base”** + (ingestão de arquivos, APIs, bancos de dados; limpeza, transformação e padronização) +- **Web Scraping e automação** + (requests, parsing de HTML/JSON, agendamento de rotinas, respeito a limites e boas práticas) +- **Análise exploratória e visualização** + (EDA, estatísticas descritivas, gráficos, identificação de outliers e data quality) +- **Boas práticas de código e organização de projeto** + (estrutura de pastas, funções reutilizáveis, logging, testes básicos, versionamento com Git) + +O objetivo é dar visibilidade aos projetos criados internamente e organizar materiais que mostrem **como se projeta e implementa um fluxo de dados de ponta a ponta** – desde a captura da informação até a entrega de tabelas, relatórios e bases prontas para modelos de IA, finanças quantitativas ou análises aplicadas. + +--- + +## Pra quem é essa trilha? + +> 👇 Se você se identificou com pelo menos um ponto, essa trilha é pra você: + +- Quer aprender **ETL, Web Scraping e manipulação de dados em Python/SQL** +- Gosta de **automatizar tarefas repetitivas** (coleta de dados, relatórios, atualizações de planilhas) +- Quer entender **como cientistas de dados e engenheiros de dados** preparam bases antes da modelagem +- Está se preparando para **estágios/trainees em dados, BI, analytics, engenharia de dados ou áreas quantitativas** + +Não precisa já dominar tudo – o importante é estar disposto a **estruturar melhor seus códigos, se preocupar com qualidade de dados e compartilhar boas práticas**. + +--- +## Como navegar pela trilha + +Use o menu à baixo para acessar os conteúdos de cada semestre: diff --git a/content/04-extras/2025-s2/Lorem-Ipsum-Document.md b/content/04-extras/2025-s2/Lorem-Ipsum-Document.md deleted file mode 100644 index 00cfe6bc4..000000000 --- a/content/04-extras/2025-s2/Lorem-Ipsum-Document.md +++ /dev/null @@ -1,56 +0,0 @@ ---- -title: Lorem Ipsum Document -tags: - - "#nivel/basico" - - "#trilha/extras" ---- - -# Lorem Ipsum Document - -# Introduction - -Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. - -# Section 1: Detailed Placeholder Content - -This section demonstrates the use of various placeholders in a mock document setting. - -## Subsection 1.1: Dates and People - -We plan to finalize the initial draft by Date. The main point of contact for this phase will be Person. Please ensure that all team members, including Person, review the content before the deadline. - -## Subsection 1.2: Location and Files - -The next project meeting is scheduled to take place at Place. All attendees should bring a copy of the revised project brief, which is available in the File file. - -## Subsection 1.3: Key Meetings and Events - -Remember to add the link for the Project Kickoff meeting: Calendar event. This event is mandatory for all core team members. The subsequent training session, focusing on new software, should also have its calendar link reserved: Calendar event. - -# Section 2: Tabular Data Example - -The following table provides a mock overview of tasks, assignees, and their status. - -| Task ID | Description | Assignee | Status | -| :---- | :---- | :---- | :---- | -| A001 | Initial Data Collection | Person | Pending | -| A002 | Outline Creation | Person | In Progress | -| A003 | Document Review | Person | Complete | -| A004 | Final Approval | Person | Pending | -| A005 | Resource Allocation | Person | Complete | - -# Section 3: Lists and Visual Elements - -A list of essential resources for this project is provided below. - -* Project Requirements Document: File -* Meeting Minutes Archive: File -* Team Contact List: File - -![An abstract, professional image of digital shapes overlapping to represent mock data flow and collaboration][image1] - -# Conclusion - -Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. This document serves purely as a mock-up to test document formatting and placeholder usage. - -[image1]: \ No newline at end of file diff --git a/content/04-extras/index.md b/content/04-extras/index.md index cf0b9a71f..b96faaa0d 100644 --- a/content/04-extras/index.md +++ b/content/04-extras/index.md @@ -3,6 +3,36 @@ title: Extras --- >[!warning] > Se você é membro da dev e quer contribuir com algum material, se liga no **Guia do Hub** disponível na seção Extras: [[../05-guiahub/01-guia-onboarding-hub|Guia do Hub]] -## Destaques Recentes: -(colocar acho que 5 redirecionamentos para os nossos melhores projetos) +## O que é a trilha Extras? + + A trilha de **Extras** reúne conteúdos de **infraestrutura técnica e ferramentas** que serve como complemento as outras trilhas do Hub. +Aqui entram materiais que não são de uma área específica (FinQuant, IA ou Ciência de Dados), mas que são fundamentais para **trabalhar bem em time, versionar código e dominar o ecossistema de desenvolvimento**: + +- **Git e GitHub** + (workflow com branches, pull requests, resolução de conflitos, boas práticas de commit) +- **Outras linguagens de programação e ferramentas de apoio** + (bash/shell, uso de terminais, scripts auxiliares, noções de C/C++, Java, JavaScript/TypeScript etc.) +- **Ambiente de desenvolvimento e produtividade** + (VS Code, extensões úteis, conda/venv, organização de projetos, snippets, automações) +- **Materiais gerais de programação, algoritmos e boas práticas** + (estilo de código, estruturação de pastas, documentação mínima, testes básicos) + +O objetivo é concentrar aqui tudo o que **aumenta a qualidade e a eficiência do trabalho técnico**, independentemente da trilha principal do projeto. + +--- + +## Pra quem é essa trilha? + +> 👇 Se você se identificou com pelo menos um ponto, vale explorar os materiais de Extras: + +- Quer **entender melhor Git/GitHub** e parar de “apanhar” de merge, conflitos e branches +- Está montando ou melhorando seu **ambiente de desenvolvimento** (editor, terminal, Python, etc.) +- Quer aprender **conceitos de programação** que se aplicam em qualquer trilha (estrutura de código, funções, módulos, testes) +- Gosta de explorar **novas linguagens** ou ferramentas úteis para projetos da dev + +--- + +## Como navegar pela trilha? + +Use o menu à baixo para acessar os conteúdos de cada semestre: diff --git a/content/index.md b/content/index.md index cbf78c937..8e68e1282 100644 --- a/content/index.md +++ b/content/index.md @@ -3,7 +3,6 @@ title: Hub.dev description: Notas, finanças quantitativas e IA. enableToc: false --- - # Bem-vindo! > [!info] O que é o Hub?