Instrukcja return, zmienne lokalne i globalne, zakresy widocznosci
ð Podstawa programowa: II.1Instrukcja return pozwala funkcji zwrocic wartosc do miejsca, w ktorym zostala wywolana. Dzieki temu mozna uzyc wyniku funkcji w dalszych obliczeniach.
print() vs funkcja z return: Funkcja z print() tylko wyswietla wynik na ekranie. Funkcja z return przekazuje wartosc - mozna ja zapisac w zmiennej, uzyc w wyrazeniu, przekazac do innej funkcji.
# Funkcja ZWRACAJACA wartosc
def pole_prostokata(a, b):
return a * b
# Mozna uzyc wyniku na wiele sposobow:
p = pole_prostokata(5, 3)
print(f"Pole = {p}") # Pole = 15
print(f"Podwojne pole = {pole_prostokata(5, 3) * 2}") # 30
# Porownanie z funkcja bez return:
def pole_prostokata_print(a, b):
print(a * b) # tylko wyswietla, nic nie zwraca
wynik = pole_prostokata_print(5, 3) # wyswietli 15
print(wynik) # None! - bo funkcja nic nie zwracadef podziel_z_reszta(a, b):
iloraz = a // b
reszta = a % b
return iloraz, reszta # zwraca krotke (tuple)
i, r = podziel_z_reszta(17, 5)
print(f"17 / 5 = {i} reszty {r}") # 17 / 5 = 3 reszty 2Zmienne zdefiniowane wewnatrz funkcji sa lokalne - istnieja tylko w tej funkcji:
def moja_funkcja():
x = 10 # zmienna lokalna
print(x) # 10
moja_funkcja()
# print(x) # BLAD! x nie istnieje poza funkcjaZmienne zdefiniowane poza funkcjami sa globalne - dostepne w calym programie:
PI = 3.14159 # zmienna globalna
def pole_kola(r):
return PI * r ** 2 # mozna odczytac PI
print(pole_kola(5)) # 78.53975Aby zmieniac zmienna globalna wewnatrz funkcji, nalezy uzyc global (ale tego unikamy!):
licznik = 0
def zwieksz():
global licznik # deklaracja - bedziemy modyfikowac globalna
licznik += 1
zwieksz()
zwieksz()
print(licznik) # 2return. Programy staja sie latwiejsze do zrozumienia i debugowania.
def zastosuj(funkcja, lista):
"""Stosuje funkcje do kazdego elementu listy."""
wyniki = []
for element in lista:
wyniki.append(funkcja(element))
return wyniki
def kwadrat(x):
return x ** 2
liczby = [1, 2, 3, 4, 5]
kwadraty = zastosuj(kwadrat, liczby)
print(kwadraty) # [1, 4, 9, 16, 25]Napisz funkcje silnia(n) i potega(a, n), ktore ZWRACAJA wynik (nie wyswietlaja go). Przetestuj uzywajac ich w wyrazeniach, np. print(silnia(5) + potega(2, 3)).
def silnia(n):
wynik = 1
for i in range(1, n + 1):
wynik *= i
return wynik
def potega(a, n):
wynik = 1
for i in range(n):
wynik *= a
return wynik
# Testy
print(f"5! = {silnia(5)}") # 120
print(f"2^3 = {potega(2, 3)}") # 8
print(f"5! + 2^3 = {silnia(5) + potega(2, 3)}") # 128Napisz funkcje moje_min(a, b, c) i moje_max(a, b, c), ktore zwracaja odpowiednio najmniejsza i najwieksza z trzech liczb. NIE uzywaj wbudowanych min()/max().
def moje_min(a, b, c):
najmniejsza = a
if b < najmniejsza:
najmniejsza = b
if c < najmniejsza:
najmniejsza = c
return najmniejsza
def moje_max(a, b, c):
najwieksza = a
if b > najwieksza:
najwieksza = b
if c > najwieksza:
najwieksza = c
return najwieksza
print(moje_min(5, 2, 8)) # 2
print(moje_max(5, 2, 8)) # 8Napisz funkcje celsius_na_fahrenheit(c) i fahrenheit_na_celsius(f) zwracajace przekonwertowana temperature. Wzory: F = C * 9/5 + 32, C = (F - 32) * 5/9. Wyswietl tabele konwersji od 0 do 100 stopni C co 10 stopni.
def celsius_na_fahrenheit(c):
return c * 9/5 + 32
def fahrenheit_na_celsius(f):
return (f - 32) * 5/9
print(f"{'Celsius':>10} | {'Fahrenheit':>12}")
print("-" * 25)
for c in range(0, 101, 10):
f = celsius_na_fahrenheit(c)
print(f"{c:>10} | {f:>12.1f}")Przeanalizuj ponizszy kod BEZ uruchamiania. Zapisz, co zostanie wyswietlone na ekranie. Nastepnie uruchom i sprawdz swoje odpowiedzi.
x = 10
def f1():
x = 20
print(f"f1: x = {x}")
def f2():
print(f"f2: x = {x}")
def f3():
global x
x = 30
print(f"f3: x = {x}")
f1()
print(f"glowny: x = {x}")
f2()
f3()
print(f"glowny: x = {x}")# Wynik:
# f1: x = 20 (lokalne x w f1)
# glowny: x = 10 (globalne x bez zmian)
# f2: x = 10 (f2 czyta globalne x)
# f3: x = 30 (f3 modyfikuje globalne x)
# glowny: x = 30 (globalne x zmienione przez f3)