Jarekz: /* Przykład */

2015-05-22T19:46:40Z

Przykład

Jarekz: Utworzono nową stronę " ==Wprowadzenie== Funkcje to fragmenty programu, które można używać wielokrotnie. Możemy nadać nazwę jakiejś grupie instrukcji i uruchamiać ją używając tej n..."

2015-05-22T19:42:53Z

Utworzono nową stronę " ==Wprowadzenie== Funkcje to fragmenty programu, które można używać wielokrotnie. Możemy nadać nazwę jakiejś grupie instrukcji i uruchamiać ją używając tej n..."

Nowa strona

==Wprowadzenie==
Funkcje to fragmenty programu, które można używać wielokrotnie. Możemy nadać nazwę jakiejś grupie instrukcji i uruchamiać ją używając tej nazwy w dowolnym miejscu programu tyle razy ile chcemy. Operację taką nazywamy wywołaniem funkcji. Tak naprawdę używaliśmy już wielu wbudowanych funkcji takich jak <tt>len</tt> czy <tt>range</tt>. Funkcje są prawdopodobnie najważniejszym składnikiem budującym każdy program (w dowolnym języku programowania), musimy więc poznać je dokładniej.

Funkcje definiujemy w programie używając słowa kluczowego <tt>def</tt>. Po tym słowie następuje nazwa funkcji oraz para nawiasów, które mogą zawierać nazwy zmiennych (parametrów funkcji), a linia kończy się dwukropkiem. Parametry służą do przekazywania funkcji różnych wartości tzw. wejściowych i uzyskiwania zależnych od nich wyników. Potem następuje blok linii programu, które tworzą funkcję. Poniżej jest przedstawiony przykład '''definicji''' i '''wywołania''' funkcji.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: function1.py

# początek definicji funkcji
def przywitajSie():
print 'Sie ma!' # instrukcje tworzące funkcję
# koniec definicji funkcji

przywitajSie() # wywołanie (użycie) funkcji
przywitajSie() # ponowne wywołanie funkcji
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
Sie ma!
Sie ma!
</source>

;Jak to działa?
Definiujemy funkcję o nazwie <tt>przywitajSie</tt> w sposób opisany powyżej. Ponieważ funkcja ta nie używa żadnych parametrów, nie ma więc żadnych zmiennych wewnątrz nawiasów. Zauważ, że możemy wywołać tę samą funkcję dwukrotnie co oznacza, że nie musimy dwa razy pisać tego fragmentu programu.

==Parametry funkcji==
Jak wiemy, funkcja może mieć parametry wywołania. Są to wartości, które dostarczamy funkcji, i których możemy użyć wewnątrz funkcji. Parametry zachowują się tak samo jak zmienne z tą różnicą, że ich wartości są nadawane w momencie wywołania funkcji.

Parametry wpisuje się w nawiasach podczas definiowania funkcji oddzielając je przecinkami. Kiedy wywołujemy funkcję, ich wartości podajemy w taki sam sposób. Uwaga: nazwy, które podaliśmy podczas definiowania funkcji nazywamy parametrami, ale wartości podane przy wywołaniu funkcji nazywamy argumentami.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_param.py

def printMax(a, b):
if a > b:
print a, 'jest większe'
elif a == b:
print a, 'jest równe', b
else:
print b, 'jest większe'

printMax(3, 4) # bezpośrednio podane wartości

x = 5
y = 7

printMax(x, y) # zmienne podane jako argumenty
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
4 jest większe
7 jest większe
</source>

;Jak to działa?
Definiujemy tutaj funkcję o nazwie <tt>printMax</tt>, która używa dwóch parametrów o nazwach <tt>a</tt> i <tt>b</tt>. Funkcja ma znaleźć większą z liczb używając instrukcji <tt>if..else</tt> a następnie wypisać, która liczba jest większa. Podczas pierwszego użycia funkcji <tt>printMax</tt> podaliśmy bezpośrednio liczby jako argumenty. Przy drugim wywołaniu jako argumentów użyliśmy zmiennych. Instrukcja <tt>printMax(x,y)</tt> przypisuje wartość pierwszego argumentu (zmiennej <tt>x</tt>) do parametru <tt>a</tt> oraz wartość drugiego argumentu (zmiennej <tt>y</tt>) do parametru <tt>b</tt>. Samo wyznaczenie większej liczby i jej wypisanie odbywa się wewnątrz funkcji tak samo za każdym razem.

