summaryrefslogtreecommitdiffhomepage
path: root/pl-pl
diff options
context:
space:
mode:
Diffstat (limited to 'pl-pl')
-rw-r--r--pl-pl/bf-pl.html.markdown96
-rw-r--r--pl-pl/haskell-pl.html.markdown449
-rw-r--r--pl-pl/json-pl.html.markdown86
-rw-r--r--pl-pl/perl-pl.html.markdown13
-rw-r--r--pl-pl/python-pl.html.markdown640
-rw-r--r--pl-pl/ruby-pl.html.markdown593
-rw-r--r--pl-pl/vim-pl.html.markdown236
-rw-r--r--pl-pl/xml-pl.html.markdown137
8 files changed, 2245 insertions, 5 deletions
diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
new file mode 100644
index 00000000..88f928cf
--- /dev/null
+++ b/pl-pl/bf-pl.html.markdown
@@ -0,0 +1,96 @@
+---
+category: language
+language: bf
+filename: learnbf-pl.bf
+contributors:
+ - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+ - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+ - ["Jakub Młokosiewicz", "https://github.com/hckr"]
+lang: pl-pl
+
+---
+
+Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo
+minimalistycznym, kompletnym w sensie Turinga, językiem programowania.
+Zawiera zaledwie 8 poleceń.
+
+Możesz przetesotwać brainfucka w swojej przeglądarce, korzystając z narzędzia
+[brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Wszystkie znaki oprócz "><+-.,[]" (wyłączając znaki zapytania) są ignorowane.
+
+Pamięć w brainfucku jest reprezentowana przez tablicę 30.000 komórek
+zainicjalizowanych zerami, ze wskaźnikiem pokazującym na aktualną komórkę.
+
+Oto osiem poleceń brainfucka:
++ : inkrementuje (zwiększa o jeden) wartość aktualnie wskazywanej komórki
+- : dekrementuje (zmniejsza o jeden) wartość aktualnie wskazywanej komórki
+> : przesuwa wskaźnik na następną komórkę (w prawo)
+< : przesuwa wskaźnik na poprzednią komórkę (w lewo)
+. : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
+, : wczytuje (jeden) znak z wejścia do bieżącej komórki
+ (konkretnie jego numer z tabeli ASCII)
+[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
+ odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
+] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
+ następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
+
+[ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
+musi być zakończona ].
+
+Zobaczmy kilka prostych programów w brainfucku.
+
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Ten program wypisuje literę 'A'. Najpierw zwiększa wartość komórki #1 do 6.
+Komórka #1 będzie wykorzystana w pętli. Następnie program wchodzi w pętlę ([)
+i przechodzi do komórki #2. Pętla wykonuje się sześć razy (komórka #1 jest
+dekrementowana sześć razy, nim osiągnie wartość zero, kiedy to program
+przechodzi do odpowiadającego ] i wykonuje kolejne instrukcje).
+
+W tym momencie wskaźnik pokazuje na komórkę #1, mającą wartość 0, podczas gdy
+komórka #2 ma wartość 60. Przesuwamy wskaźnik na komórkę #2, inkrementujemy ją
+pięć razy, uzyskując wartość 65. Następnie wyświetlamy wartość komórki #2.
+65 to 'A' w tabeli ASCII, więc właśnie ten znak jest wypisany na konsolę.
+
+
+, [ > + < - ] > .
+
+Ten program wczytuje znak z wejścia i umieszcza jego kod ASCII w komórce #1.
+Następnie zaczyna się pętla, w której znajdują się następujące instrukcje:
+przesunięcie wskaźnika na komórkę #2, inkrementacja wartości komóri #2,
+powrót do komórki #1 i dekrementacja wartości komórki #1. Instrukcje pętli
+wykonują się aż wartość komórki #1 osiągnie zero, a komórka #2 osiągnie
+poprednią wartość komórki #1. Ponieważ na końcu pętli wskaźnik pokazuje na
+komórkę #1, po pętli następuje instrukcja przejścia do komórki #2 i wysłanie
+jej wartości (w formie znaku ASCII) na wyjście.
+
+Zauważ, że odstępy służą wyłącznie poprawie czytelności.
+Równie dobrze można powyższy program zapisać tak:
+
+,[>+<-]>.
+
+
+Spróbuj odgadnąć, co robi poniższy program:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Ten program pobiera z wejścia dwie liczby i je mnoży.
+
+Po wczytaniu dwóch wejść (do komórek #1 i #2) następuje pętla zewnętrzna,
+warunkowana wartością komórki #1. Następnie program przechodzi do komórki #2
+i rozpoczyna pętlę wewnętrzną z warunkiem zakończenia w komórce #2,
+inkrementującą komórkę #3. Tu jednak pojawia się problem: w chwili zakończenia
+wewnętrznej pętli komórka #2 ma wartość zero. W takim razie wewętrzna pętla
+nie wywoła się następny raz. Aby rozwiązać ten problem, inkrementujemy także
+wartość komórki #4, a następnie kopiujemy jej wartość do komórki #2.
+Ostatecznie wynik działania znajduje się w komórce #3.
+```
+
+I to właśnie jest brainfuck. Nie taki trudny, co? W ramach rozrywki możesz
+napisać własne programy w brainfucku. Możesz też napisać interpreter brainfucka
+w innym języku. Implementacja interpretera to dość proste zadanie. Jeśli
+jesteś masochistą, spróbuj napisać interpreter brainfucka w... brainfucku.
diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
new file mode 100644
index 00000000..236b8958
--- /dev/null
+++ b/pl-pl/haskell-pl.html.markdown
@@ -0,0 +1,449 @@
+---
+category: language
+filename: haskell-pl.hs
+language: Haskell
+contributors:
+ - ["Adit Bhargava", "http://adit.io"]
+translators:
+ - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+lang: pl-pl
+
+---
+
+Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język
+programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
+typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że
+programowanie jest prawdziwą przyjemnością.
+
+```haskell
+-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
+{- Komentarze wielolinijkowe należy
+zamykać w bloki klamrami.
+-}
+
+----------------------------------------------------
+-- 1. Podstawowe typy danych oraz operatory
+----------------------------------------------------
+
+-- Mamy liczby
+3 -- 3
+
+-- Podstawowe działania działają tak, jak powinny
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- dzielenie domyślnie zwraca ,,dokładny'' wynik
+35 / 4 -- 8.75
+
+-- dzielenie całkowitoliczbowe
+35 `div` 4 -- 8
+
+-- wartości logiczne także są podstawowym typem danych:
+True
+False
+
+-- operacje logiczne: negacja oraz porównania
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
+-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
+-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
+-- funkcja arg1 arg2 arg3...
+-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
+
+-- Łańcuchy znaków (stringi) i pojedyncze znaki:
+"To jest lancuch."
+'a' -- znak
+'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
+
+-- Łańcuchy można sklejać
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Łańcuch jest listą własnych znaków
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"To jest lancuch" !! 0 -- 'T'
+
+----------------------------------------------------
+-- 2. Listy oraz krotki
+----------------------------------------------------
+
+-- Wszystkie elementy listy muszą być tego samego typu.
+-- Poniższe dwie listy są identyczne:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Zakresy są uniwersalne.
+['A'..'F'] -- "ABCDEF"
+
+-- Przy tworzeniu zakresów można określić krok.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indeksowanie listy od zera
+[1..10] !! 3 -- 4
+
+-- Można nawet tworzyć listy nieskończone!
+[1..] -- lista wszystkich liczb naturalnych
+
+-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym
+-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy,
+-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i
+-- dostaniemy go:
+
+[1..] !! 999 -- 1000
+
+-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta
+-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
+-- taka potrzeba.
+
+-- łączenie dwóch list
+[1..5] ++ [6..10]
+
+-- dodawanie pojedynczego elementu na początek listy
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- więcej operacji na listach
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- z dodatkowym warunkiem
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej
+-- długości. Przykładowo:
+("haskell", 1)
+
+-- dostęp do elementów pary (krotki długości 2):
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Funkcje
+----------------------------------------------------
+-- Prosta funkcja przyjmująca dwa argumenty
+add a b = a + b
+
+-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie
+-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
+-- let add a b = a + b
+
+-- Używanie funkcji:
+add 1 2 -- 3
+
+-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
+-- otoczona grawisami:
+1 `add` 2 -- 3
+
+-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest
+-- operator dzielenia:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
+fib x
+ | x < 2 = 1
+ | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
+-- z poniższych definicji fib powinna zostać użyta:
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie z krotkami:
+foo (x, y) = (x + 1, y + 2)
+
+-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy,
+-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
+-- na każdy z elementów listy:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
+-- wszystkie argumenty:
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
+-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Więcej funkcji
+----------------------------------------------------
+
+-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów,
+-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
+-- brakujące argumenty.
+
+add a b = a + b
+foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
+foo 5 -- 15
+
+-- Inny sposób na zapisanie tego samego:
+foo = (10+)
+foo 5 -- 15
+
+-- składanie funkcji:
+-- operator `.` składa wiele funkcji w jedną.
+-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży
+-- tak uzyskaną liczbę przez 4 i zwraca wynik:
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- ustalanie kolejności
+-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
+-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania
+-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
+-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
+-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
+
+-- wcześniej
+even (fib 7) -- fałsz
+
+-- równoważnie
+even $ fib 7 -- fałsz
+
+-- składanie funkcji
+even . fib $ 7 -- fałsz
+
+
+----------------------------------------------------
+-- 5. Sygnatury typów
+----------------------------------------------------
+
+-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne
+-- wyrażenie ma swój typ.
+
+-- Kilka podstawowych typów:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Funkcje też są określonego typu.
+-- `not` przyjmuje wartość logiczną i taką też zwraca:
+-- not :: Bool -> Bool
+
+-- Przykład funkcji przyjmującej dwa argumenty
+-- add :: Integer -> Integer -> Integer
+
+-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
+-- także jej typu:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Wyrażenia warunkowe
+----------------------------------------------------
+
+-- wyrażenie warunkowe
+haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
+
+-- wyrażenie warunkowe można rozbić na wiele linii,
+-- ale trzeba uważać na wcięcia w kodzie
+haskell = if 1 == 1
+ then "wspaniale"
+ else "paskudnie"
+
+-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
+case args of
+ "help" -> printHelp
+ "start" -> startProgram
+ _ -> putStrLn "bad args"
+
+-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
+-- map aplikuje funkcję do każdego elementu listy:
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- możesz zdefiniować funkcję for przy użyciu map:
+for array func = map func array
+
+-- a następnie użyć jej:
+for [0..5] $ \i -> show i
+
+-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
+for [0..5] show
+
+-- Do redukcji listy służy polecenie foldl (foldr):
+-- foldl <fn> <initial value> <list>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Jest to równoważne z:
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl składa od od lewej strony, foldr od prawej
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- To zaś równoważne jest:
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Typy danych
+----------------------------------------------------
+
+-- Oto jak tworzy się nowe typy danych w Haskellu:
+
+data Color = Red | Blue | Green
+
+-- Teraz można używać ich we własnych funkcjach:
+
+say :: Color -> String
+say Red = "You are Red!"
+say Blue = "You are Blue!"
+say Green = "You are Green!"
+
+-- Twoje typy danych mogą posiadać nawet parametry:
+
+data Maybe a = Nothing | Just a
+
+-- Wszystkie poniższe są typu Maybe
+Just "hello" -- typu `Maybe String`
+Just 1 -- typu `Maybe Int`
+Nothing -- typu `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
+-- monad, spróbujemy zrobić to częściowo
+
+-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main`
+-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn has type String -> IO ()
+
+-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie
+-- zaimplementowany jako funkcja String -> String. Funkcja
+-- interact :: (String -> String) -> IO ()
+-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
+-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
+-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
+
+sayHello :: IO ()
+sayHello = do
+ putStrLn "What is your name?"
+ name <- getLine -- this gets a line and gives it the name "name"
+ putStrLn $ "Hello, " ++ name
+
+-- Ćwiczenie: napisz własną wersję `interact`,
+-- która czyta tylko jedną linię wejścia.
+
+-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie
+-- uruchomiona, jest wartość `main`.
+-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
+-- main = sayHello
+
+-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
+-- użyliśmy. Jej typem jest
+-- getLine :: IO String
+-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
+-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
+-- Możemy także tworzyć własne akcje typu `IO String`:
+
+action :: IO String
+action = do
+ putStrLn "This is a line. Duh"
+ input1 <- getLine
+ input2 <- getLine
+ -- The type of the `do` statement is that of its last line.
+ -- `return` is not a keyword, but merely a function
+ return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Możemy użyć tego tak jak używaliśmy `getLine`:
+
+main'' = do
+ putStrLn "I will echo two lines!"
+ result <- action
+ putStrLn result
+ putStrLn "This was all, folks!"
+
+-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do
+-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
+-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
+-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
+-- czystych od zależnych od świata lub modyfikujących stan.
+
+-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
+-- czyste funkcje jednocześnie.
+
+----------------------------------------------------
+-- 9. Interaktywne środowisko programowania
+----------------------------------------------------
+
+-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
+-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
+-- słowo kluczowe `let`:
+
+let foo = 5
+
+-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
+
+> :t foo
+foo :: Integer
+
+-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
+-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- Dodatkowych informacji dostarcza `:i`:
+
+> :i (+)
+class Num a where
+ (+) :: a -> a -> a
+ ...
+ -- Defined in ‘GHC.Num’
+infixl 6 +
+
+-- Można nawet wykonywać akcje typu `IO ()`!
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one
+sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
+pokażę Tobie implementację algorytmu quicksort w Haskellu:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+ where lesser = filter (< p) xs
+ greater = filter (>= p) xs
+```
+
+Haskell może zostać zainstalowany na co najmniej dwa sposoby:
+ - tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
+ - nowocześnie [z pomocą Stack](https://www.stackage.org/install).
+
+Godnymi poleceniami wprowadzeniami są wspaniałe
+[Learn you a Haskell](http://learnyouahaskell.com/) albo
+[Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown
new file mode 100644
index 00000000..edd059bf
--- /dev/null
+++ b/pl-pl/json-pl.html.markdown
@@ -0,0 +1,86 @@
+---
+category: language
+language: json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+ - ["himanshu", "https://github.com/himanshu81494"]
+ - ["Michael Neth", "https://github.com/infernocloud"]
+translators:
+ - ["Michał Mitrosz", "https://github.com/Voltinus"]
+lang: pl-pl
+filename: learnjson-pl.json
+---
+
+JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
+
+Kod JSON musi zawierać któreś z poniższych:
+* Zbiór par nazwa/wartość (`{ }`). W różnych językach jest to obiekt, rekord, struktura, słownik, tablica mieszająca, lista z kluczami, lub tablica asocjacyjna.
+* Uporządkowana lista wartości (`[ ]`). W różnych językach jest to tablica, wektor, lista, lub sekwencja.
+ tablica/lista/sekwencja (`[ ]`) lub słownik/obiekt/tablica asocjacyjna (`{ }`).
+
+JSON w swojej czystej postaci nie ma komentarzy, ale większość parserów akceptuje komentarze w stylu C (`//`, `/* */`). Niektóre parsery pozwalają także na końcowy przecinek (np. przecinek po ostatnim elemencie w tablicy lub po ostatiej własności obiektu), ale powinien on być omijany dla lepszej kompatybilności.
+
+Dla celów tego poradnika wszystko będzie 100% kodem JSON. Na szczęście, to samo mówi za siebie.
+
+Wspierane typy danych:
+
+* Łańcuchy znaków: `"witaj"`, `"\"Cytat.\""`, `"\u0abe"`, `"Nowa linia.\n"`
+* Liczby: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Obiekty: `{ "klucz": "wartość" }`
+* Tablice: `["Wartości"]`
+* Inne: `true`, `false`, `null`
+
+```json
+{
+ "klucz": "wartość",
+
+ "klucze": "muszą być zawsze zamknięte w podwójnych cudzysłowach",
+ "liczby": 0,
+ "łańcuchy": "Hellø, wørld. Wszystkie znaki unicode są dozwolone, razem z \"sekwencjami escape\".",
+ "wartości logiczne?": true,
+ "nic": null,
+
+ "duża liczba": 1.2e+100,
+
+ "obiekty": {
+ "komentarz": "Większość twojej struktury będzie zbudowana z obiektów.",
+
+ "tablica": [0, 1, 2, 3, "Tablice mogą mieć wewnątrz cokolwiek", 5],
+
+ "inny obiekt": {
+ "komentarz": "Elementy mogą się w sobie zawierać, bardzo użyteczne"
+ }
+ },
+
+ "głupota": [
+ {
+ "źródła potasu": ["banany"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "styl alternatywny": {
+ "komentarz": "sprawdź to!"
+ , "pozycja przecinka": "nie ma znaczenia, o ile jest przed następnym kluczem, jest poprawnie"
+ , "następny komentarz": "jak ładnie"
+ },
+
+
+
+ "znaki białe": "nie mają znaczenia",
+
+
+
+ "to było krótkie": "I gotowe. Wiesz już wszystko o formacie JSON."
+}
+```
+
+## Dalsza lektura
+
+* [JSON.org](http://json.org) Cały JSON pięknie wytłumaczony na podstawie grafik przypominających schematy blokowe.
diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown
index 9e8ade5b..3e27cc4f 100644
--- a/pl-pl/perl-pl.html.markdown
+++ b/pl-pl/perl-pl.html.markdown
@@ -2,11 +2,14 @@
name: perl
category: language
language: perl
-filename: learnperl.pl
+filename: learnperl-pl.pm
contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"]
+ - ["Dan Book", "http://github.com/Grinnz"]
+translators:
- ["Michał Kupczyński", "http://github.com/ukoms"]
lang: pl-pl
+
---
Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
@@ -163,7 +166,7 @@ z repozytorium CPAN do zrealizowania konkretnego zadania.
#### Do doczytania
- - [perl-tutorial](http://perl-tutorial.org/)
- - [Naucz się Perla na www.perl.com](http://www.perl.org/learn.html)
- - [perldoc](http://perldoc.perl.org/)
- - wbudowane w Perla: `perldoc perlintro` \ No newline at end of file
+ - [perl-tutorial](http://perl-tutorial.org/)
+ - [Naucz się Perla na www.perl.com](http://www.perl.org/learn.html)
+ - [perldoc](http://perldoc.perl.org/)
+ - wbudowane w Perla: `perldoc perlintro`
diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
new file mode 100644
index 00000000..023c3e6b
--- /dev/null
+++ b/pl-pl/python-pl.html.markdown
@@ -0,0 +1,640 @@
+---
+name: python
+category: language
+language: python
+filename: learnpython-pl.py
+contributors:
+ - ["Louie Dinh", "http://ldinh.ca"]
+ - ["Amin Bandali", "http://aminbandali.com"]
+ - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+ - ["Dominik Krzemiński", "https://github.com/dokato"]
+lang: pl-pl
+---
+
+Python został opracowany przez Guido Van Rossuma na początku lat 90-tych.
+Obecnie jest jednym z najbardziej popularnych języków programowania.
+Zakochałem się w Pythonie dzięki porządkowi, jaki utrzymywany jest w kodzie.
+To po prostu wykonywalny pseudokod.
+
+Zapraszam do kontaktu. Złapiecie nas na:
+- kontakt polski: raymon92 [at] [google's email service]
+- kontakt angielski: [@louiedinh](http://twitter.com/louiedinh) lub louiedinh [at] [google's email service]
+
+Uwaga: Ten artykuł odnosi się do wersji Pythona 2.7, ale powinien
+działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stronie głównej.
+
+```python
+# -*- coding: utf-8 -*-
+
+# Pojedyncze komentarze oznaczamy takim symbolem.
+
+""" Wielolinijkowe napisy zapisywane są przy użyciu
+ potrójnych cudzysłowów i często
+ wykorzystywane są jako komentarze.
+"""
+
+####################################################
+## 1. Podstawowe typy danych i operatory
+####################################################
+
+# Liczby to liczby
+3 # => 3
+
+# Matematyka jest intuicyjna
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7
+
+# Dzielenie może być kłopotliwe. Poniższe działanie to dzielenie
+# całkowitoliczbowe(int) i wynik jest automatycznie zaokrąglany.
+5 / 2 # => 2
+
+# Aby to naprawić, musimy powiedzieć nieco o liczbach zmiennoprzecinkowych.
+2.0 # To liczba zmiennoprzecinkowa, tzw. float
+11.0 / 4.0 # => 2.75 ahhh...znacznie lepiej
+
+# Wynik dzielenia całkowitoliczbowego jest obcinany dla liczb
+# dodatnich i ujemnych.
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # działa też na floatach
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Operator modulo - wyznaczanie reszty z dzielenia
+7 % 3 # => 1
+
+# Potęgowanie (x do potęgi y-tej)
+2**4 # => 16
+
+# Wymuszanie pierwszeństwa w nawiasach
+(1 + 3) * 2 # => 8
+
+# Operacje logiczne
+# Zauważ, że przy "and" i "or" trzeba zwracać uwagę na rozmiar liter
+True and False #=> False # Fałsz
+False or True #=> True # Prawda
+
+# Zauważ, że operatorów logicznych można używać z intami
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+k1 == True #=> True
+
+# aby zanegować, użyj "not"
+not True # => False
+not False # => True
+
+# Równość ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Nierówność !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Więcej porównań
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Porównania można układać w łańcuch!
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# Napisy (typ string) tworzone są przy użyciu cudzysłowów " lub '
+"Jestem napisem."
+'Ja też jestem napisem.'
+
+# Napisy można dodawać!
+"Witaj " + "świecie!" # => "Witaj świecie!"
+
+# ... a nawet mnożyć
+"Hej" * 3 # => "HejHejHej"
+
+# Napis może być traktowany jako lista znaków
+"To napis"[0] # => 'T'
+
+# % może być używane do formatowania napisów:
+"%s są %s" % ("napisy", "fajne")
+
+# Jednak nowszym sposobem formatowania jest metoda "format".
+# Ta metoda jest obecnie polecana:
+"{0} są {1}".format("napisy", "fajne")
+# Jeśli nie chce ci się liczyć, użyj słów kluczowych.
+"{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
+
+# None jest obiektem
+None # => None
+
+# Nie używaj "==" w celu porównania obiektów z None
+# Zamiast tego użyj "is"
+"etc" is None # => False
+None is None # => True
+
+# Operator 'is' testuje identyczność obiektów. Nie jest to zbyt
+# pożyteczne, gdy działamy tylko na prostych wartościach,
+# ale przydaje się, gdy mamy do czynienia z obiektami.
+
+# None, 0 i pusty napis "" są odpowiednikami logicznego False.
+# Wszystkie inne wartości są uznawane za prawdę (True)
+bool(0) # => False
+bool("") # => False
+
+
+####################################################
+## 2. Zmienne i zbiory danych
+####################################################
+
+# Python ma instrukcję wypisującą "print" we wszystkich wersjach 2.x, ale
+# została ona usunięta z wersji 3.
+print "Jestem Python. Miło Cię poznać!"
+# Python ma też funkcję "print" dostępną w wersjach 2.7 i 3...
+# ale w 2.7 musisz dodać import (odkomentuj):
+# from __future__ import print_function
+print("Ja też jestem Python! ")
+
+# Nie trzeba deklarować zmiennych przed przypisaniem.
+jakas_zmienna = 5 # Konwencja mówi: używaj małych liter i znaków podkreślenia _
+jakas_zmienna # => 5
+
+# Próba dostępu do niezadeklarowanej zmiennej da błąd.
+# Przejdź do sekcji Obsługa wyjątków, aby dowiedzieć się więcej...
+inna_zmienna # Wyrzuca nazwę błędu
+
+# "if" może być użyte jako wyrażenie
+"huraaa!" if 3 > 2 else 2 # => "huraaa!"
+
+# Listy:
+li = []
+# Możesz zacząć od wypełnionej listy
+inna_li = [4, 5, 6]
+
+# Dodaj na koniec, używając "append"
+li.append(1) # li to teraz [1]
+li.append(2) # li to teraz [1, 2]
+li.append(4) # li to teraz [1, 2, 4]
+li.append(3) # li to teraz [1, 2, 4, 3]
+# Usuwanie z konca da "pop"
+li.pop() # => 3 a li stanie się [1, 2, 4]
+# Dodajmy ponownie
+li.append(3) # li to znowu [1, 2, 4, 3].
+
+# Dostęp do list jak do każdej tablicy
+li[0] # => 1
+# Aby nadpisać wcześniej wypełnione miejsca w liście, użyj znaku =
+li[0] = 42
+li[0] # => 42
+li[0] = 1 # Uwaga: ustawiamy starą wartość
+# Tak podglądamy ostatni element
+li[-1] # => 3
+
+# Jeżeli wyjdziesz poza zakres...
+li[4] # ... zobaczysz IndexError
+
+# Możesz też tworzyć wycinki.
+li[1:3] # => [2, 4]
+# Bez początku
+li[2:] # => [4, 3]
+# Omijamy koniec
+li[:3] # => [1, 2, 4]
+# Wybierz co drugi
+li[::2] # =>[1, 4]
+# Odwróć listę
+li[::-1] # => [3, 4, 2, 1]
+# Użyj kombinacji powyższych aby tworzyć bardziej skomplikowane wycinki
+# li[poczatek:koniec:krok]
+
+# Usuń element używając "del"
+del li[2] # li to teraz [1, 2, 3]
+
+# Listy można dodawać
+li + inna_li # => [1, 2, 3, 4, 5, 6]
+# Uwaga: wartości oryginalnych list li i inna_li się nie zmieniają.
+
+# Do łączenia list użyj "extend()"
+li.extend(other_li) # li to teraz [1, 2, 3, 4, 5, 6]
+
+# Sprawdź, czy element jest w liście używając "in"
+1 in li # => True
+
+# "len()" pokazuje długość listy
+len(li) # => 6
+
+
+# Krotki (tuple) są jak listy, ale nie można ich modyfikować.
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # wyrzuci TypeError
+
+# Ale wielu akcji dla list możesz używać przy krotkach
+len(tup) # => 3
+tup + (4, 5, 6) # => (1, 2, 3, 4, 5, 6)
+tup[:2] # => (1, 2)
+2 in tup # => True
+
+# Można rozpakować krotki i listy do poszczególych zmiennych
+a, b, c = (1, 2, 3) # a to teraz 1, b jest 2, a c to 3
+# Jeżeli zapomnisz nawiasów, automatycznie tworzone są krotki
+d, e, f = 4, 5, 6
+# Popatrz jak prosto zamienić wartości
+e, d = d, e # d to teraz 5 a e to 4
+
+
+# Słowniki są również pożyteczne
+pusty_slownik = {}
+# Tu tworzymy wypełniony:
+pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
+
+# Podglądany wartość
+pelen_slownik["one"] # => 1
+
+# Wypisz wszystkie klucze, używając "keys()"
+pelen_slownik.keys() # => ["trzy", "dwa", "raz"]
+# Uwaga: słowniki nie zapamiętują kolejności kluczy.
+
+# A teraz wszystkie wartości "values()"
+pelen_slownik.values() # => [3, 2, 1]
+# Uwaga: to samo dotyczy wartości.
+
+# Sprawdzanie czy klucz występuje w słowniku za pomocą "in"
+"raz" in pelen_slownik # => True
+1 in pelen_slownik # => False
+
+# Próba dobrania się do nieistniejącego klucza da KeyError
+pelen_slownik["cztery"] # KeyError
+
+# Użyj metody "get()", aby uniknąć błędu KeyError
+pelen_slownik.get("raz") # => 1
+pelen_slownik.get("cztery") # => None
+# Metoda get zwraca domyślną wartość gdy brakuje klucza
+pelen_slownik.get("one", 4) # => 1
+pelen_slownik.get("cztery", 4) # => 4
+# zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
+# (get nie ustawia wartości słownika)
+
+# przypisz wartość do klucza podobnie jak w listach
+pelen_slownik["cztery"] = 4 # teraz: pelen_slownik["cztery"] => 4
+
+# "setdefault()" wstawia do słownika tylko jeśli nie było klucza
+pelen_slownik.setdefault("piec", 5) # pelen_slownik["piec"] daje 5
+pelen_slownik.setdefault("piec", 6) # pelen_slownik["piec"] to wciąż 5
+
+
+# Teraz zbiory (set) - działają jak zwykłe listy, ale bez potórzeń
+pusty_zbior = set()
+# Inicjalizujemy "set()" pewnymi wartościami
+jakis_zbior = set([1, 2, 2, 3, 4]) # jakis_zbior to teraz set([1, 2, 3, 4])
+
+# kolejność nie jest zachowana, nawet gdy wydaje się posortowane
+inny_zbior = set([4, 3, 2, 2, 1]) # inny_zbior to set([1, 2, 3, 4])
+
+# Od Pythona 2.7 nawiasy klamrowe {} mogą być użyte do deklarowania zbioru
+pelen_zbior = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
+
+# Dodaj więcej elementów przez "add()"
+pelen_zbior.add(5) # pelen_zbior is now {1, 2, 3, 4, 5}
+
+# Znajdź przecięcie (część wspólną) zbiorów, używając &
+inny_zbior = {3, 4, 5, 6}
+pelen_zbior & other_set # => {3, 4, 5}
+
+# Suma zbiorów |
+pelen_zbior | other_set # => {1, 2, 3, 4, 5, 6}
+
+# Różnicę zbiorów da znak -
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Sprawdzanie obecności w zbiorze: "in".
+2 in pelen_zbior # => True
+10 in pelen_zbior # => False
+
+
+####################################################
+## 3. Kontrola przepływu
+####################################################
+
+# Tworzymy zmienną jakas_zm
+jakas_zm = 5
+
+# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia w Pythonie są ważne!
+# Poniższy kod wypisze "jakas_zm jest mniejsza niż 10"
+if jakas_zm > 10:
+ print("jakas_zm jest wieksza niż 10")
+elif some_var < 10: # Opcjonalna klauzula elif
+ print("jakas_zm jest mniejsza niż 10")
+else: # Również opcjonalna klauzula else
+ print("jakas_zm jest równa 10")
+
+
+"""
+Pętla for iteruje po elementach listy, wypisując:
+ pies to ssak
+ kot to ssak
+ mysz to ssak
+"""
+for zwierze in ["pies", "kot", "mysz"]:
+ # Użyj metody format, aby umieścić wartość zmiennej w ciągu
+ print("{0} to ssak".format(zwierze))
+
+"""
+"range(liczba)" zwraca listę liczb
+z przedziału od zera do wskazanej liczby (bez niej):
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Skrót od x = x + 1
+
+# Wyjątki wyłapujemy, używając try i except
+
+# Działa w Pythonie 2.6 i wyższych:
+try:
+ # Użyj "raise" aby wyrzucić wyjątek
+ raise IndexError("To błąd indeksu")
+except IndexError as e:
+ pass # Pass to brak reakcji na błąd. Zwykle opisujesz tutaj, jak program ma się zachować w przypadku błędu.
+except (TypeError, NameError):
+ pass # kilka wyjątków można przechwycić jednocześnie.
+else: # Opcjonalna część bloku try/except. Musi wystąpić na końcu
+ print "Wszystko ok!" # Zadziała tylko, gdy program nie napotka wyjatku.
+
+
+####################################################
+## 4. Funkcje
+####################################################
+
+# Użyj "def", aby stworzyć nową funkcję
+def dodaj(x, y):
+ print("x to %s, a y to %s" % (x, y))
+ return x + y # słowo kluczowe return zwraca wynik działania
+
+# Tak wywołuje się funkcję z parametrami:
+dodaj(5, 6) # => wypisze "x to 5, a y to 6" i zwróci 11
+
+# Innym sposobem jest wywołanie z parametrami nazwanymi.
+dodaj(y=6, x=5) # tutaj kolejność podania nie ma znaczenia.
+
+
+# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów pozycyjnych,
+# które zostaną przekazana jako krotka, pisząc w definicji funkcji "*args"
+def varargs(*args):
+ return args
+
+varargs(1, 2, 3) # => (1, 2, 3)
+
+
+# Można też stworzyć funkcję, które przyjmują zmienną liczbę parametrów
+# nazwanych kwargs, które zostaną przekazane jako słownik, pisząc w definicji funkcji "**kwargs"
+def keyword_args(**kwargs):
+ return kwargs
+
+# Wywołajmy to i sprawdźmy co się dzieje
+keyword_args(wielka="stopa", loch="ness") # => {"wielka": "stopa", "loch": "ness"}
+
+
+# Możesz też przyjmować jednocześnie zmienną liczbę parametrów pozycyjnych i nazwanych
+def all_the_args(*args, **kwargs):
+ print(args)
+ print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) wypisze:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# Użyj * aby rozwinąć parametry z krotki args
+# i użyj ** aby rozwinąć parametry nazwane ze słownika kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # odpowiednik foo(1, 2, 3, 4)
+all_the_args(**kwargs) # odpowiednik foo(a=3, b=4)
+all_the_args(*args, **kwargs) # odpowiednik foo(1, 2, 3, 4, a=3, b=4)
+
+# Możesz podać parametry args i kwargs do funkcji równocześnie
+# przez rozwinięcie odpowiednio * i **
+def pass_all_the_args(*args, **kwargs):
+ all_the_args(*args, **kwargs)
+ print varargs(*args)
+ print keyword_args(**kwargs)
+
+# Zasięg zmiennych
+x = 5
+
+def setX(num):
+ # Lokalna zmienna x nie jest tym samym co zmienna x
+ x = num # => 43
+ print x # => 43
+
+def setGlobalX(num):
+ global x
+ print x # => 5
+ x = num # globalna zmienna to teraz 6
+ print x # => 6
+
+setX(43)
+setGlobalX(6)
+
+# Można tworzyć funkcje wewnętrzne i zwrócić je jako wynik
+def rob_dodawacz(x):
+ def dodawacz(y):
+ return x + y
+ return dodawacz
+
+dodaj_10 = rob_dodawacz(10)
+dodaj_10(3) # => 13
+
+# Są również funkcje anonimowe "lambda"
+(lambda x: x > 2)(3) # => True
+
+# Python ma też wbudowane funkcje wyższego rzędu (przyjmujące inną funkcje jako parametr)
+map(add_10, [1, 2, 3]) # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# Można używać wyrażeń listowych (list comprehensions) do mapowania i filtrowania
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] # => [6, 7]
+
+
+####################################################
+## 5. Klasy
+####################################################
+
+# Wszystkie klasy są podklasą object
+class Czlowiek(object):
+
+ # Atrybut klasy. Występuje we wszystkich instancjach klasy.
+ gatunek = "H. sapiens"
+
+ # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
+ # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
+ # specjalne obiekty lub atrybuty wykorzystywane wewnętrznie przez Pythona.
+ # Nie używaj ich we własnych metodach.
+ def __init__(self, nazwa):
+ # przypisz parametr "nazwa" do atrybutu instancji
+ self.nazwa = nazwa
+
+ # Metoda instancji. Wszystkie metody przyjmują "self" jako pierwszy argument
+ def mow(self, wiadomosc):
+ return "%s: %s" % (self.nazwa, wiadomosc)
+
+ # Metoda klasowa współdzielona przez instancje.
+ # Przyjmuje wywołującą klasę jako pierwszy argument.
+ @classmethod
+ def daj_gatunek(cls):
+ return cls.gatunek
+
+ # Metoda statyczna jest wywoływana bez argumentów klasy czy instancji.
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Instancja klasy
+i = Czlowiek(name="Ian")
+print(i.mow("cześć")) # wypisze "Ian: cześć"
+
+j = Czlowiek("Joel")
+print(j.mow("cześć")) # wypisze "Joel: cześć"
+
+# Wywołujemy naszą metodę klasową
+i.daj_gatunek() # => "H. sapiens"
+
+# Zmieniamy wspólny parametr
+Czlowiek.gatunek = "H. neanderthalensis"
+i.daj_gatunek() # => "H. neanderthalensis"
+j.daj_gatunek() # => "H. neanderthalensis"
+
+# Wywołanie metody statycznej
+Czlowiek.grunt() # => "*grunt*"
+
+
+####################################################
+## 6. Moduły
+####################################################
+
+# Tak importuje się moduły:
+import math
+print(math.sqrt(16)) # => 4
+
+# Można podać konkretne funkcje, np. ceil, floor z modułu math
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Można zaimportować wszystkie funkcje z danego modułu.
+# Uwaga: nie jest to polecane, bo później w kodzie trudno połapać się,
+# która funkcja pochodzi z którego modułu.
+from math import *
+
+# Można skracać nazwy modułów.
+import math as m
+math.sqrt(16) == m.sqrt(16) # => True
+# sprawdźmy czy funkcje są równoważne
+from math import sqrt
+math.sqrt == m.sqrt == sqrt # => True
+
+# Moduły Pythona to zwykłe skrypty napisane w tym języku. Możesz
+# pisać własne i importować je. Nazwa modułu to nazwa pliku.
+
+# W ten sposób sprawdzisz jakie funkcje wchodzą w skład modułu.
+import math
+dir(math)
+
+
+####################################################
+## 7. Zaawansowane
+####################################################
+
+# Generatory pomagają tworzyć tzw. "leniwy kod"
+def podwojne_liczby(iterowalne):
+ for i in iterowalne:
+ yield i + i
+
+# Generatory tworzą wartości w locie.
+# Zamiast generować wartości raz i zapisywać je (np. w liście),
+# generator tworzy je na bieżąco, w wyniku iteracji. To oznacza,
+# że w poniższym przykładzie wartości większe niż 15 nie będą przetworzone
+# w funkcji "podwojne_liczby".
+# Zauważ, że xrange to generator, który wykonuje tę samą operację co range.
+# Stworzenie listy od 1 do 900000000 zajęłoby sporo czasu i pamięci,
+# a xrange tworzy obiekt generatora zamiast budować całą listę jak range.
+
+# Aby odróżnić nazwę zmiennej od nazwy zarezerwowanej w Pythonie, używamy
+# zwykle na końcu znaku podkreślenia
+xrange_ = xrange(1, 900000000)
+
+# poniższa pętla będzie podwajać liczby aż do 30
+for i in podwojne_liczby(xrange_):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Dekoratory
+# w tym przykładzie "beg" jest nakładką na "say"
+# Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
+# zostanie zmieniona
+
+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, "Proszę! Jestem spłukany :(")
+ return msg
+ return wrapper
+
+
+@beg
+def say(say_please=False):
+ msg = "Kupisz mi piwo?"
+ return msg, say_please
+
+
+print(say()) # Kupisz mi piwo?
+print(say(say_please=True)) # Kupisz mi piwo? Proszę! Jestem spłukany :(
+```
+
+## Gotowy na więcej?
+### Polskie
+
+* [Zanurkuj w Pythonie](http://pl.wikibooks.org/wiki/Zanurkuj_w_Pythonie)
+* [LearnPythonPl](http://www.learnpython.org/pl/)
+
+### Angielskie:
+#### Darmowe źródła online
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](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)
+
+#### Inne
+
+* [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/pl-pl/ruby-pl.html.markdown b/pl-pl/ruby-pl.html.markdown
new file mode 100644
index 00000000..7ab47847
--- /dev/null
+++ b/pl-pl/ruby-pl.html.markdown
@@ -0,0 +1,593 @@
+---
+language: ruby
+filename: learnruby-pl.rb
+contributors:
+ - ["David Underwood", "http://theflyingdeveloper.com"]
+ - ["Joel Walden", "http://joelwalden.net"]
+ - ["Luke Holder", "http://twitter.com/lukeholder"]
+ - ["Tristan Hume", "http://thume.ca/"]
+ - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+ - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+ - ["Ariel Krakowski", "http://www.learneroo.com"]
+ - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+ - ["Levi Bostian", "https://github.com/levibostian"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+ - ["Gabriel Halley", "https://github.com/ghalley"]
+ - ["Persa Zula", "http://persazula.com"]
+translators:
+ - ["Marcin Klocek", "https://github.com/mklocek"]
+lang: pl-pl
+---
+
+```ruby
+# To jest komentarz
+
+=begin
+To jest wielolinijkowy komentarz
+Nikt ich nie używa
+Ty też nie powinieneś
+=end
+
+# Przede wszystkim: Wszystko jest obiektem.
+
+# Liczby są obiektami
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Trochę podstawowej arytmetyki
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+5 ^ 6 #=> 3
+
+# Arytmetyka jest zastąpeniem składni
+# metod wywoływanych na obiektach
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Wartości specjalne są obiektami
+nil # To na prawdę jest niczym
+true # prawda
+false # fałsz
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Równość
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Nierówność
+1 != 1 #=> false
+2 != 1 #=> true
+
+# jedyną 'fałszywą' wartością poza false, jest nil
+
+!nil #=> true
+!false #=> true
+!0 #=> false
+
+# Więcej porównań
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operatory logiczne
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Istnieją alternatywne wersje operatorów logicznych ze znacznie mniejszym
+# pierwszeństwem. Używane są by kontrolować wyrażenia w łańcuchach wyrażeń
+# aż jedno z nich wróci true lub false.
+
+# `zrob_cos_innego` wywołaj tylko wtedy gdy `zrob_cos` zakończy się sukcesem.
+zrob_cos_innego() and zrob_cos()
+# `log_error` wywołaj tylko wtedy gdy `zrob_cos` nie zakończy się sukcesem.
+zrob_cos() or log_error()
+
+
+# Stringi są obiektami
+
+'Jestem stringiem.'.class #=> String
+"Ja również jestem stringiem.".class #=> String
+
+wypelnienie = 'użyć interpolacji stringa'
+"Potrafię #{wypelnienie} używając podwójnych cudzysłowów."
+#=> "Potrafię użyć interpolacji stringa używając podwójnych cudzysłowów."
+
+# Staraj się zapisywać stringi za pomocą apostrof, zamiast cudzysłowów tam, gdzie to możliwe
+# Cudzysłowy wykonują dodatkowe wewnętrzne operacje
+
+
+# Łączenie stringów, ale nie liczb
+'hej ' + 'świecie' #=> "hej świecie"
+'hej ' + 3 #=> TypeError: can't convert Fixnum into String
+'hej ' + 3.to_s #=> "hej 3"
+
+# Łączenie stringów i operatorów
+'hej ' * 3 #=> "hej hej hej "
+
+# Dodawanie do stringa
+'hej' << ' świecie' #=> "hej świecie"
+
+# wydrukowanie wartości wraz z nową linią na końcu
+puts "Drukuję!"
+#=> Drukuję!
+#=> nil
+
+# wydrukowanie wartości bez nowej linii na końcu
+print "Drukuję!"
+#=> Drukuję! => nill
+
+# Zmienne
+x = 25 #=> 25
+x #=> 25
+
+# Zauważ, że przypisanie zwraca przypisywaną wartość
+# To znaczy, że możesz wykonać wielokrotne przypisanie:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Zwyczajowo, używaj notacji nazwa_zmiennej dla nazw zmiennych
+nazwa_zmiennej = true
+
+# Używaj opisowych nazw zmiennych
+sciezka_do_projektu = '/dobra/nazwa/'
+sciezka = '/zla/nazwa/'
+
+# Symbole (są obiektami)
+# Symbole są niezmiennymi, wielokrotnie używanymi stałymi reprezentowanymi wewnętrznie jako
+# liczby całkowite. Często używane są zamiast stringów w celu wydajniejszego przekazywania danych
+
+:oczekujacy.class #=> Symbol
+
+status = :oczekujacy
+
+status == :oczekujacy #=> true
+
+status == 'oczekujacy' #=> false
+
+status == :zatwierdzony #=> false
+
+# Tablice
+
+# To jest tablica
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Tablice mogą zwierać różne typy danych
+
+[1, 'hej', false] #=> [1, "hej", false]
+
+# Tablice mogę być indeksowane
+# Od początku
+tablica[0] #=> 1
+tablica.first #=> 1
+tablica[12] #=> nil
+
+# Podobnie jak przy arytmetyce, dostęp poprzez [zmienna]
+# jest tylko czytelniejszą składnią
+# dla wywoływania metody [] na obiekcie
+tablica.[] 0 #=> 1
+tablica.[] 12 #=> nil
+
+# Od końca
+tablica[-1] #=> 5
+tablica.last #=> 5
+
+# Z początkowym indeksem i długością
+tablica[2, 3] #=> [3, 4, 5]
+
+# Odwrotność tablicy
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Lub zakres
+array[1..3] #=> [2, 3, 4]
+
+# Dodawanie do tablicy w taki sposób
+tablica << 6 #=> [1, 2, 3, 4, 5, 6]
+# Lub taki
+tablica.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Sprawdzanie, czy tablica zawiera element
+tablica.include?(1) #=> true
+
+# Hasze są Ruby'owymi podstawowymi słownikami z parami klucz/wartość.
+# Hasze są zapisywane za pomocą nawiasów klamrowych
+hasz = { 'kolor' => 'zielony', 'numer' => 5 }
+
+hasz.keys #=> ['kolor', 'numer']
+
+# Można szybko sprawdzić zawartość hasza za pomocą kluczy:
+hasz['kolor'] #=> 'zielony'
+hasz['numer'] #=> 5
+
+# Sprawdzenie wartośći dla nieistniejącego klucza zwraca nil:
+hasz['nic tutaj nie ma'] #=> nil
+
+# Od wersji 1.9, Ruby posiada specjalną składnię, gdy używamy symboli jako kluczy:
+
+nowy_hasz = { stan: 3, akcja: true }
+
+nowy_hasz.keys #=> [:stan, :akcja]
+
+# Sprawdzenie istnienia kluczy i wartości w haszu
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+
+# Wskazówka: Zarówno tablice, jak i hasze, są policzalne
+# Współdzielą wiele metod takich jak each, map, count, i inne
+
+# Instrukcje warunkowe
+
+if true
+ 'wyrażenie if'
+elsif false
+ 'wyrażenie if, opcjonalne'
+else
+ 'wyrażenie else, również opcjonalne'
+end
+
+for licznik in 1..5
+ puts "powtórzenie #{licznik}"
+end
+#=> powtórzenie 1
+#=> powtórzenie 2
+#=> powtórzenie 3
+#=> powtórzenie 4
+#=> powtórzenie 5
+
+# JEDNAKŻE, Nikt nie używa pętli for.
+# Zamiast tego, powinno się używać metody "each" i podawać jej blok.
+# Blok jest kawałkiem kodu, który możesz podać metodzie podobnej do "each".
+# Jest analogiczny do wyrażeń lambda, funkcji anonimowych lub zamknięć w innych
+# językach programowania.
+#
+# Metoda "each" danego zakresu, wykonuje blok dla każdego elementu w zakresie.
+# Do bloku zostaje przekazany licznik jako parametr.
+# Wykonanie metody "each" z przekazaniem bloku wygląda następująco:
+
+(1..5).each do |licznik|
+ puts "powtórzenie #{licznik}"
+end
+#=> powtórzenie 1
+#=> powtórzenie 2
+#=> powtórzenie 3
+#=> powtórzenie 4
+#=> powtórzenie 5
+
+# Możesz również otoczyć blok nawiasami klamrowymi:
+(1..5).each { |licznik| puts "powtórzenie #{licznik}" }
+
+# Zawartość struktur danych również może być powtarzana używając each.
+tablica.each do |element|
+ puts "#{element} jest częścią tablicy"
+end
+hasz.each do |klucz, wartosc|
+ puts "#{klucz} jest #{wartosc}"
+end
+
+# Jeśli nadal potrzebujesz indeksum, możesz użyć "each_with_index" i zdefiniować
+# zmienną odpowiadającą indeksowi
+tablica.each_with_index do |element, indeks|
+ puts "#{element} jest numerem #{indeks} w tablicy"
+end
+
+licznik = 1
+while licznik <= 5 do
+ puts "powtórzenie #{licznik}"
+ licznik += 1
+end
+#=> powtórzenie 1
+#=> powtórzenie 2
+#=> powtórzenie 3
+#=> powtórzenie 4
+#=> powtórzenie 5
+
+# W Ruby istnieje dużo pomocnych funkcji wykonujących pętle,
+# na przykład "map", "reduce", "inject" i wiele innych. Map,
+# w każdym wywołaniu, pobiera tablicę, na której wykonuję pętlę,
+# wykonuje kod zapisany za pomocą bloku i zwraca całkowicie nową tablicę.
+tablica = [1,2,3,4,5]
+podwojone = tablica.map do |element|
+ element * 2
+end
+puts podwojona
+#=> [2,4,6,8,10]
+puts tablica
+#=> [1,2,3,4,5]
+
+ocena = 2
+
+case ocena
+when 1
+ puts 'Dobra robota, masz wolne'
+when 2
+ puts 'Następnym razem będziesz miał więcej szczęścia'
+when 3
+ puts 'Możesz to zrobić lepiej'
+when 4
+ puts 'Przebrnąłeś'
+when 5
+ puts 'Oblałeś!'
+else
+ puts 'Inny system oceniania?'
+end
+#=> "Następnym razem będziesz miał więcej szczęścia"
+
+# case może również użwać zakresów
+ocena = 82
+case ocena
+when 90..100
+ puts 'Hurra!'
+when 80...90
+ puts 'Dobra robota'
+else
+ puts 'Oblałeś!'
+end
+#=> "Dobra robota"
+
+# obsługa błędów:
+begin
+ # kod, który może wywołać wyjątek
+ raise NoMemoryError, 'Zabrakło pamięci.'
+rescue NoMemoryError => zmienna_wyjatku
+ puts 'Został wywołany NoMemoryError', zmienna_wyjatku
+rescue RuntimeError => inna_zmienna_wyjatku
+ puts 'Teraz został wywołany RuntimeError'
+else
+ puts 'To zostanie uruchomione, jeśli nie wystąpi żaden wyjątek'
+ensure
+ puts 'Ten kod wykona się zawsze'
+end
+
+# Funkcje
+
+def podwojenie(x)
+ x * 2
+end
+
+# Funkcje (i wszystkie bloki) zawsze zwracają wartość ostatniego wyrażenia
+podwojenie(2) #=> 4
+
+# Okrągłe nawiady są opcjonalne, gdy wynik jest jednoznaczny
+podwojenie 3 #=> 6
+
+podwojenie podwojenie 3 #=> 12
+
+def suma(x, y)
+ x + y
+end
+
+# Argumenty metod są oddzielone przecinkami
+suma 3, 4 #=> 7
+
+suma suma(3, 4), 5 #=> 12
+
+# yield
+# Wszystkie metody mają ukryty, opcjonalny parametr bloku,
+# który może być wykonany używając słowa kluczowego 'yield'
+
+def otoczenie
+ puts '{'
+ yield
+ puts '}'
+end
+
+otoczenie { puts 'hej świecie' }
+
+# {
+# hej świecie
+# }
+
+
+# Możesz przekazać blok do funkcji
+# "&" oznacza referencję to przekazanego bloku
+def goscie(&blok)
+ blok.call 'jakis_argument'
+end
+
+# Możesz przekazać listę argumentów, które będę przekonwertowane na tablicę
+# Do tego służy operator ("*")
+def goscie(*tablica)
+ tablica.each { |gosc| puts gosc }
+end
+
+# Definiowanie klas używając słowa kluczowego class
+class Czlowiek
+
+ # Zmienna klasowa. Jest współdzielona przez wszystkie instancje tej klasy.
+ @@gatunek = 'H. sapiens'
+
+ # Podstawowe inicjalizowanie
+ def initialize(imie, wiek = 0)
+ # Przypisanie argumentu do zmiennej danej instancji o nazwie "imie"
+ @imie = imie
+ # Jeśli nie podano wieku, zostanie użyta domyślna wartość z listy argumentów.
+ @wiek = wiek
+ end
+
+ # Podstawowa metoda przypisująca wartość
+ def imie=(imie)
+ @imie = imie
+ end
+
+ # Podstawowa metoda pobierająca wartość
+ def imie
+ @imie
+ end
+
+ # Powyższa funkcjonalność może być zastąpiona używając metody attr_accessor w taki sposób
+ attr_accessor :imie
+
+ # Metody przypisujące/pobierające mogą być stworzone indywidualnie
+ attr_reader :imie
+ attr_writer :imie
+
+ # Metody klasowe używają self aby odróżnić się od metody instancji.
+ # To może być wywołane na klasie, nie na instancji.
+ def self.powiedz(wiadomosc)
+ puts wiadomosc
+ end
+
+ def gatunek
+ @@gatunek
+ end
+end
+
+
+# Tworzenie instancji klasy
+jim = Czlowiek.new('Jim Halpert')
+
+dwight = Czlowiek.new('Dwight K. Schrute')
+
+# Wywołajmy parę metod
+jim.gatunek #=> "H. sapiens"
+jim.imie #=> "Jim Halpert"
+jim.imie = "Jim Halpert II" #=> "Jim Halpert II"
+jim.imie #=> "Jim Halpert II"
+dwight.gatunek #=> "H. sapiens"
+dwight.imie #=> "Dwight K. Schrute"
+
+# Wywołanie metody klasowej
+Czlowiek.powiedz('Cześć') #=> "Cześć"
+
+# Zasięg zmiennej jest definiowany poprzez jej nazwę.
+# Zmienne, które zaczynają się na $ mają zasięg globalny
+$zmienna = "Jestem zmienną globalną"
+defined? $zmienna #=> "global-variable"
+
+# Zmienne zczynające się na @ mają zasięg danej instancji
+@zmienna = "Jestem zmienną instancji"
+defined? @zmienna #=> "instance-variable"
+
+# Zmienne, które zaczynają się na @@ mają zasięg danej klasy
+@@zmienna = "Jestem zmienną klasową"
+defined? @@zmienna #=> "class variable"
+
+# Zmienne, które zaczynają się na dużą literę, są stałymi
+Zmienna = "Jestem stałą"
+defined? Zmienna #=> "constant"
+
+# Klasa jest również obiektem w ruby. Może więc mieć zmienne instancji.
+# Zmienna klasowa może być współdzielona między klasą i jej potomstwem.
+
+# podstawowa klasa
+class Czlowiek
+ @@cokolwiek = 0
+
+ def self.cokolwiek
+ @@cokolwiek
+ end
+
+ def self.cokolwiek=(wartosc)
+ @@cokolwiek = wartosc
+ end
+end
+
+# klasa pochodna
+class Pracownik < Czlowiek
+end
+
+Czlowiek.cokolwiek # 0
+Pracownik.cokolwiek # 0
+
+Czlowiek.cokolwiek = 2 # 2
+Pracownik.cokolwiek # 2
+
+# Zmienna instancji danej klasy nie jest współdzielona przez jej potomstwo.
+
+class Czlowiek
+ @cos = 0
+
+ def self.cos
+ @cos
+ end
+
+ def self.cos=(wartosc)
+ @cos = wartosc
+ end
+end
+
+class Doktor < Czlowiek
+end
+
+Czlowiek.cos # 0
+Doktor.cos # nil
+
+module PrzykladowyModul
+ def cokolwiek
+ 'cokolwiek'
+ end
+end
+
+# Włączanie modułów łączy ich metody z metodami instancji klasy
+# Rozszerzanie modułów łączy ich metody z metodami klasy
+
+class Osoba
+ include PrzykladowyModul
+end
+
+class Ksiazka
+ extend PrzykladowyModul
+end
+
+Osoba.cokolwiek # => NoMethodError: undefined method `cokolwiek' for Osoba:Class
+Osoba.new.cokolwiek # => 'cokolwiek'
+Ksiazka.cokolwiek # => 'cokolwiek'
+Ksiazka.new.cokolwiek # => NoMethodError: undefined method `cokolwiek'
+
+# Gdy włączamy lub rozszerzamy muduły, wykonywane są tzw. wywołania zwrotne
+
+module PrzykladowyModul
+ def self.included(baza)
+ baza.extend(MotodyKlasowe)
+ baza.send(:include, MetodyInstancji)
+ end
+
+ module MotodyKlasowe
+ def cos
+ 'cos'
+ end
+ end
+
+ module MetodyInstancji
+ def xyz
+ 'xyz'
+ end
+ end
+end
+
+class Cokolwiek
+ include PrzykladowyModul
+end
+
+Cokolwiek.cos # => 'cos'
+Cokolwiek.xyz # => NoMethodError: undefined method `xyz'
+Cokolwiek.new.cos # => NoMethodError: undefined method `cos'
+Cokolwiek.new.xyz # => 'qux'
+```
+
+## Dodatkowe źródła
+### Polskie
+
+- [Dokumentacja](https://www.ruby-lang.org/pl/documentation/quickstart/)
+
+### Angielskie
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown
new file mode 100644
index 00000000..8ac2df56
--- /dev/null
+++ b/pl-pl/vim-pl.html.markdown
@@ -0,0 +1,236 @@
+---
+category: tool
+tool: vim
+contributors:
+ - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+ - ["Adam Bobowski", "https://github.com/Bobowski"]
+lang: pl-pl
+filename: LearnVim-pl.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix.
+Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest
+wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych
+do szybkiej nawigacji do wybranych miejsc w plikach oraz szybkiej edycji
+danych fragmentów.
+
+## Podstawy nawigacji w Vim
+
+```
+ vim <nazwapliku> # Otwórz <nazwapliku> w vim
+ :q # Zamknij vim
+ :w # Zapisz aktualny plik
+ :wq # Zapisz i wyjdź z vim
+ :q! # Wyjdź bez zapisywania
+ # ! *wymusza* wykonanie :q, dlatego nie wykonuje zapisu
+ :x # Zapisz i wyjdź, krótszy odpowiednik :wq
+
+ u # Cofnij operację
+ CTRL+R # Powtórz operację
+
+ h # Przesuń kursor w lewo
+ j # Przesuń kursor w dół
+ k # Przesuń kursor w górę
+ l # Przesuń kursor w prawo
+
+ # Poruszanie w obrębie jednej lini
+
+ 0 # Skocz do początku linii
+ $ # Skocz do końca linii
+ ^ # Skocz do pierwszego niebiałego znaku
+
+ # Wyszukiwanie w tekście
+
+ /slowo # Zaznacza wszystkie wystąpienia słowa za kursorem
+ ?slowo # Zaznacza wszystkie wystąpienia słowa przed kursorem
+ n # Przemieszcza kursor do następnego wystąpienia słowa
+ N # Przemieszcza kursor do poprzedniego wystąpenia słowa
+
+ :%s/foo/bar/g # Zamień 'foo' na 'bar' w każdej linii tekstu
+ :s/foo/bar/g # Zamień 'foo' na 'bar' w aktualnej linii
+
+ # Skoki do znaków
+
+ f<znak> # Skocz do przodu i zatrzymaj się na <znak>
+ t<znak> # Skocz do przodu i zatrzymaj się przed <znak>
+
+ # Na przykład,
+ f< # Skocz do przodu i zatrzymaj się na <
+ t< # Skocz do przodu i zatrzymaj się przed <
+
+ # Moving by word
+
+ w # Przesuń kursor do przodu o jedno słowo
+ b # Przesuń kursor do tyłu o jedno słowo
+ e # Przesuń kursor do końca aktualnego słowa
+
+ # Inne znaki do przemieszczania się
+
+ gg # Skocz na początek pliku
+ G # Skocz na koniec pliku
+ :NUM # Skocz do linii o numerze NUM
+ H # Skocz na górę ekranu
+ M # Skocz na środek ekranu
+ L # Skocz na dół ekranu
+```
+
+## Tryby:
+
+Vim oparty jest na koncepcji **trybów**.
+
+Command Mode - (Tryb komend) vim zaczyna w tym trybie, używany do nawigacji i wpisywania komend
+Insert Mode - (Tryb wprowadzania) używany do wprowadzania zmian w pliku
+Visual Mode - (Tryb wizualny) używany do zaznaczania tekstu i wykonywania komend na nim
+Ex Mode - (Tryb Ex)
+
+```
+ i # Przechodzi to trybu wprowadzania, przed pozycją kursora
+ a # Przechodzi do trybu wprowadzania, za pozycją kursora
+ v # Przechodzi do trybu wizualnego
+ : # Przechodzi do trybu ex
+ <esc> # Wychodzi z dowolnego aktywnego trybu do trybu komend
+
+ # Kopiowanie i wklejanie tekstu
+
+ y # Skopiuj zaznaczony tekst
+ yy # Skopiuj aktualną linię
+ d # Usuń zaznaczony tekst
+ dd # Usuń aktualną linię
+ p # Wklej skopiowany tekst za kursorem
+ P # Wklej skopiowany tekst przed kursorem
+ x # Usuń znak pod kursorem
+```
+
+## 'Gramatyka' vim'a
+
+Vim można traktować jako zbiór komend w formacie 'Akcja-Modyfikator-Obiekt', gdzie:
+
+Akcja - jedna z dostępnych akcji
+Modyfikator - w jaki sposób wykonywana jest akcja
+Obiekt - obiekt na którym wykonywana jest akcja
+
+Kilka ważnych przykładów Akcji, Modyfikatorów i Obiektów:
+
+```
+ # 'Akcje'
+
+ d # Usuń
+ c # Zmień
+ y # Skopiuj
+ v # Zaznacz
+
+ # 'Modyfikatory'
+
+ i # W środku
+ a # Dookoła
+ NUM # Liczba
+ f # Szuka czegoś i zatrzymuje się na tym
+ t # Szuka czegoś i zatrzymuje się przed tym
+ / # Znajduje napis od kursora naprzód
+ ? # Znajduje napis przed kursorem
+
+ # 'Obiekty'
+
+ w # Słowo
+ s # Zdanie
+ p # Paragraf
+ b # Blok
+
+ # Przykładowe 'zdania'
+
+ d2w # Usuń 2 słowa
+ cis # Zmień w zdaniu
+ yip # Skopiuj paragraf w którym jest kursor
+ ct< # Zamień na <
+ d$ # Usuń tekst do końca linii
+```
+
+## Pewne skróty i triki
+
+ <!--TODO: Dodać więcej!-->
+```
+ > # Zrób wcięcie zaznaczonego bloku
+ < # Usuń wcięcie zaznaczonego bloku
+ :earlier 15m # Przywróć dokument do stanu z przed 15 minut
+ :later 15m # Odwróć efekt poprzedniej komendy
+ ddp # Zamień kolejnością kolejne linie, dd potem p
+ . # Powtórz poprzednią komendę
+```
+
+## Makra
+
+Makra są właściwie nagrywanymi akcjami. Gdy zaczynasz nagrywać makro, nagrywa ono
+**każdą** akcję i komendę jaką wykonasz do momentu przerwania nagrywania.
+Wywołanie makra wykonuje dokładnie te same operacje w tej samej kolejności.
+
+```
+ qa # Zacznij nagrywać makro 'a'
+ q # Przerwij nagrywanie
+ @a # Odtwórz makro 'a'
+```
+
+### Konfiguracja ~/.vimrc
+
+Plik .vimrc może być użyty do skonfigurowania Vim'a przy jego starcie
+
+Poniżej zamieszczono przykładowy plik ~/.vimrc:
+
+```
+" Przykładowy ~/.vimrc
+" 2016.10
+
+" Wymagane aby korzystać z opcji iMproved
+set nocompatible
+
+" Na podstawie typu pliku włącza inteligentne wcięcia i inne.
+filetype indent plugin on
+
+" Włącz podkreślanie składni
+syntax on
+
+" Lepsze uzupełnianie składni komend
+set wildmenu
+
+" Wyszukiwanie będzie ignorować wielkość liter poza przypadkami gdy użyjemy wielkich liter
+set ignorecase
+set smartcase
+
+" Po otwarciu pliku gdzie nie jest zdefiniowane zachowanie wcięć
+" zostanie zachowane wcięcie takie samo jak w aktualnej linii
+set autoindent
+
+" Wyświetlaj numer lini
+set number
+
+" Opcje wcięć, zmień w zależności od osobistych upodobań
+
+" Szerokość TAB w spacjach
+set tabstop=4
+
+" Liczba spacji w TAB podczas edycji
+set softtabstop=4
+
+" Liczba spacji gdy wykonywane są operacje wcięcia (>> i <<)
+set shiftwidth=4
+
+" Zamieniaj tabulatory na spacje
+set expandtab
+
+" Aktywuj inteligentne tabulatory i spacje do wcięć i wyrównań
+set smarttab
+```
+
+### Odniesienia [ENG]
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
diff --git a/pl-pl/xml-pl.html.markdown b/pl-pl/xml-pl.html.markdown
new file mode 100644
index 00000000..7cce138f
--- /dev/null
+++ b/pl-pl/xml-pl.html.markdown
@@ -0,0 +1,137 @@
+---
+language: xml
+filename: learnxml-pl.xml
+contributors:
+ - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+ - ["Tomasz Janiszewski", "https://github.com/janisz"]
+lang: pl-pl
+---
+
+XML (_Extensible Markup Language_) to rozszerzalny język znaczników, stworzony
+do przechowywania i transportu danych.
+
+W przeciwieństwie do HTML, XML nie specyfikuje w jaki sposób wyświetlić dane, a
+tylko je przechowuje.
+
+* Składnia XML
+
+```xml
+<!-- Komentarze w XML wyglądają jak ten -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<ksiegarnia>
+ <ksiazka kategoria="GOTOWANIE">
+ <tytul lang="pl">Codzienny Włoski</tytul>
+ <autor>Giada De Laurentiis</autor>
+ <rok>2005</rok>
+ <cena>30.00</cena>
+ </ksiazka>
+ <ksiazka kategoria="DZIECI">
+ <tytul lang="pl">Harry Potter</tytul>
+ <autor>J K. Rowling</autor>
+ <rok>2005</rok>
+ <cena>29.99</cena>
+ </ksiazka>
+ <ksiazka kategoria="WEB">
+ <tytul lang="pl">Nauka XML</tytul>
+ <autor>Erik T. Ray</autor>
+ <rok>2003</rok>
+ <cena>39.95</cena>
+ </ksiazka>
+</ksiegarnia>
+
+<!-- Powyżej jest typowy plik XML.
+ Zaczyna się od deklaracji zawierającej metadane (opcjonalne).
+
+ XML używa drzewiastej struktury. Powyżej, głównym wierzchołkiem jest
+ 'ksiegarnia' , która zawiera trzy (3) węzły potomne, wszystkie 'ksiazki',
+ które zawierają swoje węzły potomne, i tak dalej...
+
+ Węzły są tworzone używające otwierających/zamykających znaczników.
+ Węzły potomne znajdują się pomiędzy otwierającym i zamykającym znacznikiem.
+-->
+
+<!-- XML przechowuje dwa typy danych
+ 1 - Atrybuty -> metadane o węźle
+ Zazwyczaj parser XML używa tych informacji do przechowywania danych we
+ właściwy sposób. Atrybuty nadawane są poprzez wpisanie ich w otwierajacym
+ znaczniku.
+ 2 - Elementy -> to są czyste dane.
+ Dane, które parser otrzymuje z pliku XML.
+ Elementy są deklarowane pomiędzy otwierajacym i zamykającym znacznikiem,
+ bez nawiasów. -->
+
+<!-- Poniższy element ma dwa atrybuty -->
+<plik type="gif" id="4293">komputer.gif</plik>
+
+
+```
+
+* Dobrze sformatowany dokument i walidacja
+
+Dokument XML jest dobrze sformatowany gdy jest syntaktycznie poprawny.
+Jednakże możliwe jest wstrzykiwanie większej liczby ograniczeń w dokumencie,
+używając definicji takich jak DTD i XML Schema.
+
+Dokument XML, który jest zgodny ze swoją definicją jest poprawny.
+
+
+Korzystając z tych narzędzi możesz sprawdzić dane zawarte w dokumencie poza
+logiką aplikacji.
+
+```xml
+
+
+<!-- Poniżej jest uproszczona wersja dokumentu księgarni,
+ z dodatkową definicją DTD.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE notatka SYSTEM "Ksiegarnia.dtd">
+<ksiegarnia>
+ <ksiazka kategoria="GOTOWANIE">
+ <tytul >Everyday Italian</tytul>
+ <cena>30.00</cena>
+ </ksiazka>
+</ksiegarnia>
+
+<!-- DTD może wyglądać następująco:-->
+
+<!DOCTYPE notatka
+[
+<!ELEMENT ksiegarnia (ksiazka+)>
+<!ELEMENT ksiazka (tytul,cena)>
+<!ATTLIST ksiazka kategoria CDATA "Literatura">
+<!ELEMENT tytul (#PCDATA)>
+<!ELEMENT cena (#PCDATA)>
+]>
+
+
+<!-- DTD zaczyna się od deklaracji
+ Zaczynając od góry, główny węzeł jest zadeklarowany jako wymagający jednego
+ lub więcej węzłów potomnych typu 'ksiżka'.
+ Każda 'ksiażka' powinna zawierać dokładnie jeden 'tytuł' i 'cene' oraz atrybut
+ 'kategoria' z 'literaturą' jako wartość domyślna.
+ 'tytuł' i 'cena' to pola typu parsowalnych zmiennyc znakowych, co oznacza że
+ użyte znaczniki zostaną zinterpretowane &lt; zamienione <. -->
+
+<!-- DTD moze być deklarowane wewnątrz pliku XML. -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE notatka
+[
+<!ELEMENT ksiegarnia (ksiazka+)>
+<!ELEMENT ksiazka (tytul,cena)>
+<!ATTLIST ksiazka kategoria CDATA "Literatura">
+<!ELEMENT tytul (#PCDATA)>
+<!ELEMENT cena (#PCDATA)>
+]>
+
+<ksiegarnia>
+ <ksiazka kategoria="GOTOWANIE">
+ <tytul >Everyday Italian</tytul>
+ <cena>30.00</cena>
+ </ksiazka>
+</ksiegarnia>
+```