Python
Stworzony został w latach 90. przez Guido van Rossuma, nazwa zaś pochodzi od tytułu serialu komediowego emitowanego w BBC pt. “Latający cyrk Monty Pythona” ;)
Język programowania wysokiego poziomu ogólnego przeznaczenia, o rozbudowanym pakiecie bibliotek standardowych, którego ideą przewodnią jest czytelność i klarowność kodu źródłowego. Jego składnia cechuje się przejrzystością i zwięzłością. Jego składnia cechuje się przejrzystością i zwięzłością.
Python rozprowadzany jest na otwartej licencji umożliwiając także zastosowanie do zamkniętych komercyjnych projektów.
Python rozwijany jest jako projekt Open Source zarządzany przez Python Software Foundation, która jest organizacją non-profit. Standardową implementacja języka jest CPython (napisany w C), ale istnieją też inne, np. Jython (napisany w Javie), CLPython napisany w Common Lisp, IronPython (na platformę .NET) i PyPy (napisany w Pythonie, zob. bootstrap).
---------------------------------------------------------------------------------------------------------------------------
Kto używa Pythona?
Google, Yahoo, Nokia, IBM czy NASA wykorzystują Pythona w swoich wartych
wiele milionów, czy też miliardów dolarów aplikacjach i projektach.
Microsoft jak i Apple oferują pełne wsparcie dla Pythona w swoich
systemach operacyjnych i platformach programistycznych. Wiele stron
internetowych takich jak YouTube czy Grono napisane jest w Pythonie.
---------------------------------------------------------------------------------------------------------------------------
Gdzie działa Python?
Aplikacje napisane w Pythonie działają pod wieloma systemami takimi jak
Windows, Linux/Unix, Mac OS X, OS/2, Amiga, czy smartphony Palma i
Nokia. Dostępne są także implementacje Pythona w Javie (Jython) i .NET
(IronPython) działające wszędzie tam, gdzie dostępne są te platformy.
---------------------------------------------------------------------------------------------------------------------------
Do czego użyć?
Pythona można wykorzystać do tworzenia serwisów internetowych, aplikacji
desktopowych działających na komputerach użytkowników, wliczając w to
także gry. Można także wykorzystać Pythona w aplikacjach sieciowych, czy
skryptach np. generujących zestawienia i raporty.
Tworzenie dynamicznych stron internetowych jest bardzo łatwe i efektywne dzięki bardzo dobrym frameworkom takim jak Django, Pylons, czy kombajnowi aplikacji Zope/Plone.
Python znalazł zastosowanie przy efektywnym i szybkim tworzeniu
nowoczesnych stron internetowych bogatych w funkcjonalności. Dzięki
wszechstronnej kolekcji modułów i bibliotek serwisy "web 2.0" napisane w
Pythonie mogą łatwiej oferować funkcjonalności znane np. z aplikacji
desktopowych w porównaniu do np. PHP.
Usługi i serwisy społecznościowe to obecnie podstawa dla wielu serwisów www. Za pomocą Pythona bezproblemowo można wykorzystać API/usługi serwisów
takich jak Twitter, Blip.pl, Facebook, aplikacji Google (Maps, Docs i
innych przez GData), czy Google Wave. Przykładowo biblioteka PyFacebook
pozwala w prosty sposób tworzyć aplikacje dla tego serwisu
społecznościowego, a API Google Wave umożliwia tworzenie aplikacji dla
tej platformy, czy integrowanie własnych stron i aplikacji z Wave.
Aplikacje desktopowe działające pod kluczowymi systemami
operacyjnymi (MS Windows, OS X, Linux) można bez problemu pisać także w
Pythonie za pomocą bibliotek takich jak PyQt4, PyGTK, wxPython, czy
wbudowanej biblioteki tk. Za pomocą aplikacji py2exe można stworzyć
gotowe aplikacje (exe) dla systemów MS Windows, a za pomocą py2app
gotowe aplikacje dla OS X.
W zastosowaniach naukowych, czy finansowych skrypty i aplikacje Pythonowe przydają się tam gdzie potrzebne jest przetwarzanie danych i generowanie wykresów,
zestawiań, plików PDF, arkuszy Excela, czy ODT/ODS. Za pomocą Reportlab
wygenerujemy pliki PDF i sformatujemy wszelakie raporty w nim zawarte.
Matplotlib oferuje generowanie wykresów różnego typu. Scipy oferuje
implementacje różnych algorytmów do skomplikowanych obliczeń w Pythonie.
PIL zapewnia obróbkę grafik (jak skalowanie, wyostrzanie, obracanie
itd.), a xlwt i xlrt zapis i odczyt arkuszy Excela.
Gry i aplikacje wykorzystujące 3D też można stworzyć z
wykorzystaniem Pythona. Częstym rozwiązaniem jest udostępnienie w
Pythonie API silnika gry napisanego w C/C++. Takim przykładem jest np.
Świątynia Pierwotnego Zła. W Pythonie mamy dostęp do kilku silników
umożliwiających obsługę grafiki 3D, 2D i pozostałych komponentów
potrzebnych do aplikacji tego typu - PyGame, PyCrystal (API na CrystalSpace), Python-Ogre (API na Ogre 3D), pyopengl (API na OpenGL).
---------------------------------------------------------------------------------------------------------------------------
Instalacja Pythona pod Windows
https://www.python.org/downloads/windows/
---------------------------------------------------------------------------------------------------------------------------
Narzędzie do edycji Pythona
Skrypty Pythona można zapisywać w dowolnym edytorze tekstu, ale oczywiście
wygodniej jest używać programów, które potrafią przynajmniej odpowiednio
podświetlać kod.
PyCharm to profesjonalne, komercyjne środowisko programistyczne dostępne
za darmo do celów szkoleniowych. To IDE doskonale wspiera proces uczenia się. Udostępnia nawigację po kodzie,
podpowiedzi, wykrywa błędy i ma wbudowanych wiele innych udogodnień.
Eclipse + pyDEV
– chyba najlepsza opcja. Edytor Eclipse jest napisany w Javie i wymaga
trochę pamięci, ale jest b. dobry. Posiada intuicyjny interfejs, mnóstwo
pluginów dających spójne środowisko do pracy z javą, pythonem, ruby i
php. pyDEV z zintegrowanym pakietem pyLint
nie tylko podpowiada kod, ale także ma możliwość wyłapania nieużytej
zmiennej, czy brak zgodności stylu programowania z zaleceniem PEP8 itp. Oczywiście jest też zintegrowany debugger.
---------------------------------------------------------------------------------------------------------------------------
Moduły
W Pythonie moduły są po prostu plikami z rozszerzeniem .py, w których zawarto pewien zestaw funkcji.
Instalacja modułu Kiedy nie mamy zainstalowanego modułu mamy wówczas komunikat:
ModuleNotFoundError: No module named 'numpy'
Aby zainstalować należy użyć PIP w wierszy poleceń wpisać:
pip install numpy
Deinstalacja jest podobna.
Tworzenie modułu
Aby stworzyć moduł, wystarczy utworzyć nowy plik z rozszerzeniem .py i nazwą
jaką chcesz nadać swojemu modułowi. Kiedy już skończysz edytować swój
moduł, wystarczy, że go zaimportujesz za pomocą komendy 'import' (bez
rozszerzenia .py).
Importowanie modułu
Moduły importujemy do swojego programu za pomocą komendy import.
Moduły mogą importować inne moduły. Zazwyczaj, wszystkie instrukcje import umieszczane są na początku modułu
(lub skryptu).
Import modułu:
# importowanie biblioteki
import urllib
Za pomocą funkcji dir możemy zobaczyć, jakie funkcje zostały umieszczone w dowolnym module:
>>> import urllib
>>> dir(urllib)
['ContentTooShortError', 'FancyURLopener', 'MAXFTPCACHE', [...] ]
Kiedy już znajdziemy funkcję, której chcemy użyć, możemy dowiedzieć się o niej więcej, używając help w interpreterze Pythona:
help(urllib.urlopen)
--------------------------------------------------------------------------------------------------------------------------- Pakiety
Pakiety są przestrzeniami nazw, które zawierają w
sobie wiele modułów, a nawet innych pakietów. Są po prostu folderami,
ale z pewnym znakiem szczególnym.
Każdy pakiet w Pythonie jest folderem, który musi zawierać specjalny plik nazwany '__init__.py'.
Plik __init__.py są wymagane, aby zmusić Pythona do traktowania
katalogów jako zawierające pakiety. Ten plik może być pusty i służy informowaniu, że ten folder zawiera
pakiet Pythona. Dzięki temu może być importowany tak samo jak moduły.
Jeśli utworzymy folder o nazwie foo, która jest tożsama nazwie pakietu, możemy w nim utworzyć moduł nazwany bar. Nie możemy zapomnieć także dodać pliku __init__.py wewnątrz folderu foo.
Aby używać modułu bar, możemy go zaimportować na dwa sposoby:
import foo.bar
albo:
from foo import bar
W pierwszym przypadku będziemy musieli używać przedrostka 'foo' za każdym razem, gdy będziemy chcieli posłużyć się funkcją oferowaną przez 'bar'. W drugim przypadku nie musimy, ponieważ, zaimportowaliśmy moduł do naszej przestrzeni nazw modułów.
---------------------------------------------------------------------------------------------------------------------------
Import
Istnieją trzy metody wywołania np. metody z pliku pakietu:
- Sposób 1
import pakiet.folder_1.plik_1
a potem cały czas odnosząc się pełną ścieżką wywołać funkcje
pakiet.folder_1.plik_1.funkcja_1_pakietu()
-
Sposób 2
from pakiet.folder_1.folder_2 import plik_2
a potem odnosząc się tylko to nazwy pliku wywołać funkcje
plik_2.funkcja_2_pakietu()
-
Sposób 3
from pakiet.folder_1.folder_2.plik_3 import funkcja_3_pakietu
importujemy bezpośrednio funkcje
funkcja_3_pakietu()
---------------------------------------------------------------------------------------------------------------------------
Nazywanie zmiennych
- Nazwy zmiennych w Pythonie mogą być dowolnie długie.
- Mogą zawierać zarówno małe, jak i
duże litery alfabetu, tak łacińskiego, jak i polskiego.
- Takie same nazwy, ale
napisane małymi bądź dużymi literami, oznaczają różne zmienne.
- Nazwy nie mogą zawierać spacji.
- Cyfry nie mogą rozpoczynać nazwy zmiennej.
- Znak podkreślenia może rozpoczynać nazwę zmiennej,
UWAGA: w języku Python nazwy zaczynające się od "_" mają specjalne znaczenie.
Zmiennym nie można nadawać nazw zastrzeżonych dla instrukcji
języka Python:
and del for
is raise
assert elif from
lambda return
break else
global not try
class except
if or while
continue
exec
import pass yield
def finally
in print
---------------------------------------------------------------------------------------------------------------------------
Zmienne i typy
Python jest językiem obiektowym i każda zmienna w Pythonie jest obiektem.
Liczby (Numbers)
Napisy (String)
Typ logiczny (Bool)
Listy (List)
Krotki (Tuple)
Słowniki (Dictionary)
Liczby
Python obsługuje dwa typy liczbowe – liczby całkowite (ang. integers w skrócie int) i rzeczywiste (float). Obsługiwane są także liczby zespolone.
calkowita = 7
rzeczywista = 7.5
rzeczywista = float(38)
Możliwe jest "jednoczesne" przypisanie wartości kilku różnym zmiennym w tej samej linijce jak w przykładzie poniżej.
a, b = 3, 4
Napisy
Napis (string) jest inicjowany za pomocą pojedyńczego lub podwójnego cudzysłowu.
napis1 = 'witaj'
napis2 = "witaj"
napis 1 == napis2 # zwroci "True"
napis = "Nie martw sie o 'pojedyncze' cudzyslowy."
print "Nigdy nie czytalem 'Potopu'." # Nigdy nie czytalem 'Potopu'.
# Ponizej jak umiescic " w tekscie
print "Nigdy nie czytalem \"Potopu\"." # Nigdy nie czytalem "Potopu".
Po komendzie print umieszczasz napis, który ma zostać wyświetlony.
Oprócz zwykłego tekstu będzie zawierał także specjalne symbole np. %s czy %d. Po cudzysłowie zamykającym napis umieszczasz znak %, a po nim zmienne lub wyrażenia odpowiadające użytym wcześniej symbolom. Zmienne muszą być umieszczone w nawiasach (), chyba że jest tylko jedna zmienna. Wtedy możesz je pominąć.
# To wypisze "Marek ma 23 lata."
imie = "Marek"
wiek = 23
print "%s ma %d lata." % (imie, wiek)
Poniżej znajduje się kilka podstawowych specyfikatorów, których znaczenie dobrze zapamiętać:
%s – Napis (lub każdy inny obiekt, który ma reprezentację w formie napisu, np. liczba, tablica)
%d – Liczby całkowite
%f – Liczby rzeczywiste
%.<ilość cyfr> – Liczba zmiennoprzecinkowa ze stałą liczbą cyfr po kropce.
%x/%X – Liczby całkowite zapisane w systemie szesnastkowym (małe/duże litery)
Funkcja len() informuje nas z jak wielu znaków składa się napis.
napis = "AAA BBB ..."
print len(napis) # 11
Metoda index zwraca numer pierwszego znaku identycznego z tym podanym w
nawiasie. Znaki numerowane są od lewej i od zera, tak samo jak
tablicach.
napis = "abcdeabcde"
print napis.index("a") # 0
print napis.index("d") # 3
Ta metoda sprawdza ile razy w napisie pojawia się znak lub ciąg ujęty w cudzysłów.
napis = "abrakadabra"
print napis.count("a") # 5
print napis.count("ab") # 2
Za pomocą nawiasów kwadratowych możemy uzyskać dostęp do pojedynczego znaku, jeśli znamy jego indeks.
napis = "abcdefghijk"
print napis[2] # c
W ten sposób możemy wypisać interesujący nas fragment napisu.
napis = "abcdefghijklmnop"
print napis[3:7] # defg
Jeśli przed dwukropkiem pozostawisz wolne miejsce, a po nim umieścisz
jakąś liczbę, to otrzymasz fragment od początku do umieszczonego numeru.
Jeśli usuniesz również drugą liczbę, to otrzymasz cały napis.
napis = "abcdefg"
print napis[0:4] # abcd
print napis[:4] # abcd
print napis[::] # Wypisze caly napis
print napis[4:len(napis)] # efg
print napis[4:] # efg
W nawiasach możesz umieścić nawet liczby ujemne. Dzięki temu znaki będą liczone od końca, a nie od początku. To oznacza, że -3 to trzeci znak od końca.
napis = "abcdef"
print napis[-1] # f
print napis[-4:-2] # cd
print napis[-4:] # cdef
print napis[:-2] # abcd
Zamiana wszystkich małe litery w napisie na duże i odwrotnie.
napis = "Witaj"
print napis.upper() # WITAJ
print napis.lower() # witaj
Te fragmenty kodu służą do ustalenia, czy napis zaczyna się lub kończy od danego ciągu znaków.
napis = "Witaj Alu"
print napis.startswith("Witaj") # True
print napis.startswith("Czesc") # False
print napis.endswith("Alu") # True
print napis.endswith("swiecie") # False
To rozbije napis na kilka napisów zebranych razem w tablicy.
napis = "Ala ma kota."
tablica_slow = napis.split(" ")
print tablica_slow # ['Ala', 'ma', 'kota']
Listy
Tablice w Pythonie również nazywane są listami.
tablica = []
tablica.append(1)
tablica.append(2)
tablica.append(3)
print tablica[0] # wypisze 1
print tablica[1] # wypisze 2
print tablica[2] # wypisze 3
# wypisze kolejno 1, 2, 3
for x in tablica:
print x
Listy składane
Listy składane (ang. list comprehension) są potężnym narzędzie, które tworzy nową tablicę na podstawie innej tablicy.
Przykładowo powiedzmy, że potrzebujemy stworzyć nową tablicę liczb całkowitych, które określają długość każdego słowa
napis = 'Odwazny rudy lis przeskoczyl nad spiacym wilczurem'
slowa = napis.split()
dlugosc_slow = [len(slowo) for slowo in slowa]
print dlugosc_slow
Zbiory (tablica)
Zbiór (ang. set) to tablica, w których nie ma dwóch lub więcej identycznych elementów.
Instrukcja set() tworzy zbiór:
zbior = set("Jakiś tam przykładowy tekst")
{'p', 'ś', 'y', 'a', 'm', 'ł', ' ', 't', 'w', 'r', 'i', 'J', 'd', 'o', 'k', 'z', 'e', 's'}
Tworzenie zbioru z listy:
lista = ["dziesięć", "dziesięć", 9, 9, "jedenaście", (0, 0)]
zbior = set(lista)
{'dziesięć', 9, (0, 0), 'jedenaście'}
Łączenie dwóch zbiorów:
zbior1 = set("tekst")
zbior2 = set("tekst jakiś tam")
print(zbior1.union(zbior2))
lub
print(zbior1 | zbior2)
{'j', 's', 'm', 'ś', 'e', 'a', ' ', 'k', 't', 'i'}
Część wspólna dwóch zbiorów
zbior1 = set("tekst")
zbior2 = set("tekst jakiś tam")
print(zbior1.intersection(zbior2))
lub
print(zbior1 & zbior2)
{'k', 'e', 't', 's'}
Różnica dwóch zbiorów
zbior1 = set("tekst")
zbior2 = set("tekst jakiś tam")
print(zbior1.difference(zbior2))
print(zbior2.difference(zbior1))
lub
print(zbior1 - zbior2)
print(zbior2 - zbior1)
{'j', 'ś', 'a', ' ', 'm', 'i'}
Liczba elementów zbioru
zbior = set("jakiś tam tekst")
print(len(zbior))
lub
print(zbior.__len__())
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
10
Kopiowanie zbioru
zbior = set("jakiś tam tekst")
print(zbior)
zbior2 = zbior.copy()
print(zbior2)
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
Opróżnianie zbioru
zbior = set("jakiś tam tekst")
print(zbior)
zbior.clear()
print(zbior)
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
set()
Usuwanie pojedynczego elementu zbioru
zbior = set("jakiś tam tekst")
print(zbior)
zbior.remove("ś")
print(zbior)
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
{'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
Metoda remove ma pewną wadę, a mianowicie taką, że gdy dany element nie istnieje w zbiorze generowany jest paskudny kod błędu. Dlatego też, gdy nie ma pewności, czy dany element istnieje w zbiorze lepiej użyć metody discard, która usuwa dany element, jeśli istnieje on w zbiorze
zbior = set("jakiś tam tekst")
print(zbior)
zbior.discard("ś")
zbior.discard("ś")
print(zbior)
Kolejną metodą, która zwraca i usuwa pierwszy element zbioru jest pop:
zbior = set("jakiś tam tekst")
print(zbior)
print(zbior.pop())
print(zbior)
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
ś
{'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
Metoda pop zwraca błąd, jeżeli zbiór jest pusty.
Dodawanie pojedynczego elementu do zbioru
zbior = set("jakiś tam tekst")
print(zbior)
zbior.add("5")
print(zbior)
{'ś', 'e', 'i', 's', '5', 'a', 'j', 'k', 'm', 't', ' '}
{'ś', 'e', 'i', 's', 'a', 'j', 'k', 'm', 't', ' '}
---------------------------------------------------------------------------------------------------------------------------
Podstawowe operatory
Operatory logiczne
and – oznaczającego, że oba warunki muszą być prawdziwe
or – oznaczającego, że jednen z dwóch warunków musi być spełniony
imie = "Jan"
wiek = 23
if imie == "Jan" and wiek == 23:
print "Nazywasz sie Jan i masz 23 lata."
if imie == "Jan" or imie == "Robert":
print "Nazywasz sie Jan lub Robert"
Operator "in"
Za pomocą operatora "in" możesz sprawdzić, czy konkretny obiekt znajduje
sie w tablicy lub innym obiekcie gromadzącym inne obiekty:
imie = "Robert"
if imie in ["Jan", "Robert"]:
print "Nazywasz sie Jan lub Robert"
Operator "is"
W przeciwieństwie do ==, operator is nie sprawdza, czy zmienne mają taką samą wartość, ale czy wskazują na ten sam obszar w pamięci komputera.
x = [1,2,3]
y = [1,2,3]
print x == y # Wypisze True
print x is y # Wypisze False
Ponieważ tablica i tablica2 odnoszą się do tego samego obiektu, zmiana jednej oznacza zmianę drugiej:
tablica = [1, 2, 3]
tablica2 = ['a', 'b', tablica]
print tablica == tablica2[2] # True
print tablica is tablica2[2] # True
Operator "not"
Używając not przed wyrażeniem logicznym zmieniamy jego wartość na przeciwną:
print not False # Wypisze True
print (not False) == (False) # Wypisze False
---------------------------------------------------------------------------------------------------------------------------
Instrukcje
Instrukcja warunkowa IF
if [...]: [...] elif: [...] else: [...]
if saldo < 0:
print("Saldo poniżej 0, doladuj konto.")
elif saldo == 0:
print("Saldo rowne 0, dodaj srodki.")
else:
print("Saldo wynosi 0 lub wiecej.")
Pętla FOR
for [...] in [...]:
pierwsze = [2,3,5,7]
for pierwsza in pierwsze:
print pierwsza
Pętla WHILE
while [...]:
licznik = 0
while licznik < 5:
print licznik,
licznik += 1
---------------------------------------------------------------------------------------------------------------------------
Funkcje
Funkcje są definiowane z użyciem słowa kluczowego def,
po którym umieszcza się nazwę funkcji, a potem nawiasy. Jeżeli funkcja
nie wymaga informacji z zewnątrz nawiasy pozostawiamy puste.
def przywitanie():
print "Pozdrowienia z mojej funckji!"
def przywitanie_imienne(imie, zyczenia):
print "Witaj" + imie + ". Zycze Tobie " + zyczenia
Aby przerwać działanie funkcji i zwrócić wartość, musisz użyć słowa return, a za nim umieścić zwracaną wartość. Jeżeli pominiesz wartość, to funkcja tylko zakończy swoje działanie i nic nie zwróci.
def dzielenie(dzielna, dzielnik):
if(dzielnik == 0):
return # zakoncz funkcje nic nie zwracajac
else:
return dzielna / dzielnik
# brak argumentow i zwracanej wartosci
przywitanie()
# brak zwracanej wartosci, ale sa juz argumenty
przywitanie_imienne("Jacek", "zdrowia")
# jak przypisac zmiennej wartosc zwrocona przez funkcje
x = dzielenie(9, 3)
Funkcje o zmiennej liczbie argumentów
Możliwe jest również zdefiniowanie funkcji, która otrzymuje zmienną liczbę argumentów:
def foo(pierwszy, drugi, trzeci, *reszta):
print "Pierwszy: %s" % pierwszy
print "Drugi: %s" % drugi
print "Trzeci: %s" % trzeci
print "I cala reszta... %s" % list(reszta)
Tak więc wywołanie foo(1,2,3,4,5) wypisze:
Pierwszy: 1
Drugi: 2
Trzeci: 3
I cala reszta... [4, 5]
Argumenty do funkcji można przesyłać także za pomocą słów-kluczy, dzięki czemu kolejność w jakiej zostały podane argumenty nie ma znaczenia:
def funkcja(pierwszy, drugi, trzeci, **opcje):
if opcje.get("akcja") == "dodaj":
print "Suma to: %d" % (pierwszy + drugi + trzeci)
if opcje.get("zwroc") == "pierwszy":
return pierwszy
wynik = funkcja(1, 2, 3, akcja = "dodaj", zwroc = "pierwszy")
print "Wynik: %d" % wynik
Otrzymamy:
Suma to: 6
Wynik: 1
Funkcje częściowe
Czasami w swoim programie wielokrotnie wywołujemy pewną funkcję z tymi
samymi argumentami. Aby skrócić zapis w takich sytuacjach, stosujemy
funkcje częściowe.
from functools import partial
def mnozenie(x, y):
return x * y
podwojenie = partial(mnozenie, 2)
print podwojenie(6) # 12
print podwojenie(11) # 22
print podwojenie(7) # 14
---------------------------------------------------------------------------------------------------------------------------
Klasy i obiekty
Obiety są połączeniem zmiennych i funkcji w jedną strukturalną całość. Obiekty biorą swoje zmienne i funkcje z klas. Klasy są podstawowym schematem, według których tworzone są obiekty.
Poniżej znajduje się bardzo prosty przykład klasy:
class MojaKlasa:
zmienna = "blah"
def moja_funkcja(self):
print "To jest wiadomość wewnątrz klasy."
Użycie klasy:
mojobiekt = MojaKlasa()
Dostęp do zmiennych obiektu:
mojobiekt.zmienna
Dostęp do funkcji obiektu:
nazwa_obiektu.moja_funkcja()
---------------------------------------------------------------------------------------------------------------------------
Słownik
Słownik jest strukturą danych podobną do tablicy, ale pracuje się na nim
w oparciu o klucze (zwane też hasłami), a nie indeksy. Klucze mogą być
obiektem dowolnego typu (napisy, liczby, tablice itp.).
kontakty = {}
kontakty["Jan"] = 938477566
kontakty["Jacek"] = 938377264
kontakty["Janusz"] = 947662781
lub
kontakty = {
"Jan" : 938477566,
"Jacek" : 938377264,
"Janusz" : 947662781
}
Przeszukiwanie słowników:
for imie, numer in kontakty.iteritems():
print "%s ma numer telefonu: %d" % (imie, numer)
lub
for imie in kontakty:
print "%s ma numer telefonu: %d" % (imie, kontakty[imie])
Usuwanie wartości:
del kontakty["Jan"]
lub
kontakty.pop("Jan")
---------------------------------------------------------------------------------------------------------------------------
Obsługa wyjątków
- Blok try pozwala przetestować a blok kodu dla błędów.
- Blok except pozwala obsłużyć błąd.
- Blok else pozwala wykonaj kod, gdy nie ma błędu.
- Blok finally pozwala wykonaj kod, niezależnie od wyniku bloków try- iexcept.
Możemy użyć raise aby zgłosić wyjątek, jeśli wystąpi warunek. if x < 0:
raise Exception("Sorry, no numbers below zero")
Asercja to kontrola poprawności, którą można włączyć lub wyłączyć po zakończeniu testowania program.
Gdy napotkamy instrukcję asercji,
Python ocenia towarzyszące jej wyrażenie. Jeśli wyrażenie ma wartość false, Python zgłasza wyjątek AssertionError
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32
AssertionError: Colder than absolute zero!
Gdy wystąpi błąd lub wyjątek, jak go nazywamy, Python zwykle zatrzymuje się i wygenerować komunikat o błędzie.
try:
...
except:
print("An exception occurred")
Możesz zdefiniować dowolną liczbę bloków wyjątków:
try:
linux_interaction()
with open('file.log') as file:
read_data = file.read()
except FileNotFoundError as fnf_error:
print(fnf_error)
except AssertionError as error:
print(error)
W Pythonie, używając instrukcji else, możesz nakazać programowi wykonanie określonego bloku kodu w przypadku braku wyjątków.
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
Kiedy musisz zaimplementować jakąś akcję, aby posprzątać po wykonaniu kodu python umożliwia to za pomocą klauzuli finally.
try:
print(x)
except:
print("Something went wrong")
finally:
print("The 'try except' is finished")
Pomijanie wyjątku (pass):
try:
linux_interaction()
except:
pass
---------------------------------------------------------------------------------------------------------------------------
Uruchamianie kodu
Sposób 1 - IDLE
Po zaintalowaniu pythona uruchom IDLE (Python [version] X-bit).
Otwórz plik pythona z kodem.
Wybierz z menu Run -> Run module
Sposób 2 - Wiersz poleceń (Command Prompt)
Otwórz wiersz poleceń i przejdź do foldera w którym jest plik pythona.
Wpisz : [path]>python plik_python.py
---------------------------------------------------------------------------------------------------------------------------
Kursy Pythona
http://www.python.rk.edu.pl/w/p/podstawy/
https://www.learnpython.org/pl/
https://www.w3schools.com/python/default.asp