==Zmienne lokalne==
Jeśli wewnątrz funkcji zadeklarujemy zmienne, nie mają one żadnego związku ze zmiennymi poza funkcją, nawet jeśli mają takie same nazwy. Mówimy, że nazwy zmiennych wewnątrz funkcji są lokalne dla tej funkcji. Obszar, w którym możemy danej zmiennej używać nazywamy zasięgiem zmiennej. Każda zmienna zdefiniowana w funkcji ma zasięg poczynając od miejsca, w którym po raz pierwszy przypiszemy jej wartość, aż do końca funkcji.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_local.py

x = 50

def func(x):
print 'x wynosi', x
x = 2
print 'Zmieniono lokalne x na', x

func(x)
print 'x ciągle wynosi', x
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
x wynosi 50
Zmieniono lokalne x na 2
x ciągle wynosi 50
</source>

;Jak to działa?
Kiedy po raz pierwszy wypisujemy wartość zmiennej <tt>x</tt>, w pierwszej linii funkcji <tt>func</tt>, użyta zostaje wartość parametru zadeklarowanego w bloku głównym, powyżej definicji funkcji.

Następnie przypisujemy zmiennej <tt>x</tt> wartość <tt>2</tt>. Nazwa <tt>x</tt> jest lokalna dla funkcji, tak więc gdy zmieniamy wartość <tt>x</tt> wewnątrz funkcji, zmienna <tt>x</tt> zdefiniowana w bloku głównym pozostaje niezmieniona.

W momencie ostatniego wywołania polecenia <tt>print</tt> wypisujemy wartość zmiennej <tt>x</tt> zdefiniowanej w bloku głównym potwierdzając, że nie została ona zmieniona przez przypisanie nowej wartości lokalnej zmiennej <tt>x</tt> wewnątrz poprzednio wywołanej funkcji.

===Dostęp do zmiennych globalnych===
Wewnątrz funkcji, odczytywać zmienne zdefiniowane na wyższym poziomie można bez problemu. Jeśli natomiast chcemy przypisywać
wartość do takiej zmiennej, zdefiniowanej poza zakresem danej funkcji, to trzeba tą zmienną określić jako ''globalną''. Służy do tego deklaracja <tt>global</tt>. Bez użycia tej deklaracji nie jest możliwe przypisanie wartości zmiennej zdefiniowanej na zewnątrz funkcji — jedyny efekt takiego przypisania to utworzenie ''lokalnej'' zmiennej o tej nazwie, która zasłania zmienną globalną.


Należy powiedzieć precyzyjnie, co tutaj znaczy słowo ''globalna''. W Pythonie zmienną globalną nazywa się zmienną zdefiniowaną bezpośrednio w jakimś module, a nie wewnątrz funkcji czy klasy w tym module. Takie znaczenie jest zupełnie inne niż np. w C, gdzie zmienna globalna o danej nazwie w całym programie może być tylko jedna.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_global.py

x = 50

def func():
global x

print 'x wynosi', x
x = 2
print 'Zmieniono zewnętrzny x na', x

func()
print 'x wynosi teraz', x
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
x wynosi 50
Zmieniono zewnętrzny x na 2
x wynosi teraz 2
</source>

;Jak to działa?
Deklaracja <tt>global</tt> została użyta do poinformowania, że chodzi nam o globalną, zewnętrzną zmienną <tt>x</tt>. Jeśli teraz przypisujemy wartość zmiennej <tt>x</tt> wewnątrz funkcji, zmieniamy wartość <tt>x</tt> z głównego bloku.

