Strona używa cookies (ciasteczek). Dowiedz się więcej o celu ich używania i zmianach ustawień. Korzystając ze strony wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki.    X

Programowanie funkcyjne w Pythonie

W komentarzu do poprzedniego wpisu nintyfan napisał:

Python jest świetny. To co możemy zrobić przy pomocy generatorów i iteratorów (również w postaci konstruktora tablicowego) jest niesamowite. Prosty, przejrzysty, przyjemny zapis. Nie wspominając o składni z wcięciami.

O wcięciach w kodzie już było, więc teraz napiszę nieco o generatorach, iteratorach i programowaniu funkcyjnym. Zapraszam do czytania;)

Wstęp

Język Python można wykorzystać do programowania proceduralnego, zorientowanego obiektowo oraz (w mniejszym stopniu) programowania w stylu funkcyjnym (funkcjonalnym). Największą rolę odgrywa styl obiektowy, chociaż coraz częściej spotykam ciekawe rozwiązania napisane w stylu funkcyjnym. Nic w tym dziwnego. Programowanie funkcyjne pozwala w znaczny sposób zredukować ilość kodu.

Języki takie jak C, C++, Java to języki imperatywne. Programy w nich napisane zawierają zmienne i obiekty, na których przeprowadzane są operacje. Zmienne i obiekty charakteryzują się stanem, którym może ulegać zmianie w czasie wykonywania programu. Programy imperatywne stanowią listę rozkazów dla komputera.

Czym wyróżnia się paradygmat funkcyjny?

Nazwa programowanie funkcyjne pochodzi od funkcji (w ich matematycznym znaczeniu), na których dokonywane są ,,bezstanowe'' operacje. W programowaniu funkcyjnym definiujemy co trzeba wykonać, a nie w jaki sposób.

Niektóre cechy/elementy języków czysto funkcyjnych (na przykładzie Haskella) [1] to:

* Funkcje to pojęcia podstawowe (ang. first-class)
* Funkcje mogą operować na funkcjach (ang. high-order functions)
* Rekurencja zamiast pętli
* Listy jako podstawowa struktura danych
* Brak efektów ubocznych (ang. no side-effect)
* Wyrażenia lambda (funkcje anonimowe)
* Leniwe wartościowanie (ang. lazy evaluation)
* Strażnicy (ang. guards)

Po czym najłatwiej rozpoznać, że mamy do czynienia z językiem funkcyjnym? Po wymienionych powyżej funkcjach lambda i pewnych podstawowych funkcjach (ang. primary functional programming primitives) takich jak: map, filter, reduce, fold, scan. Używanie tych funkcji najczęściej prowadzi do eliminacji pętli.

Python językiem funkcyjnym nie jest, a już na pewno nie jest językiem czysto funkcyjnym, ale posiada pewne cechy charaketrystyczne dla tych języków. Przede wszystkim umożliwia korzystanie z wyrażeń lambda oraz dostarcza wymienione powyżej funkcje map, filter, reduce.

Równie ważne są iteratory oraz generatory dostępne w modułach biblioteki standardowej takich jak itertools i functools.

Mapowanie polega na pobieraniu funkcji oraz obiektu pozwalającego na iterację i wygenerowanie nowego elementy iterowanego, w którym element będzie wynikiem wywołania funkcji względem odpowiadającego mu elementu w początkowym obiekcie [3].

Filtrowanie pozwala na iterację i wygenerowanie nowego iteratora, w którym każdy element pochodzi z początkowego iteratora--pod warunkiem, że funkcja wywołana względem tego iteratora zwróciła wartość True [3].

Redukcja natomiast polega na pobieraniu funkcji i obiektu pozwalającego na iterację, a następnie wygenerowaniu pojedynczej wartości [3], np.

functools.reduce(lambda x, y: x * y, [1, 2, 3, 4]) # wynik: 24

Przyjrzyjmy się bliżej wyrażeniom lambda. Przeanalizujmy następujący przykład:

>>> def f(x): return x ** 2 >>> f(4) 16

To samo można zrealizować przy pomocy funkcji anonimowej.

