Tocar mp3 com a biblioteca pygame

A biblioteca pygame é muito versátil na sua utilização, mas uma implementação simples é utilizá-la para tocar arquivos no formato mp3.

A implementação é muito simples e com poucas linhas, você pode utilizá-la para curtir um som ou inserir um arquivo de audio no seu sistema ou game.

Vamos ao código!


Uma forma de implementar o código.

# importar a biblioteca pygame
from pygame import mixer

# uma forma de implementar o código
mixer.init()

# substitua o nome do arquivo "musica.mp3" pelo seu arquivo mp3
mixer.music.load('musica.mp3')
mixer.music.play()
x = input('Digite algo para parar...')

Outra forma de implementar o código.

# importar a biblioteca pygame
import pygame

# outra forma de implementar o código

pygame.mixer.init()
# substitua o nome do arquivo "musica.mp3" pelo seu arquivo mp3
pygame.mixer.music.load('musica.mp3')
pygame.mixer.music.play()
x = input('Digite algo para parar a musica...')

As duas formas funcionam, porém fica a critério de cada um como implementar.

obs: código postado no grupo de Telegram da comunidade Py013.

Até a próxima!

Buscar CEPs com Python e Selenium

Um dos trabalhos apresentados no Encontro da Comunidade no dia 27/05/23 por Altair Ribeiro

Muitas vezes precisamos obter endereços completos para a realização de testes de software, ou ainda para incluir dados em um formulário na Web.
O Selenium é uma biblioteca muito utilizada para testes de software e que pode ser utilizada a realização desse tipo de trabalho repetitivo.

Você precisa ter o geckodriver.exe (baixe aqui) ou o chromedriver.exe (baixe aqui) para que o código fonte em Python em conjunto com a biblioteca Selenium crie uma instância do Browser e controle todo o processo de execução.

Tanto o Geckodriver.exe quanto o Chromedriver.exe precisam estar na mesma pasta do código fonte.

Utilizamos um site muito utilizado por Analistas de Qualidade para a geração de massa de dados.

É um site muito conhecido nesse meio e também muito bem montado e que contribui muito para elevarmos o nível da disciplina de qualidade no Brazil.

É o site www.4devs.com.br!

Vamos ao código fonte.

# importar as bibliotecas necessárias
import os
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
import random
import re

# Definir a quantidade de endereços que serão gravados no arquivo "ceps.txt"
qtde= 5

# Inclusão de um Try para obter o código de erro em caso de falha do código fonte e o código que será executado
try:
    path_atual = os.getcwd()
    print('path:' , path_atual)

    # driver = webdriver.Chrome()
    driver = webdriver.Firefox()
    driver.maximize_window()

    # URL que será acessada
    url = 'https://www.4devs.com.br/gerador_de_cep'

    driver.get(url)
    time.sleep(2)

    cont = 0

    estado = driver.find_element(By.ID, 'cep_estado')
    estado.send_keys('SP')
    time.sleep(5)

    estado = driver.find_element(By.ID, 'cep_cidade')
    estado.send_keys('Santos')
    time.sleep(5)

    with open("ceps.txt",'a', newline="") as arquivo:
        while cont <qtde:

            submit = driver.find_element(By.ID,'btn_gerar_cep')
            #time.sleep(3)
            submit.click()
            time.sleep(5)
            cep = driver.find_element(By.ID, 'cep')
            cep.click()
            endereco = driver.find_element(By.ID, 'endereco')
            endereco.click()
            bairro = driver.find_element(By.ID, 'bairro')
            bairro.click()
            cidade = driver.find_element(By.ID, 'cidade')
            cidade.click()
            estado = driver.find_element(By.ID, 'estado')
            estado.click()
            time.sleep(5)
            arquivo.write(re.sub("\-","",cep.text) + ';' + endereco.text + ';' + str(random.randint(1,1000)) + ';' + 'ap. ' + str(random.randint(1,100)) + ';' + bairro.text + ';' + cidade.text + ';' +estado.text + '\n')
            cont += 1
            #print(cont , ". ", cep.text + ';' + endereco.text + ';' + str(random.randint(1,1000)) + ';' +  'ap. ' + str(random.randint(1,100)) + ';' + bairro.text + ';' + cidade.text + ';' +estado.text)
            print(cont , ". ", re.sub("\-","",cep.text) + ';' + endereco.text + ';' + str(random.randint(1,1000)) + ';' +  'ap. ' + str(random.randint(1,100)) + ';' + bairro.text + ';' + cidade.text + ';' +estado.text)

    arquivo.close()
    driver.close()

