juancerqueirabr

[juancerqueirabr]

Limpeza e tratamento de dados são etapas essenciais no processo de análise de dados. Utilizando Python, podemos empregar bibliotecas como pandas para executar essas tarefas de forma eficiente. A seguir, apresento um guia básico sobre como limpar e tratar dados utilizando pandas:

### Passo 1: Importar Bibliotecas Necessárias

```python

import pandas as pd

import numpy as np

```

### Passo 2: Carregar os Dados

Carregue seus dados em um DataFrame. Por exemplo, se seus dados estiverem em um arquivo CSV:

```python

df = pd.read_csv('seu_arquivo.csv')

```

### Passo 3: Examinar os Dados

Verifique as primeiras linhas do DataFrame para ter uma ideia dos dados:

```python

print(df.head())

```

### Passo 4: Verificar Valores Faltantes

Identifique valores ausentes em suas colunas:

```python

print(df.isnull().sum())

```

### Passo 5: Tratamento de Valores Faltantes

Existem várias abordagens para lidar com valores ausentes:

- **Remover Linhas/Colunas com Valores Faltantes**:

```python

df.dropna(inplace=True) # Remove linhas com qualquer valor faltante

# df.dropna(axis=1, inplace=True) # Remove colunas com qualquer valor faltante

```

- **Substituir Valores Faltantes**:

```python

df.fillna(value='substituto', inplace=True) # Substitui valores faltantes com 'substituto'

df['coluna'].fillna(df['coluna'].mean(), inplace=True) # Substitui valores faltantes pela média da coluna

```

### Passo 6: Remover Duplicatas

Remova linhas duplicadas:

```python

df.drop_duplicates(inplace=True)

```

### Passo 7: Correção de Tipos de Dados

Verifique e converta tipos de dados, se necessário:

```python

print(df.dtypes)

# Exemplo de conversão

df['coluna'] = df['coluna'].astype('int')

```

### Passo 8: Manipulação de Strings

Limpe e padronize strings:

```python

df['coluna'] = df['coluna'].str.strip() # Remove espaços em branco no início e no fim

df['coluna'] = df['coluna'].str.lower() # Converte para minúsculas

```

### Passo 9: Tratamento de Outliers

Identifique e trate outliers. Um método comum é usar o IQR (Intervalo Interquartil):

```python

Q1 = df['coluna'].quantile(0.25)

Q3 = df['coluna'].quantile(0.75)

IQR = Q3 - Q1

df = df[~((df['coluna'] < (Q1 - 1.5 * IQR)) | (df['coluna'] > (Q3 + 1.5 * IQR)))]

```

### Passo 10: Renomear Colunas

Renomeie colunas para tornar os nomes mais descritivos:

```python

df.rename(columns={'antigo_nome': 'novo_nome'}, inplace=True)

```

### Exemplo Completo

Aqui está um exemplo completo que reúne algumas dessas etapas:

```python

import pandas as pd

# Carregar os dados

df = pd.read_csv('seu_arquivo.csv')

# Examinar os dados

print(df.head())

# Verificar valores faltantes

print(df.isnull().sum())

# Tratar valores faltantes

df.fillna(df.mean(), inplace=True)

# Remover duplicatas

df.drop_duplicates(inplace=True)

# Corrigir tipos de dados

df['data'] = pd.to_datetime(df['data'])

# Limpar strings

df['nome'] = df['nome'].str.strip().str.lower()

# Tratar outliers

Q1 = df['valor'].quantile(0.25)

Q3 = df['valor'].quantile(0.75)

IQR = Q3 - Q1

df = df[~((df['valor'] < (Q1 - 1.5 * IQR)) | (df['valor'] > (Q3 + 1.5 * IQR)))]

# Renomear colunas

df.rename(columns={'nome_antigo': 'nome_novo'}, inplace=True)

# Verificar o resultado final

print(df.head())

```

Esses passos fornecem uma base sólida para a limpeza e tratamento de dados com Python. Dependendo dos dados e do contexto, você pode precisar adaptar e expandir essas etapas.

[juancerqueirabr]

Erros de iniciantes na programação

