DEV Community: Lisandra Melo

Obtendo Dados do WhoScored: Projeto de Web Scraping com Selenium

Lisandra Melo — Thu, 06 Jun 2024 22:01:22 +0000

Há algum tempo, escrevi um post no dev.to sobre Web Scraping com Python, BeautifulSoup e Requests. Embora esse post ofereça uma base sobre o processo de raspagem de dados na maioria dos websites, em alguns casos, essa abordagem não é suficiente. Alguns sites são configurados para evitar o acesso automatizado para raspagem de dados. Em geral, os websites buscam evitar robôs que podem causar sobrecargas nos servidores e usuários que podem obter informações e usá-las sem o devido crédito.

Apesar dessas proteções, o uso de ferramentas de automações em sites podem ser essencial para a criação de soluções de automação, testes e análise de dados de aplicações web. Por isso, aprender sobre essas ferramentas é fundamental para o desenvolvimento, teste e análise de websites com proteções anti-crawlers.

Neste tutorial, vamos explorar como utilizar o Selenium para acessar e extrair dados de websites que possuem mecanismos de proteção mais avançados. O Selenium é ferramenta para automação de navegadores que pode simular a interação humana com páginas web, permitindo contornar algumas restrições impostas a scripts tradicionais de web scraping.

Requisitos e Instalação de Bibliotecas

Antes de começar a produzir o código em si, teremos de garantir que temos todas as ferramentas necessárias. Dessa forma, garanta que você possua os seguintes requisitos:

Python instalado em sua máquina;
Biblioteca Selenium para Python;
Biblioteca BeautifulSoup para Python;
Biblioteca Pandas para Python;
WebDriver de navegador.

Instalação de Ferramentas Necessárias

Instalação Selenium

A biblioteca Selenium para Python é uma ferramenta para automatizar interações com navegadores web. O Selenium permite que você escreva scripts em Python que exijam ações em um navegador, como clicar em botões, preencher formulários, navegar entre páginas e extrair dados de sites com proteções anti-crawlers.

Para instalar a biblioteca do Selenium, você pode usar o pip.

pip install selenium

Instalação BeautifulSoup

A biblioteca BeautifulSoup é uma ferramenta para extrair dados de arquivos HTML e XML. Ela torna a navegação, a busca e a modificação de documentos HTML e XML simples e eficaz.

Para instalar a biblioteca do BeautifulSoup, você também pode usar o pip.

pip install beautifulsoup4

Instalação Pandas

A biblioteca Pandas oferece estruturas de dados de alto desempenho e funções para manipulação de dados, tornando os processos de análise e ciência de dados mais eficientes e intuitivos.

Para instalar a biblioteca do Pandas, você também pode usar o pip.

pip install pandas

Download WebDriver

A ferramenta do Selenium usa Web Drivers para realizar atividades de automações. Um WebDriver é uma ferramenta usada para automatizar testes em navegadores web. Ele permite que desenvolvedores e testadores controlem um navegador (como Chrome, Firefox ou Safari) programaticamente, simulando a interação de um usuário real. Um dos WebDrivers mais populares é o Selenium WebDriver, que oferece suporte a diversos navegadores e linguagens de programação, como Python, Java e C#.

O ChromeDriver é um componente específico do Selenium WebDriver que permite controlar o navegador Google Chrome. Ele serve como uma ponte entre o Selenium WebDriver e o navegador, possibilitando que os testes automatizados sejam executados no Chrome.

Para fazer o download da ferramenta, é necessário acessar o site de downloads do Google Chrome e selecionar a versão de chromedriver compatível com seu Sistema Operacional.

Versões Estáveis do Chrome Driver Disponíveis

Após fazer o download do arquivo compactado correspondente, extraia os arquivos e guarde o local do arquivo chromedriver.exe, pois ele será usado posteriormente.

Implementação

O primeiro passo da implementação do nosso projeto será a importação das bibliotecas que usaremos. Para isso, use o trecho de código a seguir. O trecho importa a BeautifulSoup, a biblioteca Selenium e a biblioteca Pandas.

from bs4 import BeautifulSoup
from selenium.webdriver.chrome.service import Service
from selenium import webdriver
import pandas as pd

Com as bibliotecas importadas, podemos configurar nosso web driver para acessar páginas da internet. Para a configuração, o construtor do Selenium WebDriver precisa de um serviço - Service, que é usado para configurar e gerenciar o serviço do WebDriver para o Chrome, como especificar o caminho para o executável do ChromeDriver e definir argumentos adicionais; e opções para a instância do navegador Chrome. Dessa forma, no trecho abaixo, estamos configurando e instanciando nosso objeto responsável pela obtenção e manipulação da página.

chrome_options = webdriver.chrome.options.Options()
chrome_driver = "endereco/do/arquivo/chromedriver.exe"
service_to_pass = Service(executable_path=chrome_driver)
wd = webdriver.Chrome(service=service_to_pass, options=chrome_options)

Agora, iremos realizar a ação necessária para obter dados da página que desejamos. Para isso, utilizaremos o método get() do objeto criado. O método get é responsável por abrir o website. Posteriormente, utilizaremos a propriedade do objeto WebDriver chamada page_source, que nos dá acesso ao código-fonte (conteúdo) da página em questão.

Além disso, será necessário determinar o endereço da página que se deseja acessar. No projeto, usei o website www.whoscored.com, especificamente sua página sobre estatísticas. Este website possui proteção anti-crawler e, por isso, utilizando-a como teste, podemos notar a efetividade da ferramenta.

Página Acessada no Tutorial

URL_BASE = "https://www.whoscored.com/Statistics"
wd.get(URL_BASE)
soup_file = wd.page_source

Após esse trecho, já podemos acessar todo o código HTML da página web. Podemos utilizar essa informação para testes, análises ou transformações necessárias. Ainda, podemos usar o WebDriver para preencher formulários, clicar em botões ou navegar entre páginas. Para o projeto atual, irei propor apenas a limpeza da informação não estruturada presente na página e sua transformação em dados estruturados.

Para isso, usaremos as bibliotecas Pandas e BeautifulSoup importadas anteriormente. Caso você tenha dificuldades em acompanhar o código a seguir, indico buscar meu tutorial de Introdução ao WebScraping, já que ele introduz cada uma das funções usadas a seguir.

A primeira parte do tratamento consiste em passar o código-fonte pelo analisador de HTML da BeautifulSoup.

soup_page = BeautifulSoup(soup_file, "html.parser")

Agora, iremos buscar os dados que desejamos. No projeto, iremos obter dados da tabela destacada abaixo. São dados sumarizados com os 20 melhores clubes de acordo com as notas designadas pelo site.

Tabela a ser Acessada

Primeiro, acessaremos a tabela escolhida no HTML pelo seu ID.

main_table = soup_page.find('div', {'id': 'top-team-stats-summary'})

team_sum_stats_table = main_table.find('table', {'id': 'top-team-stats-summary-grid'})

Agora, dentro da tabela, conseguiremos os nomes de colunas existentes.

team_sum_stats_header = team_sum_stats_table.find_all('th')

header_columns = [column_name.text for column_name in team_sum_stats_header]

Note que o código acima usa List Comprehension. Esse tipo de recurso usa uma sintaxe mais limpa e simples para criar listas a partir de outras listas. Dessa forma, o código acima é equivalente ao proposto abaixo.

team_sum_stats_header = team_sum_stats_table.find_all('th')

header_columns = []
    for column_name in team_sum_stats_header:
        header_columns.append(column_name.text)

Agora, vamos obter os dados de células da nossa tabela. Para isso, use o código abaixo.

team_sum_stats_body = team_sum_stats_table.find('tbody').find_all('tr')

teams_stats = [[cell_value.text for cell_value in row.find_all('td')] for row in team_sum_stats_body]

Dessa vez, o código possui duas list comprehensions aninhadas. Talvez pareça complexo, mas na realidade, o código proposto faz o mesmo que o código abaixo.

teams_stats = []
for row in team_sum_stats_body:
    cells = row.find_all('td')
    row_values = []
    for cell_value in cells:
        row_values.append(cell_value.text)
    teams_stats.append(row_values)

Agora, já temos nossas colunas e nossas linhas de valores. Podemos então criar nosso DataFrame com informações estruturadas que estavam presentes no site. Para isso, use o código abaixo.

df_sum = pd.DataFrame(teams_stats, columns=header_columns)

print(df_sum.head())

O código resultará nos cinco primeiros registros da tabela do site como a imagem abaixo.

Resultado do Nosso Código

Repositório

O código completo do projeto está no meu repositório do github.

Considerações Finais

Espero que o tutorial ajude de alguma forma. Encorajo que implementem suas próprias versões e fico à disposição para ajudar como puder.

Deixo meu e-mail lisandramelo34@gmail.com e meu perfil no LinkedIn caso desejem entrar em contato.

Plataforma Scylax e a Análise de Dados sobre Pesquisas Acadêmicas

Lisandra Melo — Tue, 09 Nov 2021 11:28:28 +0000

Pesquisa Acadêmica e o Scylax