# Tratamentos dos erros para uma melhor identificação em caso de falha
except OSError as err:
    #<aqui vai o erro de Sistema Operacional>
    print("Erro de S.O. : {0}".format(err))
except ValueError:
    # <aqui vai o erro do programa>
    print("Não pode converter data para inteiro.")
except BaseException as err:
    #<aqui vão exceções que aconteçam no programa>
    print(f"Inesperado {err=}, {type(err)=}")
    raise

Se tiver dúvidas no uso do código, entre na comunidade no Telegram (https://t.me/+aLIZYCmBJfH-qPGs).

Até a próxima!

Baixar a playlist inteira do Youtube

Algumas vezes queremos estudar offline e para isso precisamos baixar os videos localmente no computador.

Existem ferramentas que fazem isso, mas geralmente são pagas.

Com poucas linhas de código fonte, você pode fazer isso com Python.

Porém, respeitem os direitos autorais dos autores dos vídeos, músicas ou qualquer forma de conteúdo produzido.

Vamos lá!

# carregar os métodos Youtube e Playlist da biblioteca pytube
from pytube import YouTube, Playlist

# atribui à variável playlist_fim a URL da playlist obtida no Youtube
playlist_fim = 'https://www.youtube.com/watch?v=IftUFXo2e-k&list=PLnNURxKyyLIKvXocwRwLCQqPU0mcTSLxJ'

# atribuir à variável playlist a lista de vídeos da playlist com o método Playlist
playlist = Playlist(playlist_fim)

# para cada item da lista de vídeos da playlist, baixar cada
# vídeo sequencialmente (laço for utilizado)
for url in playlist:
    # atribuir à variável video o método Youtube com o parãmetro url que irá
    # ler o vídeo sequencialmente, iniciando do primeiro da playlist
    video = YouTube(url)
    # atribuir à variável stream a utilização do vídeo de mais alta resolução
    stream = video.streams.get_highest_resolution()
    # efetuar o download do vídeo e gravar na pasta "playlist"
    stream.download(output_path='playlist')

A variável PLAYLIST_URL terá a atribuição da URL que foi obtida do Youtube.

O código fonte está comentado para facilitar o entendimento.

Até mais!

Baixar video do Youtube com 2 linhas de código

Muitas vezes queremos baixar um vídeo no Youtube para ver posteriormente, mas os sites que existem para isso contém malwares que podem ser instalados no seu computador.

Por isso, algumas vezes é melhor você mesmo fazer o download com poucas linhas de código em Python.

Somente fique atento aos direitos autorais de músicas, filmes e artistas em geral, porque existem leis que protegem os direitos autorais do autor da obra e utilizar a obra sem autorização é crime.

Esse snippet é somente ilustrativo para você exercitar a sua programação e conhecer mais uma biblioteca neste vasto mundo do Python.

A biblioteca que utilizaremos é a pytube.

A Pytube é um biblioteca que se define como “leve e livre de dependências para baixar vídeos do Youtube”.

Simples assim!

Vamos ao snippet!

from pytube import YouTube

YouTube("https://www.youtube.com/watch? \
v=a72yIwfvZXg").streams.get_highest_resolution().download()

O caracter “\” no final da segunda linha é somente para a quebra de linha explícita e facilitar o copy e paste do código. Na verdade, é uma única string com os parâmetros e métodos.

Se o vídeo no Youtube tiver restrição de idade (“age_restricted”) ele dará um erro, nesse caso, é bom dar uma verificada na documentação da biblioteca para contornar essa restrição. Podemos tratar essa situação em outro post.

O vídeo será baixado na mesma pasta que o código Python está sendo executado.

Não esqueça de instalar antes a biblioteca com o comando abaixo na linha de comando (cmd):

c:> pip install pytube

Nesse exemplo, utilizamos o vídeo do canal Dev Aprender do Jhonatan de Souza, que possui vídeos excelentes sobre Python e sua utilização.

Conheça mais sobre a biblioteca pytube e explore novas opções de download!

Até mais!

Baixar audio de um video no Youtube

Muitas vezes queremos baixar somente o som de um vídeo no Youtube, mas os sites que existem para isso contém muitas armadilhas que podem instalar malwares no seu computador, enquanto realizam o download para você.

Por isso, algumas vezes é melhor você mesmo fazer o download com poucas linhas de código em Python.

Somente fique atento aos direitos autorais de músicas, filmes e artistas em geral, porque existem leis que protegem os direitos autorais do autor da obra e utilizar a obra sem autorização é crime.

Esse snippet é somente ilustrativo para você exercitar a sua programação e conhecer mais uma biblioteca neste vasto mundo do Python.

A biblioteca que utilizaremos é a pytube.

A Pytube é um biblioteca que se define como “leve e livre de dependências para baixar vídeos do Youtube”.

Simples assim!

Vamos ao snippet!

from pytube import YouTube

VIDEO_URL = 'https://www.youtube.com/watch?v=FBLAV1SbJFk&t=2s'
yt = YouTube(VIDEO_URL)

audio = yt.streams.filter(only_audio=True)[0]
audio.download()

Na variável VIDEO_URL você incluirá a URL do vídeo do Youtube que será realizado o download.

Não esqueça de instalar antes a biblioteca com o comando abaixo na linha de comando (cmd):

c:> pip install pytube

Nesse exemplo, utilizamos o vídeo do canal Dev Aprender do Jhonatan de Souza, que possui vídeos excelentes sobre Python e sua utilização.

Conheça mais sobre a biblioteca pytube e explore novas opções de download!

Até mais!

Baixada NERD – 22/10/2022 – Manipulando Dados com Python

No dia 22/10/22, a comunidade participou do evento do Baixada Nerd na ETEC Itanhaém palestrando sobre manipulação de dados com Python.

Altair Ribeiro falou sobre a ingestão de dados, manipulação e visualização de grandes volumes de dados e a versatilidade ao utilizar python para big data.


Arquivos para Download

  • Arquivo do notebook para o Jupyter Notebook.

Arquivo do Notebook – Baixe aqui: ETEC 22/10/22 - Manipulação de Dados - Notebook (629 downloads )

Arquivo de Dados – Baixe Aqui: ETEC - 22/10/22 - ifood.csv - Arquivo de dados compactado (554 downloads )


Imagens do Evento da Baixada Nerd

Notebook

etec_22_10_22

Py013 – Comunidade de Python da Baixada Santista

Manipulando Dados

1. Importando as bibiliotecas

In [456]:
# Importa das bibliotecas necessárias para manipular os dataframes (dados)
import numpy as np
import pandas as pd
import seaborn as sea
from pandas import Grouper
import matplotlib.pyplot as plt
%matplotlib inline

2. Carregando os arquivos de dados utilizando o Pandas

In [457]:
# lê o arquivo de dados "network.csv" em um diretório padrão. Nomeie o arquivo de log para "network.csv"
# municipio = pd.read_csv('Base_MUNIC_2020.csv')
ifood = pd.read_csv('ifood.csv', sep=";")

3. Examinando os tipos de dados

In [458]:
# Tipos dos dados
ifood.dtypes
Out[458]:
categoria              object
tempo_entrega           int64
CodMun                  int64
preco_minimo_pedido     int64
nome_restaurante       object
faixa_preco            object
url                    object
dtype: object

4. Alterando o tipo de CodMun de “int64” para “object”, porque não será necessário realizar cálculo com ele

In [459]:
ifood = ifood.astype({'CodMun':object})

5. Examinando novamente os dados

In [460]:
# Tipos dos dados
ifood.dtypes
Out[460]:
categoria              object
tempo_entrega           int64
CodMun                 object
preco_minimo_pedido     int64
nome_restaurante       object
faixa_preco            object
url                    object
dtype: object

6. Quantidade de registros (linha) e variáveis (colunas)

In [461]:
# Formato dos dados
ifood.shape
Out[461]:
(406399, 7)

7. Uma amostragem dos dados do início e do fim do arquivo

In [464]:
#ifood.head(30)
ifood.tail()
Out[464]:
categoria tempo_entrega CodMun preco_minimo_pedido nome_restaurante faixa_preco url
406394 Açaí 60 4309209 300 Açaí da Duda Muito barato https://www.ifood.com.br/delivery/gravatai-rs/…
406395 Açaí 50 4309209 100 Pede aí açaí Muito barato https://www.ifood.com.br/delivery/cachoeirinha…
406396 Açaí 40 4309209 0 Açaí do Jeitinho Brasileiro Muito barato https://www.ifood.com.br/delivery/gravatai-rs/…
406397 Lanches 60 4309209 200 Classic Burger Muito barato https://www.ifood.com.br/delivery/gravatai-rs/…
406398 Doces & Bolos 20 4309209 0 Cacau Show – Cachoerinha Shopping Moderado https://www.ifood.com.br/delivery/cachoeirinha…

8. Alterando a forma de visualização

In [465]:
# Inversão da forma de visualização dos dados
ifood.T
Out[465]:
0 1 2 3 4 5 6 7 8 9 406389 406390 406391 406392 406393 406394 406395 406396 406397 406398
categoria Marmita Açaí Bebidas Carnes Brasileira Lanches Brasileira Congelados Lanches Lanches Doces & Bolos Lanches Lanches Lanches Lanches Açaí Açaí Açaí Lanches Doces & Bolos
tempo_entrega 27 61 70 63 58 67 46 40 41 47 40 50 50 60 60 60 50 40 60 20
CodMun 5300108 5300108 5300108 5300108 5300108 5300108 5300108 5300108 5300108 5300108 4309209 4309209 4309209 4309209 4309209 4309209 4309209 4309209 4309209 4309209
preco_minimo_pedido 100 100 50 200 200 200 200 100 200 200 140 130 200 150 150 300 100 0 200 0
nome_restaurante Cantina Arte & Sabor Raruty Açaí Raiz Toma na Kombi Churrasquinho do Barriga´s Prime Restaurante Clara Quitutes & Cia Loca Como Tú Madre Frutos de Goiás 710 Sul Lemos Cozinha Club House Burguer Churros no Copo Jcs Lancheria Hamburgueria Duarte ki-sabor Pizza Cone del Miko Açaí da Duda Pede aí açaí Açaí do Jeitinho Brasileiro Classic Burger Cacau Show – Cachoerinha Shopping
faixa_preco Muito barato Muito barato Moderado Muito barato Muito barato Barato Muito caro Muito barato Moderado Moderado Muito barato Muito barato Moderado Barato Muito barato Muito barato Muito barato Muito barato Muito barato Moderado
url https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/brasilia-df/… https://www.ifood.com.br/delivery/viamao-rs/ch… https://www.ifood.com.br/delivery/viamao-rs/jc… https://www.ifood.com.br/delivery/alvorada-rs/… https://www.ifood.com.br/delivery/viamao-rs/ki… https://www.ifood.com.br/delivery/alvorada-rs/… https://www.ifood.com.br/delivery/gravatai-rs/… https://www.ifood.com.br/delivery/cachoeirinha… https://www.ifood.com.br/delivery/gravatai-rs/… https://www.ifood.com.br/delivery/gravatai-rs/… https://www.ifood.com.br/delivery/cachoeirinha…

7 rows × 406399 columns

9. Agrupando os dados

In [466]:
ifood.groupby(['CodMun', 'categoria', 'nome_restaurante', 'faixa_preco']).sum()
Out[466]:
tempo_entrega preco_minimo_pedido
CodMun categoria nome_restaurante faixa_preco
1100023 Açaí Açai Sport Barato 60 0
Açaí Mania Barato 60 100
Açaí Mix Cremoso Muito barato 20 100
Imperio Acai e Petiscaria Muito barato 45 0
Mega Sorvetes e Açaí Muito barato 50 120
5300108 Árabe Souk Restaurante Arabe Caro 67 200
Tarbush – Comidas Árabes Muito caro 38 100
Teggiano Muito barato 50 300
Valença Narg Pub Muito barato 80 200
Árabe Gourmet Muito caro 44 200

403085 rows × 2 columns

10. Copiando o dataframe original

In [467]:
cp_ifood = ifood.copy()

11. Vendo uma amostra do dataframe copiado

In [468]:
cp_ifood.head()
Out[468]:
categoria tempo_entrega CodMun preco_minimo_pedido nome_restaurante faixa_preco url
0 Marmita 27 5300108 100 Cantina Arte & Sabor Muito barato https://www.ifood.com.br/delivery/brasilia-df/…
1 Açaí 61 5300108 100 Raruty Açaí Raiz Muito barato https://www.ifood.com.br/delivery/brasilia-df/…
2 Bebidas 70 5300108 50 Toma na Kombi Moderado https://www.ifood.com.br/delivery/brasilia-df/…
3 Carnes 63 5300108 200 Churrasquinho do Barriga´s Muito barato https://www.ifood.com.br/delivery/brasilia-df/…
4 Brasileira 58 5300108 200 Prime Restaurante Muito barato https://www.ifood.com.br/delivery/brasilia-df/…

12. Eliminando algumas colunas e atribuindo a outro dataframe

In [469]:
# df_cp = cp_ifood.drop(['CodMun', 'preco_minimo_pedido', 'nome_restaurante', 'faixa_preco','url'], axis=1)
In [470]:
df_cp = cp_ifood.drop(['tempo_entrega','preco_minimo_pedido', 'nome_restaurante', 'faixa_preco','url'], axis=1)

13. Verificando novamente a amostra do novo dataframe sem as colunas excluídas

In [471]:
df_cp.head()
Out[471]:
categoria CodMun
0 Marmita 5300108
1 Açaí 5300108
2 Bebidas 5300108
3 Carnes 5300108
4 Brasileira 5300108

14. Agrupando as categorias de restaurantes (limitado a n tipos)

In [473]:
df_grupos = df_cp.groupby(['categoria'],sort=True).count().head(20)
# df_grupos = df_cp.groupby(['categoria'],sort=False).count().head(20)

15. Verificando os agrupamentos

In [474]:
df_grupos
Out[474]:
CodMun
categoria
Africana 92
Alemã 191
Argentina 358
Asiática 155
Açaí 22110
Baiana 154
Bebidas 13375
Brasileira 73348
Cafeteria 3136
Carnes 8394
Casa de Sucos 357
Chinesa 1912
Colombiana 48
Congelados 2101
Congelados Fit 197
Contemporânea 578
Conveniência 3162
Coreana 64
Cozinha Rápida 2527
Crepe 225

16. Plotando os dados dos grupos

In [475]:
df_grupos.plot(kind='barh', figsize=(8,8))
Out[475]:
<matplotlib.axes._subplots.AxesSubplot at 0x2282e611c88>

17. Contando as categorias de restaurantes

In [476]:
cp_ifood['categoria'].value_counts()
Out[476]:
Lanches            98946
Brasileira         73348
Doces & Bolos      39828
Pizza              36819
Açaí               22110
                   ...  
Colombiana            48
Típica do Norte       31
Grega                  6
Paranaense             4
Marroquina             1
Name: categoria, Length: 61, dtype: int64

Exemplo de gráfico utilizando a biblioteca Seaborn

1. Mapa Termal

In [477]:
### 1. Gráfico de Barras
import matplotlib.pyplot as plt
import seaborn as sns
# sns.set_theme()
# Load the example flights dataset and convert to long-form
flights_long = sns.load_dataset("flights")
flights = flights_long.pivot("month", "year", "passengers")
# Draw a heatmap with the numeric values in each cell
f, ax = plt.subplots(figsize=(9, 6))
sns.heatmap(flights, annot=True, fmt="d", linewidths=.5, ax=ax)
Out[477]:
<matplotlib.axes._subplots.AxesSubplot at 0x2280fd1e978>

2. Gráfico de Dispersão

In [478]:
import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="whitegrid")
# Load the example diamonds dataset
diamonds = sns.load_dataset("diamonds")
# Draw a scatter plot while assigning point colors and sizes to different
# variables in the dataset
f, ax = plt.subplots(figsize=(6.5, 6.5))
sns.despine(f, left=True, bottom=True)
clarity_ranking = ["I1", "SI2", "SI1", "VS2", "VS1", "VVS2", "VVS1", "IF"]
sns.scatterplot(x="carat", y="price",
                hue="clarity", size="depth",
                palette="ch:r=-.2,d=.3_r", 
                hue_order=clarity_ranking,
                sizes=(1, 8), linewidth=0,
                data=diamonds, ax=ax)