🔍 1. Ficar só na teoria, assistindo aulas de cursos e copiando código das aulas Ficar só vendo aulas não vai te levar a lugar nenhum! Não adianta se não colocar a mão na massa. Comece a criar seus próprios projetos e resolver problemas reais.

🧠 2. Ignorar a Lógica de Programação Sem lógica, você está ferrado. Aprenda a pensar como um programador, e o único jeito de fazer isso é praticando muito!

🎯 3. Estudar mais que uma linguagem de uma vez Foque em uma linguagem até dominá-la. Depois, vá para a próxima. Se você estudar mais que uma ao mesmo tempo, vai ser ruim em todas.

📉 4. Culpar o Mercado “Saturado” Mercado saturado é desculpa de preguiçoso. Sempre tem espaço para quem é bom e se destaca. Se diferencie e prove seu valor! Aprenda a vender suas habilidades e a se posicionar no mercado.

📝 5. Copiar Códigos Sem Entender Copiar e colar código é normal, mas entenda o que cada linha faz antes de colar, ou você só vai virar um zumbi programador.

🚫 6. Fazer Projetos Saturados Pokedex e clone de Netflix de novo? Vamos ser criativos! Faça algo original, que resolva problemas reais, não esses projetos padrões.

📚 7. Não Ler Documentações Documentação é a bíblia do programador. Entenda a tecnologia que está usando. Vai te poupar muito tempo.

🔧 8. Ignorar as Bases e Ir Direto para Frameworks Usar direto framework sem entender a base é bomba. Aprenda o básico primeiro, frameworks depois. Saber como as coisas funcionam por trás dos panos te dá uma vantagem enorme.

😨 9. Medo de Aplicar para Vagas Se você nunca tentar, nunca vai conseguir. Envie currículos, mesmo que ache que não está 100% pronto. Experiência vem com a prática! Cada entrevista é uma chance de aprender e melhorar.

[juancerqueirabr]

10 posts!

[juancerqueirabr]

No CSS, há vários tipos de display que controlam como os elementos são renderizados na página. Aqui estão os principais tipos:

1. **`block`**: O elemento �� renderizado como um bloco, ocupando toda a largura disponível. Exemplos incluem `<div>`, `<h1>`, e `<p>`.

2. **`inline`**: O elemento é renderizado na mesma linha que outros elementos, ocupando apenas o espaço necessário. Exemplos incluem `<span>`, `<a>`, e `<strong>`.

3. **`inline-block`**: Combina características de `block` e `inline`. O elemento é renderizado na mesma linha que outros elementos, mas se comporta como um bloco, permitindo definir largura e altura.

4. **`flex`**: Define um contêiner flexível que pode alterar a disposição de seus elementos filhos com flexbox. Exemplos incluem `display: flex` e `display: inline-flex`.

5. **`grid`**: Define um contêiner de grade que pode organizar seus elementos filhos em uma estrutura de grade. Exemplos incluem `display: grid` e `display: inline-grid`.

6. **`none`**: O elemento não é renderizado e não ocupa espaço na página.

7. **`table`**: O elemento é renderizado como uma tabela. Exemplos incluem `display: table`, `display: table-row`, e `display: table-cell`.

8. **`list-item`**: O elemento é renderizado como um item de lista, incluindo marcadores ou números. É usado principalmente com `<li>`.

Cada um desses tipos de display tem um impacto significativo no layout e na renderização dos elementos na página.

[juancerqueirabr]

Existem vários frameworks que permitem o desenvolvimento de aplicações desktop utilizando JavaScript ou TypeScript. Alguns dos mais populares são:

### Electron

- **Descrição**: Electron é um framework que permite criar aplicações desktop usando tecnologias web (HTML, CSS e JavaScript).

- **Características**:

- Utiliza Node.js para a parte backend.

- Usa Chromium para renderizar a interface.

- Muitas aplicações populares como Visual Studio Code, Slack e Discord são feitas com Electron.

- **Vantagens**:

- Grande comunidade e muitos recursos.

- Permite criar aplicações multiplataforma (Windows, macOS, Linux).

- **Desvantagens**:

- Pode resultar em aplicações mais pesadas em termos de uso de memória e armazenamento.

### Tauri

- **Descrição**: Tauri é um framework mais recente que permite criar aplicações desktop com uma pegada mais leve em comparação com o Electron.

- **Características**:

- Usa uma renderização nativa, o que geralmente resulta em uma menor pegada de memória.

- Suporta JavaScript, TypeScript e Rust para o backend.

- **Vantagens**:

- Menor consumo de recursos.

- Rápida evolução e boas práticas de segurança.

- **Desvantagens**:

- Comunidade e ecossistema menores comparados ao Electron.

### NW.js (anteriormente conhecido como Node-Webkit)

- **Descrição**: NW.js permite criar aplicações desktop usando Node.js e tecnologias web.

- **Características**:

- Integrado com Node.js.

- Acesso completo às APIs do Node.js diretamente da camada de front-end.

- **Vantagens**:

- Simplicidade de uso.

- Boa integração entre frontend e backend.

- **Desvantagens**:

- Similar ao Electron, pode resultar em aplicações mais pesadas.

### Neutralino.js

- **Descrição**: Neutralino.js é uma alternativa leve ao Electron e NW.js.

- **Características**:

- Usa tecnologias web padrão para a UI.

- Backend pode ser escrito em JavaScript.

- **Vantagens**:

- Muito leve e eficiente.

- Suporte para criar aplicações multiplataforma.

- **Desvantagens**:

- Menos maduro e com menos recursos disponíveis.

Cada um desses frameworks tem suas próprias vantagens e desvantagens, e a escolha do melhor para o seu projeto vai depender dos requisitos específicos, como o desempenho desejado, o tamanho da aplicação, a familiaridade com as tecnologias envolvidas e a necessidade de suporte multiplataforma.

[juancerqueirabr]

Para descobrir os endereços IP do seu computador usando o Prompt de Comando (CMD) no Windows, você pode usar os seguintes comandos:

1. Usando o comando ipconfig

Abrir o Prompt de Comando:

Pressione Windows + R, digite cmd e pressione Enter.

Executar o comando ipconfig:

No Prompt de Comando, digite o seguinte comando e pressione Enter: bash ipconfig

Interpretar a Saída:

A saída mostrará informações sobre todos os adaptadores de rede do seu computador.

Procure por Endereço IPv4 (IPv4 Address) sob as diferentes seções de adaptadores de rede (Ethernet, Wi-Fi, etc.).

O endereço IP será algo como 192.168.1.2 ou 10.0.0.5.

2. Usando o comando getmac

O comando getmac é usado para obter o endereço MAC dos adaptadores de rede, mas também pode mostrar informações sobre os adaptadores ativos.

Executar o comando getmac:

No Prompt de Comando, digite o seguinte comando e pressione Enter: bash getmac

Interpretar a Saída:

A saída mostrará uma lista de adaptadores de rede ativos com seus endereços MAC e nomes de conexões.

3. Usando o comando netsh

Executar o comando netsh:

No Prompt de Comando, digite o seguinte comando e pressione Enter: bash netsh interface ip show addresses

Interpretar a Saída:

A saída mostrará informações detalhadas sobre as interfaces de rede, incluindo endereços IP.

Exemplo de Saída do ipconfig

Adaptador de Rede sem Fio Conexão Local* 1: Sufixo DNS específico de conexão. . . : Endereço IPv6 . . . . . . . . . . . . : fe80::8c6e:30ff:fe97:5d95%4 Endereço IPv4. . . . . . . . . . . . .: 192.168.0.101 Máscara de Sub-rede . . . . . . . . . : 255.255.255.0 Gateway Padrão. . . . . . . . . . . . : 192.168.0.1

Resumo dos Comandos

Mostrar todos os IPs

ipconfig

Mostrar adaptadores ativos e endereços MAC

getmac

Mostrar informações detalhadas das interfaces de rede

netsh interface ip show addresses

Usando esses comandos, você poderá descobrir os endereços IP atribuídos ao seu computador em diferentes interfaces de rede.

[juancerqueirabr]

Organização de endereçamento de IP publico