O processo de realização de pesquisas científicas é parte imperiosa durante a formação acadêmica. Visto que, tal processo fomenta o desenvolvimento da construção de conhecimento, promovendo a concretização do que se é proposto em sala de aula de forma interdisciplinar e palpável, possibilitando assim a atuação universitária sob os três pilares da universidade: ensino, pesquisa e extensão. Nesse sentido, é notável que pesquisas acadêmicas são bases fundamentais para o exercício adequado de centros acadêmicos universitários.

“Art. 207. As universidades [...] obedecerão ao princípio da indissociabilidade entre ensino, pesquisa e extensão.” (Constituição Federal, 1988)

Nessa perspectiva, é notável que o que se é produzido nas pesquisas acadêmicas constitui-se de dados de elevada relevância para a análise da qualidade e da circunstância de universidades ou quaisquer outros centros educacionais. Para agrupar todos esses dados, foi desenvolvida a plataforma Scylax, que tem como objetivo fornecer informações sobre pesquisas relacionadas a docentes, instituições, centros, departamentos e diversos outros membros componentes da universidade.

Características do Scylax

A plataforma obtém dados a partir de plataformas como Lattes, Scopus e Orcid e diante dos dados fornecidos fornece a visualização de informações como: total de produções, Qualis de produções, quantidade de produções com colaboração, áreas de pesquisa e tipo de pesquisa. Além disso, o Scylax fornece a funcionalidade de comparação de informações entre pesquisadores ou organizações educacionais.

Com ela também é possível visualizar e extrair informações relevantes a respeito das pesquisas por pesquisadores e instituições de ensino de forma prática e rápida. Esses dados, por sua vez, podem ser usados por diversas organizações e seus membros para avaliar o impacto e alcance de suas produções, a relevância de suas colaborações e áreas correlatas aos temas estudados.

Sendo assim, a ferramenta funciona como um acurado medidor de desempenho acadêmico, onde diversas instituições de pesquisa, que necessitem de dados de diferentes plataformas, podem recorrer seja para avaliar um candidato a bolsa ou reconhecer os trabalhos de maior destaque e relevância.

Possibilidades com os Dados

Sabemos que os dados que estejam brutos, ou seja, não estão dispostos de maneira organizada e analisados de maneira isolada não apresentam qualquer fundamento. Por isso, é necessário o processamento e relacionamento desses dados, a fim de gerar informação.

Contudo, há dois principais problemas na produção de informação, o primeiro deles é a coleta de dados: geralmente os dados são gerados em formatos, estruturas e tamanhos diferentes. O segundo problema é como será feito o armazenamento dessas informações: é preciso que os dados estejam bem estruturados para facilitar seu uso nas bases de dados.

Pensando nisso, existe um processo chamado ETL, que vem de Extract, Transform e Load (Extração, Transformação e Carregamento). ETL é um processo de integração de dados, relacionando dados de diversas fontes e gerenciando o armazenamento em um banco de dados centralizado.

As etapas da ETL:

Extração
Na etapa de extração os dados brutos são coletados de sua fonte original, por meio de API, banco de dados, raspagem ou outros sistemas. Esses dados são ajustados e unificados,e ficam na espera de serem transformados.
Transformação
Nesta etapa, os dados são processados, limpos e consolidados, a fim de que fiquem livres de quaisquer ruídos ou inconsistências. Também nesta etapa, os dados são agrupados de acordo com características similares.
Carregamento
Na última etapa, os dados transformados são carregados para uma estrutura de banco de dados.

Portanto, vimos que sem o uso de um método como o ETL seria muito difícil analisar as informações coletadas e por consequência não poderíamos resolver os problemas propostos.

Finalmente, sob posse dos dados reunidos pela plataforma Scylax e fazendo uso de ferramentas que auxiliem no processamento e relacionamento dessas informações, será possível realizar diversos tipos de estudos, como análises correlacionais, com os dados disponibilizados e agrupamentos baseados em características similares entre organizações educacionais ou pesquisadores.

Conclusão

Espera-se, dessa forma, que a partir da continuidade do estudo do tema, a preparação e análise dos dados fornecidos, a construção de um estudo agregador às informações já presentes na plataforma.

O texto acima foi desenvolvido a partir do esforço conjunto de Lisandra Melo, Kaio Menezes, Paulo Belarmino, Debora Gizele e Kelmo Alexandre. Este foi utilizado durante a avaliação parcial da disciplina de Ciências de Dados do curso de Bacharelado de Tecnologia da Informação oferecido pelo Instituto Metrópole Digital da Universidade Federal do Rio Grande do Norte.

Searching Tweets Using Twitter API

Lisandra Melo — Fri, 03 Sep 2021 15:22:08 +0000

Disclaimer: this is the English version of my work which is also available in Brazilian Portuguese, so, if you prefer, you can access that version by clicking here.

Creating your Developer Account

The Twitter API is a tool provided by Twitter that allows real-time access to what is being tweeted by its users. To access it, you will first need to have a developer account; you will need to request one, click here to go to the request page.

Once you gain access to the Developer Portal, you will notice a dashboard like the one below.

Now to connect to an API endpoint, you will need to create a project and an App. To do it, click on Create New Project and fill in the required information for the project and the App creation. After filling out the entire form, you will see a screen with the authentication keys of your application; they will be necessary when connecting to the API.

Now you have everything needed to connect to the API!

API Connection

It is possible to use several different technologies to create the API connection, but we will use Python and some of its libraries.

First, about the libraries that will be used, there will be three: Python Requests, json and Python Decouple. Python Requests will be responsible for carrying out the HTTP requests, json will help handle the responses obtained for the .json format, and the Python Decouple library will assist in the separation of the authentication from what is in the code.

So, first, we will import the required libraries.

from decouple import config
import requests
import json

After that, we must import the authentication value into the code for that, we will create, in the same directory of our file, a file with the name .env, and inside it, we will add the following information.

BEARERTOKEN=BearerTokenValue

After the file creation, it is now possible to use the Bearer Token authentication value without adding sensitive information to the code. To do this, we'll add the following line of code to our .py file.

bearer_token = config('BEARERTOKEN')

The bearer_token variable will now hold the value of your Bearer Token.

Now, we will create a function that adds authentication in the header of the HTTP request.

def set_auth(ob_auth):
    objeto_para_auth.headers["Authorization"] = f"Bearer {bearer_token}"
    return ob_auth

After that, we can carry out the request process for the API. We will define our search parameters and API endpoint.

search_url = "https://api.twitter.com/2/tweets/search/recent"
str_busca = f'to:{profile} {keyword} lang:{language}'
query_params = {'query': str_aux,'tweet.fields': 'attachments,author_id,created_at,lang,public_metrics,source','max_results':limit_tweets}

In the code above, the search_url variable receives the endpoint that will be used (you can read a little more about the endpoints available by clicking here). Furthermore, the str_busca variable receives the search string in the case of the example the search will be for tweets sent to a profile, containing a search key and written in a specific language, you can found other search filters here. Lastly, the query-params receives the search string, the fields that will be present in the responses (see more options by clicking here) and the number of tweets returned in the search.

After the previous definitions, we can perform the request for that we will use the commands below.

response = requests.get(search_url, auth=set_autenticacao, params=query_params)

if response.status_code != 200:
    raise Exception(response.status_code, response.text)

r = response.json()
print(json.dumps(r, indent=4, sort_keys=True))

Now you can see your tweets obtained based on your search!

The program developed in this tutorial is available in my GitLab repository.

Buscando Tweets com a API do Twitter

Lisandra Melo — Fri, 03 Sep 2021 15:21:10 +0000

Criando sua Conta de Desenvolvedor

A API do Twitter é uma ferramenta fornecida pelo próprio Twitter e permite o acesso em tempo real ao que está sendo produzido (tuitado) pelos usuários da rede social. Para acessá-la será necessário, primeiro, que você possua uma conta de desenvolvedor, para obtê-la é preciso que você realize uma solicitação clique aqui para seguir para página de solicitação.

Depois de conseguir seu acesso ao Portal de Desenvolvedor, você será apresentado a um painel como o abaixo.

Agora para ser capaz de se conectar a um endpoint da API, você precisará criar um projeto e um App. Para isso, clique em Create New Project e depois preencha as informações necessárias para a criação do projeto e de um App dentro do projeto. Após preencher todo o formulário você será apresentado a uma tela com as chaves de autenticação da sua aplicação, essas são necessárias durante a conexão com a API.

Agora você tem todo o necessário para se conectar à API!

Conexão com a API

Para realizar a conexão com a API é possível utilizar diversas tecnologias distintas, mas usaremos Python juntamente com algumas de suas bibliotecas.

Primeiramente, sobre as bibliotecas que serão utilizadas, serão três: Python Requests, json e Python Decouple. A Python Requests será responsável por realizar as solicitações HTTP, a json ajudará a manipular as respostas obtidas para o formato .json e a biblioteca Python Decouple será usada para separar a autenticação do que está escrito no código.

Então, primeiramente, importaremos as bibliotecas necessárias.

from decouple import config
import requests
import json

Depois disso, é necessário que importemos o valor de autenticação para o código, para isso, criaremos, no mesmo diretório do nosso arquivo, um arquivo com o nome .env e dentro dele adicionaremos a seguinte informação.

