Fugindo para as Colinas Com Python

Júlio Biason
Azion Technologies
@juliobiason
https://functional.cafe/@juliobiason
julio.biason@gmail.com
http://presentations.juliobiason.net

O Problema

"Hello world" não é muito didático
Escrever "Fujam para as colinas"
... com randomização de alguns elementos.
Ex: "Cujam para as folinas", "Lujam para as cofinas" e "Nujam para as folicas"

Solução

"""Randomize a "Run to the hills" phrase."""

from __future__ import print_function

import random
from argparse import ArgumentParser


CONSONANTS = ['f', 'j', 'c', 'l', 'n']
PASSPHRASE = '{}u{}am para as {}o{}i{}as'


def print_phrase(consonants):
    """Print the phrase with the randomized consonants."""
    print(PASSPHRASE.format(*consonants).capitalize())


def totally_random():
    """Run a totally random way."""
    random.shuffle(CONSONANTS)
    print_phrase(CONSONANTS)


def switch_two():
    """Run by changing two steps at a time."""
    first = random.randint(0, 1)
    second = random.randint(2, 4)

    CONSONANTS[second], CONSONANTS[first] = \
        CONSONANTS[first], CONSONANTS[second]
    print_phrase(CONSONANTS)


def unknown():
    """We don't know what to do."""
    print('Dude, option!')


if __name__ == "__main__":
    args = ArgumentParser()
    args.add_argument('-t', '--totally',
                      dest='type',
                      action='store_const',
                      const='totally',
                      help='Like, toootaly random')
    args.add_argument('-s', '--short',
                      dest='type',
                      action='store_const',
                      const='switch'
                      help='Not so random')
    result = args.parse_args()

    callbacks = {
        'totally': totally_random,
        'switch': switch_two
    }

    func = callbacks.get(result.type, unknown)
    func()

Docstrings


"""Randomize a "Run to the hills" phrase."""

Módulos e imports


import random
from argparse import ArgumentParser

Módulos e imports

Módulos e imports

Variáveis e tipos


CONSONANTS = ['f', 'j', 'c', 'l', 'n']
PASSPHRASE = '{}u{}am para as {}o{}i{}as'

Primeiro, como vimos, strings são marcadas com aspas simples ou duplas. Segundo, temos uma lista: `[]` indicam listas e, nesse caso, nos temos uma lista de strings (não existe o conceito de "um caractere" como em C, por exemplo -- simplesmente, strings com um caractere só). Terceiro: Existe uma string com uns colchetes no meio. Por si só, esses colchetes não fazem nada e se alguém tentar imprimir essa string, os colchetes ainda vão estar lá. Quarto: como pode ser visto, o nome dessas variávels está em maiúsculo. Isso é apenas por notação para indicar constantes, embora o Python não tenha esse conceito de constantes; isso é apenas convenção (e, mais pra frente, nós vamos estragar essa convenção.)

Funções


def print_phrase(consonants):
    """Print the phrase with the randomized consonants."""

Nossa primeira função, sem nada de especial: Primeiro, elas começam com `def`. Segundo, elas tem nomes e, por padrão, tem que ser em minúsculas e separadas por underscore; não existe nada na linguagem barrando criar funções com nomes todos em maiúsculas ou com camelCase, mas, de novo, é a convenção da comunidade. Terceiro, funções tem parâmetros, que seguem a mesma convenção de nomes que já vimos. Quarto, funcões são seguidas de dois pontos. Quinto: Python não usa colchetes para blocos; blocos são definidos por identação (como pode ser visto pela docstring).

Funções


def print_phrase(consonants, something_else):

Funcões


def soma(primeiro, segundo):
    total = primeiro + segundo
    return total

Funções


soma(1, 2)

Funções


soma(primeiro=2, segundo=3)

Funções


soma(segundo=3, primeiro=2)

Funções


def soma(primeiro=0, segundo=0):


soma()
soma(1)
soma(segundo=3)

Pausa: Varargs


def soma(primeiro, segundo):
    total = primeiro + segundo
    return total


soma(1)


soma(1, 2, 3)

Pausa: Varargs


TypeError: soma() takes exactly 2 arguments (3 given)

Pausa: Varargs


def soma(*valores):

Pausa: Varargs


def soma(*valores):
    print(valores)


soma(1, 2, 3, 4, 5)


[1, 2, 3, 4, 5]

Pausa: Varargs


def soma(inicial, segundo=0, *valores):
    print(inicial)
    print(segundo)
    print(valores)


soma(2)


2
0
[]

Pausa: Varargs

E o que acontece com parâmetros com nomes?

Pausa: Varargs


def soma(**valores):
    print(valores)


soma(primeiro=1, segundo=2)


{'primeiro': 1, 'segundo': 2}

Pausa: Varargs

O legal de varargs (e o asterísco) é que ele funciona pros dois lados: Não só ele transforma parâmetros em lista, mas ele também pode funcionar para converter uma lista em parâmetros.

Pausa: Varargs


params = [4, 4]
soma(*params)