A administração e a alocação de endereços IP, tanto públicos quanto privados, são geridas por várias organizações globais, regionais e locais. Aqui estão os principais organismos responsáveis pela administração de endereços IP:

Organizações de Administração de Endereços IP

IANA (Internet Assigned Numbers Authority):

Função: IANA é responsável pela alocação global de endereços IP e pela gestão de outros recursos críticos da internet, como números de sistemas autônomos (ASNs) e parâmetros de protocolo.

Operação: IANA opera sob a supervisão da ICANN (Internet Corporation for Assigned Names and Numbers).

ICANN (Internet Corporation for Assigned Names and Numbers):

Função: ICANN supervisiona a IANA e tem a responsabilidade geral pela coordenação do sistema de identificação único da internet, incluindo endereços IP e nomes de domínio.

Objetivo: Garantir a operação estável e segura dos sistemas de endereçamento da internet.

RIRs (Regional Internet Registries):

Função: As RIRs são responsáveis pela alocação e registro de endereços IP dentro de regiões específicas do mundo. Existem cinco RIRs:

ARIN (American Registry for Internet Numbers): América do Norte

RIPE NCC (Réseaux IP Européens Network Coordination Centre): Europa, Oriente Médio e partes da Ásia Central

APNIC (Asia-Pacific Network Information Centre): Ásia e Pacífico

LACNIC (Latin America and Caribbean Network Information Centre): América Latina e Caribe

AFRINIC (African Network Information Centre): África

Operação: As RIRs recebem blocos de endereços IP da IANA e redistribuem esses blocos para ISPs, organizações e outras entidades dentro de suas regiões.

ISPs (Internet Service Providers):

Função: ISPs obtêm blocos de endereços IP de RIRs ou LIRs e os alocam para seus clientes (indivíduos, empresas e organizações).

Operação: Os ISPs podem fornecer endereços IP dinâmicos ou estáticos, dependendo das necessidades e contratos com seus clientes.

Hierarquia de Administração

IANA: Aloca grandes blocos de endereços IP para as RIRs.

RIRs: Distribuem esses blocos para ISPs e outras entidades dentro de suas regiões.

ISPs: Alocam endereços IP aos usuários finais (consumidores, empresas).

Processo de Alocação

IANA Aloca para RIRs: Baseado na demanda e política de alocação.

RIRs Distribuem aos ISPs: Com base em justificativas apresentadas pelos ISPs sobre a necessidade de endereços IP.

ISPs Distribuem aos Clientes: Podem ser alocados como IPs dinâmicos ou estáticos, dependendo do serviço contratado pelo cliente.

Organizações e seus Papéis

IANA: Coordenação global.

ICANN: Supervisão e política.

RIRs: Gestão regional.

ISPs: Distribuição ao usuário final.

A administração de endereços IP é um esforço colaborativo que garante a distribuição ordenada e a utilização eficiente dos recursos limitados de endereçamento da internet, garantindo a operação estável e segura da rede global.

[juancerqueirabr]

estrutura de um BLOG

Para criar um site com serviço (frequentemente referido como um site web com backend) moderno e escalável, você precisa considerar a estrutura em várias camadas, incluindo frontend, backend, banco de dados, e infraestrutura. Aqui está uma visão geral da arquitetura típica de um site com serviço:

1. Frontend (Cliente)

O frontend é a parte visível do site com a qual os usuários interagem diretamente. Pode ser desenvolvido usando várias tecnologias:

HTML: Linguagem de marcação para estruturar o conteúdo da web.

CSS: Folhas de estilo para estilizar o conteúdo HTML.

JavaScript: Linguagem de programação para adicionar interatividade e dinamismo ao site.

Frameworks e Bibliotecas: React, Angular, Vue.js para desenvolver interfaces de usuário dinâmicas e responsivas.

2. Backend (Servidor)

O backend é a parte do site que processa a lógica do servidor, gerencia dados e responde às solicitações dos clientes. Ele pode ser desenvolvido usando várias linguagens e frameworks:

Linguagens de Programação: Python, JavaScript (Node.js), Java, Ruby, PHP, etc.