BEARERTOKEN=ValorDoSeuBearerToken

Após a criação do arquivo, já é possível utilizar o valor de autenticação do Bearer Token sem precisar colocar uma informação sigilosa junto ao código. Para isso, adicionaremos a seguinte linha de código no nosso arquivo .py.

bearer_token = config('BEARERTOKEN')

Dentro da variável bearer_token agora estará o valor de seu Bearer Token.

Agora, criaremos uma função que adiciona a autenticação no cabeçalho da solicitação HTTP que será realizada.

def set_autenticacao(objeto_para_auth):
    """
    Método que acrescenta, no objeto da busca, um cabeçalho correspondente a autenticação do request.
    """

    objeto_para_auth.headers["Authorization"] = f"Bearer {bearer_token}"
    return objeto_para_auth

Após isso, já somos capazes de realizar o processo de solicitação para a API. Então, determinaremos os nossos parâmetros de busca e o endpoint da API que será utilizado.

search_url = "https://api.twitter.com/2/tweets/search/recent"
str_busca = f'to:{perfil} {chave_busca} lang:{lingua}'
query_params = {'query': str_aux,'tweet.fields': 'attachments,author_id,created_at,lang,public_metrics,source','max_results':limite_tweets}

No código superior, a variável search_url recebe o endpoint que será usado (você pode ler um pouco mais sobre os endpoints disponíveis clicando aqui). Ademais, a variável str_busca recebe a string de busca que será aplicada, no caso do exemplo a busca será por tweets enviados para um perfil, contendo uma chave de busca e escritos em uma língua específica, outros filtros de busca podem ser vistos aqui. Já o query-params, recebe a string de busca, os campos que estarão presentes nas respostas (veja mais opções clicando aqui) e o número de tweets retornados na busca.

Depois das definições, podemos realizar o request, para isso, usaremos os comandos abaixo.

"""
Abaixo realizamos o request que usa os parâmetros
search url para defnir o endpoint,
auth para determinar o nosso bearer token como autenticação baseado na função anterior
params que usa a string de parâmetros
"""
response = requests.get(search_url, auth=set_autenticacao, params=query_params)

# Testa se a resposta foi bem sucedida
if response.status_code != 200:
    raise Exception(response.status_code, response.text)

# Converte a resposta para json
r = response.json()

# Imprime a resposta
print(json.dumps(r, indent=4, sort_keys=True))

Agora você pode ver seu os tweets obtidos baseados na sua busca!

O programa desenvolvido nesse tutorial está disponível no meu repositório do gitlab.

Building a "Hello World!": An Intro to Flask for Web Development

Lisandra Melo — Mon, 04 Jan 2021 22:11:46 +0000

What is Flask?

Flask is a Python micro-framework built to work with both web applications and RESTful APIs. Being a micro-framework gives Flask the ability to be simpler and lighter than other frameworks, (such as Django) in fact, Flask only "carries" along with it the libraries: Jinja and Werkzeug.

Jinja Library is a template engine tool used in Python web Frameworks (again, such as Django), Jinja gives us the ability to use variables and Python expressions inside HTML and XML files. Thus, you can write lines of codes in static files, such as HTML, and then, when the files are rendered, the code is executed and the static content is dynamically changed.

The Werkzeug library is a set of utilities and applications WSGI (Web Server Gateway Interface), hence, this library has applications for web server and web application communication and it controls and processes requests. Shortly, the library acts as a bridge, managing the interactions between users and our Flask applications.

What do I Need to Start with Flask?

To start with Flask, it is recommended that you have a basic knowledge of Python, along with some knowledge of HTML, CSS, and JavaScript. Besides, of course, the installation of Python and Flask.

That said, we will now install Flask, as Flask is a python library you will need to have the programming language installed on your machine before start using Flask. As for the library installation, we will use a python package installer (that comes with python on its installation), called pip, and to perform the installation we will type the following command in our terminal:

$ pip install Flask

When using this command you will be installing Flask on your entire machine, but it is recommended that we do not do this and use a virtual environment like Virtualenv, but to avoid any complications we will choose the simplest path shown above.

Building our "Hello World!"

Now we start the coding! First, we will have to import the Flask class from the flask library into our program:

from flask import Flask

After that, we will need to create an object of the Flask class, in its constructor we usually use the term __name__, because with it Flask will know where to look for HTML, CSS, and other files.

app = Flask(__name__)

Flask works with an internal route system, each route represents an address of our domain, that is, imagine that the domain of our page is helloworld.com.br a route from that address can be/specialhello that behaves being concatenated to the domain to represent another route on our website, in this case, the route address would be helloworld.com.br/specialhello.

Each route triggers the operation of a specific method (the method located immediately below the definition of the route) in our code and that method will determine what will be executed at our address upon its return. The return of this function is interpreted as pure HTML and rendered as one.

So, we will create our first two routes.

"""
Now we will define a route with @app.route(), the parameter inside the parentheses
represent an address of our route.
When using only '/' in parentheses we are specifying the main route
of our website, that is, we are just accessing the homepage of the website
"""
@app.route('/')
def hello_world():
    return 'Hello World!'

"""
Now we will define a second route with @app.route(), the parameter inside the
parentheses represents an address of our route. In this case, our route
will be ourdomain.com/lisandra
"""
@app.route('/lisandra')
def hello_lisandra():
    # We will return our text with a HTML tag this time
    return '<h1>Hello Lisandra!</h1>'

And you need to save all that in a file with a .py format.

Now we have our first web application ready to be executed, and we can do that in two ways.

First Method of Running Flask Locally

The first method for executing the flash is to use the flask command to run your program, but first, you must tell flask settings what your program name is.

If you are on Linux, you can type the following command in your terminal:

$ export FLASK_APP=<your_program_name>.py

If you are on Windows, type the following line of code at your command prompt:

C:\your\application\directory>set FLASK_APP=<your_program_name>.py

And if you are in the PowerShell, type:

PS C:\your\application\directory>$env:FLASK_APP = "<your_program_name>.py"

Then, you can run the following command to run your program.

flask run

Second Method

Another way to run your application is by adding a few lines of code to your application.

First, we will test whether we are running this program as a program alone or importing it as a library, if it is being executed as a program the variable __name__ receives the value of__main__.

After that, we will use the run() method of the Flask class to run our program.

"""
Now we will determine that we want to run our app, for that we use app.run()
we could only write this at the end of our program, but we do a test
before this test checks if our variable __name__ is equal to '__main__' when
a .py file is executed by itself as a program, __name__ is defined
as '__main__' so if we run our program we will run app.run ()
"""
if __name__ == "__main__":
     app.run ()

Then, to run your program, type the following command in your terminal.

python <your_program_name>.py

Execution

When you run the program, in either one of the ways presented before, you will see something on the screen like the following output.

 * Serving Flask app "hello" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

And now if you access the address shown in your output you will see the following page:

Hello World developed in the program presented in the browser

If you access our route '/lisandra' at the address http://127.0.0.1:5000/lisandra you will see the output "Hello Lisandra!", because it was what we asked for it to return.

Screenshot of the page in the second route created

Note that "Hello Lisandra!" is printed as a <h1> element, that happens because our return in the /lisandra route function is always executed as HTML content, so any tags in the return will be executed as such.

Now you can see your first website using Flask up and running!

The program developed in this tutorial is available in my GitLab.

Introdução ao Flask: Criando seu Primeiro "Olá Mundo!"

Lisandra Melo — Sun, 03 Jan 2021 16:55:15 +0000

O Que é Flask?

Flask é um micro-framework especializado em desenvolvimento de aplicações web e de APIs RESTful para a linguagem de programação Python. Ser um micro-framework significa que o Flask é uma estrutura mais simples e leve que Frameworks comuns, especificamente, o flask somente necessita de duas bibliotecas: a biblioteca Jinja e a biblioteca Werkzeug.

A biblioteca Jinja é uma ferramenta para modificação de templates que é usada em frameworks web de Python como o Django, em outras palavras, com Jinja conseguimos usar variáveis e expressões escritas em Python em arquivos HTML ou XML. Desse modo, você consegue usar linhas de código dentro de um arquivo estático como o HTML que depois são renderizadas e apresentadas juntos aos outros conteúdos do arquivo, tornando o conteúdo da nossa página algo dinâmico.

Já a biblioteca Werkzeug, é um conjunto de utilidades e aplicações de um WSGI (Web Server Gateway Interface - Interface de Gateway de Servidor Web), ou seja, essa biblioteca apresenta aplicações para as maneiras de comunicações de um servidor da Web com aplicativos da Web e como esses podem ser encadeados para processar uma solicitação. Em resumo, essa biblioteca controla as interações entre a internet e nossas aplicações em flask.

O Que Preciso Para Começar com o Flask?

Para começar com o Flask é indicável que você tenha conhecimento básico de Python, juntamente com conhecimento de HTML, CSS e JavaScript. Além de, obviamente, a instalação do Python e do Flask.

Dito isso, agora instalaremos o flask, como o framework é uma biblioteca python, precisamos instalar o python em nossa máquina antes de usar o flask. Quanto à instalação da biblioteca, usaremos um instalador de pacotes python, como pip, e para realizar a instalação, digitaremos o seguinte comando em nosso terminal:

$ pip install Flask

Ao executar esse comando você estará instalando o Flask em toda sua máquina, mas é recomendado que não façamos isso e usemos um ambiente virtual como o Virtualenv, mas para evitar quaisquer complicações utilizaremos esse caminho mais simples de instalação.

Criando Nosso "Olá Mundo!"

Primeiramente, temos que importar a classe Flask da biblioteca flask para o nosso programa:

# Primeiro precisamos importar a Classe Flask da biblioteca Flask que instalamos
from flask import Flask

Depois disso, precisaremos criar um objeto da classe Flask. No seu construtor geralmente usamos o termo __name__, pois com tal termo o Flask saberá onde procurar arquivos HTML, CSS e outros facilmente.

# Agora criaremos um objeto da classe Flask
app = Flask(__name__)

O Flask funciona com um sistema interno de rotas, cada rota representa um endereço do nosso domínio. Imagine que o domínio da nossa página é olamundo.com.br uma rota desse endereço pode ser /olaespecial que se comporta se juntando ao domínio para representar outro local no nosso site, nesse caso, o local seria olamundo.com.br/olaespecial.

Cada rota engatilha o funcionamento de uma função específica (a função localizada imediatamente abaixo da definição da rota) no nosso programa, essa função determinará o que será executado no nosso endereço a partir do seu retorno. Além disso, retorno dessa função é interpretado como HTML e rederizado como um.

Então, criaremos nossas duas primeiras rotas.

"""
Agora definiremos uma rota com o @app.route() o parâmetro dentro dos parênteses
representam um endereço da nossa rota.
Quando usamos somente '/' nos parênteses estamos especificando a rota principal
do nosso site, ou seja só estamos buscando a página referente ao domínio do site
"""
@app.route('/')
def ola_mundo():
    return 'Ola Mundo!'

"""
Agora definiremos uma segunda rota com o @app.route() o parâmetro dentro dos
parênteses representam um endereço de nossa rota. Nesse caso, nossa rota
será dominio.com.br/lisandra
"""
@app.route('/lisandra')
def ola_lisandra():
    # Retornaremos uma tag HTML nesse caso
    return '<h1>Olá Lisandra!</h1>'

Agora temos nossa primeira aplicação web pronta para executá-la podemos realizar dois processos.

Primeiro Método de Executar Localmente o Flask

O primeiro método para execução do flash consiste em usar o comando flask para executar seu programa, mas antes de utilizá-lo, você deverá dizer para as configurações do flask qual o nome do seu programa.

Se você está no Linux, pode digitar o seguinte comando no seu terminal:

$ export FLASK_APP=<nomedoseuprograma>.py

Se você está no Windows, digite no seu prompt de comando a seguinte linha de código:

C:\lugar\da\sua\aplicacao>set FLASK_APP=<nomedoseuprograma>.py

Já se você estiver no power shell, digite:

PS C:\lugar\da\sua\aplicacao>$env:FLASK_APP = "<nomedoseuprograma>.py"

Depois disso, você pode executar o seguinte comando para executar seu programa.

flask run

Segundo Método

Outra maneira de executar sua aplicação é adicionando algumas linhas de código a sua aplicação. Primeiro, testaremos se estamos executando esse programa como um programa sozinho ou o importando, caso esteja sendo executado como um programa a variável __name__ recebe o valor de __main__, caso seja importado, não.

Após isso, iremos usar o método run() da classe Flask para executar o nosso programa.

"""
Agora determinaremos que desejamos executar nosso app, para isso usamos o app.run()
poderíamos somente escrever isso no final do nosso programa, mas fazemos um teste
antes esse teste verifica se nossa variável __name__ é igual a '__main__' quando
um arquivo.py é executado por sozinho como um programa, __name__ é definido
como '__main__' logo se executarmos o nosso programa iremos executar o app.run()
"""
if __name__ == "__main__":
    app.run()

Depois, para executar seu programa escreva no seu terminal o seguinte comando.

python <nomedoseuprograma>.py

Execução

Ao executar o programa em qualquer uma das formas, você verá na sua tela algo como a seguinte saída.

 * Serving Flask app "ola" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

E agora se você acessar o endereço mostrado na sua saída você verá a seguinte saída:

Olá Mundo desenvolvido no programa apresentado no navegador

Já se você acessar nossa rota '/lisandra' no endereço http://127.0.0.1:5000/lisandra você verá a saída "Olá Lisandra!", pois foi o que pedimos no retorno da nossa função.

Print do retorno ao acessar a segunda rota criada

Perceba que o "Olá Lisandra!" está impresso como um elemento <h1>, pois nosso retorno na função da rota /lisandra é executado sempre como um conteúdo HTML, então quaisquer tags no retorno serão executadas.

Agora você pode ver seu primeiro site usando Flask em funcionamento!

O programa desenvolvido nesse tutorial está disponível no meu repositório do gitlab.

Using Probability and Statistics to Predict Sportive Results

Lisandra Melo — Thu, 13 Aug 2020 16:27:40 +0000

This article is an English translation of my article which was written on Brazilian Portuguese and posted here on my dev.to profile.

Initial Considerations

In this article we will use mathematical concepts like Expected Value and Probability Distribution, if you don’t know much about these concepts, you may still understand everything that’s being done in the article, but if you want to learn more about the content, I indicate the Khan Academy website especially the modules on Probability Distribution and Average - Expected Value, they are short and very explanatory videos about the concepts.

Introduction to the Project

In this project, we will use probability and statistics to predict the results of football matches. For this, we will use Python and its Numpy library, along with concepts of probability and statistics.

We will perform the following process, we will read a file containing all the results of AFC Ajax matches in the Dutch football league (Eredivisie) during the 18/19 season and we will, for each round, predict the score of the next match of the team, this prediction will consist of the Expected Value (EV) of goals scored by the club and the EV of goals conceded.

What Happens If We Guess Random Values?

For future reference, we will look at what would happen if we tried to guess the results of the matches using random values.

We will consider that Ajax can score from 0 (minimum number of goals scored in a match in our data) to 8 (maximum number recorded by Ajax in a match in our data) goals, that is, a total of 9 possible results, and allow from 0 (registered minimum) to 6 (registered maximum) goals, a total of 7 possibilities. We have that the probability of getting a match score prediction right is to get the right number of goals scored and the right number of goals conceded, so if we choose random values in the determinated interval we will have:

\frac{1}{9} \newline P(goalsAllowed) = \frac{1}{7} \newline P(matchScore) = P(goalsScored) * P(goalsAllowed) = \frac{1}{9}* \frac{1}{7} = \frac{1}{63} = 0,0159

The Dutch league has a total of 34 matches, we will not make predictions for the first round, as we have no previous data to help us calculate a prediction. So, considering that we have 33 matches to try to get at least one right score, we will multiply 33 by the probability of a right match score, which gives us a value of around 0.5238 right score. This means that without mathematical tools, using random values, we are expected to get the right score of less than one match of the 33 analyzed. For the number of goals scored on a match, we have an expected value of 3.6667 (33 * 1/9) right results and for goals conceded 4.7143 (33 * 1/7).

So let's try to improve these values (which are very low) using math and programming.

Project Implementation

To create our project, first, we will create our scores file, this file will have a specific format and will be written as:

goalsscored,goalsconceded

For example, if Ajax scored 4 goals and conceded 2 in a match we will have in the file:

4,2

This file will be named resultados.txt, and it is available in the project repository.

Now we are going to start the coding part of our project! We will begin importing the necessary library.

import numpy as np

Then we will open our scores file.

# Opening the file with our scores
fileResults = open("resultados.txt", "r")

After opening the file, we will insert the contents of the file into a list called matchesScores using a list comprehension, which is a way of defining, creating, and maintaining lists in python. With this tool, we can create an iterator and fill lists within a single line of code.

At the end of the iteration, we will close the file (resultados.txt) that was opened at the beginning of our code.

# Declaring our score list
matchesScores = []

# The for loop will work with every line of the file in each iteration
for lineofFile in fileResults:
    """
   The next line of code will add the contents of a file line,
   inside the braquets we have a list comprehension which
   does the exact same work as the following code:
   list = []
    for x in l.split(","):
        list.append(int(x))
    results.append(list)
    """
    matchesScores.append([int(x) for x in lineofFile.split(",")])

# The we will close our file
fileResults.close()

Now we will start analyzing the data obtained. But first, we will initialize some variables that will store our formatted data.

# We Will declare two lists, one containing the goals scored and one with the goals conceded
goals_scored = []
goals_conceded = []

# We will declare the number of time we got the goals scored, goals conceded and both of them right
right_round = 0
right_goals_scored = 0
right_goals_conceded = 0

We will then iterate through the entire matchesScores list, separating the values it contains in goals scored and conceded and then calculating the expected value of each of these categories to calculate a score prediction for the next round.

For it, we will obtain the frequency of each number of goals, that is, how many times the team has scored 0 goals, 1 goal, 2 goals, and so on. We will do the same with the goals conceded. With the frequency of each number of goals, we will have the data to calculate our expected value.

