Foto de Emile Perron

Bibliotecário em Ciência de Dados: Programando em Python

Habilidades com programação é uma das bases em ciência de dados. Diversas linguagens podem ser utilizadas, as mais faladas são R e Python. Nesse artigo falaremos de Python, porque além de ser a linguagem utilizada pelo autor do livro “Data Science” do zero no qual estou trilhando seus passos é uma linguagem excelente para iniciantes em programação.

Python tem uma filosofia de simplificar a legibilidade, permitindo que se tenha um código com poucas linhas, bonitas e mais “naturais”.

A linguagem é uma das mais populares no mundo!

Além de ciência de dados, também é utilizada para desenvolvimento web.

Curiosidade

O nome “Python” não veio do gênero de répteis, mas o seu criador, Guido van Rossum, batizou a linguagem por causa de um grupo humorístico britânico chamado “Monty Python”.

Fonte

Parecia desconhecido para mim, mas lendo mais a respeito vi que eles foram os principais influenciadores de outros programas brasileiros como “TV Pirata” e “Casseta e Planeta”, que possivelmente pode também ainda parecer estranho para você que está lendo isso se tiver menos de 20 anos.

O básico da linguagem

A intenção do autor no livro é fazer uma revisão rápida nos conceitos da linguagem trazendo os pontos principais.

Eu irei passar por elas e explicarei através do Google Colab, que é um serviço de nuvem gratuito que permite escrever código Python com o próprio navegador, sem nenhuma instalação, de fácil compartilhamento e acesso gratuito a GPUs.

Você pode encontrar aqui o notebook do Colab deste artigo.

Compreensão do código

Além do livro, tenho trilhado meus estudos em ciência de dados através da plataforma da Alura. Conforme vou avançando, tenho apenas mais certeza que se fosse apenas pelo livro, eu já teria desanimado.

A compreensão do código e o desenvolvimento de sistemas, realmente não é algo que hoje vejo como de “outro mundo”, como via há alguns anos. Na realidade tem me estimulado mais, por todo o “poder” da criação que linguagens de programação e análises mais aprofundadas podem fazer.

Você entrar em um “mundo novo” e “sozinho”, traz algumas inseguranças e diversas incertezas, mas a Alura conseguiu solucionar estes meus medos, por ter uma didática fantástica (se você ainda não se aventurou em alguma linguagem, saiba que isso é muito importante), ter uma comunidade para você discutir e trocar informações e principalmente a todos os cursos, podcasts, posts, vídeos entre tudo que eles criam diariamente, para você estar em constante atualização.

Não é “rápido”, tem que ter dedicação e dependerá do quanto você consegue se dispor a aprender e praticar, mas não é tão difícil quanto imaginava antes.

Bom… Vamos aos códigos!

Variáveis

As variáveis são formas que podemos “guardar” dados em palavras.

Se eu quiser guardar o número 11 na palavra mês eu executo desta forma, repetindo a palavra para ele imprimir para mim o que armazenou:

mes = 11
mes

Ou um nome na palavra “autor”:

autor = "Le Coadic, Yves-François"
autor

Existem vários tipos de dados possíveis, string, int, float, bol:

subject = "Biblioteconomia"         #string

subject_2 = "Ciência da informação" #string

date	= 2004                        #int

price = 44.90                       #float

comparativo = subject == subject_2   #bool

Indentação

Grande parte da fácil legibilidade do Python é na sua forma de escrever usando espaços em branco (um Tab) para separar blocos de código, pois em outras linguagens é comum se utilizar chaves {}.

Como por exemplo aqui:

def saudacao_inicial():
  print('Olá usuário! O que você gosta de ler?')
saudacao_inicial()

Para se indicar que o “print” está dentro da função “saudacao_inicial” ela possui este espaço inicial.

Funções

Uma função é um comando para se realizar algumas ações com entradas e retornar uma saída.

Para se criar uma função utilizamos def nome_da_funcao ():

