Tempo de leitura:
Neste artigo vou mostrar-te como podes manipular dados de uma base de dados com Python utilizando métodos mais simples que em Excel e Power Query. Vamos utilizar a biblioteca Pandas para manipular DataFrames e obter de forma dinâmica linhas e colunas da base de dados.
Com Python podes aceder a dados externos como ficheiros csv e manipular os mesmos para moldar as tabelas de acordo com a tua necessidade.
No cenário vamos obter um conjunto de dados através de um ficheiro csv, que será importado através do Power Query, mas vamos usar Python para moldar os dados em vez do Power Query!
Definir a DataFrame de base
Para começar o nosso cenário vamos converter os dados numa DataFrame, que é basicamente uma Tabela que pode ser de seguida trabalhada.
Para iniciar o código Python numa célula podemos aceder ao separador Formulas -> Inserir Python ou escrever diretamente numa célula: =PY
df = pd.DataFrame(xl(“dados”))
O comando define uma variável “df” que representa a DataFrame. O nome “df” é apenas um exemplo, sendo que podes usar qualquer nome para representar a variável. O nome não pode conter espaços.
O método DataFrame do módulo pd (pandas) permite criar uma DataFrame através da query “dados”.
Para confirmar o código devemos pressionar: [CTRL] + [ENTER]
O resultado é um objeto de Python -> DataFrame, que podemos converter num intervalo (Array Dinâmico) e visualizar os dados na folha de cálculo.
Para definir a saída para um valor de Excel podemos também usar a combinação das teclas:
[CRTL] + [ALT] + [SHIFT] + [M]
O resultado apresentado na folha de cálculo.
Mostrar apenas um conjunto de linhas no topo
Para mostrarmos apenas um conjunto de linhas do topo da DataFrame, de modo a obtermos uma amostra dos dados, podemos usar o método .head().
Sem argumentos o método devolve apenas as 5 primeiras linhas, mas podemos indicar o número de linhas pretendido.
Numa nova célula, vamos então executar o código, recorrendo agora à variável “df” que representa a nossa DataFrame.
df.head(5)
Obter colunas específicas da DataFrame
Para obter colunas específicas da DataFrame, devemos indicar as colunas pelo seu nome. Se definirmos apenas uma coluna é devolvida uma Serie (Coluna). Selecionando mais do que uma coluna, obtemos uma DataFrame. Quando especificamos várias colunas estas devem ser especificadas como uma Lista (Estrutura de dados de Python).
df[[“Produto”, “Preço de fabrico”, “Vendas_brutas”]].head(5)
No exemplo serão devolvidas as 5 primeiras linhas das colunas: Produto, Preço de Fabrico e Vendas Brutas.
Devolver linhas e colunas específicas
Usando o método .loc é possível definir um conjunto de linhas e colunas especificas para selecionar da DataFrame.
df.loc[3:7, [‘Produto’, ‘Preço de fabrico’, ‘Ano’, ‘Margem’, ‘País’]]
Usar o Método .filter()
Através do método filter() é possível também filtrar colunas específicas na DataFrame.
df.filter([“País”, “Produto”]).head(5)
Filtrar colunas com caracteres específicos
Usando o método .filter() podemos especificar, usando o parâmetro like, colunas com caracteres específicos para filtrar.
No exemplo, vamos filtrar todas as colunas que contém “_”.
df.filter(like=”_”).head(10)
Selecionar colunas por tipo de dados
Com o método .select_dtypes() podemos selecionar colunas com um determinado tipo de dados.
Por exemplo podemos retornar apenas colunas que contem valores inteiros como tipo de dados.
df.select_dtypes(“int”).head(5)
Podemos colocar o parâmetro “float” para selecionar colunas com tipo de dados -> Decimal.
df.select_dtypes(“float”).head(5)
Incluir colunas com múltiplos tipos de dados
Se acrescentarmos o parâmetro include selecionamos colunas com vários tipos de dados.
df.select_dtypes(include = [“int”, “float”]).head(5)
E se o objetivo é excluir um conjunto de colunas de acordo com o Tipo de Dados, podemos usar o parâmetro exclude.
df.select_dtypes(exclude = [“int”, “float”]).head(5)
Definir uma máscara (mask) para o critério de filtro
Podemos atribuir critérios de filtro diversos, combinando por exemplo a lógica “AND” e “OR”. Para tornar o código mais fácil de interpretar e ler, normalmente usa-se o conceito de máscara, que armazena os critérios e depois é utilizado como parâmetro do método .loc visto anteriormente.
mask = df[“País”] == “Alemanha”
df.loc[mask].head(10)
Agora um exemplo com múltiplos critérios onde aplicamos o conceito lógico “AND” que é usado com “&” para definir múltiplos critérios.
mask = (df[“País”] == “Alemanha”) & (df[“Produto”] == “Montana”)
df.loc[mask]
Se alterarmos a lógica para “OR” -> | obtemos todos os valores com o país – Alemanha ou o produto – Montana.
mask = (df[“País”] == “Alemanha”) | (df[“Produto”] == “Montana”)
df.loc[mask]
E naturalmente com o método loc podemos também escolher as colunas que pretendemos devolver.
mask = (df[“País”] == “Alemanha”) | (df[“Produto”] == “Montana”)
df.loc[mask , [“País”, “Produto”, “Vendas”]]
Usar o Excel para definir um critério dinâmico
E já que estamos a usar Python no Excel, porque não aproveitar o potencial do Excel. Podemos usar as células do Excel como Inputs para definir os parâmetros de filtro de uma forma dinâmica.
mask = (df[“Unidades_Vendidas”] >= xl(“B3”)) & (df[“Vendas”] >= xl(“B4”))
df.loc[mask , [“País”, “Produto”, “Unidades_Vendidas”, “Vendas”]]
E como podes ver com apenas alguns comandos de Python moldamos o intervalo de inúmeras formas e feitios!
Próximo artigo:
Artigo Anterior:
Artigos por Categoria
Artigos por Categoria
- Microsoft Excel (44)
- Power Apps (16)
- Power Automate (3)
- Power BI (11)
- Power Query (14)
- Python (3)
- VBA (7)
Leave a Reply