Frameworks: Django (Python), Flask (Python), Express (Node.js), Spring (Java), Ruby on Rails (Ruby), Laravel (PHP), etc.

APIs: A criação de APIs (RESTful ou GraphQL) para comunicação entre o frontend e o backend.

3. Banco de Dados

O banco de dados armazena os dados do site. A escolha do banco de dados depende dos requisitos do projeto:

Relacionais (SQL): MySQL, PostgreSQL, Oracle Database, Microsoft SQL Server.

Não Relacionais (NoSQL): MongoDB, Redis, DynamoDB, Cassandra.

4. Infraestrutura

A infraestrutura refere-se ao ambiente onde o site é hospedado e como ele é gerenciado e escalado:

Servidores e Hospedagem: AWS, Google Cloud, Azure, DigitalOcean, Heroku, etc.

Containers e Orquestração: Docker para containerização e Kubernetes para orquestração de containers.

CI/CD (Integração Contínua/Entrega Contínua): Jenkins, Travis CI, CircleCI, GitHub Actions para automatizar o pipeline de desenvolvimento e implantação.

5. Segurança

A segurança é crítica em todas as camadas da arquitetura do site:

Autenticação e Autorização: OAuth, JWT, Passport.js.

Certificados SSL/TLS: Para criptografar a comunicação entre o cliente e o servidor.

Proteção contra Ataques: Proteção contra SQL injection, XSS, CSRF, etc.

6. Serviços e Funcionalidades Adicionais

Para adicionar funcionalidades e melhorar a experiência do usuário, você pode integrar vários serviços adicionais:

Serviços de Cache: Redis, Memcached para melhorar o desempenho do site.

Serviços de Mensageria: RabbitMQ, Apache Kafka para comunicação assíncrona.

CDN (Content Delivery Network): Cloudflare, Akamai para distribuir conteúdo e melhorar a velocidade de carregamento.

Exemplo de Estrutura de Projeto

Aqui está um exemplo simplificado de como os arquivos e diretórios podem ser organizados em um projeto típico

 ├── frontend/

    │   ├── public/

    │   │   └── index.html

    │   ├── src/

    │   │   ├── components/

    │   │   ├── pages/

    │   │   ├── App.js

    │   │   └── index.js

    │   ├── package.json

    │   └── webpack.config.js

    ├── backend/

    │   ├── src/

    │   │   ├── controllers/

    │   │   ├── models/

    │   │   ├── routes/

    │   │   ├── services/

    │   │   └── app.js

    │   ├── .env

    │   ├── package.json

    │   └── server.js

    ├── database/

    │   └── schema.sql

    ├── docker-compose.yml

    ├── Dockerfile

    ├── README.md

    └── .gitignore

Descrição dos Diretórios e Arquivos

frontend/: Contém todo o código do frontend.

public/: Arquivos públicos como index.html.

src/: Código fonte do frontend (componentes React/Vue/Angular).

backend/: Contém todo o código do backend.

controllers/: Lida com a lógica das requisições.

models/: Definições dos modelos de dados.

routes/: Definições das rotas da API.

services/: Serviços de negócios e integração com APIs externas.

app.js: Arquivo principal da aplicação.

database/: Scripts de banco de dados.

schema.sql: Definição do esquema do banco de dados.

docker-compose.yml: Arquivo de configuração do Docker Compose para orquestrar serviços.

Dockerfile: Instruções para construir a imagem Docker do projeto.

README.md: Documentação do projeto.

.gitignore: Arquivo para especificar quais arquivos/diretórios devem ser ignorados pelo Git.

Essa estrutura e essas tecnologias podem variar dependendo das necessidades específicas do seu projeto, mas fornecem uma boa base para construir um site com serviço moderno e escalável.

[juancerqueirabr]

O sniffing é uma técnica usada para interceptar e analisar o tráfego de dados em uma rede. Pode ser classificado em vários tipos, dependendo dos métodos e objetivos específicos:

1. **Sniffing passivo**:

- **Definição**: Interceptação do tráfego sem alterar ou enviar pacotes para a rede. É difícil de detectar porque não altera o comportamento normal da rede.

