Fix typos, improve the language

1 files changed, 81 insertions, 78 deletions

diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
index ade1d7ca..023c3e6b 100644
--- a/pl-pl/python-pl.html.markdown
+++ b/pl-pl/python-pl.html.markdown
@@ -30,7 +30,7 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
 # Pojedyncze komentarze oznaczamy takim symbolem.
 
 """ Wielolinijkowe napisy zapisywane są przy użyciu
-    trzech znaków cudzysłowiu i często
+    potrójnych cudzysłowów i często
     wykorzystywane są jako komentarze.
 """
 
@@ -47,11 +47,11 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
 10 * 2  # => 20
 35 / 5  # => 7
 
-# Dzielenie może być kłopotliwe. Poniższe to dzielenie
+# 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.
+# 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
 
@@ -65,7 +65,7 @@ działać w wersjach 2.x. Dla wersji 3.x znajdziesz odpowiedni artykuł na stron
 # Operator modulo - wyznaczanie reszty z dzielenia
 7 % 3 # => 1
 
-# Potęgowanie (x do potęgi ytej)
+# Potęgowanie (x do potęgi y-tej)
 2**4 # => 16
 
 # Wymuszanie pierwszeństwa w nawiasach
@@ -83,7 +83,7 @@ False or True #=> True   # Prawda
 2 == True #=> False
 k1 == True #=> True
 
-# aby zanegować użyj "not"
+# aby zanegować, użyj "not"
 not True  # => False
 not False  # => True
 
@@ -112,7 +112,7 @@ not False  # => True
 # Napisy można dodawać!
 "Witaj " + "świecie!"  # => "Witaj świecie!"
 
-# ... a nawet mnożone
+# ... a nawet mnożyć
 "Hej" * 3  # => "HejHejHej"
 
 # Napis może być traktowany jako lista znaków
@@ -124,7 +124,7 @@ not False  # => True
 # 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.
+# Jeśli nie chce ci się liczyć, użyj słów kluczowych.
 "{imie} chce zjeść {jadlo}".format(imie="Bob", jadlo="makaron")
 
 # None jest obiektem
@@ -135,12 +135,12 @@ None  # => None
 "etc" is None  # => False
 None is None  # => True
 
-# Operator 'is' testuje identyczność obiektów. To nie jest zbyt 
+# 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ą True
+# None, 0 i pusty napis "" są odpowiednikami logicznego False.
+# Wszystkie inne wartości są uznawane za prawdę (True)
 bool(0)  # => False
 bool("")  # => False
 
@@ -149,20 +149,20 @@ bool("")  # => False
 ## 2. Zmienne i zbiory danych
 ####################################################
 
-# Python ma wyrażenie wypisujące "print" we wszystkich wersjach 2.x, ale
-# zostało usunięte z wersji 3.
-print "Jestem Python. Miło poznać!"
-# Python ma też funkcję "print" dostępną w wersjach 2.7 and 3...
+# 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 znaków i kładki _
+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 po więcej...
+# 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
@@ -173,7 +173,7 @@ li = []
 # Możesz zacząć od wypełnionej listy
 inna_li = [4, 5, 6]
 
-# Dodaj na koniec używając "append"
+# 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]
@@ -185,7 +185,7 @@ li.append(3)    # li to znowu [1, 2, 4, 3].
 
 # Dostęp do list jak do każdej tablicy
 li[0]  # => 1
-# Użyj = aby nadpisać wcześniej wypełnione miejsca w liście
+# 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ść
@@ -195,7 +195,7 @@ li[-1]  # => 3
 # Jeżeli wyjdziesz poza zakres...
 li[4]  # ... zobaczysz IndexError
 
-# Możesz tworzyć wyniki.
+# Możesz też tworzyć wycinki.
 li[1:3]  # => [2, 4]
 # Bez początku
 li[2:]  # => [4, 3]
