1.

2.

3.

4.

5.

6.

7.

8.

• Airbyte:

9.

• AWS Glue:

10.

• Metabase:
• Google Data Studio:

11.

• pandas:

12.

1.

import requests
from bs4 import BeautifulSoup

url = 'http://example.com'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

2.

tables = soup.find_all('table')

3.

import pandas as pd
data = []

for table in tables:
    rows = table.find_all('tr')
    for row in rows:
        cols = row.find_all('td')
        cols = [ele.text.strip() for ele in cols]
        data.append(cols)
df = pd.DataFrame(data)

4.

df.dropna(inplace=True)  # Drop missing values

5.

df.to_csv('scraped_data.csv', index=False)

df_list = pd.read_html('http://example.com')
df = df_list[0]  # Assuming the table of interest is the first one

13.

import dask.dataframe as dd
df = dd.read_csv('large_dataset.csv')

• PySpark:

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('data_processing').getOrCreate()
df = spark.read.csv('large_dataset.csv', header=True, inferSchema=True)

import pandas as pd
chunk_size = 10000
for chunk in pd.read_csv('large_dataset.csv', chunksize=chunk_size):
    process(chunk)  # Replace with your processing function

14.

import cProfile
cProfile.run('your_function()')

import numpy as np
data = np.array([1, 2, 3, 4, 5])
result = data * 2  # Vectorized operation

data_dict = {'key1': 'value1', 'key2': 'value2'}  # Faster lookups compared to lists

from multiprocessing import Pool

def process_data(data_chunk):
    # Your processing logic here
    return processed_chunk
with Pool(processes=4) as pool:
    results = pool.map(process_data, data_chunks)

from functools import lru_cache
  
@lru_cache(maxsize=None)
def expensive_computation(x):
    # Perform expensive computation
    return result

15.

 def validate_data(df):
     assert df['age'].min() >= 0, "Age cannot be negative"
     assert df['salary'].dtype == 'float64', "Salary should be a float"

     # Additional checks...

 df.dropna(inplace=True)  # Drop missing values
 df.drop_duplicates(inplace=True)  # Remove duplicates

import pytest
  
def test_clean_data():
    raw_data = pd.DataFrame({'age': [25, -3], 'salary': ['50k', '60k']})
    clean_data = clean_data_function(raw_data)
    assert clean_data['age'].min() >= 0
    assert clean_data['salary'].dtype == 'float64'

 from airflow import DAG
 from airflow.operators.dummy_operator import DummyOperator
 from airflow.operators.email_operator import EmailOperator

 # Define your DAG and tasks...

16.

• Removal:

 df.dropna(inplace=True)

 df['column'].fillna(df['column'].mean(), inplace=True)

 df['column_missing'] = df['column'].isnull().astype(int)

 from sklearn.impute import KNNImputer
 imputer = KNNImputer(n_neighbors=5)
 df = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)

17.

SELECT *
FROM class
WHERE id IN (
  SELECT DISTINCT id
  FROM students
  WHERE grade = "A"
  AND major = "Science"
);

WITH temp AS (
  SELECT id
  FROM students
  WHERE grade = "A"
  AND major = "Science"
)
SELECT *
FROM class
WHERE id IN (SELECT id FROM temp);

18.

SELECT
  id,
  sales,
  RANK() OVER (ORDER BY sales DESC) AS rank
FROM bill;

19.

CREATE TEMPORARY FUNCTION get_gender(type VARCHAR) RETURNS VARCHAR AS (
  CASE 
    WHEN type = "M" THEN "male"
    WHEN type = "F" THEN "female"
    ELSE "n/a"
  END
);
SELECT
  name,
  get_gender(type) AS gender
FROM class;

20.

SELECT
  department,
  product,
  SUM(sales) AS total_sales
FROM sales_data
GROUP BY ROLLUP(department, product);

21.

SELECT id, COALESCE(salary, 0) AS salary FROM employees;

 SELECT id, 
        CASE 
          WHEN salary IS NULL THEN 0 
          ELSE salary 
        END AS salary 
 FROM employees;

22.

SELECT department, 
       SUM(salary) AS total_salary, 
       AVG(salary) AS average_salary, 
       COUNT(*) AS employee_count 
FROM employees 
GROUP BY department;

23.

24.

25.

26.

27.

28.

29.

30.

31.

32.

def is_valid(ip):
    ip = ip.split(".")
   
    for i in ip:
        if len(i) > 3 or int(i) < 0 or int(i) > 255:
            return False
        if len(i) > 1 and int(i) == 0:
            return False
        if len(i) > 1 and int(i) != 0 and i[0] == '0':
            return False
           
    return True
A = "255.255.11.135"
B = "255.050.11.5345"
print(is_valid(A))  # True
print(is_valid(B))  # False

33. Quais são os vários modos do Hadoop?

O Hadoop funciona principalmente em três modos:

• Modo autônomo: Esse modo é usado para fins de depuração. Ele não usa o HDFS e depende do sistema de arquivos local para entrada e saída.
• Modo pseudo-distribuído: Este é um cluster de nó único no qual o NameNode e o DataNode residem na mesma máquina. Ele é usado principalmente para testes e desenvolvimento.
• Modo totalmente distribuído: Esse é um modo pronto para produção no qual os dados são distribuídos em vários nós, com nós separados para os daemons mestre (NameNode) e escravo (DataNode).

Perguntas da entrevista com o engenheiro de dados do Google

34. Como você lidaria com pontos de dados duplicados em uma consulta SQL?

Para lidar com duplicatas no SQL, você pode usar a palavra-chave DISTINCT ou excluir linhas duplicadas usando ROWID com a função MAX ou MIN. Aqui estão alguns exemplos:

Usando o site DISTINCT:

SELECT DISTINCT Name, ADDRESS 
FROM CUSTOMERS 
ORDER BY Name;

Exclusão de duplicatas usando ROWID:

DELETE FROM Employee
WHERE ROWID NOT IN (
  SELECT MAX(ROWID)
  FROM Employee
  GROUP BY Name, ADDRESS
);

35. Dada uma lista de n-1 números inteiros, esses números inteiros estão no intervalo de 1 a n. Não há duplicatas na lista. Um dos números inteiros está faltando na lista. Você pode escrever um código eficiente para encontrar o número inteiro que falta?

Esse desafio comum de codificação pode ser resolvido usando uma abordagem matemática:

def search_missing_number(list_num):
    n = len(list_num)
    # Check if the first or last number is missing
    if list_num[0] != 1:
        return 1
    if list_num[-1] != n + 1:
        return n + 1
    # Calculate the sum of the first n+1 natural numbers
    total = (n + 1) * (n + 2) // 2
    # Calculate the sum of all elements in the list
    sum_of_L = sum(list_num)
    # Return the difference, which is the missing number
    return total - sum_of_L
# Validation
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13]
print("The missing number is", search_missing_number(num_list))  # The missing number is 12

Como se preparar para a entrevista com o engenheiro de dados

Antes de comparecer a uma entrevista, você deve rever todos os conceitos e termos padrão usados na engenharia de dados. Aqui estão algumas das áreas mais importantes nas quais você deve se concentrar:

• Master SQL: Você deve praticar a criação, a modificação e o gerenciamento de bancos de dados. Além disso, você deve dominar a análise, a modelagem e a transformação de dados.
• Resolva desafios de codificação: Resolva desafios de codificação em Python, Scala ou C++. A maioria das empresas avalia as habilidades de programação por meio de exames em casa e desafios de codificação ao vivo. 
• Projetar um pipeline de ETL: prática para criar dados, ETL ou pipelines de entrega. Você deve entender como testar, validar, dimensionar e manter pipelines de dados. 
• Engenharia analítica: prática de carregamento, transformação e análise de dados. Aprenda a criar um painel de controle para a qualidade dos dados e o desempenho do sistema. 
• Analise as possíveis perguntas: Prepare-se para a entrevista analisando exemplos de perguntas simuladas. Uma simples pesquisa no Google dará a você acesso a centenas de perguntas. 
• Conheça as ferramentas modernas de engenharia de dados: mesmo que não tenha experiência com ferramentas modernas de engenharia de dados, você deve saber como elas funcionam e como se integram a outras ferramentas. As empresas estão sempre buscando ferramentas melhores para melhorar o desempenho a um custo menor.
• Aprenda sobre processamento em lote e streaming: O Apache Spark é usado para processamento em lote, e o Apache Kafka é usado para streaming de dados. Essas ferramentas estão em alta demanda e ajudarão você a conseguir um emprego nas melhores empresas.
• Meio ambiente: Às vezes, o entrevistador perguntará sobre computação em nuvem (GCP, AWS, Azure), Docker, scripts, Terraform e Kubernetes. Você pode usar essas ferramentas para configurar recursos de armazenamento e computadores na nuvem ou no local. Compreender essas tecnologias e integrá-las aos projetos do portfólio é uma boa prática. 

Preparar-se para uma entrevista de engenharia de dados pode ser um desafio, mas com os recursos e a prática certos, você pode se destacar e conseguir o emprego dos seus sonhos. Para aprimorar ainda mais suas habilidades e conhecimentos, confira estes valiosos recursos:

• Entendendo a engenharia de dados: Obter uma compreensão abrangente dos conceitos e princípios da engenharia de dados.
• Engenheiro de dados em Python: Domine a engenharia de dados com Python por meio desta trilha de carreira, que abrange ferramentas e estruturas essenciais.
• Projeto de banco de dados: Aprenda os fundamentos do design de bancos de dados para criar bancos de dados eficientes e dimensionáveis.

Aproveite esses cursos para solidificar sua base e ficar à frente em sua carreira de engenharia de dados. Boa sorte em suas entrevistas!