do print() ao Web Crawler

Robson Cruz

5º ano de Ciência da Computação;
Desenvolvedor backend freelance;
Aspirador de café;
Não sente frio;
Demora pra entender piadas;
Por dentro deve ser um velho de 80 anos.

Por que aprender Python?

Poderosa;
Capaz de se comunicar com múltiplas tecnologias;
Rápida;
Amigável e fácil de aprender;
Open-Source;

Roadmap

Basics;
Funções, Classes e POO;
Módulos e Bibliotecas;
Construção de aplicação.

Basics

Python?

É uma linguagem interpretada, dinamicamente tipada, de alto nível orientada a objeto.

Criada em 1991, Python se se encontra na versão 3.7

Leia mais sobre a história do Python aqui

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Plano é melhor que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o bastante para se quebrar as regras.
Embora a simplicidade supere o purismo.
Erros nunca deveriam passar silenciosamente.
A menos que explicitamente silenciados.
Ao encarar a ambiguidade, recuse a tentação de adivinhar.
Deveria haver uma – e preferencialmente apenas uma – maneira óbvia de se fazer isto.
Embora aquela maneira possa não ser óbvia à primeira vista se você não for holandês.
Agora é melhor que nunca.
Embora nunca, seja muitas vezes melhor que pra já.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces são uma idéia estupenda – vamos fazer mais deles!

PEP 20 - Zen of Python

Strings

Um conjunto de caracteres organizados.

Strings são apenas 1 dos tipos de dados do Python:

Strings;
Inteiros (Integer);
Reais (Floats);
etc.

# 'Python' é uma string

# Exibir uma string em tela
print('python')

# variável contendo uma string
a = 'python'

Strings

Coisas que podemos fazer com strings

Concatenar ;
Capitalização;
Slicing;
Formatação;

# concatenação
a = 'Isso é '
b = 'uma string'
c = a + b

# Upper/lower
print(a.lower())  # 'isso é '
print(b.upper())  # 'Uma string'

# Slicing
print(c[0:4])

# Formatação
print('isso é %s' % 'formatação')
print('também pode ser {}'.format('assim'))
print('ou assim {texto}'.format(texto='utilizando variaveis'))

a = 'f-string'
print(f'ou utilizando {a}')

Operadores

Operador	Operação	Exemplo
**	Exponenciação	2 ** 3
%	Módulo	22 % 8
//	Divisão inteira	22 // 8
/	Divisão	22 / 8
*	Multiplicação	3 * 3
-	Subtração	5 - 2
+	Soma	2 + 2

>>> (5 - 1) * ((7 + 1) / (3 - 1)) - 2 ** 3
8.0

Listas

Um conjunto de elementos organizados.

Listas suportam dados de múltiplos tipos!!

# Listas possuem mais de um elemento
lista_de_compras = ['café', 'mais café', 'chá']

# Exibindo pelo índice
print(lista_de_compras[0])

# As operações que podiam ser feitas em strings também pode ser feitas em listas!!!

Listas

São mutáveis, podem ser ordenadas, e criadas com "[]" ou list().

Tuplas

São imutáveis, não podem ser ordenadas. Criadas utilizando "()" ou tuple().

A grande maioria das operações que vimos em uma lista se aplicam para tuplas.

Dicionários

Dados organizados por chave:valor.

Dicionários, junto com listas são estruturas extremamente poderosas

lista_de_compras = {
    'arroz': 1,
    'feijao': 2,
    'tomate': 5,
    'cebola': 2
}

# valores de dicionários são acessados por sua chave
print(lista_de_compras['arroz'])

# podemos checar a existência de uma chave
'alface' in lista_de_compras

Condicionais

Isso e verdade?

if 2 > 1:
    print('Matemática ainda funciona')

# IFs também podem ser encadeados

# e também podemos checar o vazio
if lista == []:
    print('essa lista está vazia')

# Caso especial
if __name__ == "__main__":
    # do magic!

