O Que é o MongoDB?

O MongoDB é um sistema de base de dados NoSQL, orientado a documentos e de código aberto, que ganhou popularidade devido à sua capacidade de manusear grandes volumes de dados de forma eficiente. Em vez de tabelas, como nas bases de dados relacionais, o MongoDB utiliza coleções e documentos. Um documento é um conjunto de pares chave-valor, que no mundo do MongoDB é representado num formato chamado BSON (uma versão binária de JSON). Esta estrutura torna-o muito flexível e fácil de escalar, o que o torna especialmente adequado para aplicações web modernas e o manuseio de dados em formato JSON, comum no desenvolvimento de aplicações web e móveis.

A Diferença Entre SQL e NoSQL

Para entender melhor o MongoDB, é crucial diferenciar entre as bases de dados SQL e NoSQL. As bases de dados SQL (como MySQL, PostgreSQL ou Microsoft SQL Server) utilizam uma linguagem de consulta estruturada (SQL) e baseiam-se num esquema de dados predefinido. Isso significa que precisas saber antecipadamente como os teus dados serão estruturados e aderir a essa estrutura, o que oferece um alto grau de consistência e transações ACID (Atomicidade, Consistência, Isolamento e Durabilidade).
Por outro lado, as bases de dados NoSQL, como o MongoDB, são esquematicamente dinâmicas, permitindo-te guardar documentos sem ter que definir a sua estrutura antecipadamente. São ideais para dados não estruturados ou semi-estruturados e oferecem uma escalabilidade horizontal, o que significa que podes adicionar mais servidores facilmente para lidar com mais carga.

Instalação do MongoDB no Ubuntu

Colocar o MongoDB em funcionamento no teu sistema Ubuntu é um processo bastante simples, mas requer seguir alguns passos com atenção. Aqui explico-te como fazer:

Atualização do Sistema

Antes de instalar qualquer pacote novo, é sempre uma boa prática atualizar a lista de pacotes e as versões de software do teu sistema operativo com os seguintes comandos:

sudo apt update
sudo apt upgrade

Instalação do Pacote do MongoDB

O Ubuntu tem o MongoDB nos seus repositórios predefinidos, mas para te certificares de obter a última versão, é recomendável usar o repositório oficial do MongoDB. Aqui mostro-te como configurá-lo e realizar a instalação:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E52529D4
echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list
sudo apt update
sudo apt install -y mongodb-org

Colocar o MongoDB em Funcionamento

Uma vez instalado, podes iniciar o servidor do MongoDB com o seguinte comando:

sudo systemctl start mongod

Se além disso quiseres que o MongoDB inicie automaticamente com o sistema, executa:

sudo systemctl enable mongod

Verificação da Instalação

Para verificar que o MongoDB está instalado e a funcionar corretamente, usa:

sudo systemctl status mongod

Ou podes tentar conectar-te ao servidor MongoDB utilizando o seu shell:

mongo

Gestão Básica do MongoDB a Partir do Console

Agora que tens o MongoDB a funcionar na tua máquina Ubuntu, é hora de aprender alguns comandos básicos para gerir a tua instância do MongoDB a partir do console.

Criar e Usar uma Base de Dados

Para criar uma nova base de dados, simplesmente usa o comando use seguido do nome da tua base de dados:

use minhaBaseDeDados

Se a base de dados não existir, o MongoDB irá criá-la quando guardares nela o teu primeiro documento.

Inserir Dados

Para inserir dados numa coleção, podes usar o comando insert. Por exemplo:

db.minhaColecao.insert({ nome: "Alice", idade: 25 })

Isto adicionará um novo documento à coleção minhaColecao.

Ler Dados

Podes ler ou procurar documentos numa coleção com o comando find. Por exemplo:

db.minhaColecao.find({ nome: "Alice" })

Isto procurará todos os documentos onde o nome seja “Alice”.
Atualizar Dados

Para atualizar documentos, usarias update. Por exemplo:

db.minhaColecao.update({ nome: "Alice" }, { $set: { idade: 26 } })

Isto atualizará a idade de Alice para 26.

Eliminar Dados

E para eliminar documentos, simplesmente usas remove:

db.minhaColecao.remove({ nome: "Alice" })

Isto eliminará todos os documentos onde o nome seja “Alice”.

A Potência dos Clusters do MongoDB

Embora a gestão de uma instância simples do MongoDB possa ser suficiente para muitos projetos, especialmente durante as fases de desenvolvimento e testes, quando se trata de aplicações em produção com grandes volumes de dados ou altos requisitos de disponibilidade, configurar um cluster do MongoDB pode ser essencial. Um cluster pode distribuir os dados por vários servidores, o que não só proporciona redundância e alta disponibilidade, mas também melhora o desempenho das operações de leitura e escrita.
Os clusters do MongoDB utilizam o conceito de sharding para distribuir os dados de maneira horizontal e as réplicas para assegurar que os dados estejam sempre disponíveis, mesmo se parte do sistema falhar. Num outro artigo, exploraremos como configurar o teu próprio cluster do MongoDB, mas por agora, é suficiente saber que esta é uma poderosa característica que o MongoDB oferece para escalar a tua aplicação à medida que cresce.

