Funkcje
Funkcja to zbiór instrukcji, który posiada nazwę, zbiór argumentów (ale nie musi posiadać argumentów) i „:”. Pozwala na wyodrębnienie fragmentu kodu programu w celu uniknięcia powtórzeń i może być wielokrotnie wywoływana w kodzie.
W celu zdefiniowania funkcji należy użyć słówka „def„, podać jej nazwę, argumenty (opcjonalnie) i instrukcje:
def przykladowa_nazwa_funkcji ($argument1,$argument2,$argument3.........):
instrukcja....
instrukcja...
Funkcje mogą zwracać konkretne wartości lub wyświetlać komunikat.
Aby wywołać funkcję wystarczy podać jej nazwę z nawiasami!
przykladowa_nazwa_funkcji() # wywołanie funkcji w kodzie
print i return
print nie zwraca wartości tylko wyświetla wynik na ekranie;
return zwraca wartość, którą możemy później wykorzystać jako zmienną.
Przykład funkcji bez argumentów:
def wyswietl_tekst(): # deklaracja funkcji bez argumentów
print("Witam serdecznie!") # instrukcje do wykonania
wyswietl_tekst() #ponieważ wewnątrz funkcji jest print to dostaniemy napis: Witam serdecznie!
Przykład funkcji z argumentami:
def dodawanie(liczba1, liczba2):
wynik = liczba1+liczba2
print(wynik)
dodawanie(2,3) #ponieważ wewnątrz funkcji jest print to dostaniemy napis: 5
#funkcja może posiadać domyślnie zadeklarowane argumenty
def odejmowanie(liczba3, liczba4=4): #domyślne argumenty zawsze na końcu!!!
odj = liczba3-liczba4
print(odj)
odejmowanie(3) # jeden argument ma wartość domyślną
odejmowanie(3,3) #możemy nadpisać wartość domyślną
odejmowanie(liczba3=5) #możemy wskazać któremu argumentowi wpisujemy wartość
Jeżeli w funkcji deklarujemy 2 argumenty, to dokładnie 2 musimy wywołać, inaczej otzrymamy błąd (chyba że deklarujemy wartości domyślne).
Przykład funkcji z return:
def dodawanie(liczba1, liczba2):
wynik = liczba1+liczba2
return wynik
print(dodawanie(2,3)) # 5
Porównajmy print i return:
#porównanie print i return
back_print = odejmowanie(6,3)
back_return = dodawanie(6,3)
print(f"back_print = {back_print}, a back_return = {back_return}")
#otrzymamy:
#back_print = None, a back_return = 9
print nic nie zwraca, jest traktowane jak None
Funkcja rekurencyjna (rekursja)
Funkcja rekurencyjna, to funkcja która wywołuje samą siebie.
#przykład iteracyjny
def silnia_iter(n):
silnia_tmp=1
if n in (0,1):
return 1
else:
for i in range(2,n+1):
silnia_tmp = silnia_tmp*i
return silnia_tmp
#przykład rekurencji
def silnia(n):
if n > 1:
return n*silnia(n-1) #wywołanie samej siebie
return1
#wersja skrócona kodu
def silnia(n): return n*silnia(n-1) if n > 1 else 1
Zasięg zmiennych
Nie ma dostępu z zewnątrz do zmiennych, które zostały zadeklarowane w środku.
def zasieg():
text = "zmienna wewnątrz funkcji"
return text
print(text) #NameError: name 'text' is not defined
text = "zmienna poza funkcją"
def zasieg():
return text #wyęwietli zmienna poza funkcją.
#Jeżeli każemy wyświetlić coś funkcji zaczyna ona poszukiwać podanej
# #nazwy zmiennej wewnątrz funkcji, a kiedy jej nie znajdzie
# #poszukuje poza funkcją
print(zasieg())
text = "zmienna poza funkcją"
def zasieg():
text = "zmienna wewnątrz funkcji"
return text
print(zasieg()) #wyświetli: zmienna wewnątrz funkcji
print(text) #wyświetli: zmienna poza funkcją
text = "zmienna poza funkcją"
def zasieg():
return text
print(zasieg()) #wyświetli: zmienna poza funkcją
print(text) #wyświetli: zmienna poza funkcją
#funkcja w funkcji - zasięg funkcji - scoping
def func1(name):
print("Jesteś wewnątrz funkcji 1 ", name)
def func2():
print("Jesteś wewnątrz funkcji 2 ", name)#odwołujemy się tutaj do zmiennej, która do tej f-i nie została bezpośrednio przekazana. Jeżeli funkcja nie znajdzie zmiennej wewnątrz to poszuka jej na zewnątrz
func2()
func1("Kama")
#print(name) #to nie zadziała
Nieokreślona liczba argumentów:
Jeżeli nie wiemy ile będziemy mieli argumentów, to korzystamy z tzw. Arbitrary Arguments, w skrócie *args
#przekazywanie nieokreślonej liczby argumentów poprzedzamy znakiem *
def sum(*args): #nazwa args jest opcjonalna, możecie wymyślić swoją. Argumenty zapisywane są do tuple - sprawdź sam
wynik=0
for liczba in args:
wynik = wynik + liczba
return wynik
print(sum(1,2,3,4,5))
#nieznana ilośc argumentów
def add(*args):
sum=0
for n in args:
sum+=n
return sum
print(add(1,2,3,5))
print(add(7,5,1,10,2,3,5))
Nieokreślona liczba par klucz=wartość:
Jeżeli nie wiemy ile par klucz=wartość przekażemy do funkcji, korzystamy z Arbitrary Kword Arguments, w skrócie **kwargs
#przekazywanie nieokreślonej pary klucz=wartość. Te argumenty stworzą dictionary
def zamowienie(nazwa, adres, **skladniki): #najczęściej nazywane jest **kwargs - key value arguments
print(f"Zamówienie dla {nazwa}")
print(f"Dostawa na adres {adres}")
cena = 20.00
for key, value in skladniki.items():
cena = cena + 2.00
print(f"Wartość zamówienia {cena}")
return cena
zamowienie("Kama", "Zduńska Wola", jalapenos=True, dodatkowy_ser=True, szynka=True)
def funk(**kwargs):
print("Liczba przekazanych parametrów:",len(kwargs))
for key, item in kwargs.items():
print ("Klucz:", key, "Wartość:", item)
funk(a=1,b=2,c=3)
Dekoratory
#wywołanie funkcji jako parametru funkcji
"""def simple_function():
print("Prosta funkcja")
def my_decorator(func):
def wrapper():
print("Coś robię.")
func()
print("Kontynuuję pracę")
return wrapper
new_function = my_decorator(simple_function) #podajemy funkcję jako parametr dlatego nie podajemy()
new_function()"""
#ten sam przykład co powyżej z użyciem dekoratora
def my_decorator(func):
def wrapper():
print("Coś robię.")
func()
print("Kontynuuję pracę")
return wrapper
@my_decorator
def simple_function():
print("Prosta funkcja")
simple_function()
Pozostałe funkcje wbudowane języka Python
Część funkcji omówiliśmy podczas lekcji o typach danych, poniżej lista najczęściej używanych funkcji, które nie zostały omówione na lekcjach.
Lista funkcji wbudowanych Pythona dostępna jest w dokumentacji tego języka:
https://www.w3schools.com/python/python_ref_functions.asp
https://docs.python.org/3/library/functions.html
Lista funkcji dla poszczególnych bibliotek (pakietów/modułów):
https://docs.python.org/3/search.html?q=functions&check_keywords=yes&area=default
Wersja Pythona
W celu wyświetlenia informacji o zainstalowanym języku należy skorzystać z funkcji version biblioteki sys
import sys
print(sys.version)
Operacje na dacie
https://docs.python.org/3/library/calendar.html?highlight=functions
Operacje na czasie
https://docs.python.org/3/library/time.html?highlight=functions
Operacje na dacie i czasie
https://www.w3schools.com/python/python_datetime.asp
Operacje matematyczne
https://www.w3schools.com/python/python_math.asp
Lambda
Jest to krótka, anonimowa funkcja. Przyjmuje ona dowolną liczbę argumentów i ma tylko jedno wyrażenie. Anonimowa ponieważ nie ma nazwy.
lambda a, b: a*b
Wyrażenie przyjmuje 2 argumenty i zwraca ich sumę.
Więcej informacji znajdziecie w poniższych linkach:
https://www.w3schools.com/python/python_lambda.asp
Python lambda – wszystko co trzeba wiedzieć
Operacje na ciągach znaków
Łańcuchy znaków (ciągi), to zmienne typu string, które możemy formatować za pomocą wielu funkcji wbudowanych języka Python https://www.w3schools.com/python/python_ref_string.asp
Ćwiczenia do samodzielnego wykonania:
Ćwiczenie 1: Napisz funkcję, która sprawdza, czy wprowadzona przez użytkownika liczba jest dodatnia, ujemna, czy może jest 0.
Ćwiczenie 2: Napisz funkcję, która pyta o dwie liczby i mówi czy są one równe, jeśli nie to podaje ich różnicę
Ćwiczenie 3: Napisz funkcję, która oblicza przychód po odliczeniu podatku od dochodu. Dochód i wielkość podatku (w procentach) podaje użytkownik.
Ćwiczenie 4: Podana jest nazwa pliku:
filename = '01012020_sales.xlsx’
Napisz funkcję, która sprawdzi, czy nazwa pliku jest z rozszerzeniem 'xlsx’. Wydrukuj do konsoli 'TAK’ jeśli to prawda, przeciwnie 'NIE’.
Oczekiwany wynik: TAK
Ćwiczenie 5: Podany jest poniższy łańcuch znaków:
code = 'DSVNDOICSN’
Sprawdź czy zmienna code składa się tylko z dużych liter. Wydrukuj do konsoli 'TAK’ jeśli to prawda, przeciwnie 'NIE’.
Oczekiwany wynik: TAK
Ćwiczenie 6: Podane jest poniższe hasło:
password = 'cskdnjcasa#!’
Sprawdź, czy hasło ma wymaganą długość 11 znaków. Jeżeli tak, wydrukuj 'Hasło poprawne’, w przeciwnym razie 'Hasło zbyt krótkie’.
Oczekiwany wynik:
- Hasło poprawne
Ćwiczenie 7:
Podane są zmienne:
- var1 = 'Python’
- var2 = (’Python’)
- var3 = (’Python’,)
- var4 = [’Python’]
- var5 = {’Python’}
Używając odpowiedniej funkcji, sprawdź czy podane zmienne przechowują obiekty typu tuple (krotki). Dla każdej zmiennej wynik wydrukuj w osobnej linii.
Wskazówka: Użyj funkcji wbudowanej isinstance().
Oczekiwany wynik:
- False
- False
- True
- False
- False
Ćwiczenie 8:
Podana jest poniższa lista:
- characters = [’k’, 'b’, 'c’, 'j’, 'z’, 'w’]
Wykorzystując funkcje wbudowane zwróć pierwszą i ostatnią literę ułożonych w kolejności alfabetycznej liter z listy characters. Wynik wydrukuj do konsoli tak jak pokazano poniżej.
Oczekiwany wynik:
- Pierwsza: b
- Ostatnia: z
Wskazówka: Użyj funkcji min() oraz max().
Ćwiczenie 9:
Podane są dwa obiekty typu tuple:
- ticker = (’TEN’, 'PLW’, 'CDR’)
- full_name = (’Ten Square Games’, 'Playway’, 'CD Projekt’)
Używając odpowiednich funkcji wbudowanych utwórz listę składającą się z obiektów typu tuple (ticker, full_name). Wynik wydrukuj do konsoli.
Oczekiwany wynik:
- [(’TEN’, 'Ten Square Games’), (’PLW’, 'Playway’), (’CDR’, 'CD Projekt’)]
Wskazówka: Użyj funkcji zip().
Ćwiczenie 10:
Używając odpowiedniej funkcji wbudowanej sprawdź, czy wszystkie elementy poniższego obiektu tuple zwracają wartość logiczną True:
- items = (’ ’, '0′, 0.1, True)
Wynik wydrukuj do konsoli.
Oczekiwany wynik:
- True
Ćwiczenie 11:
Używając odpowiedniej funkcji wbudowanej sprawdź, czy jakikolwiek element poniższego obiektu tuple zwracają wartość logiczną True:
-
items = ('', 0.0, 0, False)
Wynik wydrukuj do konsoli.
Oczekiwany wynik:
- False
Ćwiczenie 12:
Zlicz liczbę jedynek w binarnej reprezentacji liczby number:
- number =234
Wynik wydrukuj do konsoli.
Wskazówka: Użyj funkcji wbudowanej bin().
Oczekiwany wynik:
- 5
Ćwiczenie 13:
Podana jest lista słów:
- stocks =[’playway’, 'boombit’, 'cd projekt’]
Używając funkcji map() oraz wyrażenia lambda przekształć podaną listę w listę zawierającą długości poszczególnych słów. Wynik wydrukuj do konsoli.
Oczekiwany wynik:
- [7,7, 10]
Ćwiczenie 14:
Napisz funkcję sort_list(), która uporządkuje listę składającą się z dwuelementowych obiektów typu tuple według drugiego elementu tupli.
Przykład działania funkcji:
- [IN]: sort_list([(1, 3), (4, 1), (4, 2), (0, 7)])
- [OUT]: [(4, 1), (4, 2), (1, 3), (0, 7)]
- [IN]: sort_list([(’a’, 'b’), (’g’, 'a’), (’z’, 'd’)])
- [OUT]: [(’g’, 'a’), (’a’, 'b’), (’z’, 'd’)]
Wskazówka: Wykorzystaj funkcję sorted().
Ćwiczenie 15:
Poniżej zdefiniowana jest funkcja func_1():
- def func_1(x, y):
- return x + y + 2
Wykorzystując wyrażenie lambda zdefiniuj analogiczną funkcję i przypisz ją do zmiennej func_2().
Ćwiczenie 16:
Podana jest lista:
- items = [(3, 4), (2, 5), (1, 4), (6, 1)]
Posortuj listę według rosnącej sumy kwadratów liczb podanych w obiektach typu tuple. Użyj metody list.sort() oraz wyrażenia lambda. W odpowiedzi wydrukuj listę do konsoli.
Oczekiwany wynik:
- [(1, 4), (3, 4), (2, 5), (6, 1)]
Ćwiczenie 17:
Posortuj podaną listę słowników po kluczu price:
- stocks = [
- {’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304},
- {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309},
- {’indeks’: 'sWIG80′, 'name’: 'BBT’, 'price’: 22}
- ]
Wynik wydrukuj do konsoli.
Pomocniczy wynik:
- [{’indeks’: 'sWIG80′, 'name’: 'BBT’, 'price’: 22},
- {’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304},
- {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309}]
Oczekiwany wynik:
- [{’indeks’: 'sWIG80′, 'name’: 'BBT’, 'price’: 22}, {’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304}, {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309}]
Ćwiczenie 18:
Podana jest poniższa lista:
- stocks = [
- {’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304},
- {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309},
- {’indeks’: 'sWIG80′, 'name’: 'BBT’, 'price’: 22}
- ]
Z listy stocks wyciągnij spółki z indeksu 'mWIG40′ w postaci listy i wynik wydrukuj do konsoli.
Pomocniczy wynik:
- [{’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304},
- {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309}]
Oczekiwany wynik:
- [{’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304}, {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309}]
Ćwiczenie 19:
Podana jest poniższa lista:
- stocks = [
- {’indeks’: 'mWIG40′, 'name’: 'TEN’, 'price’: 304},
- {’indeks’: 'mWIG40′, 'name’: 'PLW’, 'price’: 309},
- {’indeks’: 'sWIG80′, 'name’: 'BBT’, 'price’: 22}
- ]
Przekształć podaną listę na listę wartości logicznych (True, False). True w przypadku, gdy spółka należy do indeksu 'mWIG40′, False przeciwnie. Przekształconą listę wydrukuj do konsoli.
Wskazówka: Skorzystaj z funkcji map().
Oczekiwany wynik:
- [True, True, False]
Ćwiczenie 20:
Podana jest poniższa lista:
- items =[’P-1′, 'R-2′, 'D-4′, 'F-6′]
Wykorzystując funkcję map() oraz wyrażenie lambda przekształć podaną listę w taki sposób, aby pozbyć się z każdego elementu znaku ’-’ (myślnik). Wynik wydrukuj do konsoli.
Oczekiwany wynik:
- [’P1′, 'R2′, 'D4′, 'F6′]
- == 'mWIG40′, stocks)))
Ćwiczenie 21:
Podane są dwie listy:
- num1 = [4, 2, 6, 2, 11]
- num2 = [5, 2, 3, 3, 9]
Listy są tej samej długości. Wykorzystując funkcję map() oraz wyrażenie lambda przekształć podane listy w jedną zawierającą resztę z dzielenia elementu pierwszej listy przez odpowiedni element drugiej listy.
Oczekiwany wynik:
- [4, 0, 0, 2, 2]
Ćwiczenie 22:
Zdefiniuj funkcję o nazwie maximum(), która zwróci maksimum z dwóch liczb. Użyj instrukcji warunkowej.
Przykładowe wywołanie funkcji:
- [IN]: maximum(4, 2)
- [OUT]: 4
- [IN]: maximum(-4, 2)
- [OUT]: 2
Ćwiczenie 23:
Zdefiniuj funkcję o nazwie maximum(), która zwróci maksimum z trzech liczb. Użyj instrukcji warunkowej.
Przykładowe wywołanie funkcji:
- [IN]: maximum(4, 2, 1)
- [OUT]: 4
- [IN]: maximum(-3, 2, 5)
- [OUT]: 5
Ćwiczenie 24:
Zdefiniuj funkcję o nazwie multi(), która jako parametr przyjmie obiekt iterowalny (lista, tupla) oraz zwróci iloczyn wszystkich elementów listy.
Przykładowe wywołanie funkcji:
- [IN]: multi((-4, 6, 2))
- [OUT]: -48
- [IN]: multi([4, 2, -5])
- [OUT]: -40
Ćwiczenie 25:
Napisz funkcję o nazwie map_longest(), która przyjmie listę słów i zwróci długość najdłuższego słowa.
Przykładowe wywołanie funkcji:
- [IN]: map_longest([’python’, 'sql’])
- [OUT]: 6
- [IN]: map_longest([’java’, 'sql’, 'r’])
- [OUT]: 4
Ćwiczenie 26:
Napisz funkcję o nazwie filter_ge_6(), która przyjmie listę słów i zwróci słowa o długości większej lub równej 6 znaków.
Przykład działania funkcji:
- [IN]: filter_ge_6([’programowanie’, 'python’, 'java’, 'sql’])
- [OUT]: [’programowanie’, 'python’]
- [IN]: filter_ge_6([’java’, 'sql’])
- [OUT]: []
Ćwiczenie 27:
Napisz funkcję o nazwie factorial(), która obliczy wartość silni z danej liczby.
Przykład działania funkcji:
- [IN]: factorial(6)
- [OUT]: 720
- [IN]: factorial(10)
- [OUT]: 3628800
Ćwiczenie 28:
Napisz funkcję count_str(), która zwróci liczbę obiektów typu str w obiekcie iterowalnym (list, tuple, set).
Przykład działania funkcji:
- [IN]: count_str([’p’, 2, 4.3, None])
- [OUT]: 1
- [IN]: count_str({’p’, 2, 4.3, True, 'True’, None})
- [OUT]: 2
Ćwiczenie 29:
Napisz funkcję count_str(), która zwróci liczbę obiektów typu str o długości powyżej 2 znaków w obiekcie iterowalnym (lista, tuple, set).
Przykład działania funkcji:
- [IN]: count_str([1, '#hello’, ”, 'python’, 'go’])
- [OUT]: 2
- [IN]: count_str([1, 2, 3, 'python’])
- [OUT]: 1
Ćwiczenie 30:
Napisz funkcję remove_duplicates(), która usunie duplikaty z listy (kolejność elementów nie musi być zachowana).
Przykład działania funkcji:
- [IN]: remove_duplicates([1, 5, 3, 2, 2, 4, 2, 4])
- [OUT]: [1, 2, 3, 4, 5]
- [IN]: remove_duplicates([1, 1, 1, 1])
- [OUT]: [1]
Ćwiczenie 31:
Napisz funkcję is_distinct(), która sprawdzi, czy lista zawiera unikalne wartości.
Przykład działania funkcji:
- [IN]: is_distinct([1, 2, 3])
- [OUT]: True
- [IN]: is_distinct([1, 2, 3, 3])
- [OUT]: False
Ćwiczenie 32:
Zdefiniowana jest funkcja function():
- def function(idx, l=[]):
- for i in range(idx):
- append(i ** 3)
- print(l)
Wywołaj funkcję function() trzykrotnie w następujący sposób:
- function(3)
- function(5, [’a’, 'b’, 'c’])
- function(6)
Przeanalizuj wyniki!
Oczekiwany wynik:
- [0, 1, 8]
- [’a’, 'b’, 'c’, 0, 1, 8, 27, 64]
- [0, 1, 8, 0, 1, 8, 27, 64, 125]
Ćwiczenie 33:
Podana jest funkcja function():
- def function(*args, **kwargs):
- print(args, kwargs)
Wywołaj funkcję function() w podanej kolejności:
- function(3, 4)
- function(x=3, y=4)
- function(1, 2, x=3, y=4)
Przeanalizuj wynik!
Oczekiwany wynik:
- (3, 4) {}
- () {’x’: 3, 'y’: 4}
- (1, 2) {’x’: 3, 'y’: 4}
Ćwiczenie 34:
Zdefiniuj funkcję is_palindrome(), która za argument przyjmie obiekt typu str i sprawdzi czy podany string jest palindromem (wyrażenie brzmiące tak samo czytane od lewej do prawej i od prawej do lewej).
Jeżeli tak, funkcja ma zwracać wartość logiczną True, przeciwnie False.
Przykład działania funkcji:
- [IN]: is_palindrome(’kajak’)
- [OUT]: True
- [IN]: is_palindrome(’ocena’)
- [OUT]: False
Ćwiczenie 35: Napisz funkcję rekurencyjną wyświetlającą ciąg Fibonacciego