Neste tutorial vamos escrever um pequeno programa em linguagem Python que irá gerar uma lista com os números de 1 até 1000 (sequenciais), colocados depois em ordem aleatória, e então retirar um único número dessa lista, de forma aleatória também (não sabemos qual será o número retirado).

Na sequência, o programa executará uma função que varre essa lista e descobre qual o número que está faltando, informando-o ao usuário.

Qual o nosso objetivo com esse script? Estudar e praticar técnicas de programação. No caso iremos trabalhar com geração de números aleatórios, embaralhamento de listas, definição de funções e aplicação de lógica para resolver problemas.

Abaixo temos o código usado, e na sequência a explicação detalhada de seu funcionamento. Fique à vontade para alterar o código a seu gosto, modificando ou acrescentando funcionalidades ao script.

Código em Python

import random

# Função para encontrar o número que está faltando
def encontrar_numero_faltando(lista):
    # A soma esperada dos números de 1 a 1000
    soma_esperada = sum(range(1, 1001))
    # A soma dos números na lista com um número faltando
    soma_lista = sum(lista)
    # O número que está faltando será a diferença entre a soma esperada e a soma da lista
    return soma_esperada - soma_lista

# Gerar uma lista de 1 a 1000
lista_numeros = list(range(1, 1001))

# Embaralhar a lista de forma aleatória
random.shuffle(lista_numeros)

# Remove um número aleatório da lista
numero_removido = random.choice(lista_numeros)
lista_numeros.remove(numero_removido)

# Mostrar a lista
print(f'Lista de números: \n{lista_numeros}')

# Encontrar o número faltando e exibir para o usuário
numero_faltando = encontrar_numero_faltando(lista_numeros)
print(f'\nO número faltando é: {numero_faltando}')

Como funciona esse script

Inicialmente, importamos o módulo random, que será necessário para a geração e manipulação dos números aleatórios (na verdade, pseudoaleatórios) que necessitaremos.

Na sequência, definimos a função “encontrar_numero_faltando“, que recebe como argumento a lista de números que será analisada.

Para determinar o número que está ausente nesta lista (haverá apenas um único número ausente dentre os mil valores), podemos aplicar várias técnicas. Aqui, iremos calcular a soma dos números de 1 até 1000 (armazenada na variável soma_esperada), e na sequência somaremos todos os números da lista passada à função, armazenado esse valor na variável soma_lista.

Então, basta subtrair da soma_esperada o valor de soma_lista, e o resultado será o número que falta (ausente). A função então retorna esse valor.

Fora da função, geramos uma lista de 1 até 1000 usando a função list() combinada com a função range, embaralhamos os números com o método random.shuffle, e retiramos um número da lista com os métodos random.choice (escolhe o número) e lista_numeros.remove (remove esse número da lista).

Na sequência, exibimos a lista na tela com a função print, e finalmente encontramos o número faltante chamando a função criada encontrar_numero_faltando, exibindo no final seu valor para o usuário.

Note que cada vez que o script for executado, um número diferente será sacado da lista, pois a escolha do valor a ser retirado pelo método choice é aleatória.

Conclusão

Com este pequeno script pudemos treinar o emprego e manipulação de números aleatórios, além da criação de funções e da aplicação de raciocínio lógico para a resolução de problemas com programação.

Você pode alterar o algoritmo para, por exemplo, gerar mais de 1000 números (que tal 1 milhão de valores?) e rodá-lo para testar sua performance e verificar sua utilidade. Será que ele ainda roda de forma satisfatória?

Você também pode tentar portar esse script para outras linguagens de programação que prefira, como por exemplo JavaScript, C# ou Rust, para treinar abordagens ligeiramente diferentes de codificação.

O post Descobrir número que falta em lista de 1000 números sequenciais em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Função built-in é uma função que já está disponível para uso imediato no interpretador Python (ou em outras linguagens de programação), ou seja, faz parte do próprio núcleo da linguagem. Essas funções fornecem funcionalidades essenciais que são amplamente utilizadas no desenvolvimento de programas. São também chamadas de funções internas.

Algumas das funções built-in mais comuns incluem print(), len(), type(), sum(), max(), min(), entre outras. Elas estão sempre disponíveis e não requerem importação de módulos adicionais para serem utilizadas em um programa Python.

A lista a seguir traz as funções internas do Python com uma breve descrição de cada uma.

Funções internas do Python

É isso aí! Vimos neste artigo um resumo de todas as funções internas do Python, com uma breve descrição de cada uma delas. Para saber mais sobre cada uma dessas funções built-in, consulte a documentação oficial do Python na página a seguir: Funções Built-In do Python.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Lista de funções built-in do Python (funções internas) apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos discutir brevemente os tipos de dados disponíveis no SQLite, juntamente com os tipos de dados correspondentes no Python.

O que são Tipos de Dados?

Os tipos de dados representam os diferentes formatos e faixas de valores que podem ser armazenados em um banco de dados. Eles definem o tipo de informação que pode ser armazenado em uma coluna de uma tabela, e seu domínio (faixa de valores válidos).

Também determinam como os dados serão armazenados em disco, como serão manipulados e quais operações podem (ou não) ser realizadas sobre eles.

Os tipos em um banco de dados são importantes porque garantem a integridade dos dados e ajudam a otimizar o armazenamento e a recuperação de informações. Cada um tem suas próprias características e restrições, e é importante escolher o tipo mais apropriado para cada coluna com base no tipo de informação que será armazenada.

Classificação dos tipos de dados

Podemos classificar os tipos de dados em bancos de dados da seguinte forma:

• Tipos numéricos: Armazenam valores numéricos, como valores inteiros, números de ponto flutuante e números decimais.
• Tipos de caracteres: Armazenam strings de caracteres, como nomes, endereços e descrições. Podem incluir tipos de caracteres fixos (char) e variáveis (varchar).
• Tipos de data e hora: Armazenam datas, horas ou data e hora combinadas. Isso pode incluir tipos como DATE, TIME, DATETIME e TIMESTAMP.
• Tipos booleanos: Armazenam valores booleanos, como verdadeiro (true) ou falso (false).
• Tipos de sequência: Armazenam sequências de bytes, como imagens, arquivos de áudio ou arquivos binários.
• Tipos de coleção: Permitem armazenar coleções de valores, como listas, conjuntos e dicionários.
• Tipos especiais: Alguns bancos de dados oferecem tipos de dados especiais para armazenar dados geoespaciais, JSON, endereços de rede, XML, etc.

Vejamos agora como são classificados os tipos de dados no SQLite.

Classe de Armazenamento em SQLite

Uma classe de armazenamento é, basicamente, uma coleção de tipos de dados similares, como tipos inteiros, de ponto flutuante ou de strings. Em SQLite existem as seguintes cinco classes de armazenamento (tipos de dados) disponíveis:

E o tipo booleano (lógico)?

O SQLite não possui uma classe de armazenamento separada para dados booleanos. Em vez disso, valores booleanos são armazenados na forma de números inteiros 0 (equivalente a falso) e 1 (equivalente a verdadeiro).

O sistema também reconhece as palavras-chave “TRUE” e “FALSE”, a partir da versão 3.23.0, sendo, na verdade, apenas grafias alternativas para os literais inteiros 1 e 0, respectivamente.

Na tabela a seguir comparamos os tipos de dados em SQLite e seus tipos correspondentes em Python:

É importante lembrar que o SQLite é um banco de dados de tipagem dinâmica, ou ainda tipagem flexível, o que significa que ele é flexível em relação aos tipos de dados e pode converter automaticamente entre tipos, se for necessário, em vez de usar tipos rígidos por padrão (que também estão disponíveis). Mas o que significa isso? Significa que:

No SQLite, o tipo de dados de um valor está associado ao próprio valor, não ao seu contêiner (no caso, uma coluna de tabela).

Além disso, o sistema de tipos dinâmicos do SQLite é compatível com versões anteriores dos sistemas de tipos estáticos mais comuns de outros mecanismos de banco de dados, no sentido de que as instruções SQL que funcionam em bancos de dados de tipo estaticamente funcionam da mesma maneira no SQLite.

O tipo de dados ANY

Quando o tipo de dados de uma coluna é “ANY“, significa que qualquer tipo de dados – números inteiros, de ponto flutuante, strings ou blobs binários – pode ser inserido nessa tabela e seu valor e tipo de dados serão preservados exatamente como foram inseridos. Atualmente, o SQLite é o único mecanismo de banco de dados SQL que suporta esse recurso.

O comportamento de ANY é ligeiramente diferente em uma tabela STRICT (de tipagem rígida) e em uma tabela comum. Em uma tabela STRICT, uma coluna do tipo ANY sempre preserva os dados exatamente como eles são recebidos. Já em uma tabela comum não estrita, uma coluna do tipo ANY tentará converter strings que se parecem com números em um valor numérico e, se não ocorrerem erros, armazenará o valor numérico em vez da string original.