- **Ferramentas comuns**: Wireshark, Tcpdump.

- **Usos**: Captura de senhas, análise de tráfego, detecção de problemas na rede.

2. **Sniffing ativo**:

- **Definição**: Envolve a inserção de pacotes na rede para enganar outros dispositivos ou modificar o fluxo de tráfego. É mais fácil de detectar devido à alteração do tráfego normal.

- **Técnicas**:

- **ARP Spoofing**: Engana dispositivos em uma rede local para enviar dados ao atacante ao falsificar respostas ARP.

- **DNS Spoofing**: Redireciona o tráfego para um site falso, modificando respostas DNS.

- **Ferramentas comuns**: Cain & Abel, Ettercap.

3. **Sniffing em redes cabeadas**:

- **Definição**: Intercepta tráfego em uma rede com cabos físicos (Ethernet).

- **Métodos**:

- **Modo promíscuo**: Configurar a placa de rede para capturar todo o tráfego que passa pelo segmento.

- **Port Mirroring**: Em um switch, duplicar o tráfego de uma porta específica para outra porta onde está conectado o sniffer.

4. **Sniffing em redes sem fio**:

- **Definição**: Intercepta tráfego em redes Wi-Fi.

- **Métodos**:

- **Modo monitor**: Permite que a placa de rede capture todo o tráfego sem fio na área.

- **Captura de pacotes WPA/WPA2**: Interceptar o handshake de autenticação para tentar decifrar a senha.

5. **Sniffing baseado em aplicações**:

- **Definição**: Orientado para interceptar e analisar o tráfego de aplicações específicas.

- **Exemplos**: Captura de tráfego HTTP para obter cookies, interceptação de e-mails.

6. **Sniffing de telefones móveis**:

- **Definição**: Intercepta tráfego de dados de dispositivos móveis, geralmente através de redes Wi-Fi públicas ou pontos de acesso maliciosos.

Esses tipos de sniffing são usados em diferentes contextos e têm várias aplicações, tanto legítimas (como monitoramento de rede) quanto maliciosas (como roubo de informações).

[juancerqueirabr]

JavaScript oferece várias funções nativas para manipulação de arrays. Aqui estão algumas das mais comuns e úteis:

1. **`push` e `pop`**:

- `push`: Adiciona um ou mais elementos ao final do array.

- `pop`: Remove o último elemento do array.

```javascript

let arr = [1, 2, 3];

arr.push(4); // [1, 2, 3, 4]

arr.pop(); // [1, 2, 3]

```

2. **`shift` e `unshift`**:

- `shift`: Remove o primeiro elemento do array.

- `unshift`: Adiciona um ou mais elementos no início do array.

```javascript

let arr = [1, 2, 3];

arr.shift(); // [2, 3]

arr.unshift(0); // [0, 2, 3]

```

3. **`concat`**:

- Junta dois ou mais arrays.

```javascript

let arr1 = [1, 2];

let arr2 = [3, 4];

let arr3 = arr1.concat(arr2); // [1, 2, 3, 4]

```

4. **`slice`**:

- Retorna uma cópia rasa de uma parte do array, sem modificar o array original.

```javascript

let arr = [1, 2, 3, 4];

let slicedArr = arr.slice(1, 3); // [2, 3]

```

5. **`splice`**:

- Adiciona/remova elementos de qualquer posição do array.

```javascript

let arr = [1, 2, 3, 4];

arr.splice(1, 2); // [1, 4]

arr.splice(1, 0, 2, 3); // [1, 2, 3, 4]

```

6. **`map`**:

- Cria um novo array com os resultados de uma função aplicada a cada elemento do array.

```javascript

let arr = [1, 2, 3];

let mappedArr = arr.map(x => x * 2); // [2, 4, 6]

```

7. **`filter`**:

- Cria um novo array com todos os elementos que passam no teste implementado pela função fornecida.

```javascript

let arr = [1, 2, 3, 4];

let filteredArr = arr.filter(x => x > 2); // [3, 4]

```

8. **`reduce`**:

- Aplica uma função a um acumulador e a cada elemento do array (da esquerda para a direita) para reduzi-lo a um único valor.