Out[478]:
<matplotlib.axes._subplots.AxesSubplot at 0x2280f7107b8>

3. Gráfico de barras Verticais

In [479]:
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="white", context="talk")
rs = np.random.RandomState(8)
# Set up the matplotlib figure
f, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(7, 5), sharex=True)
# Generate some sequential data
x = np.array(list("ABCDEFGHIJ"))
y1 = np.arange(1, 11)
sns.barplot(x=x, y=y1, palette="rocket", ax=ax1)
ax1.axhline(0, color="k", clip_on=False)
ax1.set_ylabel("Sequencial")
# Center the data to make it diverging
y2 = y1 - 5.5
sns.barplot(x=x, y=y2, palette="vlag", ax=ax2)
ax2.axhline(0, color="k", clip_on=False)
ax2.set_ylabel("Divergente")
# Randomly reorder the data to make it qualitative
y3 = rs.choice(y1, len(y1), replace=False)
sns.barplot(x=x, y=y3, palette="deep", ax=ax3)
ax3.axhline(0, color="k", clip_on=False)
ax3.set_ylabel("Qualitativo")
# Finalize the plot
sns.despine(bottom=True)
plt.setp(f.axes, yticks=[])
plt.tight_layout(h_pad=2)

3. Gráfico de Barras Horizontais