For example, we can have a frequency like the one shown in the graph below (This is not the actual frequency of the data).

Example of how the frequency could look like

To define the goals scored and conceded we will code:

"""
We will go through our list of scores per round
and calculate the expected value of goals scored
and conceded for each round,
we will predict with these values and
then we will check if these values correspond
to the result that happened in the match.
"""
for round in range(len(matchesScores)):
    goals_scored.append(matchesScores[round][0])
    goals_conceded.append(matchesScores[round][1])

    # Now we will get the frequency of the number of goals scored so far
    num_goals, freq_num_goals = np.unique(goals_scored, return_counts=True)
    # For organizational reasons, we will transform our values into a dictionary 'goals': frequency
    dic_goals_scored = dict(zip(num_goals, freq_num_goals))

    # We wil do the same with the goals conceded
    num_goals, freq_num_goals = np.unique(goals_conceded, return_counts=True)
    # For organizational reasons, we will transform our values into a dictionary 'goals': frequency
    dic_goals_conceded = dict(zip(num_goals, freq_num_goals))

After that, we will calculate the expected value of the goals, that is, the values that are expected in the next match considering the values of the previous rounds. To calculate this value we will multiply all the values in the dictionary (number of goals scored) by their probability of occurrence (Frequency divided by the number of rounds) getting then our expected values.

    expected_scored=0
    for goal in dic_goals_scored.keys():
        expected_scored += goal*(dic_goals_scored[goal]/len(goals_scored))

    expected_conceded=0 
    for goal in dic_goals_conceded:
        expected_conceded += goal*(dic_goals_conceded[goal]/len(goals_conceded))

After calculating our expected values, we will print our prediction and compare it with the result of the next round to see if we got the result of the match, the number of goals scored and the number of goals conceded right with our prediction.

    # After calculating our prediction we will print it and compare to the real result

    # The next line will round our values to the closest integer
    expected_scored = int(np.around(expected_scored))
    expected_conceded = int(np.around(expected_conceded))

    """
    If we are in the last round we have no future round
    to predict so we will stop our iteration
    """
    if (round+1 == len(matchesScores)):
        break
    """
    Now we will print our expected value for the next round
     as lists start at number 0 we have to add
     1 to the round value to get the round currently being read,
     that is, we have to add 2 to the number of the `round`
     to get the value of the NEXT round.
    """
    print(f'At the {round+2} round we predicted a result of Ajax  {expected_scored} x {expected_conceded} opponent')
    print(f'At the {round+2} we got a result of Ajax  {matchesScores[round+1][0]} x {matchesScores[round+1][1]} opponent')

    # We will check the results
    if(expected_scored==matchesScores[round+1][0] and expected_conceded==matchesScores[round+1][1]):
        right_round += 1
    if(expected_scored==matchesScores[round+1][0]):
        right_goals_scored += 1
    if(expected_conceded==matchesScores[round+1][1]):
        right_goals_conceded += 1

After the loop execution, we will check our number of right guesses.

# We Will print the results
print("We got {0:1d} of the matches results right, this is, {1:2.2f}%".format(right_round, (right_round/33)*100))

print("We got {0:1d} of the goals scored in a match right, this is, {1:2.2f}%".format(right_goals_scored, (right_goals_scored/33)*100))

print("We got {0:1d} of the goals conceded in a match right, this is, {1:2.2f}%".format(right_goals_conceded, (right_goals_conceded/33)*100))

The output of our program will look like this

> At the 2 round we predicted a result of Ajax  1 x 1 opponent
> At the 2 we got a result of Ajax  1 x 0 opponent
...
> At the 34 round we predicted a result of Ajax  3 x 1 opponent
> At the 34 we got a result of Ajax  4 x 1 opponent
> We got 4 of the matches results right, this is, 12.12%
> We got 7 of the goals scored in a match right, this is, 21.21%
> We got 15 of the goals conceded in a match right, this is, 45.45%

Note that we got 4 results right from a complete match, 8 times more than using random values, 7 predictions of goals scored, 2 times more, and 15 predictions of goals conceded, 3 times more.

The use of expected values helped a lot to improve our number of correct guesses. This shows how powerful simple concepts of probability and statistics can be in data analysis.

The program developed in this article is available in my gitlab repository. I hope I have helped you in any way, if you have any problems or questions feel free to leave a comment on this post or send me an email;).

Probabilidade E Estatística Para Previsão de Resultados Esportivos

Lisandra Melo — Tue, 11 Aug 2020 20:13:42 +0000

Considerações Iniciais

Usaremos conceitos matemáticos como Valor Esperado e Distribuição de Probabilidade nesse artigo, se você não conhece muito sobre esses conceitos, é possível que você ainda entenda tudo que está sendo feito no artigo, mas se você deseja aprender mais sobre os conteúdos, indico o site Khan Academy nos módulos sobre distribuição de probabilidade e Média - Valor Esperado, são vídeos curtos e bastante explicativos sobre o conteúdo.

Introdução ao Projeto

Nesse projeto, vamos usar probabilidade e estatística para prever resultados de partidas de futebol. Para isso, vamos usar Python e sua biblioteca Numpy, acompanhados de conceitos de probabilidade e estatística.

Vamos realizar o seguinte processo, faremos a leitura de um arquivo contendo todos os resultados de partidas do AFC Ajax na liga holandesa de futebol (Eredivisie) na temporada de 18/19 e iremos, a cada rodada, realizar uma previsão de resultado da próxima partida do time, essa previsão consistirá na Esperança (Valor Esperado) de gols feitos pelo clube e na Esperança de gols sofridos.

O Que Acontece Se Usarmos Adivinhação Com Valores Aleatórios?

Para futura comparação, analisaremos o que aconteceria se tentássemos adivinhar os resultados das partidas usando valores aleatórios.

Considerando que o Ajax pode marcar de 0 (número mínimo de gols marcados em uma partida nos nossos dados) a 8 (número máximo registrado pelo Ajax em uma partida nos nossos dados) gols, ou seja, um total de 9 possibilidades de resultados, e sofrer de 0 (mínimo registrado) a 6 (máximo registrado) gols, um total de 7 possibilidades. Temos que a probabilidade de acertar uma previsão de rodada é acertar o número de gols marcados e de gols sofridos, então escolhendo valores aleatórios no intervalo essa é.

\frac{1}{9} \newline P(golsSofridos) = \frac{1}{7} \newline P(umaRodada) = P(golsMarcados) * P(golsSofridos) = \frac{1}{9}* \frac{1}{7} = \frac{1}{63} = 0,0159

A liga holandesa possui 34 rodadas, não faremos previsão para a primeira rodada, pois não temos nenhum dado anterior que nos ajude a calcular uma previsão. Então, considerando que temos 33 rodadas para tentar acertar pelo menos um resultado, multiplicaremos 33 pela probabilidade de uma rodada, que nos fornece um valor de 0,5238 resultados certos. O que significa que sem artifícios de probabilidade, usando valores aleatórios, é esperado que acertemos o resultado de menos de uma rodada das 33 analisadas. Já para o número de gols marcados temos um valor esperado de acertos de 3,6667 (33 * 1/9) e para o de gols sofridos 4,7143 (33 * 1/7).

Vamos então tentar melhorar esses valores (que são bem baixos) usando matemática e programação.

Implementação Do Projeto

Para criarmos nosso projeto, primeiro, vamos criar nosso arquivo de resultados, esse arquivo terá uma formatação específica e será escrito como:



golsmarcados,golssofridos

Por exemplo, se o Ajax marcou 4 gols e sofreu 2 em uma partida de uma rodada teremos no arquivo:

4,2

Esse arquivo será salvo como resultados.txt, e está disponível no repositório do projeto.

Agora vamos começar a produzir nosso programa, iniciaremos importando as bibliotecas que usaremos.



import numpy as np

Depois abriremos nosso arquivo de resultados.



# Abrindo o arquivo com os resultados
"""
o arquivo está formatado da seguinte forma:
se o ajax ganhou fazendo 3 gols e sofrendo 1 - em casa ou fora de casa -
nosso arquivo registrará a rodada como:
3,1
"""
arquivo = open("resultados.txt", "r")

Após a abertura, vamos inserir o conteúdo do arquivo em uma lista chamada resultado_rodadas usando uma list comprehension, que é uma forma de definição, criação e manutenção de listas no python. Com essa ferramenta, podemos criar um iterador e preencher listas com uma só linha.

Já no fim da iteração, fecharemos o arquivo (resultados.txt) que foi aberto no início do nosso programa.



# Inicializando nossa lista de resultados
resultado_rodadas = []

# O for vai percorrer cada linha do arquivo
for linha in arquivo:
    """
    A próxima linha irá adicionar os resultados na nossa lista,
    dentro dos parênteses temos uma 'list comprehension' que
    realiza o mesmo que o seguinte trecho de código:
    list = []
    for x in l.split(","):
        list.append(int(x))
    results.append(list)
    """
    resultado_rodadas.append([int(x) for x in linha.split(",")])

# Fecharemos o arquivo
arquivo.close()

Agora daremos início à análise dos dados obtidos. Primeiramente, inicializaremos algumas variáveis que armazenaram nossos dados formatados.



