Perguntas da entrevista do engenheiro de dados com Python

• Entenda as perguntas comuns da entrevista do engenheiro de dados
• Distinguir entre bancos de dados relacionais e não relacionais
• Configurar bancos de dados usando Python
• Usar Python para consultar dados

Tornar-se um engenheiro de dados

O que faz um engenheiro de dados?

Como o Python pode ajudar os engenheiros de dados?

Responder a perguntas da entrevista do engenheiro de dados

Perguntas sobre bancos de dados relacionais

• NoSQL
• Bancos de dados de cache
• Bancos de dados gráficos
• Suporte NoSQL em bancos de dados SQL

Q1:Bancos de dados relacionais x não relacionais

Um exemplo SQLite

import sqlite3

db = sqlite3.connect(':memory:')  # Using an in-memory database
cur = db.cursor()

1. Cliente: Essa tabela conterá uma chave primária, bem como o nome e sobrenome do cliente.
2. Itens: Esta tabela conterá uma chave primária, o nome do item e o preço do item.
3. Itens comprados :Esta tabela conterá um número de pedido, data e preço. Ele também se conectará às chaves primárias nas tabelas Itens e Clientes.

cur.execute('''CREATE TABLE IF NOT EXISTS Customer (
                id integer PRIMARY KEY,
                firstname varchar(255),
                lastname varchar(255) )''')
cur.execute('''CREATE TABLE IF NOT EXISTS Item (
                id integer PRIMARY KEY,
                title varchar(255),
                price decimal )''')
cur.execute('''CREATE TABLE IF NOT EXISTS BoughtItem (
                ordernumber integer PRIMARY KEY,
                customerid integer,
                itemid integer,
                price decimal,
                CONSTRAINT customerid
                    FOREIGN KEY (customerid) REFERENCES Customer(id),
                CONSTRAINT itemid
                    FOREIGN KEY (itemid) REFERENCES Item(id) )''')

cur.execute('''INSERT INTO Customer(firstname, lastname)
               VALUES ('Bob', 'Adams'),
                      ('Amy', 'Smith'),
                      ('Rob', 'Bennet');''')
cur.execute('''INSERT INTO Item(title, price)
               VALUES ('USB', 10.2),
                      ('Mouse', 12.23),
                      ('Monitor', 199.99);''')
cur.execute('''INSERT INTO BoughtItem(customerid, itemid, price)
               VALUES (1, 1, 10.2),
                      (1, 2, 12.23),
                      (1, 3, 199.99),
                      (2, 3, 180.00),
                      (3, 2, 11.23);''') # Discounted price 

Q2:Funções de agregação SQL

>>> cur.execute('''SELECT itemid, AVG(price) FROM BoughtItem GROUP BY itemid''')
>>> print(cur.fetchall())
[(1, 10.2), (2, 11.73), (3, 189.995)]

>>> cur.execute('''SELECT item.title, AVG(boughtitem.price) FROM BoughtItem as boughtitem
...             INNER JOIN Item as item on (item.id = boughtitem.itemid)
...             GROUP BY boughtitem.itemid''')
...
>>> print(cur.fetchall())
[('USB', 10.2), ('Mouse', 11.73), ('Monitor', 189.995)]

>>> cur.execute('''SELECT customer.firstname, SUM(boughtitem.price) FROM BoughtItem as boughtitem
...             INNER JOIN Customer as customer on (customer.id = boughtitem.customerid)
...             GROUP BY customer.firstname''')
...
>>> print(cur.fetchall())
[('Amy', 180), ('Bob', 222.42000000000002), ('Rob', 11.23)]

T3:Acelerando as consultas SQL

• Juntas
• Agregações
• Travessias
• Registros

Q4:depuração de consultas SQL

>>> cur.execute('''EXPLAIN QUERY PLAN SELECT customer.firstname, item.title, 
...                item.price, boughtitem.price FROM BoughtItem as boughtitem
...                INNER JOIN Customer as customer on (customer.id = boughtitem.customerid)
...                INNER JOIN Item as item on (item.id = boughtitem.itemid)''')
...
>>> print(cur.fetchall())
[(4, 0, 0, 'SCAN TABLE BoughtItem AS boughtitem'), 
(6, 0, 0, 'SEARCH TABLE Customer AS customer USING INTEGER PRIMARY KEY (rowid=?)'), 
(9, 0, 0, 'SEARCH TABLE Item AS item USING INTEGER PRIMARY KEY (rowid=?)')]

SCAN TABLE BoughtItem AS boughtitem
SEARCH TABLE Customer AS customer USING INTEGER PRIMARY KEY (rowid=?)
SEARCH TABLE Item AS item USING INTEGER PRIMARY KEY (rowid=?)

Perguntas sobre bancos de dados não relacionais

Um exemplo do MongoDB

$ pip install pymongo

import pymongo

client = pymongo.MongoClient("mongodb://localhost:27017/")