À medida que te aprofundas no mundo do MongoDB, descobrirás que há muito mais para aprender e explorar. Desde a sua integração com diferentes linguagens de programação até às complexidades da indexação e o desempenho das consultas, o MongoDB oferece um mundo de possibilidades que pode adaptar-se a quase qualquer necessidade de aplicação moderna.

Lembra-te que dominar o MongoDB leva tempo e prática, mas começar com os fundamentos colocar-te-á no caminho certo. Experimenta com os comandos, testa diferentes configurações e não tenhas medo de quebrar coisas num ambiente de teste; é a melhor maneira de aprender. A flexibilidade e o poder do MongoDB esperam, e com a base que construíste hoje, estás mais do que pronto para começar a explorar. Mãos à obra!

La entrada Cómo Empezar com o MongoDB: O Teu Guia Definitivo se publicó primero en Aprende IT.

Python é uma linguagem de programação poderosa e versátil, popular pela sua legibilidade e simplicidade. Mas também é uma linguagem de alto nível com gestão automática de memória, o que significa que o programador não tem de se preocupar muito com a alocação e libertação de memória.

Isso não significa que podemos esquecer completamente a gestão de memória. Na verdade, um bom entendimento de como o Python lida com a memória pode ajudar-te a escrever código mais eficiente e evitar problemas inesperados. Então, vamos mergulhar neste fascinante tópico.

Memória e o Coletor de Lixo

Antes de entrarmos em dicas e truques específicos, vamos entender um pouco mais sobre como o Python gerencia a memória.

Quando crias um objeto em Python, o sistema reserva um bloco de memória para o armazenar. Este bloco de memória permanece ocupado enquanto o objeto existir, ou seja, enquanto houver alguma referência a ele no teu código.

No entanto, quando um objeto já não é necessário (não há referências a ele), esse bloco de memória não é imediatamente libertado. O Python tem um componente chamado “coletor de lixo” que é responsável por libertar a memória ocupada por objetos que já não são necessários.

A Importância das Referências

Entender como funcionam as referências em Python pode ser muito útil para gerir a memória de forma eficiente. Quando atribuis uma variável a um objeto, estás realmente a criar uma referência ao objeto, não uma cópia do objeto.

Isto é importante porque significa que se atribuíres uma variável a outro objeto, a referência anterior é perdida e o objeto original pode ser coletado como lixo, libertando a sua memória. Mas tem cuidado: se houver outras referências ao objeto original, este não será eliminado.

Variáveis Imutáveis e Mutáveis

Outro aspeto que deves ter em conta ao gerir a memória em Python é a diferença entre variáveis imutáveis e mutáveis. Números, strings e tuplas são imutáveis, o que significa que uma vez criados, o seu valor não pode mudar.

Por outro lado, listas, dicionários e a maioria dos objetos definidos pelo utilizador são mutáveis, o que significa que o seu valor pode mudar. Quando modificas um objeto mutável, a mudança acontece no mesmo bloco de memória.

Truques para Otimizar a Gestão de Memória

Agora que entendemos os conceitos básicos, vamos ver alguns truques que podem ajudar-te a gerir a memória de forma mais eficiente em Python.

Usando Geradores

Os geradores são uma característica poderosa do Python que te permite iterar sobre uma sequência de valores sem ter de gerar toda a sequência na memória de uma só vez. Em vez disso, os valores são gerados à medida que vão sendo necessários, um de cada vez, o que pode poupar uma quantidade significativa de memória se a sequência for grande.

Evita Referências Desnecessárias

Lembra-te que cada referência a um objeto mantém o objeto na memória. Portanto, se quiseres que um objeto seja coletado como lixo, certifica-te de remover todas as referências a ele quando já não precisares dele.

Usando __slots__ em Classes

Se estás a definir uma classe que vai ter muitas instâncias, podes poupar memória usando __slots__. Esta é uma funcionalidade do Python que limita os atributos que uma instância de uma classe pode ter, o que pode reduzir a quantidade de memória usada para armazenar cada instância.

Reciclagem de Objetos

Em alguns casos, pode ser útil reciclar objetos em vez de criar novos. Por exemplo, se tiveres uma lista de objetos que são usados de forma intermitente, podes mantê-los num “pool” e reutilizá-los quando necessário, em vez de criar novos objetos de cada vez.

Conhecer as Ferramentas de Diagnóstico do Python

Por último, mas não menos importante, é útil conhecer as ferramentas que o Python fornece para o diagnóstico de memória. A biblioteca padrão do Python inclui módulos como gc e tracemalloc que podes usar para monitorizar e controlar a gestão de memória.

O módulo gc permite-te interagir com o coletor de lixo, enquanto o tracemalloc fornece informações detalhadas sobre a memória que está a ser usada pelo teu programa.

Então, aí o tens. A gestão de memória em Python pode parecer um tema complicado, mas com estas dicas e truques, podes começar a escrever código mais eficiente e otimizado. Lembra-te, cada pequeno detalhe conta quando se trata de otimizar a eficiência do teu código e estas dicas são um ótimo lugar para começar.

Tens algum outro truque ou dica que gostarias de partilhar? Adoraríamos ouvir sobre isso nos comentários!