# Agora iremos trabalhar com os dados que obtemos rodada a rodada

# Inicializaremos nossas listas de gols marcados e gols sofridos
gols_marcados = []
gols_sofridos = []

# Também calcularemos nosso número de acertos de resultados para controlarmos quão boa é nossa previsão
acertos_rodada = 0
acertos_gols_marcados = 0
acertos_gols_sofridos = 0

Iremos, então, percorrer toda a lista resultado_rodadas separando os valores que ela contém em gols marcados e sofridos e depois calculando o valor esperado de cada uma dessas categorias para calcularmos uma previsão para a próxima rodada.

Além disso, obteremos a frequência de cada número de gols, isto é, quantas vezes o time marcou 0 gol, 1 gol, 2 gols e assim por diante. Faremos o mesmo com os gols sofridos. Com a frequência de cada gol, vamos ter os dados necessário para calcular nosso valor esperado.

Por exemplo, podemos ter uma frequência como a representada no gráfico abaixo (Essa não é a frequência real dos dados).

Gráfico de Exemplificação de como funcionará nosso dicionário de frequência

Para separar os gols escreveremos:



"""
Percorreremos nossa lista de resultados por rodada e calcularemos
o valor esperado de gols marcados e sofridos para cada rodada faremos
uma previsão com esses valores e depois iremos conferir se esses valores 
correspondem ao resultado que ocorreu na rodada
"""
for rodada in range(len(resultado_rodadas)):
    gols_marcados.append(resultado_rodadas[rodada][0])
    gols_sofridos.append(resultado_rodadas[rodada][1])

    # Agora iremos obter a frequência do número de gols registrados até o momento
    num_gols, freq_num_gols = np.unique(gols_marcados, return_counts=True)
    # Por questão de organização transformaremos nossos valores em um dicionário do tipo 'gols':frequencia
    dic_gols_marcados = dict(zip(num_gols, freq_num_gols))

    # Faremos o mesmo com os gols sofridos
    num_gols, freq_num_gols = np.unique(gols_sofridos, return_counts=True)
    # Por questão de organização transformaremos nossos valores em um dicionário do tipo 'gols':frequencia
    dic_gols_sofridos = dict(zip(num_gols, freq_num_gols))

Após isso, calcularemos a esperança/valor esperado dos gols, isto é, os valores que são esperados na próxima rodada considerando os valores das rodadas anteriores. Para calcularmos tal valor iremos multiplicar todos os valores do dicionário (número de gols marcados) por sua probabilidade de ocorrência (Frequência dividida pelo número de rodadas).



    # Agora calcularemos a esperança dos gols 
    esperanca_marcados=0
    for gol in dic_gols_marcados.keys():
        esperanca_marcados += gol*(dic_gols_marcados[gol]/len(gols_marcados))

    esperanca_sofridos=0 
    for gol in dic_gols_sofridos:
        esperanca_sofridos += gol*(dic_gols_sofridos[gol]/len(gols_sofridos))

Depois de calcular nossas esperanças, vamos realizar nossa previsão e compará-las com os resultados reais das rodadas para conferir se acertamos o resultado da partida, o número de gols marcados e o número de gols sofridos com nossa previsão.



    # Depois de calcular nossas esperanças vamos imprimi-las e compará-las com os resultados reais

    # As próximas linhas arredondam nosso resultado para um valor inteiro
    esperanca_marcados = int(np.around(esperanca_marcados))
    esperanca_sofridos = int(np.around(esperanca_sofridos))

    # Se estivermos na última rodada já realizamos nossa previsão
    # na iteração anterior então devemos não devemos imprimir nossa esperança
    if (rodada+1 == len(resultado_rodadas)):
        break
    """
    Agora imprimiremos nosso valor esperado para a rodada que virá
    como listas têm posição inicial no número 0 temos que adicionar
    1 ao valor da rodada para conseguirmos a rodada que está sendo lida atualmente,
    ou seja, temos que adicionar 2 ao numero da `rodada`
    para conseguirmos o valor da próxima rodada.
    """
    print(f'Na {rodada+2} rodada esperamos um resultado de Ajax  {esperanca_marcados} x {esperanca_sofridos} adversário')
    print(f'Na {rodada+2} rodada obtemos um resultado de Ajax  {resultado_rodadas[rodada+1][0]} x {resultado_rodadas[rodada+1][1]} adversário')

    # Veremos se acertamos os resultados
    if(esperanca_marcados==resultado_rodadas[rodada+1][0] and esperanca_sofridos==resultado_rodadas[rodada+1][1]):
        acertos_rodada += 1
    if(esperanca_marcados==resultado_rodadas[rodada+1][0]):
        acertos_gols_marcados += 1
    if(esperanca_sofridos==resultado_rodadas[rodada+1][1]):
        acertos_gols_sofridos += 1

Depois da execução do for, iremos conferir nossa quantidade de acertos.



# Imprimiremos nossa quantidade de acertos
print("Acertamos {0:1d} previsões de uma rodada completa, isto é, {1:2.2f}%".format(acertos_rodada, (acertos_rodada/33)*100))

print("Acertamos {0:1d} previsões de gols marcados, isto é, {1:2.2f}%".format(acertos_gols_marcados, (acertos_gols_marcados/33)*100))

print("Acertamos {0:1d} previsões de gols sofridos, isto é, {1:2.2f}%".format(acertos_gols_sofridos, (acertos_gols_sofridos/33)*100))

A saída do nosso programa será basicamente a seguinte



> Na 2 rodada esperamos um resultado de Ajax  1 x 1 adversário
> Na 2 rodada obtemos um resultado de Ajax  1 x 0 adversário
...
> Na 34 rodada esperamos um resultado de Ajax  3 x 1 adversário
> Na 34 rodada obtemos um resultado de Ajax  4 x 1 adversário
> Acertamos 4 previsões de uma rodada completa, isto é, 12.12%
> Acertamos 7 previsões de gols marcados, isto é, 21.21%
> Acertamos 15 previsões de gols sofridos, isto é, 45.45%

Note que acertamos 4 resultados de uma rodada completa, 8 vezes mais que com o uso de valores aleatórios, 7 previsões de gols marcados, 2 vezes mais, e 15 previsões de gols sofridos, 3 vezes mais.

É perceptível que o uso de valor esperado ajudou bastante a melhorarmos nosso número de acertos de resultados. Isso representa o quanto conceitos simples de probabilidade, estatística e especialmente a matemática podem ser poderosos na análise de dados.

O programa desenvolvido nesse artigo está disponível no meu repositório do gitlab. Espero ter ajudado, se você estiver com algum problema ou dúvida sinta-se convidado a comentar esse post ou enviar um e-mail para mim ;).

Introduction to Probability Using Python

Lisandra Melo — Tue, 04 Aug 2020 20:54:37 +0000

This article is an English translation of my article which was written on Brazilian Portuguese and posted here on my dev.to profile.

What Is Probability?

When we roll a dice or throw a coin we deal with an attribute very common on some of our daily lives events, randomness, in these type situations we do not have full control of the output we are going to receive.
We use probability studies to try to empower ourselves with a bit of control in this type of situation, which is to say, we try to predict what outcomes are easier or harder to occur in an event. Thus, we can say that probability is the study of how likely a result is in an event.

In general, we represent a probability as the ratio between the outcomes we want to receive and the possible results of the event. So, being P(E) the probability of an event, we have the following equation.

\frac{n(wantedOutcomes)}{n(allOutcomes)}

This equation results in a value in a number between 0 and 1 and this probability represents the likeability of occurrence of one or more outcomes in each execution of the event. However, it is important to remember that generally in the real world we do not record the exact calculated values, after all, the event is random, the probability determines what usually tends to happen, that is, it is an approximation.

For example, if we want to know how likely it is that an even number will be obtained in a die roll, we must perform the following process:

First, we must separate our wanted cases, that is, the even numbers in a dice which are 2, 4, and 6 (three possibilities).
Then we must obtain all of the possible outcomes which are the numbers 1,2,3,4,5,6 six possibilities).
After that, we will apply these values in the equation presented above, so we will have: $\frac{3}{6} = \frac{1}{2} = 0,5$ Thus, we will have a probability of 0.5 to get an even number on a die roll, which means that out of 10 rolls we will probably get 5 even numbers and from 10000, 5000 even numbers.

Now we will check the behavior of the mentioned situation using programming to simulate it.

Random Events Using Python

We will create a program that, when executed, shows us the number of even numbers obtained in 10,000 dice rolls.

For it, we will use the function random.choice () from the Python library numpy which can choose, randomly, between values of an array, so we will need to import the numpy library at the beginning of the program.

import numpy as np

Now we will define all the outcomes, the wanted outcomes, the counter of the times an even number was obtained, and a constant with the number of times our "dice" will be rolled in the program.

# Defining a array with all possible outcomes
possible_outcomes = [1,2,3,4,5,6]

# Defining an array with all wanted outcomes
wanted_outcomes = [2,4,6]

# Defining the counter of the times an even number was obtained
number_of_even = 0

# Defining the number of times our "dice" will be rolled in the program
# We must use capitalized letters to represent that we are creating a constant
NUMBER_OF_EXECUTIONS = 10000

