|
|
|
|
@ -64,7 +64,7 @@
|
|
|
|
|
<div class="reveal"> |
|
|
|
|
<div class="slides"> |
|
|
|
|
<section> |
|
|
|
|
<section data-background="_images/python.jpg"> |
|
|
|
|
<section data-background="_images/python.jpg" data-header> |
|
|
|
|
<h1 class="semi-opaque">Fugindo para as Colinas Com Python</h1> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
@ -645,6 +645,10 @@ frase.capitalize()
|
|
|
|
|
<pre><code> |
|
|
|
|
print(PASSPHRASE.format(*consonants).capitalize()) |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Holy cow! |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
@ -685,6 +689,11 @@ frase.capitalize()
|
|
|
|
|
<pre><code> |
|
|
|
|
Bem vindo Júlio! |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Format funciona da seguinte format: Tudo que tiver `{}` no |
|
|
|
|
meio, ele troca pelo que vier de parâmetro. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
@ -698,6 +707,288 @@ PASSPHRASE.format('f', 'j', 'c', 'l', 'n')
|
|
|
|
|
<pre class="fragment"><code> |
|
|
|
|
'fujam para as colinas' |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
... se eu passar cada uma das consoantes no format com |
|
|
|
|
a nossa string original, ele vai trocar cada um dos `{}` |
|
|
|
|
pelas consoantes passadas como parâmetros, uma a uma. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to... Hell</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
CONSONANTS = ['f', 'j', 'c', 'l', 'n'] |
|
|
|
|
PASSPHRASE = '{}u{}am para as {}o{}i{}as' |
|
|
|
|
PASSPHRASE.format(*CONSONANTS) |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
'fujam para as colinas' |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
... e como a gente viu que dá pra converter listas |
|
|
|
|
para parâmetros, usando o `*` a gente passa a lista, |
|
|
|
|
que é convertida para chamada de parâmetros exatamente |
|
|
|
|
como anteriormente e ainda temos o mesmo resultado. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to... Hell?</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
'fujam para as colinas'.capitalize() |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
Fujam para as colinas |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
E `capitalize()` simplesmente converte o primeiro |
|
|
|
|
caractere para maiúscula. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<section> |
|
|
|
|
<h2>Randomizações</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
def totally_random(): |
|
|
|
|
"""Run a totally random way.""" |
|
|
|
|
random.shuffle(CONSONANTS) |
|
|
|
|
print_phrase(CONSONANTS) |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Nada complicado: A gente chama o `random.shuffle`, |
|
|
|
|
que é um método do módulo `random` que a gente fez |
|
|
|
|
import lá no começo. |
|
|
|
|
|
|
|
|
|
O único problema aqui é que `shuffle` faz *in-place*, |
|
|
|
|
ou seja, a lista vai ter o conteúdo alterado. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Randomizações</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
def switch_two(): |
|
|
|
|
"""Run by changing two steps at a time.""" |
|
|
|
|
first = random.randint(0, 1) |
|
|
|
|
second = random.randint(2, 4) |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Essa função simplesmente escolhe dois números randomicamente. |
|
|
|
|
|
|
|
|
|
O primeiro vai de 0 a 1. |
|
|
|
|
|
|
|
|
|
E o segundo de 2 a 4. |
|
|
|
|
|
|
|
|
|
... que, se a gente contar, são exatamente as posições das |
|
|
|
|
consoantes de "fujam" e de "colinas", respecticamente, |
|
|
|
|
começando por 0. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to hell, maybe?</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
CONSONANTS[second], CONSONANTS[first] = \ |
|
|
|
|
CONSONANTS[first], CONSONANTS[second] |
|
|
|
|
</code></pre> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to Listas!</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
# CONSONANTS = ['f', 'j', 'c', 'l', 'n'] |
|
|
|
|
# second = random.randint(2, 4) |
|
|
|
|
CONSONANTS[second] |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Para acessar um elemento específico de uma lista |
|
|
|
|
é só usar colchetes e um índice; ou seja, iremos |
|
|
|
|
pegar a consoante indicada pelo número randômico |
|
|
|
|
seleciado (entre 2 e 4, inclusive). |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to Tuples!</h2> |
|
|
|
|
|
|
|
|
|
<p> |
|
|
|
|
Tuplas são como listas, só que |
|
|
|
|
não podem ser alteradas. |
|
|
|
|
</p> |
|
|
|
|
|
|
|
|
|
<p> |
|
|
|
|
E pra criar uma tupla: |
|
|
|
|
</p> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
valor, valor |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<p class="fragment">Ou mais bonitinho: <code>(valor, valor)</code></p> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Welcome to Destructuring</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
primeiro, segundo = [1, 2] |
|
|
|
|
print(primeiro) |
|
|
|
|
print(segundo) |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
1 |
|
|
|
|
2 |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Destructuring (e não destroying) serve |
|
|
|
|
para "desmontar" tuplas e listas. |
|
|
|
|
|
|
|
|
|
Por exemplo, a lista tem dois elementos; se |
|
|
|
|
eu apontar os dois valores para ela, o |
|
|
|
|
primeiro vai ter o primeiro valor e o segundo, |
|
|
|
|
o segundo; se forem três, eu preciso de três |
|
|
|
|
variáveis. |
|
|
|
|
|
|
|
|
|
E se o número de váriaveis estiver errado, |
|
|
|
|
dá erro. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<h2>Tudo junto, agora!</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
CONSONANTS[second], CONSONANTS[first] = \ |
|
|
|
|
CONSONANTS[first], CONSONANTS[second] |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<pre class="fragment"><code> |
|
|
|
|
tmp = CONSONANTS[first] |
|
|
|
|
CONSONANTS[first] = CONSONANTS[second] |
|
|
|
|
CONSONANTS[second] = tmp |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Ou seja, estamos pegando a consonante |
|
|
|
|
escolhida randomicamente entre 0 e 1 (f e j) |
|
|
|
|
e a consoante escolhida randomicante entre |
|
|
|
|
2 e 4 (c, l, n) e criando uma tupla com esses |
|
|
|
|
dois valores; a seguir a gente desmonta |
|
|
|
|
(destructura) esses dois na ordem inversa. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<section> |
|
|
|
|
<h2>O Pai de Todos Módulos</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
if __name__ == "__main__": |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
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. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<section> |
|
|
|
|
<h2>A linha de comando</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
args = ArgumentParser() |
|
|
|
|
args.add_argument('-t', '--totally', |
|
|
|
|
dest='totally', |
|
|
|
|
default=False, |
|
|
|
|
action='store_true', |
|
|
|
|
help='Like, toootaly random') |
|
|
|
|
args.add_argument('-s', '--short', |
|
|
|
|
dest='short', |
|
|
|
|
default=False, |
|
|
|
|
action='store_true', |
|
|
|
|
help='Not so random') |
|
|
|
|
result = args.parse_args() |
|
|
|
|
</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
Nada de muito mágico aqui, exceto que o |
|
|
|
|
ArgumentParser faz um monte de coisas pra |
|
|
|
|
nós: nós só definimos os parametros, onde eles |
|
|
|
|
vão ficar no final, qual ação a ser tomada |
|
|
|
|
e um help. E o ArgumentParser faz todo |
|
|
|
|
o resto. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section> |
|
|
|
|
<section> |
|
|
|
|
<h2>E os finalmentes...</h2> |
|
|
|
|
|
|
|
|
|
<pre><code> |
|
|
|
|
if result.totally: |
|
|
|
|
totally_random() |
|
|
|
|
elif result.short: |
|
|
|
|
switch_two() |
|
|
|
|
else: |
|
|
|
|
print('Dude, option!')</code></pre> |
|
|
|
|
|
|
|
|
|
<aside class="notes"> |
|
|
|
|
E a gente simplesmente acessa as propriedades |
|
|
|
|
do objeto de resultado do `parse_args` e, |
|
|
|
|
se for verdadeiro (True), executamos |
|
|
|
|
uma função ou a outra. |
|
|
|
|
</aside> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
|
|
|
|
|
<section data-background='_images/thats-all-folks.jpg'> |
|
|
|
|
<section> |
|
|
|
|
<h1 class="fragment semi-opaque">Perguntas?</h1> |
|
|
|
|
</section> |
|
|
|
|
</section> |
|
|
|
|
</div> |
|
|
|
|
|
Julio Biason
7 years ago