jbiason
/
Presentations
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

more python

master
Julio Biason 7 years ago
parent
68a6a709b5
commit
cc17b8cdc1
1 changed files with 477 additions and 229 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 706
      fugindo-com-python-2.html

706
fugindo-com-python-2.html
Unescape View File

@ -45,18 +45,18 @@
list-style: none outside; list-style: none outside;
} }
li { li {
display: block; display: block;
} }
.cursor { .cursor {
background-color: #666; background-color: #666;
color: white; color: white;
} }
img { img {
max-height: 90%; max-height: 90%;
} }
</style> </style>
</head> </head>
@ -76,7 +76,7 @@
<div> <div>
<ul class="empty"> <ul class="empty">
<li>Júlio Biason</li> <li>Júlio Biason</li>
<li>Azion Technologies<img src="_images/azion-logo.png" alt="Azion logo" class='company-logo'></li> <li>Azion Technologies<img src="_images/azion-logo.png" alt="Azion logo" class='company-logo'></li>
<li>@juliobiason</li> <li>@juliobiason</li>
<li>julio.biason@gmail.com</li> <li>julio.biason@gmail.com</li>
<li><a href="http://presentations.juliobiason.net">http://presentations.juliobiason.net</a></li> <li><a href="http://presentations.juliobiason.net">http://presentations.juliobiason.net</a></li>
@ -87,40 +87,40 @@
<section> <section>
<img src="_images/start-a-fight.jpg" alt="Eu faço perguntas em reuniões que eu não sei nada e reunião explode; não é de propósito" class='stretch'/> <img src="_images/start-a-fight.jpg" alt="Eu faço perguntas em reuniões que eu não sei nada e reunião explode; não é de propósito" class='stretch'/>
<aside class="notes"> <aside class="notes">
Eu sou famoso (ou era) por entrar eu reuniões, fazer uma Eu sou famoso (ou era) por entrar eu reuniões, fazer uma
pergunta e a reunião explodir em discussões (úteis, diga-se pergunta e a reunião explodir em discussões (úteis, diga-se
de passagem). Mas eu não fazia isso de propósito. de passagem). Mas eu não fazia isso de propósito.
</aside> </aside>
</section> </section>
<section> <section>
<img src="_images/fast-speaker.jpg" alt="Eu falo rárpido"> <img src="_images/fast-speaker.jpg" alt="Eu falo rárpido">
<aside class="notes">
Eu também tenho costume de falar rápido.
</aside>
</section>
</section>
<section> <aside class="notes">
<section> Eu também tenho costume de falar rápido.
<h2>O Problema</h2> </aside>
</section>
</section>
<ul> <section>
<li class="fragment">"Hello world" não é muito didático</li> <section>
<li class="fragment">Escrever "Fujam para as colinas"</li> <h2>O Problema</h2>
<li class="fragment">... com randomização de alguns elementos.</li>
<li class="fragment">Ex: "Cujam para as folinas", "Lujam para as cofinas" e "Nujam para as folicas"</li> <ul>
</ul> <li class="fragment">"Hello world" não é muito didático</li>
</section> <li class="fragment">Escrever "Fujam para as colinas"</li>
</section> <li class="fragment">... com randomização de alguns elementos.</li>
<li class="fragment">Ex: "Cujam para as folinas", "Lujam para as cofinas" e "Nujam para as folicas"</li>
</ul>
</section>
</section>
<section> <section>
<section> <section>
<h2>Solução</h2> <h2>Solução</h2>
<pre><code>"""Randomize a "Run to the hills" phrase.""" <pre><code>"""Randomize a "Run to the hills" phrase."""
from __future__ import print_function from __future__ import print_function
@ -173,246 +173,494 @@ if __name__ == "__main__":
switch_two() switch_two()
else: else:
print('Dude, option!')</code></pre> print('Dude, option!')</code></pre>
</section> </section>
</section> </section>
<section> <section>
<section> <section>
<h2>Docstrings</h2> <h2>Docstrings</h2>
<pre><code> <pre><code>
"""Randomize a "Run to the hills" phrase.""" """Randomize a "Run to the hills" phrase."""
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Docstrings são utilizadas para documentar coisas Docstrings são utilizadas para documentar coisas
em Python: módulos, funções, classes. em Python: módulos, funções, classes.
Essas docstrings depois são utilizadas para o `help` Essas docstrings depois são utilizadas para o `help`
e para extração de documentação, com aplicativos tipo e para extração de documentação, com aplicativos tipo
o Sphinx. o Sphinx.
Outra coisa: Strings. Docstrings são strings normais, Outra coisa: Strings. Docstrings são strings normais,
só que ficam logo abaixo do módulo/classe/função. E só que ficam logo abaixo do módulo/classe/função. E
como strings normais, elas podem ser geradas com como strings normais, elas podem ser geradas com
aspas simples ou duplas; as três aspas significam que aspas simples ou duplas; as três aspas significam que
a string pode ter quebra de linhas. a string pode ter quebra de linhas.
</aside> </aside>
</section> </section>
</section> </section>
<section> <section>
<section> <section>
<h2>Módulos e imports</h2> <h2>Módulos e imports</h2>
<pre><code> <pre><code>
import random import random
from argparse import ArgumentParser from argparse import ArgumentParser
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Para importar módulos no Python, se usa `import` ou Para importar módulos no Python, se usa `import` ou
`from X import Y`. `from X import Y`.
</aside> </aside>
</section> </section>
<section> <section>
<h2>Módulos e imports</h2> <h2>Módulos e imports</h2>
<img src="_images/modules.png" alt="Visão de módulos"/> <img src="_images/modules.png" alt="Visão de módulos"/>
<aside class="notes"> <aside class="notes">
Imagine dois módulos: `mod1` e `mod2`. Imagine dois módulos: `mod1` e `mod2`.
`mod1` tem uma função `func1` e `mod2` tem uma `mod1` tem uma função `func1` e `mod2` tem uma
funcão `func2`. funcão `func2`.
Como ambos estão em espaços separados, de `mod1` eu Como ambos estão em espaços separados, de `mod1` eu
não consigo chamar `func2` (e nem o contrário). não consigo chamar `func2` (e nem o contrário).
</aside> </aside>
</section> </section>
<section> <section>
<h2>Módulos e imports</h2> <h2>Módulos e imports</h2>
<img src="_images/modules-import.png" alt="import"/> <img src="_images/modules-import.png" alt="import"/>
<aside class="notes"> <aside class="notes">
Se eu fizer `import mod2`, tudo que tiver dentro Se eu fizer `import mod2`, tudo que tiver dentro
de `mod2` vai vir para o "namespace" atual (assim de `mod2` vai vir para o "namespace" atual (assim
como quando tu cria um objeto a partir de uma classe como quando tu cria um objeto a partir de uma classe
ele vira uma "instância", ao importar um módulo, ele vira uma "instância", ao importar um módulo,
ele vira um namespace). ele vira um namespace).
Agora, usando o nome do módulo/namespace, eu consigo Agora, usando o nome do módulo/namespace, eu consigo
chamar `func2`, por exemplo. chamar `func2`, por exemplo.
Como fazer a chamada usando o namespace é visto a seguir. Como fazer a chamada usando o namespace é visto a seguir.
</aside> </aside>
</section> </section>
<section> <section>
<h2>Módulos e imports</h2> <h2>Módulos e imports</h2>
<img src="_images/modules-from-import.png" alt="from X import Y"/> <img src="_images/modules-from-import.png" alt="from X import Y"/>
<aside class="notes"> <aside class="notes">
Se eu fizer `from mod2 import func2`, a única coisa Se eu fizer `from mod2 import func2`, a única coisa
que eu vou trazer para o namespace atual é `func2`; que eu vou trazer para o namespace atual é `func2`;
se houvessem outras funções ou outros módulos ou classes, se houvessem outras funções ou outros módulos ou classes,
essas não estariam disponíveis para uso. essas não estariam disponíveis para uso.
</aside> </aside>
</section> </section>
</section> </section>
<section> <section>
<section> <section>
<h2>Variáveis e tipos</h2> <h2>Variáveis e tipos</h2>
<pre><code> <pre><code>
CONSONANTS = ['f', 'j', 'c', 'l', 'n'] CONSONANTS = ['f', 'j', 'c', 'l', 'n']
PASSPHRASE = '{}u{}am para as {}o{}i{}as' PASSPHRASE = '{}u{}am para as {}o{}i{}as'
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Primeiro, como vimos, strings são marcadas com aspas simples Primeiro, como vimos, strings são marcadas com aspas simples
ou duplas. ou duplas.
Segundo, temos uma lista: `[]` indicam listas e, nesse caso, Segundo, temos uma lista: `[]` indicam listas e, nesse caso,
nos temos uma lista de strings (não existe o conceito de "um nos temos uma lista de strings (não existe o conceito de "um
caractere" como em C, por exemplo -- simplesmente, strings caractere" como em C, por exemplo -- simplesmente, strings
com um caractere só). com um caractere só).
Terceiro: Existe uma string com uns colchetes no meio. Por Terceiro: Existe uma string com uns colchetes no meio. Por
si só, esses colchetes não fazem nada e se alguém tentar si só, esses colchetes não fazem nada e se alguém tentar
imprimir essa string, os colchetes ainda vão estar lá. imprimir essa string, os colchetes ainda vão estar lá.
Quarto: como pode ser visto, o nome dessas variávels está Quarto: como pode ser visto, o nome dessas variávels está
em maiúsculo. Isso é apenas por notação para indicar em maiúsculo. Isso é apenas por notação para indicar
constantes, embora o Python não tenha esse conceito de constantes, embora o Python não tenha esse conceito de
constantes; isso é apenas convenção (e, mais pra frente, constantes; isso é apenas convenção (e, mais pra frente,
nós vamos estragar essa convenção.) nós vamos estragar essa convenção.)
</aside> </aside>
</section> </section>
</section> </section>
<section> <section>
<section> <section>
<h2>Funções</h2> <h2>Funções</h2>
<pre><code> <pre><code>
def print_phrase(consonants): def print_phrase(consonants):
"""Print the phrase with the randomized consonants.""" """Print the phrase with the randomized consonants."""
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Nossa primeira função, sem nada de especial: Nossa primeira função, sem nada de especial:
Primeiro, elas começam com `def`. Primeiro, elas começam com `def`.
Segundo, elas tem nomes e, por padrão, tem que ser em Segundo, elas tem nomes e, por padrão, tem que ser em
minúsculas e separadas por underscore; não existe minúsculas e separadas por underscore; não existe
nada na linguagem barrando criar funções com nomes nada na linguagem barrando criar funções com nomes
todos em maiúsculas ou com camelCase, mas, de novo, todos em maiúsculas ou com camelCase, mas, de novo,
é a convenção da comunidade. é a convenção da comunidade.
Terceiro, funções tem parâmetros, que seguem a mesma Terceiro, funções tem parâmetros, que seguem a mesma
convenção de nomes que já vimos. convenção de nomes que já vimos.
Quarto, funcões são seguidas de dois pontos. Quarto, funcões são seguidas de dois pontos.
Quinto: Python não usa colchetes para blocos; blocos Quinto: Python não usa colchetes para blocos; blocos
são definidos por identação (como pode ser visto pela são definidos por identação (como pode ser visto pela
docstring). docstring).
</aside> </aside>
</section> </section>
<section> <section>
<h2>Funções</h2> <h2>Funções</h2>
<pre><code> <pre><code>
def print_phrase(consonants, something_else): def print_phrase(consonants, something_else):
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Para ter mais parâmetros, basta adicionar os parâmetros Para ter mais parâmetros, basta adicionar os parâmetros
separados por vírgulas. separados por vírgulas.
</aside> </aside>
</section> </section>
<section> <section>
<h2>Funcões</h2> <h2>Funcões</h2>
<pre><code> <pre><code>
def soma(primeiro, segundo): def soma(primeiro, segundo):
total = primeiro + segundo total = primeiro + segundo
return total return total
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Se uma função tem algum retorno, basta adicionar `return`; Se uma função tem algum retorno, basta adicionar `return`;
funções sem `return` retornam um valor vazio, chamado `None` funções sem `return` retornam um valor vazio, chamado `None`
(que é o mesmo que `nil`, `null` e tantos outros nomes). (que é o mesmo que `nil`, `null` e tantos outros nomes).
Não existe diferença na hora de criar uma "função" e uma Não existe diferença na hora de criar uma "função" e uma
"procedure", como existe no Pascal: Simplesmente funções que "procedure", como existe no Pascal: Simplesmente funções que
não retornam valor não retornam valor (e ficam como None). não retornam valor não retornam valor (e ficam como None).
</aside> </aside>
</section> </section>
<section> <section>
<h2>Funções</h2> <h2>Funções</h2>
<pre><code> <pre><code>
soma(1, 2) soma(1, 2)
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
Para chamar uma função, basta chamar a função passando os Para chamar uma função, basta chamar a função passando os
parâmetros. parâmetros.
</aside> </aside>
</section> </section>
<section> <section>
<h2>Funções</h2> <h2>Funções</h2>
<pre><code> <pre><code>
soma(primeiro=2, segundo=3) soma(primeiro=2, segundo=3)
</code></pre> </code></pre>
<aside class="notes"> <aside class="notes">
O legal de Python é que é possível colocar nome dos O legal de Python é que é possível colocar nome dos
parâmetros na chamada da função... parâmetros na chamada da função...
</aside> </aside>
</section> </section>
<section> <section>
<h2>Funções</h2> <h2>Funções</h2>
<pre><code> <pre><code>
soma(segundo=3, primeiro=2) soma(segundo=3, primeiro=2)
</code></pre> </code></pre>
<aside class="notes">
... e por isso dá pra misturar a ordem dos parâmetros,
se ficar mais fácil de ler.
Também ajuda se a função tiver vários parâmetros, sem
contar que ajuda quem tiver lendo o código pra não
precisar voltar e ver quais são os parâmetros.
</aside>
</section>
<section>
<h2>Funções</h2>
<pre><code>
def soma(primeiro=0, segundo=0):
</code></pre>
<pre><code>
soma()
soma(1)
soma(segundo=3)
</code></pre>
<aside class="notes"> <aside class="notes">
... e por isso dá pra misturar a ordem dos parâmetros, Parâmetros também podem ser opcionais, passando
se ficar mais fácil de ler. o valor que o mesmo vai ter se não for passado.
Também ajuda se a função tiver vários parâmetros, sem E, com nomes nos parâmetros, é possível "pular"
contar que ajuda quem tiver lendo o código pra não por parâmetros que tem valor default.
precisar voltar e ver quais são os parâmetros. </aside>
</aside> </section>
</section> </section>
</section>
<section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
def soma(primeiro, segundo):
total = primeiro + segundo
return total
</code></pre>
<section> <pre class="fragment"><code>
<section> soma(1)
<h2>Welcome to Hell</h2> </code></pre>
<pre><code> <pre class="fragment"><code>
soma(1, 2, 3)
</code></pre>
<aside class="notes">
O que acontece quando não se passa a quantidade correta
de parâmetros para uma função?
</aside>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
TypeError: soma() takes exactly 2 arguments (3 given)
</code></pre>
<aside class="notes">
Simplesmente, o Python se recusa a executar porque não
foi passado o número correto de parâmetros.
</aside>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
def soma(*valores):
</code></pre>
<aside class="notes">
Entram os varargs: Quando um parâmetro tem um asterísco
na frente do nome, ele significa "colete tudo que foi
passado que não conseguiu associar a um parâmetro e
retorne como lista"
</aside>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
def soma(*valores):
print(valores)
</code></pre>
<pre><code>
soma(1, 2, 3, 4, 5)
</code></pre>
<pre class="fragment"><code>
[1, 2, 3, 4, 5]
</code></pre>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
def soma(inicial, segundo=0, *valores):
print(inicial)
print(segundo)
print(valores)
</code></pre>
<pre><code>
soma(2)
</code></pre>
<pre><code>
2
0
[]
</code></pre>
</section>
<section>
<h2>Pausa: Varargs</h2>
<p>
E o que acontece com parâmetros com nomes?
</p>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
def soma(**valores):
print(valores)
</code></pre>
<pre><code>
soma(primeiro=1, segundo=2)
</code></pre>
<pre><code>
{'primeiro': 1, 'segundo': 2}
</code></pre>
<aside class="notes">
Para capturar parâmetros com nomes, usam-se
dois asteríscos na frente do nome. Assim como um
asterísco significa "capture tudo que não for
capturado por parâmetros normais", dois asteríscos
significam "capture tudo que tiver nome e não
for capturado por parâmetros normais".
E agora também vimos como funcionam dicionários
em Python (que são chamadas de "objetos", "arrays
associativos", "mapas" e outros nomes em outras
linguagens).
</aside>
</section>
<section>
<h2>Pausa: Varargs</h2>
<p>
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.
</p>
</section>
<section>
<h2>Pausa: Varargs</h2>
<pre><code>
params = [4, 4]
soma(*params)
</code></pre>
</section>
</section>
<section>
<section>
<h2>Pausa: Objetos</h2>
<p>
Sem entrar em detalhes sobre como
criar objetos:
</p>
<ul>
<li class="fragment">Objetos tem métodos (funções associadas a um objeto)</li>
<li class="fragment">Para chamar um método, usa-se '.' e o nome do método</li>
<li class="fragment">Strings são objetos</li>
</ul>
</section>
<section>
<h2>Pausa: Objetos</h2>
<pre><code>
"isso é uma string"
</code></pre>
<aside class="notes">
Uma string é um objeto.
</aside>
</section>
<section>
<h2>Pausa: Objetos</h2>
<pre><code>
help("isso é uma string")
</code></pre>
<aside class="notes">
Pedindo help num objeto vai mostrar o help
da classe do objeto; no caso, serão mostrados
todos os métodos presentes no objeto "str", de
string.
E é por isso que é interessante colocar docstrings:
help() vai mostrar tudo que aquele objeto faz,
desde que documentado.
</aside>
</section>
<section>
<h2>Pausa: Objetos</h2>
<pre><code>
"isso é uma string".capitalize()
</code></pre>
<pre><code>
frase = "isso é uma string"
frase.capitalize()
</code></pre>
</section>
</section>
<section>
<section>
<h2><span style="color:crimson">Welcome to Hell</span></h2>
<pre><code>
print(PASSPHRASE.format(*consonants).capitalize()) print(PASSPHRASE.format(*consonants).capitalize())
</code></pre> </code></pre>
</section> </section>
</section>
<section>
<h2><span style="color:crimson">Welcome to</span> Hell</h2>
<p>O que sabemos:</p>
<ul>
<li class="fragment"><code>PASSPHRASE</code> é uma string.</li>
<li class="fragment"><code>.format</code> deve ser um método de strings.</li>
<li class="fragment"><code>consonants</code> é uma lista</li>
<li class="fragment"><code>*consonants</code> tá transformando a lista em parâmetros</li>
<li class="fragment"><code>capitalize</code> também deve ser um método de strings</li>
</ul>
</section>
</section>
</div> </div>
</div> </div>

Write Preview
Loading…
Cancel
Save