Now we will define our iterator that will go through our code 10,000 times choosing a random value in our outcomes (dice) each time and checking if that value is even if so, we will add 1 to the number_of_even variable.

# Now we will write an iterator for dice rolling
for i in range (NUMBER_OF_EXECUTIONS):
    # np.random.choice() chooses between the values of  all the outcomes of the event
    x = np.random.choice(possible_outcomes)
    """
    If the chosen value is in our wanted outcomes we will increment the counter of the times an even number was obtained 
    """
    if(x in wanted_outcomes):
        number_of_even += 1

Finally, we will print the value of number_of_even, that is, our number of even launches and the probability that it will be with the equation presented previously.

# Calculating our probability
probability_of_even  = number_of_even/NUMBER_OF_EXECUTIONS

# Printing the results
print("{0: d} of the outcomes were even, so, we had a probability of around {1:.2f}".format(number_of_even, probability_of_even))

When executing the program you will notice that the probability value rarely differs from 0.5 (in every execution of the program the value returned in numpy.random.choice () are different, so the number of even launches changes) which is what we predict initially as a probability of rolling dice with an even result.

Hence, is noticeable that probability creates a very good approximation of how real random situations tend to occur. Therefore, using tools from this area we can reach the most diverse conclusions about any random events.

The developed project is available in my gitlab repository. I hope that I have helped you in any way, and if you have any doubts, comments or problems feel free to leave a comment in this post ;).

Introdução À Probabilidade Com O Uso De Python

Lisandra Melo — Sun, 02 Aug 2020 21:14:59 +0000

O Que é Probabilidade?

Quando lançamos um dado ou jogamos uma moeda lidamos com uma característica de algumas situações do nosso cotidiano, a aleatoriedade, nessas situações não temos total controle do resultado que vamos obter.

Utilizamos estudos de probabilidade para tentar assumir um pouco de controle nesse tipo de situação, isto é, tentar prever resultados mais fáceis ou difíceis de ocorrer em um evento. Desse modo, podemos dizer que probabilidade é o estudo do quão provável é um resultado em um fenômeno (evento).

De modo geral, representamos a probabilidade como a razão entre os resultados que queremos e resultados possíveis do evento. Isto é, sendo P(E) a probabilidade de um evento, podemos determinar a seguinte definição

\frac{n(resultadosDesejados)}{n(todosResultados)}

Essa equação resulta em um valor em um número entre 0 e 1 e essa probabilidade representa as chances de ocorrência de um ou mais resultados a cada ocorrência do evento. Porém, é importante lembrar que geralmente no mundo real não registramos os exatos valores calculados, afinal, o evento é aleatório, a probabilidade determina o que geralmente tende a acontecer, ou seja, ela é uma aproximação.

Por exemplo, se desejamos saber quão provável é que um número par seja obtido em um lançamento de um dado devemos realizar o seguinte processo:

Primeiro devemos separar nossos casos favoráveis, isto é, os números pares em um dado que são 2, 4 e 6 (três possibilidades).
Depois devemos obter todas as possibilidades de números em um lançamento de um dado, o que também chamamos de espaço amostral ( $Ω\Omega$ ), essas possibilidades são 1, 2, 3, 4, 5 e 6 (seis possibilidades).
Após isso, aplicaremos esses valores na equação apresentada anteriormente, teremos: $\frac{3}{6} = \frac{1}{2} = 0,5$ Ou seja, teremos uma probabilidade de 0,5 de obter um número par em um lançamento de um dado, o que significa que de 10 lançamentos provavelmente obteremos cerca de 5 números pares e em 10.000 obteremos aproximadamente 5.000 números pares.

Agora iremos conferir o comportamento da situação mencionada usando programação para simulá-la.

Evento de Probabilidade Usando Python

Criaremos um programa que quando executado nos apresenta a quantidade de números pares obtidos em 10.000 lançamentos de dado.

Para isso, usaremos a função random.choice() da biblioteca do Python numpy que é capaz de escolher, aleatoriamente, entre valores de uma array, por isso, vamos precisar importar a biblioteca numpy no início do nosso programa.

import numpy as np

Agora definiremos o espaço amostral, os casos favoráveis, o contador de lançamentos favoráveis e uma constante com o número de lançamentos a ser realizado no nosso programa.

# Definiremos nosso espaço amostral como uma lista de todos os valores de um dado
espaco_amostral = [1,2,3,4,5,6]

# Definiremos nossos casos favoráveis como uma lista valores pares de um dado
favoraveis = [2,4,6]

# Definiremos nosso contador de lançamentos com resultados pares
resultados_pares = 0

# Definiremos nosso número de lançamentos, iremos usar 10000 no nosso exemplo
# Usamos letra maiúscula para representar que estamos criando uma constante
NUM_LANCAMENTOS = 10000

Agora definiremos um for que percorrerá nosso código 10.000 vezes escolhendo um valor aleatório no nosso espaço amostral cada uma das vezes e checando se esse valor é par, caso seja, adicionaremos 1 ao nosso contador de lançamentos resultados_pares.

# Agora escreveremos nosso iterador com nossos lançamentos
for i in range (NUM_LANCAMENTOS):
    # np.random.choice escolhe um dos valores no espaço amostral, ou seja, algum valor entre (1,2,3,4,5,6)
    x = np.random.choice(espaco_amostral)
    """O comando x in favoráveis checa se o valor escolhido
    está na nossa lista de favoráveis, ou seja, se é 2, 4 ou 6
    """
    if(x in favoraveis):
        resultados_pares += 1

Por fim, imprimiremos o valor de resultados_pares, ou seja, nosso número de lançamentos pares e a probabilidade de obtenção de números pares que será calculada com a equação apresentada anteriormente.

# Definição da probabilidade
probabilidade_par  = resultados_pares/NUM_LANCAMENTOS

# Impressão do resultado obtido
print("{0: d} dos resultados é par, isto é, obtemos uma probabilidade de aproximadamente {1:.2f}".format(resultados_pares, probabilidade_par))

Ao executar o programa você irá observar que raramente o valor de probabilidade varia de 0,5 (a cada execução os valores obtidos no numpy.random.choice() são diferentes então a quantidade de lançamentos pares muda) que é o que previmos inicialmente como probabilidade de lançamento de dado com um resultado par.

Dessa maneira, podemos observar que o cálculo de probabilidade cria uma aproximação muito boa de como situações aleatórias reais costumam ocorrer. Logo, a partir de ferramentas dessa área podemos conseguir as mais diversas conclusões sobre eventos aleatórios quaisquer.

O programa desenvolvido nesse tutorial está disponível no meu repositório do gitlab. Espero ter ajudado e se você estiver com algum problema ou dúvida sinta-se convidado a comentar esse post.

Extracting Data from Transfermarkt: An Introduction to WebScraping

Lisandra Melo — Tue, 28 Jul 2020 18:04:41 +0000

This a translated version of my tutorial originaly published in Brazilian Portuguese. The repository with the code from this tutorial is in my gitlab profile.

Getting data and transforming it into information is the foundation of fields such as Data Science. Sometimes obtaining it is very simple, for example, you can, right now, visit the Brazilian government website data.gov.br and get access to several raw data files from the government and then perform the analysis of a .csv file (a file format that transmits data) in an easy, simple and fast way.

However, in some situations the data is somewhat difficult to obtain, for example, you may need to receive data that is only available on a web page to perform an analysis. In this situation you can use Beautiful Soup, a Python library, to perform web scraping.

Beautiful Soup is the most popular Python library for receiving web data, it is capable of extracting data from HTML and XML files, it has several methods that make the search for specific data on web pages rather simple an fast.

For this tutorial, we will extract data from the website Transfermarkt which is a web plataform that contains news and data about games, transfers, clubs and players from the football/soccer world.

Transfermarkt Homepage

We will receive the name, country of the previous league and the price of the 25 most expensive players in the history of the AFC Ajax club, this information can be found on the Transfermarkt page.

Page which contains the informations about the 25 biggest AFC Ajax signs

Extracting Data

Before obtaining the data itself, we will import the libraries required for the execution of the program, these will be: Beautiful Soup, Pandas and Requests.



import requests
from bs4 import BeautifulSoup
import pandas as pd

After that, we will download the webpage in our program using the requests library, which requests the information from the page, and the BeautifulSoup library, which transforms the data received in requests (a Response object) into aBeautifulSoup object that will be used in data extraction.



"""
To make the request to the page we have to inform the
website that we are a browser and that is why we
use the headers variable
"""
headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36'}

# endereco_da_pagina stands for the data page address
endereco_da_pagina = "https://www.transfermarkt.co.uk/ajax-amsterdam/transferrekorde/verein/610/saison_id//pos//detailpos/0/w_s//altersklasse//plus/1"

# In the objeto_response variable we will the download of the web page
objeto_response = requests.get(endereco_da_pagina, headers=headers)

"""
Now we will create a BeautifulSoup object from our object_response.
The 'html.parser' parameter represents which parser we will use when creating our object,
a parser is a software responsible for converting an entry to a data structure.
"""
pagina_bs = BeautifulSoup(objeto_response.content, 'html.parser')

