mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-11-23 14:17:02 +03:00
887cbee8af
Before renaming, all Python 2 filenames were 'learnpython-*.py'.
This commit renames them to 'learnpythonlegacy-*.py'.
To verify that the filenames were named consistently across
translations prior to this commit, and to change this:
```
find . -name "pythonlegacy*.markdown" -exec ack filename: {} \;
find . -name "pythonlegacy*.markdown" -exec \
sed -i 's/^filename: learnpython/filename: learnpythonlegacy/' {} \;
```
641 lines
19 KiB
Markdown
641 lines
19 KiB
Markdown
---
|
|
name: python
|
|
category: language
|
|
language: Python 2 (legacy)
|
|
filename: learnpythonlegacy-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.0
|
|
|
|
# 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)
|
|
|