diff --git a/_images/boring.gif b/_images/boring.gif new file mode 100644 index 0000000..37d2923 Binary files /dev/null and b/_images/boring.gif differ diff --git a/python.html b/python.html index 3777372..fc37630 100644 --- a/python.html +++ b/python.html @@ -49,7 +49,6 @@
-

Python

@@ -64,12 +63,17 @@
  • Linguagem interpretada.
  • Dinamicamente tipada.
    • +
  • Principais usos em pesquisas e web.
- + + +

O Zen de Python

+
+
  • Bonito é melhor que feio.
  • Explícito é melhor que implícito.
    • @@ -83,20 +87,24 @@
      -
    • Casos especiais não são especiais o suficiente para quebrar as regras.
      • -
    • Embora praticabilidade ganhe de puridade.
      • -
    • Erros nunca devem passam silenciosamente.
      • -
    • A não ser que sejam explicitamente silenciados.
      • +
    • Casos especiais não são especiais o suficiente para quebrar as regras. +
      • Embora praticabilidade ganhe de puridade.
      +
      • +
    • Erros nunca devem passam silenciosamente. +
      • A não ser que sejam explicitamente silenciados.
      +
    • Em caso de ambiguidade, evite a tentação de adivinhar.
      • -
    • Deve haver um -- e preferencialmente apenas um -- modo óbvio de fazer algo.
      • -
    • Embora talvez não seja tão óbvio de primeira a não ser que você seja Holandês.
      • +
    • Deve haver um -- e preferencialmente apenas um -- modo óbvio de fazer algo. +
      • Embora talvez não seja tão óbvio de primeira a não ser que você seja Holandês.
      +
      -
    • Agora é melhor do que nunca.
      • -
    • Embora nunca seja melhor que agora mesmo.
      • +
    • Agora é melhor do que nunca. +
      • Embora nunca seja melhor que agora mesmo.
      +
    • Se a implementação é difícil de explicar, é uma péssima idéia.
    • Se a implementação é fácil de explicar, pode ser uma boa idéia.
    • Namespaces são uma grande idéia - vamos fazer mais desses!
      • @@ -129,7 +137,7 @@ python meuscript.py
      -

      Tipos

      +

      Tipos de Variáveis

      @@ -446,6 +454,18 @@ iterável[start:end:step] >>> return (a + b) / c

      + +
      +

      Parâmetros podem ser nomeados.

      + + 

      
+>>> def funcao(a, b, c):
+>>>     return (a + b) / c
+>>>
+>>> funcao(b=2, c=3, a=10)
+4
+

      +
      @@ -536,6 +556,227 @@ iterável[start:end:step] Julio

      + +
      +

      Herança

      + + 

      
+>>> class A(object):
+>>>     def __init__(self):
+>>>         self.value = 10
+>>> class B(A):
+>>>     def __init__(self):
+>>>         super(B, self).__init__()
+>>>         self.name = 'AAAA'
+

      +
      + +
      +

      Herança Múltipla

      + + 

      
+>>> class A(object):
+>>>     def __init__(self):
+>>>         self.value = 10
+>>> class B(object):
+>>>     def __init__(self):
+>>>         self.name = 'AAAA'
+>>> class C(A, B):
+>>>     def __init__(self):
+>>>         super(C, self).__init__()
+

      +
      + +
      +

      No Python 3, basta usar super().__init__(). +

      +
    + +
    +

    As Esquisitices de Python

    +
    + +
    +
    +

    Strings São Imutáveis

    +
    + +
    + 

    
+>>> a = 'string 1'
+>>> b = 'string 2'
+>>> c = a + ' ' + b
+

    + +
      +
    • Cria um objeto que é o conteúdo de "a" com um espaço.
      • +
    • Cria um novo objeto que é o novo objeto mais o conteúdo de "b".
      • +
    • Atribui o novo objeto à "c".
      • +
    +
    + +
    +

    Forma correta de concatenar strings:

    + + 

    
+>>> a = 'string 1'
+>>> b = 'string 2'
+>>> c = ' '.join([a, b])
+

    +
    +
    + +
    +
    +

    Listas São Mutáveis

    +
    + +
    + 

    
+>>> def a(l=[]):
+>>>     l.append(1)
+>>>     print l
+>>>
+>>> a()
+[1]
+>>> a()
+[1, 1]
+

    +
    + +
    +

    Forma correta de lidar com parâmetros mutáveis:

    + + 

    
+>>> def a(l=None):
+>>>     if not l:
+>>>         l = []
+>>>     l.append(1)
+>>>
+>>> a()
+[1]
+>>> a()
+[1]
+

    +
    +
    + +
    +
    +

    Stars

    +
    + +
    +

    "Stars" servem para empacotar e desempacotar parâmetros indefinidos.

    +
    + +
    + 

    
+>>> def a(*args):
+>>>     print args
+>>>
+>>> a(1)
+[1]
+>>> a(1, 2, 3, 4, 5)
+[1, 2, 3, 4, 5]
+

    + +

    * pega somente os parâmetros que não tem nome.

    +
    + +
    + 

    
+>>> def a(**kwargs):
+>>>     print kwargs
+>>>
+>>> a(a=1)
+{a: 1}
+>>> a(value1=10, a=2)
+{value1: 10, a: 2}
+

    + +

    ** pega somente os parâmetros que tem nome.

    +
    + +
    + 

    
+>>> def a(*args, **kwargs):
+>>>     print args
+>>>     print kwargs
+>>>
+>>> a(a=1)
+[]
+{a: 1}
+>>> a(1, 2, 3, a=5)
+[1, 2, 3]
+{a: 5}
+

    +
    + +
    + 

    
+>>> def a(a, b, *args, name=None, **kwargs):
+>>>     print 'a =', a
+>>>     print 'b =', b
+>>>     print 'args =', args
+>>>     print 'name = ', name
+>>>     print 'kwargs =', kwargs
+

    +
    + +
    + + +

    BORING!

    +
    + +
    +

    A parte legal dos stars não é usar para criar funções que aceitam + qualquer parâmetro (embora isso seja legal em alguns casos).

    + +

    A parte legal é fazer chamadas de funções com dicionários.

    +
    + +
    + 

    
+>>> def funcao(a, b, c):
+>>>     return (a + b) / c
+>>>
+>>> params = {b: 2, c: 3, a:10}
+>>> funcao(**params)
+

    +
    +
    + +
    +
    +

    "Functions are First Class Citizens"

    +
    + +
    + 

    
+>>> def funcao(a, b, c):
+>>>     return (a + b) / c
+>>>
+>>> def check(a, b, c, condition, function):
+>>>     if condition:
+>>>         print function(a, b, c)
+>>>
+>>> check(1, 2, 3, True, funcao)
+1
+>>> check(1, 2, 3, False, funcao)
+>>>
+

    +
    +
    + +
    +
    +

    Decorators

    +
    + +
    +