Można określić więcej niż jedną zmienną globalną w tej samej deklaracji global, na przykład:
<tt>global x, y, z</tt>.

Wyskakując na moment do [[TI:Moduły|rozdziału o modułach]], należy wspomnieć, że do do zmiennych zdefiniowanych &bdquo;gdzie indziej“ można się odwoływać podając nazwę modułu który je zawiera. Na przykład zmienna <tt>argv</tt> zdefiniowana w module <tt>sys</tt> jest z poza tego modułu dostępna jako <tt>sys.argv</tt>. Dlatego atrybut <tt>global</tt> służy do dostępu do zmiennych zdefiniowanych na poziomie modułu, ale tylko z wewnątrz tego modułu.

==Domyślne wartości argumentów==
W przypadku pewnych funkcji nie zawsze chcemy podawać argumenty odpowiadające ''wszystkim'' parametrom określonych w definicji funkcji. Parametry mogą być &bdquo;opcjonalne“. Nie musimy wtedy ich podawać w wyłaniu funkcji, i jeśli tego nie zrobimy zostaną użyte wartości domyślne. Wartości domyślne definiujemy dopisując w definicji funkcji po nazwie parametru znak <tt>=</tt> i wartość domyślną.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_default.py

def napisz(wiadomosc, razy=1):
print wiadomosc * razy

napisz('Dzień')
napisz('dobry', 5)
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
Dzień
dobrydobrydobrydobrydobry
</source>

;Jak to działa?
Funkcja o nazwie <tt>napisz</tt> ma za zadanie wypisać tekst tyle razy ile podano. Jeśli nie podamy ile razy, wtedy domyślnie tekst wypisywany jest jeden raz. Osiągamy to podając wartość domyślną argumentu dla parametru <tt>razy</tt> równą <tt>1</tt>.

Podczas pierwszego wywołania <tt>napisz</tt> podajemy tylko tekst i wypisywany jest on jeden raz. Przy drugim wywołaniu <tt>napisz</tt> podajemy zarówno tekst jak i argument <tt>5</tt> mówiący, że chcemy napisać tekst 5 razy.

;Uwaga: tylko parametry z końca listy parametrów mogą mieć wartości domyślne. Nie można mieć parametru z wartością domyślną przed parametrem bez wartości domyślnej w kolejności deklaracji na liście parametrów funkcji. Dzieje się tak dlatego, że wartości są przypisywane parametrom zgodnie z ich pozycją na liście. Na przykład deklaracja <tt>def func(a, b=5)</tt> jest prawidłowa, ale deklaracja <tt>def func(a=5, b)</tt> nie jest, bo wówczas w wywołaniu <tt>func(11)</tt> nie byłoby jasne, czy podany argument tyczy się <tt>a</tt> czy <tt>b</tt>.

==Zaawansowane sposoby przekazywania argumentów==
===Argumenty nazwane===
Jeśli chcemy skorzystać z funkcji o dużej liczbie parametrów, wygodne może być jawne użycie nazw parametrów. Działa to tak, że ''w wywołaniu'' funkcji podajemy zarówno nazwę parametru, jak i, tak jak poprzednio, właściwy argument.
Podanie wartości danego parametru poprzez taki ''nazwany argument'' (po angielsku argumenty takie nazywa się ''keyword arguments''), powoduje, że jego wartość w wywołaniu funkcji jest ustalona i zostaje on wyłączony z normalnego przypisywania argumentów do parametrów według kolejności.

Rozpoznawanie argumentów po nazwie, a nie kolejności, ma dwie zalety:
# użycie funkcji jest prostsze, bo nie musimy się martwić o kolejność argumentów
# możemy podać wartości tylko tych argumentów, których chcemy (pod warunkiem, że parametry które pomieliśmy mają określone wartości domyślne).

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_key.py

def func(a, b=5, c=10):
print 'a wynosi', a, 'oraz b wynosi', b, 'oraz c wynosi', c