# Note: This database is not created until it is populated by some data
db = client["example_database"]

customers = db["customers"]
items = db["items"]

customers_data = [{ "firstname": "Bob", "lastname": "Adams" },
                  { "firstname": "Amy", "lastname": "Smith" },
                  { "firstname": "Rob", "lastname": "Bennet" },]
items_data = [{ "title": "USB", "price": 10.2 },
              { "title": "Mouse", "price": 12.23 },
              { "title": "Monitor", "price": 199.99 },]

customers.insert_many(customers_data)
items.insert_many(items_data)

Q5:consulta de dados com o MongoDB

# Just add "boughtitems" to the customer where the firstname is Bob
bob = customers.update_many(
        {"firstname": "Bob"},
        {
            "$set": {
                "boughtitems": [
                    {
                        "title": "USB",
                        "price": 10.2,
                        "currency": "EUR",
                        "notes": "Customer wants it delivered via FedEx",
                        "original_item_id": 1
                    }
                ]
            },
        }
    )

amy = customers.update_many(
        {"firstname": "Amy"},
        {
            "$set": {
                "boughtitems":[
                    {
                        "title": "Monitor",
                        "price": 199.99,
                        "original_item_id": 3,
                        "discounted": False
                    }
                ]
            } ,
        }
    )
print(type(amy))  # pymongo.results.UpdateResult

>>> customers.create_index([("name", pymongo.DESCENDING)])

>>> items = customers.find().sort("name", pymongo.ASCENDING)

>>> for item in items:
...     print(item.get('boughtitems'))    
...
None
[{'title': 'Monitor', 'price': 199.99, 'original_item_id': 3, 'discounted': False}]
[{'title': 'USB', 'price': 10.2, 'currency': 'EUR', 'notes': 'Customer wants it delivered via FedEx', 'original_item_id': 1}]

>>> customers.distinct("firstname")
['Bob', 'Amy', 'Rob']

>>> for i in customers.find({"$or": [{'firstname':'Bob'}, {'firstname':'Amy'}]}, 
...                                  {'firstname':1, 'boughtitems':1, '_id':0}):
...     print(i)
...
{'firstname': 'Bob', 'boughtitems': [{'title': 'USB', 'price': 10.2, 'currency': 'EUR', 'notes': 'Customer wants it delivered via FedEx', 'original_item_id': 1}]}
{'firstname': 'Amy', 'boughtitems': [{'title': 'Monitor', 'price': 199.99, 'original_item_id': 3, 'discounted': False}]}

SELECT firstname, boughtitems FROM customers WHERE firstname LIKE ('Bob', 'Amy')

Q6:NoSQL vs SQL

• Pesquisa elástica é altamente eficiente na pesquisa de texto. Ele aproveita seu banco de dados baseado em documentos para criar uma poderosa ferramenta de pesquisa.
• Newt DB combina ZODB e o recurso PostgreSQL JSONB para criar um banco de dados NoSQL compatível com Python.
• InfluxDB é usado em aplicativos de série temporal para armazenar eventos.

Perguntas sobre bancos de dados de cache

Um exemplo do Redis

P7:Como usar bancos de dados de cache

$ pip install redis

import redis
from datetime import timedelta

# In a real web application, configuration is obtained from settings or utils
r = redis.Redis()

# Assume this is a getter handling a request
def get_name(request, *args, **kwargs):
    id = request.get('id')
    if id in r:
        return r.get(id)  # Assume that we have an {id: name} store
    else:
        # Get data from the main DB here, assume we already did it
        name = 'Bob'
        # Set the value in the cache database, with an expiration time
        r.setex(id, timedelta(minutes=60), value=name)
        return name

Perguntas sobre padrões de design e conceitos de ETL

1. Um valor no banco de dados nº 1 é atualizado.
2. Esse mesmo valor no Banco de Dados #2 é mantido o mesmo (não atualizado).
3. Uma consulta é executado no banco de dados nº 2.

1. Extrair: Há um gatilho do MongoDB sempre que um registro é criado, atualizado e assim por diante. Uma função de retorno de chamada é chamada de forma assíncrona em um encadeamento separado.
2. Transformar: Partes do registro são extraídas, normalizadas e colocadas na estrutura de dados (ou linha) correta para serem inseridas no SQL.
3. Carregar: O banco de dados SQL é atualizado em lotes ou como um único registro para gravações de alto volume.

Q8:Desafios de ETL

• Grandes dados
• Problemas com estado
• Trabalhadores assíncronos
• Correspondência de tipo

Q9:Padrões de design em Big Data

Q10:Aspectos comuns do processo ETL e fluxos de trabalho de Big Data

Conclusão

• Use Python com SQL, NoSQL e bancos de dados de cache
• Use Python em ETL e aplicativos de consulta
• Planeje projetos com antecedência, mantendo o design e o fluxo de trabalho em mente