```javascript

let arr = [1, 2, 3, 4];

let sum = arr.reduce((acc, x) => acc + x, 0); // 10

```

9. **`find` e `findIndex`**:

- `find`: Retorna o primeiro elemento que satisfaz a função de teste.

- `findIndex`: Retorna o índice do primeiro elemento que satisfaz a função de teste.

```javascript

let arr = [1, 2, 3, 4];

let found = arr.find(x => x > 2); // 3

let foundIndex = arr.findIndex(x => x > 2); // 2

```

10. **`sort`**:

- Ordena os elementos do array e retorna o array.

```javascript

let arr = [4, 2, 3, 1];

arr.sort(); // [1, 2, 3, 4]

```

11. **`forEach`**:

- Executa uma função para cada elemento do array.

```javascript

let arr = [1, 2, 3];

arr.forEach(x => console.log(x)); // 1 2 3

```

Essas são algumas das principais funções de manipulação de array em JavaScript. Elas permitem realizar uma ampla gama de operações para trabalhar com dados de maneira eficiente e concisa.

[juancerqueirabr]

VsCode

Aqui estão alguns atalhos úteis para o Visual Studio Code (VS Code):

Navegação

Abrir arquivo rapidamente: Ctrl + P

Alternar entre arquivos abertos: Ctrl + Tab

Navegar para a definição: F12

Voltar para a posição anterior: Alt + ←

Avançar para a posição seguinte: Alt + →

Edição

Copiar linha abaixo: Shift + Alt + ↓

Mover linha para cima/baixo: Alt + ↑ / Alt + ↓

Duplicar linha: Shift + Alt + ↓

Excluir linha: Ctrl + Shift + K

Comentar/descomentar linha: Ctrl + /

Comentar em bloco: Shift + Alt + A

Formatar documento: Shift + Alt + F

Seleção

Selecionar tudo: Ctrl + A

Expandir seleção: Shift + Alt + →

Reduzir seleção: Shift + Alt + ←

Selecionar a mesma palavra em vários lugares: Ctrl + D

Selecionar todas as ocorrências da palavra atual: Ctrl + Shift + L

Gerenciamento de Janelas e Terminais

Abrir um novo terminal: `Ctrl + Shift + ``

Alternar entre editor e terminal: `Ctrl + ``

Dividir o editor (horizontal): Ctrl + \

Alternar entre grupos de editores: Ctrl + 1 / Ctrl + 2 / Ctrl + 3

Pesquisa e Substituição

Abrir pesquisa: Ctrl + F

Abrir pesquisa em arquivos: Ctrl + Shift + F

Abrir substituição: Ctrl + H

Controle de Código-Fonte

Abrir controle de código-fonte: Ctrl + Shift + G

Commit de alterações: Ctrl + Enter (dentro do painel de controle de código-fonte)

Outros Atalhos Úteis

Abrir configurações: Ctrl + ,

Alternar barra lateral: Ctrl + B

Mostrar paleta de comandos: Ctrl + Shift + P

Esses atalhos ajudam a aumentar a produtividade e a eficiência ao usar o VS Code.

[juancerqueirabr]

Ranking de revistas científica

A relevância das revistas científicas no âmbito acadêmico é geralmente medida por métricas como o fator de impacto (impact factor, IF), que indica a média de citações recebidas por artigos publicados em uma revista específica. Aqui está uma lista de algumas das revistas científicas mais relevantes em várias áreas de pesquisa, baseadas no fator de impacto e reconhecimento na comunidade acadêmica:

Ciências da Natureza e Exatas

Nature

Fator de Impacto (2023): 69.504

Área: Multidisciplinar

Science

Fator de Impacto (2023): 63.714

Área: Multidisciplinar

Cell

Fator de Impacto (2023): 58.7

Área: Biologia Celular

The New England Journal of Medicine (NEJM)

Fator de Impacto (2023): 91.245

Área: Medicina

Lancet

Fator de Impacto (2023): 202.731

Área: Medicina

Ciências Sociais

American Economic Review

Fator de Impacto (2023): 11.50

