Kod, czyli jak się bawić własnymi zabawkami

Kilka najprostszych instrukcji zostało wprowadzonych w rozdziale 5. dotyczącym interpretera. Za ich pomocą potrafimy już zapamiętywać wartości obliczanych wyrażeń oraz korzystać z czynności złożonych znając ich nazwy.

W bieżącym rozdziale znajomość instrukcji zostanie rozszerzona: w pierwszej kolejności usystematyzujemy znajomość instrukcji prostych. Następnie wprowadzimy instrukcje pozwalające zarządzać wykonywaniem innych instrukcji. Bez tej możliwości programowanie sprowadzałoby się do pisania długich i nudnych ciągów poleceń wykonywanych w tej samej kolejności, w jakiej zostały napisane. To właśnie instrukcje sterujące przesądzają o potędze automatycznego przetwarzania.

Instrukcje

Podsumujemy naszą dotychczasową wiedzę o instrukcjach. Ich podstawową rolą jest wyrażanie poleceń. Instrukcje są przeznaczone do wykonywania w ustalonej kolejności; mogą też być w różnych celach grupowane.

Instrukcje proste

Instrukcji proste opisują pojedyncze niezwiązane ze sobą polecenia. Służyły nam one do:

• tworzenia nowych zmiennych i nadawania im wartości

  zmienna = wartość	# obliczona wartość wyrażenia zostanie zapamiętana w zmiennej
  

• usuwania zmiennych

  del zmienna		# instrukcja del usuwa wskazaną zmienną
  

• modyfikowania wartości istniejących zmiennych:

  zmienna = wartość	# zastąpienie istniejącej wartości zmiennej nową wartością
  zmienna += wartość
  zmienna -= wartość
  zmienna *= wartość
  zmienna /= wartość

• obliczania wartości wyrażeń, bez zapamiętywania ich gdziekolwiek

  input('naciśnij Enter...')	# wstrzymanie pracy programu terminalowego
  plik.readline()			# przeczytanie wiersza pliku bez zapamiętywania go, 
  				# a jedynie w celu przesunięcia głowicy do początku następnego wiersza
  

• korzystania z dostępnych poleceń i funkcji, np.

  max([a,b,c])			# funkcja max() wyznacza największy element ciągu
  y = 1 + math.sin(2*x)		# funkcja sin() z modułu math oblicza wartość sinusa
  dane2 = sorted(dane)		# funkcja sorted() zwraca ten sam ciąg po uporządkowaniu jego elementów
  

