mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 10:01:38 +00:00
Merge pull request #2027 from hejmsdz/master
[python/pl] Fix typos, improve the language
This commit is contained in:
Spurlow
commit
d16af7d04c
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user