O que é Afinidade de Tipos

Afinidade de Tipos é um conceito no SQLite de como são associados os tipos de dados de colunas a uma das cinco categorias de tipos que ele suporta internamente, explicadas acima.

Apesar do SQLite ser um banco de dados de tipo dinâmico e permitir a inserção de qualquer tipo de dado em qualquer coluna, ele ainda possui esse sistema de afinidade de tipos que ajuda a interpretar e armazenar os dados de maneira eficiente e consistente.

Para isso algumas regras são definidas, descritas na sequência.

Regras de Afinidade de Tipos no SQLite

Quando uma tabela é criada no SQLite e especificamos os tipos de dados para as colunas, são aplicadas regras de afinidade de tipos para determinar a categoria interna mais adequada. Essas regras são baseadas nos nomes dos tipos de dados fornecidos.

Vejamos algumas regras gerais.

• INTEGER: Qualquer coluna com “INT” no tipo terá afinidade INTEGER.
• TEXT: Qualquer coluna com “CHAR”, “VARCHAR”, “CLOB”, ou “TEXT” no tipo terá afinidade TEXT.
• BLOB: Qualquer coluna com o tipo “BLOB” terá afinidade BLOB.
• REAL: Qualquer coluna com “REAL”, “FLOAT”, ou “DOUBLE” no tipo terá afinidade REAL.
• NUMERIC: Qualquer coluna que não se encaixe nas regras acima terá afinidade NUMERIC.

Ao inserir dados em uma coluna, o SQLite tentará converter o valor para o tipo de afinidade da coluna.

Para saber mais e se aprofundar em tipos de dados no SQLite, visite a página da documentação oficial: Tipos de Dados no SQLite.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Tipos de Dados no SQLite e tipos correspondentes em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste tutorial veremos como criar um banco de dados usando o SGBD SQLite e como acessá-lo para realizar tarefas variadas a partir de um script em Python. Para tal, faremos uso da biblioteca built-in sqlite3, explorando sua funcionalidade básica na criação e acesso a dados armazenados em um banco de dados.

Primeiramente, vamos conceituar o que é o SQLite.

O que é o SQLite

O SQLite é uma biblioteca de software que fornece um sistema de gerenciamento de bancos de dados relacional (SGBDR). Trata-se de uma biblioteca muito leve (daí o termo “lite“) em termos de configuração, administração do BD e recursos necessários.

Presente em todos os smartphones e na maioria dos computadores e outros equipamentos, é software livre e de código aberto.

Site oficial: https://www.sqlite.org/

Características principais do SQLite

• Autocontido: O SQLite é independente, o que significa que requer suporte mínimo do sistema operacional ou biblioteca externa. Isso o torna utilizável em qualquer ambiente, especialmente em dispositivos incorporados como iPhones, telefones Android, consoles de jogos, reprodutores de mídia portáteis, etc.
  É desenvolvido usando ANSI-C. O código-fonte está disponível nos arquivos sqlite3.c e seu arquivo de cabeçalho sqlite3.h. Se precisarmos desenvolver uma aplicação que utilize SQLite, basta colocar esses arquivos no projeto e compilá-lo com seu código.
• Sem servidor (serverless): Normalmente, um SGBDR como MySQL, PostgreSQL, etc., requer um processo de servidor separado para operar. As aplicações que desejam acessar o servidor de banco de dados utilizam o protocolo TCP/IP para enviar e receber solicitações. Isso é chamado de arquitetura cliente/servidor.
  Já o SQLite NÃO requer um servidor para funcionar.
  O banco de dados SQLite é integrado à aplicação que acessa o banco de dados. Os aplicativos interagem com o banco de dados SQLite lendo e escrevendo diretamente dos arquivos do banco de dados armazenados no disco.
• Configuração zero: Devido à arquitetura serverless, não precisamos “instalar” o SQLite antes de usá-lo. Não há nenhum processo do servidor que precise ser configurado, iniciado e interrompido.
  Além disso, o SQLite não usa nenhum arquivo de configuração específico.
• Transacional: Todas as transações no SQLite são totalmente compatíveis com as propriedades ACID. Isso significa que todas as consultas e alterações são atômicas, consistentes, isoladas e duráveis.
  Em outras palavras, todas as alterações em uma transação ocorrem completamente ou não ocorrem, mesmo quando ocorre uma situação inesperada, como falha de aplicativo, falha de energia ou falha do sistema operacional.

O SQLite também tem suporte a subconsultas, transações, junções, pesquisa em texto (full text search), restrições de chave estrangeira, entre outras funcionalidades.

Outros Recursos do SQLite

• O SQLite usa tipos dinâmicos para tabelas. Isso significa podemos armazenar qualquer valor em qualquer coluna, independentemente do tipo de dados.
• Permite que uma única conexão de banco de dados acesse vários arquivos de banco de dados simultaneamente. Isso fornece muitos recursos interessantes, como unir tabelas em bancos de dados diferentes ou copiar dados entre bancos de dados em um único comando.
• O SQLite é capaz de criar bancos de dados na memória de acesso muito rápido.

Observações sobre o SQLite

É importante notar que, por não ter um servidor para seu gerenciamento, o SQLite não provê um acesso direto pela rede. As soluções existentes para acesso remoto são no geral “caras” e ineficientes.

Além disso, o SQLite não possui suporte à autenticação, com usuários e permissões definidas. Estamos falando aqui sobre usuários do banco de dados, que têm permissão para criar tabela, inserir registros etc.

Porém, apesar do SQLite não ter suporte à autenticação, é claro que podemos e devemos implementar nosso próprio controle de acesso para nossa aplicação.

Finalmente, O SQLite é case-insensitive, ou seja, não diferencia letras maiúsculas de minúsculas.

Ferramentas GUI para gerenciamento do SQLite

Diversas ferramentas gráficas existem para auxiliar no gerenciamento de bancos de dados criados com SQLite, disponíveis em várias plataformas e sob vários tipos de licenciamento. Algumas das mais populares incluem o SQLiteStudio, DBeaver e o DB Browser for SQLite, citadas a seguir:

• SQLiteStudio
  O SQLiteStudio é uma ferramenta GUI gratuita para gerenciar bancos de dados SQLite.
  É gratuito, portátil, intuitivo e multiplataforma.
  A ferramenta também fornece alguns dos recursos mais importantes para trabalhar com bancos de dados SQLite, como importação e exportação de dados em vários formatos, incluindo CSV, XML e JSON.
  Download: https://github.com/pawelsalawa/sqlitestudio/releases

Além do SQLite Studio, também temos disponíveis as seguintes ferramentas GUI gratuitas para SQLite: 

• DBeaver: Ferramenta gratuita de banco de dados multiplataforma. Suporta todos os principais sistemas de banco de dados relacionais populares como MySQL, PostgreSQL, Oracle Database, IBM DB2, Microsoft SQL Server, Sybase, Firebird, além é claro do SQLite.
  Download: https://dbeaver.io/download/
• DB Browser for SQLite: Ferramenta de código aberto para gerenciar arquivos de banco de dados compatíveis com SQLite.
  Download: https://sqlitebrowser.org/

Módulo sqlite3

O módulo SQLite3 é uma biblioteca embutida em Python, compatível com a especificação DB-API 2.0 (descrita pelo PEP 249), que permite a interação com bancos de dados SQLite. Esse módulo fornece uma API simples mas bastante eficaz para realizar operações variadas de consulta, atualização e gerenciamento em bancos de dados SQLite diretamente a partir de scripts Python.

O SQLite3 é amplamente utilizado devido à sua natureza leve, rápida e autônoma. Ele não requer um servidor separado para funcionar, pois todo o banco de dados é armazenado em um único arquivo, o que facilita a distribuição e o compartilhamento de aplicativos.

Além disso, essa biblioteca suporta a maioria das funcionalidades comuns de bancos de dados relacionais, incluindo tipos de dados, consultas SQL complexas, transações ACID (Atomicidade, Consistência, Isolamento e Durabilidade) e outras. Fornece classes e métodos para executar consultas SQL, inserir dados, atualizar registros, excluir dados, gerenciar transações e manipular exceções de maneira eficiente.

Apesar de não ser necessário instalá-lo (por se tratar de um módulo built-in), o módulo sqlite3 requer a versão SQLite 3.7.15 ou mais recente para funcionar.

Como criar um banco de dados SQLite com sqlite3

Para criar um novo banco de dados, ou abrir um banco de dados já existente, o primeiro passo é importar a biblioteca sqlite3 com a declaração import no script Python:

import sqlite3 as s

Logo após, criamos / conectamos um banco de dados usando o método connect() do sqlite3 para criar um objeto de conexão:

conexao = s.connect(banco_teste.db')

Nesta instrução, passamos o nome do banco entre aspas como argumento para o método connect, atribuindo seu retorno a uma variável objeto que batizamos aqui de conexao. Caso o banco de dados não exista, será criado no mesmo diretório onde reside o script python; se já existir, o banco será aberto para acesso. Usaremos o nome banco_teste como nome do banco de dados, com a extensão .db.

Na sequência, criaremos um cursor que nos permitirá executar as declarações SQL no banco de dados em si, como comandos para criar tabelas, inserir registros, atualizar linha e excluir elementos, entre outros. Para isso usamos o método cursor() do objeto conexao criado:

cursor = conexao.cursor()

Agora podemos escrever uma declaração SQL a ser executada no banco. Por exemplo, vamos criar uma tabela usando a declaração CREATE TABLE, e então executar essa declaraçãop no banco de dados usando o método execute() do cursor criado:

sql = "CREATE TABLE teste(coluna1, coluna2, coluna3);"
cursor.execute(sql)

Como estamos executando um comando que realiza alterações no banco de dados, precisamos efetuar um commit logo após para efetivar a transação, caso contrário as alterações requisitadas não serão tornadas permanentes no arquivo do banco. Para isso, executamos o método commit() da conexão:

conexao.commit()

Finalmente, verificamos se a tabela foi criada efetuando uma consulta na tabela mestra do sqlite, que se chama sqlite-master. Usamos na sequência o método fetchall() para acessar todos os registros retornados pela consulta a um objeto batizado de res ( de “resultado”):

res = cursor.execute("SELECT name FROM sqlite_master")
print(res.fetchall())

Código completo:

import sqlite3 as s

# Criar objeto de conexão e conectar ao banco
conexao = s.connect('banco_teste.db')

# Criar cursor
cursor = conexao.cursor()

# Determinar declarações SQL a serem executadas e executá-las no banco
sql = "CREATE TABLE teste(coluna1, coluna2, coluna3);"
cursor.execute(sql)

# Efetivar a transação (comitar)
conexao.commit()

# Verificar se tabelas foram criadas
res = cursor.execute("SELECT name FROM sqlite_master")
print(res.fetchall())

Resultado:

[('teste',)]

Note que foi retornada uma lista de tuplas, com um único elemento, que representa o nome da tabela de teste criada.

É isso aí! Criamos um banco de dados com SQLite e Python, além de uma tabela simples, e testamos a existência da tabela por meio de instruções no script. Na próxima lição veremos como inserir dados nesta tabela (criar registros) e testar essa inserção.

Case prefira, assista a um vídeo da Bóson Treinamentos sobre Python com SQLite:

O post Criar banco de dados SQLite em Python com sqlite3 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Anteriormente falamos sobre o objeto Series do Pandas, e neste artigo vamos explorar algumas funções de um outro tipo de objeto muito comum também fornecido pelo módulo Pandas, o DataFrame.

Os DataFrames do Pandas são uma estrutura de dados bastante versátil e poderosa que pode ser usada em análise, manipulação e processamento de dados em Python. Eles são empregados em uma ampla gama de aplicações de várias áreas, incluindo análise de dados, ciência de dados, engenharia, finanças, pesquisa e muito mais.

Algumas das principais aplicações dos DataFrames do Pandas incluem:

• Pré-processamento de Dados: Limpeza, formatação, dados duplicados, valores ausentes, transformação nos dados
• Análise e Exploração de Dados: Importação de dados, Cálculos de Estatística Descritiva (média, mediana, desvio-padrão, etc.).
• Manipulação de Dados: Filtro, seleção e ordenação para extrair informações específicas dos dados; funções de agregação, colunas calculadas
• Análise de Séries Temporais: Manipulação e análise de dados temporais, como séries temporais de preços de ações, dados climáticos, etc.; reamostragem
• Modelagem Estatística e Machine Learning: Criação de conjuntos de treinamento e teste em aprendizado de máquina, divisão de dados para validação cruzada, etc.

entre muitas outras.

Além disso, os DataFrames podem ser integrados com outras bibliotecas, como por exemplo as bibliotecas NumPy, SciPy, Matplotlib e inúmeras outras, permitindo executar diversas tarefas adicionais, como visualização de dados e cálculos complexos sobre os datasets, por exemplo.

O que é um DataFrame?

Um objeto do tipo DataFrame representa uma tabela de dados retangular bidimensional semelhante a uma tabela de banco de dados ou uma planilha do Excel, contendo uma coleção ordenada de colunas, em que cada uma pode ter um tipo de valor diferente (numérico, string, booleano etc.).

O DataFrame possui índices tanto para linha quanto para coluna; pode ser imaginado como um array de objetos Series, todos compartilhando o mesmo índice.

Há várias formas de construir um DataFrame, embora as mais comuns sejam a partir de dados armazenados em bancos de dados, arquivos CSV, arquivos de planilhas como o Excel, dicionários com listas de mesmo tamanho ou ainda a partir de arrays NumPy, entre outras.

Neste tutorial vamos criar DataFrames a partir de dicionários para explorar algumas de suas funcionalidades. Nos próximos tutoriais, vamos trabalhar também com importação de dados de planilhas do Excel, arquivos CSV e tabelas de bancos de dados relacionais, entre outras tarefas.

Criar um DataFrame a partir de um Dicionário

Vamos começar criando um DataFrame de exemplo a partir de um dicionário de dados. Antes disso, precisamos importar o módulo em nosso script:

import pandas as pd

Vamos criar agora um DataFrame a partir de um dicionário que contém nomes de países, quantidade de títulos mundiais da FIFA, e ano em que o país ganhou seu primeiro título.

dicionario={'País':['Brasil','Uruguai','Inglaterra','Espanha','Holanda','Itália','Argentina','Alemanha','França'],
'Ano':[1958,1930,1966,2010,None,1934,1978,1954,1998],
'Titulos':[5,2,1,1,0,4,3,4,2]
}
dados = pd.DataFrame(dicionario)
print(dados)

Saída:

  País       Ano    Titulos
0 Brasil     1958.0       5
1 Uruguai    1930.0       2
2 Inglaterra 1966.0       1
3 Espanha    2010.0       1
4 Holanda    NaN          0
5 Itália     1934.0       4
6 Argentina  1978.0       3
7 Alemanha   1954.0       4
8 França     1998.0       2

Note que na linha correspondente à Holanda a coluna Ano traz o valor NaN, que significa “Not a Number” (Não é um Número), indicando que este dado está ausente (a Holanda ainda não ganhou nenhuma copa, por isso um valor para a coluna de ano não existe!)

Mostrar início ou fim do dataset

Se o conjunto de dados for grande e não quisermos exibi-lo inteiro na tela, podemos imprimir apenas as cinco primeiras ou as cinco últimas linhas com os métodos head() e tail(), respectivamente:

# 5 primeiras linhas
print(dados.head())

# 5 últimas linhas
print(dados.tail())

Por padrão, o Pandas limita o número de linhas exibidas na tela a 60 linhas e o número de colunas a 20 colunas, para evitar saída de grandes volumes de dados.

Manipulação de colunas

Podemos alterar a ordem das colunas passando como parâmetro ao método .DataFrame() uma lista de valores a serem usados como cabeçalho:

dados = pd.DataFrame(dados, columns=['Titulos','País','Ano'])
print(dados)

Para ver apenas os nomes das colunas constituintes do df:

print(dados.columns)

Para imprimir colunas individuais (em vez do DataFrame completo) podemos passar o nome da coluna desejada como valor de índice (entre colchetes), ou então chamar a coluna pelo seu nome como uma propriedade (precedida de um ponto):

print('Países:')
print(dados['País'])
print('\nAnos:')
print(dados.Ano)

Adicionamos uma nova coluna ao DF simplesmente passando seu nome entre colchetes, e atribuindo valores a partir de uma sequência, como uma lista. Podemos inicializar a coluna com um único valor também (mesmo valor em todas as linhas), como por exemplo o valor 0:

# Acrescentar uma coluna ao DataFrame:
dados['Participações'] = 0
print(dados)

# Preencher a coluna com valores de uma lista:
part = [22,14,16,16,11,18,18,20,16]
dados['Participações'] = part
print(dados)

Para excluir uma coluna do DataFrame empregamos a função del:

# Excluir coluna "Participações"
del dados['Participações']
print(dados)

Manipulação de linhas

É possível excluir uma linha usando o método .drop(), passando o número da linha a excluir como um valor de índice. No exemplo a seguir vamos criar um novo DataFrame a partir do atual, excluindo nele a linha 4:

# Excluir a linha 4 (Holanda)
dados2 = dados.drop([4])
print(dados2)

Para excluir várias linhas de uma vez, basta passar uma lista com seus números de índice:

# Excluir as linhas 3, 4 e 5 de uma vez
dados2 = dados.drop([4, 3, 5])
print(dados2)

Para excluir uma linha no DataFrame em si, sem precisar criar uma cópia dele, usamos o parâmetro inplace=True:

# Excluir linhas in loco
dados.drop(4, inplace=True)
print(dados)

Slicing em DataFrames

Podemos retornar um conjunto de linhas passando seus índices, inclusive usando fatiamento (slicing):

# Retornar linhas de 1 a 5:
print(dados[1:5])

Também é possível realizar essa operação usando rótulos em vez de números de índice:

# Fatiamento com rótulos

dicionario={'País':['Brasil','Uruguai','Inglaterra','Espanha','Holanda','Itália','Argentina'],
'Ano':[1958,1930,1966,2010,None,1934,1978],
'Titulos':[5,2,1,1,0,4,3]
}

dados = pd.DataFrame(dicionario, index=['a','b','c','d','e','f','g'])
# Mostra df completo
print(dados, '\n')

# Mostra apenas linhas de rótulos b até e:
print(dados['b':'e'])

Indexação: loc() e iloc()

Podemos realizar indexação com método .loc(), retornando linhas e colunas específicas apenas por meio de seus rótulos:

# Indexação com loc
# Linha b, colunas de País e Títulos
print(dados.loc['b',['País', 'Titulos']])
# Linhas de a a d, coluna de Ano:
print(dados.loc[:'d','Ano'])

Ou ainda indexar com método .iloc(), que retorna as linhas e colunas específicas de acordo com números de índices:

# Indexação com iloc
print(dados.iloc[1,[0, 2]])

Ordenação em Dataframes

Podemos exibir os dados ordenados por índice tanto em ordem crescente quando decrescente com o método sort_index():

# Ordenação por índice
print(dados.sort_index())

# Ordenação por índice em ordem inversa
print(dados.sort_index(ascending=False))

Para ordenar os dados pelos valores de uma coluna específica usamos o método sort_values(), passando os nomes das colunas na ordem em que desejamos a ordenação:
 Ordenação por colunas: ordem alfabética de país
print(dados.sort_values(by='País'))

# Ordem alfabética inversa:
print(dados.sort_values(by='País', ascending=False))

# Ordenação por várias colunas: ordem crescente de títulos e alfabética de países
print(dados.sort_values(by=['Titulos','País']))

# Ou ainda ordem decrescente de títulos e alfabética de países
# Ordenação por várias colunas
print(dados.sort_values(by=['Titulos','País'],
ascending = [False, True]))

Renomear colunas

É possível renomear uma ou mais colunas de um DF usando o método rename(). Para tal, passamos um mapeamento de dicionário para o parâmetro “columns” contendo pares chave:valor nos quais a chave é o nome da coluna a renomear, e o valor é o novo nome que será usado.

Por exemplo, vamos renomear a coluna “Titulos” para “Campeonatos”:

# Renomear uma coluna 
dados2=dados.rename(columns = {'Titulos':'Campeonatos'})
print(dados2.columns)

Uma alternativa é usar o parâmetro axis=’columns’ ou axis=’1′:

# Renomear a coluna de volta
dados2=dados.rename({'Campeonatos':'Titulos'}, axis='columns')
print(dados2.columns)

Para alterar o nome da coluna in loco (sem criar outro df), usamos novamente o parâmetro inplace:

# Renomear coluna no DataFrame atual (inplace).
dados2.rename({'Titulos':'Campeonatos'}, axis='columns', inplace=True)
print(dados2.columns)

Para renomear múltiplas colunas o processo é o mesmo, bastando passá-las como um mapeamento de dicionário.
Por exemplo, vamos renomear as colunas “Campeonatos” e “Ano” para “Titulos” e “Primeiro_Titulo” respectivamente no df dados2:

# Renomear várias colunas de uma vez no DataFrame atual.
dados2.rename({'Campeonatos':'Titulos', 'Ano':'Primeiro_Titulo'}, axis='columns', inplace=True)
print(dados2.columns)

Também podemos renomear todas as colunas de um dataframe de uma vez, passando para isso uma lista com os novos nomes a usar. O comprimento da lista deve ser igual ao número de colunas existentes no df, e as colunas serão renomeadas na ordem em que aparecem.

Note que neste caso renomeamos as colunas SEM usar o método rename().

Por exemplo:

# Renomear colunas com lista
nomes = ['Nação','Ano_Ganhou','Qtde_Titulos']
dados2.columns = nomes
print(dados2.columns)

Renomear colunas adicionando sufixos ou prefixos

Às vezes precisamos renomear colunas adicionando sufixos ou prefixos na forma de uma sequência de caracteres. Podemos fazer isso usando os métodos add_prefix() ou add_suffix(). Por exemplo, vamos adicionar o prefixo “copa_” a todas as colunas do dataframe dados2:

# Renomear todas as colunas adicionando um prefixo
dados2 = dados2.add_prefix('copa_')
print(dados2.columns)

Leia mais aqui: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.add_prefix.html

Para remover um prefixo ou sufixo, podemos usar (entre outros) o método str.replace(), que substitui todas as ocorrências de uma determinada string por outra string (ou nenhuma string, que é o caso). Vamos remover o prefixo “copa_” adicionado anteriormente para testar:

# Remover prefixo com método str.replace
dados2.columns = dados.columns.str.replace('copa_', '')
dados2

Cuidado ao usar esse método para remover prefixos e sufixos, pois se houverem outras sequências de caracteres nos nomes das colunas iguais às que se deseja remover, estas também serão removidas, alterando de forma indesejada os nomes.

No próximo artigo estudaremos algumas técnicas de limpeza e tratamento de dados ausentes ou duplicados em um dataframe.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Como usar o objeto DataFrame da biblioteca Pandas em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A função enumerate é uma ferramenta útil em Python que permite associar um índice a cada elemento de uma sequência (como uma lista, tupla ou string) durante uma iteração. Isso torna mais fácil acessar tanto o elemento em si quanto sua posição na sequência.

Neste tutorial, vou mostrar como funciona a função enumerate, sua sintaxe e as vantagens e desvantagens de seu uso.

Para Que Serve a Função enumerate?

A função enumerate é usada para numerar elementos em uma sequência enquanto iteramos sobre eles. Ela cria pares de índices e valores a partir dos elementos da sequência, permitindo que sejam acessados tanto o elemento quanto sua posição. Ou seja, basicamente a função adiciona um contador sobre um objeto iterável.

Essa funcionalidade é útil em situações onde necessitamos saber a posição de um elemento em uma sequência.

Sintaxe da Função enumerate

A sintaxe básica da função enumerate() é a seguinte:

enumerate(iterável, start=0)

onde:

• iterável: O objeto que você deseja enumerar (por exemplo, uma lista, tupla, iterador, etc.).
• start (opcional): O valor inicial do índice (posição a partir de onde começa a contagem). Por padrão, o valor inicial é 0

A função retorna um objeto enumerado que é um iterador contendo pares chave (índice) e valor.

Vantagens do Uso da Função enumerate

Existem algumas vantagens de se usar a função enumerate para trabalhar com conjuntos iteráveis, como por exemplo:

1. Acesso aos Índices: A função enumerate facilita o acesso aos índices dos elementos em uma sequência, o que é útil em muitas situações de programação, como por exemplo contar o número de iterações completadas ao trabalhar com iteradores.
2. Sintaxe Concisa: Ela fornece uma maneira concisa de enumerar elementos, evitando a necessidade de rastrear manualmente os índices em sequências.

Desvantagens do Uso da Função enumerate

Porém, a função enumerate também possui algumas desvantagens, que devem ser consideradas ao escolher as técnicas de programação a serem empregadas no desenvolvimento. Entre elas posso citar:

1. Uso de memória: A função enumerate cria um objeto enumerado que armazena pares de índice e valor na memória, o que pode consumir um pouco mais de memória do que a iteração tradicional.
2. Índices baseados em 0: Os índices gerados pela função enumerate são baseados em 0 por padrão, o que pode ser contra intuitivo em algumas situações.
3. Nem sempre é necessária: Se não precisarmos acessar os índices e necessitarmos simplesmente iterar sobre os elementos, a função enumerate é desnecessária. Use iteração comum.

Sendo assim, a função enumerate é uma ferramenta útil para rastrear índices enquanto iteramos sobre uma sequência. No entanto, deve ser usada com moderação, especialmente se a economia de memória for uma preocupação e não for necessário usar os índices.

Em muitos casos, a iteração tradicional é mais do que suficiente.

Dito isto, vejamos alguns exemplos de como usar a função enumerate em Python.

Exemplos de enumerate em Python

Exemplo 1: Iterar Sobre uma lista de itens com enumerate

frutas = ["maçã", "banana", "laranja", "uva", "caju", "figo", "abacaxi", "framboesa"]
for indice, fruta in enumerate(frutas):
    print(f"Índice {indice}: {fruta}")

Neste exemplo, estamos iterando sobre uma lista de frutas e usando enumerate para associar um índice a cada fruta. O resultado será:

Índice 0: maçã
Índice 1: banana
Índice 2: laranja
Índice 3: uva
Índice 4: caju
Índice 5: figo
Índice 6: abacaxi
Índice 7: framboesa

Exemplo 2: Enumerar Linhas em um Arquivo de Texto

Suponha que tenhamos um arquivo de texto chamado “arquivo.txt” contendo várias linhas de texto com o seguinte conteúdo:

“É mais fácil pedir perdão do que permissão.”
Grace Hopper

Essa frase é muitas vezes usada para destacar a importância da inovação e da ação decisiva no campo da tecnologia e da programação.

Grace Hopper, uma pioneira da computação, foi conhecida por sua abordagem ousada e sua disposição para desafiar o status quo, o que a tornou uma figura notável na história da informática.

 Podemos empregar a função enumerate para numerar as linhas enquanto o arquivo é lido:

with open("arquivo.txt", "r") as arquivo:
    for numero_linha, linha in enumerate(arquivo, 1):
        print(f"Linha {numero_linha}: {linha.strip()}")

Neste exemplo, o script efetua a leitura do arquivo linha por linha e usa enumerate para numerar as linhas, começando em 1. O método .strip() é usado para remover espaços em branco e quebras de linha no final de cada linha.

Resultado:

Linha 1: "É mais fácil pedir perdão do que permissão."
Linha 2: Grace Hopper
Linha 3: 
Linha 4: Essa frase é muitas vezes usada para destacar a importância da inovação e da ação decisiva no campo da tecnologia e da programação.
Linha 5: 
Linha 6: Grace Hopper, uma pioneira da computação, foi conhecida por sua abordagem ousada e sua disposição para desafiar o status quo, o que a tornou uma figura notável na história da informática.

Exemplo 3: Enumerar Elementos em uma Matriz

Vamos criar uma matriz bidimensional (uma lista de listas) e usar enumerate para enumerar os elementos em cada linha.

matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for indice_linha, linha in enumerate(matriz):
    for indice_coluna, elemento in enumerate(linha):
        print(f"Elemento na linha {indice_linha}, coluna {indice_coluna}: {elemento}")

Resultado:

Elemento na linha 0, coluna 0: 1
Elemento na linha 0, coluna 1: 2
Elemento na linha 0, coluna 2: 3
Elemento na linha 1, coluna 0: 4
Elemento na linha 1, coluna 1: 5
Elemento na linha 1, coluna 2: 6
Elemento na linha 2, coluna 0: 7
Elemento na linha 2, coluna 1: 8
Elemento na linha 2, coluna 2: 9

Exemplo 4: Encontrar a Posição de um Elemento em uma Lista

Vamos criar uma lista de números e um elemento-alvo, informado pelo usuário. Usaremos então a função enumerate para encontrar a posição (índice) do elemento-alvo na lista.

numeros = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]
alvo = int(input("Qual valor múltiplo de 10 deseja pesquisar?"))
for indice, numero in enumerate(numeros):
    if numero == alvo:
        print(f"O elemento {alvo} está na posição {indice}.")