@@ -213,12 +213,12 @@ 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 poszczególnych list się nie zmieniają.
+# 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 jest w liście używając "in"
+# Sprawdź, czy element jest w liście używając "in"
 1 in li   # => True
 
 # "len()" pokazuje długość listy
@@ -238,7 +238,7 @@ tup[:2]   # => (1, 2)
 
 # 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
+# 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
@@ -252,28 +252,28 @@ pelen_slownik = {"raz": 1, "dwa": 2, "trzy": 3}
 # Podglądany wartość
 pelen_slownik["one"]   # => 1
 
-# Wypisz wszystkie klucze używając "keys()"
+# Wypisz wszystkie klucze, używając "keys()"
 pelen_slownik.keys()   # => ["trzy", "dwa", "raz"]
-# Uwaga: słowniki nie gwarantują kolejności występowania kluczy.
+# 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 występuje to "in"
+# 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 "get()" method aby uniknąć 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") jest wciąż => None
+# zauważ, że pelen_slownik.get("cztery") wciąż zwraca => None
 # (get nie ustawia wartości słownika)
 
 # przypisz wartość do klucza podobnie jak w listach
@@ -284,12 +284,12 @@ pelen_slownik.setdefault("piec", 5)  # pelen_slownik["piec"] daje 5
 pelen_slownik.setdefault("piec", 6)  # pelen_slownik["piec"] to wciąż 5
 
 
-# Teraz zbiory (set) ... cóż zbiory (to po prostu listy ale bez potórzeń)
+# 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 gwarantowana, nawet gdy wydaje się posortowane
+# 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
@@ -298,7 +298,7 @@ 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 zbiorów używając &
+# Znajdź przecięcie (część wspólną) zbiorów, używając &
 inny_zbior = {3, 4, 5, 6}
 pelen_zbior & other_set   # => {3, 4, 5}
 
@@ -317,32 +317,32 @@ pelen_zbior | other_set   # => {1, 2, 3, 4, 5, 6}
 ## 3. Kontrola przepływu
 ####################################################
 
-# Tworzymy zmienną some_var
-some_var = 5
+# Tworzymy zmienną jakas_zm
+jakas_zm = 5
 
-# Tutaj widzisz wyrażenie warunkowe "if". Wcięcia są ważne Pythonie! 
-# wypisze "some_var jest mniejsza niż 10"
-if some_var > 10:
-    print("some_var jest wieksza niż 10")
-elif some_var < 10:    # This elif clause is optional.
-    print("some_var jest mniejsza niż 10")
-else:           # This is optional too.
-    print("some_var jest równa 10")
+# 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:
+Pętla for iteruje po elementach listy, wypisując:
     pies to ssak
     kot to ssak
     mysz to ssak
 """
 for zwierze in ["pies", "kot", "mysz"]:
-    # Możesz użyć % aby stworzyć sformatowane napisy
-    print("%s to ssak" % zwierze)
+    # Użyj metody format, aby umieścić wartość zmiennej w ciągu
+    print("{0} to ssak".format(zwierze))
 
 """
 "range(liczba)" zwraca listę liczb
-od zera do danej liczby:
+z przedziału od zera do wskazanej liczby (bez niej):
     0
     1
     2