pagina_bs is now a variable that contains all the HTML content inside our data page.

Now let's extract the data that is in our variable, note that the information we need is in a table. Each row in this table represents a player, with his name, represented in HTML by an anchor (<a>) with the class "spielprofil_tooltip", country of origin league, represented as a flag image (<img>) with a class "flaggenrahmen" in the seventh column (<td>) of each row, and cost represented by a table cell (<td>) of the class "rechts hauptlink"

We will then get this data using the BeautifulSoup library.

First we will get the names of the players.



nomes_jogadores = [] # List that will receive all the players names

# The find_all () method is able to return all tags that meet restrictions within parentheses
tags_jogadores = pagina_bs.find_all("a", {"class": "spielprofil_tooltip"})
# In our case, we are finding all anchors with the class "spielprofil_tooltip"

# Now we will get only the names of all players
for tag_jogador in tags_jogadores:
    nomes_jogadores.append(tag_jogador.text)

Now we will get the countries of the players’s previous leagues.



pais_jogadores = [] # List that will receive all the names of the countries of the players’s previous leagues.

tags_ligas = pagina_bs.find_all("td",{"class": None})
# Now we will receive all the cells in the table that have no class atribute set

for tag_liga in tags_ligas:
    # The find() function will find the first image whose class is "flaggenrahmen" and has a title
    imagem_pais = tag_liga.find("img", {"class": "flaggenrahmen"}, {"title":True})
    # The country_image variable will be a structure with all the image information,
    # one of them is the title that contains the name of the country of the flag image
    if(imagem_pais != None): # We will test if we have found any matches than add them
        pais_jogadores.append(imagem_pais['title'])

Finally, we will get the players' prices.



custos_jogadores = []

tags_custos = pagina_bs.find_all("td", {"class": "rechts hauptlink"})

for tag_custo in tags_custos:
    texto_preco = tag_custo.text
    # The price text contains characters that we don’t need like £ (euros) and m (million) so we’ll remove them
    texto_preco = texto_preco.replace("£", "").replace("m","")
    # We will now convert the value to a numeric variable (float)
    preco_numerico = float(texto_preco)
    custos_jogadores.append(preco_numerico)

Now that we have got all the data we wanted, let's make it understandable to improve any analysis we want to do. For this, we will use the pandas library and its DataFrame class, which is a class that represents a tabular data structure, that is, it is similar to a common table.



# Creating a DataFrame with our data
df = pd.DataFrame({"Jogador":nomes_jogadores,"Preço (milhão de euro)":custos_jogadores,"País de Origem":pais_jogadores})

# Printing our gathered data
print(df)

Now we can see all our data obtained with web scraping organized in the DataFrame!

I hope I have helped in any way and if you have any problems or questions, feel free to leave a comment on this post or send an email to me ;).

Recebendo Informações do Transfermarkt: Uma Introdução ao Web Scraping

Lisandra Melo — Sat, 25 Jul 2020 20:41:14 +0000

Conseguir dados e transformá-los em informação é a base de áreas da computação como a Ciência de Dados. Às vezes essa obtenção é bem simples, por exemplo, você pode, agora mesmo, visitar o site do governo brasileiro dados.gov.br e conseguir acesso a diversos arquivos de dados brutos e depois realizar a análise de um arquivo .csv (um tipo de arquivo que transmite dados) de forma fácil, simples e rápida.

Contudo, em algumas situações essa obtenção é dificultada, por exemplo, você pode precisar receber dados que estão disponíveis somente em uma página da web para realizar uma análise. Nessa situação você pode usar a biblioteca Beautiful Soup do Python para realizar um web scraping, isto é, uma raspagem dos dados que você necessita na página.

A Biblioteca Beautiful Soup

Beautiful Soup é a biblioteca mais popular para receber dados web de python, ela é capaz de realizar a extração de dados de arquivos HTML e XML. Além de possuir vários métodos que facilitam a busca de dados específicos em páginas web.

Os Dados que Usaremos

Para o tutorial, iremos extrair dados do portal Transfermarkt que é um site que contém notícias e dados sobre jogos, tranferências, clubes e jogadores de futebol.

Página Inicial do Transfermarkt

Iremos receber o nome, a o país da liga de origem e o preço dos 25 jogadores mais caros da história do clube AFC Ajax, essas informações podem ser encontradas na página do Transfermarkt.

Página com as informações sobre as 25 maiores transferências do AFC Ajax

Obtendo os Dados

Antes de obter os dados em si, iremos importar as bibliotecas necessárias para a execução do programa, essas serão: Beautiful Soup, Pandas e Requests.



import requests
from bs4 import BeautifulSoup
import pandas as pd

Depois disso, iremos receber a página no nosso programa usando a biblioteca requests, que solicita as informações da página, e a biblioteca BeautifulSoup, que transforma os dados recebidos no requests (um objeto Response) em um objeto BeautifulSoup que será usado na extração dos dados.



"""
Para realizar a solicitação à página temos que informar ao site que somos um navegador
e é para isso que usamos a variável headers
"""
headers = {'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36'}

# endereco_da_pagina representa o link que direciona a página com os dados
endereco_da_pagina = "https://www.transfermarkt.co.uk/ajax-amsterdam/transferrekorde/verein/610/saison_id//pos//detailpos/0/w_s//altersklasse//plus/1"

# no objeto_response iremos realizar o download da página da web 
objeto_response = requests.get(endereco_da_pagina, headers=headers)

"""
Agora criaremos um objeto BeautifulSoup a partir do nosso objeto_response.
O parâmetro 'html.parser' representa qual parser usaremos na criação do nosso objeto,
um parser é um software responsável por realizar a conversão de uma entrada para uma estrutura de dados.
"""
pagina_bs = BeautifulSoup(objeto_response.content, 'html.parser')

pagina_bs agora é uma variável que contém todo o HTML existente na nossa página.

Agora vamos extrair os dados que estão na nossa variável, note que as informações que precisamos estão em uma tabela. Cada linha dessa tabela representa um jogador, com seu nome, representado no HTML por uma âncora (<a>) com a classe "spielprofil_tooltip", país de liga de origem, representado como uma bandeira de classe "flaggenrahmen" na sétima coluna (<td>) de cada linha, e custo representado por uma célula (<td>) de classe "rechts hauptlink".

Vamos então conseguir esses dados usando a biblioteca BeautifulSoup.

Primeiro iremos conseguir os nomes dos jogadores



nomes_jogadores = [] # Lista ordenada dos nomes de todos os jogadores

# O método find_all() consegue retornar todas as tags que cumprem as restrições dentro dos parênteses
tags_jogadores = pagina_bs.find_all("a", {"class": "spielprofil_tooltip"})
# No nosso caso estamos encontrando todas as âncoras com a classe "spielprofil_tooltip"

# Agora iremos conseguir somente os nomes de todos os jogadores
for tag_jogador in tags_jogadores:
    nomes_jogadores.append(tag_jogador.text)

Agora conseguiremos os países das ligas de origem dos jogadores.



pais_jogadores = [] # Lista ordenada dos nomes do país da liga de origem de todos os jogadores

tags_ligas = pagina_bs.find_all("td",{"class": None})
# Agora iremos receber todas as células da tabela que não possuem classe

for tag_liga in tags_ligas:
    # A função find irá encontrar a primeira imagem cuja classe é "flaggenrahmen" e possui um título
    imagem_pais = tag_liga.find("img", {"class": "flaggenrahmen"}, {"title":True})
    # A variável imagem_país será uma estrutura com todas as informações da imagem,
    # uma delas é o title que contem o nome do país da bandeira
    if(imagem_pais != None): # Testaremos se o método encontrou alguma correspondência
        pais_jogadores.append(imagem_pais['title'])

Por fim conseguiremos os custos dos jogadores.



custos_jogadores = []

tags_custos = pagina_bs.find_all("td", {"class": "rechts hauptlink"})

for tag_custo in tags_custos:
    texto_preco = tag_custo.text
    # O texto do preço contém caracteres que não precisamos como £ (euros) e m (milhão) então iremos retirá-los
    texto_preco = texto_preco.replace("£", "").replace("m","")
    # Converteremos agora o valor para uma variável numérica
    preco_numerico = float(texto_preco)
    custos_jogadores.append(preco_numerico)

Agora que conseguimos todos os dados que queríamos, vamos tornar eles entendíveis para melhorar qualquer análise que desejamos fazer. Para isso, usaremos a biblioteca pandas e sua classe DataFrame que é uma classe que representa uma estrutura de dados tabular, ou seja, é parecida com uma tabela comum.



# Criando um DataFrame a partir de nossos dados
df = pd.DataFrame({"Jogador":nomes_jogadores,"Preço (milhão de euro)":custos_jogadores,"País de Origem":pais_jogadores})

# Imprimindo os dados que obtemos
print(df)

Agora podemos ver todos os nossos dados obtidos com o web scraping organizados no DataFrame!

O programa desenvolvido nesse tutorial está disponível no meu repositório do gitlab. Espero ter ajudado e se você estiver com algum problema ou dúvida sinta-se convidado a comentar esse post ou enviar um e-mail para mim ;).