func(3, 7)
func(25, c=24)
func(c=50, a=100)
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
a wynosi 3 oraz b wynosi 7 oraz c wynosi 10
a wynosi 25 oraz b wynosi 5 oraz c wynosi 24
a wynosi 100 oraz b wynosi 5 oraz c wynosi 50
</source>

;Jak to działa?
Funkcja o nazwie <tt>func</tt> ma jeden parametr bez wartości domyślnej, oraz dwa parametry posiadające wartości domyślne.
* Przy pierwszym użyciu, <tt>func(3, 7)</tt>, parametr <tt>a</tt> dostaje wartość <tt>3</tt>, parametr <tt>b</tt> dostaje wartość <tt>7</tt>, a parametr <tt>c</tt> dostaje wartość domyślną <tt>10</tt>.

* Przy drugim użyciu, <tt>func(25, c=24)</tt>, zmienna <tt>a</tt> dostaje wartość <tt>25</tt> ze względu na pozycję na liście argumentów. Parametr <tt>c</tt> dostaje wartość <tt>24</tt> ze względu na użycie jego nazwy. Zmienna <tt>b</tt> dostaje wartość domyślną <tt>5</tt>.

* Przy trzecim użyciu, <tt>func(c=50, a=100)</tt>, używamy wyłącznie nazw jako argumentów do podania wartości. Zauważ, że podajemy wartość parametru <tt>c</tt> przed parametrem <tt>a</tt>, mimo że <tt>a</tt> jest podany przed <tt>c</tt> w definicji funkcji.

Użycie argumentu nazwanego nazwą która nie odpowiada żadnemu parametrowi jest błędem.

===Zmienna liczba parametrów===
Czasami wygodnie byłoby zdefiniować funkcję, która przyjmowałaby dowolną liczbę parametrów, tak jak polecenie <tt>print</tt>. Można to uzyskać dodając na końcu listy parametrów zmienną, do której zostanie wpisana lista &bdquo;nadmiarowych“ argumentów. Ten specjalny parametr jest oznaczony przez gwiazdkę przed jego nazwą.

====Przykład====
<source lang='shell_example'>
>>> def powypisuj(rozdzielacz, pierwsze, *reszta)
... """Wypisuje podane słowa używając pierwszego argumentu
... jako rozdzielacza."""
... print pierwsze
... for slowo in reszta:
... print rozdzielacz, slowo,
...
...
>>> powypisuj('-x-', 'ala', 'ma', 'kota')
ala-x-ma-x-kota
>>> powypisuj('-x-', 'ala')
ala
>>> powypisuj('-x-')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: powypisuj() takes at least 2 arguments (1 given)
</source>

==== W jaki sposób argumenty zostają przyporządkowane? ====
Argumenty nazwane nie mogą występować tylko na końcu listy argumentów, lub patrząc od drugiej strony, argumenty ''nienazwane'' muszą znajdować się na początku.
Podane argumenty są przyporządkowywane parametrom w ten sposób, że najpierw argumenty bez zadanej nazwy parametru zostają przydzielone do odpowiednich parametrów w kolejności, a potem argumenty nazwane zostają przydzielone do odpowiednich parametrów według nazwy. Tak więc, jeśli argumentów jest więcej niż parametrów &bdquo;bez gwiazki“, to trafią one do zmiennej &bdquo;z gwiazdką“.

Błędem jest jeśli jakiemuś parametrowi zostaną przyporządkowane dwa argumenty &mdash na przykład jeden zwykły, a drugi nazwany.