In [480]:
import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="whitegrid")
# Initialize the matplotlib figure
f, ax = plt.subplots(figsize=(6, 15))
# Load the example car crash dataset
crashes = sns.load_dataset("car_crashes").sort_values("total", ascending=False)
# Plot the total crashes
sns.set_color_codes("pastel")
sns.barplot(x="total", y="abbrev", data=crashes,
            label="Total", color="b")
# Plot the crashes where alcohol was involved
sns.set_color_codes("muted")
sns.barplot(x="alcohol", y="abbrev", data=crashes,
            label="Alcoolizados", color="b")
# Add a legend and informative axis label
ax.legend(ncol=2, loc="lower right", frameon=True)
ax.set(xlim=(0, 24), ylabel="Estados Americanos",
       xlabel="Colisões de automóveis por bilhão de milhas")
sns.despine(left=True, bottom=True)

Evento 24/09/22 – Pillow e Mineração de Dados

No dia 24/09/22, a comunidade realizou mais um encontro para falarmos sobre a bilbioteca Pillow para manipulação e tratamento de imagens, apresentado por Altair Ribeiro.

Também, foi apresentado a Mineração de Dados na teoria e na prática e, um Caso de Uso demonstrando a ingestão, tratamento e processamento de dados, por José Fontebasso Neto.