Resultado:

Qual valor múltiplo de 10 deseja pesquisar?
40
O elemento 40 está na posição 3.

Exemplo 5: Iteração sobre os itens de uma tupla, ajustando o valor de inicio dos índices

linguagens = ("cobol", "c++", "python", "fortran", "kotlin", "javascript", "ruby", "lisp")
for indice, linguagem in enumerate(linguagens, start=10):
    print(f"Índice {indice}: {linguagem}")

Aqui, iteramos sobre uma lista com nomes de linguagens de programação e usamos enumerate com o parâmetro start para associar um índice, iniciando em 10, a cada linguagem.

Resultado:

Índice 10: cobol
Índice 11: c++
Índice 12: python
Índice 13: fortran
Índice 14: kotlin
Índice 15: javascript
Índice 16: ruby
Índice 17: lisp

Exemplo 6: Iterar sobre um objeto do tipo enumerate com laço for

# Lista de entrada
lista_cidades = ["Amsterdam", "Ushuaia", "São Paulo", "Manchester", "Osaka"]

# Criar objeto enumerate
obj_enumerate = enumerate(lista_cidades)

# Usar laço for para iterar sobre cada item no objeto enumerate
for item in obj_enumerate:
    # Imprimir o item correspondente a cada iteração
    print(item)