La entrada Gestão de Memória em Python: Dicas e Truques Úteis para Otimizar o Teu Código se publicó primero en Aprende IT.

Compreendendo o Docker e os contentores

Antes de nos aprofundarmos nas complexidades da depuração, é bom esclarecer brevemente o que é o Docker e por que os contentores são tão relevantes no desenvolvimento moderno de aplicações. O Docker é uma ferramenta que permite aos desenvolvedores como tu, empacotar aplicações e suas dependências em contentores. Estes contentores são leves e portáteis, permitindo-te executar as tuas aplicações em qualquer sistema operativo que suporte Docker, sem te preocupares com tarefas de configuração tediosas.

Ferramentas para depuração no Docker

Depurando a partir do host

Primeiro, vamos falar sobre como podes depurar as tuas aplicações a partir do mesmo host onde o contentor Docker está a ser executado. Isto é útil em situações em que queres acompanhar o que está a acontecer na tua aplicação em tempo real, sem a necessidade de aceder ao contentor.

Podes utilizar ferramentas como docker logs, que te permite visualizar os logs das tuas aplicações em tempo real. Além disso, podes usar docker top para ver os processos que estão a ser executados dentro do teu contentor. Isto permite-te ver o que está a consumir recursos e se há algum processo que não deveria estar a ser executado.

Acedendo ao contentor

Ocasionalmente, precisarás aceder diretamente ao contentor para depurar a tua aplicação. O Docker permite que faças isso usando o comando docker exec, que te permite executar comandos dentro do teu contentor como se estivesses no sistema operativo host.

Uma vez dentro do contentor, poderás usar as ferramentas de depuração instaladas na tua imagem. Por exemplo, se estiveres a trabalhar com uma aplicação em Python, poderias usar o pdb para depurar o teu código.

Depurando com Docker Compose

O Docker Compose é outra ferramenta que será útil na depuração das tuas aplicações. O Docker Compose permite-te definir e executar aplicações multi-contentor com uma simples descrição num ficheiro YAML.

Tal como com o Docker, podes aceder aos logs das tuas aplicações com docker-compose logs, e também podes aceder ao contentor com docker-compose exec.

Técnicas para depurar aplicações no Docker

Depuração em tempo de execução

A depuração em tempo de execução permite-te inspecionar o estado da tua aplicação enquanto ela está a ser executada. Podes fazer isto usando ferramentas como pdb (para Python) ou gdb (para C/C++) dentro do teu contentor.

Estas ferramentas permitem-te colocar pontos de parada no teu código, inspecionar variáveis e avançar passo a passo na execução da tua aplicação, permitindo-te ver exatamente o que está a acontecer a cada momento.

Depuração post-mortem

A depuração post-mortem é realizada depois de a tua aplicação ter falhado. Isto permite-te inspecionar o estado da tua aplicação no momento da falha.

A depuração post-mortem é especialmente útil quando te deparas com erros intermitentes ou difíceis de reproduzir. Nestes casos, podes configurar a tua aplicação para gerar um dump de memória em caso de falha, que poderás analisar mais tarde para encontrar o problema.

Tracing e Profiling

Outra técnica útil na depuração de aplicações no Docker é o tracing e profiling. Isto permite-te obter informações detalhadas sobre a execução da tua aplicação, como o tempo que cada função demora a executar ou a utilização da memória.

Existem várias ferramentas que te permitem fazer tracing e profiling das tuas aplicações no Docker, como strace (para sistemas baseados em Linux) ou DTrace (para sistemas baseados em Unix).

Dicas finais

Antes de terminar, gostaria de te dar algumas dicas para tornar a tua experiência de depuração de aplicações no Docker o mais suave possível:

• Certifica-te de que tens uma boa compreensão de como funciona o Docker. Quanto melhor entenderes o Docker, mais fácil será depurar as tuas aplicações.
• Familiariza-te com as ferramentas de depuração disponíveis para a tua linguagem de programação.
• Não te esqueças da importância de ter bons logs. Um bom sistema de logs pode ser o teu melhor aliado ao depurar problemas nas tuas aplicações.
• Usa Docker Compose para orquestrar as tuas aplicações multi-contentor. Isto facilitará a tarefa de depurar problemas que surjam da interação entre vários contentores.

Em resumo, depurar aplicações em contentores Docker pode ser uma tarefa complexa, mas com as ferramentas e técnicas adequadas, poderás fazê-lo de maneira eficiente e eficaz. Lembra-te, a prática leva à perfeição, por isso não te frustres se parecer complicado no início. Força e vamos à depuração!

La entrada Como depurar aplicações em contentores Docker: O teu guia definitivo se publicó primero en Aprende IT.

Entendendo as Diferenças entre Python 2 e Python 3

Antes de entrarmos completamente nos truques para a transição do Python 2 para o Python 3, é essencial que compreendas as principais diferenças entre estas duas versões. O Python 3 introduz alterações na linguagem que não são retrocompatíveis. Esta é a principal razão pela qual o processo de migração pode ser complicado.

Por exemplo, no Python 2, o comando print é usado sem parênteses, enquanto no Python 3, os parênteses são necessários. No Python 2.7 poderias usar:

print "Olá, mundo!"

No Python 3.7 ou superior, deverias escrever assim:

print("Olá, mundo!")

Usando Bibliotecas Específicas do Python 3

O Python 3 traz consigo uma série de novas bibliotecas que não estão disponíveis no Python 2.7. Portanto, precisarás de alterar as tuas importações para corresponderem às bibliotecas do Python 3. Por exemplo, se usavas urlib2 antes, agora terás que importar urllib.request, urllib.parse, e urllib.error.

Aqui está um exemplo de como o teu código deve ficar:

# Python 2.7
import urllib2
response = urllib2.urlopen('http://python.org/')
html = response.read()

# Python 3.7
import urllib.request
response = urllib.request.urlopen('http://python.org/')
html = response.read()

Mudança na Sintaxe da Exceção

Uma das mudanças mais notáveis entre o Python 2 e o Python 3 é a forma como as exceções são tratadas. No Python 2, a sintaxe except Exception, e: era utilizada. Mas no Python 3, deves mudar para except Exception as e:. Aqui está um exemplo de como fazer isso:

# Python 2.7
try:
    ...
except Exception, e:
    print e

# Python 3.7
try:
    ...
except Exception as e:
    print(e)

A Função map()

A função map() no Python 2 retorna uma lista, enquanto no Python 3 retorna um objeto iterável. Então, se quiseres obter uma lista como resultado, deves converter explicitamente o resultado para uma lista usando a função list(). Aqui está um exemplo:

# Python 2.7
result = map(func, values)

# Python 3.7
result = list(map(func, values))

Lidando com a Divisão no Python

No Python 2, a divisão de dois inteiros resulta num número inteiro. No Python 3, no entanto, a divisão de dois inteiros resulta num número de ponto flutuante. Quando estiveres a migrar o teu código, é essencial ter isto em conta. Veja o exemplo abaixo:

# Python 2.7
result = 5 / 2  # O resultado é 2

# Python 3.7
result = 5 / 2  # O resultado é 2.5

A Biblioteca __future__

A biblioteca __future__ pode ser a tua melhor amiga durante a migração. Esta permite que uses as funcionalidades do Python 3 no teu código Python 2.7, tornando a tarefa de migração muito mais fácil. Por exemplo, podes usar a função print() do Python 3 no teu código Python 2.7 assim:

from __future__ import print_function
print("Olá, mundo!")

Compreensões de lista e Escopo de Variável

Outra alteração importante no Python 3 é a forma como lida com o escopo de variáveis em compreensões de lista. No Python 2, as variáveis usadas em compreensões de lista vazam para o escopo principal. O Python 3 corrigiu este problema encapsulando o escopo da variável dentro da compreensão da lista. Aqui está um exemplo:

# Python 2.7
x = 1
print [x for x in range(5)]
print x  # Isto imprime 4, não 1

# Python 3.7
x = 1
print([x for x in range(5)])
print(x)  # Isto imprime 1

As Chaves do Dicionário são Visualizações no Python 3

No Python 3, dictionary.keys(), dictionary.values(), e dictionary.items() retornam objetos de visualização em vez de listas. Se precisares de obter uma lista, deverás converter o resultado numa lista explicitamente. Vê o seguinte exemplo:

# Python 2.7
dictionary = {'um': 1, 'dois': 2}
keys = dictionary.keys()  # Isto é uma lista

# Python 3.7
dictionary = {'um': 1, 'dois': 2}
keys = list(dictionary.keys())  # Agora isto é uma lista
Adeus a xrange()

No Python 3, a função xrange() foi substituída por range(), que agora retorna um objeto iterável. No Python 2.7, se quiseres obter uma lista a partir de range(), precisas de a converter explicitamente numa lista:

# Python 2.7
x = xrange(10)  # Isto é um iterável

# Python 3.7
x = list(range(10))  # Isto é uma lista

Códigos de Escape em Strings

O Python 2 permite o uso de códigos de escape em strings não formatadas, enquanto que o Python 3 não permite. Se quiseres usar códigos de escape no Python 3, precisas de usar strings formatadas. Aqui está como fazer isso:

# Python 2.7
x = '\100'

# Python 3.7
x = r'\100'

Arredondamento em Python

As funções de arredondamento também se comportam de forma diferente em Python 2 e Python 3. No Python 2, round(0.5) é igual a 0.0 e round(1.5) é igual a 2.0. No entanto, Python 3 segue o método de arredondamento para o número par mais próximo, também conhecido como arredondamento de banqueiro. Aqui está um exemplo:

# Python 2.7
print(round(0.5))  # Isto imprime 0

# Python 3.7
print(round(0.5))  # Isto imprime 1

Alterações nos Operadores de Comparação

No Python 2, poderias comparar objetos não ordenáveis. Python 3 lançará uma exceção nesses casos. Portanto, deverás rever o teu código para garantir que não estás a tentar comparar objetos não ordenáveis. Por exemplo:

# Python 2.7
print(1 < '1')  # Isto é True

# Python 3.7
print(1 < '1')  # Isto lança uma exceção TypeError

Usando next()

A função next() é usada para obter o próximo item de um iterador. No Python 2, poderias usar o método iterator.next(). No Python 3, deverás usar a função next(iterator). Aqui está um exemplo:

# Python 2.7
iterator = iter([1, 2, 3])
print iterator.next()  # Isto imprime 1

# Python 3.7
iterator = iter([1, 2, 3])
print(next(iterator))  # Isto imprime 1

Codificação Padrão

Python 2 usa ASCII como a codificação padrão, enquanto Python 3 usa UTF-8. Isso pode causar problemas se o teu código Python 2 manipular strings que não são ASCII. Eis como podes lidar com isso em Python 3:

# Python 2.7
string = '¡Hola, mundo!'

# Python 3.7
string = '¡Hola, mundo!'

__eq__() ou __cmp__()?

No Python 2, poderias implementar o método __cmp__() nas tuas classes para realizar comparações entre objetos. Python 3 elimina este método e em vez disso, deverás implementar os métodos __eq__() e __lt__() para igualdade e comparação respetivamente. Aqui está um exemplo:

# Python 2.7
class Test(object):
    def __cmp__(self, other):
        return self.value - other.value

# Python 3.7
class Test(object):
    def __eq__(self, other):
        return self.value == other.value

    def __lt__(self, other):
        return self.value < other.value

Alterações nas Variáveis de Classe

No Python 2, as variáveis de classe são acessíveis através da instância da classe. No Python 3, não podes mudar as variáveis de classe através da instância. Portanto, ao migrar o teu código Python 2 para Python 3, deverás ter isto em conta. Aqui está um exemplo:

# Python 2.7
class Test(object):
    valor = "Olá, mundo!"

    def mudar_valor(self, novo_valor):
        self.valor = novo_valor

teste = Test()
teste.mudar_valor("Adeus, mundo!")
print(teste.valor) # Isto imprime: Adeus, mundo!

Python 3.7
class Test(object):
    valor = "Olá, mundo!"

    def mudar_valor(self, novo_valor):
        self.valor = novo_valor
        
teste = Test()
teste.mudar_valor("Adeus, mundo!")
print(teste.valor) # Isto imprime: Olá, mundo!
print(Test.valor) # Isto imprime: Adeus, mundo!

Adicionando *args e **kwargs nos Métodos de Classe

Python 2 permite que os métodos de classe aceitem um número arbitrário de argumentos posicionais e de palavras-chave, mesmo que não estejam definidos no método. Python 3 não permite isso, por isso deverás garantir que incluis *args e **kwargs na definição do método se quiseres que ele aceite um número arbitrário de argumentos. Aqui está um exemplo:

# Python 2.7
class Test(object):
    def metodo(self, x):
        print(x)

teste = Test()
teste.metodo(1, 2, 3)  # Isto é válido

# Python 3.7
class Test(object):
    def metodo(self, x, *args, **kwargs):
        print(x, args, kwargs)

teste = Test()
teste.metodo(1, 2, 3)  # Isto é válido

Iteradores em Python 3

Em Python 2, os métodos dict.iterkeys(), dict.itervalues() e dict.iteritems() retornam iteradores. Python 3 os substitui por dict.keys(), dict.values(), e dict.items(), que retornam visualizações de dicionários. Mas não te preocupes, porque estes também são iteráveis e podes convertê-los em listas, se necessário.

# Python 2.7
dicionario = {'um': 1, 'dois': 2}
for chave in dicionario.iterkeys():
    print(chave)

# Python 3.7
dicionario = {'um': 1, 'dois': 2}
for chave in dicionario.keys():
    print(chave)

Com todos estes truques, estou certo de que a tua migração do Python 2.7 para o Python 3.7 será mais suave. Não te esqueças de que migrar o teu código para o Python 3 não é apenas importante pelas melhorias que oferece, mas também porque o Python 2 já não é oficialmente mantido. Boa sorte na tua jornada rumo ao Python 3!

La entrada Truques para Transição do Teu Código Python 2.7 para 3.7 ou Superior se publicó primero en Aprende IT.

La entrada Monitorização e gestão de logs em ambientes DevOps se publicó primero en Aprende IT.

La entrada Introdução aos Sistemas de Controlo de Versões: Git e Além se publicó primero en Aprende IT.

let x = 5;

let mut y = 10; y = 20;

let numero = 10;

if numero < 5 {
    println!("O número é menor que 5");
} else {
    println!("O número é 5 ou maior");
}

for i in 1..5 {
    println!("{}", i);
}

let mut i = 1;

while i < 5 {
    println!("{}", i);
    i += 1;
}

fn adicionar(a: i32, b: i32) -> i32 {
    a + b
}

struct Pessoa {
    nome: String,
    idade: i32,
}

let pessoa = Pessoa {
    nome: String::from("João"),
    idade: 30,
};

cargo new meu_projeto

fn main() {
    println!("Olá, mundo!");
}

cargo run

La entrada Aprende os Fundamentos da Programação em Linguagem Rust e Como Utilizá-la nos Teus Projetos de Desenvolvimento se publicó primero en Aprende IT.

Padrão de Design Singleton

O padrão de design Singleton garante que exista apenas uma instância de uma classe em todo o programa. Isso é especialmente útil quando você precisa ter acesso a uma única instância compartilhada em diferentes partes do seu código. Vamos ver como implementá-lo em Python.

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