• korzystania z metod będących właściwościami obiektów, np.

  print(napis.title()	# metoda title() przekształca tekst tak, by każde jego słowo rozpoczynało się z wielkiej litery
  dane.sort()			# metoda sort() porządkuje ciąg danych
  

Instrukcja pusta pass nie powoduje żadnej akcji. Przydaje się w sytuacjach szczególnych.

Instrukcje sterujące

Do zarządzania przebiegiem programu, a w szczególności do decydowania o wykonywaniu innych instrukcji, służą instrukcje sterujące. Należą do nich przede wszystkim:

• instrukcje warunkowe,
• instrukcje iteracji,
• instrukcje deklaracji podprogramów,
• instrukcje obsługi wyjątków.

Pierwsze trzy typy instrukcji sterujących zostaną omówione w kolejnych podrozdziałach. Obsługi wyjątków nie będziemy szczegółowo omawiać; wstępne objaśnienia zamieszczamy w podrozdziale 8.4.

Każda instrukcja sterująca Pythona kończy się dwukropkiem. O zasięgu grupowania decydują wcięcia następujących po niej instrukcji. Blok instrukcji podrzędnych składa się z instrukcji wciętych głębiej, niż instrukcja sterująca.

ta instrukcja:
    grupuje
    instrukcje
    podrzędne
    takie grupowanie:
	może
	być
	wielopoziomowe
    chociaż wcale nie musi
grupowanie:
    zawsze powinno czemuś służyć:
	np. wykonaniu warunkowemu
	lub powtarzaniu czynności
    zawsze się gdzieś kończy
    # choćby na końcu pliku

Głębokość wcięć jest dowolna, ale na danym poziomie grupowania instrukcji musi być taka sama, a na głębszym — większa. Mieszanie wcięć robionych za pomocą spacji i znaków tabulacji nie jest rozsądne. Stosujmy albo jedno, albo drugie.

Wiersze nie zawierające instrukcji są traktowane jak nieistniejące i mogą zawierać dowolne wcięcia.

Blok instrukcji podrzędnych nie może być pusty. Jeżeli z jakichś względów chcemy, by nie zawierał on żadnej sensownej instrukcji, możemy umieścić w nim instrukcję pustą pass.

Instrukcje warunkowe

Często zachodzi potrzeba zdecydowania o kierunku dalszego działania na podstawie szczegółów zaistniałej sytuacji. Wtedy przydaje się konstrukcja algorytmiczna, która analizuje zadany warunek lub układ warunków i uzależnia od jego wyników wybór dalszej ścieżki postępowania. W większości języków programowania konstrukcja taka ma postać instrukcji warunkowej. W niektórych językach istnieje również możliwość użycia wyrażeń warunkowych.

Składnię instrukcji warunkowej w Pythonie można nieformalnie opisać w następujący sposób:

if warunek:
    ...
elif warunek:
    ...
else:
    ...

W instrukcji warunkowej występuje:

• dokładnie jedna fraza if,
• dowolnie wiele fraz elif,
• co najwyżej jedna fraza else,
• instrukcje podrzędne zgrupowane we wciętych blokach kodu.

""" instrukcja warunkowa
widzisz, dlaczego wcięcia są ważne?
"""
if (warunek1):
    wykonaj
    te instrukcje
    w przypadku
    spełnienia warunku warunek1
elif (warunek2):
    wykonaj
    te instrukcje
    w przypadku niespełnienia wyrażenia warunek1
    i spełnienia wyrażenia warunek2
else:
    wykonaj
    te instrukcje
    w przypadku
    niespełnienia żadnego warunku

Warunki następujące po słowach if oraz elif powinny być wyrażeniami typu logicznego. Jeżeli tak nie jest, dokonywana jest ich konwersja do typu logicznego.

Łączenie instrukcji warunkowych

W bieżącym podrozdziale pokażemy na kilka sytuacji, które wymagają radzenia sobie z układami warunków. Zależnie od wzajemnych związków między tymi warunkami, albo będziemy sprawdzać je niezależnie, albo alternatywnie, albo przez zagnieżdżanie instrukcji warunkowych.

Techniki zilustrowane w poniższych przykładach są wspólne dla wszystkich metod opisu algorytmów, nie tylko dla języków programowania, a w szczególności nie tylko dla Pythona.

Niezależne sprawdzanie warunków

Mamy dane: wzrost osobnika w metrach i wiek w latach. Chcemy wygenerować raport, w którym dokonana będzie (umowna) klasyfikacja wzrostu: wysoki/niski i wielu: młody/stary.

Pojedyncza klasyfikacja polega w tym przypadku na porównaniu wartości testowanej z pojedynczą wartością graniczną. Każdą klasyfikację przeprowadzamy za pomocą instrukcji warunkowej niezależnie od klasyfikacji innych kryteriów.

if wzrost < progWzr:
    klasaWzrost = 'niski'
else:
    klasaWzrost = 'wysoki'

if wiek < progWiek:
    klasaWiek = 'młody'
else:
    klasaWiek = 'stary'

Odrębne sprawdzanie warunków wzrost < progWzr i wzrost >= progWzr jest niepożądane, gdyż dopełniają się one wzajemnie; ze spełnienia jednego wynika niespełnienie drugiego. Stąd użycie frazy else.

W poniższym przykładzie sprawdza się niepotrzebnie i warunek, i jego zaprzeczenie:

if wzrost < progWzr:
    klasaWzrost = 'niski'
if wzrost >= progWzr:
    klasaWzrost = 'wysoki'

W poniższym przykładzie obie instrukcje warunkowe są potrzebne, gdyż w obrębie pierwszej zachodzi modyfikacja zmiennej, która może mieć wpływ na wartość drugiego warunku.

if ciezar < wagaDopuszczalna:
    ciezar += przedmiot
if ciezar >= wagaDopuszczalna:
    print('Za ciężko')

Sprawdzanie warunków wzajemnie się wykluczających

Mamy za zadanie zaklasyfikować wzrost osobnika jako niski, średni, wysoki lub bardzo wysoki. Dysponujemy wartościami progowymi rozdzielającymi poszczególne grupy. Z uwagi na fakt, że klasy wzrostu są rozłącznymi przedziałami na osi liczbowej, będziemy sprawdzać spełnienie pojedynczych nierówności za pomocą fraz elif.

if wzrost < prog1:
    klasaWzrost = 'niski'
elif wzrost < prog2:
    klasaWzrost = 'średni'
elif wzrost < prog3:
    klasaWzrost = 'wysoki'
else:
    klasaWzrost = 'bardzo wysoki'

W poniższym przykładzie sprawdza się za dużo:

if wzrost < prog1:
    klasaWzrost = 'niski'
elif prog1 <= wzrost < prog2:
    klasaWzrost = 'średni'
elif prog2 <= wzrost < prog3:
    klasaWzrost = 'wysoki'
else:
    klasaWzrost = 'bardzo wysoki'

Kolejność sprawdzania ma wpływ na liczbę niezbędnych porównań, co widać zwłaszcza przy dużej liczbie wartości progowych. Wtedy lepiej skorzystać z profesjonalnego algorytmu wyszukiwania. Nie będziemy rozwijać tego tematu w tym miejscu.

Zagnieżdżenia instrukcji warunkowych

W ostatnim przykładzie znów dysponujemy wzrostem i wiekiem, ale progi decydujące o klasie wzrostu mamy zastosować wyłącznie dla osobników dojrzałych. Zatem klasyfikację dotyczącą wzrostu zagnieżdżamy w instrukcji warunkowej dotyczącej klasyfikacji wieku.

if wiek < progWiek:
    klasaWzrost = None
    klasaWiek = 'młody'
else:
    if wzrost < prog1:
	klasaWzrost = 'niski'
    elif wzrost < prog2:
	klasaWzrost = 'średni'
    elif wzrost < prog3:
	klasaWzrost = 'wysoki'
    else:
	klasaWzrost = 'bardzo wysoki'    
    klasaWiek = 'stary'

Analogicznie należałoby postąpić, gdyby progi klasyfikacyjne jednej cechy (np. masy ciała) zależały od wyniku klasyfikacji innej cechy (np. wieku osobnika).

W poniższym przykładzie autor kodu nie przeprowadził rzetelnej analizy układu warunków, skutkiem czego instrukcja jest skomplikowana, nieczytelna i trudna do przebudowy:

if wiek < progWiek:
    klasaWzrost = None
    klasaWiek = 'młody'
elif wiek >= progWiek and wzrost < prog1:
    klasaWzrost = 'niski'
    klasaWiek = 'stary'
elif wiek >= progWiek and  wzrost < prog2:
    klasaWzrost = 'średni'
    klasaWiek = 'stary'
elif wiek >= progWiek and wzrost < prog3:
    klasaWzrost = 'wysoki'
    klasaWiek = 'stary'
else:
    klasaWzrost = 'bardzo wysoki'    
    klasaWiek = 'stary'

Dalsze przykłady

Instrukcje iteracji

Sumując elementy danego zbioru lub ciągu, musimy powtórzyć czynność dodawania tyle razy, ile elementów ma ten zbiór czy też ciąg. Poszukując rozwiązania pewnego problemu metodą kolejnych przybliżeń, musimy powtarzać te same proste operacje tak długo, aż przekonamy się, że osiągnęliśmy dostatecznie dobre rozwiązanie. W obu tych sytuacjach zachodzi konieczność wielokrotnego wykonania tych samych operacji, przy czym w pierwszej z nich liczba koniecznych powtórzeń jest z góry wiadoma, zaś w drugiej — nie.

Instrukcje iteracji umożliwiają:

• wielokrotne powtarzanie raz zapisanego ciągu instrukcji,
• skończony opis przetwarzania danych niezależnie od ich długości.

Iteracje są jednym z najważniejszych mechanizmów sterowania. Rozważmy różnice między następującymi przykładami ciągów poleceń wyrażonymi w języku naturalnym:

• wrzuć łopatę węgla do piwnicy; wrzuć łopatę węgla do piwnicy; wrzuć łopatę węgla do piwnicy;
• wykonaj trzy razy: wrzuć łopatę węgla do piwnicy;
• niech n = 10; wykonaj n razy: wrzuć łopatę węgla do piwnicy;
• dopóki przed wsypem leży węgiel, powtarzaj: wrzuć łopatę węgla do piwnicy;

W pierwszym opisie nie użyto techniki iteracji. W pozostałych iteracja jest stosowana, przy czym powtarzanie odbywa się, tak jak w wariantach drugim i trzecim, ustaloną liczbę razy, albo tak jak w wariancie ostatnim, tak długo, jak długo spełniony jest warunek, którego sprawdzenie następuje przed każdorazowym powtórzeniem czynności.

Większość języków programowania, w tym Python, ma instrukcje opisujące oba warianty iteracji.

Przebieganie zbioru elementów dowolnej listy

for element in lista:
    wykonaj te instrukcje
    po kolei 
    dla każdego
    elementu listy
else:
    wykonaj te instrukcje
    jeden raz 
    po zakończeniu iteracji, 
    o ile nie przerwano jej
    instrukcją break

Fraza else: i następujący po niej blok nie są obowiązkowe.

Przykład

Przebieganie zbioru kolejnych liczb całkowitych

Funkcja range() zwraca listę składającą się z kolejnych liczb całkowitych.

Najprostsza postać użycia range(n) z jednym argumentem typu całkowitoliczbowego daje ciąg liczb od 0 do n−1 włącznie.

range(1)
[0]
range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
k = 4
range(k)
[0, 1, 2, 3]
range(2*k)
[0, 1, 2, 3, 4, 5, 6, 7]

Nieco inne użycie funkcji range(poczatek, stop) pozwala rozpocząć numerację od wskazanej liczby całkowitej poczatek i zakończyć ją na wartości stop−1:

range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
k = 4
range(1, k)
[1, 2, 3]
range(k, 2*k)
[4, 5, 6, 7]

Jeżeli zachodzi potrzeba numerowania przebiegów iteracji, to wykorzystanie pętli for przebiegającej listę range() jest najlepszym rozwiązaniem.

for element in range(liczba):
    wykonaj te instrukcje liczba razy, 
    przy czym zmienna element przy każdym powtórzeniu
    będzie przyjmować kolejną wartość całkowitą
    z zakresu od 0 do liczba−1

for element in range(poczatek, stop):
    wykonaj te instrukcje stop−poczatek razy, 
    przy czym zmienna element przy każdym powtórzeniu
    będzie przyjmować kolejną wartość całkowitą
    z zakresu od poczatek do stop−1

Z pętli sterowanej za pomocą listy range winniśmy korzystać za każdym razem, kiedy istotne są nie tylko wartości, ale i numery porządkowe elementów ciągu. Jest tak np. w sytuacjach, kiedy interesuje nas modyfikacja elementów listy, kiedy działamy na dwóch listach jednocześnie, kiedy chcemy mieć dostęp do elementu poprzedzającego element bieżący, itp.

Przykład

Przebieganie list złożonych

W sytuacji, kiedy iterowana struktura składa się z list (np. kiedy jest listą punktów, listą wektorów albo innych obiektów), zmienna sterująca iteracji for przyjmuje wartości będące listami. Dostęp do jej elementów uzyskamy pobierając jej pierwszy, drugi i następne składniki.

Operację tę można uprościć, zmieniając postać zmiennej sterującej. Zamiast nadawać jej nazwę, opiszemy ją jako listę zbudowaną z nazwanych elementów.

Generowanie list

Utworzenie listy zawierającej ciąg obliczonych przez nas wartości przebiegać może według następującego schematu: najpierw tworzy się pustą listę, a potem po kolei dołącza się do niej następne elementy. Jeżeli są one wszystkie tworzone w ten sam sposób, warto wykorzystać instrukcję iteracji for.

Tym sposobem w przykładzie poniżej tworzona jest lista kwadraty zawierająca drugie potęgi kolejnych liczb całkowitych od 1 do 10.

kwadraty = []
for i in range(1, 11):
    kwadraty.append(i**2)

print(kwadraty)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Dla informacji, że instrukcja nie została zakończona, zgłoszenie interpretera przybiera postać ... zamiast >>>. Wstawienie pustego wiersza powoduje zakończenie wciętego bloku, tym samym zamknięcie ciała instrukcji iteracji i powrót do zwykłego zgłoszenia >>>.

Iteracje for: niekoniecznie na podstawie listy

We wszystkich dotychczasowych przykładach użycia pętli for zakładaliśmy, że wykorzystuje ona listę elementów. Jest to pewne uproszczenie. Python nie wymaga, by kolekcja obiektów „odwiedzanych” w trakcie iteracji for była listą. W dokumentacji języka jest mowa o obiektach iterowalnych (iterables), tj. takich, których elementy składowe da się ustawić w ciąg. Oczywiście listy są iterowalne; oprócz tego do typów iterowalnych należą napisy i krotki, a także pliki, zbiory i słowniki. Typy te były wspomniane w podrozdziale 6.5.

Jeżeli ponadto elementy danego obiektu wolno numerować liczbami całkowitymi — jest tak np. w listach, napisach i krotkach; nie jest zaś w plikach, zbiorach i słownikach; dokumentacja Python mówi o typach „indeksowalnych” (scriptable) — to do iteracji można wykorzystać listę ich numerów, utworzoną za pomocą funkcji range().

Iteracja sterowana warunkiem

Iteracje for są związane z przetwarzaniem elementów danego ciągu. Czasami nie jest to naturalne podejście. W innym ważnym modelu iteracji instrukcje powtarzane są tak długo, jak długo spełniony jest pewien warunek.

Iteracje tego typu są w Pythonie opisywane za pomocą instrukcji while. Warunek jest sprawdzany każdorazowo przed przystąpieniem do wykonywania instrukcji podległych.

while warunek:
    wykonuj te instrukcje
    tak długo, jak długo 
    sprawdzanie wartości warunku 
    daje wynik True
else:
    wykonaj te instrukcje
    jeden raz 
    po zakończeniu iteracji, 
    o ile nie przerwano jej
    instrukcją break

Pętla while nie potrzebuje żadnej listy ani żadnego licznika. Nic nie stoi na przeszkodzie, by w razie potrzeby użyć w niej własnej konstrukcji do zliczania przebiegów iteracji.

Przykłady

Przykład

Wyczerpywanie losowych porcji z zasobnika.

Przykład

Metoda bisekcji (więcej szczegółów w rozdziale 9.)

Zagnieżdżanie instrukcji sterujących

Przykład: sumowanie dodatnich elementów ciągu

Warunek wewnątrz pętli

Przykład: znajdowanie położenia największych elementów w każdym wierszu macierzy

Pętla i układ warunków wewnątrz pętli

Główna pętla sterująca programem

Typowy program użytkowy oczekuje na zlecenie od operatora, po czym interpretuje otrzymaną komendę i wykonuje ją. Taki cykl powtarza się aż do chwili, kiedy operator wyda polecenie zakończenia pracy.

Do tego modelu działania „pasuje” pętla sterowana warunkiem; w Pythonie jest to pętla while.

opcja = -1
while opcja != 0:
    opcja = wywołaj funkcję decyzyjną
    wykonaj czynność określoną dla wybranej opcji

Pętla taka zakończy się, kiedy funkcja decyzyjna zwróci wartość 0, po wykonaniu czynności przewidzianych na tę okoliczność.

Bywa, że warunkiem sterującym takiej pętli jest True, zaś zakończenie działania wymusza się jawnym wywołaniem funkcji exit() w odpowiednim miejscu.

Poniższy przykład przedstawia szkic aplikacji sterowanej dialogiem z modułu easygui (patrz podrozdział 11.1.4).

Bardziej eleganckie rozwiązanie podobnego zagadnienia przestawimy w końcowej sekcji podrozdziału 7.6.8, jako ilustrację zastosowania podprogramów.

Podprogramy, czyli wymyślanie nowych zabaw

• Deklaracja podprogramu tworzy nową instrukcję opisującą czynność złożoną
  • co umożliwia wielokrotne użycie kodu w różnych miejscach bez przepisywania i kopiowania
  • i ukrywa „szczegóły techniczne” — przez co zwiększa się czytelność kodu
• Zadeklarowanie podprogramu umożliwia jego użycie w wyrażeniu lub w instrukcji wywołania
• Podprogramy mają nazwę i listę argumentów
  • co pozwala wykonywać tę samą czynność na różnych obiektach
  • argumentami wywołania podprogramu mogą być
    • wartości stałe
    • zmienne
    • nazwy czynności (czyli nazwy innych podprogramów)
    • inne obiekty
• Korzystanie z podprogramów pozwala przejść z poziomu „wysokiego” na poziom na „bardzo wysoki”

def nazwa(argumenty):
    wykonaj te instrukcje za każdym razem w przypadku
    wywołania funkcji nazwa z konkretnymi wartościami 
    argumentów przekazanymi w instrukcji wywołującej
    return wynik

Jeżeli podprogram ma być używany bez przekazywania mu argumentów, to nawias w nagłówku powinien być pusty — ale nie wolno go pominąć.

Instrukcja return powoduje zakończenie wykonywania podprogramu i przekazuje sterowanie do miejsca, z którego został on wywołany.

Instrukcja return bez argumentu jest równoważna return None. Jeżeli podczas wykonywania kodu podprogramu nie dojdzie do wykonania instrukcji return, to wynikiem jest None — tak samo, jakby ostatnią instrukcją w podprogramie była return None.

Analogia: okienko napraw w punkcie usługowym. Pracownik pozostaje w gotowości świadczenia usługi; klient wymusza usługę swoją decyzją. Pracownik zna swoją pracę; klient nie ma wglądu w tok jego czynności. Z punktu widzenia klienta efektem naprawy jest przywrócenie określonych wartości użytkowych towaru, będące przedmiotem zlecenia (mamy tu zgodność wyniku działania z jego specyfikacją). Pracownik pracuje z anonimowym „towarem do naprawy”; dla klienta przekazany towar jest rozpoznawalny. Pracownik oddaje przez okienko „towar do wydania” (return); klient odbiera swój towar. Pracownik nie wie, co klient zrobi z odebranym towarem, i nie ma na to wpływu.

Samo zadeklarowanie podprogramu sprawia jedynie, że jest on do dyspozycji autora kodu. Instrukcja używająca zadeklarowanego podprogramu nosi nazwę instrukcji wywołania. Postać wywołania zależy od sposobu zadeklarowania podprogramu, od sposobu w jaki wykonuje on swoją pracę, wreszcie od potrzeb.

Funkcje

Rodzaj podprogramów zwany funkcjami charakteryzuje się istnieniem wartości wynikowej, podobnie jak to jest z funkcjami w sensie matematycznym.

W Pythonie wartość wynikowa funkcji jest deklarowana za pomocą instrukcji return wartość.

def odleglosc(x, y):
    """ oblicza długość wektora XY na płaszczyźnie """
    return math.sqrt((x[0]-y[0])**2 + (x[1]-y[1])**2)

def odlegloscRn(x, y):
    """ oblicza długość wektora XY o dowolnej liczbie współrzędnych """
    if len(x) != len(y):
	return None
    suma = 0.0
    for i in range(len(x)):
	suma += (x[i]-y[i])**2
    return math.sqrt(suma)

Podstawowy sposób korzystania z funkcji polega na używaniu ich w obliczanych wyrażeniach. W takim przypadku następuje wywołanie funkcji, a wynik jest wstawiany w to miejsce w wyrażeniu, z którego nastąpiło wywołanie.

ab = odleglosc(punktA, punktB)
ac = odleglosc(punktA, punktC)
oc = odleglosc([0.0, 0.0], punktC)

Wynik funkcji może być dowolnym obiektem, nawet bardzo skomplikowanym.

Funkcji Pythona można także używać jako poleceń, „gubiąc” wynik (ma to sens, o ile funkcja oprócz obliczenia wyniku, „przy okazji” robi jeszcze coś sensownego — w informatyce nazywa się to „efektem ubocznym”).

plik = open(nazwa)
plik.readline()		# pomijamy nieistotny dla nas wiersz przy czytaniu pliku, przesuwając czytnik do początku następnego wiersza
plik.readline()		# drugi wiersz pomijamy podobnie jak pierwszy
dane = plik.readline()	# pobieramy zawartość trzeciego wiersza pliku do zmiennej dane

Procedury

Terminem procedura określa się podprogramy, które nie mają wartości wynikowej

def zapiszWektor(x, nazwa):
    """ zapisuje wektor x do pliku o wskazanej nazwie """
    plik = open(nazwa, 'w')
    for element in x:
	plik.write(str(element)+'\n')
    plik.close()

Deklaracje takich podprogramów są definicjami czynności złożonych lub zależnych od parametrów, zaś każde wywołanie jest rozkazem wykonania w danym momencie uprzednio zadeklarowanej czynności. Tym samym nazwy podprogramów stają się instrukcjami wyższego poziomu.

zapiszWektor([1.0, -3.5, 12.4, 3.1], 'dane1.txt')
a = [-1, 3, 5, -2.17, 81.4]
zapiszWektor(a, 'dane2.txt')
zapiszWektor(['kura', 'koza', 'małpa', 'nic'], 'slowa')

W Pythonie każda procedura jest funkcją o wyniku None. Myślmy o funkcji, kiedy efekt jej działania jest zwracany jako wynik, i o procedurze, kiedy bardziej liczy się jej działanie zewnętrzne.

W innych językach programowania różnice między funkcjami (których wywołanie jest wyrażeniem) a procedurami (których wywołanie jest instrukcją) mogą być wyraźniejsze.

Metody

Szczególny rodzaj podprogramów wiąże się z obiektowym traktowaniem danych.

Funkcje lub procedury, przypisane do konkretnych obiektów i będące ich „właściwościami” noszą w programowaniu nazwę metod.

Wywołanie metody ma w Pythonie postać wynik = nazwaobiektu.nazwametody(argumenty) (o ile jest ona funkcją), lub nazwaobiektu.nazwametody(argumenty) (o ile jest ona procedurą), np.

# użyj metody readline() należącej do obiektu plik, a wynik umieść w zmiennej o nazwie tekst
tekst = plik.readline()	

# użyj metody write() należącej do obiektu plik, i przekaż jej argument tekst
plik.write(tekst)

# użyj metody close() należącej do obiektu plik
plik.close()

# użyj metody encode() z parametrem kodowanie należącej do obiektu napis, a wynik umieść w zmiennej napis 
# (dotychczasowa wartość napis zostanie utracona)
napis = napis.encode(kodowanie)

Deklarowanie przez autora programu własnych metod jest możliwe, lecz w podstawowym kursie nie omówimy wyczerpująco tego zagadnienia. Pewne wskazówki są zawarte w podrozdziale 10.5. poświęconym tworzeniu własnych typów obiektowych. Podrozdział ten ma charakter uzupełniający.

Dokumentowanie podprogramów

We wszystkich podanych przez nas przykładach bezpośrednio po deklaracji podprogramu rozpoczynającej się słowem kluczowym def znajduje się tekst w cudzysłowach. Nie jest to przypadek. W programie Pythona występujące samodzielnie stałe tekstowe pełnią rolę komentarza. Dodatkowa konwencja zakłada, że taka stała umieszczona zaraz po nagłówku deklaracji podprogramu zawiera dokumentację jego użycia. Jest ona pokazywana w systemach pomocy, z których najbardziej elementarnym jest polecenie help().

Do tego typu komentarzy stosowana bywa nazwa napis dokumentujący lub docstring.

Po zdefiniowaniu procedury zapiszWektor(x, nazwa) zgodnie z deklaracją zamieszczoną w podrozdziale 7.6.2, możemy zapytać o sposób jej użycia:

help(zapiszWektor)
Help on function zapiszWektor in module __main__:

zapiszWektor(x, nazwa)
    zapisuje wektor x do pliku o wskazanej nazwie
(END)  
>>>

Uwagi o wywoływaniu podprogramów

W wywołaniu podprogramu po nazwie podprogramu muszą wystąpić nawiasy z argumentami. W najprostszym przypadku liczba argumentów musi być taka sama, jak zadeklarowana w nagłówku podprogramu (istnieją sposoby deklaracji podprogramów umożliwiające bardziej elastyczne traktowanie parametrów; nie będziemy ich szczegółowo omawiać). Jeżeli w danym wywołaniu argumentów się nie podaje, to nawiasy powinny pozostać puste.

import datetime

def dzisiaj():
    return str(datetime.date.today())	# OK

print(dzisiaj())		# OK: wywołanie bez argumentów

import datetime

def dzisiaj():
    return str(datetime.date.today())	# OK

print(dzisiaj)		# błąd rzeczowy: dzisiaj jest podprogramem, a nie zmienną; zobaczysz adres liczbowy tego podprogramu

def dodaj(a, b):
    return a + b

print(dodaj(1, 3.5))	# OK: działanie liczba + liczba
print(dodaj('Ala ',' ma kota'))	# OK: tekst + tekst

def dodaj(a, b):
    return a + b

print(dodaj(1, 3.5, 2))	# błąd: dodaj() wymaga 2 argumentów
print(dodaj('Ala ', 3))	# błąd: dodawanie liczba + tekst

Podprogram powinien być zadeklarowany w pliku źródłowym w taki sposób, by jego deklaracja została wczytana przed pierwszym jego wywołaniem. W programie linearnym (bez warunków i iteracji) znaczy to, że deklaracja musi się znajdować przed pierwszą instrukcją wywołania.

def f(a):
    return a**2

x = 1.0
y = f(x)	# OK: f() zdefiniowano wcześniej

x = 1.0
y = f(x)	# błąd: w tym miejscu nie wiadomo, co to jest f()

def f(a):
    return a**2

def f(a):
    return a**2

def g(a):
    return f(2*a)+1	# OK: deklaracja g() korzysta z f()
    
x = 1.0
y = g(x)	# OK: g() i f() są znane w tym miejscu

def f(a):
    return a**2

x = 1.0
y = g(x)	# błąd: w tym miejscu nie wiadomo, co to jest g()

def g(a):
    return f(2*a)+1	# OK: deklaracja g() korzysta z f()

def g(a):
    return f(2*a)+1	# OK: deklaracja g() korzysta z f()
			# w tym miejscu nie wiadomo co to 
			# jest f(), ale nikt jej jeszcze 
			# nie każe wywoływać

def f(a):
    return a**2

    
x = 1.0
y = g(x)	# OK: g() i f() są znane w tym miejscu

def g(a):
    return f(2*a)+1	# OK: deklaracja g() korzysta z f()
			# w tym miejscu nie wiadomo co to 
			# jest f(), ale nikt jej jeszcze 
			# nie każe wywoływać
x = 1.0
y = g(x)	# błąd: w tym miejscu znamy g(), ale nie możemy
		# jej obliczyć, bo nie znamy f()

def f(a):
    return a**2

Podprogramy zadeklarowane w modułach można wywołać w dowolnym miejscu kodu po zaimportowaniu modułu.

import datetime

def dzisiaj():
    return str(datetime.date.today())	# OK: datetime jest wczytany, 
					# chociaż nie musi

print(dzisiaj())			# OK: datetime jest wczytany

def dzisiaj():
    return str(datetime.date.today())	# OK: datetime nie musi 
					# być wczytany w tym miejscu

import datetime
print(dzisiaj())			# OK: datetime jest wczytany

def dzisiaj():
    return str(datetime.date.today())	# OK: datetime nie musi 
					# być wczytany w tym miejscu

print(dzisiaj())		# błąd: nie wczytano modułu datetime
import datetime

Jeżeli podprogram jest zadeklarowany w obrębie innego podprogramu, to nie da się go używać „na zewnątrz”. Ta sama reguła dotyczy także obiektów przechowujących dane.

def cosinus(a, b):
    """ oblicza cosinus kąta między wektorami na płaszczyźnie """
    # OK: deklaruje lokalne funkcje pomocnicze dlugosc() i iloczyn()

    def dlugosc(x):
	return (x[0]**2 + x[1]**2)**0.5

    def iloczyn(x, y):
	return x[0]*y[0] + x[1]*y[1]

    m = dlugosc(a)*dlugosc(b)
    if m != 0.0:
	return iloczyn(a, b)/m

print(cosinus([1,0], [0,1]))	# OK

def cosinus(a, b):
    """ oblicza cosinus kąta między wektorami na płaszczyźnie """
    # OK: deklaruje lokalne funkcje pomocnicze dlugosc() i iloczyn()

    def dlugosc(x):
	return (x[0]**2 + x[1]**2)**0.5

    def iloczyn(x, y):
	return x[0]*y[0] + x[1]*y[1]

    m = dlugosc(a)*dlugosc(b)
    if m != 0.0:
	return iloczyn(a, b)/m

print(cosinus([1,0], [0,1]))	# OK
print(dlugosc([1,0]))	# na tym poziomie nie wiemy co to jest dlugosc()

def dlugosc(x):
    return (x[0]**2 + x[1]**2)**0.5

def iloczyn(x, y):
    return x[0]*y[0] + x[1]*y[1]

def cosinus(a, b):
    """ oblicza cosinus kąta między wektorami na płaszczyźnie """
    # OK: korzysta z zewnętrznych funkcji dlugosc() i iloczyn()
    m = dlugosc(a)*dlugosc(b)
    if m != 0.0:
	return iloczyn(a, b)/m

print(cosinus([1,0], [0,1]))	# OK
print(dlugosc([1,0]))	# OK

Argumenty podprogramów i zmienne w podprogramach

• tożsamość zmiennej. Operator is (patrz podrozdział 10.1.3.)
• argumenty prostych typów dają się modyfikować, ich modyfikacje są ważne tylko wewnątrz podprogramu. To samo odnosi się do przypisania nowego obiektu argumentowi.
• elementy argumentów złożonych dają się modyfikować. Skutki takich modyfikacji są trwałe, także dla programu wywołującego podprogram.
• podprogram może używać własnych „prywatnych” zmiennych. Nie różnią się one niczym o „zwykłych” zmiennych oprócz tego, że są inicjowane wewnątrz podprogramu. Są one usuwane z pamięci z chwilą, kiedy wykonanie podprogramu zostaje zakończone.
• podprogram może korzystać ze zmiennych programu nie będących argumentami, ale nie może ich modyfikować, chyba że użyjemy deklaracji global Dotyczy to wszystkich obiektów istniejących w chwili wywołania podprogramu. Nie muszą one istnieć w miejscu, w którym znajduje się deklaracja podprogramu.

  global jest słowem kluczowym Pythona.

  W Pythonie 3 oprócz słowa global wprowadzono także słowo kluczowe nonlocal, pozwalające na pełny dostęp do zmiennych zadeklarowanych w blokach nadrzędnych, jednak niekoniecznie globalnych.

• argumenty podprogramów mogą mieć wartości domyślne, np.

  def powieksz(obiekt, skala = 1.0, srodek = [0, 0]):
      ''' tworzy obraz obiektu płaskiego przekształcony w jednokładności o zadanej skali i centrum.
  	obiekt powinien być listą dwuwymiarowych punktów. 
      '''
      obraz = []
      for punkt in obiekt:
  	obraz.append([srodek[0] + skala*(punkt[0]-srodek[0]),
                        srodek[1] + skala*(punkt[1]-srodek[1])])
      return obraz
  

  Przy wywoływaniu takiego podprogramu argumenty z wartością domyślną wolno pominąć:

  a = powieksz(cos)	# parametry skala i srodek mają wartości takie, jak w nagłówku deklaracji
  

  Wolno także nadawać im wartości inne niż domyślne za pomocą podstawienia w nagłówku:

  b = powieksz(cos, skala = 2)                                # srodek jest taki, jak w deklaracji
  c = powieksz(cos, srodek = [-1, 1.2])                       # skala jest taka, jak w deklaracji
  d = powieksz(cos, skala = math.sqrt(2), srodek = [-1, 3.3]) # oba parametry mają wartości jawnie zadane
  e = powieksz(cos, srodek = [-1, 3.3], skala = math.sqrt(2)) 
  

  Kolejność nazwanych parametrów w wywołaniu nie ma znaczenia, jednak w wywołaniu funkcji po argumencie nazwanym nie można już umieścić argumentu bez nazwy.

  b = powieksz(cos, 2.5, [0.1, -2.1])		# kolejność argumentów zgodna z kolejnością w deklaracji
  b = powieksz(cos, 2.5)				# pominięte argumenty mają wartości domyślne
  c = powieksz(cos, srodek = [-1, 1.2])
  d = powieksz(cos, skala = math.sqrt(2), srodek = [-1, 3.3])
  

  b = powieksz(cos, [0.1, -2.1])			# pomylona kolejność argumentów bez użycia nazw
  b = powieksz(cos, [0.1, -2.1], 2.5)		# pomylona kolejność argumentów bez użycia nazw
  b = powieksz(skala = 2, cos)			# argument bez nazwy po argumencie nazwanym
  c = powieksz(cos, srodek = [-1, 1.2], 2.5)	# argument bez nazwy po argumencie nazwanym
  

Przykłady