O exemplo anterior já continha uma função, mas agora vamos incrementar um pouquinho mais ela:

def saudacao_inicial():
  nome = input('Qual é o seu nome?')
  print(f'Olá {nome}! O que você gosta de ler?')
saudacao_inicial()

Listas

assuntos = ['Amazônia - História',	
            'Gestão ambiental', 
            'Sistemas de informação geográfica', 
            'Amazon', 
            'Environmental management']
assuntos

Agora e como selecionar um item desta lista?

O índice do python começa em 0, portanto se fizer:

print(assuntos [0])
print(assuntos [1])
print(assuntos [2])

Retornará:

Amazônia - História
Gestão ambiental
Sistemas de informação geográfica

Podemos também consultar de outras formas:

assuntos [2:4]
['Sistemas de informação geográfica', 'Amazon'

Ou mesmo manipular estas listas, como acrescentar elementos:

assuntos.append('Geographic information system')
assuntos
['Amazônia - História',
 'Gestão ambiental',
 'Sistemas de informação geográfica',
 'Amazon',
 'Environmental management',
 'Geographic information system']

Entre outras diversas formas.

Tuplas

Muito parecido com as listas, as tuplas possuem as mesmas características, entretanto são imutáveis e ao invés de usar colchetes [] utiliza-se parênteses ()

dias_da_Semana = ("Dom","Seg","Ter","Qua","Qui","Sex","Sab")
dias_da_Semana[0]
'Dom'

Utilizada em casos onde não são mutáveis os elementos.

Comumente são utilizadas as Listas em casos onde os dados são homogêneos (apenas string ou apenas int …) e as Tuplas e casos que são heterogêneos (string com int …).

Dicionários

Os dicionários são muito interessantes!
Eles são estruturas em pares chave-valor, permitindo que você recupere o valor de uma determinada chave como por exemplo:

db_livro = {
  "title" :	"A ciência da informação",
  "creator"	: "Le Coadic, Yves-François",
  "subject" :	["Biblioteconomia",	"Ciência da informação"],
  "description"	: "Tradução de: La science de l'information",
  "publisher" :	"Briquet de Lemos",
  "date" :	"2004",
  "type" :	"LIVRO",
  "format" :	"124p. : il.",
  "identifier" :	["8585637234 (broch.)"],
  "language" :	[	"por", "fre"]
  }

Usei para ilustrar os dados da catalogação de um livro em Dublin Core, se eu quiser saber o “Creator” apenas uso esse código:

db_livro["creator"]
'Le Coadic, Yves-François'

Ou qual o “subject”?

db_livro["subject"]
['Biblioteconomia', 'Ciência da informação']

Como é uma lista, se eu quiser apenas o primeiro item executo:

db_livro["subject"][0]
'Biblioteconomia'

Ainda que simples, mas bem legal não é?!

Condicionais

Ações condicionais já são mais conhecidas para todos, aqui em Python utilizamos o if, elif e else. Como no exemplo a seguir:

qtd_usuarios = int(input('Qual é a quantidade de usuarios da biblioteca? '))

if qtd_usuarios <= 50:
  print('A biblioteca tem poucos usuarios')
elif qtd_usuarios <= 200:
  print('A biblioteca tem uma quantidade razoável de usuarios')
elif qtd_usuarios <= 500:
  print('A biblioteca tem muitos usuarios')
else:
  print('A biblioteca tem um número muito grande de usuarios')

Repetição

Repetição é algo também essencial dentro da lógica de programação.

Em Python se utiliza o for, como exatamente um “para”. Como no exemplo, temos esta lista de autores:

autores = [
  "Dante Alighieri",
  "Machado de Assis",
  "Franz Kafka",
  "Luís Vaz de Camões",
  "William Shakespeare",
  "José Saramago",
  "Aristóteles",
  "Júlio Verne",
  "Fernando Pessoa",
  "José de Alencar",
  "Euclides da Cunha",
  "Thomas Morus"
]

Para cada autor dentre a lista de autores eu irei imprimir seu nome, é isso que esse código fala:

for autor in autores:
  print(autor)

A variável autor foi criada dentro do for e poderia ter sido utilizada de qualquer outra forma simbólica. Escolhi autor, pois é o que reflete melhor o seu significado.

Temos também o while que de fato é um “enquanto”.

Vamos pegar esse exemplo:

Possuo uma variável numero que sua posição é -10 , enquanto a variável não chegar em 10, ela adicionará mais 1.

numero = -10
while (numero < 10):
  numero += 1
  print(numero)

Veracidade

Testar a veracidade no Python, segue a mesma linha lógica padrão, o True e o False aqui são impressos de com a primeira letra maiúscula.

10 < 5
False
20 > 10
True

O True é considerado 1 e o False 0.

Todos estes exemplos são considerados False:

False   #falso
None    #nulo
0       #zero
''      #string vazia
[]      #lista vazia
()      #tupla vazia
{}      #dicionário vazio

Em relação aos operadores booleanos são os comuns and, or, not, que nós bibliotecários já estamos acostumados com eles.

Python também tem duas funções: o all que retornará True quando todos os elementos de uma lista forem verdadeiros ou False se apenas um for falso.

lista_all = [5, True, (2,2)]
all(lista_all)
True
lista_all = [5, True, ()]
all(lista_all)
False

Tem também outra função any que retorna True se ao menos um for verdadeiro e False se não houver nenhum.

lista_any = [1, 0, ()]
any(lista_any)
True
lista_any = [0, 0, ()]
any(lista_any)
False

Importar Módulos

Nem todos os recursos do Python são carregados por padrão, tanto da própria linguagem ou como de terceiros.

Para isso precisamos usar o import:

import collections

Para facilitar o uso, podemos atribuir um alias (apelido) para ele quando você o chamar para utilizar alguma função.

import collections as coll
coll.Counter

Assim como nós temos o bastante conhecido do Pandas, que é pd:

import pandas as pd
pd

Podemos também importar um valor específico do módulo e não precisar qualificá-lo quando utilizar como em:

from collections import Counter 
Counter

Contador

Essa funcionalidade é super útil e irá mapear os valores para contá-los. Com por exemplo, temos esta lista de interesses:

interesses = [
  'biblioteconomia',
  'gatos',
  'livros',
  'ciencia de dados',
  'filmes',
  'gatos',
  'livros',
  'séries',
  'biblioteconomia',
  'filmes',
  'séries',
  'gatos',
  'trekking',
  'leitura',
  'história',
  'matemática',
  'filmes',
  'séries',
  'livros',
  'ciencia de dados',
  'livros',
  'filmes',
  'biblioteconomia'
  ]

Se eu quiser saber quantas vezes cada interesse se repete, apenas faço este código:

contagem_interesse = Counter(interesses)
contagem_interesse
Counter({'biblioteconomia': 3,
         'ciencia de dados': 2,
         'filmes': 4,
         'gatos': 3,
         'história': 1,
         'leitura': 1,
         'livros': 4,
         'matemática': 1,
         'séries': 3,
         'trekking': 1})

Eu posso também querer apenas os dois interesses mais escolhidos:

Para cada interesse e contagem de vezes dentro da lista eu quero apenas os dois mais comuns.

for interesse, count in contagem_interesse.most_common(2):
    print (interesse, count)

livros 4 
filmes 4

Só para lembrar que pode parecer bem simples quando olhamos no detalhe micro, mas são todos esses pequenos detalhes sendo trabalhados em conjunto que criarão um mecanismo poderoso.

Fico fascinado cada dia mais com a tecnologia!

Conjuntos (Sets)

Conjuntos são coleções de itens distintos entre si.

Vamos criar um conjunto:

id_contratos = set()
id_contratos.add(1)
id_contratos.add(2)
id_contratos.add(3)
id_contratos.add(4)
id_contratos.add(5)
id_contratos

Se consultar o id 12, o resultado será false:

id = 12
id in id_contratos
False

Mas Francisco, por que usar conjuntos?

Usar o in é uma ação muito rápida e se tivermos uma grande coleção, um conjunto é mais adequado do que uma lista. A outra razão é a facilidade de se encontrar itens únicos dentro de uma coleção.

Ordenação

O Python possui uma forma de ordenar os dados de uma lista, com a função sorted() ou o método .sort(). Como no exemplo:

ordenacao = [10,2,8,4,6,0]
print(sorted(ordenacao))    #sorted não altera a lista
print(ordenacao)
[0, 2, 4, 6, 8, 10]
[10, 2, 8, 4, 6, 0]
ordenacao.sort()            #.sort altera a lista
print(ordenacao)
[0, 2, 4, 6, 8, 10]

A função sorted() não altera a lista em si, mas o método .sort, já altera a ordem da lista na variável.

Ainda dentro de sorted(), você pode passar se quer em ordem crescente ou decrescente através do reverse:

qualis = ['B1','A1','B4']

sorted(qualis, reverse=True)
['B4', 'B1', 'A1']

Aleatoriedade

De acordo com o autor, é necessário gerar números aleatórios frequentemente, em ciência de dados. Para isso temos o módulo random, no qual random.random() gerará números entre 0 e 1.

random.random()
0.43363336680510567
random.random()
0.5317198217606026

Mas eles são números pseudo aleatórios, pois são determinísticos a partir de um estado interno que você pode determinar a partir do ramdon.seed().

Não ficou claro? Confira este vídeo que tenho certeza que você entenderá.

Mas, vamos exemplificar o ramdom.seed():

random.seed(10)
print(random.random())
random.seed(2)
print(random.random())
random.seed(10)
print(random.random())
0.5714025946899135
0.9560342718892494
0.5714025946899135

O seed configurado para 10 sempre terá aquele número pseudo aleatório.

Você também pode usar o random.range, no qual irá passar um limite de números para ele escolher entre eles

random.random()
0.9424502837770503
random.randrange(10)    #será um número entre 0 e 10
6
random.randrange(10,100) #será um número entre 10 e 100
83

Ou mesmo escolher um elemento entre vários de uma lista, a partir do random.choice:

periodicos = [
              'BRITISH JOURNAL OF NURSING', 
              'CIRCULATION (NEW YORK, N.Y.)', 
              'EUROPEAN JOURNAL OF HEART FAILURE', 
              'EUROPEAN JOURNAL OF ENDOCRINOLOGY'
              ]
random.choice(periodicos)

E até escolher aleatoriamente uma amostra sem substituição com o random.sample():

lista_de_numeros = range(100)
amostra = random.sample(lista_de_numeros,4)   #escolherá 4 números dentre a lista de 0 a 100 passada
amostra

Expressões Regulares

O autor passou bem por cima deste tópico, no qual achei bastante importante para nós como bibliotecários. Ele diz que expressões regulares são uma maneira de procurar por texto e até mesmo deixa claro que são complicadas. Cita alguns exemplos bem básicos, mas pouco claros.

Eu particularmente vou aprofundar mais um pouco neste tópico, nas próximas semanas, pois me atiçou a curiosidade.

O módulo de expressões regulares é o re:

import re       #módulo de expressões regulares

Compreensão de lista

Compreensões de listas é uma forma bem mais fácil de se criar uma nova lista a partir de elementos de uma anterior. Aplica-se uma função para cada elemento da lista original, reduzindo assim linhas de códigos a mais que seriam necessárias.

Por exemplo:

Para cada x numa lista de 0 a 5, se o x dividido por 2 for igual a 0, imprima eles:

lista = range(5)

for x in lista:         
  if x % 2 == 0:    
    print(x)

Comprimimos o for e o if em uma linha apenas de código:

numeros_pares = [x for x in lista if x % 2 == 0]
numeros_pares

O exemplo é bem simples, mas com códigos mais elaborados, isso se torna muito importante para melhorá-los.

Geradores e iteradores

Se pensarmos que podemos ter listas com 1.000.000 de números e que talvez queiramos trabalhar com eles um a cada vez, que retornar o cálculo, podemos utilizar um gerador com o operador yield.

Neste exemplo temos uma função que irá imprimir o x e somar mais 1, enquanto não chegar a 1.000.000:

def exemplo_de_gerador():
  x = 0
  while x < 1000000: 
    print(x)
    x = x + 1
exemplo_de_gerador()

Além de ser ineficiente e demorado, ele consumirá muita memória.

Ao colocarmos o operador yield, a função se tornará um gerador e nos retornará como abaixo:

def exemplo_de_gerador():
  x = 0
  while x < 1000000: 
    print(x)
    yield x
    x = x + 1
exemplo_de_gerador()

Ele fará o cálculo e vai parar, depois chamaremos o próximo e ele para novamente, chamaremos de novo e finaliza a rodada novamente.

Como no código abaixo:

gerador = exemplo_de_gerador() 
next(gerador) 
next(gerador) 
next(gerador) 
next(gerador)

Utilizamos o next() e passamos a função, ele irá imprimir 0,1,2,3.

Programação Orientada a Objeto

Assim como em outras linguagens o Python é multiparadigma e permite a “Orientação ao Objeto”. O que seria isso?

É a forma de se criar “Objetos” (Classes) que possuem dados (Atributos) e têm ações (funções), tornando o código mais limpo e simples.

Para ilustrar trouxe como exemplo genérico este trecho:

class UsuarioUniversitario:
  def __init__(self, id, curso):
    self.__id = id;
    self.__curso = curso;
    self.__disciplinas_ativas = disciplinas_ativas

  def consulta(self):
    # Codigo para consultar informação
    
  def pega_emprestado(self):
    # Codigo para pegar emprestado um recurso informacional

  def devolve(self):
    # Codigo para devolver recurso informacional

  def solicita_referencia(self):
    # Codigo para solicitar referência ao bibliotecário

Teríamos aqui algumas linhas de código onde possuímos uma classe “UsuarioUniversitario”, que possui 3 atributos característicos:

• id (número de identificação);
• curso (qual curso este universitário está realizando);
• disciplinas ativas (quais disciplinas ele está cursando neste semestre).

Ele também tem algumas ações:

• Consulta;
• Pega emprestado;
• Devolve;
• Solicita Referência.

A OO (Orientação aos objetos) é um paradigma bastante legal de se aprender devido a toda sua estruturação e possibilidade de desenvolvimento de sistemas mais complexos e organizados.

Ferramentas funcionais

O Python também possui ferramentas do paradigma da programação funcional, que tem como objetivo facilitar a resolução de problemas através da isolação deles com o uso das funções matemáticas puras.

Parece bastante complicado no começo, porque por facilitar tanto, até mesmo nos confunde para que suspeitemos ser mais complexo do que realmente é.

Vamos iniciar com o map():, ele possui duas variáveis, a primeira é uma função estabelecida e a segunda é uma lista de elementos.

Automaticamente ele passa a função em todos os elementos da lista, como no exemplo:

def subtrair_1(x):
  return x - 1

numeros_pares = [2,4,6,8,10]

numeros_impares = map(subtrair_1, numeros_pares)
print(list(numeros_impares))

Para usarmos a reduce (), precisaremos importar ela da biblioteca functools:

from functools import reduce

O módulo reduce tem uma estrutura similar ao map, mas ao invés de passar apenas a função em todos da lista, ele ainda reduz a apenas uma só. Como no exemplo:

def multiplicar(x, y):
  return x * y

numeros_multiplicados = reduce(multiplicar, numeros_pares)
numeros_multiplicados

Ele vai multiplicar cada número da lista pelo próximo = 2 x 4 x 6 x 8 x 10

Já o filter(), vai filtrar a lista por uma função. Da mesma forma como os dois anteriores, passa a função, depois a lista.

Como no exemplo:

def numeros_negativos(x):
  if x < 0: 
    return x

lista_numeros = range(-10,100)
print(list(filter(numeros_negativos, lista_numeros)))
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]