@@ -352,7 +352,7 @@ for i in range(4):
     print(i)
 
 """
-While to pętla która jest wykonywana dopóki spełniony jest warunek:
+While to pętla, która jest wykonywana, dopóki spełniony jest warunek:
     0
     1
     2
@@ -363,46 +363,46 @@ while x < 4:
     print(x)
     x += 1  # Skrót od x = x + 1
 
-# Wyjątki wyłapujemy używając try, except
+# 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ąte
+    # 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. Zazwyczaj nanosisz tu poprawki.
+    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że być przechwyce razem.
+    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. Funkcjie
+## 4. Funkcje
 ####################################################
 
-# Użyj "def" aby stworzyć nową funkcję
+# 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łówko kluczowe return zwraca wynik działania
+    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 (args):
-dodaj(5, 6)   # => wypisze "x to 5 a y to 6" i zwróci 11
+# 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ą różną ilość parametrów
-# nienazwanych args, co będzie interpretowane jako krotka jeśli nie użyjesz *
+# 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ą różną ilość parametrów
-# nazwanych kwargs, które będa interpretowane jako słownik jeśli nie dasz **
+# 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
 
@@ -410,12 +410,12 @@ def keyword_args(**kwargs):
 keyword_args(wielka="stopa", loch="ness")   # => {"wielka": "stopa", "loch": "ness"}
 
 
-# Możesz też to pomieszać
+# 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) wyrzuci:
+all_the_args(1, 2, a=3, b=4) wypisze:
     (1, 2)
     {"a": 3, "b": 4}
 """
@@ -435,7 +435,7 @@ def pass_all_the_args(*args, **kwargs):
     print varargs(*args)
     print keyword_args(**kwargs)
 
-# Zakres widoczności
+# Zasięg zmiennych
 x = 5
 
 def setX(num):
@@ -461,14 +461,14 @@ def rob_dodawacz(x):
 dodaj_10 = rob_dodawacz(10)
 dodaj_10(3)   # => 13
 
-# Są również funkcje nienazwane "lambda"
+# Są również funkcje anonimowe "lambda"
 (lambda x: x > 2)(3)   # => True
 
-# Są także wbudowane funkcje wysokiego poziomu
+# 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 do mapowania (map) i filtrowania (filter)
+# 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]
 
@@ -485,18 +485,18 @@ class Czlowiek(object):
     
     # Podstawowa inicjalizacja - wywoływana podczas tworzenia instacji.
     # Zauważ, że podwójne podkreślenia przed i za nazwą oznaczają
-    # obietky lub atrybuty, który żyją tylko w kontrolowanej przez
-    # użytkownika przestrzeni nazw. Nie używaj ich we własnych metodach.
+    # 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 biorą "self" jako pierwszy argument
+    # 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.
-    # Ma wywołującą klasę jako pierwszy argument.
+    # Przyjmuje wywołującą klasę jako pierwszy argument.
     @classmethod
     def daj_gatunek(cls):
         return cls.gatunek
@@ -540,7 +540,8 @@ print(ceil(3.7))  # => 4.0
 print(floor(3.7))   # => 3.0
 
 # Można zaimportować wszystkie funkcje z danego modułu.
-# Ostrzeżenie: nie jest to polecane.
+# 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.
@@ -550,7 +551,7 @@ math.sqrt(16) == m.sqrt(16)   # => True
 from math import sqrt
 math.sqrt == m.sqrt == sqrt  # => True
 
-# Moduły pythona to zwykłe skrypty napisane w tym języku. Możesz
+# 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.
@@ -568,14 +569,16 @@ def podwojne_liczby(iterowalne):
         yield i + i
 
 # Generatory tworzą wartości w locie.
-# W przeciwienstwie do wygenerowania wartości raz i ich zachowania, 
-# powstają one na bieżąco, w wyniku iteracji. To oznacza, że wartości
-# większe niż 15 nie będą przetworzone w funkcji "podwojne_liczby".
+# 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 tworzyć całą listę jak range.
-# Użyto podkreślinika, aby odróżnić nazwę zmiennej od słówka kluczowego
-# Pythona.
+# 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 
@@ -587,7 +590,7 @@ for i in podwojne_liczby(xrange_):
 
 # Dekoratory
 # w tym przykładzie "beg" jest nakładką na "say"
-# Beg wywołuje say. Jeśli say_please jest prawdziwe wtedy wzracana wartość
+# Beg wywołuje say. Jeśli say_please jest prawdziwe, wtedy zwracana wartość
 # zostanie zmieniona
 
 from functools import wraps