summaryrefslogtreecommitdiffhomepage
path: root/uk-ua
diff options
context:
space:
mode:
authorStanley Lim <slim679975@gmail.com>2019-11-21 10:54:24 -0500
committerGitHub <noreply@github.com>2019-11-21 10:54:24 -0500
commit2b1e1cca08eac0d4dc8f685dbe98d80683ca9d3a (patch)
tree460bb7d5cbc1141f8e710e3704f6d03dc25ea193 /uk-ua
parentd4c5ff14cc8a0717f68746b4fe84cfb4efbdecf6 (diff)
parentf1d03b0318a43441bb96bfdaabbd914eaa985879 (diff)
Merge pull request #1 from adambard/master
Merging from master.
Diffstat (limited to 'uk-ua')
-rw-r--r--uk-ua/cypher-ua.html.markdown254
-rw-r--r--uk-ua/go-ua.html.markdown449
-rw-r--r--uk-ua/java-ua.html.markdown52
-rw-r--r--uk-ua/javascript-ua.html.markdown16
-rw-r--r--uk-ua/kotlin-ua.html.markdown464
-rw-r--r--uk-ua/mips-ua.html.markdown366
-rw-r--r--uk-ua/python-ua.html.markdown818
-rw-r--r--uk-ua/rust-ua.html.markdown331
-rw-r--r--uk-ua/wasm-ua.html.markdown226
9 files changed, 2942 insertions, 34 deletions
diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown
new file mode 100644
index 00000000..e1eef5a2
--- /dev/null
+++ b/uk-ua/cypher-ua.html.markdown
@@ -0,0 +1,254 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+ - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+translators:
+ - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтаксис SQL та перемішує його з таким собі ascii стилем для відображення структури графа.
+Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними.
+
+[Деталі тут](https://neo4j.com/developer/cypher-query-language/)
+
+
+Вершини
+---
+
+**Відображує запис у графі.**
+
+`()`
+Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
+
+`(n)`
+Це вершина, яка має назву **n**, до неї можна повторно звертатись у запиті. Звернення до вершини **n** починається з нижнього підкреслення та використовує camelCase (верблюжий регіст).
+
+`(p:Person)`
+Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та використовує верблюжу нотацію.
+
+`(p:Person:Manager)`
+Вершина може мати кілька *ярликів*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починатися з великої літери та використовувати верблюжу нотацію.
+
+Наступні типи дозволяється використовувати у властивостях:
+
+ - Чиселиний
+ - Булевий
+ - Рядок
+ - Списки попередніх примітивних типів
+
+*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
+
+`p.name`
+За допомогою крапки можна звернутись до властивості вершини.
+
+
+Зв'язки (або ребра)
+---
+
+**Сполучають дві вершини**
+
+`[:KNOWS]`
+Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
+
+`[k:KNOWS]`
+Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково.
+
+`[k:KNOWS {since:2017}]`
+Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це **since**.
+
+`[k:KNOWS*..4]`
+Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
+
+
+Шляхи
+---
+
+**Спосіб поєднувати вершини та зв'язки.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Шлях описує, що вершини **a** та **b** знають (knows) один одного.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Шлях може бути направленим. Цей описує, що **а** є менеджером **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Можна створювати ланцюги зі зв'язків. Цей шлях описує друга друга (**a** знає **b**, який в свою чергу знає **c**).
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** - бос **b** і супер бос для **c**.
+
+Шаблони, які часто використовуються (з документації Neo4j):
+
+```
+// Друг-мого-друга
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Найкоротший шлях
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Спільна фільтрація
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Навігація по дереву
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Запити на створення
+---
+
+Створити нову вершину:
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN` дозволяє повернути результат після виконання запиту. Можна повертати кілька значень, наприклад, `RETURN a, b`.*
+
+Створити новий зв'язок (із двома вершинами):
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Запити на знаходження
+---
+
+Знайти всі вершини:
+```
+MATCH (n)
+RETURN n
+```
+
+Знайти вершини за ярликом:
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Знайти вершини за ярликом та властивістю:
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Знайти вершини відповідно до зв'язків (ненаправлених):
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Знайти вершини відповідно до зв'язків (направлених):
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Знайти вершини за допомогою `WHERE`:
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Запити на оновлення
+---
+
+Оновити окрему властивість вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Оновити всі властивості вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Додати нову властивіcть до вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Повісити ярлик на вершину:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Запити на видалення
+---
+
+Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Видалити властивість певної вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+
+*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й `DELETE`!*
+
+Видалити ярлик певної вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Видалити всю базу даних:
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+
+*Так, це `rm -rf /` на мові Cypher !*
+
+
+Інші корисні запити
+---
+
+`PROFILE`
+Перед виконанням, показати план виконання запитів.
+
+`COUNT(e)`
+Порахувати елементи (вершини та зв'язки), що відповідають **e**.
+
+`LIMIT x`
+Обмежити результат до x перших результатів.
+
+
+Особливі підказки
+---
+
+- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
+- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
+- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
+- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як **OpenCypher**).
diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
new file mode 100644
index 00000000..933b34f9
--- /dev/null
+++ b/uk-ua/go-ua.html.markdown
@@ -0,0 +1,449 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+ - ["Sonia Keys", "https://github.com/soniakeys"]
+ - ["Christopher Bess", "https://github.com/cbess"]
+ - ["Jesse Johnson", "https://github.com/holocronweaver"]
+ - ["Quint Guvernator", "https://github.com/qguv"]
+ - ["Jose Donizetti", "https://github.com/josedonizetti"]
+ - ["Alexej Friesen", "https://github.com/heyalexej"]
+ - ["Clayton Walker", "https://github.com/cwalk"]
+ - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
+translators:
+ - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Go був створений для того, щоб виконати задачу. Це не останній тренд в теорії мов програмування, а спосіб вирішення реальних проблем.
+
+Він увібрав принципи з імперативних мов зі статичною типізацією.
+Go швидко компілюється та виконується, а його багатопоточність легка для
+вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 мільйонів в Google, Inc.)
+
+Go має чудову стандартну бібліотеку та чимале ком'юніті.
+
+```go
+// Однорядковий коментар
+/* Багато-
+ рядковий коментар */
+
+// Кожен файл вихідного коду має починатись із ключового слова package.
+// main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку.
+package main
+
+// import оголошує бібліотеки, що використовуються в даному файлі.
+import (
+ "fmt" // Пакет стандартної бібліотеки Go.
+ "io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт.
+ m "math" // Бібліотека математичних операцій з локальним псевдонімом m.
+ "net/http" // Так, веб сервер!
+ "os" // Функції операційної системи, такі як робота з файловою системою.
+ "strconv" // Перетворення текстових змінних.
+)
+
+// Оголошення функції.
+// Функція main - особлива. Це вхідна точка для виконуваних програм.
+// Ви можете любити це, або ж ненавидіти, але Go використовує фігурні дужки.
+func main() {
+ // Println виводить рядок в stdout.
+ // Ця функція входить у пакет fmt.
+ fmt.Println("Hello world!")
+
+ // Викликати іншу функцію з цього файлу.
+ beyondHello()
+}
+
+// Аргументи функцій описуються у круглих дужках.
+// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обов`язкові.
+func beyondHello() {
+ var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені.
+ x = 3 // Присвоєння значення.
+ // "Короткі" оголошення використовують := щоб окреслити тип, оголосити та присвоїти значення.
+ y := 4
+ sum, prod := learnMultiple(x, y) // Функція повертає два значення.
+ fmt.Println("sum:", sum, "prod:", prod) // Просто вивід.
+ learnTypes() // < y хвилин, потрібно вивчити більше!
+}
+
+/* <- багаторядковий коментар
+Функції можуть мати параметри та повертати довільну кількість значень.
+В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертаються.
+Зверніть увагу, що `x` та `sum` мають тип `int`.
+*/
+func learnMultiple(x, y int) (sum, prod int) {
+ return x + y, x * y // Повернути два значення.
+}
+
+// Кілька вбудованих типів та літералів.
+func learnTypes() {
+ // Короткі оголошення зазвичай виконують все, що необхідно.
+ str := "Вчи Go!" // рядок (string).
+
+ s2 := `"Необроблений" текст
+може містити переноси рядків.` // Також має тип рядок.
+
+ // Не ASCII символи. Go використовує UTF-8.
+ g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода.
+
+ f := 3.14195 // float64, IEEE-754 64-бітне число з плаваючою крапкою.
+ c := 3 + 4i // complex128, комплексні числа, що являють собою два float64.
+
+ // Синтаксис ініціалізації з var.
+ var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int.
+ var pi float32 = 22. / 7
+
+ // Синтаксис перетворення типів з коротким оголошенням.
+ n := byte('\n') // Байт - це переіменований uint8.
+
+ // Розмір масива фіксований протягом часу виконання.
+ var a4 [4]int // Масив з 4 чисел, всі проініціалізовані 0.
+ a5 := [...]int{3, 1, 5, 10, 100} // Масив проініціалізованих чисел з фіксованим розміром у
+ // п'ять елементів, що мають значення 3, 1, 5, 10, та 100.
+
+ // Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте
+ // останні використовуються частіше.
+ s3 := []int{4, 5, 9} // Порівняйте з a5. Тут немає трьокрапки.
+ s4 := make([]int, 4) // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0.
+ var d2 [][]float64 // Декларація, нічого не виділяється.
+ bs := []byte("a slice") // Синтаксис переведення у інший тип.
+
+ // Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю.
+ // Для цієї операції використовується вбудована функція append().
+ // Перший аргумент - це зріз, до якого додається елемент. Зазвичай
+ // змінна масиву оновлюється на місці, як у прикладі нижче.
+ s := []int{1, 2, 3} // В результаті отримуємо зріз із 3 чисел.
+ s = append(s, 4, 5, 6) // додаємо 3 елементи. Зріз тепер довжини 6.
+ fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6]
+
+ // Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам,
+ // можна передати посилання на зріз із трьокрапкою, як у прикладі нижче. Таким чином,
+ // зріз розпакується і його елементи додадуться до зріза s.
+ s = append(s, []int{7, 8, 9}...)
+ fmt.Println(s) // Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9]
+
+ p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа.
+ fmt.Println(*p, *q) // * іде попереду вказівника. Таким чином, виводяться числа.
+
+ // Асоціативний масив (map) - це динамічно розширюваний тип даних, як хеш
+ // або словник в інших мовах програмування
+ m := map[string]int{"three": 3, "four": 4}
+ m["one"] = 1
+
+ // В Go змінні, які не використовуються, вважаються помилкою.
+ // Нижнє підкреслення дозволяє "використати" змінну, але проігнорувати значення.
+ _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
+ // Зазвичай це використовується, щоб проігнорувати значення, що повертає функція.
+ // Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає
+ // функція os.Create, вважаючи, що файл буде створений за будь-яких умов.
+ file, _ := os.Create("output.txt")
+ fmt.Fprint(file, "Приклад, як відбувається запис у файл.")
+ file.Close()
+
+ // Вивід значень змінних.
+ fmt.Println(s, c, a4, s3, d2, m)
+
+ learnFlowControl() // Рухаємось далі.
+}
+
+// Навідміну від більшості інших мов програмування, функції в Go підтримують
+// іменоване значення, що повертається.
+// Змінні, значення яких повертається функцією, вказуються із зазначенням типу при
+// оголошенні функції. Таким чином, можна з легкістю повернути їхні значення в різних
+// точках коду, не перелічуючи їх після ключового слова return.
+func learnNamedReturns(x, y int) (z int) {
+ z = x * y
+ return // z не потрібно вказувати, при оголошенні описано змінну для повернення.
+}
+
+// Go використовує сміттєзбірник. В ньому використовуються вказівники, проте немає
+// операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не
+// при збільшенні значення вказівника (перехід по адресам пам'яті).
+func learnMemory() (p, q *int) {
+ // Іменовані змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
+ p = new(int) // Вбудована функція виділяє нову пам'ять.
+ // Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil.
+ s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті.
+ s[3] = 7 // Присвоїти значення одному з них.
+ r := -2 // Оголосити нову локальну змінну.
+ return &s[3], &r // Оператор & повертає адресу в пам'яті об'єкта.
+}
+
+func expensiveComputation() float64 {
+ return m.Exp(10)
+}
+
+func learnFlowControl() {
+ // if твердження вимагає фігурні дужки, але не вимагає округлих.
+ if true {
+ fmt.Println("Кажу ж")
+ }
+ // Форматування стандартизовано командою командного рядка "go fmt".
+ if false {
+ // Pout.
+ } else {
+ // Gloat.
+ }
+ // Використання перемикача (switch) замість ланцюга if-тверджень.
+ x := 42.0
+ switch x {
+ case 0:
+ case 1:
+ case 42:
+ // Кейси не "провалюються". Натомість, є ключове слово `fallthrough`:
+ // https://github.com/golang/go/wiki/Switch#fall-through (англ)
+ case 43:
+ // Недоступний.
+ default:
+ // Кейс за замовчуванням не обов'язковий.
+ }
+ // Як і if, формат оголошення циклу for не вимагає круглих дужок:
+ // Змінні, оголошені всередині if та for - належать цій області видимості.
+ for x := 0; x < 3; x++ { // ++ - це твердження.
+ fmt.Println("iteration", x)
+ }
+ // Тут x == 42.
+
+ // For - це єдиний цикл в Go, проте він має кілька різних форм.
+ for { // Ініціалізація циклу.
+ break // Упс, помилково зайшли.
+ continue // Недоступне твердження.
+ }
+
+ // Можна використовувати діапазони, зрізи, рядки, асоціативні масиви, або ж
+ // канал для ітерації в циклі. Діапазон (range) повертає один (канал) або два
+ // значення (масив, зріз, рядок та асоціативний масив).
+ for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
+ // для кожної пари в асоціативному масиві, надрукувати ключ та значення
+ fmt.Printf("key=%s, value=%d\n", key, value)
+ }
+ // якщо потрібне тільки значення, можна застосувати нижнє підкреслення як ключ
+ for _, name := range []string{"Bob", "Bill", "Joe"} {
+ fmt.Printf("Hello, %s\n", name)
+ }
+
+ // так само, як і з циклом for, оператор := в розгалуженні означає оголосити
+ // локальну змінну в області видимості if та присвоїти значення. Далі
+ // значення змінної проходить перевірку y > x.
+ if y := expensiveComputation(); y > x {
+ x = y
+ }
+ // Літерали функцій - це замикання
+ xBig := func() bool {
+ return x > 10000 // Посилання на x, що був оголошений раніше, перед switch.
+ }
+ x = 99999
+ fmt.Println("xBig:", xBig()) // true
+ x = 1.3e3 // Тобто, тепер x == 1300
+ fmt.Println("xBig:", xBig()) // false тепер.
+
+ // Функція може бути оголошена та викликана в одному рядку, поводячи себе
+ // як аргумент функції, але за наступних умов:
+ // 1) літерал функції негайно викликається за допомогою ()
+ // 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу
+ fmt.Println("Add + double two numbers: ",
+ func(a, b int) int {
+ return (a + b) * 2
+ }(10, 2)) // Викликаємо з аргументами 10 та 2
+ // => Додати + подвоїти два числа: 24
+
+ // Коли вам це знадобиться, ви полюбите це
+ goto love
+love:
+
+ learnFunctionFactory() // функція, що повертає функцію - це весело(3)(3)
+ learnDefer() // Швидкий обхід до важливого ключового слова.
+ learnInterfaces() // Тут на вас чекає крута штука!
+}
+
+func learnFunctionFactory() {
+ // Два наступних твердження роблять однакові дії, але другий приклад частіше
+ // застосовується
+ fmt.Println(sentenceFactory("summer")("A beautiful", "day!"))
+
+ d := sentenceFactory("summer")
+ fmt.Println(d("A beautiful", "day!"))
+ fmt.Println(d("A lazy", "afternoon!"))
+}
+
+// Декоратори звична річ для багатьох мов програмування. В Go їх можна реалізувати
+// за допомогою літералів функцій, що приймають аргументи.
+func sentenceFactory(mystring string) func(before, after string) string {
+ return func(before, after string) string {
+ return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок
+ }
+}
+
+func learnDefer() (ok bool) {
+ // твердження defer змушує функцію посилатись на список. Список
+ // збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує
+ // виконання.
+ defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).")
+ defer fmt.Println("\nЦей рядок надрукується першим, тому що")
+ // Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином,
+ // функція, що закриває файл, залишається близькою до функції, що відкриває файл.
+ return true
+}
+
+// Оголошує Stringer як тип інтерфейсу з одним методом, String.
+type Stringer interface {
+ String() string
+}
+
+// Оголошує pair як структуру з двома полями, цілими числами x та y.
+type pair struct {
+ x, y int
+}
+
+// Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив
+// всі методи в цьому інтерфейсі.
+func (p pair) String() string { // p тепер називається "приймачем"
+ // Sprintf - ще одна функція з пакету fmt.
+ // Крапка використовується, щоб звернутись до полів об'єкту p.
+ return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+ // Синтаксис з використанням фігурних дужок називається "літералом структури".
+ // Він застосовується до ініціалізованої структури. Оператор := оголошує
+ // та ініціалізує p цією структурою.
+ p := pair{3, 4}
+ fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair.
+ var i Stringer // Оголошує і інтерфейсного типу Stringer.
+ i = p // Допустиме, оскільки pair реалізує Stringer
+ // Викликає метод String об'єкта і, що має тип Stringer. Виводить те ж саме, що й
+ // аналогічний метод вище.
+ fmt.Println(i.String())
+
+ // Функції з бібліотеки fmt викликають метод String, щоб запросити у об'єкта
+ // своє представлення, яке можна надрукувати.
+ fmt.Println(p) // Виводить те ж саме, що й раніше.
+ fmt.Println(i) // Виводить те ж саме, що й раніше.
+
+ learnVariadicParams("great", "learning", "here!")
+}
+
+// Кількість аргументів функції може бути змінною.
+func learnVariadicParams(myStrings ...interface{}) {
+ // Пройтись по значенням всіх аргументів.
+ // _ - це ігнорування порядкового номеру аргумента в масиві.
+ for _, param := range myStrings {
+ fmt.Println("param:", param)
+ }
+
+ // Передати значення аргументів як параметр змінної величини.
+ fmt.Println("params:", fmt.Sprintln(myStrings...))
+
+ learnErrorHandling()
+}
+
+func learnErrorHandling() {
+ // Ідіома ", ok"використовується, щоб перевірити виконання команди без помилок.
+ m := map[int]string{3: "three", 4: "four"}
+ if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться
+ // в асоціативному масиві.
+ fmt.Println("немає таких")
+ } else {
+ fmt.Print(x) // x буде мати значення 1, якщо 1 знаходиться в m.
+ }
+ // Значення помилки повідомляє не тільки, що все добре, але й може розповісти
+ // більше про проблему.
+ if _, err := strconv.Atoi("non-int"); err != nil { // _ ігнорує значення
+ // виводить помилку 'strconv.ParseInt: parsing "non-int": invalid syntax'
+ fmt.Println(err)
+ }
+ // Ми розглянемо інтерфейси дещо пізніше. А поки, розглянемо багатопоточність.
+ learnConcurrency()
+}
+
+// Канал с - це потокозохищений об'єкт для спілкування між потоками.
+func inc(i int, c chan int) {
+ c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу
+ // знаходиться зліва від нього.
+}
+
+// inc виконує збільшення значення на 1. Ми використаємо його, щоб збільшувати
+// числа рівночасно.
+func learnConcurrency() {
+ // вже знайома функція make, яка раніше використовувалась для виділення пам'яті,
+ // тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує
+ // зрізи, асоційовані масиви та канали. Новостворений канал буде передавати
+ // цілочисельні значення.
+ c := make(chan int)
+ // Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовірно
+ // паралельно якщо пристрій здатний до цього та правильно сконфігурований.
+ // Всі три ґорутини надсилають значення в один канал.
+ go inc(0, c) // Твердження go запускає нову ґорутину.
+ go inc(10, c)
+ go inc(-805, c)
+ // Читаємо три результати з каналу та друкуємо їх.
+ // Порядок результатів - невідомий!
+ fmt.Println(<-c, <-c, <-c) // якщо канал знаходиться справа від оператора <-,
+ // він виконує функцію "приймача".
+
+ cs := make(chan string) // Ще один канал, який примає рядки.
+ ccs := make(chan chan string) // Канал каналів рядків.
+ go func() { c <- 84 }() // Запустимо нову ґорутину, щоб надіслати значення в канал с.
+ go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs.
+ // Ключове слово select має синтаксис, подібний до switch, проте кожен кейс
+ // включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові
+ // комунікувати (передавати дані).
+ select {
+ case i := <-c: // Отримане значення може бути присвоєно змінній,
+ fmt.Printf("it's a %T", i)
+ case <-cs: // або значення може бути проігнороване.
+ fmt.Println("it's a string")
+ case <-ccs: // Пустий канал, не готовий комунікувати.
+ fmt.Println("Не відбудеться.")
+ }
+ // На цьому етапі, значення було прочитане або з с або з cs. Одна з двох
+ // ґорутин завершилась, але інша все ще заблокована.
+
+ learnWebProgramming() // Go вміє й у веб. Так, ти хочеш зробити це.
+}
+
+// Лиш одна функція з пакету http запускає веб сервер.
+func learnWebProgramming() {
+
+ // перший аргумент ListenAndServe - це TCP адреса, який сервер буде слухати.
+ // Другий аргумент - це інтерфейс, а точніше http.Handler.
+ go func() {
+ err := http.ListenAndServe(":8080", pair{})
+ fmt.Println(err) // не ігноруйте помилки
+ }()
+
+ requestServer()
+}
+
+// pair матиме тип http.Handler, якщо реалізувати один його метод, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ // Відповідати на запити можна методом, що належить http.ResponseWriter.
+ w.Write([]byte("Ти вивчив Go за Y хвилин!"))
+}
+
+func requestServer() {
+ resp, err := http.Get("http://localhost:8080")
+ fmt.Println(err)
+ defer resp.Body.Close()
+ body, err := ioutil.ReadAll(resp.Body)
+ fmt.Printf("\nWebserver said: `%s`", string(body))
+}
+```
+
+## Подальше вивчення
+
+Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
+Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
+
+Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
+
+Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://uk.wikipedia.org/wiki/REPL) до тестів та коду в твоєму браузері, без встановлення Go.
+
+В списку для прочитання новачкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно задокоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
+Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/), щоб перейти до її реалізації.
+
+Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/).
+
+Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go для мобільних застосунків або написати бібліотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).
diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 1d600400..40d56988 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -30,7 +30,7 @@ JavaDoc-коментар виглядає так. Використовуєтьс
// Імпорт класу ArrayList з пакета java.util
import java.util.ArrayList;
-// Імпорт усіх класів з пакета java.security
+// Імпорт усіх класів з пакета java.security
import java.security.*;
// Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає
@@ -99,13 +99,13 @@ public class LearnJava {
// Примітка: Java не має беззнакових типів.
- // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754
+ // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754
// 2^-149 <= float <= (2-2^-23) * 2^127
float fooFloat = 234.5f;
// f або F використовується для позначення того, що змінна має тип float;
// інакше трактується як double.
- // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754
+ // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754
// 2^-1074 <= x <= (2-2^-52) * 2^1023
double fooDouble = 123.4;
@@ -130,13 +130,13 @@ public class LearnJava {
// байтів, операції над ними виконуються функціями, які мають клас BigInteger
//
// BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
-
+
BigInteger fooBigInteger = new BigInteger(fooByteArray);
// BigDecimal — Незмінні знакові дробові числа довільної точності
//
- // BigDecimal складається з двох частин: цілого числа довільної точності
+ // BigDecimal складається з двох частин: цілого числа довільної точності
// з немасштабованим значенням та 32-бітного масштабованого цілого числа
//
// BigDecimal дозволяє розробникам контролювати десяткове округлення.
@@ -147,10 +147,10 @@ public class LearnJava {
// чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-
+
// Для дотримання заданої точності рекомендується використовувати
- // конструктор, який приймає String
-
+ // конструктор, який приймає String
+
BigDecimal tenCents = new BigDecimal("0.1");
@@ -295,7 +295,7 @@ public class LearnJava {
// Виконається 10 разів, fooFor 0->9
}
System.out.println("Значення fooFor: " + fooFor);
-
+
// Вихід із вкладеного циклу через мітку
outer:
for (int i = 0; i < 10; i++) {
@@ -306,7 +306,7 @@ public class LearnJava {
}
}
}
-
+
// Цикл For Each
// Призначений для перебору масивів та колекцій
int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
@@ -318,7 +318,7 @@ public class LearnJava {
// Оператор вибору Switch Case
// Оператор вибору працює з типами даних byte, short, char, int.
- // Також працює з переліками Enum,
+ // Також працює з переліками Enum,
// класом String та класами-обгортками примітивних типів:
// Character, Byte, Short та Integer.
int month = 3;
@@ -334,7 +334,7 @@ public class LearnJava {
break;
}
System.out.println("Результат Switch Case: " + monthString);
-
+
// Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
String myAnswer = "можливо";
switch(myAnswer) {
@@ -398,7 +398,7 @@ public class LearnJava {
// toString повертає рядкове представлення об’єкту.
System.out.println("Інформація про об’єкт trek: " + trek.toString());
-
+
// У Java немає синтаксису для явного створення статичних колекцій.
// Це можна зробити так:
@@ -554,7 +554,7 @@ public interface Digestible {
// Можна створити клас, що реалізує обидва інтерфейси.
public class Fruit implements Edible, Digestible {
-
+
@Override
public void eat() {
// ...
@@ -592,7 +592,7 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
// Позначення класу як абстрактного означає, що оголошені у ньому методи мають
// бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри
// абстракних класів, але їх можна успадковувати. Нащадок зобов’язаний реалізувати всі абстрактні
-// методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
+// методи. На відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
// так і абстрактні методи. Методи в інтерфейсах не мають тіла,
// за винятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод «main».
@@ -694,41 +694,41 @@ public abstract class Mammal()
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
- THURSDAY, FRIDAY, SATURDAY
+ THURSDAY, FRIDAY, SATURDAY
}
// Перелік Day можна використовувати так:
public class EnumTest {
-
+
// Змінна того же типу, що й перелік
Day day;
-
+
public EnumTest(Day day) {
this.day = day;
}
-
+
public void tellItLikeItIs() {
switch (day) {
case MONDAY:
- System.out.println("Понеділкі важкі.");
+ System.out.println("Понеділки важкі.");
break;
-
+
case FRIDAY:
System.out.println("П’ятниці краще.");
break;
-
- case SATURDAY:
+
+ case SATURDAY:
case SUNDAY:
System.out.println("Вихідні найліпші.");
break;
-
+
default:
System.out.println("Середина тижня так собі.");
break;
}
}
-
+
public static void main(String[] args) {
EnumTest firstDay = new EnumTest(Day.MONDAY);
firstDay.tellItLikeItIs(); // => Понеділки важкі.
@@ -737,7 +737,7 @@ public class EnumTest {
}
}
-// Переліки набагато потужніші, ніж тут показано.
+// Переліки набагато потужніші, ніж тут показано.
// Тіло переліків може містити методи та інші змінні.
// Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 397b1c5e..6a64a623 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -45,7 +45,7 @@ doStuff()
3; // = 3
1.5; // = 1.5
-// Деякі прості арифметичні операції працють так, як ми очікуємо.
+// Деякі прості арифметичні операції працюють так, як ми очікуємо.
1 + 1; // = 2
0.1 + 0.2; // = 0.30000000000000004 (а деякі - ні)
8 - 1; // = 7
@@ -106,7 +106,7 @@ null == undefined; // = true
// ... але приведення не виконується при ===
"5" === 5; // = false
-null === undefined; // = false
+null === undefined; // = false
// ... приведення типів може призвести до дивних результатів
13 + !0; // 14
@@ -171,7 +171,7 @@ myArray[3] = "світ";
// Об’єкти в JavaScript схожі на словники або асоціативні масиви в інших мовах
var myObj = {key1: "Hello", key2: "World"};
-// Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
+// Ключі - це рядки, але лапки не обов’язкові, якщо ключ задовольняє
// правилам формування назв змінних. Значення можуть бути будь-яких типів.
var myObj = {myKey: "myValue", "my other key": 4};
@@ -258,7 +258,7 @@ function myFunction(thing) {
return thing.toUpperCase();
}
myFunction("foo"); // = "FOO"
-
+
// Зверніть увагу, що значення яке буде повернено, повинно починатися на тому ж
// рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
// через автоматичну вставку крапки з комою
@@ -332,7 +332,7 @@ var myObj = {
};
myObj.myFunc(); // = "Hello, world!"
-// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за
+// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за
// допомогою ключового слова this.
myObj = {
myString: "Hello, world!",
@@ -348,7 +348,7 @@ myObj.myFunc(); // = "Hello, world!"
var myFunc = myObj.myFunc;
myFunc(); // = undefined
-// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до
+// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до
// цього об’єкта через this
var myOtherFunc = function() {
return this.myString.toUpperCase();
@@ -371,7 +371,7 @@ Math.min(42, 6, 27); // = 6
Math.min([42, 6, 27]); // = NaN (Ой-ой!)
Math.min.apply(Math, [42, 6, 27]); // = 6
-// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт
+// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт
// використовують bind
var boundFunc = anotherFunc.bind(myObj);
boundFunc(" Hello!"); // = "Hello world, Hello!"
@@ -475,7 +475,7 @@ if (Object.create === undefined) { // не перезаписуємо метод
// Створюємо правильний конструктор з правильним прототипом
var Constructor = function(){};
Constructor.prototype = proto;
-
+
return new Constructor();
}
}
diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
new file mode 100644
index 00000000..5e79cc48
--- /dev/null
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -0,0 +1,464 @@
+---
+language: kotlin
+filename: LearnKotlin-uk.kt
+lang: uk-ua
+contributors:
+ - ["S Webber", "https://github.com/s-webber"]
+translators:
+ - ["AstiaSun", "https://github.com/AstiaSun"]
+---
+
+Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера.
+Вона має 100% сумісність із Java.
+
+[Детальніше](https://kotlinlang.org/)
+
+```kotlin
+// Однорядкові коментарі починаються з //
+/*
+Такий вигляд мають багаторядкові коментарі
+*/
+
+// Ключове слово package працює так само, як і в Java.
+package com.learnxinyminutes.kotlin
+
+/*
+Точкою входу для програм на Kotlin є функція під назвою main.
+Вона приймає масив із аргументів, що були передані через командний рядок.
+Починаючи з Kotlin 1.3, функція main може бути оголошена без параметрів взагалі.
+*/
+fun main(args: Array<String>) {
+ /*
+ Оголошення змінних відбувається за допомогою ключових слів var або val.
+ Відмінність між ними полягає в тому, що значення змінних, оголошених через
+ val, не можна змінювати. Водночас, змінній "var" можна переприсвоїти нове
+ значення в подальшому.
+ */
+ val fooVal = 10 // більше ми не можемо змінити значення fooVal на інше
+ var fooVar = 10
+ fooVar = 20 // fooVar може змінювати значення
+
+ /*
+ В більшості випадків Kotlin може визначати, якого типу змінна, тому не
+ потрібно щоразу точно вказувати її тип.
+ Тип змінної вказується наступним чином:
+ */
+ val foo: Int = 7
+
+ /*
+ Рядки мають аналогічне з Java представлення. Спеціальні символи
+ позначаються за допомогою зворотнього слеша.
+ */
+ val fooString = "My String Is Here!"
+ val barString = "Printing on a new line?\nNo Problem!"
+ val bazString = "Do you want to add a tab?\tNo Problem!"
+ println(fooString)
+ println(barString)
+ println(bazString)
+
+ /*
+ Необроблений рядок розмежовується за допомогою потрійних лапок (""").
+ Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та
+ будь-які інші символи.
+ */
+ val fooRawString = """
+fun helloWorld(val name : String) {
+ println("Hello, world!")
+}
+"""
+ println(fooRawString)
+
+ /*
+ Рядки можуть містити шаблонні вирази.
+ Шаблонний вираз починається із символа доллара "$".
+ */
+ val fooTemplateString = "$fooString has ${fooString.length} characters"
+ println(fooTemplateString) // => My String Is Here! has 18 characters
+
+ /*
+ Щоб змінна могла мати значення null, потрібно це додатково вказати.
+ Для цього після оголошеного типу змінної додається спеціальний символ "?".
+ Отримати значення такої змінної можна використавши оператор "?.".
+ Оператор "?:" застосовується, щоб оголосити альтернативне значення змінної
+ у випадку, якщо вона буде рівна null.
+ */
+ var fooNullable: String? = "abc"
+ println(fooNullable?.length) // => 3
+ println(fooNullable?.length ?: -1) // => 3
+ fooNullable = null
+ println(fooNullable?.length) // => null
+ println(fooNullable?.length ?: -1) // => -1
+
+ /*
+ Функції оголошуються з використанням ключового слова fun.
+ Аргументи функції перелічуються у круглих дужках після назви функції.
+ Аргументи можуть мати значення за замовчуванням. Тип значення, що повертатиметься
+ функцією, вказується після оголошення аргументів за необхідністю.
+ */
+ fun hello(name: String = "world"): String {
+ return "Hello, $name!"
+ }
+ println(hello("foo")) // => Hello, foo!
+ println(hello(name = "bar")) // => Hello, bar!
+ println(hello()) // => Hello, world!
+
+ /*
+ Аргументи функції можуть бути помічені ключовим словом vararg. Це дозволяє
+ приймати довільну кількість аргументів функції зазначеного типу.
+ */
+ fun varargExample(vararg names: Int) {
+ println("Argument has ${names.size} elements")
+ }
+ varargExample() // => Argument has 0 elements
+ varargExample(1) // => Argument has 1 elements
+ varargExample(1, 2, 3) // => Argument has 3 elements
+
+ /*
+ Коли функція складається з одного виразу, фігурні дужки не є обов'язковими.
+ Тіло функції вказується після оператора "=".
+ */
+ fun odd(x: Int): Boolean = x % 2 == 1
+ println(odd(6)) // => false
+ println(odd(7)) // => true
+
+ // Якщо тип значення, що повертається функцією, може бути однозначно визначено,
+ // його непотрібно вказувати.
+ fun even(x: Int) = x % 2 == 0
+ println(even(6)) // => true
+ println(even(7)) // => false
+
+ // Функції можуть приймати інші функції як аргументи, а також повертати інші функції.
+ fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+ return {n -> !f.invoke(n)}
+ }
+ // Іменовані функції можуть бути вказані як аргументи за допомогою оператора "::".
+ val notOdd = not(::odd)
+ val notEven = not(::even)
+ // Лямбда-вирази також можуть бути аргументами функції.
+ val notZero = not {n -> n == 0}
+ /*
+ Якщо лямбда-вираз приймає лише один параметр, його оголошення може бути пропущене
+ (разом із ->). Всередині виразу до цього параметра можна звернутись через
+ змінну "it".
+ */
+ val notPositive = not {it > 0}
+ for (i in 0..4) {
+ println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+ }
+
+ // Ключове слово class використовується для оголошення класів.
+ class ExampleClass(val x: Int) {
+ fun memberFunction(y: Int): Int {
+ return x + y
+ }
+
+ infix fun infixMemberFunction(y: Int): Int {
+ return x * y
+ }
+ }
+ /*
+ Щоб створити новий об'єкт, потрібно викликати конструктор класу.
+ Зазначте, що в Kotlin немає ключового слова new.
+ */
+ val fooExampleClass = ExampleClass(7)
+ // Методи класу викликаються через крапку.
+ println(fooExampleClass.memberFunction(4)) // => 11
+ /*
+ Якщо функція була позначена ключовим словом infix, тоді її можна викликати через
+ інфіксну нотацію.
+ */
+ println(fooExampleClass infixMemberFunction 4) // => 28
+
+ /*
+ Класи даних - це лаконічний спосіб створювати класи, що містимуть тільки дані.
+ Методи "hashCode"/"equals" та "toString" автоматично генеруються.
+ */
+ data class DataClassExample (val x: Int, val y: Int, val z: Int)
+ val fooData = DataClassExample(1, 2, 4)
+ println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+ // Класи даних також мають функцію "copy".
+ val fooCopy = fooData.copy(y = 100)
+ println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+ // Об'єкти можуть бути деструктурувані кількома способами.
+ val (a, b, c) = fooCopy
+ println("$a $b $c") // => 1 100 4
+
+ // деструктурування у циклі for
+ for ((a, b, c) in listOf(fooData)) {
+ println("$a $b $c") // => 1 100 4
+ }
+
+ val mapData = mapOf("a" to 1, "b" to 2)
+ // Map.Entry також деструктурувуються
+ for ((key, value) in mapData) {
+ println("$key -> $value")
+ }
+
+ // Функція із "with" працює майже так само як це ж твердження у JavaScript.
+ data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+ val fooMutableData = MutableDataClassExample(7, 4, 9)
+ with (fooMutableData) {
+ x -= 2
+ y += 2
+ z--
+ }
+ println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+ /*
+ Список можна створити використовуючи функцію listOf.
+ Список буде незмінним, тобто елементи не можна буде додавати або видаляти.
+ */
+ val fooList = listOf("a", "b", "c")
+ println(fooList.size) // => 3
+ println(fooList.first()) // => a
+ println(fooList.last()) // => c
+ // доступ до елементів здійснюється через їхні порядковий номер.
+ println(fooList[1]) // => b
+
+ // Змінні списки можна створити використовуючи функцію mutableListOf.
+ val fooMutableList = mutableListOf("a", "b", "c")
+ fooMutableList.add("d")
+ println(fooMutableList.last()) // => d
+ println(fooMutableList.size) // => 4
+
+ // Функція setOf створює об'єкт типу множина.
+ val fooSet = setOf("a", "b", "c")
+ println(fooSet.contains("a")) // => true
+ println(fooSet.contains("z")) // => false
+
+ // mapOf створює асоціативний масив.
+ val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Доступ до значень в асоціативних масивах здійснюється через їхні ключі.
+ println(fooMap["a"]) // => 8
+
+ /*
+ Послідовності представлені як колекції лінивих обчислень. Функція generateSequence
+ створює послідовність.
+ */
+ val fooSequence = generateSequence(1, { it + 1 })
+ val x = fooSequence.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Приклад використання послідовностей, генерація чисел Фібоначчі:
+ fun fibonacciSequence(): Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun next(): Long {
+ val result = a + b
+ a = b
+ b = result
+ return a
+ }
+
+ return generateSequence(::next)
+ }
+ val y = fibonacciSequence().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+ // Kotlin має функції вищого порядку для роботи з колекціями.
+ val z = (1..9).map {it * 3}
+ .filter {it < 20}
+ .groupBy {it % 2 == 0}
+ .mapKeys {if (it.key) "even" else "odd"}
+ println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+ // Цикл for може використовуватись з будь-чим, що має ітератор.
+ for (c in "hello") {
+ println(c)
+ }
+
+ // Принцип роботи циклів "while" не відрізняється від інших мов програмування.
+ var ctr = 0
+ while (ctr < 5) {
+ println(ctr)
+ ctr++
+ }
+ do {
+ println(ctr)
+ ctr++
+ } while (ctr < 10)
+
+ /*
+ if може бути використаний як вираз, що повертає значення. Тому тернарний
+ оператор ?: не потрібний в Kotlin.
+ */
+ val num = 5
+ val message = if (num % 2 == 0) "even" else "odd"
+ println("$num is $message") // => 5 is odd
+
+ // "when" використовується як альтернатива ланцюгам "if-else if".
+ val i = 10
+ when {
+ i < 7 -> println("first block")
+ fooString.startsWith("hello") -> println("second block")
+ else -> println("else block")
+ }
+
+ // "when" може приймати аргумент.
+ when (i) {
+ 0, 21 -> println("0 or 21")
+ in 1..20 -> println("in the range 1 to 20")
+ else -> println("none of the above")
+ }
+
+ // "when" також може використовуватись як функція, що повертає значення.
+ var result = when (i) {
+ 0, 21 -> "0 or 21"
+ in 1..20 -> "in the range 1 to 20"
+ else -> "none of the above"
+ }
+ println(result)
+
+ /*
+ Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить
+ успішно, тоді можна використовувати об'єкт як данний тип не приводячи до нього
+ додатково.
+ */
+ fun smartCastExample(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x тепер має тип Boolean
+ return x
+ } else if (x is Int) {
+ // x тепер має тип Int
+ return x > 0
+ } else if (x is String) {
+ // x тепер має тип String
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(smartCastExample("Hello, world!")) // => true
+ println(smartCastExample("")) // => false
+ println(smartCastExample(5)) // => true
+ println(smartCastExample(0)) // => false
+ println(smartCastExample(true)) // => true
+
+ // Smartcast (розумне приведення) також працює з блоком when
+ fun smartCastWhenExample(x: Any) = when (x) {
+ is Boolean -> x
+ is Int -> x > 0
+ is String -> x.isNotEmpty()
+ else -> false
+ }
+
+ /*
+ Розширення - це ще один спосіб розширити функціонал класу.
+ Подібні методи розширення реалізовані у С#.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("Hello, world!".remove('l')) // => Heo, word!
+}
+
+// Класи перелічення також подібні до тих типів, що і в Java.
+enum class EnumExample {
+ A, B, C // Константи перелічення розділені комами.
+}
+fun printEnum() = println(EnumExample.A) // => A
+
+// Оскільки кожне перелічення - це об'єкт класу enum, воно може бути
+// проініціалізоване наступним чином:
+enum class EnumExample(val value: Int) {
+ A(value = 1),
+ B(value = 2),
+ C(value = 3)
+}
+fun printProperty() = println(EnumExample.A.value) // => 1
+
+// Кожне перелічення має властивості, які дозволяють отримати його ім'я
+// та порядок (позицію) в класі enum:
+fun printName() = println(EnumExample.A.name) // => A
+fun printPosition() = println(EnumExample.A.ordinal) // => 0
+
+/*
+Ключове слово object можна використати для створення об'єкту сінглтону. Об'єкт не
+можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем.
+Подібна можливість є в сінглтон об'єктах у Scala.
+*/
+object ObjectExample {
+ fun hello(): String {
+ return "hello"
+ }
+
+ override fun toString(): String {
+ return "Hello, it's me, ${ObjectExample::class.simpleName}"
+ }
+}
+
+
+fun useSingletonObject() {
+ println(ObjectExample.hello()) // => hello
+ // В Kotlin, "Any" - це корінь ієрархії класів, так само, як і "Object" у Java.
+ val someRef: Any = ObjectExample
+ println(someRef) // => Hello, it's me, ObjectExample
+}
+
+
+/*
+Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає виняток, якщо значення рівне null.
+*/
+var b: String? = "abc"
+val l = b!!.length
+
+// Далі - приклади перевизначення методів класу Any в класі-насліднику
+data class Counter(var value: Int) {
+ // перевизначити Counter += Int
+ operator fun plusAssign(increment: Int) {
+ this.value += increment
+ }
+
+ // перевизначити Counter++ та ++Counter
+ operator fun inc() = Counter(value + 1)
+
+ // перевизначити Counter + Counter
+ operator fun plus(other: Counter) = Counter(this.value + other.value)
+
+ // перевизначити Counter * Counter
+ operator fun times(other: Counter) = Counter(this.value * other.value)
+
+ // перевизначити Counter * Int
+ operator fun times(value: Int) = Counter(this.value * value)
+
+ // перевизначити Counter in Counter
+ operator fun contains(other: Counter) = other.value == this.value
+
+ // перевизначити Counter[Int] = Int
+ operator fun set(index: Int, value: Int) {
+ this.value = index + value
+ }
+
+ // перевизначити виклик екземпляру Counter
+ operator fun invoke() = println("The value of the counter is $value")
+
+}
+// Можна також перевизначити оператори через методи розширення.
+// перевизначити -Counter
+operator fun Counter.unaryMinus() = Counter(-this.value)
+
+fun operatorOverloadingDemo() {
+ var counter1 = Counter(0)
+ var counter2 = Counter(5)
+ counter1 += 7
+ println(counter1) // => Counter(value=7)
+ println(counter1 + counter2) // => Counter(value=12)
+ println(counter1 * counter2) // => Counter(value=35)
+ println(counter2 * 2) // => Counter(value=10)
+ println(counter1 in Counter(5)) // => false
+ println(counter1 in Counter(7)) // => true
+ counter1[26] = 10
+ println(counter1) // => Counter(value=36)
+ counter1() // => The value of the counter is 36
+ println(-counter2) // => Counter(value=-5)
+}
+```
+
+### Подальше вивчення
+
+* [Уроки Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Спробувати попрацювати з Kotlin в браузері](https://play.kotlinlang.org/)
+* [Список корисних посилань](http://kotlin.link/)
diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
new file mode 100644
index 00000000..8d4517fe
--- /dev/null
+++ b/uk-ua/mips-ua.html.markdown
@@ -0,0 +1,366 @@
+---
+language: "MIPS Assembly"
+filename: MIPS.asm
+contributors:
+ - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+ - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+
+[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# Коментарі позначені як'#'
+
+# Всі символи після '#' ігноруються лексичним аналізатором асемблера.
+
+# Зазвичай програми поділяються на .data та .text частини
+
+.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
+ # в мовах програмування вищого рівня
+
+ # Змінна оголошується наступним чином: [назва]: .[тип] [значення]
+ # Наприклад:
+ hello_world: .asciiz "Hello World\n" # Оголосити текстову змінну
+ num1: .word 42 # word - це чисельний тип 32-бітного розряду
+
+ arr1: .word 1, 2, 3, 4, 5 # Масив чисел
+ arr2: .byte 'a', 'b' # Масив буквених символів (розмір кожного - 1 байт)
+ buffer: .space 60 # Виділити місце в RAM
+ # (не очищується, тобто не заповнюється 0)
+
+ # Розміри типів даних
+ _byte: .byte 'a' # 1 байт
+ _halfword: .half 53 # 2 байти
+ _word: .word 3 # 4 байти
+ _float: .float 3.14 # 4 байти
+ _double: .double 7.0 # 8 байтів
+
+ .align 2 # Вирівнювання пам'яті даних, де число
+ # показує кількість байтів, вирівнених
+ # у степені 2. (.align 2 означає
+ # чисельне (word) вирівнювання оскільки
+ # 2^2 = 4 байти)
+
+.text # Розділ, що містить інструкції та
+ # логіку програми
+
+.globl _main # Оголошує назву інструкції як
+ # глобальну, тобто, яка є доступною для
+ # всіх інших файлів
+
+ _main: # програми MIPS виконують інструкції
+ # послідовно, тобто першочергово код
+ # буде виконуватись після цієї позначки
+
+ # Виведемо на екран "hello world"
+ la $a0, hello_world # Завантажує адресу тексту у пам'яті
+ li $v0, 4 # Завантажує значення системної
+ # команди (вказуючи тип функціоналу)
+ syscall # Виконує зазначену системну команду
+ # з обраним аргументом ($a0)
+
+ # Регістри (використовуються, щоб тримати дані протягом виконання програми)
+ # $t0 - $t9 # Тимчасові регістри використовуються
+ # для проміжних обчислень всередині
+ # підпрограм (не зберігаються між
+ # викликами функцій)
+
+ # $s0 - $s7 # Збережені регістри, у яких значення
+ # зберігаються між викликами підпрограм.
+ # Зазвичай зберігаються у стеку.
+
+ # $a0 - $a3 # Регістри для передачі аргументів для
+ # підпрограм
+ # $v0 - $v1 # Регістри для значень, що повертаються
+ # від викликаної функції
+
+ # Типи інструкції завантаження / збереження
+ la $t0, label # Скопіювати адресу в пам'яті, де
+ # зберігається значення змінної label
+ # в регістр $t0
+ lw $t0, label # Скопіювати чисельне значення з пам'яті
+ lw $t1, 4($s0) # Скопіювати чисельне значення з адреси
+ # пам'яті регістра зі зміщенням в
+ # 4 байти (адреса + 4)
+ lb $t2, label # Скопіювати буквений символ в частину
+ # нижчого порядку регістра $t2
+ lb $t2, 0($s0) # Скопіювати буквений символ з адреси
+ # в $s0 із зсувом 0
+ # Подібне використання і 'lh' для halfwords
+
+ sw $t0, label # Зберегти чисельне значення в адресу в
+ # пам'яті, що відповідає змінній label
+ sw $t0, 8($s0) # Зберегти чисельне значення в адресу,
+ # що зазначена у $s0, та зі зсувом у 8 байтів
+ # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords.
+ # 'sa' не існує
+
+
+### Математичні операції ###
+ _math:
+ # Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять
+ lw $t0, num # Із розділа з даними
+ li $t0, 5 # Або безпосередньо з константи
+ li $t1, 6
+ add $t2, $t0, $t1 # $t2 = $t0 + $t1
+ sub $t2, $t0, $t1 # $t2 = $t0 - $t1
+ mul $t2, $t0, $t1 # $t2 = $t0 * $t1
+ div $t2, $t0, $t1 # $t2 = $t0 / $t1 (Може не підтримуватись
+ # деякими версіями MARS)
+ div $t0, $t1 # Виконує $t0 / $t1. Отримати частку можна
+ # за допомогою команди 'mflo', остаток - 'mfhi'
+
+ # Бітовий зсув
+ sll $t0, $t0, 2 # Побітовий зсув вліво на 2. Біти вищого порядку
+ # не зберігаються, нищого - заповнюються 0
+ sllv $t0, $t1, $t2 # Зсув вліво зі змінною кількістю у
+ # регістрі
+ srl $t0, $t0, 5 # Побітовий зсув вправо на 5 (не зберігає
+ # біти, біти зліва заповнюються 0)
+ srlv $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у
+ # регістрі
+ sra $t0, $t0, 7 # Побітовий арифметичний зсув вправо
+ # (зберігає біти)
+ srav $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у
+ # регістрі зі збереження значеннь бітів
+
+ # Побітові операції
+ and $t0, $t1, $t2 # Побітове І (AND)
+ andi $t0, $t1, 0xFFF # Побітове І з безпосереднім значенням
+ or $t0, $t1, $t2 # Побітове АБО (OR)
+ ori $t0, $t1, 0xFFF # Побітове АБО з безпосереднім значенням
+ xor $t0, $t1, $t2 # Побітова виключна диз'юнкція (XOR)
+ xori $t0, $t1, 0xFFF # Побітове XOR з безпосереднім значенням
+ nor $t0, $t1, $t2 # Побітова стрілка Пірса (NOR)
+
+## Розгалуження ##
+ _branching:
+ # В основному інструкції розгалуження мають наступну форму:
+ # <instr> <reg1> <reg2> <label>
+ # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
+ # правдиве
+
+ beq $t0, $t1, reg_eq # Перейдемо у розгалуження reg_eq
+ # якщо $t0 == $t1, інакше -
+ # виконати наступний рядок
+ bne $t0, $t1, reg_neq # Розгалужується, якщо $t0 != $t1
+ b branch_target # Розгалуження без умови завжди виконується
+ beqz $t0, req_eq_zero # Розгалужується, якщо $t0 == 0
+ bnez $t0, req_neq_zero # Розгалужується, якщо $t0 != 0
+ bgt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 > $t1
+ bge $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 >= $t1
+ bgtz $t0, t0_gt0 # Розгалужується, якщо $t0 > 0
+ blt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 < $t1
+ ble $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 <= $t1
+ bltz $t0, t0_lt0 # Розгалужується, якщо $t0 < 0
+ slt $s0, $t0, $t1 # Інструкція, що посилає сигнал коли
+ # $t0 < $t1, результат зберігається в $s0
+ # (1 - правдиве твердження)
+
+ # Просте твердження якщо (if)
+ # if (i == j)
+ # f = g + h;
+ # f = f - i;
+
+ # Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+ bne $s3, $s4, L1 # if (i !=j)
+ add $s0, $s1, $s2 # f = g + h
+
+ L1:
+ sub $s0, $s0, $s3 # f = f - i
+
+ # Нижче наведений приклад знаходження максимального значення з 3 чисел
+ # Пряма трансляція в Java з логіки MIPS:
+ # if (a > b)
+ # if (a > c)
+ # max = a;
+ # else
+ # max = c;
+ # else
+ # max = b;
+ # else
+ # max = c;
+
+ # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр
+ ble $s0, $s1, a_LTE_b # якщо (a <= b) розгалуження(a_LTE_b)
+ ble $s0, $s2, max_C # якщо (a > b && a <=c) розгалуження(max_C)
+ move $v0, $s1 # інакше [a > b && a > c] max = a
+ j done # Перейти в кінець програми
+
+ a_LTE_b: # Мітка розгалуження, коли a <= b
+ ble $s1, $s2, max_C # якщо (a <= b && b <= c) розгалуження(max_C)
+ move $v0, $s1 # якщо (a <= b && b > c) max = b
+ j done # Перейти в кінець програми
+
+ max_C:
+ move $v0, $s2 # max = c
+
+ done: # Кінець програми
+
+## Цикли ##
+ _loops:
+ # Цикл складається з умови виходу та з інструкції переходу після його завершення
+ li $t0, 0
+ while:
+ bgt $t0, 10, end_while # Коли $t0 менше 10, продовжувати ітерації
+ addi $t0, $t0, 1 # Збільшити значення
+ j while # Перейти на початок циклу
+ end_while:
+
+ # Транспонування 2D матриці
+ # Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+ li $t0, 0 # Лічильник для i
+ li $t1, 0 # Лічильник для j
+ matrix_row:
+ bgt $t0, 3, matrix_row_end
+
+ matrix_col:
+ bgt $t1, 3, matrix_col_end
+
+ # ...
+
+ addi $t1, $t1, 1 # Збільшити лічильник стовпця (col)
+ matrix_col_end:
+
+ # ...
+
+ addi $t0, $t0, 1
+ matrix_row_end:
+
+## Функції ##
+ _functions:
+ # Функції - це процедури, що викликаються, приймають аргументи та повертають значення
+
+ main: # Програма починається з головної функції
+ jal return_1 # jal збереже поточний ПЦ (програмний центр) в $ra,
+ # а потім перейде до return_1
+
+ # Як передати аргументи?
+ # По-перше, ми маємо передати значення аргументів у регістри аргументів
+ li $a0, 1
+ li $a1, 2
+ jal sum # Тепер ми можемо викликати функцію
+
+ # Як щодо рекурсії?
+ # Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо
+ # та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику
+ li $a0, 3
+ jal fact
+
+ li $v0, 10
+ syscall
+
+ # Ця функція повертає 1
+ return_1:
+ li $v0, 1 # Завантажити val в регіст $v0
+ jr $ra # Повернутись до попереднього ПЦ і продовжити виконання
+
+
+ # Функція з двома аргументами
+ sum:
+ add $v0, $a0, $a1
+ jr $ra # Повернутись
+
+ # Рекурсивна функція, яка знаходить факторіал
+ fact:
+ addi $sp, $sp, -8 # Виділити місце в стеку
+ sw $s0, ($sp) # Зберегти регістр, що містить поточне число
+ sw $ra, 4($sp) # Зберегти попередній ПЦ
+
+ li $v0, 1 # Проініціалізувати значення, що повертатиметься
+ beq $a0, 0, fact_done # Закінчити, якщо параметр 0
+
+ # Інакше, продовжити рекурсію
+ move $s0, $a0 # Скопіювати $a0 в $s0
+ sub $a0, $a0, 1
+ jal fact
+
+ mul $v0, $s0, $v0 # Множення
+
+ fact_done:
+ lw $s0, ($sp)
+ lw $ra, ($sp) # Відновити ПЦ
+ addi $sp, $sp, 8
+
+ jr $ra
+
+## Макроси ##
+ _macros:
+ # Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою
+ # однієї змінної, для покращення читабельності
+ # Це не заміна функцій.
+ # Вони мають бути оголошені перед використанням
+
+ # Макрос для виведення нових рядків (оскільки операція досить часто виконується)
+ .macro println()
+ la $a0, newline # Значення нового рядка зберігатиметься тут
+ li $v0, 4
+ syscall
+ .end_macro
+
+ println() # Асемблер скопіює цей блок коду сюди
+ # перед тим, як виконувати його
+
+ # Можна передавати параметри у макроси.
+ # Параметри позначаються знаком '%' з довільною назвою
+ .macro print_int(%num)
+ li $v0, 1
+ lw $a0, %num
+ syscall
+ .end_macro
+
+ li $t0, 1
+ print_int($t0)
+
+ # Значення також можна передавати безпосередньо в макроси
+ .macro immediates(%a, %b)
+ add $t0, %a, %b
+ .end_macro
+
+ immediates(3, 5)
+
+ # Одночасно із назвами змінних
+ .macro print(%string)
+ la $a0, %string
+ li $v0, 4
+ syscall
+ .end_macro
+
+ print(hello_world)
+
+## Масиви ##
+.data
+ list: .word 3, 0, 1, 2, 6 # Це масив чисел
+ char_arr: .asciiz "hello" # Це текстовий масив
+ buffer: .space 128 # Виділяє блок пам'яті, що
+ # автоматично не очищується
+ # Ці блоки пам'яті вирівнені
+ # вирівнені поруч один з одним
+
+.text
+ la $s0, list # Завантажити адресу списку
+ li $t0, 0 # Лічильник
+ li $t1, 5 # Довжина списку
+
+ loop:
+ bgt $t0, $t1, end_loop
+
+ lw $a0, ($s0)
+ li $v0, 1
+ syscall # Вивести число
+
+ addi $s0, $s0, 4 # Розмір числа - 4 байти
+ addi $t0, $t0, 1 # Збільшити
+ j loop
+ end_loop:
+
+## Включення ##
+# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу
+# копіюється та вставляється в місце, де оголошений імпорт)
+.include "somefile.asm"
+
+```
diff --git a/uk-ua/python-ua.html.markdown b/uk-ua/python-ua.html.markdown
new file mode 100644
index 00000000..4091e433
--- /dev/null
+++ b/uk-ua/python-ua.html.markdown
@@ -0,0 +1,818 @@
+---
+language: python
+lang: uk-ua
+contributors:
+ - ["Louie Dinh", "http://ldinh.ca"]
+ - ["Amin Bandali", "https://aminb.org"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+ - ["evuez", "http://github.com/evuez"]
+ - ["asyne", "https://github.com/justblah"]
+ - ["habi", "http://github.com/habi"]
+translators:
+ - ["Oleh Hromiak", "https://github.com/ogroleg"]
+filename: learnpython-ua.py
+---
+
+Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з
+найбільш популярних мов. Я закохався у Python завдяки простому і зрозумілому
+синтаксису. Це майже як виконуваний псевдокод.
+
+З вдячністю чекаю ваших відгуків: [@louiedinh](http://twitter.com/louiedinh)
+або louiedinh [at] [поштовий сервіс від Google]
+
+Примітка: Ця стаття стосується Python 2.7, проте має працювати і
+у інших версіях Python 2.x. Python 2.7 підходить до кінця свого терміну,
+його підтримку припинять у 2020, тож наразі краще починати вивчення Python
+з версії 3.x.
+Аби вивчити Python 3.x, звертайтесь до статті по Python 3.
+
+```python
+# Однорядкові коментарі починаються з символу решітки.
+
+""" Текст, що займає декілька рядків,
+ може бути записаний з використанням 3 знаків " і
+ зазвичай використовується у якості
+ вбудованої документації
+"""
+
+####################################################
+## 1. Примітивні типи даних та оператори
+####################################################
+
+# У вас є числа
+3 # => 3
+
+# Математика працює досить передбачувано
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7
+
+# А ось з діленням все трохи складніше. Воно цілочисельне і результат
+# автоматично округлюється у меншу сторону.
+5 / 2 # => 2
+
+# Аби правильно ділити, спершу варто дізнатися про числа
+# з плаваючою комою.
+2.0 # Це число з плаваючою комою
+11.0 / 4.0 # => 2.75 ох... Так набагато краще
+
+# Результат цілочисельного ділення округлюється у меншу сторону
+# як для додатніх, так і для від'ємних чисел.
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # Працює і для чисел з плаваючою комою
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Зверніть увагу, що ми також можемо імпортувати модуль для ділення,
+# див. розділ Модулі
+# аби звичне ділення працювало при використанні лише '/'.
+from __future__ import division
+
+11 / 4 # => 2.75 ...звичне ділення
+11 // 4 # => 2 ...цілочисельне ділення
+
+# Залишок від ділення
+7 % 3 # => 1
+
+# Піднесення до степеня
+2 ** 4 # => 16
+
+# Приорітет операцій вказується дужками
+(1 + 3) * 2 # => 8
+
+# Логічні оператори
+# Зверніть увагу: ключові слова «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
+not True # => False
+not False # => True
+
+# Рівність — це ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Нерівність — це !=
+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
+
+# Рядки позначаються символом " або '
+"Це рядок."
+'Це теж рядок.'
+
+# І рядки також можна додавати!
+"Привіт " + "світ!" # => "Привіт світ!"
+# Рядки можна додавати і без '+'
+"Привіт " "світ!" # => "Привіт світ!"
+
+# ... або множити
+"Привіт" * 3 # => "ПривітПривітПривіт"
+
+# З рядком можна працювати як зі списком символів
+"Це рядок"[0] # => 'Ц'
+
+# Ви можете дізнатися довжину рядка
+len("Це рядок") # => 8
+
+# Символ % використовується для форматування рядків, наприклад:
+"%s можуть бути %s" % ("рядки", "інтерпольовані")
+
+# Новий спосіб форматування рядків — використання методу format.
+# Це бажаний спосіб.
+"{} є {}".format("Це", "заповнювач")
+"{0} можуть бути {1}".format("рядки", "форматовані")
+# Якщо ви не хочете рахувати, то можете скористатися ключовими словами.
+"{name} хоче з'істи {food}".format(name="Боб", food="лазанью")
+
+# None - це об'єкт
+None # => None
+
+# Не використовуйте оператор рівності '=='' для порівняння
+# об'єктів з None. Використовуйте для цього «is»
+"etc" is None # => False
+None is None # => True
+
+# Оператор 'is' перевіряє ідентичність об'єктів. Він не
+# дуже корисний при роботі з примітивними типами, проте
+# незамінний при роботі з об'єктами.
+
+# None, 0 і порожні рядки/списки рівні False.
+# Всі інші значення рівні True
+bool(0) # => False
+bool("") # => False
+
+
+####################################################
+## 2. Змінні та колекції
+####################################################
+
+# В Python є оператор print
+print "Я Python. Приємно познайомитись!" # => Я Python. Приємно познайомитись!
+
+# Отримати дані з консолі просто
+input_string_var = raw_input(
+ "Введіть щось: ") # Повертає дані у вигляді рядка
+input_var = input("Введіть щось: ") # Працює з даними як з кодом на python
+# Застереження: будьте обережні при використанні методу input()
+
+# Оголошувати змінні перед ініціалізацією не потрібно.
+some_var = 5 # За угодою використовується нижній_регістр_з_підкресленнями
+some_var # => 5
+
+# При спробі доступу до неініціалізованої змінної
+# виникне виняткова ситуація.
+# Див. розділ Потік управління, аби дізнатись про винятки більше.
+some_other_var # Помилка в імені
+
+# if може використовуватися як вираз
+# Такий запис еквівалентний тернарному оператору '?:' у мові С
+"yahoo!" if 3 > 2 else 2 # => "yahoo!"
+
+# Списки зберігають послідовності
+li = []
+# Можна одразу створити заповнений список
+other_li = [4, 5, 6]
+
+# Об'єкти додаються у кінець списку за допомогою методу append
+li.append(1) # li тепер дорівнює [1]
+li.append(2) # li тепер дорівнює [1, 2]
+li.append(4) # li тепер дорівнює [1, 2, 4]
+li.append(3) # li тепер дорівнює [1, 2, 4, 3]
+# І видаляються з кінця методом pop
+li.pop() # => повертає 3 і li стає рівним [1, 2, 4]
+# Повернемо елемент назад
+li.append(3) # li тепер знову дорівнює [1, 2, 4, 3]
+
+# Поводьтесь зі списком як зі звичайним масивом
+li[0] # => 1
+# Присвоюйте нові значення вже ініціалізованим індексам за допомогою =
+li[0] = 42
+li[0] # => 42
+li[0] = 1 # Зверніть увагу: повертаємось до попереднього значення
+# Звертаємось до останнього елементу
+li[-1] # => 3
+
+# Спроба вийти за границі масиву призводить до помилки в індексі
+li[4] # помилка в індексі
+
+# Можна звертатися до діапазону, використовуючи так звані зрізи
+# (Для тих, хто любить математику: це називається замкнуто-відкритий інтервал).
+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[початок:кінець:крок]
+
+# Видаляємо довільні елементи зі списку оператором del
+del li[2] # li тепер [1, 2, 3]
+
+# Ви можете додавати списки
+li + other_li # => [1, 2, 3, 4, 5, 6]
+# Зверніть увагу: значення li та other_li при цьому не змінились.
+
+# Поєднувати списки можна за допомогою методу extend
+li.extend(other_li) # Тепер li дорівнює [1, 2, 3, 4, 5, 6]
+
+# Видалити перше входження значення
+li.remove(2) # Тепер li дорівнює [1, 3, 4, 5, 6]
+li.remove(2) # Помилка значення, оскільки у списку li немає 2
+
+# Вставити елемент за вказаним індексом
+li.insert(1, 2) # li знову дорівнює [1, 2, 3, 4, 5, 6]
+
+# Отримати індекс першого знайденого елементу
+li.index(2) # => 1
+li.index(7) # Помилка значення, оскільки у списку li немає 7
+
+# Перевірити елемент на входження у список можна оператором in
+1 in li # => True
+
+# Довжина списку обчислюється за допомогою функції len
+len(li) # => 6
+
+# Кортежі схожі на списки, лише незмінні
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # Виникає помилка типу
+
+# Все те ж саме можна робити і з кортежами
+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
+d, e, f = 4, 5, 6 # дужки можна опустити
+# Кортежі створюються за замовчуванням, якщо дужки опущено
+g = 4, 5, 6 # => (4, 5, 6)
+# Дивіться, як легко обміняти значення двох змінних
+e, d = d, e # тепер d дорівнює 5, а e дорівнює 4
+
+# Словники містять асоціативні масиви
+empty_dict = {}
+# Ось так описується попередньо заповнений словник
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Значення можна отримати так само, як і зі списку
+filled_dict["one"] # => 1
+
+# Можна отримати всі ключі у виді списку за допомогою методу keys
+filled_dict.keys() # => ["three", "two", "one"]
+# Примітка: збереження порядку ключів у словників не гарантується
+# Ваші результати можуть не співпадати з цими.
+
+# Можна отримати і всі значення у вигляді списку, використовуйте метод values
+filled_dict.values() # => [3, 2, 1]
+# Те ж зауваження щодо порядку ключів діє і тут
+
+# Отримуйте всі пари ключ-значення у вигляді списку кортежів
+# за допомогою "items()"
+filled_dict.items() # => [("one", 1), ("two", 2), ("three", 3)]
+
+# За допомогою оператору in можна перевіряти ключі на входження у словник
+"one" in filled_dict # => True
+1 in filled_dict # => False
+
+# Спроба отримати значення за неіснуючим ключем викине помилку ключа
+filled_dict["four"] # помилка ключа
+
+# Аби уникнути цього, використовуйте метод 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("four") все ще => None
+# (get не встановлює значення елементу словника)
+
+# Присвоюйте значення ключам так само, як і в списках
+filled_dict["four"] = 4 # тепер filled_dict["four"] => 4
+
+# Метод setdefault() вставляє пару ключ-значення лише
+# за відсутності такого ключа
+filled_dict.setdefault("five", 5) # filled_dict["five"] повертає 5
+filled_dict.setdefault("five", 6) # filled_dict["five"] все ще повертає 5
+
+
+# Множини містять... ну, загалом, множини
+# (які схожі на списки, проте в них не може бути елементів, які повторюються)
+empty_set = set()
+# Ініціалізація множини набором значень
+some_set = set([1,2,2,3,4]) # some_set тепер дорівнює set([1, 2, 3, 4])
+
+# Порядок не гарантовано, хоча інколи множини виглядають відсортованими
+another_set = set([4, 3, 2, 2, 1]) # another_set тепер set([1, 2, 3, 4])
+
+# Починаючи з Python 2.7, ви можете використовувати {}, аби створити множину
+filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+
+# Додавання нових елементів у множину
+filled_set.add(5) # filled_set тепер дорівнює {1, 2, 3, 4, 5}
+
+# Перетин множин: &
+other_set = {3, 4, 5, 6}
+filled_set & other_set # => {3, 4, 5}
+
+# Об'єднання множин: |
+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, 5}
+
+# Перевіряємо чи множина зліва є надмножиною множини справа
+{1, 2} >= {1, 2, 3} # => False
+
+# Перевіряємо чи множина зліва є підмножиною множини справа
+{1, 2} <= {1, 2, 3} # => True
+
+# Перевірка на входження у множину: in
+2 in filled_set # => True
+10 in filled_set # => False
+
+
+####################################################
+## 3. Потік управління
+####################################################
+
+# Для початку створимо змінну
+some_var = 5
+
+# Так виглядає вираз if. Відступи у python дуже важливі!
+# результат: «some_var менше, ніж 10»
+if some_var > 10:
+ print("some_var набагато більше, ніж 10.")
+elif some_var < 10: # Вираз elif є необов'язковим.
+ print("some_var менше, ніж 10.")
+else: # Це теж необов'язково.
+ print("some_var дорівнює 10.")
+
+
+"""
+Цикли For проходять по спискам
+
+Результат:
+ собака — це ссавець
+ кішка — це ссавець
+ миша — це ссавець
+"""
+for animal in ["собака", "кішка", "миша"]:
+ # Можете використовувати оператор {0} для інтерполяції форматованих рядків
+ print "{0} — це ссавець".format(animal)
+
+"""
+"range(число)" повертає список чисел
+від нуля до заданого числа
+Друкує:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+"""
+"range(нижня_границя, верхня_границя)" повертає список чисел
+від нижньої границі до верхньої
+Друкує:
+ 4
+ 5
+ 6
+ 7
+"""
+for i in range(4, 8):
+ print i
+
+"""
+Цикли while продовжуються до тих пір, поки вказана умова не стане хибною.
+Друкує:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Короткий запис для x = x + 1
+
+# Обробляйте винятки блоками try/except
+
+# Працює у Python 2.6 і вище:
+try:
+ # Аби створити виняток, використовується raise
+ raise IndexError("Помилка у індексі!")
+except IndexError as e:
+ pass # pass — оператор, який нічого не робить. Зазвичай тут відбувається
+ # відновлення після помилки.
+except (TypeError, NameError):
+ pass # Винятки можна обробляти групами, якщо потрібно.
+else: # Необов'язковий вираз. Має слідувати за останнім блоком except
+ print("Все добре!") # Виконається лише якщо не було ніяких винятків
+finally: # Виконується у будь-якому випадку
+ print "Тут ми можемо звільнити ресурси"
+
+# Замість try/finally для звільнення ресурсів
+# ви можете використовувати вираз with
+with open("myfile.txt") as f:
+ for line in f:
+ print line
+
+
+####################################################
+## 4. Функції
+####################################################
+
+# Використовуйте def для створення нових функцій
+def add(x, y):
+ print "x дорівнює {0}, а y дорівнює {1}".format(x, y)
+ return x + y # Повертайте результат за допомогою ключового слова return
+
+
+# Виклик функції з аргументами
+add(5, 6) # => друкує «x дорівнює 5, а y дорівнює 6» і повертає 11
+
+# Інший спосіб виклику функції — виклик з іменованими аргументами
+add(y=6, x=5) # Іменовані аргументи можна вказувати у будь-якому порядку
+
+
+# Ви можете визначити функцію, яка приймає змінну кількість аргументів,
+# які будуть інтерпретовані як кортеж, за допомогою *
+def varargs(*args):
+ return args
+
+
+varargs(1, 2, 3) # => (1,2,3)
+
+
+# А також можете визначити функцію, яка приймає змінне число
+# іменованих аргументів, котрі будуть інтерпретовані як словник, за допомогою **
+def keyword_args(**kwargs):
+ return kwargs
+
+
+# Давайте подивимось що з цього вийде
+keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}
+
+# Якщо хочете, можете використовувати обидва способи одночасно
+def all_the_args(*args, **kwargs):
+ print(args)
+ print(kwargs)
+
+
+"""
+all_the_args(1, 2, a=3, b=4) друкує:
+ (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)
+
+# ви можете передавати довільне число позиційних або іменованих аргументів
+# іншим функціям, які їх приймають, розпаковуючи за допомогою
+# * або ** відповідно
+def pass_all_the_args(*args, **kwargs):
+ all_the_args(*args, **kwargs)
+ print varargs(*args)
+ print keyword_args(**kwargs)
+
+
+# Область визначення функцій
+x = 5
+
+
+def set_x(num):
+ # Локальна змінна x - не те ж саме, що глобальна змінна x
+ x = num # => 43
+ print x # => 43
+
+
+def set_global_x(num):
+ global x
+ print x # => 5
+ x = num # глобальна змінна x тепер дорівнює 6
+ print x # => 6
+
+
+set_x(43)
+set_global_x(6)
+
+# В Python функції є об'єктами першого класу
+def create_adder(x):
+ def adder(y):
+ return x + y
+
+ return adder
+
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+# Також є і анонімні функції
+(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]
+map(max, [1, 2, 3], [4, 2, 1]) # => [4, 2, 3]
+
+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 in 'abc'} # => {'a', 'b', 'c'}
+{x: x ** 2 for x in range(5)} # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Класи
+####################################################
+
+# Аби отримати клас, ми наслідуємо object.
+class Human(object):
+ # Атрибут класу. Він розділяється всіма екземплярами цього класу.
+ species = "H. sapiens"
+
+ # Звичайний конструктор, буде викликаний при ініціалізації екземпляру класу
+ # Зверніть увагу, що подвійне підкреслення на початку та наприкінці імені
+ # використовується для позначення об'єктів та атрибутів,
+ # які використовуються Python, але знаходяться у просторах імен,
+ # якими керує користувач. Не варто вигадувати для них імена самостійно.
+ def __init__(self, name):
+ # Присвоєння значення аргумента атрибуту класу name
+ self.name = name
+
+ # Ініціалізуємо властивість
+ self.age = 0
+
+ # Метод екземпляру. Всі методи приймають self у якості першого аргументу
+ def say(self, msg):
+ return "%s: %s" % (self.name, msg)
+
+ # Методи класу розділяються між усіма екземплярами
+ # Вони викликаються з вказанням викликаючого класу
+ # у якості першого аргументу
+ @classmethod
+ def get_species(cls):
+ return cls.species
+
+ # Статичний метод викликається без посилання на клас або екземпляр
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+ # Властивість.
+ # Перетворює метод age() в атрибут тільки для читання
+ # з таким же ім'ям.
+ @property
+ def age(self):
+ return self._age
+
+ # Це дозволяє змінювати значення властивості
+ @age.setter
+ def age(self, age):
+ self._age = age
+
+ # Це дозволяє видаляти властивість
+ @age.deleter
+ def age(self):
+ del self._age
+
+
+# Створюємо екземпляр класу
+i = Human(name="Данило")
+print(i.say("привіт")) # Друкує: «Данило: привіт»
+
+j = Human("Меланка")
+print(j.say("Привіт")) # Друкує: «Меланка: привіт»
+
+# Виклик методу класу
+i.get_species() # => "H. sapiens"
+
+# Зміна розділюваного атрибуту
+Human.species = "H. neanderthalensis"
+i.get_species() # => "H. neanderthalensis"
+j.get_species() # => "H. neanderthalensis"
+
+# Виклик статичного методу
+Human.grunt() # => "*grunt*"
+
+# Оновлюємо властивість
+i.age = 42
+
+# Отримуємо значення
+i.age # => 42
+
+# Видаляємо властивість
+del i.age
+i.age # => виникає помилка атрибуту
+
+####################################################
+## 6. Модулі
+####################################################
+
+# Ви можете імпортувати модулі
+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
+# Ви також можете переконатися, що функції еквівалентні
+from math import sqrt
+
+math.sqrt == m.sqrt == sqrt # => True
+
+# Модулі в Python — це звичайні Python-файли. Ви
+# можете писати свої модулі та імпортувати їх. Назва
+# модуля співпадає з назвою файлу.
+
+# Ви можете дізнатися, які функції та атрибути визначені
+# в модулі
+import math
+
+dir(math)
+
+
+# Якщо у вас є Python скрипт з назвою math.py у тій же папці, що
+# і ваш поточний скрипт, то файл math.py
+# може бути завантажено замість вбудованого у Python модуля.
+# Так трапляється, оскільки локальна папка має перевагу
+# над вбудованими у Python бібліотеками.
+
+####################################################
+## 7. Додатково
+####################################################
+
+# Генератори
+# Генератор "генерує" значення тоді, коли вони запитуються, замість того,
+# щоб зберігати все одразу
+
+# Метод нижче (*НЕ* генератор) подвоює всі значення і зберігає їх
+# в `double_arr`. При великих розмірах може знадобитися багато ресурсів!
+def double_numbers(iterable):
+ double_arr = []
+ for i in iterable:
+ double_arr.append(i + i)
+ return double_arr
+
+
+# Тут ми спочатку подвоюємо всі значення, потім повертаємо їх,
+# аби перевірити умову
+for value in double_numbers(range(1000000)): # `test_non_generator`
+ print value
+ if value > 5:
+ break
+
+
+# Натомість ми можемо скористатися генератором, аби "згенерувати"
+# подвійне значення, як тільки воно буде запитане
+def double_numbers_generator(iterable):
+ for i in iterable:
+ yield i + i
+
+
+# Той самий код, але вже з генератором, тепер дозволяє нам пройтися по
+# значенням і подвоювати їх одне за одним якраз тоді, коли вони обробляються
+# за нашою логікою, одне за одним. А як тільки ми бачимо, що value > 5, ми
+# виходимо з циклу і більше не подвоюємо більшість значень,
+# які отримали на вхід (НАБАГАТО ШВИДШЕ!)
+for value in double_numbers_generator(xrange(1000000)): # `test_generator`
+ print value
+ if value > 5:
+ break
+
+# Між іншим: ви помітили використання `range` у `test_non_generator` і
+# `xrange` у `test_generator`?
+# Як `double_numbers_generator` є версією-генератором `double_numbers`, так
+# і `xrange` є аналогом `range`, але у вигляді генератора.
+# `range` поверне нам масив з 1000000 значень
+# `xrange`, у свою чергу, згенерує 1000000 значень для нас тоді,
+# коли ми їх запитуємо / будемо проходитись по ним.
+
+# Аналогічно включенням у вигляді списків, ви можете створювати включення
+# у вигляді генераторів.
+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]
+
+# Декоратори
+# Декоратор – це функція вищого порядку, яка приймає та повертає функцію.
+# Простий приклад використання – декоратор add_apples додає елемент 'Apple' в
+# список fruits, який повертає цільова функція get_fruits.
+def add_apples(func):
+ def get_fruits():
+ fruits = func()
+ fruits.append('Apple')
+ return fruits
+ return get_fruits
+
+@add_apples
+def get_fruits():
+ return ['Banana', 'Mango', 'Orange']
+
+# Друкуємо список разом з елементом 'Apple', який знаходиться в ньому:
+# Banana, Mango, Orange, Apple
+print ', '.join(get_fruits())
+
+# У цьому прикладі beg обертає say
+# Beg викличе say. Якщо say_please дорівнюватиме True, то повідомлення,
+# що повертається, буде змінено.
+from functools import wraps
+
+
+def beg(target_function):
+ @wraps(target_function)
+ def wrapper(*args, **kwargs):
+ msg, say_please = target_function(*args, **kwargs)
+ if say_please:
+ return "{} {}".format(msg, "Будь ласка! Я бідний :(")
+ return msg
+
+ return wrapper
+
+
+@beg
+def say(say_please=False):
+ msg = "Ви можете купити мені пива?"
+ return msg, say_please
+
+
+print say() # Ви можете купити мені пива?
+print say(say_please=True) # Ви можете купити мені пива? Будь ласка! Я бідний :(
+```
+
+## Готові до більшого?
+
+### Безкоштовні онлайн-матеріали
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Официальная документация](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [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)
+
diff --git a/uk-ua/rust-ua.html.markdown b/uk-ua/rust-ua.html.markdown
new file mode 100644
index 00000000..4ec2b7c9
--- /dev/null
+++ b/uk-ua/rust-ua.html.markdown
@@ -0,0 +1,331 @@
+---
+language: rust
+contributors:
+ - ["P1start", "http://p1start.github.io/"]
+translators:
+ - ["Volodymyr Korniichuk", "https://github.com/ezhikus"]
+filename: learnrust-uk.rs
+lang: uk-ua
+---
+
+Rust - це мова програмування, що розрабляється спільнотою Mozilla Research
+Rust поєднує в собі низькорівневий контроль швидкодії з високорівневими
+інструментами забезпечення гарантій цілісності та безпеки.
+
+Rust досягає своїх цілей без автоматичного збирання сміття і не вимагає
+наявності певного середовища виконання, що робить можливим пряму заміну
+бібліотек, написаних на мові С на бібліотеки, написані на Rust.
+
+Перший реліз Rust (версія 0.1) вийшла в січні 2012 року і з тих пір оновлення
+виходили так часто, що загальною порадою розробникам було не чекати якоїсь
+стабільної версії, а використовувати нічні збірки компілятора.
+
+15 травня 2015 року вийшла версія Rust 1.0. Для цієї версії була дана гарантія
+зворотної сумісності. Подальші нічні збірки покращили швидкість компіляції та
+деякі інші аспекти. На даний момент оновлення Rust виходять кожні 6 тижнів.
+Бета-версія Rust 1.1 вийшла одночасно з релізом Rust 1.0.
+
+Не зважаючи на те, що Rust є відносно низькорівневою мовою програмування, в
+ній є деякі концепти, притаманні високорівневим мовам. Це робить Rust не лише
+швидким, але й досить зручним та ефективним інструментом розробки.
+
+```rust
+// Це коментар. Він починається в цьому рядку...
+// і продовжується в цьому
+
+/// Цей коментар включає в себе документацію і підтримує markdown.
+/// # Приклади
+///
+/// ```
+/// let five = 5
+/// ```
+
+///////////////
+// 1. Основи //
+///////////////
+
+#[allow(dead_code)]
+// Функції
+// `i32` - це 32-бітний цілочислений знаковий тип даних
+fn add2(x: i32, y: i32) -> i32 {
+ // неявне повернення результату (в кінці рядку немає крапки з комою)
+ x + y
+}
+
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
+#[allow(dead_code)]
+// Головна функція
+fn main() {
+ // Числа //
+
+ // Незмінне число
+ let x: i32 = 1;
+
+ // суфікси для позначення цілого числа та числа з плаваючою змінною
+ let y: i32 = 13i32;
+ let f: f64 = 1.3f64;
+
+ // Вивід типів
+ // Як правило, Rust може самостійно визначити тип змінної, отож
+ // ви можете не прописувати його явно
+ // В даному документі типи явно прописані в багатьох місцях, це зроблено
+ // виключно в навчальних цілях. В реальному коді вивід типів спрацює
+ // в більшості випадків
+ let implicit_x = 1;
+ let implicit_f = 1.3;
+
+ // арифметика
+ let sum = x + y + 13;
+
+ // Змінні
+ let mut mutable = 1;
+ mutable = 4;
+ mutable += 2;
+
+ // Строки //
+
+ // Строкові літерали
+ let x: &str = "Привіт, світ!";
+
+ // Друк на екран
+ println!("{} {}", f, x); // 1.3 Привіт, світ!
+
+ // `String` – строка, що розміщується в "купі"
+ let s: String = "hello world".to_string();
+
+ // Строковий зріз - це незмінне відображення якоїсь строки (або її частини)
+ // Зріз можна розглядати як константну пару покажчиків (на початок та кінець
+ // якоїсь строки)
+ let s_slice: &str = &s;
+
+ println!("{} {}", s, s_slice); // Привіт, світ! Привіт, світ!
+
+ // Вектори/масиви //
+
+ // Масив фіксованого розміру
+ let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+ // Масив змінного розміру (вектор)
+ let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+ vector.push(5);
+
+ // Зріз - незмінне відображення масиву
+ // Це схоже на строковий зріз, але в даному випадку мова йде про вектори
+ let slice: &[i32] = &vector;
+
+ // Використовуйте `{:?}` щоб вивести щось в цілях відлагодження
+ println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+ // Кортеж //
+
+ // Кортеж - це набір фіксованого розміру, що включає значення кількох типів
+ let x: (i32, &str, f64) = (1, "привіт", 3.4);
+
+ // розбираємо кортеж "х" на окремі змінні "a", "b" та "с"
+ let (a, b, c) = x;
+ println!("{} {} {}", a, b, c); // 1 привіт 3.4
+
+ // доступ по індексу
+ println!("{}", x.1); // привіт
+
+ //////////////
+ // 2. Типи //
+ //////////////
+
+ // Структура
+ struct Point {
+ x: i32,
+ y: i32,
+ }
+
+ let origin: Point = Point { x: 0, y: 0 };
+
+ // Структура з безіменними полями, "кортежна структура"
+ struct Point2(i32, i32);
+
+ let origin2 = Point2(0, 0);
+
+ // перелічуваний тип даних
+ enum Direction {
+ Left,
+ Right,
+ Up,
+ Down,
+ }
+
+ let up = Direction::Up;
+
+ // перелічуваний тип даних з полями
+ enum OptionalI32 {
+ AnI32(i32),
+ Nothing,
+ }
+
+ let two: OptionalI32 = OptionalI32::AnI32(2);
+ let nothing = OptionalI32::Nothing;
+
+ // Узагальнене програмування //
+
+ struct Foo<T> { bar: T }
+
+ // Ось так стандартна бібліотека Rust оголошує `Option`
+ enum Optional<T> {
+ SomeVal(T),
+ NoVal,
+ }
+
+ // Методи //
+
+ impl<T> Foo<T> {
+ // Методи приймають неявний параметр `self`
+ fn get_bar(self) -> T {
+ self.bar
+ }
+ }
+
+ let a_foo = Foo { bar: 1 };
+ println!("{}", a_foo.get_bar()); // 1
+
+ // Типажі (в інших мовах програмування схожою сутністю є інтерфейси) //
+
+ trait Frobnicate<T> {
+ fn frobnicate(self) -> Option<T>;
+ }
+
+ impl<T> Frobnicate<T> for Foo<T> {
+ fn frobnicate(self) -> Option<T> {
+ Some(self.bar)
+ }
+ }
+
+ let another_foo = Foo { bar: 1 };
+ println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+ /////////////////////////
+ // 3. Відповідність шаблону //
+ /////////////////////////
+
+ let foo = OptionalI32::AnI32(1);
+ match foo {
+ OptionalI32::AnI32(n) => println!("Це тип i32: {}", n),
+ OptionalI32::Nothing => println!("Це ніщо!"),
+ }
+
+ // Складніший приклад
+ struct FooBar { x: i32, y: OptionalI32 }
+ let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+ match bar {
+ FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+ println!("Числа рівні нулю!"),
+ FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+ println!("Числа однакові"),
+ FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+ println!("Числа різні: {} {}", n, m),
+ FooBar { x: _, y: OptionalI32::Nothing } =>
+ println!("Друге число - ніщо!"),
+ }
+
+ /////////////////////
+ // 4. Потік керування //
+ /////////////////////
+
+ // Цикл `for`
+ let array = [1, 2, 3];
+ for i in array.iter() {
+ println!("{}", i);
+ }
+
+ // Діапазони
+ for i in 0u32..10 {
+ print!("{} ", i);
+ }
+ println!("");
+ // друкує `0 1 2 3 4 5 6 7 8 9 `
+
+ // `if`
+ if 1 == 1 {
+ println!("Математика працює!");
+ } else {
+ println!("Ой, лишенько...");
+ }
+
+ // `if` як вираз
+ let value = if true {
+ "добре"
+ } else {
+ "погано"
+ };
+
+ // Цикл `while`
+ while 1 == 1 {
+ println!("Всесвіт функціонує стабільно.");
+ // Вираз break перериває цикл
+ break
+ }
+
+ // Нескінченний цикл
+ loop {
+ println!("Привіт!");
+ // Вираз break перериває цикл
+ break
+ }
+
+ /////////////////////////////////
+ // 5. Вказівники і безпека пам'яті //
+ /////////////////////////////////
+
+ // Володіючий вказівник - тільки хтось один може "володіти" вказівником в
+ // будь-який момент. Це означає, що коли "Box" вийде за межі області
+ // видимості - його можна безпечно звільнити
+ let mut mine: Box<i32> = Box::new(3);
+ *mine = 5; // розіменування `mine` з присвоєнням йому нового значення
+ // `now_its_mine` перебирає на себе володіння над `mine`. Іншими словами,
+ // `mine` переміщується.
+ let mut now_its_mine = mine;
+ *now_its_mine += 2;
+
+ println!("{}", now_its_mine); // 7
+ // println!("{}", mine); // цей код не скомпілюється, оскільки тепер
+ // покажчиком на дані володіє `now_its_mine`
+
+ // Посилання – незмінний вказівник на дані
+ // При створенні посилання на якесь значення, ми говоримо, що значення
+ // було "запозичене". Поки значення є запозиченим - воно не може бути
+ // змінене або переміщене. Запозичення пропадає, як тільки стається вихід з
+ // області видимості, де було створене посилання
+ let mut var = 4;
+ var = 3;
+ let ref_var: &i32 = &var;
+
+ println!("{}", var); // На відміну від `mine`, `var` можна використати
+ println!("{}", *ref_var);
+ // var = 5; // цей код не скомпілюється, оскільки `var` зараз є запозиченим
+ // *ref_var = 6; // цей код також не зкомпілюється, оскільки `ref_var`
+ // є незмінним посиланням
+
+ // Змінне посилання
+ // Значення можна запозичити з можливістю зміни. У цьому випадку доступ до
+ // оригінального значення втрачається.
+ let mut var2 = 4;
+ let ref_var2: &mut i32 = &mut var2;
+ *ref_var2 += 2; // '*' використовується для доступу до змінного посилання
+
+ println!("{}", *ref_var2); // 6 , // при заміні на var2 код не зкомпілюється
+ // ref_var2 має тип &mut i32, отож зберігає посилання на i32, а не значення
+ // var2 = 2; // цей рядок не зкомпілюється, оскільки `var2` є запозиченим.
+}
+```
+
+## Матеріали для самовдосконалення
+
+В даному матеріалі ми оглянули лише основи Rust. Більше матеріалу ви можете
+знайти на сайті
+[The Rust Programming Language](http://doc.rust-lang.org/book/index.html)
+Також існує Reddit-розділ [/r/rust](http://reddit.com/r/rust). Люди на каналі
+irc.mozilla.org також завжди раді допомогти новачкам.
+
+Ви можете спробувати можливості Rust за допомогою онлайн-компілятора на сторінці
+[Rust playpen](http://play.rust-lang.org) або
+[Rust website](http://rust-lang.org).
diff --git a/uk-ua/wasm-ua.html.markdown b/uk-ua/wasm-ua.html.markdown
new file mode 100644
index 00000000..34f8cef8
--- /dev/null
+++ b/uk-ua/wasm-ua.html.markdown
@@ -0,0 +1,226 @@
+---
+language: WebAssembly
+lang: uk-ua
+filename: learnwasm-ua.wast
+contributors:
+ - ["Dean Shaff", "http://dean-shaff.github.io"]
+translators:
+ - ["Oleh Hromiak", "https://github.com/ogroleg"]
+---
+
+```
+;; learnwasm-ua.wast
+
+(module
+ ;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
+ ;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
+ ;; втім, він не сумісний з проміжним бінарним представленням коду.
+
+ ;; Формат бінарного проміжного представлення майже повністю сумісний
+ ;; з текстовим форматом WebAssembly.
+ ;; Деякі відмінності:
+ ;; local_set -> local.set
+ ;; local_get -> local.get
+
+ ;; Код розміщується у функціях
+
+ ;; Типи даних
+ (func $data_types
+ ;; WebAssembly має чотири типи даних:
+ ;; i32 - ціле число, 32 біти
+ ;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
+ ;; f32 - число з плаваючою комою, 32 біти
+ ;; f64 - число з плаваючою комою, 64 біти
+
+ ;; Створити локальну змінну можна за допомогою ключового слова "local".
+ ;; Змінні потрібно оголошувати на початку функції.
+
+ (local $int_32 i32)
+ (local $int_64 i64)
+ (local $float_32 f32)
+ (local $float_64 f64)
+
+ ;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
+ ;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
+
+ (local.set $int_32 (i32.const 16))
+ (local.set $int_32 (i64.const 128))
+ (local.set $float_32 (f32.const 3.14))
+ (local.set $float_64 (f64.const 1.28))
+ )
+
+ ;; Базові операції
+ (func $basic_operations
+
+ ;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
+ ;; з математичними виразами або зчитуванням значень змінних
+
+ (local $add_result i32)
+ (local $mult_result f64)
+
+ (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
+ ;; тепер add_result дорівнює 6!
+
+ ;; Для кожної операції потрібно використовувати правильний тип:
+ ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
+ (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
+
+ ;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
+ ;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
+ ;; Тож нам потрібно:
+ ;; - написати їх самостійно (не найкраща ідея)
+ ;; - звідкись їх імпортувати (як саме - побачимо згодом)
+ )
+
+ ;; Функції
+ ;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
+ ;; Поточне значення стеку і є значенням функції, що повертається
+
+ ;; Ми можемо викликати інші функції за допомогою `call`
+
+ (func $get_16 (result i32)
+ (i32.const 16)
+ )
+
+ (func $add (param $param0 i32) (param $param1 i32) (result i32)
+ (i32.add
+ (local.get $param0)
+ (local.get $param1)
+ )
+ )
+
+ (func $double_16 (result i32)
+ (i32.mul
+ (i32.const 2)
+ (call $get_16))
+ )
+
+ ;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
+ ;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
+ ;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
+ ;; Виклик цих функцій у WebAssembly залежить від того,
+ ;; де ми знаходимось - чи це Node.js, чи середовище браузера.
+
+ ;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
+ ;; текстове представлення WASM у справжній код webassembly.
+ ;; Наприклад, ось так (Binaryen):
+
+ ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
+
+ ;; Давай також застосуємо оптимізації:
+
+ ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
+
+ ;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
+ ;; const fs = require('fs')
+ ;; const instantiate = async function (inFilePath, _importObject) {
+ ;; var importObject = {
+ ;; console: {
+ ;; log: (x) => console.log(x),
+ ;; },
+ ;; math: {
+ ;; cos: (x) => Math.cos(x),
+ ;; }
+ ;; }
+ ;; importObject = Object.assign(importObject, _importObject)
+ ;;
+ ;; var buffer = fs.readFileSync(inFilePath)
+ ;; var module = await WebAssembly.compile(buffer)
+ ;; var instance = await WebAssembly.instantiate(module, importObject)
+ ;; return instance.exports
+ ;; }
+ ;;
+ ;; const main = function () {
+ ;; var wasmExports = await instantiate('learn-wasm.wasm')
+ ;; wasmExports.print_args(1, 0)
+ ;; }
+
+ ;; Цей код зчитує функції з importObject
+ ;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
+ ;; "print_args", яку ми викликаємо у Node.js
+
+ (import "console" "log" (func $print_i32 (param i32)))
+ (import "math" "cos" (func $cos (param f64) (result f64)))
+
+ (func $print_args (param $arg0 i32) (param $arg1 i32)
+ (call $print_i32 (local.get $arg0))
+ (call $print_i32 (local.get $arg1))
+ )
+ (export "print_args" (func $print_args))
+
+ ;; Завантаження даних з пам'яті WebAssembly.
+ ;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
+ ;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
+ ;; У прикладі нижче ми змінимо існуючий масив.
+ ;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
+ ;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
+ ;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
+
+ ;; У JavaScript ми викличемо `apply_cos64` таким чином
+ ;; (використаємо функцію instantiate з попереднього прикладу):
+ ;;
+ ;; const main = function () {
+ ;; var wasm = await instantiate('learn-wasm.wasm')
+ ;; var n = 100
+ ;; const memory = new Float64Array(wasm.memory.buffer, 0, n)
+ ;; for (var i=0; i<n; i++) {
+ ;; memory[i] = i;
+ ;; }
+ ;; wasm.apply_cos64(n)
+ ;; }
+ ;;
+ ;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
+
+ (memory (export "memory") 100)
+
+ (func $apply_cos64 (param $array_length i32)
+ ;; визначаємо змінну циклу або лічильник
+ (local $idx i32)
+ ;; визначаємо змінну для доступу до пам'яті
+ (local $idx_bytes i32)
+ ;; константа - кількість байтів у числі типу f64.
+ (local $bytes_per_double i32)
+
+ ;; визначаємо змінну, яка зберігатиме значення з пам'яті
+ (local $temp_f64 f64)
+
+ (local.set $idx (i32.const 0))
+ (local.set $idx_bytes (i32.const 0)) ;; не обов'язково
+ (local.set $bytes_per_double (i32.const 8))
+
+ (block
+ (loop
+ ;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
+ (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
+
+ ;; отримуємо число з пам'яті (за зміщенням):
+ (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
+
+ ;; рахуємо cos:
+ (local.set $temp_64 (call $cos (local.get $temp_64)))
+
+ ;; тепер зберігаємо результат обчислень у пам'ять:
+ (f64.store
+ (local.get $idx_bytes)
+ (local.get $temp_64))
+
+ ;; або робимо все за один крок (альтернативний код)
+ (f64.store
+ (local.get $idx_bytes)
+ (call $cos
+ (f64.load
+ (local.get $idx_bytes))))
+
+ ;; збільшуємо лічильник на одиницю (інкремент)
+ (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+
+ ;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
+ (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
+ (br 0)
+ )
+ )
+ )
+ (export "apply_cos64" (func $apply_cos64))
+)
+
+```