Operador	Significado
==	Igual
!=	Diferente
<	Menor que
>	Maior que
<=	Menor ou igual
>=	Maior ou igual

Operadores Lógicos

Loops

Processos repetitivos de operações.

Laços são úteis para:

Aritmética;
Renderização;
Processamento sequencial.

equanto dias_para_entrega > 1:
    fazer_trabalho = False

Loops

For Loop executa por "n" vezes

# utilizando um iterável
for number in range(5):
    print(number)

# utilizando listas
for number in [1, 2, 3, 4, 5]:
    print(number ** 2)


# e dicionários
a_dict = {"one":1, "two":2, "three":3}
for key in a_dict:
       print(key)

Loops

While Loop executa até uma condição ser atendida

# utilizando umaa variável de controle
i = 0
while i < 5:
    print(i)
    i += 1

# flow control
i = 0
while i < 10:
    if i == 3:
        i += 1
        continue
    print(i)
    if i == 5:
        break
    i += 1

Comprehensions

A criação de listas de maneira simplificada.

# gerando uma lista de 1 a 5
x = [i for i in range(5)]

# Conversão de listas
x = ['1', '2', '3', '4', '5']
y = [int(i) for i in x]

# Matriz para vetor
vec = [[1,2,3], [4,5,6], [7,8,9]]
vec = [num for elem in vec for num in elem]


# De maneira similar, podemos criar Dicionários utilizando esse mecanismo

Exceptions

O que fazer quando temos erros?

# 1/0 ?
try:
    print(1/0)
except ZeroDivisionError:
    print("You cannot divide by zero!")


# finally?
my_dict = {"a":1, "b":2, "c":3}

try:
    value = my_dict["d"]
except KeyError:
    print("A KeyError occurred!")
finally:
    print("Finally it's over!")

# Assim como o for, podemos usar o else

Lista útil

Trabalhando com arquivos

import os

handle = open("test.txt", "r")  # abrimos o arquivo para leitura
for line in handle:
    print(line)  # exibimos cada linha
handle.close()  # fechamos o arquivo

# usando with
with open("test.txt") as file_handler:
    for line in file_handler:
        print(line)

# Erros de arquivo
try:
    file_handler = open("test.txt")
    for line in file_handler:
        print(line)
except IOError:
    print("An IOError has occurred!")
finally:
    file_handler.close()

Parabéns, você já sabe o básico

Funções e Classes

Funções

Funções são blocos definidos por nós

construimos funções porque queremos uma maior flexibilidade do nosso código.

Keyword args;
*args e*kwargs;
Escopo;
lambda functions;
DRY.

# declaramos uma função utilizando o def
def add(a, b):
    """Função de soma
    
    Arguments:
        a {int} -- primeiro argumento
        b {int} -- segundo argumento
    
    Returns:
        int -- soma dos dois números
    """
    return a + b

REPL

Classes e O.O.

Tudo em Python é um objeto

# criar uma classe é muito fácil

class Veiculo:
    """docstring"""

    def __init__(self):
        """Construtor"""
        pass


    def __init__(self, cor, tipo, portas, marca, preco):
        """Construtor com atributos"""
        self.cor = cor
        self.tipo = tipo
        self.portas = portas
        self.marca = marca
        self.preco = preco

    def frear(self):
        """método de uma classe"""
        return f'{self.nome} está freando'

    def dirigir(self):
        """método para dirigir"""
        return f'Estou dirigindo um {self.nome} {self.cor}'


if __name__ == "__main__":
    # instanciando
    carro = Veiculo('blue', 'carro', 4, 'Honda', 15000)
    
    # chamando métodos
    print(carro.frear())
    print(carro.dirigir())

Classes e O.O.

Subclasses são especializações de classes

class Carro(Veiculo):
    """
    Classe Carro
    """

    def frear(self):
        """
        Override de método
        """
        return f'O carro {self.cor} está freando' 

if __name__ == "__main__":

    carro = Carro('preto', 'carro', 4, 'Toyota', 10000)
    print(carro.frear())
    carro.dirigir()

REPL 2