Neste exemplo, criamos a classe Singleton com uma variável de classe _instance que armazenará a única instância da classe. O método __new__ é responsável por controlar a criação de novas instâncias. Se a instância ainda não existe, uma nova é criada usando super().__new__(cls) e atribuída à variável de classe _instance. Em cada chamada subsequente à classe, a instância existente é retornada em vez de criar uma nova.

Padrão de Design Factory

O padrão de design Factory é usado quando você precisa criar objetos sem especificar a classe exata do objeto a ser criado. Em vez disso, um método de fábrica é usado para determinar a classe concreta e criar o objeto. Vamos ver como implementá-lo em Python.

class Car:
    def drive(self):
        pass

class Bike:
    def ride(self):
        pass

class VehicleFactory:
    def create_vehicle(self, vehicle_type):
        if vehicle_type == "car":
            return Car()
        elif vehicle_type == "bike":
            return Bike()
        else:
            raise ValueError("Tipo de veículo inválido")

Neste exemplo, criamos as classes Carro e Bicicleta, que representam diferentes tipos de veículos. Em seguida, criamos a classe VehicleFactory que contém o método create_vehicle, que recebe o tipo de veículo como argumento. Dependendo do tipo especificado, o método cria e retorna uma instância da classe correspondente. Isso permite que o cliente obtenha o objeto desejado sem precisar conhecer a lógica específica de criação.

Padrão de Design Observer

O padrão de design Observer estabelece uma relação de um para muitos entre objetos, de forma que quando um objeto muda de estado, todos os seus dependentes são notificados e atualizados automaticamente. Em Python, podemos usar o módulo Observable da biblioteca rx para implementar esse padrão.

from rx import Observable

class Subject:
    def __init__(self):
        self.observable = Observable()

    def register_observer(self, observer):
        self.observable.subscribe(observer)

    def unregister_observer(self, observer):
        self.observable.unsubscribe(observer)

    def notify_observers(self, data):
        self.observable.on_next(data)

Neste exemplo, importamos a classe Observable do módulo rx. Em seguida, criamos a classe Subject que atua como o objeto observável. Ela possui um objeto Observable interno usado para gerenciar as assinaturas dos observadores. Os métodos register_observer e unregister_observer permitem registrar e cancelar a assinatura dos observadores, respectivamente.

O método notify_observers notifica todos os observadores registrados ao chamar o método on_next do objeto Observable. Isso garante que todos os observadores recebam automaticamente as atualizações quando o estado do objeto observável mudar.

este artigo, exploramos três padrões de design fundamentais em Python: Singleton, Factory e Observer. Através de exemplos de código, demonstramos como implementar cada um deles e como podem ajudar a potencializar o seu código e lidar com desafios comuns no desenvolvimento de software.

Esperamos que este guia prático tenha proporcionado uma compreensão mais profunda dos padrões de design e como aplicá-los em Python. Lembre-se de que os padrões de design são ferramentas poderosas que podem aprimorar a estrutura, a flexibilidade e a reutilização do seu código. Continue praticando e experimentando com eles para se tornar um desenvolvedor Python ainda mais habilidoso!

Aproveite o poder dos padrões de design e eleve o seu código Python a um novo patamar!

La entrada Potencialize o seu Código com Padrões de Design: Guia Prático para Desenvolvedores Python se publicó primero en Aprende IT.

Com o Pillow, podemos realizar várias operações para analisar e processar imagens. Abaixo estão alguns exemplos, ah! Coloque o código dentro de um bloco de código:

Redimensionar uma imagem

Neste código, algo muito útil é feito: uma imagem é redimensionada para um tamanho específico. Por que é importante redimensionar uma imagem? Bem, às vezes você precisa que uma imagem tenha um tamanho específico para se ajustar a um design ou para ser exibida corretamente em uma página da web. Ou talvez você precise reduzir o tamanho de uma imagem para ocupar menos espaço no disco rígido. Seja qual for o caso, redimensionar uma imagem é uma tarefa muito comum na edição de imagens.

Este código usa o PIL (Python Imaging Library) para abrir uma imagem em Python. A imagem original é especificada como ‘imagem.jpg’, mas você pode alterar este nome para que corresponda ao nome da imagem que deseja redimensionar. Depois de abrir a imagem original, uma variável chamada ‘size’ é criada contendo o tamanho desejado da imagem redimensionada. Neste caso, o tamanho é de 224 x 224 pixels. Você pode alterar este tamanho para qualquer outro tamanho que você precise para o seu projeto.

Depois que o tamanho desejado foi definido, o método ‘resize()’ da biblioteca PIL é usado para redimensionar a imagem original para esse tamanho. O resultado é armazenado na variável ‘imagem’. É importante observar que este método altera o tamanho da imagem original e cria uma nova imagem com o tamanho desejado.

Finalmente, a imagem redimensionada é salva usando o método ‘save()’ da biblioteca PIL. A imagem é salva com o nome ‘imagem_redimensionada.jpg’, mas você pode alterar este nome para qualquer outro nome que você deseje.

Este código é muito simples, mas é muito útil para a edição de imagens em Python. Se você precisar redimensionar imagens para um projeto, pode usar este código como ponto de partida e ajustá-lo às suas necessidades.

from PIL import Image 

# Abrir a imagem original
imagem = Image.open('imagem.jpg')