O evento aconteceu na Unisantos, no campus Dom Idilio.


Arquivos para Download

  • Arquivo do notebook para o Jupyter Notebook.

Baixe aqui: Arquivo com o notebook (Jupyter Notebook) - Uso da biblioteca PILLOW (553 downloads )

  • Arquivo da Imagem utilizada no notebook.

Baixe aqui: Imagem exemplo utilizado no notebook (Crédito: Foto de David Clode no Unsplash) (554 downloads )


Imagens do Evento

Notebook

Pillow_light

Biblioteca Pillow

Chamada de PIL (Python Imaging Library) é uma bilbioteca para o processamento de imagens na linguagem Python. Ela suporta vários formatos de imagens e entre eles estão: BMP, GIF, ICO, JPEG, PNG e TIFF.

Documentação da Pillow

https://pillow.readthedocs.io

Importar a Biblioteca PIL

In [1]:
# Importar a biblioteca
from PIL import Image
import ipywidgets as widgets
import IPython.display as display
import matplotlib.pyplot as plt
%matplotlib inline

Carregar uma imagem

Crédito: Foto de David Clode no Unsplash

In [2]:
# Carregar a imagem
img = Image.open("peixe.jpg")

Mostrar a imagem no tamanho natural

In [3]:
# Mostrar a imagem local
img
Out[3]:

Mostrar a imagem no aplicativo padrão

In [4]:
# Mostrar a imagem no aplicativo padrão
img.show()

Identificar o tipo de imagem

In [5]:
# Tipo da Imagem
print(img.mode)
RGB

Identificar o formato da imagem

In [6]:
# Formato da Imagem
print("Formato = ", img.format)
Formato =  JPEG

Identificar o tamanho da imagem em pixels

In [7]:
# Tamanho da Imagem
print(img.size)
(810, 540)

O Tamanho melhor apresentado

In [8]:
# De novo o tamanho da Imagem com um texto melhor
print("Tamanho = ", img.size)
Tamanho =  (810, 540)

Melhorando a apresentação do tamanho

In [9]:
# De novo o tamanho da Imagem com um texto muito melhor
print("Lagura = ", img.size[0])
print("Altura = ", img.size[1])
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")
Lagura =  810
Altura =  540
Imagem possui =  810  x  540  pixels

Rotacionando a imagem

In [10]:
# Rotacionando uma imagem
grau = int(input("Quantos graus para rotacionar a imagem ?"))
rota_img = img.rotate(grau)
rota_img
Quantos graus para rotacionar a imagem ?45
Out[10]:

Redimensionar a imagem

In [11]:
# Redimensionar a imagem
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")
largura = int(input("Qual a nova largura da imagem ?"))
altura =  int(input("Qual a nova altura da imagem ?"))
tamanho_novo = (largura, altura)
resize_img = img.resize(tamanho_novo)

