summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--c++.html.markdown24
-rw-r--r--cobol.html.markdown4
-rw-r--r--fr-fr/markdown-fr.html.markdown34
-rw-r--r--latex.html.markdown2
-rw-r--r--pt-br/awk-pt.html.markdown4
-rw-r--r--pt-br/bash-pt.html.markdown8
-rw-r--r--pt-br/css-pt.html.markdown10
-rw-r--r--pt-br/elixir-pt.html.markdown2
-rw-r--r--pt-br/fsharp-pt.html.markdown639
-rw-r--r--pt-br/groovy-pt.html.markdown14
-rw-r--r--pt-br/julia-pt.html.markdown2
-rw-r--r--pt-br/kotlin-pt.html.markdown4
-rw-r--r--pt-br/matlab-pt.html.markdown2
-rw-r--r--pt-br/self-pt.html.markdown2
-rw-r--r--pt-br/typescript-pt.html.markdown16
-rw-r--r--python.html.markdown5
-rw-r--r--rst.html.markdown12
-rw-r--r--ru-ru/python-ru.html.markdown963
-rw-r--r--set-theory.html.markdown2
-rw-r--r--smalltalk.html.markdown4
-rw-r--r--sql.html.markdown2
-rw-r--r--tr-tr/jquery-tr.html.markdown338
-rw-r--r--tr-tr/ruby-tr.html.markdown1598
-rw-r--r--zh-cn/haskell-cn.html.markdown2
24 files changed, 3337 insertions, 356 deletions
diff --git a/c++.html.markdown b/c++.html.markdown
index 59aad210..948b52ec 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -199,7 +199,7 @@ int main()
cin >> myInt;
// cout can also be formatted
- cout << "Your favorite number is " << myInt << "\n";
+ cout << "Your favorite number is " << myInt << '\n';
// prints "Your favorite number is <myInt>"
cerr << "Used for error messages";
@@ -461,7 +461,7 @@ void Dog::print() const
Dog::~Dog()
{
- std::cout << "Goodbye " << name << "\n";
+ std::cout << "Goodbye " << name << '\n';
}
int main() {
@@ -504,7 +504,7 @@ void OwnedDog::setOwner(const std::string& dogsOwner)
void OwnedDog::print() const
{
Dog::print(); // Call the print function in the base Dog class
- std::cout << "Dog is owned by " << owner << "\n";
+ std::cout << "Dog is owned by " << owner << '\n';
// Prints "Dog is <name> and weights <weight>"
// "Dog is owned by <owner>"
}
@@ -915,7 +915,7 @@ ST.erase(20); // Will erase element with value 20
// Set ST: 10 30
// To iterate through Set we use iterators
set<int>::iterator it;
-for(it=ST.begin();it<ST.end();it++) {
+for(it=ST.begin();it!=ST.end();it++) {
cout << *it << endl;
}
// Output:
@@ -946,7 +946,7 @@ mymap.insert(pair<char,int>('Z',26));
// To iterate
map<char,int>::iterator it;
for (it=mymap.begin(); it!=mymap.end(); ++it)
- std::cout << it->first << "->" << it->second << '\n';
+ std::cout << it->first << "->" << it->second << std::cout;
// Output:
// A->1
// Z->26
@@ -1117,33 +1117,33 @@ const int maxL = 15;
auto second = make_tuple(maxN, maxL);
// Printing elements of 'first' tuple
-cout << get<0>(first) << " " << get<1>(first) << "\n"; //prints : 10 A
+cout << get<0>(first) << " " << get<1>(first) << '\n'; //prints : 10 A
// Printing elements of 'second' tuple
-cout << get<0>(second) << " " << get<1>(second) << "\n"; // prints: 1000000000 15
+cout << get<0>(second) << " " << get<1>(second) << '\n'; // prints: 1000000000 15
// Unpacking tuple into variables
int first_int;
char first_char;
tie(first_int, first_char) = first;
-cout << first_int << " " << first_char << "\n"; // prints : 10 A
+cout << first_int << " " << first_char << '\n'; // prints : 10 A
// We can also create tuple like this.
tuple<int, char, double> third(11, 'A', 3.14141);
// tuple_size returns number of elements in a tuple (as a constexpr)
-cout << tuple_size<decltype(third)>::value << "\n"; // prints: 3
+cout << tuple_size<decltype(third)>::value << '\n'; // prints: 3
// tuple_cat concatenates the elements of all the tuples in the same order.
auto concatenated_tuple = tuple_cat(first, second, third);
// concatenated_tuple becomes = (10, 'A', 1e9, 15, 11, 'A', 3.14141)
-cout << get<0>(concatenated_tuple) << "\n"; // prints: 10
-cout << get<3>(concatenated_tuple) << "\n"; // prints: 15
-cout << get<5>(concatenated_tuple) << "\n"; // prints: 'A'
+cout << get<0>(concatenated_tuple) << '\n'; // prints: 10
+cout << get<3>(concatenated_tuple) << '\n'; // prints: 15
+cout << get<5>(concatenated_tuple) << '\n'; // prints: 'A'
///////////////////////////////////
diff --git a/cobol.html.markdown b/cobol.html.markdown
index 7d94d8c9..22fcb6e0 100644
--- a/cobol.html.markdown
+++ b/cobol.html.markdown
@@ -29,7 +29,7 @@ organizations.
*COBOL code is broken up into 4 divisions.
*Those divisions, in order, are:
- *IDENTIFICATION DIVSION.
+ *IDENTIFICATION DIVISION.
*ENVIRONMENT DIVISION.
*DATA DIVISION.
*PROCEDURE DIVISION.
@@ -75,7 +75,7 @@ organizations.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 THE-MESSAGE PIC X(20).
- PROCEDURE DIVSION.
+ PROCEDURE DIVISION.
DISPLAY "STARTING PROGRAM".
MOVE "HELLO WORLD" TO THE-MESSAGE.
DISPLAY THE-MESSAGE.
diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 26c2546a..1fd22883 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -178,8 +178,8 @@ Vous pouvez également utiliser des sous-listes.
1. Item un
2. Item deux
3. Item trois
-* Sub-item
-* Sub-item
+ * Sub-item
+ * Sub-item
4. Item quatre
```
@@ -230,7 +230,7 @@ En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
```
Pas besoin d'indentation pour le code juste au-dessus, de plus, GitHub
-va utiliser une coloration syntaxique pour le langage indiqué après les ```.
+va utiliser une coloration syntaxique pour le langage indiqué après les <code>```</code>.
## Ligne Horizontale
@@ -267,13 +267,13 @@ Markdown supporte aussi les liens relatifs.
Les liens de références sont eux aussi disponibles en Markdown.
-```md
-[Cliquez ici][link1] pour plus d'information!
-[Regardez aussi par ici][foobar] si vous voulez.
+<div class="highlight"><code><pre>
+[<span class="nv">Cliquez ici</span>][<span class="ss">link1</span>] pour plus d'information!
+[<span class="nv">Regardez aussi par ici</span>][<span class="ss">foobar</span>] si vous voulez.
-[link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Génial!"
-```
+[<span class="nv">link1</span>]: <span class="sx">http://test.com/</span> <span class="nn">"Cool!"</span>
+[<span class="nv">foobar</span>]: <span class="sx">http://foobar.biz/</span> <span class="nn">"Génial!"</span>
+</pre></code></div>
Le titre peut aussi être entouré de guillemets simples, ou de parenthèses, ou
absent. Les références peuvent être placées où vous voulez dans le document et
@@ -282,11 +282,11 @@ les identifiants peuvent être n'importe quoi tant qu'ils sont uniques.
Il y a également le nommage implicite qui transforme le texte du lien en
identifiant.
-```md
-[Ceci][] est un lien.
+<div class="highlight"><code><pre>
+[<span class="nv">Ceci</span>][] est un lien.
-[ceci]: http://ceciestunlien.com/
-```
+[<span class="nv">Ceci</span>]:<span class="sx">http://ceciestunlien.com/</span>
+</pre></code></div>
Mais ce n'est pas beaucoup utilisé.
@@ -302,11 +302,11 @@ d'un point d'exclamation!
Là aussi, on peut utiliser le mode "références".
-```md
-![Ceci est l'attribut ALT de l'image][monimage]
+<div class="highlight"><code><pre>
+![<span class="nv">Ceci est l'attribut ALT de l'image</span>][<span class="ss">monimage</span>]
-[monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
-```
+[<span class="nv">monimage</span>]: <span class="sx">relative/urls/cool/image.jpg</span> <span class="nn">"si vous voulez un titre, c'est ici."</span>
+</pre></code></div>
## Divers
diff --git a/latex.html.markdown b/latex.html.markdown
index e8bc6064..49200968 100644
--- a/latex.html.markdown
+++ b/latex.html.markdown
@@ -123,7 +123,7 @@ Math has many symbols, far beyond what you can find on a keyboard;
Set and relation symbols, arrows, operators, and Greek letters to name a few.
Sets and relations play a vital role in many mathematical research papers.
-Here's how you state all x that belong to X, $\forall$ x $\in$ X.
+Here's how you state all x that belong to X, $\forall x \in X$.
% Notice how I needed to add $ signs before and after the symbols. This is
% because when writing, we are in text-mode.
% However, the math symbols only exist in math-mode.
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 9bf770fd..70d0a01c 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -317,8 +317,8 @@ a > 0 {
# Aqui está um exemplo rápido de um script simples, o tipo de coisa que o AWK
# é perfeito para fazer. Ele irá ler um nome da entrada padrão e depois
-imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
-forneça como argumento o nome de um arquivo com esses dados:
+# imprimirá a média de idade de todos com esse primeiro nome. Digamos que você
+# forneça como argumento o nome de um arquivo com esses dados:
# Bob Jones 32
# Jane Doe 22
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index 86d1a8ea..988e8e7d 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -47,7 +47,7 @@ Variavel = "Alguma string"
# Ou assim:
Variavel= 'Alguma string'
# Bash interpretará 'Alguma string' como um comando e tentará executar e lhe retornará
-# um erro porque o comando não pode ser encontrado. (Nesse caso a a parte 'Variavel='
+# um erro porque o comando não pôde ser encontrado. (Nesse caso a a parte 'Variavel='
# é vista com uma declaração de variável válida apenas para o escopo do comando 'Uma string').
# Usando a variável:
@@ -73,7 +73,7 @@ echo ${Foo:-"ValorPadraoSeFooNaoExistirOuEstiverVazia"}
# Note que isso apenas retornará o valor padrão e não mudará o valor da variável.
# Variáveis internas
-# Tem algumas variáveis internas bem uteis, como
+# Tem algumas variáveis internas bem úteis, como
echo "O ultimo retorno do programa: $?"
echo "PID do script: $$"
echo "Numero de argumentos passados para o script $#"
@@ -165,7 +165,7 @@ echo "#helloworld" | tee output.out > /dev/null
rm -v output.out error.err output-and-error.log
# 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
+# O comando a seguir mostra o número de arquivos e diretórios no diretório atual
echo "Existem $(ls | wc -l) itens aqui."
# O mesmo pode ser feito usando crase `` mas elas não podem ser aninhadas - dá se
@@ -248,7 +248,7 @@ sed -i 's/okay/legal/g' file.txt
# exibe para o stdout todas as linhas do arquivo.txt que encaixam com o regex
# O exemplo exibe linhas que começam com "foo" e terminam com "bar"
grep "^foo.*bar$" arquivo.txt
-# passe a opção "-c" para ao invês de imprimir o numero da linha que bate com o regex
+# passe a opção "-c" para ao invés de imprimir o número da linha que bate com o regex
grep -c "^foo.*bar$" arquivo.txt
# se você quer literalmente procurar por uma string,
# e não pelo regex, use fgrep (ou grep -F)
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index 38937894..e6dea5b8 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -14,7 +14,7 @@ translators:
lang: pt-br
---
-No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornara comum.
+No início da web não havia elementos visuais, apenas texto puro. Mas com maior desenvolvimento de navegadores da web, páginas web totalmente visuais também se tornaram comuns.
CSS ajuda a manter a separação entre o conteúdo (HTML) e o visual de uma página web.
@@ -130,7 +130,7 @@ seletor::after {}
   os elementos */
* {} /* */ Todos os elementos
.parent * {} /* */ todos os descendentes
-.parent> * {} /* */ todas as crianças
+.parent> * {} /* */ todos os filhos
/* ####################
   ## PROPRIEDADES
@@ -141,7 +141,7 @@ seletor {
    /* Unidades de comprimento pode ser absoluta ou relativa. */
    /* Unidades relativas */
-    width: 50%; /* Percentagem de largura elemento pai */
+    width: 50%; /* Percentagem de largura do elemento pai */
    font-size: 2em; /* Múltiplos de font-size original de elemento */
    font-size: 2rem; /* Ou do elemento raiz font-size */
    font-size: 2vw; /* Múltiplos de 1% da largura da janela de exibição (CSS 3) */
@@ -200,7 +200,7 @@ Salvar uma folha de estilo CSS com a extensão `.css`.
## Precedência ou Cascata
-Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre os outros. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
+Um elemento pode ser alvo de vários seletores e pode ter um conjunto de propriedades em que mais de uma vez. Nestes casos, uma das regras tem precedência sobre as outras. Geralmente, uma regra em um seletor mais específico têm precedência sobre um menos específico, e uma regra que ocorre mais tarde na folha de estilo substitui uma anterior.
Este processo é chamado de cascata, portanto, as Fichas de nome de estilo em cascata.
@@ -279,7 +279,7 @@ Muitos smartphones e tablets tentarão renderizar a página como se estivesse nu
## Compatibilidade
-A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
+A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática verificar antes de usar um novo recurso.
## Recursos
diff --git a/pt-br/elixir-pt.html.markdown b/pt-br/elixir-pt.html.markdown
index f8c56101..4ba78f52 100644
--- a/pt-br/elixir-pt.html.markdown
+++ b/pt-br/elixir-pt.html.markdown
@@ -40,7 +40,7 @@ e muitos outros recursos.
# 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`:
+# Podemos acessar um elemento de uma tupla com a função `elem`:
elem({1, 2, 3}, 0) #=> 1
# Listas que são implementadas como listas ligadas.
diff --git a/pt-br/fsharp-pt.html.markdown b/pt-br/fsharp-pt.html.markdown
new file mode 100644
index 00000000..55966cda
--- /dev/null
+++ b/pt-br/fsharp-pt.html.markdown
@@ -0,0 +1,639 @@
+---
+language: F#
+filename: learnfsharp-pt.fs
+contributors:
+ - ["Scott Wlaschin", "http://fsharpforfunandprofit.com"]
+ - ["Adelar da Silva Queiróz", "https://adelarsq.github.io"]
+lang: pt-br
+---
+
+F# é uma linguagem de propósito geral funcional e orientada a objetos. É livre, de código aberto e executa em Linux, Mac, Windows e outros.
+
+Possui um sistema de tipagem poderoso que evita muitos erros em tempo de compilação. Para isto utilizando inferência de tipos, o que a faz se comportar como uma linguagem dinâmica.
+
+A sintaxe é diferente das linguagens do estilo C (C, C#, Java, etc):
+
+* Chaves não são usadas para delimitar blocos de código. Ao invés disso é utilizada indentação (semelhante ao Python).
+* Espaços em branco são usados para separar parâmetros, ao invés de vírgulas.
+
+Se você deseja executar o código abaixo, copie e cole em [https://try.fsharp.org](https://try.fsharp.org), que é um REPL online.
+
+```fsharp
+
+// comentários de linhas únicas usam barras duplas
+(* comentários de linhas múltiplas usam o par (* . . . *)
+
+-fim do comentário de linhas múltiplas- *)
+
+// ================================================
+// Sintaxe básica
+// ================================================
+
+// ------ "Variáveis" (mas não exatamente) ------
+// A palavra reservada "let" define um valor imutável
+let myInt = 5
+let myFloat = 3.14
+let myString = "hello" // note que nenhum tipo é necessário
+
+// ------ Listas ------
+let twoToFive = [2; 3; 4; 5] // Colchetes criam uma lista com
+ // ponto e vírgula como delimitadores
+let oneToFive = 1 :: twoToFive // :: cria uma lista com um novo primeiro elemento
+// O resultado é [1; 2; 3; 4; 5]
+let zeroToFive = [0; 1] @ twoToFive // @ concatena duas listas
+
+// IMPORTANTE: vírgulas nunca são usadas como delimitadores, somente ponto e vírgula!
+
+// ------ Funções ------
+// A palavra chave "let" também define nomes para funções.
+let square x = x * x // Note que não são usados parêntesis
+square 3 // Agora executando a função. Também sem parêntesis
+
+let add x y = x + y // Não use add (x,y)! Isto significa algo
+ // completamente diferente.
+add 2 3 // Agora execute a função.
+
+// para definir uma função de múltiplas linhas apenas use indentação. Nenhum ponto e vírgula é necessário
+let evens list =
+ let isEven x = x % 2 = 0 // Define "isEven"como uma sub função. Note
+ // que o operador de igualdade é um simples "=".
+ List.filter isEven list // List.filter é uma função da biblioteca padrão
+ // com dois parâmetros: uma função que retorna boolean
+ // e uma lista para verificar
+
+evens oneToFive // Agora executando a função
+
+// Usando parênteses é possível deixar mais clara a precedência. Neste exemplo,
+// "map" é usado primeiro, com dois argumentos, então executa "sum" no resultado.
+// Sem os parênteses, "List.map" seria passado como uma argumento para List.sum
+let sumOfSquaresTo100 =
+ List.sum ( List.map square [1..100] )
+
+// É possível redirecionar a saída de uma operação para a próxima usando pipe ("|>")
+// Redirecimento de dados é algo comum em F#, similar a pipes Unix.
+
+// Aqui é a mesma função sumOfSquares escrita com pipe
+let sumOfSquaresTo100piped =
+ [1..100] |> List.map square |> List.sum // "square" foi definido anteriormente
+
+// você pode definir lambdas (funções anônimas) usando a palavra reservada "fun"
+let sumOfSquaresTo100withFun =
+ [1..100] |> List.map (fun x -> x * x) |> List.sum
+
+// Em F# não há a palavra chave "return". Funções sempre
+// retornam o valor da última expressão usada.
+
+// ------ Casamento de padrões (Pattern Matching) ------
+// Match..with.. é um poderoso case/switch.
+let simplePatternMatch =
+ let x = "a"
+ match x with
+ | "a" -> printfn "x is a"
+ | "b" -> printfn "x is b"
+ | _ -> printfn "x is something else" // sublinhado combina com qualquer coisa
+
+// F# não permite null por padrão -- deve-se usar um Option
+// e então efetuar um casamento de padrão.
+// Some(..) e None são análogos a Nullable
+let validValue = Some(99)
+let invalidValue = None
+
+// Neste exemplo, match..with casa com "Some" e "None",
+// e também desconstrói o valor em "Some" ao mesmo tempo.
+let optionPatternMatch input =
+ match input with
+ | Some i -> printfn "input is an int=%d" i
+ | None -> printfn "input is missing"
+
+optionPatternMatch validValue
+optionPatternMatch invalidValue
+
+// ------ Escrevando na tela ------
+// As funções printf/printfn são similares às
+// Console.Write/WriteLine encontradas no C#.
+printfn "Printing an int %i, a float %f, a bool %b" 1 2.0 true
+printfn "A string %s, and something generic %A" "hello" [1; 2; 3; 4]
+
+// Exitem também as funções sprintf/sprintfn para formatação de dados
+// em uma string, semelhante à String.Format do C#.
+
+// ================================================
+// Mais sobre funções
+// ================================================
+
+// F# é uma liguagem verdadeiramente funcional -- funções fazem
+// parte das classes e podem ser combinadas facilmente para criar
+// poderosos construtores
+
+// Módulos podem usar um grupo de funções
+// É necessário usar indentação para defini-las.
+module FunctionExamples =
+
+ // define uma função de soma
+ let add x y = x + y
+
+ // básico uso de uma função
+ let a = add 1 2
+ printfn "1 + 2 = %i" a
+
+ // aplicação parcial de parâmetros
+ let add42 = add 42
+ let b = add42 1
+ printfn "42 + 1 = %i" b
+
+ // composição para combinar funções
+ let add1 = add 1
+ let add2 = add 2
+ let add3 = add1 >> add2
+ let c = add3 7
+ printfn "3 + 7 = %i" c
+
+ // funções de alta ordem
+ [1..10] |> List.map add3 |> printfn "new list is %A"
+
+ // listas de funções e mais
+ let add6 = [add1; add2; add3] |> List.reduce (>>)
+ let d = add6 7
+ printfn "1 + 2 + 3 + 7 = %i" d
+
+// ================================================
+// Listas e coleções
+// ================================================
+
+// Existem três tipos de coleções ordenadas:
+// * Listas são o tipo mais básico de coleção imutável;
+// * Arrays são mutáveis e mais eficientes;
+// * Sequences são lazy e infinitas (semelhante a enumerator).
+//
+// Outras coleções incluem maps e conjuntos imutáveis
+// mais todas as coleções padrões do .NET
+
+module ListExamples =
+
+ // listas usam colchetes
+ let list1 = ["a"; "b"]
+ let list2 = "c" :: list1 // :: é usado para adicionar um elemento no início da lista
+ let list3 = list1 @ list2 // @ é o operador de concatenação
+
+ // list comprehensions (generators)
+ let squares = [for i in 1..10 do yield i * i]
+
+ // Um gerador de números primos
+ // - este usa a notação custa para casamento de padrões
+ // - (p::xs) significa 'primeiro :: cauda' da lista, e pode ser escrito como p :: xs
+ // isto significa que casa 'p' (o primeiro item da lista), e xs recebe o resto da lista
+ // que é chamdo de 'cons pattern'
+ // - usa a palavra chave 'rec', que é necessária quando se usa recursão
+ let rec sieve = function
+ | (p::xs) -> p :: sieve [ for x in xs do if x % p > 0 then yield x ]
+ | [] -> []
+ let primes = sieve [2..50]
+ printfn "%A" primes
+
+ // casamento de padrões (pattern matching) com listas
+ let listMatcher aList =
+ match aList with
+ | [] -> printfn "the list is empty"
+ | [first] -> printfn "the list has one element %A " first
+ | [first; second] -> printfn "list is %A and %A" first second
+ | first :: _ -> printfn "the list has more than two elements, first element %A" first
+
+ listMatcher [1; 2; 3; 4]
+ listMatcher [1; 2]
+ listMatcher [1]
+ listMatcher []
+
+ // recursão usando listas
+ let rec sum aList =
+ match aList with
+ | [] -> 0
+ | x::xs -> x + sum xs
+ sum [1..10]
+
+ // -----------------------------------------
+ // Funções da biblioteca padrão
+ // -----------------------------------------
+
+ // mapas
+ let add3 x = x + 3
+ [1..10] |> List.map add3
+
+ // filtros
+ let even x = x % 2 = 0
+ [1..10] |> List.filter even
+
+ // muito mais -- veja a documentação
+
+module ArrayExamples =
+
+ // arrays usam colchetes com barra vertical
+ let array1 = [| "a"; "b" |]
+ let first = array1.[0] // acesso por índice usando ponto
+
+ // casamento de padrões (pattern matching) para arrays é feito da mesma forma que de listas
+ let arrayMatcher aList =
+ match aList with
+ | [| |] -> printfn "the array is empty"
+ | [| first |] -> printfn "the array has one element %A " first
+ | [| first; second |] -> printfn "array is %A and %A" first second
+ | _ -> printfn "the array has more than two elements"
+
+ arrayMatcher [| 1; 2; 3; 4 |]
+
+ // As funções da biblioteca padrão são as mesmas que para List
+
+ [| 1..10 |]
+ |> Array.map (fun i -> i + 3)
+ |> Array.filter (fun i -> i % 2 = 0)
+ |> Array.iter (printfn "value is %i. ")
+
+
+module SequenceExamples =
+
+ // sequências usam chaves
+ let seq1 = seq { yield "a"; yield "b" }
+
+ // sequências podem usar yield e
+ // podem conter subsequencias
+ let strange = seq {
+ // "yield" adiciona um elemento
+ yield 1; yield 2;
+
+ // "yield!" adiciona uma subsequencia
+ yield! [5..10]
+ yield! seq {
+ for i in 1..10 do
+ if i % 2 = 0 then yield i }}
+ // teste
+ strange |> Seq.toList
+
+ // Sequências podem ser criadas usando "unfold"
+ // Este é um exemplo da série de Fibonacci
+ let fib = Seq.unfold (fun (fst,snd) ->
+ Some(fst + snd, (snd, fst + snd))) (0,1)
+
+ // teste
+ let fib10 = fib |> Seq.take 10 |> Seq.toList
+ printf "first 10 fibs are %A" fib10
+
+
+// ================================================
+// Tipos de dados
+// ================================================
+
+module DataTypeExamples =
+
+ // Todos os dados são imutáveis por padrão
+
+ // Tuplas são uma forma rápida de reprentar n elementos de tipos anônimos
+ // -- Use a vírgula para criar uma tupla
+ let twoTuple = 1, 2
+ let threeTuple = "a", 2, true
+
+ // Casamento de padrões (pattern match) para desconstruir
+ let x, y = twoTuple // atribui x = 1, y = 2
+
+ // ------------------------------------
+ // O tipo registro possui nomes nos campos
+ // ------------------------------------
+
+ // Use "type" com chaves para definir um registro
+ type Person = {First:string; Last:string}
+
+ // Use "let" com chaves para criar um registro
+ let person1 = {First="John"; Last="Doe"}
+
+ // Casamento de padrões para desconstruir
+ let {First = first} = person1 // atribui first="John"
+
+ // ------------------------------------
+ // Tipos union (variantes) possuem um conjunto de escolhas
+ // Somente um caso pode ser válido por vez.
+ // ------------------------------------
+
+ // Use "type" com barra/pipe para definir um union
+ type Temp =
+ | DegreesC of float
+ | DegreesF of float
+
+ // Use qualquer dos tipos para criar um
+ let temp1 = DegreesF 98.6
+ let temp2 = DegreesC 37.0
+
+ // Casamento de padrões deve cobrir todos os tipos de definidos para desconstruir
+ let printTemp = function
+ | DegreesC t -> printfn "%f degC" t
+ | DegreesF t -> printfn "%f degF" t
+
+ printTemp temp1
+ printTemp temp2
+
+ // ------------------------------------
+ // Tipos recursivos
+ // ------------------------------------
+
+ // Tipos podem ser combinados recursivamente de formas complexas
+ // sem ter que criar subclasses
+ type Employee =
+ | Worker of Person
+ | Manager of Employee list
+
+ let jdoe = {First="John"; Last="Doe"}
+ let worker = Worker jdoe
+
+ // ------------------------------------
+ // Modelando com tipos
+ // ------------------------------------
+
+ // Tipos union são muito bons para modelagem de estados sem usar flags
+ type EmailAddress =
+ | ValidEmailAddress of string
+ | InvalidEmailAddress of string
+
+ let trySendEmail email =
+ match email with // casamento de padrões
+ | ValidEmailAddress address -> () // envia
+ | InvalidEmailAddress address -> () // não envia
+
+ // A combinação de tipos union e registros juntos
+ // provê uma grande fundação para DDD (Domain Driven Design).
+ // Você pode criar centenas de pequenos tipos que refletem
+ // exatamente o seu domínio.
+
+ type CartItem = { ProductCode: string; Qty: int }
+ type Payment = Payment of float
+ type ActiveCartData = { UnpaidItems: CartItem list }
+ type PaidCartData = { PaidItems: CartItem list; Payment: Payment}
+
+ type ShoppingCart =
+ | EmptyCart // nenhum dado
+ | ActiveCart of ActiveCartData
+ | PaidCart of PaidCartData
+
+ // ------------------------------------
+ // Comportamento padrão para tipos
+ // ------------------------------------
+
+ // Tipos padrões possuem um padrão já definido, não precisando de codificação nenhuma.
+ // * Imutáveis
+ // * Impressão formatada para depuração
+ // * Igualdade e comparação
+ // * Serialização
+
+ // Impressão formatada usando %A
+ printfn "twoTuple=%A,\nPerson=%A,\nTemp=%A,\nEmployee=%A"
+ twoTuple person1 temp1 worker
+
+ // Igualdade e comparação padrão.
+ // Um exemplo com cartas:
+ type Suit = Club | Diamond | Spade | Heart
+ type Rank = Two | Three | Four | Five | Six | Seven | Eight
+ | Nine | Ten | Jack | Queen | King | Ace
+
+ let hand = [ Club, Ace; Heart, Three; Heart, Ace;
+ Spade, Jack; Diamond, Two; Diamond, Ace ]
+
+ // ordenando
+ List.sort hand |> printfn "sorted hand is (low to high) %A"
+ List.max hand |> printfn "high card is %A"
+ List.min hand |> printfn "low card is %A"
+
+
+// ================================================
+// Padrões ativos (Active patterns)
+// ================================================
+
+module ActivePatternExamples =
+
+ // F# possui um tipo especial de casamento de padrões chamado "padrões ativos" ("active patterns")
+ // onde o padrão pode ser interpretado ou detectado dinamicamente.
+
+ // parêntesis e barra são a sintaxe para "padrões ativos"
+
+ // Você pode usar "elif" ao invés de "else if" em expressões condicionais.
+ // Elas são equivalentes em F#
+
+ // por exemplo, defina um "padrão ativo" para tratar tipos de caracteres...
+ let (|Digit|Letter|Whitespace|Other|) ch =
+ if System.Char.IsDigit(ch) then Digit
+ elif System.Char.IsLetter(ch) then Letter
+ elif System.Char.IsWhiteSpace(ch) then Whitespace
+ else Other
+
+ // ... e então use ele para interpretar de forma bem mais simples
+ let printChar ch =
+ match ch with
+ | Digit -> printfn "%c is a Digit" ch
+ | Letter -> printfn "%c is a Letter" ch
+ | Whitespace -> printfn "%c is a Whitespace" ch
+ | _ -> printfn "%c is something else" ch
+
+ // imprima a lista
+ ['a'; 'b'; '1'; ' '; '-'; 'c'] |> List.iter printChar
+
+ // ------------------------------------------------
+ // FizzBuzz usando padrões ativos (active patterns)
+ // ------------------------------------------------
+
+ // É possível criar casamento de padrões parcial também
+ // Apenas use sublinhado para a definição, e retorne Some se casado.
+ let (|MultOf3|_|) i = if i % 3 = 0 then Some MultOf3 else None
+ let (|MultOf5|_|) i = if i % 5 = 0 then Some MultOf5 else None
+
+ // a função principal
+ let fizzBuzz i =
+ match i with
+ | MultOf3 & MultOf5 -> printf "FizzBuzz, "
+ | MultOf3 -> printf "Fizz, "
+ | MultOf5 -> printf "Buzz, "
+ | _ -> printf "%i, " i
+
+ // teste
+ [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// Expressividade
+// ================================================
+
+module AlgorithmExamples =
+
+ // F# possui uma alta razão sinais/ruídos, assim o código
+ // é lido praticamento como se descreve o algoritmo
+
+ // ------ Exemplo: defina uma função que faça soma dos quadrados ------
+ let sumOfSquares n =
+ [1..n] // 1) pega todos os números de 1 a n
+ |> List.map square // 2) eleva ao quadrado cada um
+ |> List.sum // 3) soma os resultados
+
+ // teste
+ sumOfSquares 100 |> printfn "Sum of squares = %A"
+
+ // ------ Examplo: defina uma função de ordenação ------
+ let rec sort list =
+ match list with
+ // Se a lista está vazia
+ | [] ->
+ [] // retorna a lista vazia
+ // Se a lista não está vazia
+ | firstElem::otherElements -> // pega o primeiro elemento
+ let smallerElements = // extrai os elementos menores
+ otherElements // dos restantes
+ |> List.filter (fun e -> e < firstElem)
+ |> sort // e ordena eles
+ let largerElements = // extrai os elementos maiores
+ otherElements // dos restantes
+ |> List.filter (fun e -> e >= firstElem)
+ |> sort // e ordena eles
+ // Combine as 3 partes em uma nova lista e retorne ela
+ List.concat [smallerElements; [firstElem]; largerElements]
+
+ // teste
+ sort [1; 5; 23; 18; 9; 1; 3] |> printfn "Sorted = %A"
+
+// ================================================
+// Código assíncrono
+// ================================================
+
+module AsyncExample =
+
+ // F# possui suporte a funcionalidades para ajudar a escrever código assíncrono
+ // sem tornar o código difícil de manter ("pyramid of doom")
+ //
+ // O seguinte exemplo efetua download de um conjunto de páginas em paralelo.
+
+ open System.Net
+ open System
+ open System.IO
+ open Microsoft.FSharp.Control.CommonExtensions
+
+ // Obtém o conteúdo de cara página de forma assíncrona
+ let fetchUrlAsync url =
+ async { // a palavra chave "async" e chaves
+ // criam um objeto assíncrono
+ let req = WebRequest.Create(Uri(url))
+ use! resp = req.AsyncGetResponse()
+ // use! é uma atribuição assíncrona
+ use stream = resp.GetResponseStream()
+ // "use" dispara automaticamente close()
+ // no recurso no fim do escopo
+ use reader = new IO.StreamReader(stream)
+ let html = reader.ReadToEnd()
+ printfn "finished downloading %s" url
+ }
+
+ // uma lista de sites para fazer download
+ let sites = ["http://www.bing.com";
+ "http://www.google.com";
+ "http://www.microsoft.com";
+ "http://www.amazon.com";
+ "http://www.yahoo.com"]
+
+ // efetue
+ sites
+ |> List.map fetchUrlAsync // cria uma lista de tarefas assíncronas
+ |> Async.Parallel // coloca as tarefas para executarem em paralelo
+ |> Async.RunSynchronously // inicia cada uma
+
+// ================================================
+// Compatibilidade com .NET
+// ================================================
+
+module NetCompatibilityExamples =
+
+ // F# pode pode fazer praticamente tudo que C# pode fazer, e integra
+ // de forma simples com bibliotecas .NET e Mono
+
+ // ------- usando uma função de uma biblioteca existente -------
+
+ let (i1success, i1) = System.Int32.TryParse("123");
+ if i1success then printfn "parsed as %i" i1 else printfn "parse failed"
+
+ // ------- Implementando interfaces de forma simples! -------
+
+ // cria um novo objeto que implementa IDisposable
+ let makeResource name =
+ { new System.IDisposable
+ with member this.Dispose() = printfn "%s disposed" name }
+
+ let useAndDisposeResources =
+ use r1 = makeResource "first resource"
+ printfn "using first resource"
+ for i in [1..3] do
+ let resourceName = sprintf "\tinner resource %d" i
+ use temp = makeResource resourceName
+ printfn "\tdo something with %s" resourceName
+ use r2 = makeResource "second resource"
+ printfn "using second resource"
+ printfn "done."
+
+ // ------- Código orientado a objetos -------
+
+ // F# também possui suporte a orientação a objetos.
+ // Possui suporte a classes, herança, métodos virtuais, etc.
+
+ // interface com tipo genérico
+ type IEnumerator<'a> =
+ abstract member Current : 'a
+ abstract MoveNext : unit -> bool
+
+ // classe base abstrata com métodos virtuais
+ [<AbstractClass>]
+ type Shape() =
+ // propriedades somente leitura
+ abstract member Width : int with get
+ abstract member Height : int with get
+ // método não virtual
+ member this.BoundingArea = this.Height * this.Width
+ // método virtual com implementação base
+ abstract member Print : unit -> unit
+ default this.Print () = printfn "I'm a shape"
+
+ // classe concreta que herda da classe base e sobrescreve
+ type Rectangle(x:int, y:int) =
+ inherit Shape()
+ override this.Width = x
+ override this.Height = y
+ override this.Print () = printfn "I'm a Rectangle"
+
+ // testes
+ let r = Rectangle(2, 3)
+ printfn "The width is %i" r.Width
+ printfn "The area is %i" r.BoundingArea
+ r.Print()
+
+ // ------- métodos de extensão -------
+
+ // Assim como em C#, F# pode extender classes já existentes com métodos de extensão.
+ type System.String with
+ member this.StartsWithA = this.StartsWith "A"
+
+ // testes
+ let s = "Alice"
+ printfn "'%s' starts with an 'A' = %A" s s.StartsWithA
+
+ // ------- eventos -------
+
+ type MyButton() =
+ let clickEvent = new Event<_>()
+
+ [<CLIEvent>]
+ member this.OnClick = clickEvent.Publish
+
+ member this.TestEvent(arg) =
+ clickEvent.Trigger(this, arg)
+
+ // teste
+ let myButton = new MyButton()
+ myButton.OnClick.Add(fun (sender, arg) ->
+ printfn "Click event with arg=%O" arg)
+
+ myButton.TestEvent("Hello World!")
+
+```
+
+## Mais Informações
+
+Para mais demonstrações de F# acesse [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Leia mais sobre F# em [fsharp.org](http://fsharp.org/) e [dotnet's F# page](https://dotnet.microsoft.com/languages/fsharp).
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index 1eab9cc3..3acfce21 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -14,7 +14,7 @@ Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http:
```groovy
/*
- Prepara-se:
+ Prepare-se:
1) Instale a máquina virtual de Groovy - http://gvmtool.net/
2) Instale o Groovy: gvm install groovy
@@ -104,7 +104,7 @@ tecnologiasOrdenadas = tecnologias.sort( false )
/*** Manipulando listas ***/
-//Substitue todos os elementos da lista
+//Substitui todos os elementos da lista
Collections.replaceAll(tecnologias, 'Gradle', 'gradle')
//Desorganiza a lista
@@ -159,7 +159,7 @@ println devMap.values()
usará este campo.
* Se você quer uma propriedade private ou protected, você deve prover seus
- próprios getters e setter, que devem ser declarados como private ou protected.
+ próprios getters e setters, que devem ser declarados como private ou protected.
* Se você acessar uma propriedade dentro da classe e esta propriedade é definida
em tempo de compilação com 'this', implícito ou explícito (por exemplo,
@@ -236,7 +236,7 @@ assert x.equals("Roberto Grails Groovy ")
/*
Operadores
- Sobrecarregamento de Operadores para uma lsita dos operadores comuns que
+ Sobrecarga de Operadores para uma lista dos operadores comuns que
Grooby suporta:
http://www.groovy-lang.org/operators.html#Operator-Overloading
@@ -254,7 +254,7 @@ def nomeUsuario = usuario?.nomeUsuario
/*
Closures
- Um closure, em Grooby, é como um "bloco de código" ou um ponteiro para método.
+ Um closure, em Groovy, é como um "bloco de código" ou um ponteiro para método.
É um pedação de código que é definido e executado em um momento posterior.
Mais informação em: http://www.groovy-lang.org/closures.html
@@ -269,7 +269,7 @@ clos()
def soma = { a, b -> println a+b }
soma(2,4)
-//Closdures por referir-se a variáveis que não estão listadas em sua
+//Closures podem referir-se a variáveis que não estão listadas em sua
//lista de parêmetros.
def x = 5
def multiplicarPor = { num -> num * x }
@@ -309,7 +309,7 @@ chamaClosure(3, 4)
/*
Expando
- A classe Expando é um bean dinâmico que permite adicionar propriedade e
+ A classe Expando é um bean dinâmico que permite adicionar propriedades e
closures como métodos a uma instância desta classe
http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
diff --git a/pt-br/julia-pt.html.markdown b/pt-br/julia-pt.html.markdown
index 11771d96..52675bf5 100644
--- a/pt-br/julia-pt.html.markdown
+++ b/pt-br/julia-pt.html.markdown
@@ -104,7 +104,7 @@ println("Eu sou Julia. Prazer em conhece-lo!")
## 2. Variáveis e coleções
####################################################
-#Você não declara variáveis antes de atribui-lás.
+#Você não declara variáveis antes de atribui-las.
some_var = 5 # => 5
some_var # => 5
diff --git a/pt-br/kotlin-pt.html.markdown b/pt-br/kotlin-pt.html.markdown
index 7c3313fc..bbe8c0d1 100644
--- a/pt-br/kotlin-pt.html.markdown
+++ b/pt-br/kotlin-pt.html.markdown
@@ -70,7 +70,7 @@ fun olaMundo(val nome : String) {
println(umaStringModelo)
/*
- Para uma variável receber null deve-se explicitamente declara-la
+ Para uma variável receber null deve-se explicitamente declará-la
como anulável.
A declaração de anulável é realizada incluindo uma "?" ao fim do tipo.
Pode-se acessar uma variável anulável usando o operador "?."
@@ -166,7 +166,7 @@ fun olaMundo(val nome : String) {
/*
Classes de dados são um modo sucinto de criar classes que servem apenas
- para guardas informações.
+ para guardar informações.
Os métodos "hashCode", "equals" e "toString" são gerados automaticamente.
*/
data class ExemploClasseDados (val x: Int, val y: Int, val z: Int)
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index 5ed6b7ba..fae17bca 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -356,7 +356,7 @@ disp(a) % Imprime o valor da variável a
disp('Olá Mundo') % Imprime a string
fprintf % Imprime na janela de comandos com mais controle
-% Estruturas Condicionais (os parênteses são opicionais, porém uma boa prática)
+% Estruturas Condicionais (os parênteses são opcionais, porém uma boa prática)
if (a > 15)
disp('Maior que 15')
elseif (a == 23)
diff --git a/pt-br/self-pt.html.markdown b/pt-br/self-pt.html.markdown
index 2fb2953b..eb821474 100644
--- a/pt-br/self-pt.html.markdown
+++ b/pt-br/self-pt.html.markdown
@@ -147,7 +147,7 @@ o objeto '10' no slot 'x' e retornará o objeto original"
# Protótipos
-Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copia-lo.
+Não existem classes em Self. A maneira de obter um objeto é encontrar um protótipo e copiá-lo.
```
| d |
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index 6ece02ff..ed76959c 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -10,11 +10,11 @@ lang: pt-br
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 é TypeScript válido então ele pode ser adicionado diretamente a qualquer projeto. O compilador emite typescript JavaScript.
+É um super conjunto de JavaScript: todo o código JavaScript é TypeScript válido então ele pode ser adicionado 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).
+Este artigo irá se concentrar apenas na sintaxe extra do TypeScript, 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.
+Para testar o compilador TypeScript, vá para o [Playground](http://www.typescriptlang.org/Playground), onde você vai ser capaz de escrever código, ter auto conclusão e ver diretamente o JavaScript emitido.
```js
// Existem 3 tipos básicos no TypeScript
@@ -44,13 +44,13 @@ function bigHorribleAlert(): void {
// 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
+// A seguir são equivalentes, a mesma assinatura será inferida pelo
+// Compilador, e o mesmo JavaScript será emitido
var f1 = function(i: number): number { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
var f2 = function(i: number) { return i * i; }
var f3 = (i: number): number => { return i * i; }
-// Tipo de retorno inferida
+// Tipo de retorno inferido
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;
@@ -88,7 +88,7 @@ class Point {
// Propriedades
x: number;
- // Construtor - the public/private keywords in this context will generate
+ // Construtor - as palavras-chave public/private nesse contexto irão gerar
// 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
diff --git a/python.html.markdown b/python.html.markdown
index 27b2b22a..2fc266eb 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -773,9 +773,8 @@ if __name__ == '__main__':
# Call the static method
print(Human.grunt()) # => "*grunt*"
- # Cannot call static method with instance of object
- # because i.grunt() will automatically put "self" (the object i) as an argument
- print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given
+ # Static methods can be called by instances too
+ print(i.grunt()) # => "*grunt*"
# Update the property for this instance
i.age = 42
diff --git a/rst.html.markdown b/rst.html.markdown
index bdc73c7a..56d54501 100644
--- a/rst.html.markdown
+++ b/rst.html.markdown
@@ -6,9 +6,9 @@ contributors:
filename: restructuredtext.rst
---
-RST is a file format formely created by Python community to write documentation (and so, is part of Docutils).
+RST, Restructured Text, is a file format created by the Python community to write documentation. It is part of [Docutils](https://docutils.sourceforge.io/rst.html).
-RST files are simple text files with lightweight syntax (comparing to HTML).
+RST is a markdown language like HTML but is much more lightweight and easier to read.
## Installation
@@ -39,10 +39,10 @@ A simple example of the file syntax:
Main titles are written using equals signs over and under
=========================================================
-Note that there must be as many equals signs as title characters.
+Note that each character, including spaces, needs an equals sign above and below.
-Title are underlined with equals signs too
-==========================================
+Titles also use equals signs but are only underneath
+====================================================
Subtitles with dashes
---------------------
@@ -84,7 +84,7 @@ More complex tables can be done easily (merged columns and/or rows) but I sugges
There are multiple ways to make links:
-- By adding an underscore after a word : Github_ and by adding the target URL after the text (this way has the advantage to not insert unnecessary URLs inside readable text).
+- By adding an underscore after a word : Github_ and by adding the target URL after the text (this way has the advantage of not inserting unnecessary URLs in the visible text).
- By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link)
- By making a more Markdown-like link: `Github <https://github.com/>`_ .
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index 9133549d..e0e53b9c 100644
--- a/ru-ru/python-ru.html.markdown
+++ b/ru-ru/python-ru.html.markdown
@@ -6,6 +6,7 @@ contributors:
- ["Steven Basart", "http://github.com/xksteven"]
translators:
- ["Andre Polykanine", "https://github.com/Oire"]
+ - ["Anton Grouchtchak", "https://github.com/Teraskull"]
filename: learnpython-ru.py
---
@@ -20,8 +21,10 @@ filename: learnpython-ru.py
Если вы хотите изучить Python 2.7, обратитесь к другой статье.
```python
+
# Однострочные комментарии начинаются с символа решётки.
-""" Многострочный текст может быть
+
+""" Многострочный текст может быть
записан, используя 3 знака " и обычно используется
в качестве встроенной документации
"""
@@ -31,315 +34,397 @@ filename: learnpython-ru.py
####################################################
# У вас есть числа
-3 #=> 3
+3 # => 3
# Математика работает вполне ожидаемо
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-
-# Кроме деления, которое по умолчанию возвращает число с плавающей запятой
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
35 / 5 # => 7.0
# Результат целочисленного деления округляется в меньшую сторону
# как для положительных, так и для отрицательных чисел.
-5 // 3 # => 1
-5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой
--5 // 3 # => -2
+5 // 3 # => 1
+-5 // 3 # => -2
+5.0 // 3.0 # => 1.0 # работает и для чисел с плавающей запятой
-5.0 // 3.0 # => -2.0
-# Когда вы используете числа с плавающей запятой,
-# результатом будет также число с плавающей запятой
-3 * 2.0 # => 6.0
+# # Результат деления возвращает число с плавающей запятой
+10.0 / 3 # => 3.3333333333333335
# Остаток от деления
-7 % 3 # => 1
+7 % 3 # => 1
# Возведение в степень
-2**4 # => 16
+2**3 # => 8
# Приоритет операций указывается скобками
-(1 + 3) * 2 #=> 8
+1 + 3 * 2 # => 7
+(1 + 3) * 2 # => 8
-# Для логических (булевых) значений существует отдельный примитивный тип
-True
-False
+# Булевы значения - примитивы (Обратите внимание на заглавную букву)
+True # => True
+False # => False
# Для отрицания используется ключевое слово not
-not True #=> False
-not False #=> True
-
-# Логические операторы
-# Обратите внимание: ключевые слова «and» и «or» чувствительны к регистру букв
-True and False #=> False
-False or True #=> True
-
-# Обратите внимание, что логические операторы используются и с целыми числами
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+not True # => False
+not False # => True
+
+# Булевы операторы
+# Обратите внимание: ключевые слова "and" и "or" чувствительны к регистру букв
+True and False # => False
+False or True # => True
+
+# True и False на самом деле 1 и 0, но с разными ключевыми словами
+True + True # => 2
+True * 8 # => 8
+False - 5 # => -5
+
+# Операторы сравнения обращают внимание на числовое значение True и False
+0 == False # => True
+1 == True # => True
+2 == True # => False
+-5 != False # => True
+
+# Использование булевых логических операторов на типах int превращает их в булевы значения, но возвращаются оригинальные значения
+# Не путайте с bool(ints) и bitwise and/or (&,|)
+bool(0) # => False
+bool(4) # => True
+bool(-6) # => True
+0 and 2 # => 0
+-5 or 0 # => -5
# Равенство — это ==
-1 == 1 #=> True
-2 == 1 #=> False
+1 == 1 # => True
+2 == 1 # => False
# Неравенство — это !=
-1 != 1 #=> False
-2 != 1 #=> True
+1 != 1 # => False
+2 != 1 # => True
# Ещё немного сравнений
-1 < 10 #=> True
-1 > 10 #=> False
-2 <= 2 #=> True
-2 >= 2 #=> True
-
-# Сравнения могут быть записаны цепочкой:
-1 < 2 < 3 #=> True
-2 < 3 < 2 #=> False
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Проверка, находится ли значение в диапазоне
+1 < 2 and 2 < 3 # => True
+2 < 3 and 3 < 2 # => False
+
+# Сравнения могут быть записаны цепочкой
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# (is vs. ==) ключевое слово is проверяет, относятся ли две переменные к одному и тому же объекту, но == проверяет если указанные объекты имеют одинаковые значения.
+a = [1, 2, 3, 4] # a указывает на новый список, [1, 2, 3, 4]
+b = a # b указывает на то, что указывает a
+b is a # => True, a и b относятся к одному и тому же объекту
+b == a # => True, Объекты a и b равны
+b = [1, 2, 3, 4] # b указывает на новый список, [1, 2, 3, 4]
+b is a # => False, a и b не относятся к одному и тому же объекту
+b == a # => True, Объекты a и b равны
# Строки определяются символом " или '
"Это строка."
'Это тоже строка.'
# И строки тоже могут складываться! Хотя лучше не злоупотребляйте этим.
-"Привет " + "мир!" #=> "Привет мир!"
+"Привет " + "мир!" # => "Привет мир!"
-# Строки можно умножать.
-"aa" * 4 #=> "aaaaaaaa"
+# Строки (но не переменные) могут быть объединены без использования '+'
+"Привет " "мир!" # => "Привет мир!"
# Со строкой можно работать, как со списком символов
-"Это строка"[0] #=> 'Э'
+"Привет мир!"[0] # => 'П'
-# Метод format используется для форматирования строк:
-"{0} могут быть {1}".format("строки", "форматированы")
+# Вы можете найти длину строки
+len("Это строка") # => 10
-# Вы можете повторять аргументы форматирования, чтобы меньше печатать.
-"Ехал {0} через реку, видит {0} - в реке {1}! Сунул {0} руку в реку, {1} за руку греку цап!".format("грека", "рак")
-#=> "Ехал грека через реку, видит грека - в реке рак! Сунул грека руку в реку, рак за руку греку цап!"
-# Если вы не хотите считать, можете использовать ключевые слова.
-"{name} хочет есть {food}".format(name="Боб", food="лазанью")
+# Вы также можете форматировать, используя f-строки (в Python 3.6+)
+name = "Рейко"
+f"Она сказала, что ее зовут {name}." # => "Она сказала, что ее зовут Рейко"
+# Вы можете поместить любой оператор Python в фигурные скобки, и он будет выведен в строке.
+f"{name} состоит из {len(name)} символов." # => "Рэйко состоит из 5 символов."
-# Если ваш код на Python 3 нужно запускать также и под Python 2.5 и ниже,
-# вы также можете использовать старый способ форматирования:
-"%s можно %s %s способом" % ("строки", "интерполировать", "старым")
# None является объектом
-None #=> None
+None # => None
-# Не используйте оператор равенства '==' для сравнения
-# объектов с None. Используйте для этого 'is'
-"etc" is None #=> False
-None is None #=> True
+# Не используйте оператор равенства "==" для сравнения
+# объектов с None. Используйте для этого "is"
+"etc" is None # => False
+None is None # => True
-# Оператор «is» проверяет идентичность объектов. Он не
-# очень полезен при работе с примитивными типами, но
-# зато просто незаменим при работе с объектами.
-
-# None, 0 и пустые строки/списки/словари приводятся к False.
+# None, 0 и пустые строки/списки/словари/кортежи приводятся к False.
# Все остальные значения равны True
-bool(0) # => False
+bool(0) # => False
bool("") # => False
-bool([]) #=> False
-bool({}) #=> False
+bool([]) # => False
+bool({}) # => False
+bool(()) # => False
####################################################
-## 2. Переменные и коллекции
+## 2. Переменные и Коллекции
####################################################
# В Python есть функция Print
-print("Я Python. Приятно познакомиться!")
+print("Я Python. Приятно познакомиться!") # => Я Python. Приятно познакомиться!
+
+# По умолчанию функция, print() также выводит новую строку в конце.
+# Используйте необязательный аргумент end, чтобы изменить последнюю строку.
+print("Привет мир", end="!") # => Привет мир!
+
+# Простой способ получить входные данные из консоли
+input_string_var = input("Введите данные: ") # Возвращает данные в виде строки
+# Примечание: в более ранних версиях Python метод input() назывался raw_input()
# Объявлять переменные перед инициализацией не нужно.
# По соглашению используется нижний_регистр_с_подчёркиваниями
some_var = 5
-some_var #=> 5
+some_var # => 5
+
+# При попытке доступа к неинициализированной переменной выбрасывается исключение.
+# Об исключениях см. раздел "Поток управления и итерируемые объекты".
+some_unknown_var # Выбрасывает ошибку NameError
-# При попытке доступа к неинициализированной переменной
-# выбрасывается исключение.
-# Об исключениях см. раздел «Поток управления и итерируемые объекты».
-some_unknown_var # Выбрасывает ошибку именования
+# if можно использовать как выражение
+# Эквивалент тернарного оператора '?:' в C
+"да!" if 0 > 1 else "нет!" # => "нет!"
# Списки хранят последовательности
li = []
# Можно сразу начать с заполненного списка
other_li = [4, 5, 6]
-# Объекты добавляются в конец списка методом append
-li.append(1) # [1]
-li.append(2) # [1, 2]
-li.append(4) # [1, 2, 4]
-li.append(3) # [1, 2, 4, 3]
-# И удаляются с конца методом pop
-li.pop() #=> возвращает 3 и li становится равен [1, 2, 4]
+# Объекты добавляются в конец списка методом append()
+li.append(1) # [1]
+li.append(2) # [1, 2]
+li.append(4) # [1, 2, 4]
+li.append(3) # [1, 2, 4, 3]
+# И удаляются с конца методом pop()
+li.pop() # => возвращает 3 и li становится равен [1, 2, 4]
# Положим элемент обратно
-li.append(3) # [1, 2, 4, 3].
+li.append(3) # [1, 2, 4, 3].
# Обращайтесь со списком, как с обычным массивом
-li[0] #=> 1
+li[0] # => 1
+
# Обратимся к последнему элементу
-li[-1] #=> 3
+li[-1] # => 3
# Попытка выйти за границы массива приведёт к ошибке индекса
-li[4] # Выдаёт IndexError
+li[4] # Выбрасывает ошибку IndexError
# Можно обращаться к диапазону, используя так называемые срезы
# (Для тех, кто любит математику, это называется замкнуто-открытый интервал).
-li[1:3] #=> [2, 4]
-# Опускаем начало
-li[2:] #=> [4, 3]
-# Опускаем конец
-li[:3] #=> [1, 2, 4]
-# Выбираем каждый второй элемент
-li[::2] # =>[1, 4]
-# Переворачиваем список
-li[::-1] # => [3, 4, 2, 1]
+li[1:3] # Вернуть список из индекса с 1 по 3 => [2, 4]
+li[2:] # Вернуть список, начиная с индекса 2 => [4, 3]
+li[:3] # Вернуть список с начала до индекса 3 => [1, 2, 4]
+li[::2] # Вернуть список, выбирая каждую вторую запись => [1, 4]
+li[::-1] # Вернуть список в обратном порядке => [3, 4, 2, 1]
# Используйте сочетания всего вышеназванного для выделения более сложных срезов
# li[начало:конец:шаг]
+# Сделать однослойную глубокую копию, используя срезы
+li2 = li[:] # => li2 = [1, 2, 4, 3], но (li2 is li) вернет False.
+
# Удаляем произвольные элементы из списка оператором del
-del li[2] # [1, 2, 3]
+del li[2] # [1, 2, 3]
+
+# Удалить первое вхождение значения
+li.remove(2) # [1, 3]
+li.remove(2) # Выбрасывает ошибку ValueError поскольку 2 нет в списке
+
+# Вставить элемент по определенному индексу
+li.insert(1, 2) # [1, 2, 3]
+
+# Получить индекс первого найденного элемента, соответствующего аргументу
+li.index(2) # => 1
+li.index(4) # Выбрасывает ошибку ValueError поскольку 4 нет в списке
# Вы можете складывать, или, как ещё говорят, конкатенировать списки
# Обратите внимание: значения li и other_li при этом не изменились.
-li + other_li #=> [1, 2, 3, 4, 5, 6] — Замечание: li и other_li не изменяются
+li + other_li # => [1, 2, 3, 4, 5, 6]
-# Объединять списки можно методом extend
+# Объединять списки можно методом extend()
li.extend(other_li) # Теперь li содержит [1, 2, 3, 4, 5, 6]
-# Проверить элемент на вхождение в список можно оператором in
-1 in li #=> True
+# Проверить элемент на наличие в списке можно оператором in
+1 in li # => True
# Длина списка вычисляется функцией len
-len(li) #=> 6
+len(li) # => 6
-# Кортежи — это такие списки, только неизменяемые
+# Кортежи похожи на списки, только неизменяемые
tup = (1, 2, 3)
-tup[0] #=> 1
-tup[0] = 3 # Выдаёт TypeError
+tup[0] # => 1
+tup[0] = 3 # Выбрасывает ошибку TypeError
+
+# Обратите внимание, что кортеж длины 1 должен иметь запятую после последнего элемента, но кортежи другой длины, даже 0, не должны.
+type((1)) # => <class 'int'>
+type((1,)) # => <class 'tuple'>
+type(()) # => <class 'tuple'>
# Всё то же самое можно делать и с кортежами
-len(tup) #=> 3
-tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
-tup[:2] #=> (1, 2)
-2 in tup #=> True
+len(tup) # => 3
+tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
+tup[:2] # => (1, 2)
+2 in tup # => True
# Вы можете распаковывать кортежи (или списки) в переменные
-a, b, c = (1, 2, 3) # a == 1, b == 2 и c == 3
+a, b, c = (1, 2, 3) # a == 1, b == 2 и c == 3
+# Вы также можете сделать расширенную распаковку
+a, *b, c = (1, 2, 3, 4) # a теперь 1, b теперь [2, 3] и c теперь 4
# Кортежи создаются по умолчанию, если опущены скобки
-d, e, f = 4, 5, 6
+d, e, f = 4, 5, 6 # кортеж 4, 5, 6 распаковывается в переменные d, e и f
+# соответственно, d = 4, e = 5 и f = 6
# Обратите внимание, как легко поменять местами значения двух переменных
-e, d = d, e # теперь d == 5, а e == 4
+e, d = d, e # теперь d == 5, а e == 4
-# Словари содержат ассоциативные массивы
+# Словари содержат ассоциативные массивы
empty_dict = {}
# Вот так описывается предзаполненный словарь
filled_dict = {"one": 1, "two": 2, "three": 3}
-# Значения извлекаются так же, как из списка, с той лишь разницей,
-# что индекс — у словарей он называется ключом — не обязан быть числом
-filled_dict["one"] #=> 1
+# Обратите внимание, что ключи для словарей должны быть неизменяемыми типами. Это
+# сделано для того, чтобы ключ может быть преобразован в хеш для быстрого поиска.
+# Неизменяемые типы включают целые числа, числа с плавающей запятой, строки, кортежи.
+invalid_dict = {[1,2,3]: "123"} # => Выбрасывает ошибку TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]} # Однако значения могут быть любого типа.
-# Все ключи в виде списка получаются с помощью метода keys().
+# Поиск значений с помощью []
+filled_dict["one"] # => 1
+
+# Все ключи в виде списка получаются с помощью метода keys().
# Его вызов нужно обернуть в list(), так как обратно мы получаем
-# итерируемый объект, о которых поговорим позднее.
-list(filled_dict.keys()) # => ["three", "two", "one"]
-# Замечание: сохранение порядка ключей в словаре не гарантируется
-# Ваши результаты могут не совпадать с этими.
+# итерируемый объект, о которых поговорим позднее. Примечание - для Python
+# версии <3.7, порядок словарных ключей не гарантируется. Ваши результаты могут
+# не точно соответствовать приведенному ниже примеру. Однако, начиная с Python 3.7
+# элементы в словаре сохраняют порядок, в котором они вставляются в словарь.
+list(filled_dict.keys()) # => ["three", "two", "one"] в Python <3.7
+list(filled_dict.keys()) # => ["one", "two", "three"] в Python 3.7+
+
# Все значения в виде списка можно получить с помощью values().
# И снова нам нужно обернуть вызов в list(), чтобы превратить
# итерируемый объект в список.
-list(filled_dict.values()) # => [3, 2, 1]
# То же самое замечание насчёт порядка ключей справедливо и здесь
+list(filled_dict.values()) # => [3, 2, 1] в Python <3.7
+list(filled_dict.values()) # => [1, 2, 3] в Python 3.7+
-# При помощи оператора in можно проверять ключи на вхождение в словарь
-"one" in filled_dict #=> True
-1 in filled_dict #=> False
+# При помощи ключевого слова in можно проверять наличие ключей в словаре
+"one" in filled_dict # => True
+1 in filled_dict # => False
-# Попытка получить значение по несуществующему ключу выбросит ошибку ключа
-filled_dict["four"] # KeyError
+# Попытка получить значение по несуществующему ключу выбросит ошибку KeyError
+filled_dict["four"] # Выбрасывает ошибку KeyError
# Чтобы избежать этого, используйте метод get()
-filled_dict.get("one") #=> 1
-filled_dict.get("four") #=> None
-# Метод get также принимает аргумент по умолчанию, значение которого будет
-# возвращено при отсутствии указанного ключа
-filled_dict.get("one", 4) #=> 1
-filled_dict.get("four", 4) #=> 4
+filled_dict.get("one") # => 1
+filled_dict.get("four") # => None
+# Метод get поддерживает аргумент по умолчанию, когда значение отсутствует
+filled_dict.get("one", 4) # => 1
+filled_dict.get("four", 4) # => 4
-# Метод setdefault вставляет пару ключ-значение, только если такого ключа нет
-filled_dict.setdefault("five", 5) #filled_dict["five"] возвращает 5
-filled_dict.setdefault("five", 6) #filled_dict["five"] по-прежнему возвращает 5
+# Метод setdefault() вставляет пару ключ-значение, только если такого ключа нет
+filled_dict.setdefault("five", 5) # filled_dict["five"] возвращает 5
+filled_dict.setdefault("five", 6) # filled_dict["five"] по-прежнему возвращает 5
# Добавление элементов в словарь
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4 # Другой способ добавления элементов
+filled_dict.update({"four":4}) # => {"one": 1, "two": 2, "three": 3, "four": 4}
+filled_dict["four"] = 4 # Другой способ добавления элементов
+
+# Удаляйте ключи из словаря с помощью ключевого слова del
+del filled_dict["one"] # Удаляет ключ "one" из словаря
+
+# После Python 3.5 вы также можете использовать дополнительные параметры распаковки
+{'a': 1, **{'b': 2}} # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}} # => {'a': 2}
-# Удаляйте ключи из словаря с помощью оператора del
-del filled_dict["one"] # Удаляет ключ «one» из словаря
# Множества содержат... ну, в общем, множества
empty_set = set()
# Инициализация множества набором значений.
-# Да, оно выглядит примерно как словарь… ну извините, так уж вышло.
-filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+# Да, оно выглядит примерно как словарь. Ну извините, так уж вышло.
+filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+
+# Similar to keys of a dictionary, elements of a set have to be immutable.
+# Как и ключи словаря, элементы множества должны быть неизменяемыми.
+invalid_set = {[1], 1} # => Выбрасывает ошибку TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
# Множеству можно назначать новую переменную
filled_set = some_set
-
-# Добавление новых элементов в множество
-filled_set.add(5) # filled_set равно {1, 2, 3, 4, 5}
+filled_set.add(5) # {1, 2, 3, 4, 5}
+# В множествах нет повторяющихся элементов
+filled_set.add(5) # {1, 2, 3, 4, 5}
# Пересечение множеств: &
other_set = {3, 4, 5, 6}
-filled_set & other_set #=> {3, 4, 5}
+filled_set & other_set # => {3, 4, 5}
# Объединение множеств: |
-filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+filled_set | other_set # => {1, 2, 3, 4, 5, 6}
# Разность множеств: -
-{1,2,3,4} - {2,3,5} #=> {1, 4}
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Симметричная разница: ^
+{1, 2, 3, 4} ^ {2, 3, 5} # => {1, 4, 5}
+
+# Проверить, является ли множество слева надмножеством множества справа
+{1, 2} >= {1, 2, 3} # => False
-# Проверка на вхождение во множество: in
-2 in filled_set #=> True
-10 in filled_set #=> False
+# Проверить, является ли множество слева подмножеством множества справа
+{1, 2} <= {1, 2, 3} # => True
+
+# Проверка на наличие в множестве: in
+2 in filled_set # => True
+10 in filled_set # => False
+
+# Сделать однослойную глубокую копию
+filled_set = some_set.copy() # {1, 2, 3, 4, 5}
+filled_set is some_set # => False
####################################################
## 3. Поток управления и итерируемые объекты
####################################################
-# Для начала заведём переменную
+# Для начала создадим переменную
some_var = 5
# Так выглядит выражение if. Отступы в python очень важны!
-# результат: «some_var меньше, чем 10»
+# Конвенция заключается в использовании четырех пробелов, а не табуляции.
+# Pезультат: "some_var меньше, чем 10"
if some_var > 10:
- print("some_var намного больше, чем 10.")
-elif some_var < 10: # Выражение elif необязательно.
+ print("some_var точно больше, чем 10.")
+elif some_var < 10: # Выражение elif необязательно.
print("some_var меньше, чем 10.")
-else: # Это тоже необязательно.
+else: # Это тоже необязательно.
print("some_var равно 10.")
-# Циклы For проходят по спискам. Результат:
- # собака — это млекопитающее
- # кошка — это млекопитающее
- # мышь — это млекопитающее
+"""
+Циклы For проходят по спискам.
+Выводит:
+ собака — это млекопитающее
+ кошка — это млекопитающее
+ мышь — это млекопитающее
+"""
for animal in ["собака", "кошка", "мышь"]:
# Можете использовать format() для интерполяции форматированных строк
print("{} — это млекопитающее".format(animal))
-
+
"""
-«range(число)» возвращает список чисел
+"range(число)" возвращает список чисел
от нуля до заданного числа
-Результат:
+Выводит:
0
1
2
@@ -349,8 +434,42 @@ for i in range(4):
print(i)
"""
+"range(нижнее, верхнее)" возвращает список чисел
+от нижнего числа к верхнему
+Выводит:
+ 4
+ 5
+ 6
+ 7
+"""
+for i in range(4, 8):
+ print(i)
+
+"""
+"range(нижнее, верхнее, шаг)" возвращает список чисел
+от нижнего числа к верхнему, от нижнего числа к верхнему, увеличивая
+шаг за шагом. Если шаг не указан, значение по умолчанию - 1.
+Выводит:
+ 4
+ 6
+"""
+for i in range(4, 8, 2):
+ print(i)
+
+"""
+Чтобы перебрать список и получить индекс и значение каждого элемента в списке
+Выводит:
+ 0 собака
+ 1 кошка
+ 2 мышь
+"""
+animals = ["собака", "кошка", "мышь"]
+for i, value in enumerate(animals):
+ print(i, value)
+
+"""
Циклы while продолжаются до тех пор, пока указанное условие не станет ложным.
-Результат:
+Выводит:
0
1
2
@@ -366,45 +485,77 @@ try:
# Чтобы выбросить ошибку, используется raise
raise IndexError("Это ошибка индекса")
except IndexError as e:
- # pass — это просто отсутствие оператора. Обычно здесь происходит
- # восстановление после ошибки.
- pass
+ pass # pass — это просто отсутствие оператора. Обычно здесь происходит восстановление после ошибки.
except (TypeError, NameError):
- pass # Несколько исключений можно обработать вместе, если нужно.
-else: # Необязательное выражение. Должно следовать за последним блоком except
- print("Всё хорошо!") # Выполнится, только если не было никаких исключений
+ pass # Несколько исключений можно обработать вместе, если нужно.
+else: # Необязательное выражение. Должно следовать за последним блоком except
+ print("Всё хорошо!") # Выполнится, только если не было никаких исключений
+finally: # Выполнить при любых обстоятельствах
+ print("Мы можем очистить ресурсы здесь")
+
+# Вместо try/finally чтобы очистить ресурсы, можно использовать оператор with
+with open("myfile.txt") as f:
+ for line in f:
+ print(line)
+
+# Запись в файл
+contents = {"aa": 12, "bb": 21}
+with open("myfile1.txt", "w+") as file:
+ file.write(str(contents)) # Записывает строку в файл
+
+with open("myfile2.txt", "w+") as file:
+ file.write(json.dumps(contents)) # Записывает объект в файл
+
+# Чтение из файла
+with open('myfile1.txt', "r+") as file:
+ contents = file.read() # Читает строку из файла
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
+with open('myfile2.txt', "r+") as file:
+ contents = json.load(file) # Читает объект json из файла
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
# Python предоставляет фундаментальную абстракцию,
-# которая называется итерируемым объектом (an iterable).
+# которая называется итерируемым объектом (Iterable).
# Итерируемый объект — это объект, который воспринимается как последовательность.
# Объект, который возвратила функция range(), итерируемый.
+
filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
-print(our_iterable) #=> dict_keys(['one', 'two', 'three']). Это объект, реализующий интерфейс iterable
+print(our_iterable) # => dict_keys(['one', 'two', 'three']). Это объект, реализующий интерфейс Iterable
# Мы можем проходить по нему циклом.
for i in our_iterable:
- print(i) # Выводит one, two, three
+ print(i) # Выводит one, two, three
# Но мы не можем обращаться к элементу по индексу.
-our_iterable[1] # Выбрасывает ошибку типа
+our_iterable[1] # Выбрасывает ошибку TypeError
# Итерируемый объект знает, как создавать итератор.
our_iterator = iter(our_iterable)
# Итератор может запоминать состояние при проходе по объекту.
-# Мы получаем следующий объект, вызывая функцию __next__.
-our_iterator.__next__() #=> "one"
+# Мы получаем следующий объект, вызывая функцию next().
+next(our_iterator) # => "one"
-# Он сохраняет состояние при вызове __next__.
-our_iterator.__next__() #=> "two"
-our_iterator.__next__() #=> "three"
+# Он сохраняет состояние при вызове next().
+next(our_iterator) # => "two"
+next(our_iterator) # => "three"
# Возвратив все данные, итератор выбрасывает исключение StopIterator
-our_iterator.__next__() # Выбрасывает исключение остановки итератора
+next(our_iterator) # Выбрасывает исключение StopIteration
+
+# Мы можем проходить по нему циклом.
+our_iterator = iter(our_iterable)
+for i in our_iterator:
+ print(i) # Выводит one, two, three
# Вы можете получить сразу все элементы итератора, вызвав на нём функцию list().
-list(filled_dict.keys()) #=> Возвращает ["one", "two", "three"]
+list(our_iterable) # => Возвращает ["one", "two", "three"]
+list(our_iterator) # => Возвращает [] потому что состояние сохраняется
####################################################
@@ -414,19 +565,19 @@ list(filled_dict.keys()) #=> Возвращает ["one", "two", "three"]
# Используйте def для создания новых функций
def add(x, y):
print("x равен %s, а y равен %s" % (x, y))
- return x + y # Возвращайте результат с помощью ключевого слова return
+ return x + y # Возвращайте результат с помощью ключевого слова return
# Вызов функции с аргументами
-add(5, 6) #=> выводит «x равен 5, а y равен 6» и возвращает 11
+add(5, 6) # => Выводит "x равен 5, а y равен 6" и возвращает 11
# Другой способ вызова функции — вызов с именованными аргументами
-add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке.
+add(y=6, x=5) # Именованные аргументы можно указывать в любом порядке.
# Вы можете определить функцию, принимающую переменное число аргументов
def varargs(*args):
return args
-varargs(1, 2, 3) #=> (1,2,3)
+varargs(1, 2, 3) # => (1,2,3)
# А также можете определить функцию, принимающую переменное число
@@ -435,7 +586,7 @@ def keyword_args(**kwargs):
return kwargs
# Вызовем эту функцию и посмотрим, что из этого получится
-keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}
# Если хотите, можете использовать оба способа одновременно
def all_the_args(*args, **kwargs):
@@ -451,70 +602,135 @@ all_the_args(1, 2, a=3, b=4) выводит:
# Используйте символ * для распаковки кортежей и ** для распаковки словарей
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
-all_the_args(*args) # эквивалентно foo(1, 2, 3, 4)
-all_the_args(**kwargs) # эквивалентно foo(a=3, b=4)
-all_the_args(*args, **kwargs) # эквивалентно foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args) # эквивалентно all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs) # эквивалентно all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs) # эквивалентно all_the_args(1, 2, 3, 4, a=3, b=4)
+
+# Возврат нескольких значений (с назначением кортежей)
+def swap(x, y):
+ return y, x # Возвращает несколько значений в виде кортежа без скобок.
+ # (Примечание: скобки исключены, но могут быть включены)
+
+x = 1
+y = 2
+x, y = swap(x, y) # => x = 2, y = 1
+# (x, y) = swap(x,y) # Снова, скобки были исключены, но могут быть включены.
# Область определения функций
x = 5
-def setX(num):
+def set_x(num):
# Локальная переменная x — это не то же самое, что глобальная переменная x
- x = num # => 43
- print (x) # => 43
-
-def setGlobalX(num):
+ x = num # => 43
+ print(x) # => 43
+
+def set_global_x(num):
global x
- print (x) # => 5
- x = num # Глобальная переменная x теперь равна 6
- print (x) # => 6
+ print(x) # => 5
+ x = num # Глобальная переменная x теперь равна 6
+ print(x) # => 6
-setX(43)
-setGlobalX(6)
+set_x(43)
+set_global_x(6)
-# В Python функции — «объекты первого класса»
+# Python имеет функции первого класса
def create_adder(x):
def adder(y):
return x + y
return adder
add_10 = create_adder(10)
-add_10(3) #=> 13
+add_10(3) # => 13
# Также есть и анонимные функции
-(lambda x: x > 2)(3) #=> True
+(lambda x: x > 2)(3) # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
# Есть встроенные функции высшего порядка
-map(add_10, [1,2,3]) #=> [11, 12, 13]
-filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+list(map(add_10, [1, 2, 3])) # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1])) # => [4, 2, 3]
+
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7])) # => [6, 7]
+
+# Для удобного отображения и фильтрации можно использовать списочные интерпретации
+# Интерпретация списка сохраняет вывод в виде списка, который сам может быть вложенным списком
+[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]
+
+# Вы также можете создавать интерпретации множеств и словарей.
+{x for x in 'abcddeef' if x not in 'abc'} # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
-# Для удобного отображения и фильтрации можно использовать списочные включения
-[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. Классы
+## 5. Модули
####################################################
-# Чтобы получить класс, мы наследуемся от object.
-class Human(object):
+# Вы можете импортировать модули
+import math
+print(math.sqrt(16)) # => 4.0
+
+# Вы можете получить определенные функции из модуля
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Вы можете импортировать все функции из модуля.
+# Предупреждение: это не рекомендуется
+from math import *
+
+# Вы можете сократить имена модулей
+import math as m
+math.sqrt(16) == m.sqrt(16) # => True
- # Атрибут класса. Он разделяется всеми экземплярами этого класса
- species = "H. sapiens"
+# Модули Python - это обычные файлы Python. Вы
+# можете писать свои собственные и импортировать их. Имя
+# модуля совпадает с именем файла.
+
+# Вы можете узнать, какие функции и атрибуты
+# определены в модуле.
+import math
+dir(math)
+
+# Если у вас есть скрипт Python с именем math.py в той же папке,
+# что и ваш текущий скрипт, файл math.py будет
+# будет загружен вместо встроенного модуля Python.
+# Это происходит потому, что локальная папка имеет приоритет
+# над встроенными библиотеками Python.
+
+
+####################################################
+## 6. Классы
+####################################################
+
+# Мы используем оператор class для создания класса
+class Human:
+
+ # Атрибут класса. Он используется всеми экземплярами этого класса
+ species = "Гомосапиенс"
# Обычный конструктор, вызывается при инициализации экземпляра класса
# Обратите внимание, что двойное подчёркивание в начале и в конце имени
# означает объекты и атрибуты, которые используются Python, но находятся
# в пространствах имён, управляемых пользователем.
+ # Методы (или объекты или атрибуты), например:
+ # __init__, __str__, __repr__ и т. д. называются специальными методами.
# Не придумывайте им имена самостоятельно.
def __init__(self, name):
- # Присваивание значения аргумента атрибуту класса name
+ # Присваивание значения аргумента атрибуту
self.name = name
+ # Инициализация свойства
+ self._age = 0
+
# Метод экземпляра. Все методы принимают self в качестве первого аргумента
def say(self, msg):
return "{name}: {message}".format(name=self.name, message=msg)
+ # Другой метод экземпляра
+ def sing(self):
+ return 'йо... йо... проверка микрофона... раз, два... раз, два...'
+
# Метод класса разделяется между всеми экземплярами
# Они вызываются с указыванием вызывающего класса в качестве первого аргумента
@classmethod
@@ -526,55 +742,242 @@ class Human(object):
def grunt():
return "*grunt*"
+ # property похоже на геттер.
+ # Оно превращает метод age() в одноименный атрибут только для чтения.
+ # Однако нет необходимости писать тривиальные геттеры и сеттеры в Python.
+ @property
+ def age(self):
+ return self._age
+
+ # Это позволяет установить свойство
+ @age.setter
+ def age(self, age):
+ self._age = age
+
+ # Это позволяет удалить свойство
+ @age.deleter
+ def age(self):
+ del self._age
+
+
+# Когда интерпретатор Python читает исходный файл, он выполняет весь его код.
+# Проверка __name__ гарантирует, что этот блок кода выполняется только тогда, когда
+# этот модуль - это основная программа.
+if __name__ == '__main__':
+ # Инициализация экземпляра класса
+ i = Human(name="Иван")
+ i.say("привет") # Выводит: "Иван: привет"
+ j = Human("Пётр")
+ j.say("привет") # Выводит: "Пётр: привет"
+ # i и j являются экземплярами типа Human, или другими словами: они являются объектами Human
+
+ # Вызов метода класса
+ i.say(i.get_species()) # "Иван: Гомосапиенс"
+ # Изменение разделяемого атрибута
+ Human.species = "Неандертальец"
+ i.say(i.get_species()) # => "Иван: Неандертальец"
+ j.say(j.get_species()) # => "Пётр: Неандертальец"
+
+ # Вызов статического метода
+ print(Human.grunt()) # => "*grunt*"
+
+ # Невозможно вызвать статический метод с экземпляром объекта
+ # потому что i.grunt() автоматически поместит "self" (объект i) в качестве аргумента
+ print(i.grunt()) # => TypeError: grunt() takes 0 positional arguments but 1 was given
+
+ # Обновить свойство для этого экземпляра
+ i.age = 42
+ # Получить свойство
+ i.say(i.age) # => "Иван: 42"
+ j.say(j.age) # => "Пётр: 0"
+ # Удалить свойство
+ del i.age
+ # i.age # => это выбрасило бы ошибку AttributeError
+
+
+####################################################
+## 6.1 Наследование
+####################################################
+
+# Наследование позволяет определять новые дочерние классы, которые наследуют методы и
+# переменные от своего родительского класса.
+
+# Используя класс Human, определенный выше как базовый или родительский класс, мы можем
+# определить дочерний класс Superhero, который наследует переменные класса, такие как
+# "species", "name" и "age", а также методы, такие как "sing" и "grunt" из класса Human,
+# но также может иметь свои уникальные свойства.
+
+# Чтобы воспользоваться преимуществами модульности по файлам, вы можете поместить
+# вышеперечисленные классы в их собственные файлы, например, human.py
+
+# Чтобы импортировать функции из других файлов, используйте следующий формат
+# from "имя-файла-без-расширения" import "функция-или-класс"
+
+from human import Human
+
+
+# Укажите родительский класс(ы) как параметры определения класса
+class Superhero(Human):
+
+ # Если дочерний класс должен наследовать все определения родителя без каких-либо
+ # изменений, вы можете просто использовать ключевое слово pass (и ничего больше),
+ # но в этом случае оно закомментировано, чтобы разрешить уникальный дочерний класс:
+ # pass
+
+ # Дочерние классы могут переопределять атрибуты своих родителей
+ species = 'Сверхчеловек'
+
+ # Дочерние классы автоматически наследуют конструктор родительского класса, включая
+ # его аргументы, но также могут определять дополнительные аргументы или определения
+ # и переопределять его методы, такие как конструктор класса.
+ # Этот конструктор наследует аргумент "name" от класса "Human"
+ # и добавляет аргументы "superpower" и "movie":
+ def __init__(self, name, movie=False,
+ superpowers=["сверхсила", "пуленепробиваемость"]):
+
+ # добавить дополнительные атрибуты класса:
+ self.fictional = True
+ self.movie = movie
+ # помните об изменяемых значениях по умолчанию,
+ # поскольку значения по умолчанию являются общими
+ self.superpowers = superpowers
+
+ # Функция "super" позволяет вам получить доступ к методам родительского класса,
+ # которые переопределяются дочерним, в данном случае, методом __init__.
+ # Это вызывает конструктор родительского класса:
+ super().__init__(name)
+
+ # переопределить метод sing
+ def sing(self):
+ return 'Бам, бам, БАМ!'
+
+ # добавить дополнительный метод экземпляра
+ def boast(self):
+ for power in self.superpowers:
+ print("Я обладаю силой '{pow}'!".format(pow=power))
+
+
+if __name__ == '__main__':
+ sup = Superhero(name="Тик")
-# Инициализация экземпляра класса
-i = Human(name="Иван")
-print(i.say("привет")) # Выводит: «Иван: привет»
+ # Проверка типа экземпляра
+ if isinstance(sup, Human):
+ print('Я человек')
+ if type(sup) is Superhero:
+ print('Я супергерой')
-j = Human("Пётр")
-print(j.say("Привет")) # Выводит: «Пётр: привет»
+ # Получить порядок поиска разрешения метода (MRO),
+ # используемый как getattr(), так и super()
+ # Этот атрибут является динамическим и может быть обновлен
+ print(Superhero.__mro__) # => (<class '__main__.Superhero'>,
+ # => <class 'human.Human'>, <class 'object'>)
-# Вызов метода класса
-i.get_species() #=> "H. sapiens"
+ # Вызывает родительский метод, но использует свой собственный атрибут класса
+ print(sup.get_species()) # => Сверхчеловек
-# Изменение разделяемого атрибута
-Human.species = "H. neanderthalensis"
-i.get_species() #=> "H. neanderthalensis"
-j.get_species() #=> "H. neanderthalensis"
+ # Вызов переопределенного метода
+ print(sup.sing()) # => Бам, бам, БАМ!
-# Вызов статического метода
-Human.grunt() #=> "*grunt*"
+ # Вызывает метод из Human
+ sup.say('Ложка') # => Тик: Ложка
+
+ # Метод вызова, существующий только в Superhero
+ sup.boast() # => Я обладаю силой 'сверхсила'!
+ # => Я обладаю силой 'пуленепробиваемость'!
+
+ # Атрибут унаследованного класса
+ sup.age = 31
+ print(sup.age) # => 31
+
+ # Атрибут, который существует только в Superhero
+ print('Достоин ли я Оскара? ' + str(sup.movie))
####################################################
-## 6. Модули
+## 6.2 Множественное наследование
####################################################
-# Вы можете импортировать модули
-import math
-print(math.sqrt(16)) #=> 4.0
+# Eще одно определение класса
+# bat.py
+class Bat:
-# Вы можете импортировать отдельные функции модуля
-from math import ceil, floor
-print(ceil(3.7)) #=> 4.0
-print(floor(3.7)) #=> 3.0
+ species = 'Летучая мышь'
-# Можете импортировать все функции модуля.
-# (Хотя это и не рекомендуется)
-from math import *
+ def __init__(self, can_fly=True):
+ self.fly = can_fly
-# Можете сокращать имена модулей
-import math as m
-math.sqrt(16) == m.sqrt(16) #=> True
+ # В этом классе также есть метод say
+ def say(self, msg):
+ msg = '... ... ...'
+ return msg
-# Модули в Python — это обычные Python-файлы. Вы
-# можете писать свои модули и импортировать их. Название
-# модуля совпадает с названием файла.
+ # И свой метод тоже
+ def sonar(self):
+ return '))) ... ((('
+
+if __name__ == '__main__':
+ b = Bat()
+ print(b.say('привет'))
+ print(b.fly)
+
+
+# И еще одно определение класса, унаследованное от Superhero и Bat
+# superhero.py
+from superhero import Superhero
+from bat import Bat
+
+# Определите Batman как дочерний класс, унаследованный от Superhero и Bat
+class Batman(Superhero, Bat):
+
+ def __init__(self, *args, **kwargs):
+ # Обычно для наследования атрибутов необходимо вызывать super:
+ # super(Batman, self).__init__(*args, **kwargs)
+ # Однако здесь мы имеем дело с множественным наследованием, а super()
+ # работает только со следующим базовым классом в списке MRO.
+ # Поэтому вместо этого мы вызываем __init__ для всех родителей.
+ # Использование *args и **kwargs обеспечивает чистый способ передачи
+ # аргументов, когда каждый родитель "очищает слой луковицы".
+ Superhero.__init__(self, 'анонимный', movie=True,
+ superpowers=['Богатый'], *args, **kwargs)
+ Bat.__init__(self, *args, can_fly=False, **kwargs)
+ # переопределить значение атрибута name
+ self.name = 'Грустный Бен Аффлек'
+
+ def sing(self):
+ return 'на на на на на бэтмен!'
+
+
+if __name__ == '__main__':
+ sup = Batman()
+
+ # Получить порядок поиска разрешения метода (MRO),
+ # используемый как getattr(), так и super()
+ # Этот атрибут является динамическим и может быть обновлен
+ print(Batman.__mro__) # => (<class '__main__.Batman'>,
+ # => <class 'superhero.Superhero'>,
+ # => <class 'human.Human'>,
+ # => <class 'bat.Bat'>, <class 'object'>)
+
+ # Вызывает родительский метод, но использует свой собственный атрибут класса
+ print(sup.get_species()) # => Сверхчеловек
+
+ # Вызов переопределенного метода
+ print(sup.sing()) # => на на на на на бэтмен!
+
+ # Вызывает метод из Human, потому что порядок наследования имеет значение
+ sup.say('Я согласен') # => Грустный Бен Аффлек: Я согласен
+
+ # Вызов метода, существующий только во втором родителе
+ print(sup.sonar()) # => ))) ... (((
+
+ # Атрибут унаследованного класса
+ sup.age = 100
+ print(sup.age) # => 100
+
+ # Унаследованный атрибут от второго родителя,
+ # значение по умолчанию которого было переопределено.
+ print('Могу ли я летать? ' + str(sup.fly)) # => Могу ли я летать? False
-# Вы можете узнать, какие функции и атрибуты определены
-# в модуле
-import math
-dir(math)
####################################################
## 7. Дополнительно
@@ -585,27 +988,30 @@ def double_numbers(iterable):
for i in iterable:
yield i + i
-# Генератор создаёт значения на лету.
-# Он не возвращает все значения разом, а создаёт каждое из них при каждой
-# итерации. Это значит, что значения больше 15 в double_numbers
-# обработаны не будут.
-# Обратите внимание: range — это тоже генератор.
-# Создание списка чисел от 1 до 900000000 требует много места и времени.
-# Если нам нужно имя переменной, совпадающее с ключевым словом Python,
-# мы используем подчёркивание в конце
-range_ = range(1, 900000000)
-
-# Будет удваивать все числа, пока результат не превысит 30
-for i in double_numbers(range_):
+# Генераторы эффективны с точки зрения памяти, потому что они загружают только данные,
+# необходимые для обработки следующего значения в итерации.
+# Это позволяет им выполнять операции с недопустимо большими диапазонами значений.
+# ПРИМЕЧАНИЕ: "range" заменяет "xrange" в Python 3.
+for i in double_numbers(range(1, 900000000)): # "range" - генератор.
print(i)
if i >= 30:
break
+# Так же, как вы можете создать интерпретации списков, вы можете создать и
+# интерпретации генераторов.
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+ print(x) # Выводит -1 -2 -3 -4 -5
+
+# Вы также можете преобразовать интерпретацию генератора непосредственно в список.
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list) # => [-1, -2, -3, -4, -5]
+
# Декораторы
-# В этом примере beg оборачивает say
-# Метод beg вызовет say. Если say_please равно True,
-# он изменит возвращаемое сообщение
+# В этом примере "beg" оборачивает "say".
+# Если say_please равно True, он изменит возвращаемое сообщение.
from functools import wraps
@@ -614,7 +1020,7 @@ def beg(target_function):
def wrapper(*args, **kwargs):
msg, say_please = target_function(*args, **kwargs)
if say_please:
- return "{} {}".format(msg, " Пожалуйста! У меня нет денег :(")
+ return "{} {}".format(msg, "Пожалуйста! У меня нет денег :(")
return msg
return wrapper
@@ -626,8 +1032,8 @@ def say(say_please=False):
return msg, say_please
-print(say()) # Вы не купите мне пива?
-print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :(
+print(say()) # Вы не купите мне пива?
+print(say(say_please=True)) # Вы не купите мне пива? Пожалуйста! У меня нет денег :(
```
@@ -635,17 +1041,18 @@ print(say(say_please=True)) # Вы не купите мне пива? Пожал
### Бесплатные онлайн-материалы
-* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
-* [Dive Into Python](http://www.diveintopython.net/)
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
* [Ideas for Python Projects](http://pythonpracticeprojects.com)
* [Официальная документация](http://docs.python.org/3/)
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
-* [Python Module of the Week](http://pymotw.com/3/)
-* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
-
-### Платные
-
-* [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)
+* [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/)
+* [Python 3 Computer Science Circles](http://cscircles.cemc.uwaterloo.ca/)
+* [Dive Into Python 3](http://www.diveintopython3.net/index.html)
+* [A Crash Course in Python for Scientists](http://nbviewer.jupyter.org/gist/anonymous/5924718)
+* [Python Tutorial for Intermediates](https://pythonbasics.org/)
+* [Build a Desktop App with Python](https://pythonpyqt.com/)
diff --git a/set-theory.html.markdown b/set-theory.html.markdown
index e292464c..6be7aa00 100644
--- a/set-theory.html.markdown
+++ b/set-theory.html.markdown
@@ -44,7 +44,7 @@ For example, if `S = { 1, 2, 4 }`, then `|S| = 3`.
* The empty set can be constructed in set builder notation using impossible conditions, e.g. `∅ = { x : x =/= x }`, or `∅ = { x : x ∈ N, x < 0 }`;
* the empty set is always unique (i.e. there is one and only one empty set);
* the empty set is a subset of all sets;
-* the cardinality of the empty set is 1, i.e. `|∅| = 1`.
+* the cardinality of the empty set is 0, i.e. `|∅| = 0`.
## Representing sets
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
index 58dccae4..aaa592dc 100644
--- a/smalltalk.html.markdown
+++ b/smalltalk.html.markdown
@@ -22,7 +22,7 @@ Yes, everything. Integers are instances of one of the numeric classes. Classes a
- The system knows the class of the object receiving a message and looks up the message in that class's list of methods. If it is not found, the lookup continues in the super class until either it is found or the root of the classes is reached and there is still no relevant method.
- If a suitable method is found the code is run, and the same process keeps on going with all the methods sent by that method and so on forever.
- If no suitable method is found an exception is raised, which typically results in a user interface notifier to tell the user that the message was not understood. It is entirely possible to catch the exception and do something to fix the problem, which might range from 'ignore it' to 'load some new packages for this class and try again'.
-- A method (more strictly an instance of the class CompiledMethod) is a chunk of Smalltalk code that has been compiled into bytecodes. Executing methods start at the beginning and return to the sender when a return is encountered (we use ^ to signify 'return the follwing object') or the end of the code is reached, in which case the current object running the code is returned.
+- A method (more strictly an instance of the class CompiledMethod) is a chunk of Smalltalk code that has been compiled into bytecodes. Executing methods start at the beginning and return to the sender when a return is encountered (we use ^ to signify 'return the following object') or the end of the code is reached, in which case the current object running the code is returned.
### Simple syntax
Smalltalk has a simple syntax with very few rules.
@@ -41,7 +41,7 @@ We are sending the message 'doSomethingWith:' to myObject. This happens to be a
'myObject' is a 'MyExampleClass' instance so the system looks at the list of messages understood by MyExampleClass
- beClever
-- doWierdThing:
+- doWeirdThing:
- doSomethingWith
In searching we see what initially looks like a match - but no, it lacks the final colon. So we find the super class of MyExampleClass - BigExampleClass. Which has a list of known messages of its own
diff --git a/sql.html.markdown b/sql.html.markdown
index 5edf0f7c..685e522d 100644
--- a/sql.html.markdown
+++ b/sql.html.markdown
@@ -5,7 +5,7 @@ contributors:
- ["Bob DuCharme", "http://bobdc.com/"]
---
-Structured Query Language (SQL) is an ISO standard language for creating and working with databases stored in a set of tables. Implementations usually add their own extensions to the language; [Comparison of different SQL implementations](http://troels.arvin.dk/db/rdbms/) is a good reference on product differences.
+Structured Query Language (SQL) is an [ISO/IEC 9075](https://www.iso.org/standard/63555.html) standard language for creating and working with databases stored in a set of tables. Implementations usually add their own extensions to the language; [Comparison of different SQL implementations](http://troels.arvin.dk/db/rdbms/) is a good reference on product differences.
Implementations typically provide a command line prompt where you can enter the commands shown here interactively, and they also offer a way to execute a series of these commands stored in a script file. (Showing that you’re done with the interactive prompt is a good example of something that isn’t standardized--most SQL implementations support the keywords QUIT, EXIT, or both.)
diff --git a/tr-tr/jquery-tr.html.markdown b/tr-tr/jquery-tr.html.markdown
new file mode 100644
index 00000000..4a4ebeae
--- /dev/null
+++ b/tr-tr/jquery-tr.html.markdown
@@ -0,0 +1,338 @@
+---
+category: tool
+tool: jquery
+contributors:
+ - ["Seçkin KÜKRER", "https://github.com/leavenha"]
+filename: jquery-tr-tr.js
+lang: tr-tr
+---
+
+# Tanım
+
+jQuery, (IPA: ˈd͡ʒeɪˌkwɪəɹiː).
+j + Query, olarak isimlendirilmiş, çünkü çoğunlukla HTML elementlerini sorgulamak ve onları manipüle etmek için kullanılır.
+
+jQuery, 2006 yılında geliştirilmiş ve günümüzde halen kullanımı yaygın, görece en popüler çapraz-platform JavaScript kütüphanelerinden birisidir. Şimdilerde jQuery ekibi tarafından gelişimi devam etmektedir. Dünyanın bir çok yerinden büyük şirketler ve bağımsız yazılım ekipleri tarafından kullanılmaktadır.
+
+Genel kullanım amacı animasyonlardır; Galeri, ek menü, sayfa geçişleri, ve diğer tüm gerçeklemelere sağladığı kolaylıkla birlikte Flash'ın alternatifi olarak yorumlanabilir. [Ajax][ajax-wikipedia-page] işlemleri de dahil olmak üzere olay-yönetimi, döküman manipülasyonu ve bir çok programlama görevini kolaylaştırır.
+
+Resmi sitesinden ([jQuery][jquery-official-website]) indirip web sitenize yükleyebilirsiniz. jQuery günümüz JavaScript kütüphaneleri gibi, küçültülmüş boyutlarda bulut tabanlı İçerik Dağıtım Ağı sistemleri sayesinde bağımsız olarak da sitenize eklenebilir.
+
+Kütüphanenin kullanımı ile, jQueryUI gibi ek paketlerle gelişmiş ve modern arayüzler gerçekleyebilirsiniz.
+
+Fakat, jQuery'ye giriş yapmadan önce elbetteki bu kütüphanenin üzerine kurulduğu teknoloji olan [JavaScript'i öğrenmelisiniz][javascript-learnxinyminutes-page].
+
+```js
+
+// Bu belgedeki değişken isimleri Türkçe,
+// ve [Lower Camel Case] notasyonu uygulamaktadır.
+// Bu belgedeki kod parçalarının çıktıları,
+// onları uyguladığınız dökümanın içeriğine bağlı olarak değişmektedir.
+
+// Döküman boyunca, aşağıdaki gösterimde
+// Kod - Çıktı ikilisi ile içeriğin anlamlandırılması
+// kolaylaştırılmaya çalışmıştır.
+// ornek_kod_parcasi();
+// => "ÖRNEK ÇIKTI"
+
+// *. Konsept
+// jQuery DOM nesnelerini seçmek için inovatif bir yol sunar.
+// `$` değişkeni, `jQuery` kütüphanesine işaret eder.
+// Fonksiyon notasyonu ile DOM nesnelerini elde eder
+// ve üzerinde işlemler gerçekleştirirsiniz.
+$(window)
+// => jQuery [Window] (1)
+// Bize tarayıcının belirlediği window nesnesini verir.
+
+// 1. Seçiciler
+// Tüm nesneleri seçmek için `*` çağırımı yapılır.
+const hepsi = $('*');
+// => jQuery [<html>, <head>, <meta>,
+// .... <meta>, <title>, <meta>, <meta>,
+// .... <meta>, <link>, <link>, …] (1134) = $1
+
+// Seçiciler, jQuery'de bir nesne seçmek için kullanılırlar,
+const sayfa = $(window);
+// => jQuery [window] (1)
+// Sayfa, açık döküman nesnesini seçer.
+
+// Elementler, kendileri için seçicidirler.
+const tumParagraflar = $('p');
+// => jQuery [<p>, <p>, <p>] (3)
+
+// Seçiciler aynı zamanda CSS seçicileri olabilir.
+const mavi = $('.mavi');
+// => jQuery [<p class='mavi'] (1)
+
+// Aynı zamanda element ile birlikte kullanılabilirler.
+const maviParagraf = $('p.mavi');
+// => jQuery [<p class='mavi'>] (1)
+
+// Özellik seçicileri de mevcuttur,
+// Elementin özelliği için seçim yaparlar.
+const isimSecicisi = $('input[name*="kayit.form"]');
+// => jQuery [<input name='kayit.form.sifre'>,
+// <input name='kayit.form.dogumtarihi'> ...] (10)
+
+// Diğer özellik seçiciler;
+/*
+- Özelliğin içinde arayan; *=
+- Özelliğin içinde verilen kelimeleri arayan; ~=
+ |-(kelimeler boşlukla ayrılmalı, *='den farkına dikkat ediniz.)
+- Özelliğin başlangıç verisini arayan; ^=
+- Özelliğin bitiş verisini arayan; $=
+- Özelliği tamamen karşılaştıran; =
+- Özelliğin eşitsizlik durumunu karşılaştıran; !=
+
+Diğer tüm seçiciler için resmi siteyi kontrol ediniz.
+*/
+
+// 2. Olaylar ve Efektler
+// - Olaylar
+// jQuery kullanıcı ile tarayıcı arasındaki etkileşimi olaylar ile ele alır.
+
+// En yaygın kullanımı tartışmasız ki Dökümanın Yüklenmesi olayıdır.
+
+// $.ready fonksiyonu, argüman olarak aldığı fonksiyonu,
+// seçilen eleman tamamen yüklendiğinde çağıracaktır.
+$(document).ready(function(){
+ // Dökümanın tamamı yüklendiğine göre, iş mantığımı çağırabiliriz.
+ console.info('Döküman yüklendi!');
+})
+// => jQuery [#document] (1)
+
+// Bir dökümanın tamamının yüklenmeden,
+// herhangi bir iş mantığı çalıştırmanın
+// neden kötü bir fikir olduğunu merak ediyorsanız,
+// ileri okuma kısmına danışabilirsiniz.
+
+// Önce Olay tanımlayalım.
+
+// Tıklama olayı için `$.click` olay tetikleyicisi kullanılıyor.
+$('.mavi').click(function(){
+ // Unutmayın ki, önceden tanımlanmış
+ // bir fonksiyonu da argüman olarak verebilirsiniz.
+ console.info('Mavi butona tıkladın!');
+})
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Çift Tıklama olayı için `$.dblclick` olay tetikleyicisi kullanılıyor.
+$('.mavi').dblclick(function(){
+ console.info('Mavi butona çift tıkladın!');
+})
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Seçilen Elemente birden fazla tetiklenecek fonksiyon tanımalamak
+// istersek, Olayları ve Fonksiyonları Anahtar-Değer yapısı sağlayan
+// Objeleri kullanarak da çağırabiliriz.
+
+// => tetiklenecekFonksiyon
+$('.mor').on({
+ click: () => console.info('Tek tıklama ile tetiklendim!'),
+ dblclick: () => console.info('Çift tıklama ile tetiklendim!'),
+ // ...
+});
+// => jQuery [<button>, <button>, <button>, <button>, <button>, …] (365)
+
+// Diğer olay tetikleyicileri;
+/*
+Elemente,
+- Fokus/Odaklanma; $.focus
+- Fokus/Odaklanmanın kaybedilmesi; $.blur
+- Farenin alanına girmesi; $.mouseenter
+- Farenin alanından çıkması; $.mouseleave
+
+Diğer tüm olay tetikleyicileri için resmi siteyi kontrol ediniz.
+*/
+
+// Tanımlanan olayları tetiklemek için,
+// Kullanıcı-Tarayıcı etkileşimi yerine elle çağrı yapmak da mümkün.
+// Tanımlama ile çağırım arasındaki fark sadece sağlanan argümanlardır.
+// Argümansız çağırım, olayı tetikler.
+
+// Tıklama olayını tetiklemek için.
+$('.mavi').click();
+// => Mavi butona tıkladın!
+// => jQuery [<button>] (1)
+
+// Çift Tıklama olayını tetiklemek için.
+$('.mavi').dblclick();
+// => Mavi butona çift tıkladın!
+// => jQuery [<button>] (1)
+
+// - Efektler
+// jQuery bir çok ön-tanımlı efekt sunmakta.
+// Bu efektler, belirli parametlerle, farklı iş mantıklarını
+// gerçeklemenize izin verebilir.
+// Önce parametresiz işlevlere göz atalım.
+
+// Elementleri saklayabilir,
+$('#slaytresmi').hide();
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Gizlenen elementleri tekrar görünür yapabilir,
+$('#slaytresmi').show();
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Yada dilediğiniz CSS niteliğini anime edebilirsiniz,
+
+// Bu parametre, anime etmek istediğiniz CSS özelliklerini
+// belirleyen Obje bilgisidir.
+// Yükseklik ve Genişlik bilgileri için değerler belirliyoruz.
+const animeEdilecekCSSOzellikleri =
+ {
+ weight: "300px",
+ height: "300px"
+ };
+
+// Diğer anime edilebilir CSS özellikleri;
+/*
+Elementin,
+- Opaklık; opacity
+- Dış çevre mesafesi; margin
+- Çerçeve yüksekliği; borderWidth
+- Satır yüksekliği; lineHeight
+
+Diğer tüm özellikler için resmi siteyi kontrol ediniz.
+*/
+
+// Bu parametre animasyonun süresini belirler.
+const milisaniyeCinsindenAnimasyonSuresi =
+ 1200;
+
+// Bu parametre, 'linear' yada 'swing' metin
+// bilgilerinden birini alır ve animasyonun
+// akıcılığını belirler.
+// x ∈ {'linear', 'swing'}
+const animasyonAkiciligi = 'linear';
+
+// Bu parametre, bir fonksiyondur ve
+// animasyondan sonra çağırılır.
+// Bir geri-çağırım (callback*) olarak değerlendirilebilir.
+const animasyonGeriCagirimFonksiyonu = function(){
+ console.info('Animasyon bitti!');
+};
+
+// Şimdi tanımlanan bilgilerimizle animasyonu çağırıyoruz.
+$('#slaytresmi').animate(animeEdilecekCSSOzellikleri,
+ milisaniyeCinsindenAnimasyonSuresi,
+ animasyonAkiciligi,
+ animasyonGeriCagirimFonksiyonu);
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Kütüphane `$.animate` fonksiyonu için, anime edeceğiniz
+// CSS özellikleri dışındaki tüm argümanlar için
+// ön tanımlı değerler sağlamaktadır.
+// Bu değerler için resmi siteyi kontrol ediniz.
+
+// Diğer ön tanımlı efektler;
+/*
+Elementi,
+- Yukarı kaydırır; $.slideUp
+- Verilen saydamlık değerine anime eder; $.fadeTo
+- Görünür yada görünmez yapar (geçerli durumuna bağlı); $.toggle
+
+Diğer tüm efektler için resmi siteyi kontrol ediniz.
+*/
+
+// 3. Manipülasyon
+
+// jQuery'de, HTML elementlerinin isteğiniz doğrultusunda
+// değiştirilmesi için araçlar sunulmakta.
+
+// Bir ön-tanımlı CSS sınıfımız olduğunu hayal edebilirsiniz.
+// Bu sınıfı istediğimiz elemente uygulamak için,
+$('#slaytresmi').addClass('inanilmaz-bir-cerceve-sinifi');
+// => jQuery [<img id='slaytresmi' class='inanilmaz-bir-cerceve-sinifi'>] (1)
+
+// Bu CSS sınıfını istediğimiz zaman silebiliriz,
+$('#slaytresmi').removeClass('inanilmaz-bir-cerceve-sinifi');
+// => jQuery [<img id='slaytresmi'>] (1)
+
+// Bu HTML elementini, istediğimiz başka bir element ile çevreleyebiliriz,
+$('#slaytresmi').wrap('<div class="farkli-bir-cerceve"></div>');
+// => jQuery [<img id='slaytresmi'>] (1)
+// Sonucun gözlemlenebilmesi için, elementin çevreleme işlemi sonrası
+// döküman üzerindeki yapısını temel bir seçici ile gözlemleyebiliriz;
+$('.farli-bir-cerceve')
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+// <img id='slaytresmi'>
+// </div>
+
+// Elemente içerik ekleyebiliriz,
+// Eklemeler döküman içeriğinin sonuna yapılacaktır.
+// Bu süreci daha iyi gözlemleyebilmek için içeriğine bakmamız yeterli,
+// Ekleme öncesinde;
+$('.farkli-bir-cerceve');
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+// <img id='slaytresmi'>
+// </div>
+
+// `$.append` fonksiyonu ile ekleme işlemini yapıyoruz.
+$('.farkli-bir-cerceve').append('<h1>Bu çerçeve farklı!</h1>');
+// => jQuery [<div class='farkli-bir-cerceve>] (1)
+// => <div class="farkli-bir-cerceve">
+// <img id='slaytresmi'>
+// <h1>Bu çerçeve farklı!</h1>
+// </div>
+
+// Dökümandan element silebiliriz,
+$('.farkli-bir-cerceve > h1').remove();
+// => jQuery [<h1>] (1)
+
+// Dökümanın güncel halini görmek için seçiciyi çağırıyoruz,
+$('.farkli-bir-cerceve');
+// => jQuery [<div class='farkli-bir-cerceve>] (1**
+// => <div class="farkli-bir-cerceve">
+// <img id='slaytresmi'>
+// </div>
+
+// Elementlerin özniteliklerini değiştirebilir yada
+// silebiliriz.
+// Öznitelik erişici ve değiştiricisi,
+// Bir fonksiyon notasyonuyla yapılanmış durumda.
+// Eğer bir öznitelik bilgisini almak istiyorsak, ilgili öznitelik
+// ismini;
+
+$('.farkli-bir-cerceve > img').attr('id');
+// => 'slaytresmi'
+
+// Eğer bir öznitelik bilgisini güncellemek istiyorsak,
+// ilgili öznitelik ismi ve sonrasında yeni değerini argüman
+// olarak $.attr fonksiyonuna iletiyoruz;
+
+$('.farkli-bir-cerceve > img').attr('id', 'cercevelislaytresmi');
+// => jQuery [<img id='cercevelislaytresmi'>] (1)
+
+// Diğer ön fonksiyonlar;
+/*
+Elementin,
+- Yükseklik değeri, $.height
+- HTML döküman içeriği, $.html
+- Girdi içeriği, $.val
+- Verilen CSS sınıfına sahipliği, $.hasClass
+
+Diğer tüm manipülasyon fonksiyonları için resmi siteyi kontrol ediniz.
+*/
+
+```
+
+## Notlar
+
+- Yaygın bir yanlış bilineni düzeltmek adına; jQuery bir çalışma-çatısı değil, bir *kütüphanedir*.
+- [Lower Camel Case][lower-camel-case-notasyonu] notasyonu için Wikipedia sayfası.
+
+## İleri Okuma
+
+### İngilizce
+
+- [jQuery][jquery-official-website] resmi sitesi.
+
+- [Jakob Jenkov | $(document).ready article](http://tutorials.jenkov.com/jquery/document-ready.html)
+
+[jquery-official-website]: https://jquery.com
+[ajax-wikipedia-page]: https://en.wikipedia.org/wiki/Ajax_(programming)
+[javascript-learnxinyminutes-page]: https://learnxinyminutes.com/docs/javascript/
+[lower-camel-case-notasyonu]: https://en.wikipedia.org/wiki/Camel_case#Programming_and_coding
diff --git a/tr-tr/ruby-tr.html.markdown b/tr-tr/ruby-tr.html.markdown
new file mode 100644
index 00000000..7bc21c83
--- /dev/null
+++ b/tr-tr/ruby-tr.html.markdown
@@ -0,0 +1,1598 @@
+---
+name: ruby
+language: ruby
+filename: learnruby-tr.rb
+contributors:
+ - ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
+lang: tr-tr
+---
+
+# Dile nazik bir giriş.
+
+## Ruby Nedir ?
+
+Ruby, doğrudan bir Google aramasıyla aklınızdakini bulmanız zor olabilir. İngilizce bu kelime, `Ruby` (IPA: ˈruːbi) "kırmızı taş" anlamına gelen Fransızca kökenli bir kelime olan `rubi`'den gelmektedir.
+
+Yaratıcısı tarafından, yine esinlenilen bir dil olarak ortaya çıkan `Ruby`, Perl, Smalltalk, Eiffel, Ada, Lisp programlama dillerinin en iyi özelliklerini almıştır. ! [İmperativ]() programlama mentalitesi üzerine kurmayı seçtiği bu teknoloji, günümüzde sektöründe öncü.
+
+
+## Tarihçe
+
+Ruby 1995’te halka duyurulduğundan beri, dünya çapında programcıların dikkatini çekmeye başlamıştır. 2006 Ruby’nin altın yılı olmuştur. Dünyanın en büyük şehirlerinde aktif kullanıcı grupları ve Ruby ile ilgili konferanslar gerçekleştirilmiştir.
+
+Daha sonraları `Ruby`, dünya çapında programlama dillerinin büyümesini ve popülaritesini ölçen dizinlerin (TIOBE dizini gibi) çoğunda ilk 10 içinde yer almıştır. Büyümenin çoğu, Ruby ile yazılmış yazılımların popülaritesiyle ilgilidir, özellikle de Ruby on Rails web çatısıyla.
+
+! [kaynak]()
+
+## Sektördeki Konumu ve Geleceği ?
+
+Çoğu uzmana göre, şu anda sadece `Rails` teknolojisi için bir betik dili olarak sıkışmış durumda.
+
+Bazıları ise, dilin kendi geleceğini, 2020 içinde yayınlanması planlanan `Ruby 3` ile sağlamlaştıracağını ve yeni imkanlar ve sektörek kullanım ve tercihler ile popüleritesinin artacağını düşünüyor.
+
+## Her Şey Nesne
+
+Matz'ın incelemiş olduğu diller sonucunda, teknik olarak en iyi sözdizimin kaynağını “Perl’den daha güçlü ama Python’dan daha nesneye yönelik bir betik dili” olarak tanımlamış.
+
+Her şeyin Nesne olarak görüldüğü bir programlama teknolojisi, bütünlük kavramı açısından herkese kucak açan bir pürüzsüzlük sunuyor. `Ruby`'nin neden tartışmasız, saf bir Nesne yönelimli bir programlama dili olduğuna dair örnekleri aşağıda vereceğim.
+
+## Diğer Gerçeklemeler
+
+- [JRuby](http://jruby.org/), JVM’in (Java Virtual Machine) üstünde çalışan Ruby’dir, JVM’in eniyileyen JIT derleyicisi, çöp toplayıcısı, eşzamanlı thread’leri, araç ekosistemi, ve muazzam sayıdaki kütüphanelerinden faydalanır.
+- [Rubinius](http://rubini.us/), ‘Ruby’da yazılmış Ruby’dir’. LLVM’in üstüne inşa edilmiştir ve ayrıca diğer dillerin üstüne inşa edebilecekleri şık bir sanal makine de sunar.
+- [TruffleRuby](https://github.com/oracle/truffleruby), GraalVM’in üstünde çalışan yüksek performanslı bir Ruby gerçeklemesidir.
+- [IronRuby](http://www.ironruby.net/), “.NET Web Çatısı’yla sıkı sıkıya bağlı” bir gerçeklemedir.
+
+Diğer gerçeklemeler için, lütfen ileri okumaya danışınız.
+
+```ruby
+# Bu karakter ile başlayan satırlar, yorum satırı olarak değerlendirilir.
+# Diğer yorum satırı tanımlamaları için tanımlamalar ve ifadeler kısmına danışın.
+
+## Örnek yapısı; bu örnek dosyadaki her Ruby ifadesi, Ruby yorumlayıcısı
+## tarafından yorumlanarak sonucu `=>` ifadesinin sağına yazılır.
+## örnek ifade #=> örnek sonuç
+## formatındadır.
+## Bazen satır aşımını önlemek için
+## örnek ifade
+## #=> örnek sonuç
+## şeklinde yer verilecektir.
+
+# --------------------------------
+# Veriler ve Temsilleri
+# --------------------------------
+
+## --
+## Sayılar:
+## --
+### Ruby, tamsayı veri tipini destekler. Sayısal değerlerin sisteminizdeki temsili
+### bu veri yapısıdır.
+
+# Tam sayı örneği.
+1453 #=> 1453
+
+## Okunabilirlik için, binlik ya da ondalık kısmını `_` ile
+## ayırmak mümkündür ve bu karakter tümüyle görmezden gelinir.
+3_14 #=> 314
+
+## Negatif sayılar `-` ile başlıyor.
+-3750 #=> -3750
+
+## Oktal sayılar
+03603 #=> 1923
+
+## Onaltılık sayılar
+0x23B #=> 571
+
+## İkilik sayılar
+0b11110000011 #=> 1923
+
+## Büyük sayılar temsili
+12345678901234567890 #=> 12345678901234567890
+
+## Kayan noktalı sayılar
+
+## Bir kayan-noktalı/Ondalıklı sayı.
+3.14 #=> 3.14
+
+## Bilimsel notasyon
+1.0e3 #=> 1000.0
+
+## Bir ipucu,
+## üsten önce işaret!
+3e+9 #=> 3000000000.0
+
+## --
+# Mantıksal Değerler
+## --
+
+## Mantıksal doğru ifadesi.
+true #=> true
+
+## Mantıksal yanlış ifadesi.
+false #=> false
+
+## --
+# Metinler
+## --
+
+## Metin sabitleri
+'Bu, bir metin ifadesi.'
+
+## Kaçışlar için
+'Kaçışlar için "\\"' #=> "Kaçışlar için \"\\\""
+
+## Alternatif ise çift tırnaklı ifadeler.
+"Bu da bir metin ifadesi."
+
+## Kaçışlarda farkı ise,
+"Kaçılar için '\\'" #=> "Kaçılar için '\\'"
+## bazı kaçış notasyonlarına gerek kalmaması.
+
+## Bazı notasyon karakterleri
+
+### Yeni Satır (New Line 0x0a)
+"\n" #=> "\n"
+
+### Boşluk (Space 0x20)
+"\s" #=> "\s"
+
+## --
+# Karakterler
+## --
+
+## Basitçe önlerine soru işareti getirilmiş
+## tek karakter sabitleridir.
+?a #=> "a"
+
+
+## --
+# Semboller
+## --
+## Ruby'de semboller, temsilleri bakımından
+## Clojure'daki semboller ile benzerlerdir.
+:sembol #=> :sembol
+
+## Kendileri, birinci sınıf değerdir.
+:türk.class #=> Symbol
+## Ve aynı zamanda Unicode desteği vardır. (1.9 sürümünden beri)
+
+
+## --
+# Diziler
+## --
+## Basitçe, Ruby dizileri birilerinden virgül ile ayrılmış,
+## değer veya değer sahibi referansların köşeli parantezler
+## ile çevrelenmesi ile oluşturulur. ([])
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+## Metinler için de durum aynı.
+["Mustafa", "Kemal", "ATATÜRK"] #=> ["Mustafa", "Kemal", "ATATÜRK"]
+
+## Aynı zamanda, Ruby dizileri tip bağımsız nesne ardışıklarıdır.
+[1881, "Mustafa", "Kemal", "ATATÜRK", 1923, "∞"]
+## Aynı zamanda Unicode destekler (1.9 sürümünden beri)
+
+## --
+# Eşlemeler
+## --
+## Ruby eşlemeleri, süslü parantezler içinde virgül ile ayrılan,
+## anahtar ve değer ikililieridir.
+
+## Bir tane de olabilir,
+{"izmir" => "kızları"} #=> {"izmir" => "kızları"}
+
+## Ya da, birden fazla...
+{"izmir" => "kızları", "paris" => "sokakları"} #=> {"izmir" => "kızları", "paris" => "sokakları"}
+
+## Aslında her değeri anahtar veya değer olarak
+## yerleştirmek mümkün.
+
+## Sembolleri,
+{:zafer => "30 Ağustos!"} #=> {:zafer=>"30 Ağustos!"}
+
+## Rakamları bile.
+{28101923 => "Efendiler, yarın Cumhuriyeti'i ilân edeceğiz!"}
+#=> {28101923=>"Efendiler, yarın Cumhuriyeti'i ilân edeceğiz!"}
+
+## Semboller için ufak bir sözdizimsel şekerleme mevcut ki,
+{istanbul: "beyefendi"} #=> {:istanbul=>"beyefendi"}
+## Bu kullanıma göre, sembol anahtarlar ile değerler arasına
+## `=>` yerine basitçe sembolün başına gelecek `:` sembolü
+## getiriliyor.
+
+
+## --
+# Aralıklar
+## --
+## Ruby aralıkları temeliyle başlangıç ve bitiş
+## değerleri arasındaki aralığın veriye dönüştürülmesi
+## için bir dil olanağıdır.
+
+## (başlangıç..bitiş) notasyonu kullanılabilir.
+(0..10) #=> 0..10
+## REPL'ın bize verdiği ifade sizi yanıltmasın, bu bir aralıktır.
+## Meraklılarıyla, dökümanın devamında içindeki değerleri
+## gezeceğiz.
+
+## Range.new notasyonu ile de ilklenebilirler.
+Range.new(0, 10) #=> 0..10
+
+## --
+# Düzenli İfadeler
+## --
+## İki / operatörünün ortasına tanımlanırlar.
+//.class #=> Regexp
+
+## Örnek bir düzenli ifade, a harfi için.
+/[a]/ #=> /[a]/
+
+# --------------------------------
+# Değelerin Manipüle edilmesi
+# --------------------------------
+
+## --
+## Rakamlar
+## --
+
+## Aritmatik, bildiğimiz şekilde.
+## !! infix notasyon
+
+235 + 1218 #=> 1453
+123 - 35 #=> 88
+2 * 2 #=> 4
+1 / 1 #=> 1
+
+## Bit tabanlı işlemler.
+2 & 5 #=> 0
+3 | 9 #=> 11
+2 ^ 5 #=> 7
+## Aslında C tipi ailesi dillerdeki gibi. Sezgisel bir yaklaşımla, hayatta kalınabilir.
+## Ama yine de dökümantasyona başvurulmasını tavsiye ederim.
+
+
+## --
+## Mantıksal
+## --
+
+## ! operatörü teklidir, ve aldığı değerin mantıksal tersini alır.
+!true #=> false
+!false #=> true
+
+
+## --
+## Metinler
+## --
+
+### Boş mu ?
+"".empty? #=> true
+
+### Bir bölümünü alalım.
+"Ölürüm TÜRKİYEM!".slice(7, 7) #=> "Türkiye"
+## Bir başka şekilde, indis notasyonu ile,
+"Ölürüm Türkiye'm!"[7, 7] #=> "Türkiye"
+
+## Küçük harfe dönüştürelim
+"LAY-LAY-LOM sana göre sevmeler...".downcase
+#=> "lay-lay-lom sana göre sevmeler..."
+
+## Büyük harfa dönüştürelim
+"beşiktaş".upcase #=> "BEŞIKTAŞ"
+
+## Karakterlerine ayıralım
+"BEŞİKTAŞ".chars #=> ["B", "E", "Ş", "İ", "K", "T", "A", "Ş"]
+
+## Çevrelemek için
+"Ahmet Mete IŞIKARA".center(30)
+#=> " Ahmet Mete IŞIKARA "
+
+## İçerik kontrolü için include metodu
+"aşk".include?(?a) #=> true
+## argümanı metin tipinde de verebilirdik, ama
+## yukarıdaki temsillerde gördüğümüz gibi,
+## yorumlayıcı, karakter sabitini metin olarak işliyor zaten.
+
+## Konumunu alalım.
+"Dayı".index("a") #=> 1
+## Elbette, tasarımında sağlıklı kararlar alınmış her
+## dil gibi, Ruby'de 0'dan saymaya başlıyor.
+
+## Metin yerleştirme yapalım
+"Ali Baba'nın x çiftliği var.".sub("x", "bir")
+#=> "Ali Baba'nın bir çiftliği var."
+
+## Birden fazla eşleşme için, değiştirme yapalım
+"Dal sarkar x kalkar, x kalkar dal sarkar.".gsub("x", "kartal")
+#=> "Dal sarkar kartal kalkar, kartal kalkar dal sarkar."
+
+## Düzenli ifadeler ile, cümledeki sesli harfleri değiştirelim.
+"Bir berber bir bere...".gsub(/[ie]/, "*")
+#=> "B*r b*rb*r b*r b*r*..."
+
+## Diğer işlevler için ileri okumadaki kaynağa başvurunuz.
+
+
+## --
+## Eşlemeler
+## --
+
+## basit bir eşleme ile başlayalım.
+{:boy => 1.74} #=> {:boy => 1.74}
+
+## Belirli bir anahtar, eşlememizde barınıyor mu diye
+## kontrol ediyoruz.
+{:boy => 1.74}.has_key? :boy
+#=> true
+## Parantezlerin yokluğu sizi yanıltmasın,
+## bu bir fonksiyon çağırısıdır.
+
+## Eşlemeden veri çekiyoruz
+{:boy => 1.74}.fetch :boy
+#=> 1.74
+
+## Eşlemelere veri ekliyoruz
+{:boy => 1.74}.merge!(kilo: 74)
+#=> {:boy=>1.74, :kilo=>74}
+
+## Anahtarlarımıza bakalım
+{:boy=>1.74, :kilo=>74}.keys
+#=> [:boy, :kilo]
+
+## Değerlerimize bakalım
+{:boy=>1.74, :kilo=>74}.values
+#=> [1.74, 74]
+
+## Dizi olarak almak istersek
+{:boy=>1.74, :kilo=>74}.to_a
+#=> [[:boy, 1.74], [:kilo, 74]]
+## Endişelenmeyin, dönüşümler için koca bir bölüm
+## ayırdım.
+
+
+## --
+## Diziler
+## --
+
+## Örnek bir dizi ile başlayalım.
+["Mustafa", "Kemal", "ATATÜRK"]
+#=> ["Mustafa", "Kemal", "ATATÜRK"]
+
+## İlk değeri alıyoruz
+["Mustafa", "Kemal", "ATATÜRK"].first
+#=> "Mustafa"
+
+## Son Değeri,
+["Mustafa", "Kemal", "ATATÜRK"].last
+#=> "ATATÜRK"
+
+## Indis araması için `fetch` metodu.
+["Mustafa", "Kemal", "ATATÜRK"].fetch 1
+#=> "Kemal"
+
+## Var olamyan bir indis ararsak hata alıyoruz.
+
+## Fakat seçimli ikinci argüman bize indisin
+## bulunamaması halinde döndürülecek değeri
+## belirleme imkanı veriyor.
+["Mustafa", "Kemal", "ATATÜRK"].fetch 20101927, "Nutuk"
+#=> "Nutuk"
+
+## Birden fazla değer almak için, slice metodunu
+## kullanabiliriz
+["Fatih", "Sultan", "Mehmet"].slice 1..2
+#=> ["Sultan", "Mehmet"]
+
+## Ya da, indis notasyonu da kullanılabilir.
+["Fatih", "Sultan", "Mehmet"][1..2]
+#=> ["Sultan", "Mehmet"]
+
+## Baştan n tane eleman almak için take metodunu kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].take 2
+#=> ["Fatih", "Sultan"]
+
+## Rastgele bir dizi elemanı elde etmek için sample metodunu
+## kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].sample
+#=> "Fatih"
+
+## `sample` metodu seçimli bir argüman kabul eder.
+## bu argüman rastgele istenen eleman sayısını temsil eder
+["Fatih", "Sultan", "Mehmet"].sample 2
+#=> ["Fatih", "Sultan"]
+
+## Aradığınız eleman, dizide var mı kontrolü için
+## include? metodu kullanılıyor
+["Fatih", "Sultan", "Mehmet"].include? "Fatih"
+#=> true
+
+## Dizinizdeki elemanları koşul dahilinde seçimlemek için
+## select metodunu kullanıyoruz
+["Fatih", "Sultan", "Mehmet"].select {|s| s.include? ?a}
+#=> ["Fatih", "Sultan"]
+## Süzme işleminin koşulu, a karakteri içeren nesneler için olumlu.
+## Not: filter metodu, select için bir takma addır.
+
+## Ters bir yöntem, süzgeçleme için ise;
+["Fatih", "Sultan", "Mehmet"].reject {|s| s.include? ?a}
+#=> ["Mehmet"]
+## koşulumuz aynıydı, seçimleme metodumuzu değiştirdik.
+
+### Yapısal düzenlemeler için:
+## Dizileri ters çevirmek,
+["Fatih", "Sultan", "Mehmet"].reverse
+#=> ["Mehmet", "Sultan", "Fatih"]
+
+## Sıralamak için sort metodu,
+["İş", "Aşk", "Para"].sort
+#=> ["Aşk", "Para", "İş"]
+
+## Ön koşulla sıralamak için,
+["İş", "Aşk", "Para"].sort {|a,b| b <=> a }
+#=> ["İş", "Para", "Aşk"]
+## Koşulumuz basitçe tersine sıralamak için bir tanımdır.
+## ileride karşılaştırma operatörlerini göreceğiz.
+
+## Tekrarlı elemanların temizlenmesi için
+[1,2,3,4,5,6,7,1,2,4,1,5,6,1,2,5].uniq
+#=> [1, 2, 3, 4, 5, 6, 7]
+
+## Dizilerin birleştirilmesi için
+[1,2] + [3,4]
+#=> [1, 2, 3, 4]
+## infix notasyon sizi yanıltmasın,
+## tasarımı gereği, her şey sınıflar ve metotlarına çağırım
+## olarak yürüyor.
+## Kanıtlayalım;
+[1,2].+([3,4])
+#=> [1, 2, 3, 4]
+
+## Peki ya aynı elemanları içerebilecek dizileri birleştirmek
+## istersek ?
+[1,2] | [2,3,4]
+#=> [1, 2, 3, 4]
+## | operatörü bizi, nihai sonuçtaki tekrarlı veriden koruyor.
+
+## Peki ya bir diziyi, eleman bazında diğeriyle
+## süzmek istersek ?
+[1,2] - [2,3,4]
+#=> [1]
+## Notasyon sizi yanıltmasın, Küme gibi davranan bir dizi işlevi.
+
+### Veri Dönüşümleri için:
+## Dizideki her elemana uygulamak istediğiniz bir
+## dönüşümü, map metodu ile uygulayabilirsiniz,
+["Kontak İsmi",
+ "Kontak Telefon Numarası"].map {|element| "<label>#{element}</label>"}
+#=> ["<label>Kontak İsmi</label>", "<label>Kontak Telefon Numarası</label>"]
+## HTML konusu için yine LearnXinYminutes'e danışabilirsiniz.
+
+## Son elde ettiğimiz veriyi birleştirmek için,
+["<label>Kontak İsmi</label>",
+ "<label>Kontak Telefon Numarası</label>"].join ""
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+
+## Veriyi indirgemek için ise reduce metodu kullanırız,
+["<label>Kontak İsmi</label>",
+ "<label>Kontak Telefon Numarası</label>"]
+ .reduce("") {|akümülatör, veri| akümülatör + veri}
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+## Akümülatör, her operasyondan dönen ara-geçici değer.
+## Bu değeri, parantez içinde ilkledik,
+## eğer vermeseydik, dizinin ilk elemanı olacaktı.
+
+## Tabi, daha kolay bir yolu var;
+["<label>Kontak İsmi</label>",
+ "<label>Kontak Telefon Numarası</label>"].reduce(:+)
+#=> "<label>Kontak İsmi</label><label>Kontak Telefon Numarası</label>"
+## reduce metodu, ikili bir operasyonu (akümülatör için metot!)
+## sembol olarak vermenize izin verir ve bu, reduce için
+## indirgeme fonksiyonu olarak kullanılır.
+
+## Nüansları olsa da, son üç Ruby çağırımı aynı sonucu vermektedir.
+
+
+## --
+## Semboller
+## --
+
+## Ruby sembolleri, çalışma zamanında değiştirilemezler.
+## Ama metinsel değerlerden semboller elde etmek mümkündür.
+## Bunu dönüşümler kısmında işlemek daha doğru olacak diye düşündüm.
+
+# --------------------------------
+# Dönüşümler
+# --------------------------------
+
+## --
+# Rakamlar
+## --
+
+## Sayısal değerlerin diğer tiplere dönüşümü;
+
+## Sayısal -> Metinsel
+1923.to_s #=> "1923"
+
+## Sayısal -> Mantıksal
+!1923 #=> false
+## Farkedebileceğiniz gibi,
+## sayısal değerler, mantıksal doğru'ya değerlendiriliyor.
+
+## Sayısal -> Sembol
+## Maalesef, Ruby bile Sayısal değerden Sembol değerlerine
+## doğrudan dönüşüm için metot barındırmıyor.
+## Bunu yine de başarmak istersek, değeri önce
+## Metinsel'e dönüştürerek Sembol dönüşümü için hazırlarız.
+1923.to_s.to_sym
+#=> :"1923"
+
+## Sayısal -> Dizi | bölümlenerek
+## Yine doğrudan bir dönüşüm yoktur.
+## Böyle bir doğrudan dönüşüm teşvik de edilmez.
+## Ama ihtiyaç olabilecek bir dönüşüm.
+1923.to_s.split('')
+#=> ["1", "9", "2", "3"]
+## Öncelikle Metinsel dönüşüm yapılır, sonra
+## her bir karakter için ayrılır.
+## Yine her bir rakamı sayısal bir şekilde elde etmek için
+## her birini Metinsel'den Sayısal değere dönüştürecek
+## ifade aşağıdaki gibidir.
+1923.to_s.split('').map { |i| i.to_i }
+#=> [1, 9, 2, 3]
+
+
+## --
+# Mantıksal
+## --
+
+## Mantıksal -> Metinsel
+true.to_s #=> "true"
+false.to_s #=> "false"
+
+## Mantıksal değeler için gerçeklenmiş başka bir dönüşüm
+## metodu olmadığı için, bu kısmı dilde ufak bir nüansa ayırmak
+## istedim.
+## Kaynak için ileri okumaya başvurunuz.
+
+## Hangi programlama dilinden gelirseniz gelin,
+## dilde doğruluk değerleri diye bir küme vardır.
+## Hangi değerlerin mantıksal doğru değerine dönüşeceği,
+## bu değer yerine geçebileceği
+## fikri üzerine kurulu bir küme.
+## Ve Ruby'de nil değeri, false dışında, mantıksal yanlış değerine çözümlenen tek şey.
+## Bu ön bilgi ile doyduysak, başlayalım.
+
+!!nil #=> false
+!!false #=> false
+!!0 #=> true
+!!"" #=> true
+## Şimdi ne oldu burada ?
+## `!!` ifadesi; değilinin değili, yani kendisi. Tek bir farkla.
+## Verinin türü değiştiriliyor. Mantıksal olarak yorumlanıyor.
+## Yukarıda, nil ve false ifadeleri mantıksal olarak yanlış olarak yorumlanıyor.
+## Diğerleri ise mantıksal doğru.
+
+
+## --
+# Metinsel
+## --
+
+## Metinsel -> Sayısal
+## Öncelikle dilde ufak bir tuzağa dikkat çekmek isterim.
+"".to_i #=> 0
+"asd".to_i #=> 0
+## Sayısal yorumlaması geçersiz ve boş her metinsel değer,
+## 0 rakamına değerlendirilir.
+
+## Başarılı bir dönüşüm,
+"1234".to_i #=> 1234
+
+## Sayı sistemini belirleyebileceğiniz seçimli bir argüman
+## kabul ediyor, to_i metodu.
+"1234".to_i 5 #=> 194
+## 1234 sayısının, beşlik tabandaki karşılığı.
+
+## Tam sayı dışında doğrudan dönüşümler
+## dil olanağı olarak sunulmuş durumda;
+
+## Kompleks sayı olarak,
+"1234".to_c #=> (1234+0i)
+
+## Ondalık (Kayan-noktalı) sayı olarak,
+"1234".to_f #=> 1234.0
+
+## Rasyonel sayı olarak,
+"1234".to_r #=> (1234/1)
+
+## Metinsel -> Mantıksal
+
+## Mantıksal değerin kendisi için tersinin, tersini alırız
+!!"seçkin" #=> true
+
+## Mantıksal tersi için ise tersini,
+!"seçkin" #=> false
+
+## Metinsel -> Sembol
+"cengiz".to_sym #=> :cengiz
+
+## Metinsel -> Dizi
+"Cengiz Han".split #=> ["Cengiz", "Han"]
+
+## split metodu, seçimli argümanının varsayılan değeri
+## boşluk karakteridir.
+
+## Metinsel -> Dizi | bölümlenerek
+"Cengiz Han".split ""
+#=> ["C", "e", "n", "g", "i", "z", " ", "H", "a", "n"]
+
+
+## --
+# Sembol
+## --
+
+## Sembol -> Metinsel
+:metin.to_s #=> "metin"
+## Başka bir dönüşüm için dilin bir teşviki yoktur.
+
+## --
+# Diziler
+## --
+
+## Dizi -> Metinsel
+[1,2,3,4,5].to_s #=> "[1, 2, 3, 4, 5]"
+
+
+## --
+# Eşlemeler
+## --
+
+## Eşleme -> Dizi
+{a: 1, b: 2, c: 3}.to_a
+#=> [[:a, 1], [:b, 2], [:c, 3]]
+## Her bir anahtar-değer çifti bir dizi olarak
+## değerlendirilir ve elemanları sırasıyla
+## anahtar ve değerdir.
+
+## Eşleme -> Metinsel
+{a: 1, b: 2, c: 3}.to_s
+#=> "{:a=>1, :b=>2, :c=>3}"
+## inspect metodu için bir takma addır.
+
+
+# --------------------------------
+# Tanımlamalar, ifadeler, yorumlama.
+# --------------------------------
+
+## --
+## Yorumlama
+## --
+
+## Dökümanın başından beri gördüğümüz bu tek satır yorumlama operatörü
+## (#)
+## kendinden sonra gelen her şeyin, satır boyunca yorumlama olarak
+## değerlendirilmesi gerektiğini Ruby yorumlayıcısına söyler.
+
+## Ruby, farklı yorumlama imkanları da sağlamaktadır.
+## Örneğin;
+=begin
+ Başlangıç ifadesi (=begin), sonlandırma ifadesi (=end)
+ ile arasında kalan her şeyi yorum satırı olarak ele alır.
+=end
+
+## --
+## Global değişkenler.
+## --
+
+## Ruby evrensel değişkenleri, kapsamı en geniş değişken türüdür.
+## Her yerden erişilebilir...
+
+## Basitçe dolar sembolü ( $ ) ile başlarlar.
+$evrensel_bir_değişken = 42 #=> 42
+
+## Bir çok metadoloji ve yöntem ve teknoloji, size
+## evrensel değişkenler kullanmanın projenizi karmaşıklaştıracağı
+## ve bakımını zorlaştıracağını söyler; Haklıdırlar...
+
+## --
+## Varlık değişkenleri.
+## --
+
+## At ( @ ) sembölü ile başlarlar ve isimlerinin de ifade ettiği
+## gibi, kendileri bir Sınıf'ın değeridir.
+
+class Varlık
+ def initialize()
+ @varlık_değişkeni = 101
+ end
+
+ def göster()
+ puts "Varlık değişkeni: #@varlık_değişkeni"
+ end
+end
+
+varlık1 = Varlık.new()
+
+varlık1.göster()
+#=> Varlık değişkeni: 101
+
+## Sınıf tanımı şimdilik kafanızı karıştırmasın.
+## İlgilenmemiz gereken kısım;
+## @varlık_değişkeni = 101
+## ifadesidir. Ve nesne özelinde tanımlama yapar.
+## Kapsamı sadece o nesnedir.
+
+## ! NOT: ilklenmemiş varlık değişkenleri nil ön değeri ile
+## yaşam döngüsüne başlar.
+
+## --
+## Sınıf değişkenleri.
+## --
+
+## Sınıf değişkenleri iki at ( @@ ) sembölü ile başlarlar.
+## Tanımlar, herhangi bir metot içinde
+## kullanılmadan önce ilklenmelidirler.
+## İlklenmemiş bir Sınıf Değişkenine referansta bulunmak,
+## bir hata oluşturur.
+
+class Sınıf
+ @@sınıf_nesne_sayısı = 0
+
+ def initialize()
+ @@sınıf_nesne_sayısı += 1
+ end
+
+ def göster()
+ puts "Sınıf sayısı: #@@sınıf_nesne_sayısı"
+ end
+end
+
+sınıf_varlığı1 = Sınıf.new()
+sınıf_varlığı2 = Sınıf.new()
+sınıf_varlığı3 = Sınıf.new()
+
+sınıf_varlığı1.göster()
+#=> Sınıf sayısı: 3
+
+
+## --
+## Yerel değişkenler.
+## --
+
+## Yerel değişkenlerin isimlendirmesi küçük harf
+## ya da alt çizgi ( _ ) ile başlar ve kapsamı tanımın
+## yapıldığı sınıf, modül, metot yada blok içinde kalır.
+
+## --
+## Sabitler.
+## --
+
+## Ruby sabitleri, büyük harf ile tanımlanırlar ve
+## kapsamları için iki senaryo mevcuttur;
+
+## - Sınıf ya da Modül içinde tanımlanırlarsa
+## Tanımın yapıldığı blok içinden erişilebilir.
+
+## - Sınıf ya da Modül dışında yapılan tanımlar ise
+## Evrensel bir kapsama sahiptir ve her yerden
+## erişilebilirler.
+
+## Örneğin:
+
+class Sabit
+ SABİT = 299_792_458
+
+ def göster
+ puts "Sabit değer: #{SABİT}"
+ end
+end
+
+# Create Objects
+sabit = Sabit.new()
+
+sabit.göster()
+#=> Sabit değer: 299792458
+
+## İfadenin tanımındaki alt çizgiler sizi yanıltmasın
+## binlik ayracı olarak kullandım ve Ruby yorumlayıcısı
+## tamamen görmezden geliyor.
+## Bknz: Veriler ve Temsiller: Sayılar.
+
+## --
+## Sözde Değişkenler.
+## --
+
+## Ruby özel bir dil.
+## Öyle ki, Bazı sözde-değişkenler ile
+## size, ihtiyacınız olabileceği erişimi sağlar.
+## Ama onlara atama yapamazsınız.
+
+## Sözde değişkenler ve kullanımları
+## ile ilgili İleri okumaya başvurunuz.
+
+
+# --------------------------------
+# Konvansiyonlar ve teşvikler.
+# --------------------------------
+
+## Konvansiyonlar:
+
+## --
+## İsimlendirme Konvansiyonları:
+## Döküman boyunca yaptığım gibi,
+## tanımlayıcılar ve erişilebilir tanımlanmış ifadeler
+## için lütfen önerildiği gibi İngilizce kullanın.
+## İsimlendirme, Bilgisayar bilimlerinde yeterince
+## ağır bir zemin ve dilin teşvik ettiği rehber
+## ve önerdiği konvansiyonları takip ederek
+## bakımı, okuması ve geliştirmesi kolay projeler
+## gerçeklemek mümkündür.
+
+## --
+## Semboller, Metotlar ve Değişkenler için
+##-Snake Case ( snake_case ) kullanılması önerilir.
+
+## --
+## Sınıflar için Camel Case (CamelCase):
+## Sınıf isimlendirmeleri için önerildiği gibi,
+## Camel Case isimlendirme notasyonuna sadık kalın.
+
+## --
+## Dosyalar ve Klasörler için Snake Case (snake_case):
+## Dosya ve klasörleri isimlendirmek için lütfen
+## Snake Case isimlendirme konvansiyonuna sadık kalın.
+
+## --
+## Dosya Başına Bir Sınıf:
+## Her dosyada bir sınıf barındırmaya özen gösterin.
+
+## ---
+## Bu kısımdaki teşvik içerikleri
+## rubocop-hq/ruby-style-guide'dan gelmektedir.
+
+## ! Rehbere göre bu dökümanı düzenle!
+
+## --
+## Girintileme:
+## Girintileme için TAB yerine, iki boşluk kullanın.
+
+def bir_metot
+ birşeyler_yap
+end
+## Yerine;
+def bir_metot
+ birşeyler_yap
+end
+
+## --
+## Satır Başına Karakter:
+## Satır başına maksimum 80 karakter olacak şekilde
+## dökümanı yapılandırın.
+
+## --
+## Satır Sonları:
+## Unix-Stili satır sonlarını kulanın.
+## Eğer Git kullanıyorsanız;
+## $ git config --global core.autocrlf true
+## ifadesi sizi bu zahmetten kurtaracaktır.
+
+## --
+## Satır Başına Bir İfade:
+## Satır başına bir ifade kullanın.
+
+puts 'test!'; puts 'test!'
+## Yerine;
+puts 'test!'
+puts 'test!'
+
+## --
+## Boşluklar ve Operatörler:
+## Operatörler, virgüller, ifade ayraçları
+## aralarında boşluk bırakın.
+
+toplam=1+2
+x,z=1,2
+class FooError<StandardError;end
+## Yerine;
+toplam = 1 + 2
+x , z = 1 , 2
+class FooError < StandardError; end
+## Bir kaç istisna hariç
+## - Üs operatörü
+## - Rasyonel sayı gösteriminde kullanılan eğik çizgi.
+## - Güvenli gösterim operatörü.
+
+
+### Daha fazlası için ileri okumadaki
+### bu rehbere danışabilirsiniz...
+
+# --------------------------------
+# Bloklar, Kontrol blokları ve örnekler.
+# --------------------------------
+
+## --
+## Ruby Blokları:
+## Süslü parantezler ya da `do`, `end` ile çevrelenen,
+## değişkenleri ortama bağlı işlevlerdir.
+## Diğer dillerde !{Closure} ( closure ) karşılığı
+## bulur.
+## Ruby'de bloklar, ifadeleri gruplamanın bir şeklidir.
+## Bloklar tanımlandıklarında çalıştırılmazlar,
+## Ruby, bu yönetimi akıllıca yapar.
+
+## Örneğin;
+
+## Tanımlamamız
+def selamla_sonra_çağır
+ puts 'Selamlar!'
+ yield ## tüm sihir burada!
+end
+
+## Şimdi tanımı çağıralım
+selamla_sonra_çağır {puts 'Çağrı, gerçekleşti!'}
+#= Selamlar!
+#= Çağrı, gerçekleşti!
+#=> nil
+## Çağırım, kendini çağıran kaynağa nil döndürmekte.
+## Değerlendirmenin sonucunda, Ruby yorumlayıcısı,
+## ifadenin değerini nil olarak çıktılar.
+## Fakat, puts çağrıları, girdi/çıktı işlevimizi
+## yerine getirir ve metinleri ekrana basar.
+
+## Blokların argüman almaları da mümkündür:
+def selamla_sonra_değer_ile_çağır
+ puts 'Selamlar!'
+ yield('Hain Kostok') ## tüm sihir burada!
+end
+
+selamla_sonra_değer_ile_çağır {|isim| puts "Sana da selam, #{isim}!"}
+#= Selamlar!
+#= Sana da selam, Hain Kostok!
+#=> nil
+
+## Detaylı bilgi için, ileri okumaya başvurunuz.
+
+## --
+## Eğer ( if ) kontrol ifadesi:
+## Algoritmanızda dallanma imkanı sağlar.
+## Şablonu:
+## if koşul_ifadesi [then]
+## yürütülecek_kod
+## [elsif bir_diğer_koşul [then]
+## yürütülecek_diğer_kod]
+## [else
+## yürütülecek_bir_diğer_kod]
+## end
+
+## Bu kalıba sadık kalarak, dallanmalarımızı kodlarız.
+## Köşeli parantezler, sezgisel olarak anlaşılacağı üzere
+## seçimli ifadelerdir.
+
+## Örnek:
+if true
+ puts 'Koşul ifadesi, buradan devam edecek!'
+else
+ puts 'Buradan değil.'
+end
+#= Koşul ifadesi, buradan devam edecek!
+#=> nil
+
+## --
+## Eğer ( if ) düzenleyicisi:
+## Kompak bir dil olanağıdır. Aynı şekilde, çalıştırılacak kod
+## ve bir koşul ifadesi alır. Ve koşul ifadesine bakarak
+## ifadenin yürütüleceğine karar verir.
+## Şablonu:
+## çalıştırılacak_kod if koşul_ifadesi
+
+## Örnek:
+
+puts 'Bu ifade yürütülecek!' if true
+#= Bu ifade yürütülecek!
+#=> nil
+
+
+## --
+## Durum ( case ) kontrol ifadesi:
+## Bir koşul ifadesi ve bir ya da daha fazla karşılaştırma ifadesi
+## alarak, eşleşen bloğu yürütür.
+## Şablonu:
+## case koşullanacak_ifade
+## [when karşılaştırma_ifadesi [, karşılaştırma_ifadeleri ...] [then]
+## yürütülecek_kod ]...
+## [else
+## eşleşme_olmazsa_yürütülecek_kod ]
+## end
+
+yaş = 27
+case yaş
+when 0 .. 2
+ puts "bebek"
+when 3 .. 6
+ puts "küçük çocuk"
+when 7 .. 12
+ puts "çocuk"
+when 13 .. 18
+ puts "genç"
+else
+ puts "yetişkin"
+end
+#= yetişkin
+#=> nil
+
+## --
+## .. Sürece ( while ) kontrol ifadesi:
+## Aldığı koşul ifadesini kontrol eder,
+## kontrol bloğunu çağırır ve tekrar kontrol eder.
+## Koşul ifadesi doğru olduğu sürece, kontrol bloğu
+## çağırılmaya devam eder.
+## Şablonu:
+## while koşul_ifadesi [do]
+## yürütülecek_kod
+## end
+
+## Örnek:
+
+$n = 0
+$sayı = 5
+
+while $n < $sayı do
+ puts("Döngü içinde n = #$n" )
+ $n +=1
+end
+#= Döngü içinde n = 0
+#= Döngü içinde n = 1
+#= Döngü içinde n = 2
+#= Döngü içinde n = 3
+#= Döngü içinde n = 4
+#=> nil
+
+## --
+## .. Sürece ( while ) düzenleyicisi:
+## Eğer düzenleyecisi gibi, kompak bir dil olanağıdur.
+## Kontrol ifadesinin işlevini yerine getirir,
+## ama satır içi kullanıma müsade ederek.
+## Şablonu:
+## çalıştırılacak_kod while koşul_ifadesi
+## Yada:
+## begin
+## çalıştırılacak_kod
+## end while koşul_ifadesi
+
+## --
+## İçin ( for ) kontrol ifadesi:
+## N kere, I kere, X kere gibi ifadelerin dildeki kontrol
+## karşılığıdır. Çoklu veri üzerinde iterasyonlar yapmanızı
+## veri üzerinde operasyonlar yürütmenizi sağlar.
+## Şablonu:
+## for değişken [, başka_değişken ...] in ifade [do]
+## yürütülecek_kod
+## end
+
+## Örnek:
+for i in 1..5
+ puts i
+end
+#= 0
+#= 1
+#= 2
+#= 3
+#= 4
+#= 5
+#=> 0..5
+
+## Ardışıkları itere etmek için tek yol bu değil tabii.
+## İlerleyen kısımda buna yer verilecektir.
+
+## --
+## Sonlandırıcı ( break ) kontrol ifadesi:
+## Bu kontrol ifadesi yürütüldüğünde, çalışma zamanını
+## en iç tekrarlı bloktan çıkarır.
+
+## Örnek:
+for i in 1..5
+ break if i > 2
+ puts i
+end
+#= 0
+#= 1
+#= 2
+#=> nil
+## break kontrol ifadesi, if düzenleyecisi ile çevrelenmiştir.
+## if i > 2
+## break
+## end
+## ifadesi ile eşdeğerdir.
+## ifade yürütüldüğü anda, en yakın tekrarlı blok terkedilir.
+## Yorumlayıcı, sonraki ifadeden yürütmeye devam eder.
+
+## Diğer kontrol ifadeleri ve kullanımları için ileri okumaya başvurunuz...
+
+
+# --------------------------------
+# Özel anahtar kelimeler; kullanımları ve örnekleri.
+# --------------------------------
+
+## --
+## __ENCODING__:
+## Bu anahtar kelime size yorumlayıcı kodlama türünü verecektir.
+
+__ENCODING__
+#=> "#<Encoding:UTF-8>"
+
+## Platform, araç ve çalışma zamanı yürütme
+## yönteminize bağlı olarak alacağınız çıktı
+## değişiklik gösterebilir.
+
+## --
+## __LINE__:
+## Geçerli dosyada, yürütme satır numarasını verir.
+
+__LINE__
+#=> 67
+
+## Platform, araç ve çalışma zamanı yürütme
+## yönteminize bağlı olarak alacağınız çıktı
+## değişiklik gösterebilir.
+
+## --
+## BEGIN ve END:
+## BEGIN:
+## Dosyadaki tüm içerikten önce yürütülür.
+## END:
+## Dosyadaki tüm içeriklerden sonra yürütülür.
+
+## --
+## alias:
+## Herhangi bir tanımlayıcı için takma ad tanımlamanıza
+## olanak sağlar.
+
+$eski = 0
+alias $yeni $eski
+
+$yeni
+#=> 0
+
+## --
+## and:
+## Düşük öncelikli bir Mantıksal VE operatörü.
+
+## --
+## begin / end ve rescue:
+## İstisnalar begin / end blokları
+## arasında ele alınır ve `rescue` anahtar kelimesi ile
+## işlenirler.
+## İstisnalar ve mantalitesine dair ön girişi
+## Teşvik edilen paradigma ve anlatımı kısmında bulabilirsiniz.
+
+## Hata yönetimi, Ruby'de de özenle işlenmiş bir konudur.
+
+## Örnek:
+
+begin
+ yanlış_bir_hesaplama = 2/0
+ puts "Hesaplama sonucu: #{yanlış_bir_hesaplama}"
+ rescue ZeroDivisionError => hata_nesnesi
+ puts "Sıfıra bölümle ilgili bir hata yakalandı: #{hata_nesnesi.message}"
+end
+#= Sıfıra bölümle ilgili bir hata yakalandı: divided by 0
+#=> nil
+
+## Örneğimizde matematiksel sistemimiz için hatalı bir
+## işlem gerçekleştiriyoruz. Sonrasında hatayı ilgili
+## hata durumu için belirlediğimi alanda yönetiyoruz.
+## Örnekte hatayı çıktılayarak yönettik, gerçek dünyada
+## biraz daha kompleks gerçekleşebilir.
+## Gerçek dünya örnekleri için ileri okumaya başvurabilirsiniz.
+
+
+## --
+## defined?:
+## defined?, argümanını metinsel olarak açıklayan bir dil olanağıdır.
+
+## Örnek:
+RUBY_VERSION
+#=> "2.4.0"
+
+defined? RUBY_VERSION
+#=> "constant"
+
+defined? nil
+#=> "nil"
+
+defined? puts
+#=> "method"
+
+
+## --
+## ensure:
+## Hata yönetiminin bir parçası olarak dilde görev atfedilen ensure,
+## blok içinde, hata olsun ya da olmasın yürütüleceği garanti edilen
+## dil ifadeleri için bir imkandır.
+
+## Örnek:
+
+begin
+ yanlış_bir_hesaplama = 2/0
+ puts "Hesaplama sonucu: #{yanlış_bir_hesaplama}"
+ rescue ZeroDivisionError => hata_nesnesi
+ puts "Sıfıra bölümle ilgili bir hata yakalandı: #{hata_nesnesi.message}"
+ ensure
+ puts "Hesaplama bloğu sonlandı!"
+end
+#= Sıfıra bölümle ilgili bir hata yakalandı: divided by 0
+#= Hesaplama bloğu sonlandı!
+#=> nil
+
+
+## --
+## self:
+## Nesnenin kendisine erişim sağlayan bir dil olanağı.
+
+## Örnek:
+
+dünya = "Dünya!"
+#=> "Dünya!"
+
+dünya
+#=> "Dünya!"
+
+dünya.class
+#=> String
+
+def dünya.selamla
+ "Merhaba, " + self
+end
+#=> :selamla
+
+dünya.selamla
+#=> "Merhaba, Dünya!"
+
+## Nesnenin kendisine bir metot tanımladık,
+## bunu yaparken de değerine erişim sağladık.
+
+## --
+## super:
+## Nesne yönelimli programlama (spesifik olarak, obje tabanlı)
+## paradigmasına göre, kalıtım konseptinde, türeyen sınıfın
+## türetildiği sınıfa erişimi (üst sınıfı, atası, hiyerarşik üstü)
+## bu anahtar kelime ile gerçekleşir.
+
+class A
+ def initialize(a)
+ @a = a
+ end
+end
+
+class B < A
+ def initialize(a, b)
+ @b = b
+ super a
+ end
+end
+
+b = B.new 1, 2
+#=> #<B:0x00007f852d04c7e8 @b=2, @a=1>
+## super ile üst sınıfın ilklenmesi gerçekleştirildi,
+## aldığımız çıktıda da @a=1 çıktısıyla gözlemlenebilir.
+
+## Bu konunun, dilin paradigma teşviği ile ilgili
+## olduğunu ve anlamazsanız, Paradigma başlığını bitirdikten
+## sonra tekrar bu örneği değerlendirmeniz gerektiğini hatırlatırım.
+
+## --
+## yield:
+## Ruby blokları kısmında anlattık, ama, burada da bir nüanstan
+## bahsetmeden geçemeyeceğim.
+## Çalıştırılabilir ifadeleri çalıştırmanın birden fazla yolu vardır.
+## Fakat yield, en performanslı dil olanağı olarak dökümanda işlenmiş.
+## Kaynak için ileri okumaya danışın.
+
+
+
+# --------------------------------
+# G/Ç ( I/O )
+# --------------------------------
+
+=begin
+ G/Ç, Girdi/Çıktı ( Input/Output ) kısaltmasıdır.
+ Temelde, sistemden girdi almak ve çıktı yaratmak amacıyla vardır.
+ Girdi örnekleri:
+ - Klavyeden bastığınız herhangi bir tuş.
+ - Fare hareketleriniz ya da tıklamalarınız.
+ - Mikrofonunuzun aldığı sesler.
+
+ Çıktı örnekleri:
+ - Herhangi bir dil ifadesinin sonucu.
+ - Dijital bir ses dosyasının sese dönüşmesi.
+ - Ekranda gördükleriniz.
+
+ Fakat endişelenmeyin, G/Ç derken, şu anda
+ biz sadece Ruby'de,
+ - Dosya okuma/yazma.
+ - Ekrana metin yazdırma / Bilgi okuma.
+ - Ağ soketleri. ( biraz da olsa )
+ işlerinden bahsediyor olacağız.
+=end
+
+defined? IO
+#=> "constant"
+
+IO.class
+#=> Class
+
+## IO sınıfı, File ve Socket gibi pratik kullanımı olan sınıfların atasıdır.
+## Septikler için;
+
+File.superclass
+#=> IO
+## Gözlemlediğiniz üzere, superclass metodu, üst sınıfı veriyor.
+
+## --
+## Dosya Okuma ve Yazma:
+## Ruby'de dosya okuma ve yazma işlemleri için, File
+## sınıfını kullanacağız.
+
+## Dosyaya yazmak için;
+File.write 'test.txt', "a,b,c"
+#=> 5
+## 5, ifadenin ürettiği dönüş değeridir.
+## ve, çıktılanan karakter sayısını verir.
+
+## Dosyadan okuma için;
+## Bu kısım, açıklayıcı olması açısından
+## ifadeleri teker teker işleyeceğiz.
+
+File
+#=> File
+## Sınıfımız.
+
+File.readlines 'test.txt'
+#=> ["a,b,c"]
+## readlines File sınıfının bir metodu ve aldığı argüman dosya yoludur.
+
+File.readlines('test.txt').first
+#=> "a,b,c"
+## Dönüş değeri bir diziydi, her bir satır bir eleman olacak şekilde.
+## Biz, kendi verilerimizi, kendi ayıracımızla kaydetmeyi seçtik.
+## Eğer, `\n` satır ifadesi ile ayırmayı seçseydik, readlines
+## metodu zaten işlevi gereği, bize değerleri ayrı ayrı verecekti.
+
+File.readlines('test.txt').first.split ','
+#=> ["a", "b", "c"]
+## verilerimizi aldık.
+
+## Eğer yeni satır karakterini ayıraç olarak kullansaydık;
+File.write 'ntest.txt', ['a', 'b', 'c'].join("\n")
+#=> 5
+
+File.readlines('ntest.txt').map(&:chomp)
+#=> ["a", "b", "c"]
+## Bu da genel kullanımlı bir yaklaşımdır.
+
+## --
+## Ekrana bilgi yazdırma ve Okuma:
+## Konsol'a bilgi çıktılamak için,
+## önceden tanımlanmış $stdout global nesnesini kullanacağız.
+## Pratik kullanımda, prints işlevinden bir farkı yoktur.
+## Aynı sonuca ikisi ile de ulaşabilirsiniz.
+
+$stdout.print "Bu bir çıktı.\n"
+#= Bu bir çıktı.
+#=> nil
+
+## Şimdi kullanıcıdan bilgi okuyalım:
+$stdin.gets
+#! Bu kısımda hiç bir çıktı verilmez ve aksine
+#! sizden girdi beklenir. Bir metin yazın ve onaylamak için
+#! enter tuşunu kullanın.
+#- Bu bir girdi metni!
+#=> "Bu bir girdi metni!\n"
+
+## Aldığımız veriyi temizlenin yolunu biliyoruz.
+## Dönüş değerine chomp metodunu uygulamak.
+$stdin.gets.chomp
+#- Bu bir girdi metni!
+#=> "Bu bir girdi metni!"
+
+
+## --
+## Ağ girdi/çıktı yönetimi
+## Ruby'de soketler (Socket)
+## haricen çalışma zamanına dahil edilir.
+
+require 'socket'
+#=> true
+
+soket = TCPSocket.new('google.com', 80)
+#=> #<TCPSocket:fd 13, AF_INET, 192.168.0.11, 63989>
+## Alacağınız çıktı değişiklik gösterebilir.
+## Soketi oluşturduk ve bir değişkene atadık.
+## Şimdi bunun üzerinden okuma ve yazma işlemlerini
+## gerçekleştireceğiz.
+
+soket.write "GET / HTTP/1.1"
+#=> 14
+
+soket.write "\r\n\r\n"
+#=> 4
+## İki write metodunun sonucu da, sokete yazılan verinin
+## uzunluğudur.
+
+## Şimdi okuma zamanı, soketi açtık, isteğimizi bildirdik.
+## Şimdi soket üzerinden aldığımız cevabı ekrana yazdıralım.
+
+soket.recv 80
+#=> "HTTP/1.1 200 OK\r\nDate: Thu, 03 Sep 2020 10:48:21 GMT\r\nExpires: -1\r\nCache-Control"
+## Alacağınız çıktı değişiklik gösterebilir.
+## Ancak, başarılı şekilde okuma yaptık.
+
+
+
+# --------------------------------
+# Teşviğinde bulunduğu paradigma ve derinlemesine anlatımı.
+# --------------------------------
+
+## --
+## Nesne Yönelimli Programlama Nedir?
+## Kısaca NYP, en basit anlatımıyla;
+## nesnelerle programlamadır.
+## Nesne paradigması, her programcıya doğal ve sezgisel gelir.
+## Bunun sebebi, zaten gerçekliği algılama şeklimize uygun olmasıdır.
+## Araba, onu bir araya getiren nesnelerden oluşur,
+## tekerlekleri, direksiyonu, kasası, ve diğer parçalarıyla.
+## Ama bu, tam tanım değildir. NYP'de, Nesneler,
+## Bilgilere ( evet, varlık olarak başka nesneler de sayılabilir )
+## ve bu bilgileri yönetecek ( hesaplamalar gerçekleştirecek
+## ya da aksiyonlar alacak -- G/Ç -- gibi ) metotlara sahiptir.
+
+## Bir nesnenin en net tanımı böyle yapılabilirken,
+## NYP, bir gerçek dünya problemi için bir araya getirilmiş
+## -- çoğunlukla birden fazla -- sınıfların yapıları,
+## ilişkileri ve işlevlerini ele alır.
+
+## Bir paradigma olarak NYP, bizlere her varlığı nesne olarak
+## modellemeyi ve problem uzayımızdaki nesnelerle olan ilişkilerini
+## Ruby'de NYP için sağlanan imkanlarla yönetmeyi öğütler.
+
+## Sınıf içerisinde saklanan bilgiye öznitelik ya da özellik,
+## işlevlere ise metot denilir.
+## NYP jargonu için ileri okumaya başvurabilirsiniz.
+
+## --
+## Ruby'de NYP teşviki:
+
+## Nesneler, Sınıfların gerçeklenmiş halleridir.
+## Tam tersi ile, Sınıflar ise, nesnelerin soyut kalıplarıdır.
+
+## Bir sınıf tanımı yapalım ve gerçekleyelim:
+
+class Araba
+end
+#=> nil
+## Evet, evet. Tanımımız hiç bir öznitelik ( attributes ) ya da
+## metot ( method ) içermiyor.
+
+## Şimdi bir özellik ekleyelim
+class Araba
+ def initialize(hız)
+ @hız = hız
+ end
+end
+
+araba = Araba.new 100
+#=> #<Araba:0x00007f7f300e59c8 @hız=100>
+
+## En naif haliyle, hız bilgisi saklayan bir araba sınıfı gerçekledik.
+## initialize metodu, Ruby imkanları ile, nesne yaşam döngünüzün ilk adımıdır.
+## Bu döngüyü aşağıdaki gibi betimlemek mümkündür.
+## İlkleme ( initialize ) -> [İşlevlerin çağırımı] -> Sonlandırma
+## İlkleme, initialize metodu ile ele alınır, alınacak tüm argümanlar,
+## sınıfın iş mantığı doğrultusuyla, bu ilk işlevde yönetilir ve nesne
+## kullanıma hazır hale getirilir.
+
+## Şimdi bir işlev ekleyelim.
+
+class Araba
+ def initialize(hız)
+ @hız = hız
+ end
+
+ def git!
+ puts 'Hınn, hınn!'
+ end
+end
+
+araba = Araba.new 100
+#=> #<Araba:0x00007f7f300e59c8 @hız=100>
+
+## Şimdi metodu çağırıyoruz.
+araba.git!
+#= Hınn, hınn!
+#=> nil
+
+## Başlığın amacı sadece Ruby'nin NYP olanaklarını ve
+## teşviğini işlemek değil. Paradigmaya bir giriş kazandırmak.
+## Bundan dolayı, etkileşim içinde birden fazla sınıf görmeliyiz.
+
+class Tekerlek
+ YERLİ = 5
+ İTHAL = 1
+
+ def initialize (tür)
+ @güç = tür
+ end
+
+ def döndür!
+ @güç -= 1
+ end
+end
+
+class Araba
+ def initialize (hız)
+ @hız = hız
+ @tekerlekler = (1..4).map {|| Tekerlek.new(Tekerlek::YERLİ)}
+ end
+
+ def git!
+ if @tekerlekler.map(&:döndür!).filter {|ömür| ömür < 0}.first then
+ puts 'Paat!'
+ else
+ puts 'Hınnn, hınnn!'
+ end
+ end
+end
+
+## nesnemizi oluşturuyoruz
+araba = Araba.new 100
+
+## altı sefer, araba nesnesinin git! metodunu çağırıyoruz.
+(0..6).map {|| araba.git! }
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Hınnn, hınnn!
+#= Paat!
+#= Paat!
+
+## İş mantığımıza göre, arabamızın dört tekeri ve ve Yerli olanlar
+## 5 birim dayanıklılığa sahip. ;)
+## Bu beş birim tükenince, araba gitmek yerine,
+## patlak teker çıktısı alıyoruz.
+
+
+## Şimdiye kadar gördüklerimizi bir analiz edelim;
+## Araba, sınıfın ismi. Her sınıf, tanımlamasak da, temel bir
+## kurucu metot içerecek şekilde dil işleyicisi tarafından
+## ele alınıyor.
+## Bizim bir tanımımız var ama.
+## Hız bilgisi alıyoruz.
+## bu bilgi, sınıf özniteliğidir. Sınıf, bu bilgiye kendi içinden erişebilir.
+## Bir de, binek araçların dört tekerleği olduğu fikriyle,
+## nesne içinde, kurucu metot içinde dört tane Tekerlek nesnesi gerçekliyor
+## ve saklıyoruz.
+## İş mantığımıza göre onlara erişmemiz gerekiyor.
+## git! metodu içinde, erişiyor ve kullanıyoruz.
+## metotların sonundaki ünlem işareti bir konvansiyondur,
+## metotların saf olmayan çağırımlar gerçeklediği anlamına gelmektedir.
+## Kendilerini ( ya da sahip olduğu diğer nesneleri ) değiştirdikleri,
+## bir girdi/çıktı gerçekleştirdikleri yada buna benzer yan etki içeren
+## bir ifade barındırdıkları anlamına gelir.
+
+## Sizi temin ederim ki, NYP, bu dökümanı ( hali hazırda ~1560 satır )
+## genel anlatımı için bile ikiye katlayabilir.
+## Lütfen detaylı bilgi için ileri okumaya başvurunuz.
+```
+
+# İleri okumalar.
+
+Tümüyle İngilizce olan bu ileri okumalara inat, bu detaylı özgün Türkçe içeriği üretmek istedim.
+Dilerim, benden sonra katkıda bulunanlar olur.
+
+- [Ruby Style Guide](https://rubystyle.guide), Ruby stil rehberi.
+- [Ruby-Doc üzerinde Proc](https://ruby-doc.org/core-2.4.0/Proc.html), Ruby Blokları ve Proc kavramı için.
+- [Ruby-Doc üzerinde String](https://ruby-doc.org/core-2.6/String.html) sınıfı, işlevleri, metotları.
+- [Ruby-Doc üzerinde TrueClass](https://ruby-doc.org/core-2.5.1/TrueClass.html#method-i-to_s) Dildeki mantıksal ifadelerin gerçeklemesi olan TrueClass (ve FalseClass için de aynı bağlantı üzerinden içeriğe ulaşılabilir) dönüşüm içeriği kaynağı.
+- [Ruby Gerçeklemeleri Listesi](https://github.com/codicoscepticos/ruby-implementations) Ruby'nin farklı platformlardaki gerçeklemeleri. Opal ve Topaz dikkat çekenleridir.
+- [The Object-Oriented Thought Process](https://www.amazon.com/Object-Oriented-Thought-Process-Developers-Library/dp/0321861272) kitap, bir paradigma olarak NYP ve düşünce yapısından bahsediyor. Bir paradigma olarak, NYP, türetildiği temel paradigmadan ne almış, başka paradigmalara ne kadar imkan sağlıyor ve paralel paradigma uyumu konusunda tüm sorularınıza cevap bulabilirsiniz. Yazar, belli etmese de, pragmatik bir yaklaşımda.
+- [Block Argument](https://docs.ruby-lang.org/en/2.4.0/syntax/methods_rdoc.html#label-Block+Argument) Ruby Blokları ve yield hakkındaki Ruby resmi döküman sayfası ve alt başlığı.
+- [A Theory of Objects]() Class-Based Languages başlığında inceleniyorlar.
diff --git a/zh-cn/haskell-cn.html.markdown b/zh-cn/haskell-cn.html.markdown
index c854169e..d653c58c 100644
--- a/zh-cn/haskell-cn.html.markdown
+++ b/zh-cn/haskell-cn.html.markdown
@@ -128,7 +128,7 @@ snd ("haskell", 1) -- 1
-- 一个接受两个变量的简单函数
add a b = a + b
--- 注意，如果你使用 ghci (Hakell 解释器)，你需要使用 `let`，也就是
+-- 注意，如果你使用 ghci (Haskell 解释器)，你需要使用 `let`，也就是
-- let add a b = a + b
-- 调用函数