Agora, a iteração é realizada em um objeto do tipo enumerate criado previamente na aplicação a partir de elementos presentes em uma lista – no caso, nomes de cidades.

Resultado:

(0, 'Amsterdam')
(1, 'Ushuaia')
(2, 'São Paulo')
(3, 'Manchester')
(4, 'Osaka')

Exemplo 7 – Usar a função enumerate() em uma string

Neste exemplo é fornecida uma frase, e usando a função enumerate determinamos o número de índice de cada caractere digitado.

# String de entrada
string_entrada = 'Hoje é sexta-feira!'

# Gerar um objeto enumerate a partir da string
obj_enumerate = enumerate(string_entrada)

# Converter o objeto enumerate em uma lista e mostrar seu conteúdo, um caractere por linha
print(list(obj_enumerate))

Resultado:

[(0, 'H'), (1, 'o'), (2, 'j'), (3, 'e'), (4, ' '), (5, 'é'), (6, ' '), (7, 's'), (8, 'e'), (9, 'x'), (10, 't'), (11, 'a'), (12, '-'), (13, 'f'), (14, 'e'), (15, 'i'), (16, 'r'), (17, 'a'), (18, '!')]

Conclusão

Neste tutorial, mostrei os fundamentos, vantagens, desvantagens e as aplicações práticas da função enumerate em Python, uma ferramenta muito útil para iteração eficiente sobre sequências de valores. A capacidade de associar índices a elementos durante um loop não apenas simplifica o código, mas também amplia as possibilidades de manipulação de dados e criação de estruturas mais legíveis.

A função enumerate se destaca como uma solução elegante para situações em que a indexação de elementos é crucial. Seja na criação de compreensões de lista mais concisas, na implementação de lógicas de condição baseadas em índices ou no rastreamento simultâneo de múltiplas variáveis, a versatilidade desta função oferece um valioso incremento à caixa de ferramentas de qualquer programador Python.

Portanto, ao explorar o funcionamento dessa função, podemos podem otimizar o fluxo de trabalho, tornando os códigos mais compreensíveis e, em última análise, elevar o nível de eficiência e clareza nos projetos Python.

A função enumerate representa um recurso indispensável para aqueles que buscam aprimorar suas habilidades de programação e aprofundar seu entendimento da linguagem Python.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post A função enumerate em Python – numerar elementos em uma sequência apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O arredondamento preciso de valores numéricos desempenha um papel muito importante em diversas aplicações científicas e de engenharia. No contexto da programação em Python, a biblioteca NumPy se destaca como uma ferramenta poderosa para manipulação eficiente de arrays e cálculos numéricos em geral.

Neste artigo, exploraremos algumas funções de arredondamento numérico disponíveis no NumPy, mostrando alguns exemplos de como empregar essas funções para realizar arredondamentos diversos, incluindo arredondamento de valores de ponto flutuante e para números inteiros.

Ao entender como usar essas funções, será possível otimizar nossos códigos e garantir resultados numericamente estáveis em uma variedade de cenários.

Vamos às funções de arredondamento de valores com NumPy, para Python.

Importar o NumPy

O primeiro passo para usar as funções que serão abordadas é importar a biblioteca NumPy no script que usará as funções de arredondamento (o módulo numpy deve estar instalado previamente; caso não esteja, realize a instalação do NumPy seguindo estas instruções):

import numpy as np

Após importar a biblioteca, vejamos as funções mais importantes para arredondamento de valores numéricos.

1. Função numpy.round

Ou seu alias numpy.around(): Arredonda o valor até uma precisão desejada

Sintaxe

numpy.round(valor,[num_casas_decimais])

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.round.html

Exemplo de uso

# Criar um array de valores a serem arredondados:
valores = np.array([5.0, 6.98, 0.9863, 555, 10.099])
# Podemos usar também uma simples lista (descomentar para testar):
# valores = [5.0, 6.98, 0.9863, 555, 10.099] 
print('Array original:')
print(valores)

print('\nValores arredondados:')
print(np.round(valores, decimals = 2))
print(np.round(valores, decimals = 3))
print(np.around(valores)) # valores são exibidos no formato float64
print(np.around(valores).astype(int)) # converter valores para int antes da exibição (não mostra o ponto)

Resultado:

Array original:
[ 5. 6.98 0.9863 555. 10.099 ]

Valores arredondados:
[ 5. 6.98 0.99 555. 10.1 ]
[ 5. 6.98 0.986 555. 10.099]
[ 5. 7. 1. 555. 10.]
[ 5 7 1 555 10]

2. Função numpy.floor

Arredonda para o maior inteiro menor que o valor de entrada (“tipo” arredonda para baixo).

Retorna o menor inteiro i, tal que i <= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.floor.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.floor(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 6. 0. 55. 10. -1.]

3. Função numpy.ceil

Arredonda para o inteiro imediatamente maior que valor de entrada (“tipo” arredonda para cima). Essa função retorna o menor número inteiro i, tal que i >= valor

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.ceil.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])  # mesmo array usado em np.floor
print('Array original:')
print(valores)
print('\nValores arredondados:')
print(np.ceil(valores))

Resultado:

Array original:
[ 6.3 0.786 55. 10.999 -0.63 ]
Valores arredondados:
[ 7. 1. 55. 11. -0.]

4. Função numpy.trunc

Truncar um valor numérico. Retorna o valor truncado da entrada, elemento a elemento.

O valor truncado do escalar x é o inteiro mais próximo i que está mais próximo de zero do que x. Resumindo, a parte fracionária do valor atribuido é descartada.

O que é truncar?

O verbo “truncar” se refere ao ato de cortar ou remover a parte fracionária de um número, mantendo apenas a parte inteira. A operação de truncamento geralmente é realizada em números de ponto flutuante, onde há uma parte inteira e uma parte decimal. Também é possível aplicar a operação de truncagem em strings, o que não é o caso aqui.

Por exemplo, se tivermos o número de ponto flutuante 7.75 e quisermos truncá-lo para um inteiro, o resultado será 7, pois a parte decimal (0.75) foi removida.

É importante observar que o truncamento difere do arredondamento, onde a parte decimal é arredondada para o inteiro mais próximo. No truncamento, a parte decimal é simplesmente removida, resultando sempre em um número menor ou igual ao número original.

Documentação de numpy.trunc: https://numpy.org/doc/stable/reference/generated/numpy.trunc.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores truncados:')
print(np.trunc(valores))

Resultado:

Valores truncados:
[ 6. 0. 55. 10. -0.]

5. Função numpy.fix

Arredonda para o número inteiro mais próximo em direção a zero.

Arredonda um array de pontos flutuantes elemento a elemento para o número inteiro mais próximo de zero. Os valores arredondados são retornados como valores de ponto flutuante.

Documentação: https://numpy.org/doc/stable/reference/generated/numpy.fix.html

Exemplo

valores = np.array([6.3, 0.786, 55, 10.999, -0.63])
print('Valores Arredondados:')
print(np.fix(valores))

Resultado:

Valores Arredondados:
[ 6. 0. 55. 10. -0.]

Conclusão

As funções de arredondamento proporcionadas pela biblioteca NumPy conferem uma grande flexibilidade aos programadores Python ao lidar com operações numéricas. Seja em análises estatísticas, processamento de dados ou simulações complexas, o entendimento aprofundado dessas funções é fundamental para assegurar resultados confiáveis e consistentes.

Neste artigo, trabalhamos com as principais funções de arredondamento do NumPy, com exemplos de códigos simples para melhor entendimento de cada função. Ao incorporar esses conhecimentos em seus projetos, você estará mais preparado para resolver desafios numéricos e obter soluções eficientes e precisas ao criar aplicações com Python.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post 5 Funções de Arredondamento de Valores com NumPy em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um problema que ocorre às vezes nos cursos que ministro, tanto em cursos técnicos quanto em cursos livres e de nível superior, é a formação de grupos pelos alunos para a realização de trabalhos e execução de projetos.

Essa situação ocorreu em um curso de programação recentemente. Os alunos precisavam se dividir em grupos, com até 5 membros por grupo, para trabalharem em um projeto de desenvolvimento de software com acesso a bancos de dados.

Como é o costume na instituição onde atuo, deixamos os alunos se auto-organizarem, de modo a praticarem assim a autonomia e trabalho em equipe.

Não deu certo.

Após mais de uma hora de conversas, mini-reuniões e muita discussão, eles não conseguiam entrar em acordo sobre quem ficaria em qual grupo, e a atividade estava quase se transformando em briga na sala de aula.

Sendo assim, tive de intervir. Resolvi que o melhor a fazer seria eu mesmo realizar a divisão dos grupos.

Mas como fazer isso de forma igualitária? Como atribuir alunos aos grupos aleatoriamente, sem nenhum viés de seleção?

Simples: deixando um programa escolher de forma automática os grupos e seus integrantes. Sendo assim, escrevi um pequeno script em Python para realizar essa tarefa para nós. E neste artigo reproduzo o programa, com uma explicação sucinta sobre seu funcionamento na sequência.

O que faz o programa

Temos aqui um programa em Python que sorteia números de uma lista que contém a quantidade de alunos que devem ser distribuídos nos grupos (identificados pelo número de chamada, que começa em 1).

O programa deve retornar grupos com no máximo x integrantes em cada, sem repetição – cada número sorteado é retirado da lista inicial.

A quantidade máxima de alunos em cada grupos também é informada pelo usuário. Podem haver grupos com menos alunos, caso a quantidade total de alunos não seja múltipla da quantidade de alunos por grupo.

Vamos ao código da aplicação.

Código

import random

# Perguntar ao usuário quantos alunos serão divididos em grupos
quantidade_numeros = int(input("Quantidade de alunos no total:"))

# Lista de números de 1 até a quantidade fornecida pelo usuário
numeros = list(range(1, quantidade_numeros + 1))

# Função para sortear e remover um número da lista
def sortear_numero(lista):
    numero_sorteado = random.choice(lista)
    lista.remove(numero_sorteado)
    return numero_sorteado

# Perguntar ao usuário quantos alunos no máximo por grupo
num_numeros_max_por_grupo = int(input("Quantos alunos no máximo por grupo? "))

# Inicializar a lista de grupos
grupos = []

# Gerar grupos com base na quantidade de alunos e na quantidade máxima por grupo
while numeros:
    tamanho_grupo = min(num_numeros_max_por_grupo, len(numeros))
    grupo = [sortear_numero(numeros) for _ in range(tamanho_grupo)]
    grupos.append(grupo)

# Exibir os grupos
print('\nGrupos formados:')
for i, grupo in enumerate(grupos):
    print(f'Grupo {i + 1}: {grupo}')

Teste do script

Exemplo de saída para uma turma com 23 alunos, divididos em grupos com no máximo cinco alunos por grupo:

Quantidade de alunos no total:
23
Quantos alunos no máximo por grupo? 
5

Grupos formados:
Grupo 1: [7, 2, 9, 14, 22]
Grupo 2: [5, 8, 13, 3, 11]
Grupo 3: [15, 16, 20, 12, 17]
Grupo 4: [21, 4, 10, 1, 18]
Grupo 5: [23, 6, 19]

Explicação

• Iniciamos o programa importando o módulo random para geração de números aleatórios.
• Na sequência, o programa pergunta ao usuário quantos números de identificação de alunos ele deseja usar, e armazena o valor informado na variável quantidade_numeros
• Depois, é criada uma lista de nome “números” contendo os valores sequenciais de 1 até a quantidade fornecida pelo usuário
• Então, é definida uma função de nome ‘sortear_numero‘ para sortear e remover um número da lista
• É perguntado ao usuário também quantos alunos, no máximo, devem estar em cada grupo, e o valor informado é armazenado na variável num_numeros_max_por_grupo.
• Logo após, uma lista vazia de nome ‘grupos‘ é inicializada.
• Os grupos são então gerados com base na quantidade de alunos e na quantidade máxima por grupo informadas. Para isso é empregado um laço while que continuará até que todos os alunos sejam alocados em grupos.
  A cada iteração, ele cria um grupo com no máximo o número de alunos especificado pelo usuário.
  A função sortear_numero é usada para escolher aleatoriamente os alunos para o grupo, e esses alunos são removidos da lista principal. Os grupos são armazenados na lista grupos.
• Finalmente, o programa usa um laço for para exibir os grupos formados na tela, mostrando a que grupo cada aluno pertence.

Conclusão

O programa funcionou como esperado, e os alunos foram divididos em grupos de forma satisfatória (com alguns reclamando que queriam ficar no grupo do amigo, mas paciência!)

Há espaço para melhorias neste programa? Sem dúvidas. Por exemplo, poderiam ser atribuídos ‘pesos’ aos alunos, para indicar aqueles que possuem maior conhecimento dos que tem maior dificuldade de aprendizado, e assim ao atribuir os alunos ao grupos, evitar de colocar os melhores alunos em um mesmo grupo, deixando os alunos com maior dificuldade juntos.