if largura == 1000:
    if altura == 100:
        print()
        print("Virou uma manjuba !!!!!!!!")
        print("Imagem possui = ", largura, " x ", altura, " pixels")
resize_img
Imagem possui =  810  x  540  pixels
Qual a nova largura da imagem ?1000
Qual a nova altura da imagem ?100

Virou uma manjuba !!!!!!!!
Imagem possui =  1000  x  100  pixels
Out[11]:

Alterando o tamanho da imagem

In [12]:
# Gravando a manjuba
tamanho = (1000, 100)
img = Image.open("peixe.jpg")
manjuba = img.resize(tamanho, resample = Image.BILINEAR)

manjuba.save("manjuba.jpg")

Abrindo a foto da manjuba

In [13]:
# Abrir a foto da manjuba
img1 = Image.open("manjuba.jpg")
print("Novo tamanho agora como manjuba = ", img1.size[0], " x ", img1.size[1], " pixels")
img1
Novo tamanho agora como manjuba =  1000  x  100  pixels
Out[13]:

Transformando o arquivo

In [14]:
### Carregar de novo a imagem
img = Image.open("peixe.jpg")
tamanho_novo = (480, 320)
img = img.resize(tamanho_novo)
img
Out[14]:

Retirar a luminosidade da imagem

In [15]:
# Retirar a iluminação da imagem

#tamanho_novo = (480, 320)
#img = img.resize(tamanho_novo)
with img as imgnova:
    img1 = img.convert("L") #Luminancia
img1
Out[15]:
In [16]:
# Crie um filtro de classificação.
# O filtro de classificação classifica todos os pixels em uma janela de determinado tamanho e retorna o valor de classificação.
from PIL import ImageFilter

# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Aplicar o filtro de Classificação
out = img.filter(ImageFilter.RankFilter(size=15, rank=3))