Pausa: Objetos

Sem entrar em detalhes sobre como criar objetos:

Objetos tem métodos (funções associadas a um objeto)
Para chamar um método, usa-se '.' e o nome do método
Strings são objetos

Pausa: Objetos


"isso é uma string"

Pausa: Objetos


help("isso é uma string")

Pausa: Objetos


"isso é uma string".capitalize()


frase = "isso é uma string"
frase.capitalize()

Welcome to Hell


    print(PASSPHRASE.format(*consonants).capitalize())

Welcome to Hell

O que sabemos:

PASSPHRASE é uma string.
.format deve ser um método de strings.
consonants é uma lista
*consonants tá transformando a lista em parâmetros
capitalize também deve ser um método de strings

Welcome to Hell

Lembram que PASSPHRASE tinha um monte de colchetes no meio?

.format() converte cada um deles para um dos parâmetros passados.

Welcome to Hell


'Bem vindo {}!'.format('Júlio')


Bem vindo Júlio!

Welcome to Hell


PASSPHRASE = '{}u{}am para as {}o{}i{}as'
PASSPHRASE.format('f', 'j', 'c', 'l', 'n')


'fujam para as colinas'

Welcome to... Hell


CONSONANTS = ['f', 'j', 'c', 'l', 'n']
PASSPHRASE = '{}u{}am para as {}o{}i{}as'
PASSPHRASE.format(*CONSONANTS)


'fujam para as colinas'

Welcome to... Hell?


'fujam para as colinas'.capitalize()


Fujam para as colinas

Randomizações


def totally_random():
    """Run a totally random way."""
    random.shuffle(CONSONANTS)
    print_phrase(CONSONANTS)

Randomizações


def switch_two():
    """Run by changing two steps at a time."""
    first = random.randint(0, 1)
    second = random.randint(2, 4)

Welcome to hell, maybe?


    CONSONANTS[second], CONSONANTS[first] = \
        CONSONANTS[first], CONSONANTS[second]

Welcome to Listas!


# CONSONANTS = ['f', 'j', 'c', 'l', 'n']
# second = random.randint(2, 4)
CONSONANTS[second]

Welcome to Tuples!

Tuplas são como listas, só que não podem ser alteradas.

E pra criar uma tupla:


valor, valor

Ou mais bonitinho: (valor, valor)

Welcome to Destructuring


primeiro, segundo = [1, 2]
print(primeiro)
print(segundo)

1
2

Tudo junto, agora!


    CONSONANTS[second], CONSONANTS[first] = \
        CONSONANTS[first], CONSONANTS[second]


tmp = CONSONANTS[first]
CONSONANTS[first] = CONSONANTS[second]
CONSONANTS[second] = tmp

O Pai de Todos Módulos


if __name__ == "__main__":

Falamos antes que um módulo, quando importado, vira um namespace. Pois bem, namespaces tem nomes que podem ser acessados com `__name__`. E o que acontece quando um script é executado diretamente pela linha de comando? O módulo é "importado" pelo interpretador, mas qual é o nome do namespace? `__main__`. Essa construção permite que scripts sejam tanto executados diretamente quando importados. No caso, todo o conteúdo desse if só vai ser executado se for executado pela linha de comando. Se for importado por um outro script, o script vai ter acesso às funções, mas não vai ser afetado pela leitura da linha de comando.

A linha de comando


    args = ArgumentParser()
    args.add_argument('-t', '--totally',
                      dest='type',
                      action='store_const',
                      const='totally',
                      help='Like, toootaly random')
    args.add_argument('-s', '--short',
                      dest='type',
                      action='store_const',
                      const='switch'
                      help='Not so random')
    result = args.parse_args()

Funções são cidadãos de primeira classe


    callbacks = {
        'totally': totally_random,
        'switch': switch_two
    }
    func = callbacks.get(result.type, unknown)
    func()

"Cidadão de primeira classe" significa que funções são tratadas como qualquer outro objeto/elemento/variável. No caso estamos criado um dicionário onde a chave é uma string (não por coincidência as mesmas strings que estão no argumentparser) e o valor são funções. Dicionários são objetos como strings e possuem uma função `get()`; essa função retorna o valor da entrada com a chave indicada e, caso não exista, retorna um valor padrão (que normalmente é `None`). Aqui temos, então, uma relação das possíveis strings que existem no ArgumentParser e as funções que podem ser chamadas; com o valor vindo da linha de comando, selecionamos a função `totally_random` ou `switch_two` ou, ainda, se o valor de `type` não existir, assume-se `unkonwn` -- de certa forma, agora `func` é um ponteiro para uma função. E para executar a função apontada pela variável, basta colocar os parênteses, como faria com qualquer função em Python. E esse é basicamente o formato de como se faz `switch` em Python.

Fulindo para as Cojinas com Python

Fucindo para as Lonijas com Python

Perguntas?

@juliobiason
https://functional.cafe/@juliobiason
julio.biason@gmail.com
http://presentations.juliobiason.net