Essa é uma modificação que farei futuramente no script – ou você mesmo pode tentar realizar, e se quiser, postar o código nos comentários aqui abaixo para compartilhar com o público em geral.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post Programa em Python que sorteia e divide alunos em grupos em uma turma apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O módulo Pandas é uma biblioteca de código aberto em Python que fornece estruturas de dados e ferramentas para análise de dados eficientes e bastante flexíveis. Essa biblioteca é amplamente empregada em tarefas de manipulação, limpeza, análise e transformação de dados em projetos diversos de ciência de dados, análise de dados e engenharia de software em geral.

O Pandas possui duas estruturas de dados principais: os objetos Series e DataFrame. Neste tutorial vamos trabalhar com o objeto Series, e na próxima lição, abordaremos o objeto DataFrame.

Objeto Series

Um Series (“Série”) é um objeto do tipo array unidimensional contendo uma sequência de valores (semelhante a uma lista ou um array do NumPy) e um array associado de rótulos (labels) de dados, chamado de índice.

Ou seja, trata-se de uma estrutura de dados simples cujos valores são armazenados na forma de uma coluna de dados, porém contendo uma coluna de valores de índice associados.

Outra forma de pensar em um Series é como um dicionário ordenado de tamanho fixo, como se fosse um mapeamento entre valores de índices e valores de dados. Ele pode inclusive ser utilizada em alguns contextos em que um dicionário seria empregado.

No geral, usamos Series para guardar dados sobre um atributo em particular no dataset, sendo possível extrair uma coluna de um DataFrame na forma de um objeto Series, ou ainda adicionar uma coluna a um DataFrame a partir de um Series.

Como importar a biblioteca Pandas

Para que possamos criar e usar um objeto Series, primeiramente devemos importar o módulo Pandas (que deve estar instalado):

import pandas as pd

Caso o módulo Pandas não esteja instalado, use um gerenciador de pacotes como o pip ou conda para realizar sua instalação, como segue:

pip install pandas

ou (se estiver usando o Anaconda / Miniconda)

conda install pandas

Como criar um objeto Series

Podemos criar um objeto Series de várias maneiras, incluindo a partir de listas, dicionários, arrays NumPy e até mesmo criar Series vazias. Vejamos cada uma dessas formas com um exemplo.

Criar objeto Series vazio invocando o método Series()

# Objeto Series vazio
serie = pd.Series()
print(serie)

Criar Series a partir de uma lista comum

Uma forma mais comum é criar um objeto Series passando algum tipo de array de dados, como uma lista de valores:

# Series com lista do Python
dados = pd.Series([12, 34, 21, -9, 0, 7])
print(dados)

Saída:

0    12
1    34
2    21
3    -9
4     0
5     7
dtype: int64

Criar objeto Series a partir de um array NumPy

Podemos ainda passar um array NumPy para criar um Series (a biblioteca NumPy deve estar instalada para que o exemplo a seguir funcione):

# Series com array NumPy
import numpy as np

array_numpy = np.array([10, 20, 30, 40, 50, 60])
dados = pd.Series(array_numpy)
print(dados)

Saída:

0    10
1    20
2    30
3    40
4    50
5    60
dtype: int32

Criar Series preenchida com valores repetidos

Além disso, podemos criar um Series preenchido com um dado repetido para todos os índices:

# Series com repetição de itens
serie = pd.Series(33, index = ["num1", "num2", "num3", "num4", "num5"])
print(serie)

Saída:

num1    33
num2    33
num3    33
num4    33
num5    33
dtype: int64

Criar Series a partir de um dicionário

Finalmente, podemos criar um objeto Series passando um dicionário como parâmetro. Neste caso, as chaves serão usadas como índices e os valores serão os itens:

# Series com dicionário
dicionario = {
    'Ano' :1950,
    'Item' : 'TV',
    'Valor' : 250.60
}

serie = pd.Series(dicionario)
print(serie)

Saída:

Ano       1950
Item        TV
Valor    250.6
dtype: object

Outro exemplo de dicionário

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados)

Saída:

Brasil        5
EUA           0
Inglaterra    1
Argentina     3
dtype: int64

Valores e índices

A representação em string de uma Series exibida interativamente mostra o índice à esquerda e os valores à direita. Como não especificamos um índice para os dados, um índice default constituído dos inteiros de 0 a n-1 (em que n é o tamanho dos dados) é criado.

Podemos obter a representação do array e o objeto de índice de Series por meio de seus atributos de valores (values) e de índice (index), respectivamente:

print('Dados: ', dados.values)
print('Índices: ', dados.index)

Saída:

Dados:  [5 0 1 3]
Índices:  Index(['Brasil', 'EUA', 'Inglaterra', 'Argentina'], dtype='object')

Criar índices personalizados

Com frequência, precisamos criar um Series com um índice que identifique cada ponto de dado com um rótulo. Neste caso passamos o parâmetro index=[] contendo uma lista de valores que serão usados como índices:

dados = pd.Series([12, 34, 21, -9, 0, 7], index=['a','b','c','d','e','f'])
print(dados)

Saída:

a    12
b    34
c    21
d    -9
e     0
f     7
dtype: int64

Podemos usar rótulos no índice quando selecionamos valores únicos ou um conjunto de valores:

print('Dado no índice c: ', dados['c'])
print('\nÍndices b e e:')
print(dados[['b','e']])

Saída:

Dado no índice c:  21

Índices b e e:
b    34
e     0
dtype: int64

Operações Gerais em objetos Series

Agora que sabemos como criar e acessar objetos Series do Pandas, vamos conhecer algumas operações básicas que podemos realizar sobre os índices e dados armazenados na estrutura.

1. Acessar um item

Podemos acessar itens (valores) usando número de posição de índice ou nome de índice (se aplicado):

serie = pd.Series([10, 20, 30, 40, 50], index = ["num1", "num2","num3", "num4", "num5"])
print('Item na posição 0: ', serie[0])
print('Item de índice num3: ', serie['num3'])

Saída:

Item na posição 0:  10
Item de índice num3:  30

2. Descobrir valores máximo e mínimo

Podemos retornar os valores máximo e mínimo de um objeto Series com o emprego dos métodos .max() e .min():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])
print(f'Menor valor: {serie.min()}')
print(f'Valor mais alto: {serie.max()}')

Saída:

Menor valor: -3
Valor mais alto: 22

Para obter o índice associado ao maior valor usamos o método .idxmax() e o índice do menor valor com .idxmin():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])
print(f'Valor mais alto: {serie.max()}')
print(f'Índice do maior valor: {serie.idxmax()}')
print(f'Índice do menor valor: {serie.idxmin()}')

Saída:

Valor mais alto: 22
Índice do maior valor: 9
Índice do menor valor: 8

3. Funções de Estatística Descritiva

Diversas funções de estatística descritiva estão disponíveis em objetos Series, na forma de métodos associados, como Média Aritmética Simples, Mediana e Somatório, entre outras.

A média aritmética pode ser obtida com o método .mean():

print(f'Média aritmética: {serie.mean()}')

Saída:

Média aritmética: 5.9

A mediana com .median():

print(f'Mediana dos valores: {serie.median()}')

Saída:

Mediana dos valores: 5.5

E o somatório dos valores com .sum():

print(f'Somatório dos valores: {serie.sum()}')

Saída:

Somatório dos valores: 59

4. Converter objeto Series em lista comum do Python

Podemos converter um objeto Series em uma lista comum do Python com o método .tolist():

serie = pd.Series([5, 7, 12, 2, 1, 6, 7, 0, -3, 22])

# Ver objeto Series
print(serie)

# Criar lista a partir de Series
lista = serie.tolist()

# Ver lista criada
print('Lista: ', lista)

Saída:

0     5
1     7
2    12
3     2
4     1
5     6
6     7
7     0
8    -3
9    22
dtype: int64
Lista:  [5, 7, 12, 2, 1, 6, 7, 0, -3, 22]

5. Mostrar apenas os primeiros e últimos itens da Series

Se a quantidade de itens no objeto Series for grande, talvez você queira ver apenas os primeiros valores para ter uma ideia da natureza dos dados. Neste caso, pode usar o método head(), que retorna os cinco primeiros itens da série.

print(serie.head())

Saída:

0     5
1     7
2    12
3     2
4     1
dtype: int64

Da mesma forma, para mostrar os cinco últimos elementos, usamos o método .tail()

Dependendo da quantidade de itens, o Pandas retorna automaticamente apenas os cinco primeiros e os cinco últimos, sem a necessidade de usar o método .head().

No exemplo a seguir geramos 1000 números aleatórios usando a biblioteca NumPy, e criamos um Series do Pandas com esses valores. Na sequência, imprimimos os valores na tela – somente os cinco primeiros e cinco últimos devem aparecer neste caso, mesmo sem usar os métodos head() e tail():