>>> g = lambda x : x ** 2 >>> g(4) 16

Nie musimy nawet używać nazwy argumentu. Czasami po prostu chcemy obliczyć wartość funkcji od ,,czegoś'', czymkolwiek to ,,coś'' jest.

>>> h = lambda _ : _ ** 2 >>> h(4) 16

Wyobraźmy sobie następujący problem:

Poszukujemy kwadratów liczb naturalnych od 1 do 10, o wartościach większych od 50.

Powyższy problem można rozwiązać w Haskellu w następujący sposób:

> filter (>50) (map (**2) [1..10]) [64.0,81.0,100.0]

W Pythonie można skorzystać np. z pętli for, polecenia if oraz append:

lub zrealizować to w sposób funkcyjny w jednej linii bez wprowadzania nowych zmiennych i funkcji:

>>> list(filter(lambda _ : _ > 50, map(lambda _ : _ ** 2, range(11)))) [64, 81, 100]

Inną charakterystyczną cechą Haskella jest leniwość. Zaletami tego podejścia są możliwość obliczenia wartości funkcji nawet wtedy, gdy nie jest możliwe wyznaczenie wartości któregoś z jej argumentów, o ile tylko nie jest on używany, wzrost wydajności dzięki uniknięciu wykonywania niepotrzebnych obliczeń oraz możliwość tworzenia nieskończonych struktur danych.

Spójrzmy na jeszcze jeden przykład napisany w Haskellu:

ghci> sum (takeWhile (<10000) (filter odd (map (^2) [1..]))) 166650

Lista [1..] to lista nieskończona. Może wydawać się to dziwne dla osób, które po raz pierwszy się spotykają z taką strukturą. Przecież program nie może działać w nieskończoność. To prawda, ale na etapie programowania jest to bardzo wygodne. Definiujemy nieskończoną listę elementów, a później przy pomocy funkcji take lub takeWhile bierzemy tyle ile nam potrzeba.

W Pythonie podobną listę można zrealizować przy pomocy generatorów. Generatory wykonują rodzaj leniwych obliczeń, tzn. obliczają jedynie te wartości, które są potrzebne w danej chwili [3].

Przykład:

Polecenie break jest tutaj konieczne -- bez niego pętla for..in nigdy nie zakończy działania.

Moduł Pipe

W podsumowaniu powyższych rozważań przedstawię krótko bardzo ciekawy moduł Pipe.

Głównym zadaniem modułu jest umożliwienie stosowania składni ,,infix''. Funkcje typu ,,infix'' zapisujemy podobnie jak podstawowe operacje dodawania, mnożenia itd. Np.:

plus a b = a + b plus 1 5 == 1 `plus` 5

W module tym zaimplementowane są przy pomocy generatorów podstawowe funkcje znane z Haskella takie jak: where(), take(), take_while(), tail(), groupby(), reverse(), permutations() etc.

Oto kilka prostych przykładów zastosowań:

>>> from pipe import * >>> [1, 2, 3, 4, 5] | add 15 >>> [5, 4, 3, 2, 1] | sort [1, 2, 3, 4, 5]

>>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | concat '1, 3, 5' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | concat '3, 5' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | select(lambda x: x * x) | concat '9, 25' >>> [1, 2, 3, 4, 5] | where(lambda x: x % 2) | tail(2) | select(lambda x: x * x) | add 34

Na koniec nieco bardziej zaawansowany przykład zastosowania klasycznego ciągu Fibonacciego:

euler2 = fib() | where(lambda x: x % 2 == 0) | take_while(lambda x: x < 4000000) | add

Warto przeczytać:

* Why Functional Programming Matters, John Hughes
* Learn You a Haskell for Great Good!, Miran Lipovaca

Źródła:

1. Programowanie funkcyjne w Pythonie, Adam Byrtek2. Functional Programming HOWTO, Python 3 documentation
3. Python 3. Kompletne wprowadzenie do programowania. Wydanie II, Mark Summerfield
 

Komentarze

0 nowych
  #1 13.06.2011 07:38

Bardzo dobry i przejrzysty tutorial! O ile się nie mylę, Pardus został napisany w Pythonie.

  #2 13.06.2011 09:30