=== Zmienna liczba argumentów nazwanych ===
Istnieje jeszcze jeden sposób przekazywania zmiennej liczby parametrów, w formie [[TI:Struktury danych#Słowniki|słownika]]. Ponieważ słowniki będą omówione dopiero w rozdziale o [[TI:Struktury danych|strukturach danych]], to reszta tego podrozdziału może być niezrozumiała. Jeśli tak, to nie przejmuj się i najpierw poczytaj o słownikach.

Funkcja może mieć jeszcze jeden specjalny parametr — poprzedzony dwoma gwiazkami, zwyczajowo nazywający się <tt>**kwargs</tt>. W wywołaniu takiej funkcji można użyć argumentów nazwanych, których nazwy nie odpowiadają żadnym parametrom funkcji. Te argumenty zostają wstawione do słownika, który zostaje przekazany jako parametr <tt>kwargs</tt> do funkcji.
W tym słowniku, nazwy argumentów są kluczami, a ich wartości wartościami przypisanymi do tych kluczy.

====Przykład====
<source lang='shell_example'>
>>> def f(*args, **kwargs):
... print 'args =', args
... print 'kwargs =', kwargs
...
>>> f(1, 2, 3, a=4, b=5, c=6)
args = (1, 2, 3)
kwargs = {'a': 4, 'b': 5, 'c': 6}
</source>



==Polecenie return==
Dotychczas rozważane funkcje wykonywały pewne polecenia ale nie oczekiwaliśmy od nich aby '''zwracały''' jakieś wartości (tzn. nie potrzebowaliśmy aby wartości wyliczone albo obiekty wytworzone w funkcji były dostępne w miejscu, z którego wywołaliśmy funkcję).

Polecenie <tt>return</tt> jest używane do '''powrotu''' z funkcji czyli natychmiastowego przerwania jej wykonania i zwrócenia wartości.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_return.py

def maksimum(x, y):
if x > y:
return x
else:
return y

print maksimum(2, 3)
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
3
</source>

;Jak to działa?
Funkcja <tt>maksimum</tt> zwraca większy ze swoich parametrów, czyli liczb przekazanych do funkcji. Do znalezienia większej z liczb użyta jest instrukcja <tt>if..else</tt>, po znalezieniu ta wartość jest zwracana.

;Uwaga: instrukcja <tt>return</tt> bez podanej wartości jest równoważna instrukcji <tt>return None</tt>. <tt>None</tt> jest obiektem języka Python reprezentującym brak wartości. Jest on używany na przykład do zaznaczenia, że jakaś zmienna nie ma wartości.

Każda funkcja domyślnie zawiera instrukcję <tt>return None</tt> na końcu. Można to zaobserwować wywołując <tt>print jakasFunkcja()</tt>, gdzie funkcja <tt>jakasFunkcja</tt> nie używa instrukcji <tt>return</tt>, na przykład:
====Przykład====
<source lang="shell_example">
>>> def jakasFunkcja():
... pass
...
>>> print jakasFunkcja()
None
</source>

Instrukcja <tt>pass</tt> jest w języku Python używana do oznaczenia pustego bloku instrukcji.

Uwaga:<br>
Istnieje wbudowana funkcja <tt>max</tt>, która wyszukuje większą z liczb. Jeśli tylko to możliwe należy używać funkcji wbudowanych, a nie pisać własne.

== Opisy wbudowane w funkcje ==
W Pythonie istnieje wygodna możliwość uzupełniania programu o objaśnienia–dokumentację.
W ogólności programista może umieszczać swoje uwagi jako komentarze (wykorzystując znak <tt>#</tt>), które są po prostu ignorowane w trakcie wykonywania programu, lub jako
napisy wstawione na początku definicji funkcji (wykorzystując znaki normalnie używane do ograniczania napisów, czyli <tt>'</tt> i <tt>"</tt>). Ta druga forma ma tę przewagę, że mimo iż w trakcie normalnego wykonywania programu jest pomijana podobnie jak zwykłe komentarze, to te napisy zostają także zachowane od specjalnej zmiennej i można je obejrzeć. W trybie interaktywnej pracy z Pythonem służy do tego funkcja <tt>help</tt>.

Linie tekstu z dokumentacją nazywają się po angielsku ''documentation strings'', co skraca się do ''docstrings''. Przez ''docstring'' rozumie się tylko taki napis umiejscowiony na początku funkcji (lub klasy czy modułu, mechanizm jest ten sam) stanowiący dokumentację.

====Przykład====
<source lang = python>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_doc.py

def printMax(x, y):
'''Konwertuje obydwa obiekty na int i wypisuje większą z dwóch liczb.

Niepowodzenie konwersji powoduje rzucenie wyjątku ValueError.
'''
x = int(x) # konwersja do liczby całkowitej (integer), jeśli możliwa
y = int(y)

if x > y:
print x, 'jest większa'
else:
print y, 'jest większa'

printMax(3, 5)
print(printMax.__doc__)
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
5 jest większa
Konwertuje obydwa obiekty na int i wypisuje większą z dwóch liczb.

Niepowodzenie konwersji powoduje rzucenie wyjątku ValueError.
</source>

====Używanie ''DocString''====
Napis w pierwszym logicznym wierszu funkcji staje się ''docstring''-iem dla tej funkcji. Dodajmy, że ''DocStrings'' również stosują się do modułów i klas, o których będzie mowa później.

Konwencją stosowaną dla dokumentacji jest napis w kilku wierszach. Pierwszy wiersz zaczyna się wielką literą i kończy kropką. Następny wiersz jest pusty, a w trzecim wierszu rozpoczynamy dokładniejsze objaśnienia. Jest bardzo wskazane, aby stosować się do tej konwencji opisując napisane przez siebie funkcje.

Możemy odczytać ''dosctring'' jakiejś funkcji (na przyklad <tt>printMax</tt>) używając jej ''atrybutu'' (czyli nazwy należącej do funkcji) <tt>__doc__</tt> (zauważ użycie po dwóch znaków podkreślenia). Atrybuty są częścią ''obiektów'', którymi są też funkcje. O obiektach będzie mowa w następnych rozdziałach.

Używając pomocy <tt>help()</tt> w Pythonie robimy użytek z ''docstring''ow. Funkcja <tt>help()</tt> pobiera z funkcji jej atrybut <tt>__doc__</tt> i wypisuje go. Możesz to wypróbować na powyższej funkcji — napisz w swoim programie <tt>help(printMax)</tt>. Pamiętaj, żeby nacisnąć klawisz <tt>q</tt>, żeby zakończyć pomoc <tt>help</tt>.

Automatyczne narzędzia programistyczne pobierają dokumentację z twoich programów właśnie w taki sposób. Dlatego dobrze jest używać ''docstring''s do każdej napisanej funkcji. Komenda <tt>pydoc</tt>, dostępna w dystrybucji języka Python działa podobnie do funkcji <tt>help()</tt> używając ''docstring''s.

=== Co powinna zawierać dokumentacja funkcji ===
Nawet krótka dokumentacja funkcji może być bardzo pomocna. Co powinno się w niej znaleźć?
# Jednolinijkowy opis działania wykonywanego przez funkcję: &bdquo;Mnoży wektorowo argumenty i zwraca ślad wyniku.”
# Nie ma potrzeby pisać, czym jest opisywany obiekt (w tym przypadku funkcją), ani duplikować listy parametrów, bo użytkownik i tak to wie z opisu wygenerowanego automatycznie: <strike>&bdquo;To jest funkcja która ma parametry a, b, c.”</strike>
# Dobrze jest napisać co funkcja zwraca, jeśli coś zwraca.
# Jeśli funkcja ma być wykorzystywana przez innych jako funkcja biblioteczna, to opis musi być znacznie dłuższy — powinien zawierać głębsze wyjaśnienie tego co funkcja robi, jeśli to jest istotne jakie ma ograniczenia i warunki działania.
# W przypadku funcji złożonych obliczeniowo, dobrze jest napisać jak czas wykonywania funkcji rośnie wraz ze wzrostem rozmiaru argumentów wejściowych.
# Dobrze jest podać przykład użycia funkcji i oczekiwanego wyniku. Zob. http://docs.python.org/library/doctest.html .

''Docstrings'' to ważne narzędzie, którego warto używać, bo dzięki dokumentacji program jest łatwiejszy do zrozumienia.

==Ćwiczenia==
Proszę napisać następujące funkcje:
# Która wypisuje sumę dwóch argumentów.
# Która zwraca sumę dwóch argumentów.
# Wypisującą wynik dzielenia zmiennoprzecinkowego dla dwóch dowolnych argumentów będących liczbami.
# Obliczającą i zwracającą pierwiastek zadanego stopnia — w liście parametrów podajemy liczbę podpierwiastkową i stopień pierwiastka, domyślnie niech wynosi on dwa.
# Wypisującą równanie prostej przechodzącej przez współrzędne dwóch zadanych punktów.
# Wypisującą jedno lub dwa rozwiązania równania kwadratowego <math>a x^2+b x +c = 0</math>, lub informującą, że nie ma rozwiązań rzeczywistych. Parametrami funkcji niech będą <math>a</math>, <math>b</math>, <math>c</math> — współczynniki równania kwadratowego.
# Zwracającą silnię argumentu. Zadanie proszę rozwiązać na dwa sposoby — raz z użyciem pętli, a drugi raz rekurencyjnie.
# Wypisującą żądaną liczbę wyrazów ciągu Fibbonacciego. (<math>F_0=0</math>, <math>F_1=1</math>, <math>F_n=F_{n-1}+F_{n-2}</math>)
# Służącą do obliczania <math>n</math>-tego elementu ciągu arytmetycznego o zadanym wyrazie początkowym i różnicy. Funkcja powinna dawać możliwość wypisywania wyników pośrednich (elementów ciągu od pierwszego do przedostatniego obliczonego).
# Służącą do obliczania <math>n</math>-tego elementu ciągu geometrycznego o zadanym wyrazie początkowym i ilorazie. Funkcja powinna dawać możliwość wypisywania wyników pośrednich (elementów ciągu od pierwszego do przedostatniego obliczonego).
# Służącą do obliczania <math>n</math>-tej sumy częściowej ciągu arytmetycznego o zadanym wyrazie początkowym i różnicy. Funkcja powinna dawać możliwość wypisywania wyników pośrednich (kolejno obliczanych elementów ciągu i sum).
# Służącą do obliczania <math>n</math>-tej sumy częściowej ciągu geometrycznego o zadanym wyrazie początkowym i ilorazie. Funkcja powinna dawać możliwość wypisywania wyników pośrednich (kolejno obliczanych elementów ciągu i sum).
# Służącą do obliczania <math>n</math>-tej sumy częściowej ciągu <math>1/n^m</math>, gdzie <math>n</math> i <math>m</math> są parametrami. Funkcja powinna dawać możliwość wypisywania wyników pośrednich (kolejno obliczanych elementów ciągu i sum).
# Funkcję obliczającą długość wektora jedno-, dwu- lub trójwymiarowego.
# Funkcję, która zwróci napis będący reprezentacją podanej liczby całkowitej. Tę &bdquo;konwersję na napis” wykonaj cyfra po cyfrze.

@@ Linia 22: / Linia 22: @@
 ;Rezultat<nowiki>:</nowiki>
-<source lang='shell_example'>
+<source lang= shell_example>
 Sie ma!
 Sie ma!
@@ Linia 29: / Linia 29: @@
 ;Jak to działa?
 Definiujemy funkcję o nazwie <tt>przywitajSie</tt> w sposób opisany powyżej. Ponieważ funkcja ta nie używa żadnych parametrów, nie ma więc żadnych zmiennych wewnątrz nawiasów. Zauważ, że możemy wywołać tę samą funkcję dwukrotnie co oznacza, że nie musimy dwa razy pisać tego fragmentu programu.
 ==Parametry funkcji==

TI/Funkcje - Historia wersji

Jarekz: /* Przykład */

Jarekz: Utworzono nową stronę " ==Wprowadzenie== Funkcje to fragmenty programu, które można używać wielokrotnie. Możemy nadać nazwę jakiejś grupie instrukcji i uruchamiać ją używając tej n..."