<< Dia 26 | Dia 28 >>

• 📘 Dia 27
• Python com MongoDB
  • MongoDB
    • SQL versus NoSQL
    • Obtendo a String de Conexão (URI do MongoDB)
    • Conectando a aplicação Flask ao Cluster MongoDB
    • Criando um banco de dados e uma coleção
    • Inserindo vários documentos em uma coleção
    • Find no MongoDB
    • Find com Query
    • Query com modificador
    • Limitando documentos
    • Find com ordenação
    • Update com query
    • Excluindo um documento
    • Excluindo uma coleção
  • 💻 Exercícios: Dia 27

📘 Dia 27

Python com MongoDB

Python é uma tecnologia de backend e pode ser conectado a diferentes aplicações de banco de dados. Ele pode ser conectado tanto a bancos de dados SQL quanto NoSQL. Nesta seção, vamos conectar o Python com o banco de dados MongoDB, que é um banco de dados NoSQL.

MongoDB

MongoDB é um banco de dados NoSQL. O MongoDB armazena dados em um documento no estilo JSON, o que torna o MongoDB muito flexível e escalável. Vamos ver as diferentes terminologias dos bancos de dados SQL e NoSQL. A tabela a seguir mostrará a diferença entre bancos de dados SQL e NoSQL.

SQL versus NoSQL

Nesta seção, vamos focar em um banco de dados NoSQL, o MongoDB. Vamos nos cadastrar no mongoDB clicando no botão sign in e depois clicando em register na próxima página.

Complete os campos e clique em continue

Selecione o plano gratuito

Escolha a região gratuita mais próxima e dê um nome ao seu cluster.

Agora, um sandbox gratuito é criado

Acesso a todos os hosts locais

Adicione um usuário e uma senha

Crie um link URI do mongoDB

Selecione o driver Python 3.6 ou superior

Obtendo a String de Conexão (URI do MongoDB)

Copie o link da string de conexão e você obterá algo como isto:

mongodb+srv://asabeneh:<password>@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority

Não se preocupe com a URL, ela é apenas um meio de conectar sua aplicação ao mongoDB. Vamos substituir o placeholder da senha pela senha que você usou para adicionar um usuário.

Exemplo:

mongodb+srv://asabeneh:123123123@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority

Agora, eu substituí tudo e a senha é 123123 e o nome do banco de dados é thirty_days_python. Isso é apenas um exemplo, sua senha deve ser mais forte do que a senha de exemplo.

O Python precisa de um driver mongoDB para acessar o banco de dados mongoDB. Usaremos pymongo com dnspython para conectar nossa aplicação com a base mongoDB. Dentro do diretório do seu projeto, instale o pymongo e o dnspython.

pip install pymongo dnspython

O módulo "dnspython" deve ser instalado para usar URIs mongodb+srv://. O dnspython é um toolkit de DNS para Python. Ele suporta quase todos os tipos de registros.

Conectando a aplicação Flask ao Cluster MongoDB

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
print(client.list_database_names())

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

Quando executamos o código acima, obtemos os bancos de dados padrão do mongoDB.

['admin', 'local']

Criando um banco de dados e uma coleção

Vamos criar um banco de dados; o banco de dados e a coleção no mongoDB serão criados se ainda não existirem. Vamos criar um banco de dados chamado thirty_days_of_python e uma coleção students.

Para criar um banco de dados:

db = client.name_of_databse # podemos criar um banco de dados assim ou da segunda forma
db = client['name_of_database']

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
# Criando o banco de dados
db = client.thirty_days_of_python
# Criando a coleção students e inserindo um documento
db.students.insert_one({'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250})
print(client.list_database_names())

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

Depois de criar um banco de dados, também criamos uma coleção students e usamos o método insert_one() para inserir um documento. Agora, o banco de dados thirty_days_of_python e a coleção students foram criados e o documento foi inserido. Verifique seu cluster mongoDB e você verá tanto o banco de dados quanto a coleção. Dentro da coleção, haverá um documento.

['thirty_days_of_python', 'admin', 'local']

Se você vir isso no cluster mongoDB, significa que você criou com sucesso um banco de dados e uma coleção.

Se você viu na figura, o documento foi criado com um id longo que atua como chave primária. Toda vez que criamos um documento, o mongoDB cria um id único para ele.

Inserindo vários documentos em uma coleção

O método insert_one() insere um item por vez; se quisermos inserir vários documentos de uma vez, usamos o método insert_many() ou um loop for. Podemos usar um loop for para inserir vários documentos de uma vez.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)

students = [
        {'name':'David','country':'UK','city':'London','age':34},
        {'name':'John','country':'Sweden','city':'Stockholm','age':28},
        {'name':'Sami','country':'Finland','city':'Helsinki','age':25},
    ]
for student in students:
    db.students.insert_one(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

Find no MongoDB

Os métodos find() e findOne() são métodos comuns para encontrar dados em uma coleção no banco de dados mongoDB. É similar à instrução SELECT em um banco de dados MySQL. Vamos usar o método find_one() para obter um documento em uma coleção do banco de dados.

• *find_one({"_id": ObjectId("id"}): Obtém a primeira ocorrência se um id não for fornecido

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
student = db.students.find_one()
print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Helsinki', 'city': 'Helsinki', 'age': 250}

A query acima retorna a primeira entrada, mas podemos direcionar um documento específico usando um _id específico. Vamos fazer um exemplo, usar o id de David para obter o objeto de David. '_id':ObjectId('5df68a23f106fe2d315bbc8c')

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
from bson.objectid import ObjectId # objeto id
MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
student = db.students.find_one({'_id':ObjectId('5df68a23f106fe2d315bbc8c')})
print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}

Vimos como usar find_one() com os exemplos acima. Vamos passar para find()

• find(): retorna todas as ocorrências de uma coleção se não passarmos um objeto de query. O objeto é um objeto cursor do pymongo.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
students = db.students.find()
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Podemos especificar quais campos retornar passando um segundo objeto em find({}, {}). 0 significa não incluir e 1 significa incluir, mas não podemos misturar 0 e 1, exceto para _id.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
students = db.students.find({}, {"_id":0,  "name": 1, "country":1}) # 0 significa não incluir e 1 significa incluir
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'name': 'Asabeneh', 'country': 'Finland'}
{'name': 'David', 'country': 'UK'}
{'name': 'John', 'country': 'Sweden'}
{'name': 'Sami', 'country': 'Finland'}

Find com Query

No mongoDB, find recebe um objeto de query. Podemos passar um objeto de query e filtrar os documentos que quisermos.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados

query = {
    "country":"Finland"
}
students = db.students.find(query)

for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Query com modificadores

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados

query = {
    "city":"Helsinki"
}
students = db.students.find(query)
for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Query com modificador

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
query = {
    "country":"Finland",
    "city":"Helsinki"
}
students = db.students.find(query)
for student in students:
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Query com modificadores

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
query = {"age":{"$gt":30}}
students = db.students.find(query)
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
query = {"age":{"$gt":30}}
students = db.students.find(query)
for student in students:
    print(student)

{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Limitando documentos

Podemos limitar o número de documentos retornados usando o método limit().

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
db.students.find().limit(3)

Find com ordenação

Por padrão, a ordenação é em ordem crescente. Podemos mudar a ordenação para decrescente adicionando o parâmetro -1.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
students = db.students.find().sort('name')
for student in students:
    print(student)


students = db.students.find().sort('name',-1)
for student in students:
    print(student)

students = db.students.find().sort('age')
for student in students:
    print(student)

students = db.students.find().sort('age',-1)
for student in students:
    print(student)

app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

Ordem crescente

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Ordem decrescente

{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}

Update com query

Usaremos o método update_one() para atualizar um item. Ele recebe dois objetos, um é a query e o segundo é o novo objeto. A primeira pessoa, Asabeneh, tem uma idade muito implausível. Vamos atualizar a idade de Asabeneh.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados

query = {'age':250}
new_value = {'$set':{'age':38}}

db.students.update_one(query, new_value)
# vamos verificar o resultado se a idade foi modificada
for student in db.students.find():
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Quando queremos atualizar vários documentos de uma vez, usamos o método update_many().

Excluindo um documento

O método delete_one() exclui um documento. O delete_one() recebe um objeto de query como parâmetro. Ele remove apenas a primeira ocorrência. Vamos remover um John da coleção.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados

query = {'name':'John'}
db.students.delete_one(query)

for student in db.students.find():
    print(student)
# vamos verificar o resultado se a idade foi modificada
for student in db.students.find():
    print(student)


app = Flask(__name__)
if __name__ == '__main__':
    # para o deploy usamos o environ
    # para que funcione tanto em produção quanto em desenvolvimento
    port = int(os.environ.get("PORT", 5000))
    app.run(debug=True, host='0.0.0.0', port=port)

{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38}
{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34}
{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25}

Como você pode ver, John foi removido da coleção.

Quando queremos excluir vários documentos, usamos o método delete_many(), que recebe um objeto de query. Se passarmos um objeto de query vazio para delete_many({}), ele excluirá todos os documentos da coleção.

Excluindo uma coleção

Usando o método drop() podemos excluir uma coleção de um banco de dados.

# vamos importar o flask
from flask import Flask, render_template
import os # importando o módulo do sistema operacional
import pymongo

MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority'
client = pymongo.MongoClient(MONGODB_URI)
db = client['thirty_days_of_python'] # acessando o banco de dados
db.students.drop()

Agora, excluímos a coleção students do banco de dados.

💻 Exercícios: Dia 27

🎉 PARABÉNS ! 🎉

<< Dia 26 | Dia 28 >>