Área: Economia

Journal of Political Economy

Fator de Impacto (2023): 10.07

Área: Economia/Política

American Journal of Sociology

Fator de Impacto (2023): 3.7

Área: Sociologia

Administrative Science Quarterly

Fator de Impacto (2023): 10.12

Área: Administração

Journal of Finance

Fator de Impacto (2023): 8.06

Área: Finanças

Ciências Humanas

Journal of Philosophy

Fator de Impacto (2023): 1.2

Área: Filosofia

Philosophical Review

Fator de Impacto (2023): 1.9

Área: Filosofia

PMLA (Publications of the Modern Language Association)

Fator de Impacto (2023): 1.1

Área: Literatura e Linguística

Modern Philology

Fator de Impacto (2023): 0.8

Área: Literatura

Critical Inquiry

Fator de Impacto (2023): 2.0

Área: Estudos Culturais

Engenharia e Tecnologia

IEEE Transactions on Pattern Analysis and Machine Intelligence

Fator de Impacto (2023): 24.3

Área: Ciência da Computação/Engenharia

IEEE Transactions on Neural Networks and Learning Systems

Fator de Impacto (2023): 14.2

Área: Inteligência Artificial/Engenharia

Advanced Materials

Fator de Impacto (2023): 32.1

Área: Ciência dos Materiais

Nature Nanotechnology

Fator de Impacto (2023): 38.9

Área: Nanotecnologia

Chemical Engineering Journal

Fator de Impacto (2023): 16.7

Área: Engenharia Química

Ciências da Saúde

Journal of the American Medical Association (JAMA)

Fator de Impacto (2023): 56.2

Área: Medicina

The British Medical Journal (BMJ)

Fator de Impacto (2023): 39.9

Área: Medicina

Circulation

Fator de Impacto (2023): 23.6

Área: Cardiologia

Journal of Clinical Oncology

Fator de Impacto (2023): 45.3

Área: Oncologia

Gastroenterology

Fator de Impacto (2023): 22.6

Área: Gastroenterologia

Essas revistas são algumas das mais prestigiadas e influentes em suas respectivas áreas. O fator de impacto varia anualmente e é uma das muitas métricas usadas para avaliar a relevância de uma revista. Outros fatores, como a qualidade dos artigos, a taxa de aceitação e a influência histórica, também desempenham um papel significativo na percepção de relevância acadêmica.

[juancerqueirabr]

Claro! Aqui está um resumo dos tempos verbais no passado, presente e futuro em inglês:

### **Presente (Present)**

1. **Present Simple (Presente Simples)**

- Uso: Ações habituais, fatos gerais.

- Estrutura: Sujeito + verbo (na forma base, adicionando 's' ou 'es' na 3ª pessoa do singular)

- Exemplo: "I eat breakfast every morning."

2. **Present Continuous (Presente Contínuo)**

- Uso: Ações que estão ocorrendo no momento da fala.

- Estrutura: Sujeito + verbo 'to be' (am/is/are) + verbo com 'ing'

- Exemplo: "She is eating breakfast right now."

### **Passado (Past)**

1. **Past Simple (Passado Simples)**

- Uso: Ações concluídas no passado.

- Estrutura: Sujeito + verbo na forma passada

- Exemplo: "He ate breakfast at 7 AM."

2. **Past Continuous (Passado Contínuo)**

- Uso: Ações que estavam ocorrendo em um determinado momento no passado.

- Estrutura: Sujeito + verbo 'to be' no passado (was/were) + verbo com 'ing'

- Exemplo: "They were eating breakfast when I called."

### **Futuro (Future)**

1. **Future Simple (Futuro Simples)**

- Uso: Ações que acontecerão no futuro.

- Estrutura: Sujeito + 'will' + verbo na forma base

- Exemplo: "I will eat breakfast at 8 AM tomorrow."

2. **Future Continuous (Futuro Contínuo)**

- Uso: Ações que estarão em andamento em um determinado momento no futuro.

- Estrutura: Sujeito + 'will be' + verbo com 'ing'

- Exemplo: "She will be eating breakfast at 8 AM tomorrow."