summaryrefslogtreecommitdiffhomepage
path: root/pt-br
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br')
-rw-r--r--pt-br/asymptoticnotation-pt.html.markdown161
-rw-r--r--pt-br/bash-pt.html.markdown6
-rw-r--r--pt-br/elixir.html.markdown411
-rw-r--r--pt-br/git-pt.html.markdown12
-rw-r--r--pt-br/javascript-pt.html.markdown4
-rw-r--r--pt-br/php-pt.html.markdown66
-rw-r--r--pt-br/python3-pt.html.markdown746
-rw-r--r--pt-br/ruby-pt.html.markdown10
-rw-r--r--pt-br/typescript-pt.html.markdown179
9 files changed, 1546 insertions, 49 deletions
diff --git a/pt-br/asymptoticnotation-pt.html.markdown b/pt-br/asymptoticnotation-pt.html.markdown
new file mode 100644
index 00000000..c5299a11
--- /dev/null
+++ b/pt-br/asymptoticnotation-pt.html.markdown
@@ -0,0 +1,161 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+ - ["Carolina Knoll", "http://github.com/carolinaknoll"]
+lang: pt-br
+---
+
+# Aprenda X em Y minutos
+## Onde X=Notação Assintótica
+
+# Notações Assintóticas
+## O que são?
+
+Notações assintóticas são notações matemáticas que nos permitem analisar tempo de execução
+de um algoritmo, identificando o seu comportamento de acordo como o tamanho de entrada para
+o algoritmo aumenta. Também é conhecido como taxa de "crescimento" de um algoritmo. O algoritmo
+simplesmente se torna incrivelmente lento conforme o seu tamanho aumenta? Será que pode-se na
+maior parte manter o seu tempo de execução rápido mesmo quando o tamanho de entrada aumenta?
+A notação assintótica nos dá a capacidade de responder a essas perguntas.
+
+## Além desta, existem outras alternativas para responder a essas perguntas?
+
+Uma forma seria a de contar o número de operações primitivas em diferentes tamanhos de entrada.
+Embora esta seja uma solução válida, a quantidade de trabalho necessário, mesmo para algoritmos
+simples, não justifica a sua utilização.
+
+Outra maneira é a de medir fisicamente a quantidade de tempo que leva para se executar um algoritmo
+de diferentes tamanhos. No entanto, a precisão e a relatividade (já que tempos obtidos só teriam
+relação à máquina em que eles foram testados) deste método estão ligadas a variáveis ambientais,
+tais como especificações de hardware, poder de processamento, etc.
+
+## Tipos de Notação Assintótica
+
+Na primeira seção deste documento nós descrevemos como uma notação assintótica identifica o comportamento
+de um algoritmo como as alterações de tamanho de entrada (input). Imaginemos um algoritmo como uma função
+f, n como o tamanho da entrada, e f (n) sendo o tempo de execução. Assim, para um determinado algoritmo f,
+com tamanho de entrada n você obtenha algum tempo de execução resultante f (n). Isto resulta num gráfico,
+em que o eixo Y representa o tempo de execução, o eixo X é o tamanho da entrada, e os pontos marcados são
+os resultantes da quantidade de tempo para um dado tamanho de entrada.
+
+Pode-se rotular uma função ou algoritmo com uma notação assintótica de diversas maneiras diferentes.
+Dentre seus exemplos, está descrever um algoritmo pelo seu melhor caso, pior caso, ou caso equivalente.
+O mais comum é o de analisar um algoritmo pelo seu pior caso. Isso porque você normalmente não avaliaria
+pelo melhor caso, já que essas condições não são as que você está planejando. Um bom exemplo disto é o de
+algoritmos de ordenação; especificamente, a adição de elementos a uma estrutura de tipo árvore. O melhor
+caso para a maioria dos algoritmos pode ser tão simples como uma única operação. No entanto, na maioria
+dos casos, o elemento que você está adicionando terá de ser ordenado de forma adequada através da árvore,
+o que poderia significar a análise de um ramo inteiro. Este é o pior caso, e é por ele que precisamos seguir.
+
+### Tipos de funções, limites, e simplificação
+
+```
+Função Logaritmica - log n
+Função Linear - an + b
+Função Quadrática - an^2 + bn + c
+Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde z é uma constante
+Função Exponencial - a^n, onde a é uma constante
+```
+
+Estas são algumas classificações básicas de crescimento de função usados em várias notações. A lista
+começa com a função crescimento mais lento (logarítmica, com tempo de execução mais rápido) e vai até
+a mais rápida (exponencial, com tempo de execução mais lento). Observe que 'n', ou nossa entrada,
+cresce em cada uma dessas funções, e o resultado claramente aumenta muito mais rapidamente em função
+quadrática, polinomial e exponencial, em comparação com a logarítmica e a linear.
+
+Uma observação de boa importância é que, para as notações a serem discutidas, deve-se fazer o melhor
+para utilizar termos mais simples. Isto significa desrespeitar constantes, e simplificar termos de
+ordem, porque, como o tamanho da entrada (ou n no nosso f (n) exemplo) aumenta infinitamente (limites
+matemáticos), os termos em ordens mais baixas e constantes são de pouca ou nenhuma importância. Dito
+isto, se você possui constantes com valor 2^9001, ou alguma outra quantidade ridícula, inimaginável,
+perceberá que a simplificação distorcerá a precisão de sua notação.
+
+Já que nós queremos a forma mais simples, vamos modificar nossas funções um pouco.
+
+```
+Logaritmica - log n
+Linear - n
+Quadrática - n^2
+Polinomial - n^z, onde z é uma constante
+Exponencial - a^n, onde a é uma constante
+```
+
+### O Grande-O
+
+Grande-O, geralmente escrita como O, é uma Notação Assintótica para o pior caso para uma dada função. Digamos
+que `f(n)` é o tempo de execução de seu algoritmo, e `g(n)` é uma complexidade de tempo arbitrário que você está
+tentando se relacionar com o seu algoritmo. `f(n)` será O(g(n)), se, por qualquer constante real c (c > 0),
+`f(n)` <= `c g(n)` para cada tamanho de entrada n (n > 0).
+
+*Exemplo 1*
+
+```
+f(n) = 3log n + 100
+g(n) = log n
+```
+
+É `f(n)` um O(g(n))?
+É 3 `log n + 100` igual a O(log n)?
+Vamos checar na definição de Grande-O.
+
+```
+3log n + 100 <= c * log n
+```
+
+Existe alguma constante c que satisfaça isso para todo n?
+
+```
+3log n + 100 <= 150 * log n, n > 2 (indefinido em n = 1)
+```
+
+Sim! A definição de Grande-O foi satisfeita. Sendo assim, `f(n)` é O(g(n)).
+
+*Exemplo 2*
+
+```
+f(n) = 3 * n^2
+g(n) = n
+```
+
+É `f(n)` um O(g(n))?
+É `3 * n^2` um O(n)?
+Vamos ver na definição de Grande-O.
+
+```
+3 * n^2 <= c * n
+```
+
+Existe alguma constante que satisfaça isso para todo n?
+Não, não existe. `f(n)` NÃO É O(g(n)).
+
+### Grande-Omega
+
+Grande-Omega, comumente escrito como Ω, é uma Notação Assintótica para o melhor caso, ou
+uma taxa de crescimento padrão para uma determinada função.
+
+`f(n)` é Ω(g(n)), se, por qualquer constante c real (c > 0), `f(n)` é >= `c g(n)` para cada
+tamanho de entrada n (n > 0).
+
+Sinta-se livre para pesquisar recursos adicionais e obter mais exemplos sobre este assunto!
+Grande-O é a notação primária utilizada para tempo de execução de algoritmos, de modo geral.
+
+### Notas de Finalização
+
+É complicado exibir este tipo de assunto de forma tão curta, então é definitivamente recomendado
+pesquisar além dos livros e recursos on-line listados. Eles serão capazes de analisar o assunto com
+uma profundidade muito maior, além de ter definições e exemplos. Mais sobre onde X="Algoritmos e
+Estruturas de Dados" está a caminho: Haverá conteúdo focado na análise de exemplos de códigos reais
+em breve.
+
+## Livros
+
+* [Algorithms] (http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Algorithm Design] (http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos Online
+
+* [MIT] (http://web.mit.edu/16.070/www/lecture/big_o.pdf)
+* [KhanAcademy] (https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index a604e7b8..ae18435a 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -161,11 +161,11 @@ echo "#helloworld" > output.out
echo "#helloworld" | cat > output.out
echo "#helloworld" | tee output.out > /dev/null
-# Limpa os arquivos temporarios detalhando quais foram deletados (use '-i' para confirmar exlusão)
+# Limpa os arquivos temporários detalhando quais foram deletados (use '-i' para confirmar exclusão)
rm -v output.out error.err output-and-error.log
-# Comando podem ser substituidos por outros comandos usando $( ):
-# O comand oa seguir mostra o número de arquivos e diretórios no diretorio atual
+# Comando podem ser substituídos por outros comandos usando $( ):
+# O comando a seguir mostra o número de arquivos e diretórios no diretorio atual
echo "Existem $(ls | wc -l) itens aqui."
# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se
diff --git a/pt-br/elixir.html.markdown b/pt-br/elixir.html.markdown
new file mode 100644
index 00000000..b4ca8a52
--- /dev/null
+++ b/pt-br/elixir.html.markdown
@@ -0,0 +1,411 @@
+---
+language: elixir
+contributors:
+ - ["Joao Marques", "http://github.com/mrshankly"]
+ - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+translators:
+ - ["Rodrigo Muniz", "http://github.com/muniz95"]
+filename: learnelixir-pt.ex
+---
+
+Elixir é uma linguagem funcional moderna construída no topo da Erlang VM.
+É totalmente compatível com Erlang, porém conta com uma sintaxe mais padronizada
+e muitos outros recursos.
+
+```elixir
+
+# Comentários de linha única começam com um símbolo de número.
+
+# Não há comentários de múltiplas linhas,
+# mas você pode empilhar os comentários.
+
+# Para usar o shell do elixir use o comando `iex`.
+# Compile seus módulos com o comando `elixirc`.
+
+# Ambos devem estar em seu path se você instalou o Elixir corretamente.
+
+## ---------------------------
+## -- Tipos Básicos
+## ---------------------------
+
+# Há números
+3 # integer
+0x1F # integer
+3.0 # float
+
+# Atoms, que são literais, uma constante com nome. Elas começam com `:`.
+:hello # atom
+
+# Tuplas que são guardadas contiguamente em memória.
+{1,2,3} # tupla
+
+# Podemos acessar um elemento de uma tupla om a função `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listas que são implementadas como listas ligadas.
+[1,2,3] # lista
+
+# Podemos acessar a primeira posição (head) e o resto (tail) de uma lista como a seguir:
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# Em elixir, bem como em Erlang, o sinal `=` denota pattern match,
+# e não uma atribuição.
+#
+# Isto significa que o que estiver à esquerda (pattern) é comparado com o que
+# estiver à direita.
+#
+# É assim que o exemplo acima de acesso à head e tail de uma lista funciona.
+
+# Um pattern match retornará erro quando os lados não conferem, como neste exemplo
+# onde as tuplas tem diferentes tamanhos.
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Também há binários
+<<1,2,3>> # binary
+
+# Strings e char lists
+"hello" # string
+'hello' # char list
+
+# Strings de múltiplas linhas
+"""
+Strings
+de múltiplas
+linhas.
+"""
+#=> "Strings\nde múltiplas\nlinhas"
+
+# Strings são sempre codificadas em UTF-8:
+"héllò" #=> "héllò"
+
+# Strings são de fato apenas binários, e char lists apenas listas.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c] #=> 'abc'
+
+# `?a` em elixir retorna o valor ASCII para a letra `a`
+?a #=> 97
+
+# Para concatenar listas use `++`, para binários use `<>`
+[1,2,3] ++ [4,5] #=> [1,2,3,4,5]
+'hello ' ++ 'world' #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world" #=> "hello world"
+
+# Ranges são representados como `início..fim` (ambos inclusivos)
+1..10 #=> 1..10
+menor..maior = 1..10 # Pattern matching pode ser usada em ranges também
+[lower, upper] #=> [1, 10]
+
+## ---------------------------
+## -- Operadores
+## ---------------------------
+
+# Matemática básica
+1 + 1 #=> 2
+10 - 5 #=> 5
+5 * 2 #=> 10
+10 / 2 #=> 5.0
+
+# Em elixir o operador `/` sempre retorna um float.
+
+# Para divisão de inteiros use `div`
+div(10, 2) #=> 5
+
+# Para obter o resto da divisão use `rem`
+rem(10, 3) #=> 1
+
+# Há também operadores booleanos: `or`, `and` e `not`.
+# Estes operadores esperam um booleano como primeiro argumento.
+true and true #=> true
+false or true #=> true
+# 1 and true #=> ** (ArgumentError) argument error
+
+# Elixir também fornece `||`, `&&` e `!` que aceitam argumentos de qualquer tipo.
+# Todos os valores exceto `false` e `nil` serão avaliados como true.
+1 || true #=> 1
+false && 1 #=> false
+nil && 20 #=> nil
+!true #=> false
+
+# Para comparações temos: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` e `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2 #=> true
+
+# `===` e `!==` são mais estritos ao comparar integers e floats:
+1 == 1.0 #=> true
+1 === 1.0 #=> false
+
+# Podemos comparar também dois tipos de dados diferentes:
+1 < :hello #=> true
+
+# A regra de ordenação no geral é definida abaixo:
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Ao citar Joe Armstrong nisto: "A ordem de fato não é importante,
+# mas que uma ordem total esteja bem definida é importante."
+
+## ---------------------------
+## -- Fluxo de Controle
+## ---------------------------
+
+# expressão `if`
+if false do
+ "Isso nunca será visto"
+else
+ "Isso será"
+end
+
+# Também há `unless`
+unless true do
+ "Isso nunca será visto"
+else
+ "Isso será"
+end
+
+# Lembra do patter matching? Muitas estruturas de fluxo de controle em elixir contam com ela.
+
+# `case` nos permite comparar um valor com muitos patterns:
+case {:um, :dois} do
+ {:quatro, :cinco} ->
+ "Isso não corresponde"
+ {:um, x} ->
+ "Isso corresponde e vincula `x` a `:dois`"
+ _ ->
+ "Isso corresponde a qualquer valor"
+end
+
+# É comum vincular o valor a `_` se não precisamos dele.
+# Por exemplo, se apenas a head de uma lista nos interessa:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Para melhor legibilidade podemos fazer o seguinte:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` nos permite verificar várias condições ao mesmo tempo.
+# Use `cond` em vez de aninhar vários `if`'s.
+cond do
+ 1 + 1 == 3 ->
+ "Nunca serei visto"
+ 2 * 5 == 12 ->
+ "Nem eu"
+ 1 + 2 == 3 ->
+ "Mas eu serei"
+end
+
+# É comum definir a última condição igual a `true`, que sempre irá corresponder.
+cond do
+ 1 + 1 == 3 ->
+ "Nunca serei visto"
+ 2 * 5 == 12 ->
+ "Nem eu"
+ true ->
+ "Mas eu serei (isso é essencialmente um else)"
+end
+
+# `try/catch` é usado para capturar valores que são lançados, também suporta uma
+# cláusula `after` que é invocada havendo um valor capturado ou não.
+try do
+ throw(:hello)
+catch
+ message -> "Deu #{mensagem}."
+after
+ IO.puts("Sou o after.")
+end
+#=> Sou o after
+# "Deu :hello"
+
+## ---------------------------
+## -- Módulos e Funções
+## ---------------------------
+
+# Funções Anônimas (repare o ponto)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Elas também aceitam várias cláusulas e guards.
+# Guards permitem ajustes finos de pattern matching,
+# sendo indicados pela palavra `when`:
+f = fn
+ x, y when x > 0 -> x + y
+ x, y -> x * y
+end
+
+f.(1, 3) #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir também fornece várias funções embutidas.
+# Estas estão disponíveis no escopo atual.
+is_number(10) #=> true
+is_list("ola") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Você pode agrupar algumas funções em um módulo. Dentro de um módulo use `def`
+# para definir suas funções.
+defmodule Math do
+ def sum(a, b) do
+ a + b
+ end
+
+ def square(x) do
+ x * x
+ end
+end
+
+Math.sum(1, 2) #=> 3
+Math.square(3) #=> 9
+
+# Para compilar o módulo Math salve-o como `math.ex` e use `elixirc`
+# em seu terminal: elixirc math.ex
+
+# Dentro de um módulo podemos definir funções com `def` e funções privadas com `defp`.
+# Uma função definida com `def` pode ser invocada por outros módulos,
+# já uma função privada pode ser invocada apenas localmente.
+defmodule PrivateMath do
+ def sum(a, b) do
+ do_sum(a, b)
+ end
+
+ defp do_sum(a, b) do
+ a + b
+ end
+end
+
+PrivateMath.sum(1, 2) #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarações de funções também suportam guards cláusulas múltiplas:
+defmodule Geometry do
+ def area({:rectangle, w, h}) do
+ w * h
+ end
+
+ def area({:circle, r}) when is_number(r) do
+ 3.14 * r * r
+ end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3}) #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Devido à imutabilidade, recursão é uma grande parte do elixir
+defmodule Recursion do
+ def sum_list([head | tail], acc) do
+ sum_list(tail, acc + head)
+ end
+
+ def sum_list([], acc) do
+ acc
+ end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Módulos do elixir suportam atributos, hpa atributos embutidos e você
+# pode também adicionar os seus próprios.
+defmodule MyMod do
+ @moduledoc """
+ Este é um atributo embutido em um módulo de exemplo.
+ """
+
+ @my_data 100 # Este é um atributo customizado.
+ IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- Structs e Exceptions
+## ---------------------------
+
+# Structs são extensões no topo de mapas que trazem valores padrão,
+# garantias em tempo de compilação e polimorfismo para o Elixir.
+defmodule Pessoa do
+ defstruct nome: nil, idade: 0, peso: 0
+end
+
+joe_info = %Pessoa{ nome: "Joe", idade: 30, peso: 180 }
+#=> %Pessoa{idade: 30, peso: 180, nome: "Joe"}
+
+# Acessa o valor de nome
+joe_info.name #=> "Joe"
+
+# Atualiza o valor de idade
+older_joe_info = %{ joe_info | idade: 31 }
+#=> %Pessoa{idade: 31, peso: 180, nome: "Joe"}
+
+# O bloco `try` com a palavra `rescue` é usado para manipular exceções
+try do
+ raise "algum erro"
+rescue
+ RuntimeError -> "resgatado um erro em tempo de execução"
+ _error -> "isso resgatará qualquer erro"
+end
+
+# Toda exceção possui uma mensagem
+try do
+ raise "algum erro"
+rescue
+ x in [RuntimeError] ->
+ x.message
+end
+
+## ---------------------------
+## -- Concorrência
+## ---------------------------
+
+# Elixir conta com o modelo de ator para concorrência. Tudo o que precisamos para
+# escrever programas concorrentes em elixir são três primitivos: spawning processes,
+# sending messages e receiving messages.
+
+# Para iniciar um novo processo usamos a função `spawn`, a qual leva uma função
+# como argumento.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retorna um pid (process identifier), você pode usar esse pid para enviar
+# mensagens ao processo. Para envio de mensagens usamos o operador `send`.
+# Para tudo isso ser útil precisamos estar aptos a receber mensagens. Isto é
+# realizado com o mecanismo `receive`:
+defmodule Geometry do
+ def area_loop do
+ receive do
+ {:rectangle, w, h} ->
+ IO.puts("Area = #{w * h}")
+ area_loop()
+ {:circle, r} ->
+ IO.puts("Area = #{3.14 * r * r}")
+ area_loop()
+ end
+ end
+end
+
+# Compile o módulo e crie um processo que avalie `area_loop` no shell
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Envia uma mensagem ao `pid` correspondente a um pattern na declaração de recebimento
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+# {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+# {:circle,2}
+
+# O shell também é um processo, você pode usar `self` para obter o pid atual
+self() #=> #PID<0.27.0>
+```
+
+## Referências
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) da [página do elixir](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) por Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) por Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) por Joe Armstrong
diff --git a/pt-br/git-pt.html.markdown b/pt-br/git-pt.html.markdown
index ea3570d6..907892b1 100644
--- a/pt-br/git-pt.html.markdown
+++ b/pt-br/git-pt.html.markdown
@@ -32,7 +32,7 @@ a um arquivo ou conjunto de arquivos ao longo do tempo.
de arquivos.
* Controle de versão distribuído foca em compartilhar alterações. Cada
alteração é associada a um *id* único.
-* Sistemas distribuídos não tem estrutura definida. É possivel ter um sistema
+* Sistemas distribuídos não têm estrutura definida. É possivel ter um sistema
centralizado ao estilo SVN usando git.
[Informação adicional (EN)](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@@ -56,7 +56,7 @@ referências. Pode ser descrito como uma estrutura de dados de código fonte
com a particularidade de cada elemento do código fonte permitir acesso ao
histórico das suas alterações, entre outras coisas.
-Um repositório git é constituido pelo diretório .git e a *working tree*
+Um repositório git é constituído pelo diretório .git e a *working tree*
### Diretório .git (componente do repositório)
@@ -140,10 +140,10 @@ Para visualizar rapidamente o detalhamento de cada comando ou apenas lembrar da
# Ver rapidamente os comandos disponiveis
$ git help
-# Ver todos os comandos disponiveis
+# Ver todos os comandos disponíveis
$ git help -a
-# Usar o *help* para um comando especifico
+# Usar o *help* para um comando específico
# git help <comando_aqui>
$ git help add
$ git help commit
@@ -158,7 +158,7 @@ do repositório) e o *commit* da *HEAD* atual.
```bash
# Apresenta o *branch*, arquivos não monitorados, alterações e outras
-# difereças
+# diferenças
$ git status
# Para aprender mais detalhes sobre git *status*
@@ -400,7 +400,7 @@ perigoso quando não há certeza do que se está fazendo.
```bash
# Restabelece a camada intermediária de registo para o último
-# commit (o directório fica sem alterações)
+# commit (o diretório fica sem alterações)
$ git reset
# Restabelece a camada intermediária de registo para o último commit, e
diff --git a/pt-br/javascript-pt.html.markdown b/pt-br/javascript-pt.html.markdown
index 59c6890e..e337f4bc 100644
--- a/pt-br/javascript-pt.html.markdown
+++ b/pt-br/javascript-pt.html.markdown
@@ -197,7 +197,6 @@ myObj.myFourthKey; // = undefined
// A sintaxe para essa seção é quase idêntica a maioria das linguagens.
-// The `if` structure works as you'd expect.
// A estrutura `if` funciona como deveria ser.
var count = 1
if (count == 3){
@@ -219,9 +218,6 @@ do {
input = getInput();
} while (!isValid(input))
-// The `for` loop is the same as C and Java:
-// initialisation; continue condition; iteration.
-
// O loop `for` é o mesmo de C e Java:
// inicialização, condição para continuar; iteração
for (var i = 0; i < 5; i++){
diff --git a/pt-br/php-pt.html.markdown b/pt-br/php-pt.html.markdown
index 0e710742..8a1c956e 100644
--- a/pt-br/php-pt.html.markdown
+++ b/pt-br/php-pt.html.markdown
@@ -7,7 +7,7 @@ translators:
- ["Abdala Cerqueira", "http://abda.la"]
- ["Raquel Diniz", "http://twitter.com/raquelrdiniz"]
lang: pt-br
-filename: learnphp-pt.php
+filename: php-pt.html.markdown
---
Este documento descreve PHP 5+.
@@ -20,21 +20,23 @@ Este documento descreve PHP 5+.
// Duas barras iniciam o comentário de uma linha.
-# O hash (aka pound symbol) também inicia, mas // é mais comum
+# O hash (aka pound symbol) também inicia, mas // é mais comum.
/*
O texto envolto por barra-asterisco e asterisco-barra
- faz um comentário de múltiplas linhas
+ faz um comentário de múltiplas linhas.
*/
-// Utilize "echo" ou "print" para imprimir a saída
-print('Olá '); // Imprime "Olá " sem quebra de linha
+// Utilize "echo" ou "print" para imprimir a saída.
+print('Olá '); // Imprime "Olá " sem quebra de linha.
+print 'Olá '; // Não tem a necessidade de utilizar as chaves.
// () são opcionais para print e echo
-echo "Mundo\n"; // Imprime "Mundo" com quebra de linha
-// (Todas as declarações devem terminar com um ponto e vírgula)
+echo "Mundo\n"; // Imprime "Mundo" com quebra de linha.
+echo ("Mundo\n"); // Podemos tambem utilizar com chaves no echo.
+// (Todas as declarações devem terminar com um ponto e vírgula.)
-// Qualquer coisa fora da tag <?php é impresso automaticamente
+// Qualquer coisa fora da tag <?php é impresso automaticamente.
?>
Olá mundo novamente!
<?php
@@ -48,7 +50,7 @@ Olá mundo novamente!
// Um nome de variável válido se inicia com uma letra ou sublinhado,
// seguido por qualquer quantidade de letras, números ou sublinhados.
-// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive)
+// Valores booleanos não diferenciam maiúsculo de minúsculo (case-insensitive).
$boolean = true; // ou TRUE ou True
$boolean = false; // ou FALSE ou False
@@ -63,8 +65,8 @@ $float = 1.234;
$float = 1.2e3;
$float = 7E-10;
-// Excluir variável
-unset($int1)
+// Excluir variável.
+unset($int1);
// Aritmética
$soma = 1 + 1; // 2
@@ -79,17 +81,19 @@ echo $numero++; // Imprime 1 (incrementa após a avaliação)
echo ++$numero; // Imprime 3 (incrementa antes da avaliação)
$numero /= $float; // Divide e atribui o quociente de $numero
-// Strings podem ser colocadas entre aspas simples
+// Strings podem ser colocadas entre aspas simples.
$sgl_quotes = '$String'; // => '$String'
// Evite o uso de aspas duplas, exceto para incorporar outras variáveis
$dbl_quotes = "Esta é uma $sgl_quotes."; // => 'Esta é uma $String.'
-// Os caracteres especiais só são escapados entre aspas duplas
-$escapado = "Este contém um \t caractere tab.";
-$naoescapado = 'Este contém somente a barra e o t: \t';
+// Os caracteres especiais só são escapados entre aspas duplas.
+$escapado = "Este contém um \t caractere tab.";
+echo $escapado; //Imprime: Este contém um caractere tab.
+$naoescapado = 'Este contém somente a barra e o t: \t';
+echo $naoescapado; //Imprime: Este contém somente a barra e o t: \t
-// Coloque uma variável entre chaves se necessário
+// Coloque uma variável entre chaves se necessário.
$dinheiro = "Eu tenho $${numero} no banco.";
// Desde o PHP 5.3, nowdocs podem ser usados para múltiplas linhas sem análise
@@ -105,7 +109,7 @@ $sgl_quotes
FIM;
// Concatenação de string é feita com .
-echo 'Esta string ' . 'é concatenada';
+echo 'Esta string ' . 'é concatenada'; //Imprime: 'Esta string é concatenada'
/********************************
@@ -120,7 +124,7 @@ echo 'Esta string ' . 'é concatenada';
define("FOO", "alguma coisa");
// Acesso a uma constante é possível usando diretamente o nome escolhido
-echo 'Isto sairá '.FOO;
+echo 'Isto sairá '.FOO; //Imprime: Isto sairá alguma coisa
/********************************
@@ -135,16 +139,16 @@ $associativo = array('Um' => 1, 'Dois' => 2, 'Tres' => 3);
// PHP 5.4 introduziu uma nova sintaxe
$associativo = ['Um' => 1, 'Dois' => 2, 'Tres' => 3];
-echo $associativo['Um']; // imprime 1
+echo $associativo['Um']; // Imprime 1.
// Uma lista de literais atribui chaves inteiras implicitamente
$array = ['Um', 'Dois', 'Tres'];
-echo $array[0]; // => "Um"
+echo $array[0]; // Imprime => "Um"
// Adiciona um elemento no final do array
$array[] = 'Quatro';
-// Remove um elemento do array
+// Remove um elemento do array.
unset($array[3]);
/********************************
@@ -155,12 +159,12 @@ echo('Olá Mundo!');
// Imprime Olá Mundo! para stdout.
// Stdout é uma página web se executado em um navegador.
-print('Olá Mundo!'); // O mesmo que o echo
+print('Olá Mundo!'); // O mesmo que o echo.
// echo é atualmente um construtor de linguagem, então você pode
// remover os parênteses.
-echo 'Olá Mundo!';
-print 'Olá Mundo!'; // O print também é
+echo 'Olá Mundo!'; // Imprime: Olá Mundo!
+print 'Olá Mundo!'; // O print também é - Imprime: Olá Mundo!
$paragrafo = 'parágrafo';
@@ -181,11 +185,11 @@ $z = &$y;
// $z irá mudar o valor de $y também, e vice-versa.
// $x irá permanecer inalterado com o valor original de $y
-echo $x; // => 2
-echo $z; // => 2
+echo $x; // Imprime => 2
+echo $z; // Imprime => 2
$y = 0;
-echo $x; // => 2
-echo $z; // => 0
+echo $x; // Imprime => 2
+echo $z; // Imprime => 0
// Despeja tipos e valores de variável para o stdout
var_dump($z); // imprime int(0)
@@ -222,13 +226,13 @@ assert(1 !== '1');
// As variáveis podem ser convertidas entre tipos, dependendo da sua utilização.
$inteiro = 1;
-echo $inteiro + $inteiro; // => 2
+echo $inteiro + $inteiro; // Imprime => 2
$string = '1';
-echo $string + $string; // => 2 (strings são coagidas para inteiros)
+echo $string + $string; // Imprime => 2 (strings são coagidas para inteiros)
$string = 'one';
-echo $string + $string; // => 0
+echo $string + $string; // Imprime => 0
// Imprime 0 porque o operador + não pode fundir a string 'um' para um número
// Tipo de fundição pode ser utilizado para tratar uma variável
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
new file mode 100644
index 00000000..c5a3c020
--- /dev/null
+++ b/pt-br/python3-pt.html.markdown
@@ -0,0 +1,746 @@
+---
+language: python3
+contributors:
+ - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+ - ["Steven Basart", "http://github.com/xksteven"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+ - ["Zachary Ferguson", "http://github.com/zfergus2"]
+translators:
+ - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+language: pt-br
+filename: learnpython3-pt.py
+---
+
+Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
+das mais populares linguagens em existência. Eu fiquei morrendo de amor
+pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
+
+Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
+[@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
+[serviço de e-mail do google].
+
+Observação: Este artigo trata de Python 3 especificamente. Verifique
+[aqui](http://learnxinyminutes.com/docs/pt-br/python-pt/) se você pretende
+aprender o velho Python 2.7.
+
+```python
+
+# Comentários em uma única linha começam com uma cerquilha (também conhecido por sustenido).
+
+""" Strings de várias linhas podem ser escritas
+ usando três ", e são comumente usadas
+ como comentários.
+"""
+
+####################################################
+## 1. Tipos de dados primitivos e operadores
+####################################################
+
+# Você usa números normalmente
+3 # => 3
+
+# Matemática é como você espera que seja
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+
+# Números inteiros por padrão, exceto na divisão, que retorna número
+# de ponto flutuante (float).
+35 / 5 # => 7.0
+
+# O resultado da divisão inteira arredonda para baixo tanto para números
+# positivos como para negativos.
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # funciona em float também
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Quando você usa um float, o resultado é float.
+3 * 2.0 # => 6.0
+
+# operador módulo
+7 % 3 # => 1
+
+# Exponenciação (x**y, x elevado à potência y)
+2**4 # => 16
+
+# Determine a precedência usando parêntesis
+(1 + 3) * 2 # => 8
+
+# Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
+True
+False
+
+# negação lógica com not
+not True # => False
+not False # => True
+
+# Operadores lógicos
+# Observe que "and" e "or" são sensíveis a maiúsculas e minúsculas
+True and False # => False
+False or True # => True
+
+# Observe a utilização de operadores lógicos com números inteiros
+0 and 2 # => 0
+-5 or 0 # => -5
+0 == False # => True
+2 == True # => False
+1 == True # => True
+
+# Igualdade é ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Diferença é !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Mais comparações
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Comparações podem ser agrupadas
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# (operador 'is' e operador '==') is verifica se duas referenciam um
+# mesmo objeto, mas == verifica se as variáveis apontam para o
+# mesmo valor.
+a = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4]
+b = a # b referencia o que está referenciado por a
+b is a # => True, a e b referenciam o mesmo objeto
+b == a # => True, objetos a e b tem o mesmo conteúdo
+b = [1, 2, 3, 4] # Referência a uma nova lista, [1, 2, 3, 4]
+b is a # => False, a e b não referenciam o mesmo objeto
+b == a # => True, objetos a e b tem o mesmo conteúdo
+
+# Strings são criadas com " ou '
+"Isto é uma string."
+'Isto também é uma string.'
+
+# Strings também podem ser somadas! Mas tente não fazer isso.
+"Olá " + "mundo!" # => "Olá mundo!"
+# Strings podem ser somadas sem usar o '+'
+"Olá " "mundo!" # => "Olá mundo!"
+
+# Uma string pode ser manipulada como se fosse uma lista de caracteres
+"Isso é uma string"[0] # => 'I'
+
+# .format pode ser usado para formatar strings, dessa forma:
+"{} podem ser {}".format("Strings", "interpoladas") # => "Strings podem ser interpoladas"
+
+# Você pode repetir os argumentos para digitar menos.
+"Seja ágil {0}, seja rápido {0}, salte sobre o {1} {0}".format("Jack", "castiçal")
+# => "Seja ágil Jack, seja rápido Jack, salte sobre o castiçal Jack."
+
+# Você pode usar palavras-chave se quiser contar.
+"{nome} quer comer {comida}".format(nome="Beto", comida="lasanha") # => "Beto quer comer lasanha"
+
+# Se você precisa executar seu código Python3 com um interpretador Python 2.5 ou acima, você pode usar a velha forma para formatação de texto:
+"%s podem ser %s da forma %s" % ("Strings", "interpoladas", "antiga") # => "Strings podem ser interpoladas da forma antiga"
+
+
+# None é um objeto
+None # => None
+
+# Não use o operador de igualdade "==" para comparar objetos com None
+# Use "is" para isso. Ele checará pela identidade dos objetos.
+"etc" is None # => False
+None is None # => True
+
+# None, 0, e strings/listas/dicionários vazios todos retornam False.
+# Qualquer outra coisa retorna True
+bool(0) # => False
+bool("") # => False
+bool([]) # => False
+bool({}) # => False
+
+
+####################################################
+## 2. Variáveis e coleções
+####################################################
+
+# Python tem uma função print
+print("Eu sou o Python. Prazer em conhecer!") # => Eu sou o Python. Prazer em conhecer!
+
+# Por padrão a função print também imprime o caractere de nova linha ao final.
+# Use o argumento opcional end para mudar o caractere final.
+print("Olá, Mundo", end="!") # => Olá, Mundo!
+
+# Forma simples para capturar dados de entrada via console
+input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado em uma string
+# Observação: Em versões antigas do Python, o método input() era chamado raw_input()
+
+# Não é necessário declarar variáveis antes de iniciá-las
+# È uma convenção usar letras_minúsculas_com_sublinhados
+alguma_variavel = 5
+alguma_variavel # => 5
+
+# Acessar uma variável que não tenha sido inicializada gera uma exceção.
+# Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
+alguma_variavel_nao_inicializada # Gera a exceção NameError
+
+# Listas armazenam sequencias
+li = []
+# Você pode iniciar com uma lista com alguns valores
+outra_li = [4, 5, 6]
+
+# Adicionar conteúdo ao fim da lista com append
+li.append(1) # li agora é [1]
+li.append(2) # li agora é [1, 2]
+li.append(4) # li agora é [1, 2, 4]
+li.append(3) # li agora é [1, 2, 4, 3]
+# Remover do final da lista com pop
+li.pop() # => 3 e agora li é [1, 2, 4]
+# Vamos colocá-lo lá novamente!
+li.append(3) # li agora é [1, 2, 4, 3] novamente.
+
+# Acessar uma lista da mesma forma que você faz com um array
+li[0] # => 1
+# Acessa o último elemento
+li[-1] # => 3
+
+# Acessando além dos limites gera um IndexError
+li[4] # Gera o IndexError
+
+# Você pode acessar vários elementos com a sintaxe de limites
+# (É um limite fechado, aberto pra você que gosta de matemática.)
+li[1:3] # => [2, 4]
+# Omitindo o final
+li[2:] # => [4, 3]
+# Omitindo o início
+li[:3] # => [1, 2, 4]
+# Selecione cada segunda entrada
+li[::2] # => [1, 4]
+# Tenha uma cópia em ordem invertida da lista
+li[::-1] # => [3, 4, 2, 1]
+# Use qualquer combinação dessas para indicar limites complexos
+# li[inicio:fim:passo]
+
+# Faça uma cópia profunda de um nível usando limites
+li2 = li[:] # => li2 = [1, 2, 4, 3] mas (li2 is li) resultará em False.
+
+# Apague elementos específicos da lista com "del"
+del li[2] # li agora é [1, 2, 3]
+
+# Você pode somar listas
+# Observação: valores em li e other_li não são modificados.
+li + other_li # => [1, 2, 3, 4, 5, 6]
+
+# Concatene listas com "extend()"
+li.extend(other_li) # Agora li é [1, 2, 3, 4, 5, 6]
+
+# Verifique se algo existe na lista com "in"
+1 in li # => True
+
+# Examine tamanho com "len()"
+len(li) # => 6
+
+
+# Tuplas são como l istas, mas imutáveis.
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # Gera um TypeError
+
+# Observe que uma tupla de tamanho um precisa ter uma vírgula depois do
+# último elemento mas tuplas de outros tamanhos, mesmo vazias, não precisa,.
+type((1)) # => <class 'int'>
+type((1,)) # => <class 'tuple'>
+type(()) # => <class 'tuple'>
+
+# Você pode realizar com tuplas a maior parte das operações que faz com listas
+len(tup) # => 3
+tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
+tup[:2] # => (1, 2)
+2 in tup # => True
+
+# Você pode desmembrar tuplas (ou listas) em variáveis.
+a, b, c = (1, 2, 3) # a é 1, b é 2 e c é 3
+# Por padrão, tuplas são criadas se você não coloca parêntesis.
+d, e, f = 4, 5, 6
+# Veja como é fácil permutar dois valores
+e, d = d, e # d é 5, e é 4
+
+# Dicionários armazenam mapeamentos
+empty_dict = {}
+# Aqui está um dicionário preenchido na definição da referência
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+
+# Observe que chaves para dicionários devem ser tipos imutáveis. Isto é para
+# assegurar que a chave pode ser convertida para uma valor hash constante para
+# buscas rápidas.
+# Tipos imutáveis incluem inteiros, flotas, strings e tuplas.
+invalid_dict = {[1,2,3]: "123"} # => Gera um TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]} # Já os valores, podem ser de qualquer tipo.
+
+# Acesse valores com []
+filled_dict["um"] # => 1
+
+# Acesse todas as chaves como um iterável com "keys()". É necessário encapsular
+# a chamada com um list() para transformá-las em uma lista. Falaremos sobre isso
+# mais adiante. Observe que a ordem de uma chave de dicionário não é garantida.
+# Por isso, os resultados aqui apresentados podem não ser exatamente como os
+# aqui apresentados.
+list(filled_dict.keys()) # => ["três", "dois", "um"]
+
+
+# Acesse todos os valores de um iterável com "values()". Novamente, é
+# necessário encapsular ele com list() para não termos um iterável, e sim os
+# valores. Observe que, como foi dito acima, a ordem dos elementos não é
+# garantida.
+list(filled_dict.values()) # => [3, 2, 1]
+
+
+# Verifique a existência de chaves em um dicionário com "in"
+"um" in filled_dict # => True
+1 in filled_dict # => False
+
+# Acessar uma chave inexistente gera um KeyError
+filled_dict["quatro"] # KeyError
+
+# Use o método "get()" para evitar um KeyError
+filled_dict.get("um") # => 1
+filled_dict.get("quatro") # => None
+# O método get permite um parâmetro padrão para quando não existir a chave
+filled_dict.get("um", 4) # => 1
+filled_dict.get("quatro", 4) # => 4
+
+# "setdefault()" insere em dicionário apenas se a dada chave não existir
+filled_dict.setdefault("cinco", 5) # filled_dict["cinco"] tem valor 5
+filled_dict.setdefault("cinco", 6) # filled_dict["cinco"] continua 5
+
+# Inserindo em um dicionário
+filled_dict.update({"quatro":4}) # => {"um": 1, "dois": 2, "três": 3, "quatro": 4}
+#filled_dict["quatro"] = 4 #outra forma de inserir em um dicionário
+
+# Remova chaves de um dicionário com del
+del filled_dict["um"] # Remove a chave "um" de filled_dict
+
+
+# Armazenamento em sets... bem, são conjuntos
+empty_set = set()
+# Inicializa um set com alguns valores. Sim, ele parece um dicionário. Desculpe.
+some_set = {1, 1, 2, 2, 3, 4} # some_set agora é {1, 2, 3, 4}
+
+# Da mesma forma que chaves em um dicionário, elementos de um set devem ser
+# imutáveis.
+invalid_set = {[1], 1} # => Gera um TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# Pode definir novas variáveis para um conjunto
+filled_set = some_set
+
+# Inclua mais um item no set
+filled_set.add(5) # filled_set agora é {1, 2, 3, 4, 5}
+
+# Faça interseção de conjuntos com &
+other_set = {3, 4, 5, 6}
+filled_set & other_set # => {3, 4, 5}
+
+# Faça união de conjuntos com |
+filled_set | other_set # => {1, 2, 3, 4, 5, 6}
+
+# Faça a diferença entre conjuntos com -
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Verifique a existência em um conjunto com in
+2 in filled_set # => True
+10 in filled_set # => False
+
+
+
+####################################################
+## 3. Controle de fluxo e iteráveis
+####################################################
+
+# Iniciemos um variável
+some_var = 5
+
+# Aqui está uma expressão if. Indentação é significante em python!
+# imprime "somevar é menor que10"
+if some_var > 10:
+ print("some_var é absolutamente maior que 10.")
+elif some_var < 10: # Esta cláusula elif é opcional.
+ print("some_var é menor que 10.")
+else: # Isto também é opcional.
+ print("some_var é, de fato, 10.")
+
+
+"""
+Laços for iteram sobre listas
+imprime:
+ cachorro é um mamífero
+ gato é um mamífero
+ rato é um mamífero
+"""
+for animal in ["cachorro", "gato", "rato"]:
+ # Você pode usar format() para interpolar strings formatadas
+ print("{} é um mamífero".format(animal))
+
+"""
+"range(número)" retorna um iterável de números
+de zero até o número escolhido
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+"range(menor, maior)" gera um iterável de números
+começando pelo menor até o maior
+imprime:
+ 4
+ 5
+ 6
+ 7
+"""
+for i in range(4, 8):
+ print(i)
+
+"""
+"range(menor, maior, passo)" retorna um iterável de números
+começando pelo menor número até o maior númeno, pulando de
+passo em passo. Se o passo não for indicado, o valor padrão é um.
+imprime:
+ 4
+ 6
+"""
+for i in range(4, 8, 2):
+ print(i)
+"""
+
+Laços while executam até que a condição não seja mais válida.
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Maneira mais curta para for x = x + 1
+
+# Lide com exceções com um bloco try/except
+try:
+ # Use "raise" para gerar um erro
+ raise IndexError("Isto é um erro de índice")
+except IndexError as e:
+ pass # Pass é um não-operador. Normalmente você usa algum código de recuperação aqui.
+except (TypeError, NameError):
+ pass # Varias exceções podem ser gerenciadas, se necessário.
+else: # Cláusula opcional para o bloco try/except. Deve estar após todos os blocos de exceção.
+ print("Tudo certo!") # Executa apenas se o código em try não gera exceção
+finally: # Sempre é executado
+ print("Nós podemos fazer o código de limpeza aqui.")
+
+# Ao invés de try/finally para limpeza você pode usar a cláusula with
+with open("myfile.txt") as f:
+ for line in f:
+ print(line)
+
+# Python provê uma abstração fundamental chamada Iterável.
+# Um iterável é um objeto que pode ser tratado como uma sequência.
+# O objeto retornou a função range, um iterável.
+
+filled_dict = {"um": 1, "dois": 2, "três": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) # => range(1,10). Esse é um objeto que implementa nossa interface iterável.
+
+# Nós podemos percorrê-la.
+for i in our_iterable:
+ print(i) # Imprime um, dois, três
+
+# Mas não podemos acessar os elementos pelo seu índice.
+our_iterable[1] # Gera um TypeError
+
+# Um iterável é um objeto que sabe como criar um iterador.
+our_iterator = iter(our_iterable)
+
+# Nosso iterador é um objeto que pode lembrar o estado enquanto nós o percorremos.
+# Nós acessamos o próximo objeto com "next()".
+next(our_iterator) # => "um"
+
+# Ele mantém o estado enquanto nós o percorremos.
+next(our_iterator) # => "dois"
+next(our_iterator) # => "três"
+
+# Após o iterador retornar todos os seus dados, ele gera a exceção StopIterator
+next(our_iterator) # Gera StopIteration
+
+# Você pode capturar todos os elementos de um iterador aplicando list() nele.
+list(filled_dict.keys()) # => Retorna ["um", "dois", "três"]
+
+
+####################################################
+## 4. Funções
+####################################################
+
+# Use "def" para criar novas funções.
+def add(x, y):
+ print("x é {} e y é {}".format(x, y))
+ return x + y # Retorne valores com a cláusula return
+
+# Chamando funções com parâmetros
+add(5, 6) # => imprime "x é 5 e y é 6" e retorna 11
+
+# Outro meio de chamar funções é com argumentos nomeados
+add(y=6, x=5) # Argumentos nomeados podem aparecer em qualquer ordem.
+
+# Você pode definir funções que pegam um número variável de argumentos
+# posicionais
+def varargs(*args):
+ return args
+
+varargs(1, 2, 3) # => (1, 2, 3)
+
+# Você pode definir funções que pegam um número variável de argumentos nomeados
+# também
+def keyword_args(**kwargs):
+ return kwargs
+
+# Vamos chamá-lo para ver o que acontece
+keyword_args(peh="grande", lago="ness") # => {"peh": "grande", "lago": "ness"}
+
+
+# Você pode fazer ambos simultaneamente, se você quiser
+def all_the_args(*args, **kwargs):
+ print(args)
+ print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) imprime:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# Quando chamar funções, você pode fazer o oposto de args/kwargs!
+# Use * para expandir tuplas e use ** para expandir dicionários!
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # equivalente a foo(1, 2, 3, 4)
+all_the_args(**kwargs) # equivalente a foo(a=3, b=4)
+all_the_args(*args, **kwargs) # equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Retornando múltiplos valores (com atribuição de tuplas)
+def swap(x, y):
+ return y, x # Retorna múltiplos valores como uma tupla sem os parêntesis.
+ # (Observação: os parêntesis foram excluídos mas podem estar
+ # presentes)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Novamente, os parêntesis foram excluídos mas podem estar presentes.
+
+# Escopo de função
+x = 5
+
+def setX(num):
+ # A variável local x não é a mesma variável global x
+ x = num # => 43
+ print (x) # => 43
+
+def setGlobalX(num):
+ global x
+ print (x) # => 5
+ x = num # variável global x agora é 6
+ print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python tem funções de primeira classe
+def create_adder(x):
+ def adder(y):
+ return x + y
+ return adder
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+# Também existem as funções anônimas
+(lambda x: x > 2)(3) # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
+
+# TODO - Fix for iterables
+# Existem funções internas de alta ordem
+map(add_10, [1, 2, 3]) # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Nós podemos usar compreensão de lista para interessantes mapas e filtros
+# Compreensão de lista armazena a saída como uma lista que pode ser uma lista
+# aninhada
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# Nós usamos o operador "class" para ter uma classe
+class Human:
+
+ # Um atributo de classe. Ele é compartilhado por todas as instâncias dessa
+ # classe.
+ species = "H. sapiens"
+
+ # Construtor básico, é chamado quando esta classe é instanciada.
+ # Note que dois sublinhados no início e no final de uma identificados
+ # significa objetos ou atributos que são usados pelo python mas vivem em
+ # um namespace controlado pelo usuário. Métodos (ou objetos ou atributos)
+ # como: __init__, __str__, __repr__, etc. são chamados métodos mágicos (ou
+ # algumas vezes chamados métodos dunder - "double underscore")
+ # Você não deve usar nomes assim por sua vontade.
+ def __init__(self, name):
+ @ Atribui o argumento ao atributo da instância
+ self.name = name
+
+ # Um método de instância. Todos os métodos tem "self" como primeiro
+ # argumento
+ def say(self, msg):
+ return "{name}: {message}".format(name=self.name, message=msg)
+
+ # Um método de classe é compartilhado por todas as instâncias
+ # Eles são chamados com a classe requisitante como primeiro argumento
+ @classmethod
+ def get_species(cls):
+ return cls.species
+
+ # Um método estático é chamado sem uma referência a classe ou instância
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Instancie uma classe
+i = Human(name="Ian")
+print(i.say("oi")) # imprime "Ian: oi"
+
+j = Human("Joel")
+print(j.say("olá")) # imprime "Joel: olá"
+
+# Chama nosso método de classe
+i.get_species() # => "H. sapiens"
+
+# Altera um atributo compartilhado
+Human.species = "H. neanderthalensis"
+i.get_species() # => "H. neanderthalensis"
+j.get_species() # => "H. neanderthalensis"
+
+# Chama o método estático
+Human.grunt() # => "*grunt*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Você pode importar módulos
+import math
+print(math.sqrt(16)) # => 4
+
+# Você pode importar apenas funções específicas de um módulo
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Você pode importar todas as funções de um módulo para o namespace atual
+# Atenção: isso não é recomendado
+from math import *
+
+# Você pode encurtar o nome dos módulos
+import math as m
+math.sqrt(16) == m.sqrt(16) # => True
+
+# Módulos python são apenas arquivos python comuns. Você
+# pode escrever os seus, e importá-los. O nome do
+# módulo é o mesmo nome do arquivo.
+
+# Você pode procurar que atributos e funções definem um módulo.
+import math
+dir(math)
+
+
+####################################################
+## 7. Avançado
+####################################################
+
+# Geradores podem ajudar você a escrever código "preguiçoso"
+def double_numbers(iterable):
+ for i in iterable:
+ yield i + i
+
+# Um gerador cria valores conforme necessário.
+# Ao invés de gerar e retornar todos os valores de uma só vez ele cria um em
+# cada interação. Isto significa que valores maiores que 15 não serão
+# processados em double_numbers.
+# Nós usamos um sublinhado ao final do nome das variáveis quando queremos usar
+# um nome que normalmente colide com uma palavra reservada do python.
+range_ = range(1, 900000000)
+# Multiplica por 2 todos os números até encontrar um resultado >= 30
+for i in double_numbers(range_):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Decoradores
+# Neste exemplo beg encapsula say
+# beg irá chamar say. Se say_please é verdade então ele irá mudar a mensagem
+# retornada
+from functools import wraps
+
+
+def beg(target_function):
+ @wraps(target_function)
+ def wrapper(*args, **kwargs):
+ msg, say_please = target_function(*args, **kwargs)
+ if say_please:
+ return "{} {}".format(msg, "Por favor! Eu sou pobre :(")
+ return msg
+
+ return wrapper
+
+
+@beg
+def say(say_please=False):
+ msg = "Você me paga uma cerveja?"
+ return msg, say_please
+
+
+print(say()) # Você me paga uma cerveja?
+print(say(say_please=True)) # Você me paga uma cerveja? Por favor! Eu sou pobre :(
+```
+
+## Pronto para mais?
+
+### Free Online
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+* [A curated list of awesome Python frameworks, libraries and software](https://github.com/vinta/awesome-python)
+* [30 Python Language Features and Tricks You May Not Know About](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [Official Style Guide for Python](https://www.python.org/dev/peps/pep-0008/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 668cd25f..eeb51bec 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -101,7 +101,7 @@ caminho_para_a_raiz_do_projeto = '/bom/nome/'
caminho = '/nome/ruim/'
# Símbolos (são objetos)
-# Símbolos são imutáveis, são constantes reutilizáveis representadadas
+# Símbolos são imutáveis, são constantes reutilizáveis representados
# internamente por um valor inteiro. Eles são frequentemente usados no
# lugar de strings para transmitir com eficiência os valores específicos
# e significativos
@@ -260,7 +260,7 @@ somar 3, 4 #=> 7
somar(3,4), 5 #=> 12
# yield
-# Todos os métodos possuem implicitamente um paramêntro opcional que é um bloco
+# Todos os métodos possuem implicitamente um paramêtro opcional que é um bloco
# ele pode ser chamado com a palavra chave 'yield'
def ao_redor
@@ -285,7 +285,7 @@ class Humano
# Inicialização básica (contructor)
def initialize(nome, idade=0)
- # Atribui o argumento para a variável de instancia "nome" do objeto
+ # Atribui o argumento para a variável de instância "nome" do objeto
@nome = nome
# Se a idade não for passada, nós definimos um valor padrão na lista de argumentos
@idade = idade
@@ -301,7 +301,7 @@ class Humano
@nome
end
- # Um método de classe usa a palavra chave self para se defenciar dos métodos de instância.
+ # Um método de classe usa a palavra chave self para se diferenciar dos métodos de instância.
# Ele só pode ser chamado na classe, não na instancia
def self.diz(msg)
puts "#{msg}"
@@ -362,7 +362,7 @@ Trabalhador.foo # 0
Humano.foo = 2 # 2
Trabalhador.foo # 2
-# Uma variável de instância não é compartilhada por suas classes decendentes.
+# Uma variável de instância não é compartilhada por suas classes descendentes.
class Humano
@bar = 0
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
new file mode 100644
index 00000000..f072b257
--- /dev/null
+++ b/pt-br/typescript-pt.html.markdown
@@ -0,0 +1,179 @@
+---
+language: TypeScript
+filename: learntypescript-pt.ts
+contributors:
+ - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+ - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+lang: pt-br
+---
+
+TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
+TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
+It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
+
+This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
+
+
+Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
+Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+
+Este artigo irá se concentrar apenas em texto datilografado sintaxe extra, ao contrário de [JavaScript](javascript-pt.html.markdown).
+
+Para testar compilador do texto datilografado, de cabeça para o [Parque](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitida.
+
+```js
+// Existem 3 tipos básicos no TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Quando é impossível saber, há o "Qualquer" tipo
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // Ok, definitivamente um boolean
+
+// Para coleções, não são matrizes e matrizes genéricas digitado
+var list: number[] = [1, 2, 3];
+// Como alternativa, usando o tipo de matriz genérica
+var list: Array<number> = [1, 2, 3];
+
+// Para enumerações:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Por último, "vazio" é utilizado no caso especial de uma função que não retorna nada
+function bigHorribleAlert(): void {
+ alert("I'm a little annoying box!");
+}
+
+// Funções são cidadãos de primeira classe, apoiar a sintaxe lambda "seta gordura" e
+// Tipo de uso inferência
+
+// A seguir são equivalentes, a mesma assinatura será inferido pelo
+// Compilador, e mesmo JavaScript será emitido
+var f1 = function(i: number): number { return i * i; }
+// Tipo de retorno inferida
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Tipo de retorno inferida
+var f4 = (i: number) => { return i * i; }
+// Tipo de retorno inferido, one-liner significa nenhuma palavra-chave retorno necessário
+var f5 = (i: number) => i * i;
+
+// Interfaces são estruturais, qualquer coisa que tenha as propriedades é compatível com
+// A interface
+interface Person {
+ name: string;
+ // Propriedades opcionais, marcado com um "?"
+ age?: number;
+ // E de funções curso
+ move(): void;
+}
+
+// Objeto que implementa a "Pessoa" Interface
+// Pode ser tratado como uma pessoa desde que tem o nome e mover propriedades
+var p: Person = { name: "Bobby", move: () => {} };
+// Os objetos que têm a propriedade opcional:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Não é uma pessoa porque a idade não é um número
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interfaces também pode descrever um tipo de função
+interface SearchFunc {
+ (source: string, subString: string): boolean;
+}
+// Somente tipos dos parâmetros são importantes, os nomes não são importantes.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+ return src.search(sub) != -1;
+}
+
+// Classes - membros são públicos por padrão
+class Point {
+ // Propriedades
+ x: number;
+
+ // Construtor - the public/private keywords in this context will generate
+ // o código clichê para a propriedade e a inicialização no
+ // construtor.
+ // Neste exemplo, "y" será definida como "X" é, mas com menos código
+ // Os valores padrão também são suportados.
+
+ constructor(x: number, public y: number = 0) {
+ this.x = x;
+ }
+
+ // Funções
+ dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+ // Membros Estáticos
+ static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y será 0
+
+// Herança
+class Point3D extends Point {
+ constructor(x: number, y: number, public z: number = 0) {
+ super(x, y); // Chamada explícita para o construtor da super classe é obrigatória
+ }
+
+ // Sobrescrever
+ dist() {
+ var d = super.dist();
+ return Math.sqrt(d * d + this.z * this.z);
+ }
+}
+
+// Módulos, "." pode ser utilizado como separador de sub módulos
+module Geometry {
+ export class Square {
+ constructor(public sideLength: number = 0) {
+ }
+ area() {
+ return Math.pow(this.sideLength, 2);
+ }
+ }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Alias no local para fazer referência a um módulo
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Genericos
+// Classes
+class Tuple<T1, T2> {
+ constructor(public item1: T1, public item2: T2) {
+ }
+}
+
+// Interfaces
+interface Pair<T> {
+ item1: T;
+ item2: T;
+}
+
+// e funções
+var pairToTuple = function<T>(p: Pair<T>) {
+ return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Incluindo referências a um arquivo de definição:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Leitura adicional
+ * [TypeScript site oficial](http://www.typescriptlang.org/)
+ * [TypeScript especificações de idioma (pdf)](http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Apresentando texto datilografado no Canal 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Código fonte no GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitivamente datilografado - repositório de definições de tipo](http://definitelytyped.org/)