Język programowania Python

Python jest obecnie najczęściej wybieranym językiem programowania dla początkujących programistów. Nie jest to jednak wyłącznie język do nauki – jest on również powszechnie stosowany przez zawodowych programistów na całym świecie. W Umiemy informatykę używamy języka Python 3.

Jeżeli zamierzasz dużo programować w Pythonie, warto zainstalować go na swoim komputerze. Jednak do opanowania podstaw wystarczy przeglądarka. Umiemy informatkę oferuje wiele ćwiczeń i przykładów, które można rozwiązywać bezpośrednio na stronie:

• Zacznij od ćwiczenia Decydowanie, w którym wystarczy wybrać poprawną odpowiedź z dwóch propozycji. Gdy poczujesz się pewniej, przejdź do ćwiczenia Wpisywanie odpowiedzi, w którym należy samodzielnie odgadnąć odpowiedź i wpisać ją na klawiaturze.
• Czytanie kodu możesz potrenować w ćwiczeniu Kod kostki, w którym Twoim zadaniem jest analiza i poprawne wykonanie gotowego programu.
• Przede wszystkim jednak spróbuj samodzielnego programowania. Służą do tego ćwiczenia Programowanie w Pythonie oraz Żółw Python. Program wpisuje się bezpośrednio w przeglądarce, gdzie można go uruchomić i automatycznie sprawdzić, czy działa poprawnie.

Dla zupełnie początkujących polecamy na rozgrzewkę zadania z sekcji myślenie algorytmiczne, gdzie podstawowe koncepcje programowania można poznać w formie graficznej.

Zmienna to nazwa, która odwołuje się do jakiejś wartości. Wartość zmiennej może się zmieniać – stąd też nazwa „zmienna“.

Nazwy zmiennych

Nazwy zmiennych mogą zawierać litery, cyfry oraz znak podkreślenia. Nie mogą zawierać spacji i nie mogą zaczynać się od cyfry. W nazwach zmiennych rozróżnia się wielkie i małe litery – czyli number i Number to dwie różne zmienne. W Pythonie zwyczajowo nazwy zmiennych pisze się małymi literami. W nazwach wielowyrazowych używamy podkreślenia, np. list_length. Python 3 pozwala również na używanie w nazwach zmiennych znaków z polskiego alfabetu, ale dobrą praktyką jest stosowanie nazw w języku angielskim. Nazwy zmiennych powinny być opisowe odzwierciedlać przechowywaną wartość.

Przykłady:

• poprawne nazwy zmiennych: name, k, max_value
• niepoprawne nazwy zmiennych: 2nd_var, actor name, max-value

Tworzenie i aktualizacja zmiennej

Zmienną tworzymy, przypisując do niej wartość. Wartość można następnie zaktualizować. Zmienna przechowuje ostatnią przypisaną wartość. Do przypisania używamy znaku równości:

x = 20       # utworzenie zmiennej x i przypisanie wartości 20

y = 5        # utworzenie zmiennej y i przypisanie wartości 5

x = 10       # zmiana wartości x na 10

print(x, y)  # wypisze 10 5

Zmienne mogą być różnego typu. Python jest językiem dynamicznie typowanym, co oznacza, że w programie nie musimy jawnie określać typu zmiennej – interpreter języka zrobi to automatycznie. Jeśli przypiszemy x = 5, zmienna x będzie automatycznie typu int (liczba całkowita).

Wyświetlanie zmiennych i wyrażeń

Do wyświetlania wartości używamy funkcji print. Funkcja ta może przyjmować kilka parametrów. Jeśli chcemy wyświetlić znaki operacji arytmetycznych, należy je ująć w cudzysłów lub apostrof. Przykłady:

a = 3

b = 8

print(a)           # wynik: 3

print(a, b)        # wynik: 3 8

print(a + b)       # wynik: 11

print(a, "+", b)   # wynik: 3 + 8

Operacje arytmetyczne