# Gravar um arquivo de saída
out.save("out.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [17]:
# Crie um filtro mínimo. Escolhe o valor de pixel mais baixo em uma janela com o tamanho fornecido.
from PIL import ImageFilter
out1 = img.filter(ImageFilter.MinFilter(size=5))

# Gravar um arquivo de saída
out1.save("out1.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out1.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [18]:
# Crie um filtro de modo. Escolhe o valor de pixel mais frequente em uma imagem delimitada com o tamanho fornecido.
# Os valores de pixel que ocorrem apenas uma ou duas vezes são ignorados;
# se nenhum valor de pixel ocorrer mais de duas vezes, o valor de pixel original será preservado.
out2 = img.filter(ImageFilter.ModeFilter(size=15))

# Gravar um arquivo de saída
out2.save("out2.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out2.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [19]:
# Filtro para borrar imagem borrada
from PIL import ImageFilter

out3 = img.filter(ImageFilter.BLUR)

# Gravar um arquivo de saída
out3.save("out3.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out3.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [20]:
# Filtro para contorno
from PIL import ImageFilter

out4 = img.filter(ImageFilter.CONTOUR)

# Gravar um arquivo de saída
out4.save("out4.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out4.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [21]:
# Filtro para EDGE Enhance
from PIL import ImageFilter

out5 = img.filter(ImageFilter.EDGE_ENHANCE)


# Gravar um arquivo de saída
out5.save("out5.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out5.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [22]:
# Filtro para EDGE Enhance More
from PIL import ImageFilter

out6 = img.filter(ImageFilter.EDGE_ENHANCE_MORE)

# Gravar um arquivo de saída
out6.save("out6.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out6.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [23]:
# Filtro para Emboss
from PIL import ImageFilter

out7 = img.filter(ImageFilter.EMBOSS)

# Gravar um arquivo de saída
out7.save("out7.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out7.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [24]:
# Filtro para Find Edges
from PIL import ImageFilter

out8 = img.filter(ImageFilter.FIND_EDGES)

# Gravar um arquivo de saída
out8.save("out8.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out8.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [25]:
# Filtro para SHARPEN. Utilizado para Nitidez.
from PIL import ImageFilter

out9 = img.filter(ImageFilter.SHARPEN)

# Gravar um arquivo de saída
out9.save("out9.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out9.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [26]:
# Filtro para SMOOTH. Para suavizar a imagem.
from PIL import ImageFilter

out10 = img.filter(ImageFilter.SMOOTH)

# Gravar um arquivo de saída
out10.save("out10.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out10.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [29]:
# Filtro para BoxBlur. Utilizado para desfoque de imagens.
from PIL import ImageFilter

out11 = img.filter(ImageFilter.BoxBlur(10))

# Gravar um arquivo de saída
out11.save("out11.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out11.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [30]:
# Filtro para GaussianBlur. É um filtro para desfoque utilizando uma função gaussiana.
from PIL import ImageFilter

out12 = img.filter(ImageFilter.GaussianBlur(radius=5))

# Gravar um arquivo de saída
out12.save("out12.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out12.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)
In [31]:
# Filtro para Unsharp Masking
# Aplica um desfoque gaussiano a uma cópia da imagem original e a compara com o original.
# Se a diferença for maior do que uma configuração de limite especificada pelo usuário, as imagens serão (de fato) subtraídas.
# O Unsharp Masking de nitidez é uma maneira flexível e poderosa de aumentar a nitidez da imagem.
import matplotlib.pyplot as plt 
out13 = img.filter(ImageFilter.UnsharpMask(radius=20, percent=500, threshold=3))

# Gravar um arquivo de saída
out13.save("out13.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out13.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

Mostrando a imagem com os eixos de tamanho em pixels

In [32]:
# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Plotar a imagem com os eixos
plt.imshow(img)
Out[32]:
<matplotlib.image.AxesImage at 0x1c596f3c588>

Cortando uma parte da imagem

In [33]:
# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Cortar a cabeça do peixe
cropimg = img.crop((500, 100, 700, 400)) 
cropimg
Out[33]:

Colocando título, tirando o eixo e mostrando a imagem

In [34]:
# Manipulando a plotagem da imagem
plt.figure(figsize=(7, 7))
plt.title("Eu quero ser a Dory!!!!")
plt.imshow(img)
plt.axis('off')
plt.show()

Espelhar uma imagem com a biblioteca Pillow (PIL)

A biblioteca Pillow, conhecida como PIL (Python Imaging Library) acrescenta capacidade de processamento de imagens ao Python.

A PIL fornece suporte a alguns formatos de arquivos baseados em pixels e com um rápido poder de processamento.

Vamos a um exemplo.

Objetivo: Espelhar a imagem na horizontal

Imagem Original
Imagem Espelhada

Photo de Jonathan Borba no Unsplash

Veremos o código fonte.

# Carrega o módulo Image da biblioteca PIL (para tratamento de imagens)

from PIL import Image

# Atribui a imagem original à variável img.
# Coloque a imagem na mesma pasta que esse programa estará rodando)
# Photo by Jonathan Borba on Unsplash

img = Image.open('teste.jpg')

# Inverte a imagem no sentido horizontal

espelha_imagem = img.transpose(Image.FLIP_LEFT_RIGHT)

# Grava a imagem espelhada na mesma pasta e com outro nome
# para não sobrepor a original

espelha_imagem.save(r'teste_espelhado.jpg')

# Sua imagem espelhada estará na mesma pasta da imagem original,
# porém com  outro nome