# Redimensionar a imagem para um tamanho específico
tamanho = (224, 224)
imagem = imagem.resize(tamanho)

# Salvar a imagem redimensionada
imagem.save('imagem_redimensionada.jpg')

Depois que redimensionarmos a imagem, podemos usar o Keras para detectar objetos. O Keras tem modelos pré-treinados para detecção de objetos, como o modelo YOLO. Para usar o modelo YOLO no Keras, podemos carregar o modelo pré-treinado e, em seguida, usar o método predict() para detectar objetos em uma imagem.

Contornos e formas

Os contornos são as linhas que delimitam a forma de um objeto em uma imagem. Para detectar contornos em uma imagem com o Pillow, podemos usar o método find_contours() da biblioteca scikit-image

O primeiro passo que temos que fazer é instalar as dependências, neste caso scikit-image e Pillow:

pip install scikit-image
pip install Pillow

E aqui está o código:

from PIL import Image, ImageDraw
from skimage import measure
import numpy as np

# Abrir a imagem
imagem = Image.open('imagem.jpg')

# Converter a imagem em escala de cinza
imagem_cinza = imagem.convert('L')

# Converter a imagem em uma matriz numpy
matriz_imagem = np.array(imagem_cinza)

# Detectar os contornos
contornos = measure.find_contours(matriz_imagem, 0.8)

# Desenhar os contornos na imagem original
desenhar = ImageDraw.Draw(imagem)
for contorno in contornos:
    for i in range(len(contorno) - 1):
        desenhar.line((contorno[i][1], contorno[i][0], contorno[i+1][1], contorno[i+1][0]), fill='red', width=2)

# Mostrar a imagem com os contornos
imagem.show()

Melhorando a qualidade da imagem

A qualidade de uma imagem pode ser melhorada de várias maneiras, como aumentando o contraste, a saturação e a nitidez. Para aumentar o contraste de uma imagem com o Pillow, podemos usar o método enhance().

from PIL import Image, ImageEnhance

# Abrir a imagem
imagem = Image.open('imagem.jpg')

# Aumentar o contraste
realçar = ImageEnhance.Contrast(imagem)
imagem = realçar.enhance(1.5)

# Mostrar a imagem com contraste aumentado
imagem.show()

Estes são apenas alguns exemplos de como usar o Pillow para analisar e processar imagens com base no seu conteúdo. O Pillow é uma biblioteca muito poderosa e versátil que nos permite realizar uma grande variedade de operações de processamento de imagens.

La entrada Analisar e Processar Imagens com Python se publicó primero en Aprende IT.

O que é o Vagrant e por que você deve usá-lo?

O Vagrant é uma ferramenta de código aberto que nos permite criar, configurar e gerenciar ambientes de desenvolvimento virtualizados. Com o Vagrant, podemos ter um ambiente de desenvolvimento uniforme e controlado em nossa máquina, independentemente do sistema operacional que utilizamos. Dessa forma, evitamos problemas de compatibilidade e podemos nos concentrar no que realmente importa: desenvolver!

Mas quais são as vantagens do Vagrant? Bem, algumas delas são:

• Facilita a colaboração entre desenvolvedores, já que todos podem trabalhar no mesmo ambiente.
• Simplifica a configuração e administração de máquinas virtuais.
• Permite automatizar a criação e o provisionamento de ambientes de desenvolvimento.
• Promove o uso de boas práticas no desenvolvimento, como a infraestrutura como código.

Instalação e configuração do Vagrant

Para instalar o Vagrant, primeiro precisamos ter um provedor de virtualização em nossa máquina. Um dos mais populares é o VirtualBox, mas também podemos utilizar VMware, Hyper-V, entre outros. Neste artigo, vamos nos concentrar no VirtualBox. Para instalá-lo, basta seguir as instruções na página oficial do VirtualBox.

Depois de instalar o provedor de virtualização, podemos baixar o Vagrant em sua página oficial. Lá, encontraremos versões para Windows, macOS e Linux. Baixe e instale a versão adequada para o seu sistema operacional.

Primeiros passos com o Vagrant

Agora que temos o Vagrant instalado, vamos criar nosso primeiro ambiente de desenvolvimento virtualizado. Para fazer isso, seguiremos estas etapas:

Abra um terminal e crie um novo diretório para o nosso projeto:

mkdir meu-primeiro-ambiente-vagrant
cd meu-primeiro-ambiente-vagrant

Inicialize o Vagrant no diretório:

vagrant init

Este comando criará um arquivo chamado Vagrantfile em nosso diretório. Este arquivo é a chave para configurar e personalizar nosso ambiente de desenvolvimento virtualizado.

Edite o Vagrantfile com seu editor de texto favorito e adicione a seguinte linha:

config.vm.box = "hashicorp/bionic64"

Esta linha indica que vamos usar a imagem “hashicorp/bionic64” como base para nossa máquina virtual. Esta imagem é uma versão do Ubuntu 18.04 (Bionic Beaver) de 64 bits. Existem muitas outras imagens disponíveis no catálogo oficial do Vagrant, que você pode explorar no Vagrant Cloud.

Inicie a máquina virtual com o comando:

vagrant up