Ele vai filtrar de uma lista de -10 até 100, através da função que retornará se o número for menor que zero.

Enumeração

Algo bem simples que podemos enumerar diversos conjuntos de dados.

Como no exemplo:

CDD = ['Generalidades', 
       'Filosofia',
       'Religião',
       'Ciências sociais',
       'Línguas',
       'Ciências puras',
       'Ciências aplicadas',
       'Artes',
       'Literatura',
       'História e geografia']

print(list(enumerate(CDD)))

A função enumerate criou uma contagem para cada item da lista, a partir do seu índice 0.

Descompactação de Zip e argumentos

Podemos juntar duas ou mais listas e apenas uma, formada por tuplas correspondentes, através da função zip().

Como no exemplo:

lista_alfabetica = ['a','b','c']
lista_numerica =    [1,2,3]
lista_alfanumerica = list(zip(lista_alfabetica,lista_numerica))
lista_alfanumerica

Para que se “descompacte” esta lista, apenas utilizamos o * dentro da função e passamos duas variáveis para nomeá-las:

letras, numeros = (zip(*lista_alfanumerica))
letras, numeros

Algo bem simples, mas que o autor deixou claro que utilizaremos com frequência.

Args e Kwargs

Para ser sincero me pareceu bastante estranho a primeira vez que li *args e **kwargs, mas seu conceito é mais simples que estes nomes.