@Karolinah
nie myslisz sie, skrypty startowe, system pakietow oraz inne narzedzia w pardusie sa zrobione w pythonie :)

  #3 13.06.2011 09:47

Hmmm. Jest to zdecydowanie ciekawy artykul, bede sie musial blizej przyjzec programowaniu funkcyjnemu.

TestamenT   11 #4 13.06.2011 13:34

Moja przygoda z programowaniem jest głównie na etapie programowania strukturalnego i teraz próbuje poznać programowanie zorientowane obiektowo.
I po czymś takim niełatwo się przestawić na programowanie funkcyjne.
Aczkolwiek Python daje tyle możliwości że dobrze się nauczyć jaki styl programowania da największą wydajność w danym momencie.
Więc na pewno przyjże się dokładniej możliwościami jakie daje programowanie funkcyjne w Pythonie.

Druedain   13 #5 13.06.2011 17:46

Bardzo dobry wpis, gratuluję! Ja się za bardzo funkcyjnym programowaniem nie interesuję, ale dość często kolega mi pokazuje co robi na zajęciach w Haskellu i przyznam szczerze, że powoli zaczyna mnie to ciekawić.
Zwróciłem też uwagę na zapis „list(filter(lambda _ : _ > 50, map(lambda _ : _ ** 2, range(11))))”, a konkretnie fragment z nawiasami zamykającymi. W tym momencie poczułem się tak jakby ktoś mi powiedział, że Mikołaj nie istnieje, bo zawsze mi się wydawało, że Python ma tą wyższość nad językami typu C++, że nie ma w nich takich nieczytelnych kwiatków :P

@TestamenT, ja bym Ci polecał skupić się na języku stricte funkcyjnym, bo nie będzie Cię kusiło robienie czegokolwiek w sposób strukturalny kiedy najdzie Cię ochota na ambitniejsze zabawy.

iluzion   5 #6 13.06.2011 18:26

Dzięki za miłe słowa;)

@Druedain

W Pythonie jest mniej nawiasów (w szczególności klamrowych), ale pewnych rzeczy ominąć się nie da. Jeśli się nawias otworzyło, to trzeba go zamknąć;) Dotyczy to każdego języka (nie tylko programowania).

Jeśli bardzo nie lubisz nawiasów to polecam Haskella. Tam w wielu przypadkach można zrezygnować z nawiasów stosując symbol $, zwany /function application/ lub jak kto woli /apply/ oraz . (kropka) zwany /function composition/.

Innymi słowy, $ oznacza ,,zastosuj na'', a . oznacza złożenie funkcji.

Poniższe zapisy są tożsame:

f (g (z x)) == f $ g $ z x
f (g (z x)) == (f . g . z) x

Przykład:

replicate 100 (product (map (*3) (zipWith max [1,2,3,4,5] [4,5,6,7,8])))

można zapisać jako

replicate 100 . product . map (*3) . zipWith max [1,2,3,4,5] $ [4,5,6,7,8]

mati75   6 #7 13.06.2011 20:11

@ Karolinah
Potrafisz człowieka rozbawić do łez. Przy perlu nie chciałem, ale teraz już nie wytrzymałem. Większość dystrybucji zawiera python i skrypty/aplikacje w nim pisane. Pardus zawiera takie aplikacje, ale nie jest w nim pisany, tam jest jądro Linux napisane w języku C i środowisko KDE SC w C++ i python. Taka mała rada ode mnie zastanów się najpierw co piszesz.

------------------------------------------------------------------------------

Co do wpisu, jak dla mnie super. Mam w planach opis użycia bibliotek gtk+ w aplikacjach pisanych w pythonie. Takie małe okienkowe aplikacje. Tylko najpierw muszę znaleźć czas, a to jest podstawa.

Druedain   13 #8 13.06.2011 21:20

@iluzion właśnie o tym samym mi znajomy napisał gdy mu to pokazałem :P

  #9 14.06.2011 08:04

Mati75 każdy wyraża swoje zdanie. Nie podoba Ci się moje komputerowy geeeku to się nie naśmiewaj z drugiego.