Na liczbach możemy wykonywać podstawowe operacje (działania) arytmetyczne – zapis jest taki sam jak na zwykłych kalkulatorach: (+, -, /, *). Python oferuje również inne przydatne w programowaniu operacje: dzielenie całkowite (//), dzielenie z resztą (%) oraz potęgowanie (**).

x + y      # dodawanie

x - y      # odejmowanie

x * y      # mnożenie

x / y      # dzielenie

x // y     # dzielenie całkowite

x % y      # dzielenie z resztą

x ** y     # potęgowanie

W programowaniu nie możemy pomijać zapisu mnożenia tak jak w matematyce, tzn. nie możemy pisać y = 2x, musimy użyć gwiazdki: y = 2*x.

Priorytet operacji jest taki sam jak w matematyce i podobnie jak w matematyce możemy stosować nawiasy, aby określić kolejność obliczeń.

print(2+3*4)    # -> 14

print((2+3)*4)  # -> 20

x = 5

print(3*x**2)   # -> 75

print((3*x)**2) # -> 225

Skrócony zapis

W programowaniu często aktualizujemy wartość zmiennej, dodając do niej określoną wartość, np. x = x + 1, money = money + wage. Ponieważ jest to częsta operacja, Python oferuje skrócony zapis przy użyciu operatora +=. Podobne operatory istnieją także dla innych operacji arytmetycznych.

x += 1           # to samo co x = x + 1

x *= 2           # to samo co x = x * 2

money -= price   # to samo co money = money - price

Python oferuje wbudowane funkcje do podstawowych operacji matematycznych, np.:

abs(x)        # wartość bezwzglęna x

round(x)      # wartość x zaokrąglona(do liczby całkowitej)

round(x, 2)   # wartość x zaokrąglona do dwóch miejsc po przecinku

min(x, y)     # minimum z x, y

max(x, y, z)  # maximum z x, y

Inne przydatne funkcje (np. log, sqrt, sin, floor) Python udostępnia w bibliotece math.

Program w Pythonie składa się z wielu instrukcji, które łączymy w odpowiedni sposób.

• Sekwencja poleceń oznacza wykonywanie instrukcji jedno po drugim, w ustalonej kolejności. Należy zwracać uwagę zarówno na ich dobór, jak i na właściwe uporządkowanie.
• Instrukcja warunkowa umożliwia wykonanie określonych poleceń tylko wtedy, gdy spełniony jest podany warunek.
• Pętle for i while służą do wielokrotnego wykonywania instrukcji. Każda z nich ma nieco inne zastosowanie, dlatego warto dokładnie przećwiczyć obie konstrukcje.
• Struktury sterujące można zagnieżdżać, na przykład umieszczając instrukcję warunkową wewnątrz pętli. Pętlom zagnieżdżonym poświęciliśmy osobny temat, ponieważ początkujący programiści często napotykają w tym obszarze trudności.
• Programy dzielimy na funkcje, tóre pozwalają na wielokrotne wykorzystywanie tych samych fragmentów kodu.

Osobom rozpoczynającym naukę języka Python pomocne może być wykonanie ćwiczeń z podstaw myślenia algorytmicznego, umożliwiających praktyczne przećwiczenie użycia pętli i instrukcji warunkowych w środowisku programowania graficznego.

Warunkowe wykonanie polecenia zapisujemy za pomocą if. Warunek może być dowolnym wyrażeniem logicznym. W ramach warunku możemy wykonać również więcej niż jedno polecenie. Blok poleceń oznaczamy wcięciem:

if answer != 42:           # polecenia zostaną wykonane tylko, jeśli warunek jest spełniony:

    print("Bad answer")    # wyświetlamy komunikat

    answer = 42            # dodatkowo zmieniamy zmienną

Gałąź else

Możemy również określić, co ma się stać, gdy warunek nie jest spełniony. W tym celu używamy polecenia else, po którym następuje wcięty blok poleceń:

if x < 10:

    print("small")    # wykona się, jeśli warunek jest prawdziwy

else:

    print("big")      # wykona się, jeśli warunek jest fałszywy

Poszczególne warianty obliczeń nazywamy gałęziami, a całą instrukcję warunkową możemy również określać jako rozgałęzienie.

Wielokrotne rozgałęzienie

Jeśli chcemy sprawdzić kilka możliwości, możemy użyć konstrukcji if / elif / else. W niektórych językach programowania do wielokrotnego rozgałęzienia używa się polecenia switch, ale w Pythonie wystarczy elif. Na przykład:

if age < 6:

    print("przedszkolak")

elif age < 18:        # sprawdzane, jeśli poprzedni warunek nie był prawdziwy

    print("uczeń")

elif age < 65:        # sprawdzane, jeśli żaden poprzedni warunek nie jest był prawdziwy

    print("dorosły")

else:                 # wykona się, jeśli żaden poprzedni warunek nie jest prawdziwy

    print("emeryt")

Z if/elif wykona się maksymalnie jedna – pierwsza, dla której warunek jest prawdziwy. W naszym przykładzie, jeśli w zmiennej age znajduje się wartość 15, zostanie wyświetlone tylko „uczeń”. Warunek age < 65 również jest prawdziwy, ale Python już go nie sprawdza.

Rozgałęzienia zagnieżdżone

Czasem polecenia warunkowe mogą zawierać kolejne rozgałęzienia. Mówimy wówczas o zagnieżdżaniu. W przypadku kolejnych gałęzi musimy zwiększyć wcięcie. Możemy napisać na przykład:

if choice == "tea":

    if money >= 10:

        print("ok")

    else:

        print("refuse")

else:

    print("not available")



if n % 2 == 1:

    if x > 13:

        print("Win!")

W niektórych przypadkach zamiast zagnieżdżonego kodu łatwiej i przejrzyściej jest użyć prostego polecenia warunkowego z warunkiem wykorzystującym operatory logiczne. Na przykład ostatni przykład możemy uprościć w ten sposób:

if n % 2 == 1 and x > 13:

    print("Win!")

W programowaniu wykorzystujemy pętle do powtarzania grupy poleceń. Powtórzenie często nazywamy iteracją.

Pętli for używamy w sytuacji, gdy z góry znamy liczbę powtórzeń. W pozostałych przypadkach używamy pętli while.

Prosta pętla for

Podstawowe zastosowanie pętli for polega na zwykłym powtarzaniu zestawu poleceń. Za pomocą for i in range(10) powtórzymy zestaw poleceń 10 razy. Polecenia, które mają być powtarzane, muszą być wcięte. W poniższy sposób wypiszemy dziesięć razy Hello:

for i in range(10):

    print("Hello")

Zmienna sterująca

W trakcie działania pętli zmienia się wartość zmiennej sterującej (w powyższym przykładzie jest to i). W każdym powtórzeniu pętli możemy więc wykonać coś nieco innego, w zależności od aktualnej wartości tej zmiennej. To, jakie wartości przyjmuje zmienna sterująca, określa część znajdująca się po słowie in. Jeśli użyjemy podstawowego range, zmienna sterująca będzie stopniowo zwiększana o jeden. Na przykład poniższa pętla wypisze liczby od 0 do 9:

for i in range(10):

    print(i)

W ramach pętli możemy korzystać z wielu zmiennych, ale tylko wartość zmiennej sterującej zmienia się automatycznie. Rozważmy przykład:

y = 1

z = 2

for x in range(10):

    y = x + y + z

    print(x, y, z)

Zmienną sterującą pętli jest x, którego wartość będzie się stopniowo zmieniać (od 0 do 9). Wartość zmiennej y również będzie się zmieniać, ponieważ wewnątrz pętli znajduje się instrukcja przypisania do y. Natomiast wartość zmiennej z pozostanie we wszystkich iteracjach taka sama, ponieważ z nie jest zmienną sterującą ani nie przypisujemy do niej niczego w pętli.

Zastosowanie range

W podstawowych zastosowaniach łączymy pętlę for z funkcją range, która zwraca przedział liczb, a zmienna sterująca przyjmuje kolejne wartości z tego przedziału.

Uwaga: w informatyce często liczymy od zera (a nie od jedynki jak zazwyczaj). Dlatego tutaj range(n) zwraca wartości od 0 do n-1.

Jeśli funkcji range podamy dwa parametry, tzn. wywołamy range(a, b), to otrzymamy przedział liczb od a do b-1. Możemy podać także trzeci parametr określający długość kroku. Na przykład:

for x in range(5, 13): print(x, end=" ")     # 5 6 7 8 9 10 11 12

for x in range(5, 16, 3): print(x, end=" ")  # 5 8 11 14

for x in range(8, 0, -1): print(x, end=" ")  # 8 7 6 5 4 3 2 1

Pętli for można używać nie tylko w połączeniu z range, lecz także z innymi typami danych – na przykład z listami:

for x in [3, 7, 10]:

    print(x)

Przykłady użycia pętli for

n = 20

for i in range(1, n+1):

    if i % 2 == 0:

        print(i, "jest parzysta")

    else:

        print(i, "jest nieparzysta")

n = 10

s = 0

for i in range(1, n+1):

    s = s + i

print("Suma od 1 do", n, "wynosi", s)

n = 10

for x in range(1, n+1):

    print("Dwa do potęgi", x, "wynosi", 2**x)

W programowaniu wykorzystujemy pętle do powtarzania grupy poleceń. Powtarzanie często nazywamy iteracją.

Pętlę while stosujemy, gdy nie wiemy z góry, ile razy pętla będzie się powtarzać. Jeśli z góry znamy liczbę powtórzeń, używamy pętli for.

Podstawowe zastosowanie

Pętla while powtarza się tak długo, jak spełniony jest warunek sterujący pętli (w poniższym przykładzie chodzi o n > 5). Ciało pętli (polecenia, które mają się powtarzać) zaznaczamy wcięciem.

n = 5

while n > 0:

    print("To zostanie wypisane pięć razy.")

    n = n - 1

Pętlą tą wypisujemy potęgi liczby dwa, dopóki nie przekroczą liczby sto:

n = 1

while n < 100:

    print(n)

    n = n * 2

Zero i nieskończone powtórzenia

Warunek pętli jest sprawdzany jeszcze przed pierwszym wykonaniem ciała pętli. Jeśli nie jest spełniony, ciało pętli while nie zostanie wykonane ani razu:

n = 200

while n < 100:

    print("To się nie wypisze.")

Może się zdarzyć, że pętla while nigdy się nie zakończy. Poniższy program wypisuje jedynki w nieskończoność:

n = 1

while n < 100:

    print(n)

Taka nieskończona pętla zwykle oznacza błąd w programie. Typowym błędem jest zapomnienie o zmianie wartości zmiennej użytej w warunku pętli. Taką sytuację nazywamy „wpadnięciem w pętlę nieskończoną”.

Przykłady użycia pętli while

n = 1

while n < 1000:

    print(n)

    n *= 2

total = 0

value = int(input())

while value:

    total += value

    print("Current sum:", total)

    value = int(input())

print("Final sum:", total)

Funkcja jest nazwanym blokiem poleceń. Funkcjom możemy przekazywać argumenty.

Definicja funkcji

Python oferuje całą gamę funkcji wbudowanych, czyli takich, które zostały już przygotowane przez twórców języka. Przykładem jest funkcja len, która oblicza długość łańcucha znaków.

Własną funkcję definiujemy za pomocą słowa kluczowego def:

def say_hello(name):

    print("Hello", name)

W ten sposób zdefiniowaliśmy funkcję say_hello, która ma parametr name. Funkcja może mieć również więcej parametrów.

Wywoływanie funkcji

Samo zdefiniowanie funkcji nie powoduje jej wykonania. Aby funkcja została wykonana, musimy ją wywołać. Robimy to, zapisując nazwę funkcji i przekazując w nawiasach konkretny argument:

say_hello("Alice")  # wypisze Hello Alice

say_hello("Bob")    # wypisze Hello Bob

Niektóre funkcje nie mają parametrów. Przy ich wywołaniu nadal musimy podać nawiasy, np. say_goodbye().

Wartość zwrotna

Funkcja może zwracać wartość zwrotną za pomocą słowa kluczowego return. Poniższa funkcja oblicza i zwraca silnię.

def factorial(n):

    f = 1

    for i in range(1, n+1):

        f = f*i

    return f

Taka funkcja sama w sobie nic nie wykonuje, jedynie zwraca wartość, z którą możemy dalej pracować.

factorial(5)         # obliczy wartość silni z 5, ale potem ta

                     # wartość nie zostanie w żaden sposób użyta

print(factorial(4))  # tym razem wypiszemy wynik obliczeń

x = factorial(6)     # wynik obliczeń zostanie zapisany do zmiennej

print(x)             # a następnie możemy np. wypisać wartość zmiennej

Instrukcja return kończy wykonywanie funkcji. Zatem przy wywołaniu poniższej funkcji zostanie wypisane tylko foo:

def test():

    print("foo")

    return 0

    print("bar")

Różnice między return a print

Częstym źródłem problemów u początkujących programistów jest prawidłowe użycie print i return w funkcjach.

Użycie print powoduje natychmiastowe wypisanie wartości, jednak nie można z tą wartością dalej pracować.

Użycie return kończy działanie funkcji i zwraca wartość. Nie jest ona automatycznie wypisywana, ale możemy przypisać ją do zmiennej i dalej z nią pracować.

Słownik (dictionary, dict) pozwala przechowywać dane w postaci par: klucz – wartość. Każdemu kluczowi przypisana jest konkretna wartość. Dzięki temu możemy w prosty sposób zapisać np. informację o liczbie owoców w magazynie.

Tworzenie słownika

Słownik tworzymy przy użyciu nawiasów klamrowych.

fruits = {"apple": 5,

          "banana": 10,

          "orange": 2}



empty_dictionary = {}    # pusty słownik

Dostęp do elementów

Aby odczytać wartość przypisaną do danego klucza, używamy nawiasów kwadratowych. W ten sam sposób możemy dodać nowy element do słownika.

print(fruits["apple"])

fruits["pear"] = 3

Jeśli spróbujemy odwołać się do klucza, którego nie ma w słowniku, Python zgłosi błąd. Aby tego uniknąć, warto skorzystać z get:

print(fruits["plum"])    # => KeyError: 'plum'

print(fruits.get("plum", 0))   # jeśli elementu nie ma w słowniku,

                               # zwróci podaną wartość (0)

Przydatne operacje na słownikach

Python udostępnia kilka funkcji, które ułatwiają pracę ze słownikami:

len(fruits)        # liczba kluczy w słowniku

fruits.keys()      # wszystkie klucze, czyli 'pear', 'orange', 'banana', 'apple'

fruits.values()    # wszystkie wartości, czyli 10, 2, 3, 5

"apple" in fruits  # sprawdzenie, czy klucz istnieje w słowniku