Na realidade são usados por convenção, pois poderiam ser quaisquer outros que tivessem um * ou ** em seus nomes, como *assuntos ou **metadados_do_livro.

Eles são elementos ‘coringas’ para poder passar um variedade 1 ou mais elementos variáveis,

O *args podem ser utilizados para passar uma lista variável de argumentos dentro de uma função.

Como no exemplo:

def assuntos_livro(titulo, *args):
    print('Título: ', titulo)
    for assunto in args:
        print('Assunto: ', assunto)
assuntos_livro('A aventura do livro', 
               'Livros e leitura - História',
               'Comunicação escrita', 
               'Tecnologia da informação - Aspectos sociais')
Título:  A aventura do livro
Assunto:  Livros e leitura - História
Assunto:  Comunicação escrita
Assunto:  Tecnologia da informação - Aspectos sociais

Criamos uma função que irá imprimir o título de um livros e seus 1 ou mais assuntos.

E se fosse apenas um assunto:

assuntos_livro('Crime e Castigo', 'Ficção Russa')
Título:  Crime e Castigo
Assunto:  Ficção Russa

Já os **Kwargs, podem ser usados para passar dicionários como variáveis em funções. Como no exemplo:

Criei uma função para passar o título e “puxar” apenas o autor de um dicionário que será passado como variável.

def autor_do_livro(titulo,**kwargs):
      autor = kwargs.get('creator')
      print(autor)

autor_do_livro('O Pensamento do exterior', 
               creator='Foucalt, Michel, 1926-1984', subject='Filosofia Francesa')
Foucalt, Michel, 1926-1984

Revisão

Este capítulo conseguiu abordar diversos pontos gerais da linguagem, mas com uma explicação bem rápida dos conceitos, nada do que o autor já não havia falado, entretanto acaba se tornando um obstáculo para quem não está estudando por outras fontes.

Mas para mim, foi muito legal passar por eles :)

Isso ainda é só o começo, dê um claps, me siga e vamos continuar nesta jornada do bibliotecário no mundo dos dados.

Ainda há muito a se explorar…