import pandas as pd
from numpy import random

lista = []
for i in range(1000):
    lista.append(random.randint(250))
dados = pd.Series(lista)
print(dados)

Saída:

0        0
1       39
2      161
3      125
4      147
      ... 
995     24
996     95
997    165
998    144
999     45
Length: 1000, dtype: int64

6. Mostrar os elementos ordenados por valores de índice: método .sort_index()

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados.sort_index())

Saída:

Argentina     3
Brasil        5
EUA           0
Inglaterra    1
dtype: int64

7. Mostrar os elementos ordenados por valores dos itens: método .sort_values()

dicionario = {'Brasil': 5, 'EUA': 0, 'Inglaterra': 1, 'Argentina': 3}
dados = pd.Series(dicionario)
print(dados.sort_values())

Saída:

EUA           0
Inglaterra    1
Argentina     3
Brasil        5
dtype: int64

Vamos praticar um pouco agora.

Dataset para exercícios

Escreva um código que gere um objeto Series do Pandas, contendo uma lista com todos os países da União Europeia e suas respectivas populações, com os nomes dos países sendo usados como índices.

# Dicionário contendo os países da União Europeia e suas populações
dados = {
'Austria': 9006398,
'Alemanha': 83289318,
'Bélgica': 11589623,
'Bulgária': 7000039,
'Chipre': 1207361,
'Croácia': 4076246,
'Dinamarca': 5806015,
'Eslováquia': 5459642,
'Eslovênia': 2095861,
'Espanha': 47351567,
'Estônia': 1324820,
'Finlândia': 5523231,
'França': 66977107,
'Grécia': 10423056,
'Hungria': 9775564,
'Irlanda': 4882495,
'Itália': 60233948,
'Letônia': 1906743,
'Lituânia': 2793471,
'Luxemburgo': 613894,
'Malta': 493559,
'Países Baixos': 17134872,
'Polônia': 37974750,
'Portugal': 10286263,
'República Tcheca': 10693939,
'Romênia': 19405156,
'Suécia': 10106005,
}

# Criar um objeto Series a partir do dicionário
populacao_ue = pd.Series(dados)

# Exibir o objeto Series
print(populacao_ue)

Exercícios: Series do Pandas

Vamos treinar agora. Para os próximos exercícios, use o Series populacao_ue criado anteriormente. As respostas estão na sequência, com códigos sugeridos.

01. Imprimir a população da França.

02. Imprimir a lista de países da União Europeia em ordem alfabética.

03. Calcular e imprimir o número total de países na União Europeia.

04. Calcular e imprimir a população média dos países da União Europeia. Mostrar o resultado com duas casas decimais apenas.

05. Encontrar e imprimir o país com a maior população na União Europeia.

06. Filtrar e imprimir os países da União Europeia com população acima de 10 milhões, mostrando o resultado em ordem alfabética de nome de país.

07. Calcular e imprimir a população total da União Europeia.

08. Calcular e imprimir a porcentagem da população da Espanha em relação à população total da União Europeia.

09. Ordenar a Series em ordem decrescente de população e imprimir os cinco primeiros países.

10. Criar uma nova Series com a população de apenas três países da União Europeia e calcular a média da população desses países.
Use como exemplos os países França, Alemanha e Croácia.

11. Como exibir apenas as últimas três linhas do Series Pandas de nome “populacao_ue”?
A. populacao_ue(3:)
B. populacao_ue(1:3)
C. populacao_ue(-3:)
D. populacao_ue(:3)
E. populacao_ue(+3)

12. Podemos criar um objeto Series do Pandas usando:
A. Array NumPy
B. Lista
C. Dicionário
D. Valores repetidos
E. Todos os anteriores

RESPOSTAS DOS EXERCÍCIOS

01.

print(populacao_ue['França'])

02.

print(populacao_ue.sort_index())

03.

numero_paises = len(populacao_ue.index)
print("Número de países na União Europeia:", numero_paises)

04.

populacao_media = populacao_ue.mean()
print(f'População média dos países da União Europeia: {round(populacao_media, 2)}')

05.

pais_maior_populacao = populacao_ue.idxmax()
print("País com maior população na União Europeia:", pais_maior_populacao)

06.

# Filtrar os países da União Europeia com população acima de 10 milhões
paises_mais_10M = populacao_ue[populacao_ue > 10000000]

# Ordenar os países filtrados em ordem alfabética e imprimir
paises_ordenados = paises_mais_10M.sort_index()
print("Países da União Europeia com população acima de 10 milhões, em ordem alfabética:")
print(paises_ordenados)

07.

print(f'População total da União Europeia: {populacao_ue.sum()} habitantes')

08.

populacao_espanha = populacao_ue['Espanha']
populacao_total = populacao_ue.sum()
porcentagem_espanha = (populacao_espanha / populacao_total) * 100
print(f'População da Espanha em relação à população da UE: {porcentagem_espanha:.02f}%')

09.

paises_mais_populosos = populacao_ue.sort_values(ascending=False)
print("Cinco primeiros países mais populosos:")
print(paises_mais_populosos.head())

10.

paises_selecionados = populacao_ue[['França', 'Alemanha', 'Croácia']]
media_populacao_selecionados = paises_selecionados.mean()
print("Média da população:", media_populacao_selecionados)

11.

C. populacao_ue(-3:)

12.

E. Todos os anteriores

É isso aí! No próximo tutorial vamos apresentar o objeto DataFrame (df) do Pandas, mostrando como criar um dataframe e como manipular seu conteúdo pode meio dos métodos e propriedades disponíveis.

O post Como usar o objeto Series da biblioteca Pandas em Python apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Exercício: Escreva um programa em Python que retorne uma lista de números primos compreendidos em um intervalo fornecido pelo usuário (incluindo os extremos). Use funções para tal.

Por exemplo, ao executar o script se o usuário solicitar a lista de primos entre 7 e 50, o programa deve retornar um resultado como segue:

Entre com o menor valor: 
7
Entre com o maior valor: 
50
Os números primos no intervalo de 7 a 50 são:
7 11 13 17 19 23 29 31 37 41 43 47 

Vejamos o código que permite gerar números primos em Python.

Código

# Como gerar números primos em um intervalo numérico
# Função para verificar os números primos
def primo(n):
    if n < 2:
        return False
    for i in range(2, int(n/2)+1):
        if n % i == 0:
            return False
    return True

if __name__=='__main__':
    # Usuário escolhe o intervalo
    inf = int(input('Entre com o menor valor: '))
    sup = int(input('Entre com o maior valor: '))

    print('Os primos no intervalo de {} a {} são:'.format(inf, sup))

    for i in range(inf, sup + 1):
        if primo(i):
            print(i, end=' ')

Funcionamento do script

Vou dividir a explicação em duas partes: a função primo e o bloco principal do programa.

Função primo(n)

A função primo(n) é definida para verificar se um número n é primo ou não. Ela funciona da seguinte maneira:

1. Verifica se um valor n passado como parâmetro é menor que 2. Se for, retorna False, pois números menores que 2 não são primos.
2. Se n não for menor do que 2, a função inicia um loop que percorre os valores de i de 2 até n/2 + 1 (metade +1 do valor informado).
3. Para cada valor de i, verifica se n é divisível por i (ou seja, se n % i == 0). Se essa condição for verdadeira, significa que n não é primo, pois possui um divisor além de 1 e ele mesmo. Portanto, a função retorna False.
4. Caso nenhum valor de i resulte em uma divisão exata de n, a função retorna True, indicando que n é um número primo.

Bloco if __name__==’__main__’:

No bloco principal, o programa realiza as seguintes ações:

1. Solicita que o usuário insira o valor mínimo (inf) e o valor máximo (sup) do intervalo a gerar.
2. Exibe uma mensagem informando que os números primos no intervalo de inf a sup serão exibidos na sequência.
3. Usando um laço for, percorre todos os valores de i no intervalo de inf a sup + 1.
4. Para cada valor de i, chama a função primo(i) para verificar se i é um número primo.
5. Se i for primo (ou seja, se a função primo(i) retornar True), o valor de i é impresso na mesma linha, seguido de um espaço. Isso ocorre para todos os números primos encontrados no intervalo.

Portanto, o programa vai iterar por todos os números no intervalo especificado pelo usuário, verificar se cada número é primo usando a função primo(n), e imprimir os números primos encontrados.

Veja que essa implementação é funcional, porém não é a mais eficiente em termos de tempo de execução para encontrar números primos, especialmente para intervalos maiores, pois realiza uma divisão para cada número no intervalo.

Existem algoritmos mais eficientes para geração de números primos, como o Crivo de Eratóstenes .

O post Como gerar números primos em Python em um intervalo especificado apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.