O Vagrant irá baixar a imagem (se ainda não o fez) e criar uma nova máquina virtual baseada nela. Esse processo pode levar um pouco de tempo, dependendo da velocidade da sua conexão com a internet e do seu computador.

Depois que a máquina virtual estiver em execução, podemos nos conectar a ela por meio do SSH:

vagrant ssh

Parabéns! Agora você está conectado ao seu primeiro ambiente de desenvolvimento virtualizado com o Vagrant. Você pode começar a instalar software, desenvolver aplicativos e experimentar sem medo de quebrar seu ambiente local.

Provisionamento de ambientes

Uma das características mais interessantes do Vagrant é o provisionamento, que nos permite automatizar a configuração e a instalação de software em nossas máquinas virtuais. O Vagrant é compatível com vários sistemas de provisionamento, como Shell, Puppet, Ansible e Chef, entre outros.

Para ilustrar como funciona o provisionamento, vamos usar um simples script de Shell. Adicione as seguintes linhas ao seu Vagrantfile, logo abaixo de config.vm.box = “hashicorp/bionic64”:

config.vm.provision "shell", inline: <<-SHELL
    sudo apt-get update
    sudo apt-get install -y git nginx
SHELL

Essas linhas indicam que o Vagrant deve executar um script de Shell que atualiza os repositórios de pacotes do Ubuntu e instala o Git e o Nginx. Para aplicar essas alterações, devemos provisionar nossa máquina virtual novamente com o comando:

vagrant reload --provision

Depois que o processo terminar, nossa máquina virtual terá o Git e o Nginx instalados.

Comandos básicos do Vagrant

Aqui está uma lista de alguns comandos básicos do Vagrant que serão úteis no seu dia a dia:

• vagrant init: Inicializa um novo ambiente de Vagrant no diretório atual.
• vagrant up: Inicia a máquina virtual.
• vagrant ssh: Conecta-se à máquina virtual por meio do SSH.
• vagrant halt: Desliga a máquina virtual.
• vagrant reload: Reinicia a máquina virtual.
• vagrant destroy: Exclui a máquina virtual e todos os seus recursos.
• vagrant status: Mostra o estado da máquina virtual.
• vagrant global-status: Mostra o estado de todas as máquinas virtuais em seu sistema.
• vagrant box: Gerencia as imagens de máquinas virtuais (boxes) em seu sistema.

Trabalhando com múltiplas máquinas virtuais

O Vagrant nos permite gerenciar facilmente várias máquinas virtuais em um mesmo projeto. Para fazer isso, basta adicionar uma nova definição de máquina virtual em nosso Vagrantfile. Por exemplo, se quisermos adicionar uma segunda máquina virtual com o CentOS 7, poderíamos fazer o seguinte:

config.vm.define "centos" do |centos|
    centos.vm.box = "centos/7"
    centos.vm.hostname = "centos.local"
    centos.vm.network "private_network", ip: "192.168.33.20"
end

Com essa configuração, criamos uma nova máquina virtual chamada “centos” com base na imagem “centos/7”. Além disso, atribuímos um nome de host e um endereço IP em uma rede privada.

Para iniciar ambas as máquinas virtuais, basta executar o comando vagrant up. Se quisermos iniciar apenas uma delas, podemos especificar seu nome:

vagrant up centos

Podemos nos conectar à máquina virtual do CentOS por meio do SSH com o seguinte comando:

vagrant ssh centos

Sincronização de arquivos entre o host e a máquina virtual

O Vagrant facilita a sincronização de arquivos entre nosso host e as máquinas virtuais. Por padrão, o diretório em que nosso Vagrantfile está localizado é sincronizado automaticamente com o diretório /vagrant dentro da máquina virtual. Isso nos permite compartilhar arquivos facilmente entre os dois ambientes.

Se quisermos configurar uma pasta compartilhada personalizada, podemos fazê-lo adicionando a seguinte linha ao nosso Vagrantfile:

config.vm.synced_folder "minha-pasta-local", "/minha-pasta-remota"

Essa linha indica que a pasta “minha-pasta-local” em nosso host será sincronizada com a pasta “/minha-pasta-remota” na máquina virtual. O Vagrant se encarregará de manter ambos os diretórios sincronizados automaticamente.

Redes no Vagrant

O Vagrant oferece várias opções para configurar a rede em nossas máquinas virtuais. Algumas das mais comuns são:

Rede privada: Permite que as máquinas virtuais se comuniquem entre si e com o host por meio de uma rede privada. Para configurar uma rede privada, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "private_network", ip: "192.168.33.10"

Rede pública: Conecta a máquina virtual diretamente à rede pública, permitindo que outras máquinas na rede a acessem. Para configurar uma rede pública, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "public_network"

Redirecionamento de porta: Permite acessar serviços na máquina virtual por meio de uma porta específica no host. Para configurar o redirecionamento de porta, adicione a seguinte linha ao seu Vagrantfile:

config.vm.network "forwarded_port", guest: 80, host: 8080

Essa linha indica que a porta 80 na máquina virtual será redirecionada para a porta 8080 em nosso host.

La entrada Introdução ao Vagrant: Gerenciamento de Ambientes de Desenvolvimento Virtualizados se publicó primero en Aprende IT.