|
Serwis Edukacyjny w I-LO w Tarnowie 
Materiały dla uczniów liceum |
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2026 mgr Jerzy Wałaszek
|
|
Serwis Edukacyjny w I-LO w Tarnowie
Materiały dla uczniów liceum |
Wyjście Spis treści Wstecz Dalej
Autor artykułu: mgr Jerzy Wałaszek |
©2026 mgr Jerzy Wałaszek
|
Język programowania (ang. programming language) umożliwia wydawanie poleceń komputerowi, które ten następnie wykonuje. W pierwszych komputerach stosowano binarne kody instrukcji, które bezpośrednio rozumie komputer. Procesor najpierw pobiera kod instrukcji, a następnie analizuje go i po rozpoznaniu wykonuje pożądaną operację. Na przykład, w jednym z pierwszych komputerów Konrada Zuse program był tworzony na taśmie filmowej w postaci dziurek, które odzwierciedlały binarną postać instrukcji. Zuse wybrał taśmę, ponieważ zawierała perforację (otwory z boku) do jej przesuwu w projektorze.
Dziurka/brak dziurki jest informacją bitową. Rząd takich dziurek tworzył słowo instrukcji binarnej. Komputer Konrada Zuse rozróżniał 16 instrukcji. Gdy liczba instrukcji maszyny cyfrowej rosła, a same instrukcje stawały się coraz bardziej skomplikowane, wymyślono język asemblera (ang. assembler language). Zamiast binarnych kodów instrukcji w języku asemblera stosuje się ich nazwy symboliczne (jak ADD, SUB, JMP). Dzięki temu łatwiej je zapamiętać, a i sam program staje się dużo prostszy.
| Asembler | Kod binarny | |
START: LDA #"Z LOOP: STA $INOUT DEC JMP #LOOP END |
0001010001011010
0010100000000000
1001000000000000
1010010000000010
0000000000000000
|
Procesor rozumie tylko i wyłącznie swój kod binarny. Dlatego tworząc programy w asemblerze musimy je kompilować, czyli zamieniać na postać binarną. Konwersji takiej dokonuje program, który również nazywamy asemblerem. Pierwszy program asemblera musiał jednak być napisany bezpośrednio w kodzie binarnym.
Asembler daje programiście dostęp do wszystkich składników komputera. Jednakże tworzenie programu jest bardzo żmudne, ponieważ każdą operację należy rozbijać na poszczególne instrukcje procesora. Np. sprawdzenie, czy komórki o etykietach L1 i L2 (etykieta to nazwa obszaru pamięci, w którym jest jakaś informacja, np. liczba lub instrukcja do wykonania - dzięki etykietom programista nie musiał podawać adresów liczbowych) są sobie równe, wymaga kilku instrukcji procesora:
| Asembler |
LDA $L1 ; pobierz komórkę L1 SUB $L2 ; odejmij od niej komórkę L2 JZR #ROWNE ; jeśli wynik zero, skocz do ROWNE ... ; jeśli nie, jesteś tutaj |
Czyż nie byłoby lepiej zapisać tak?:
| Jakiś język programowania |
JEŚLI L1 = L2, TO ... INACZEJ ... |
I tak dochodzimy do koncepcji języków wysokiego poziomu – HLL (ang. High Level Language). Asembler, a tym bardziej kod binarny instrukcji procesora, to języki niskiego poziomu – LLL (ang. Low Level Language), które operują bezpośrednio na zasobach komputera: na procesorze, pamięci, rejestrach wejścia/wyjścia. Aby w nich efektywnie programować, programista musi posiadać dużą wiedzę na temat budowy komputera oraz urządzeń towarzyszących. Również musi dokładnie wiedzieć, w jaki sposób realizować złożone polecenia. Pomyłki w kodzie są trudne do wyłapania. Wszystko to powoduje, że chociaż asembler jest bardzo potężnym narzędziem, to jednak jest również bardzo trudny w opanowaniu i mało efektywny przy dużych projektach. Dzisiaj w asemblerze tworzone są tylko fragmenty programów, które muszą być naprawdę szybkie i efektywne.
Język wysokiego poziomu oddala się od sprzętu komputera i pozwala tworzyć bardziej abstrakcyjne konstrukcje, które zbliżone są do pojęć matematycznych. Dzięki temu programista może dużo szybciej pisać złożone programy, niż jest to możliwe w asemblerze. Wszystkie języki wysokiego poziomu muszą być przetwarzane na postać binarną (nie dotyczy to języków interpretowanych, tzw. skryptowych, np. PYTHON, o których dowiemy się później). Konwersję taką wykonuje program zwany kompilatorem (ang. compiler).
Pierwsze języki wysokiego poziomu zaczęły się pojawiać po II Wojnie Światowej. Wcześniej stosowano kody binarne oraz asemblery. Poniżej podajemy chronologiczną listę najważniejszych języków programowania (niech cię nie przeraża ich liczba):
Python jest językiem programowania, który zdobywa obecnie coraz większą popularność wśród programistów. Stworzył go Guido van Rossum i udostępnił w roku 1991, zatem Python ma już 33 lata. Nazwa Python pochodzi od nazwy grupy komików brytyjskich Monty Python.
Program tworzony przez programistę jest wykonywany bezpośrednio przez interpreter, czyli program tłumaczący. Interpreter odczytuje kolejne wiersze programu i rozpoznaje zawarte w nich instrukcje. Następnie interpreter wykonuje te instrukcje przez wywołanie odpowiednich procedur zawartych w bibliotekach interpretera. W efekcie program Pythona można uruchomić tuż po napisaniu.
Używany jest do:
Najnowsza wersja Pythona ma obecnie numer 3.13 i pracuje w systemach Windows 10 i 11. System Windows 7 wymaga wersji Pythona 3.8. Wszystkie te wersje są ze sobą w dużym stopniu kompatybilne i doskonale nadają się do nauki programowania.
Pierwsze programy będziemy pisać i uruchamiać w prostym edytorze IDLE zawartym w dystrybucji Pythona. Później można tworzyć programy w bardziej zaawansowanych środowiskach programowania, takich jak Thonny, Pycharm, Netbeans lub Eclipse, które są szczególnie użyteczne przy dużych projektach.
Jeśli twój komputer pracuje pod systemem Windows 7 lub 8, to pobierz ten instalator:
Python 3.8
Dla systemów Windows 10 i 11 pobierz ten instalator
Python 3.13
W drugim przypadku możesz przejść do strony https://www.python.org/, wybrać zakładkę Downloads i samemu pobrać instalator najnowszej wersji Pythona.
Po załadowaniu instalatora, uruchom go jako administrator (opis dotyczy wersji 3.12, jednakże proces instalacji niczym nie różni się od wersji 3.13):
W okienku, które się pojawi zaznacz na spodzie obie opcje i kliknij w Install Now. Instalacja się rozpocznie.
Instalacja zajmuje nieco czasu w zależności od szybkości twojego komputera. Czekaj cierpliwie, aż pojawi się okienko końcowe:
Kliknij w przycisk Close, aby zakończyć pracę instalatora.
Kliknij lupkę na pasku zadań (w Window 7 kliknij w przycisk Start) i wpisz:
py
Polecenie to uruchamia tzw. konsolę Pythona, czyli okienko tekstowe, w którym możesz wpisywać różne rozkazy języka Python. Służy ono głównie do celów testowych. W okienku pojawi się tekst:
Python 3.13.1 (tags/v3.13.1:0671451, Dec 3 2024, 19:06:28) [MSC v.1942 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license()" for more information. >>>
W ostatnim wierszu trzy znaki >>> oznaczają oczekiwanie na rozkaz. Wpisz liczbę 5:
>>> 5 5 >>>
Python w odpowiedzi wypisał tę liczbę: wynikiem 5 jest po prostu 5. Wpiszmy teraz jakąś operację arytmetyczną, np.:
>>> 5+7 12 >>>
Teraz Python obliczył wynik i wypisał go. Masz zatem prosty kalkulator:
>>> 3 - 5 -2 >>> 7 * 4 28 >>> 12 / 4 3.0 >>>
Zwróć uwagę na ostatni wynik: 3.0. W Pythonie mamy dwa rodzaje liczb: całkowite i rzeczywiste. Jeśli w zapisie liczby pojawi się kropka, to liczba jest rzeczywista i może przyjmować wartości ułamkowe:
>>> 2.5 + 1 3.5 >>> 4.25 - 2.75 1.5 >>> 33.7 * 8.2 276.34 >>>
Operator dzielenia / zawsze daje wynik rzeczywisty, dlatego otrzymaliśmy 3.0, czyli liczbę rzeczywistą. Istnieje również operator dzielenia całkowitego //:
>>> 12 // 4 3 >>> 25 // 10 2 >>>
Jeśli jesteśmy przy dzieleniu całkowitym, to poznajmy jeszcze jeden operator: % - reszta z dzielenia. Operacja taka nosi nazwę modulo. Reszta z dzielenia to to, co pozostaje po dzieleniu całkowitym, np:
10 // 3 = 3 10 % 3 = 1
3 mieści się 3 razy w 10 i zostaje reszta 1:
12 // 4 = 3 12 % 4 = 0
4 mieści się 3 razy w 12 i zostaje reszta 0. Reszta zero powstaje zawsze, gdy dana liczba dzieli inną całkowitą liczbę razy.
Operatory operacji arytmetycznych są następujące:
+ : dodawanie - : odejmowanie * : mnożenie / : dzielenie rzeczywiste // : dzielenie całkowite % : reszta z dzielenia całkowitego
W wyrażeniu może wystąpić wiele operatorów operacji arytmetycznych:
>>> 3 * 2 + 5 // 3 7 >>> 5 * 5 * 5 * 5 625 >>>
Operacje wykonywane są w kolejności:
mnożenia / dzielenia i reszty
dodawania / odejmowania
3 * 2 + 5 // 3
6 + 1
7
Jeśli potrzebujesz innej kolejności, to stosujesz nawiasy ( ):
>>> 5 * (4 + 3) // (4 - 1) 11 >>>
Wyrażenie w nawiasach jest obliczane w pierwszej kolejności:
5 * (4 + 3) // (4 - 1)
5 * 7 // 3
35 // 3
11
Python posiada operator potęgowania **:
>>> 2 ** 3 8 >>> 3 ** 75 608266787713357709119683992618861307 >>>
W pytonie liczba całkowita może być dowolnie duża (istnieje ograniczenie do 4300 cyfr, ale zakres ten można powiększać). O liczbach pomówimy dokładniej na dalszych lekcjach.
Operator potęgowania ** pozwala nam obliczać pierwiastki
(pierwiastek jest potęgą ułamkową
>>> 2 ** 0.5 1.4142135623730951 >>> liczba ** 0.5 lub liczba ** (1 / 2) = pierwiastek kwadratowy z liczba liczba ** (1 / 3) = pierwiastek sześcienny z liczba liczba ** 0.25 lub liczba ** (1 / 4) = pierwiastek czwartego stopnia z liczba ...
W wyrażeniu 5 ** (1 / 3) (pierwiastek sześcienny z 5) nawiasy przy (1 / 3) są konieczne, gdyż operacja potęgowania ** posiada wyższy priorytet (ważność) od operacji +, -, *, /, // i %; bez nawiasów komputer obliczyłby:
5 ** 1 / 3
5 / 3
1.6666...
>>> 5 ** 1 / 3
1.6666666666666667
>>> 5 ** (1 / 3)
1.7099759466766968
>>>
Pracę z konsolą Pythona kończysz przez naciśnięcie klawiszy
Ctrl+Z i Enter lub wpisanie polecenia
Operatory arytmetyczne:
+ dodawanie - odejmowanie * mnożenie / dzielenie rzeczywiste // dzielenie całkowite % reszta z dzielenia ** potęgowanie
Kolejność działań:
( ) ** * / // % + -
Zaczniemy od przygotowania katalogu na program. Postępuj wg wskazówek nauczyciela i utwórz na swoim komputerze katalog p001 w swoim katalogu klasowym.
Następnie kliknij lupkę na pasku zadań i wpisz idle:
System powinien wyszukać aplikację IDLE. Uruchom ją. W zależności od ustawień IDLE może się otworzyć w trybie konsoli Pythona lub w trybie edytora. Jeśli chcemy pisać program, a nie wykonywać interaktywnie polecenia Pythona, to powinniśmy przejść do trybu edytora. Naciśnij Ctrl+N. To otwiera okno edytora, w którym można pisać program.
Pierwszy program tradycyjnie wita się z użytkownikiem. W Pythonie robi się to bardzo prosto. Wpisz w edytorze:
print("Witaj w środowisku języka Python!")
Program jest uruchamiany z dysku, zatem jeśli chcemy uruchomić nasz program, musimy go sobie zapisać na dysk.
Naciśnij Ctrl+S. W okienku zapisu wejdź do katalogu, który utworzyłeś poprzednio, zmień nazwę pliku na witaj.py – skrypty Pythona mają standardowo rozszerzenie py. Na koniec kliknij przycisk Zapisz lub wciśnij klawisz Enter.
Gdy plik zostanie zapisany, możemy go uruchomić bezpośrednio z edytora. Naciśnij klawisz F5. Jeśli plik nie zawiera błędu, to w konsoli Pythona pojawi się tekst:
Witaj w środowisku języka Python!
Jeśli są błędy, poproś o pomoc nauczyciela - na błędach też się można uczyć.
Teraz przeanalizujmy nasz "program".
W języku Python program składa się z wierszy, w których umieszczamy instrukcje do wykonania przez komputer. Nasz program składa się z jednego wiersza, w którym wpisaliśmy:
print("Witaj w środowisku języka Python!")
Słowo print oznacza tzw. funkcję lub procedurę, która drukuje tekst w oknie konsoli. Za słowem print znajdują się nawiasy (...). W nawiasach tych umieszczamy informację, którą funkcja print ma wydrukować. Tutaj informacją tą jest tekst umieszczony w cudzysłowach. Teksty umieszczamy albo w cudzysłowach (np. "Ania"), albo w apostrofach (np. 'Ania'). Cudzysłowy i apostrofy obejmują tekst, który zostanie przekazany do print jako parametr, z którym print ma coś zrobić: tutaj ma wydrukować ten tekst.
Dopisz do programu następną instrukcję print, która wydrukuje podkreślenie:
print("Witaj w środowisku języka Python!")
print('---------------------------------')
Zauważ, iż tutaj do ograniczania tekstu zostały użyte apostrofy. Zapisz program na dysk (Ctrl+S), a następnie uruchom go (F5).
Do programu dodamy teraz tzw. komentarze. Komentarz jest dowolnym tekstem, który umieszczamy po znaku #. Komentarz obowiązuje od tego znaku do końca wiersza. Komentarze są użyteczne do wpisywania różnych uwag i wyjaśnień, będziemy z nich często korzystać w programach.
Przejdź w edytorze na początek programu przed print(..., naciśnij klawisz Enter, aby otrzymać pusty wiersz, po czym wprowadź do niego komentarz:
# Program nr 001
print("Witaj w środowisku języka Python!")
print('---------------------------------')
Wciśnij Enter i w drugim wierszu wpisz następny komentarz z dzisiejszą datą:
# Program nr 001
# 11.03.2024
print("Witaj w środowisku języka Python!")
print('---------------------------------')
Przejdź na koniec ostatniego wiersza, wciśnij Enter i dopisz polecenie:
# Program nr 001
# 4.02.2024
print("Witaj w środowisku języka Python!")
print('---------------------------------')
input("Naciśnij Enter...")
Funkcja input(...) wyświetla tekst przesłany w parametrze i czeka, aż użytkownik coś wpisze i wciśnie klawisz Enter. Jest to przydatne wtedy, gdy chcemy wstrzymać program, aż do reakcji użytkownika. Więcej o input(...) powiemy na następnej lekcji.
Zapisz program na dysk i uruchom go ponownie (F5). Komentarze są ignorowane i nie wpływają na sposób wykonania programu. W oknie konsoli pojawi się tekst:
Witaj w środowisku języka Python! --------------------------------- Naciśnij Enter...
Pierwszy program jest gotowy.
Program możesz uruchamiać bezpośrednio w aplikacji IDLE. Plik w edytorze należy zapisać na dysku, po czym naciskasz klawisz F5 i zapisany program zostanie uruchomiony w konsoli Pythona.
Innym sposobem jest wykorzystanie Eksploratora plików. Ikona tej aplikacji ma postać żółtej teczki i znajduje się na pasku zadań:
Uruchom Eksplorator plików i przejdź do katalogu, w którym zapisałeś swój program. Powinieneś zobaczyć ikonę pliku programu. Kliknij w nią dwukrotnie lewym przyciskiem myszki. Program uruchomi się w okienku konsoli Pythona.
Uwaga: Jeśli na końcu programu nie wstawiłeś funkcji input(...), to program zakończy działanie i okienko konsoli natychmiast zniknie.
Kolejnym sposobem uruchamiania programów Pythona jest wykorzystanie konsoli znakowej Windows. Naciśnij klawisze Window+R (klawisz Window to klawisz z okienkiem z lewej strony u dołu klawiatury). Na ekranie pojawi się okienko uruchamiania. Wpisz w nim nazwę cmd i naciśnij Enter:
cmd to tzw. Interpreter Poleceń (ang. Command Interpreter). Program ten wyświetla okno konsoli i oczekuje na polecenia użytkownika wpisane z klawiatury. Najpierw musisz przejść do swojego katalogu z programem. Pomocne tutaj mogą być dwa polecenia:
cd (ang.
change directory) : zmiana bieżącego katalogu
dir (ang. directory) : wyświetlenie
zawartości bieżącego katalogu
Postępuj zgodnie ze wskazówkami nauczyciela.
Gdy przejdziesz do katalogu z programem witaj.py, wpisz polecenie: python witaj.py. Program zostanie uruchomiony i w oknie konsoli zobaczysz wypisywany przez niego tekst:
D:\python\p001>python witaj.py Witaj w środowisku języka Python! --------------------------------- Naciśnij Enter...
Polecenie to uruchamia interpreter języka Python i przekazuje do niego program witaj.py. To nie wyczerpuje wszystkich możliwości uruchamiania programu w języku Python, jednak na razie nam powinno wystarczyć.
Instrukcja print(...) pozwala wyświetlać różne informacje. Uruchom poniższy program:
# Program napisy.py demonstruje użycie
# cudzysłowów w łańcuchach znaków
print("Program 'napisy.py' wyświetla")
print("ciekawego", "rodzaju", "napis,")
print("wykorzystując",
"własności",
"tekstów.")
print("Oto", end=" ")
print("on...")
print(
"""
-----------------------------------------
#### ##### # # # ### # # ###
# # # # # # # # ## ## # #
#### #### ### # ##### # # # #####
# # # # # # # # # # # #
# # ##### # # ##### # # # # # #
-----------------------------------------
"""
)
input("\n\nNaciśnij Enter...")
Przeanalizujmy ważniejsze elementy tego programu:
# ... |
Komentarz, zawiera dowolny tekst, który jest ignorowany przez interpreter Pythona. Komentarz rozpoczyna się za znakiem # i kończy wraz z końcem wiersza. Edytor wyświetla komentarze w oddzielnym kolorze. |
print(...) |
Instrukcja wyświetla to, co otrzymuje jako parametry. Parametry nie są obowiązkowe. Pusta instrukcja print() wyświetla wiersz pusty. |
"...(')..."
|
Obejmuje tekst, który może zawierać apostrofy. |
'...(")...'
|
Obejmuje tekst, który może zawierać cudzysłowy. |
print("...", "...", ...)
|
W jednej instrukcji print(...) może być kilka parametrów rozdzielonych przecinkami. Na wydruku zostaną one rozdzielone spacjami. |
print("...",
"...",
...)
|
Parametry instrukcji można umieszczać w osobnych wierszach. Ostatni parametr należy zakończyć nawiasem zamykającym instrukcji print. Parametry wciąż należy rozdzielać przecinkami. |
print(..., end=" ") |
Domyślnie instrukcja print(...) wyświetla swe parametry w jednym wierszu i kończy wyświetlanie przejściem do następnego wiersza. Jeśli na końcu wstawimy end="...", to po wyświetleniu informacji zostanie wyświetlony tekst umieszczony za end= i nie nastąpi automatyczne przejście do nowego wiersza. Pozwala to wyświetlać w jednym wierszu dane z kilku kolejnych instrukcji print. |
""" ... ... """ ''' ... ...''' |
Trzy cudzysłowy (trzy apostrofy) pozwalają objąć tekst zbudowany z kilku wierszy. |
".../n..." '.../n...' |
Znaki /n są traktowane jako jedna całość. Jest to tzw. znak sterujący nowego wiersza (ang. newline control character). Powoduje on zakończenie wyświetlania bieżącego wiersza i przejście na początek następnego. |
input("...")
input('...')
|
Instrukcja input(...) wyświetla tekst otrzymany w parametrze, a następnie odczytuje znaki wprowadzone przez użytkownika z klawiatury komputera i zwraca je jako wiersz tekstu, gdy użytkownik po ich wprowadzeniu naciśnie klawisz Enter. Tutaj wprowadzony tekst zostanie zignorowany. Zadaniem tej instrukcji jest wstrzymanie zakończenia programu aż do momentu, gdy użytkownik naciśnie klawisz Enter. Parametr input() można pominąć, wtedy instrukcja nic nie wyświetli, będzie jedynie odczytywała wprowadzany tekst do momentu naciśnięcia klawisza Enter. |
W języku Python zmienna jest obiektem, który wskazuje informację przetwarzaną przez komputer. Zmienne posiadają nazwy, poprzez które program odwołuje się do wskazywanej informacji. Nazwa zmiennej składa się z dużych i małych liter (również polskich, lecz lepiej ich unikać), znaku podkreślenia oraz cyfr. Cyfra nie może być pierwszym znakiem nazwy zmiennej. Duże i małe litery są rozróżniane. Nazwa zmiennej powinna być prosta oraz informować o wskazywanym przez zmienną obiekcie.
Poprawne nazwy:
a,b,x,ya12,c125,xy3adres,imie,nazwisko,wynik
Należy unikać nazw:
miś_Uszatek_lubi_miodek_z_rana_i_z_wieczora - za długa! miś Uszatek lubi miodek- zawiera spacje! 12_litrów- cyfry na początku nazwy! l - litera "l" zbyt przypomina cyfrę 1! Rqsx678nj43- trudna i nic nie mówi!
W programie każda zmienna musi zostać zdefiniowana, zanim będzie można jej użyć. definicja zmiennej wygląda następująco:
nazwa_zmiennej = wyrażenie
Komputer oblicza wartość wyrażenia i wynik umieszcza w pamięci, następnie tworzy zmienną o podanej nazwie (jeśli taka zmienna jeszcze nie została utworzona) i umieszcza w niej odwołanie do miejsca w pamięci, w którym jest umieszczony wynik. Znak równości "=" jest tzw. operatorem przypisania (operator to element wykonujący jakąś operację, np. operator "+" wykonuje dodawanie). Operator przypisania przypisuje wartość do zmiennej.
Przykład:
a = 1200 - 300
Komputer wylicza wartość wyrażenia 1200 - 300 = 900, tworzy w swojej pamięci miejsce na wynik, umieszcza w nim liczbę 900, tworzy zmienną o nazwie a, na koniec umieszcza w tej zmiennej adres miejsca z liczbą 900. Od tego momentu zmienna a zachowuje się tak, jakby była liczbą 900. Uruchom program:
# Zmienne w Pythonie #------------------- a = 1200 - 300 print(a)
W wyniku otrzymasz:
900 |
Termin zmienna oznacza, iż w programie zmienna może zmieniać swoją zawartość. Uruchom:
# Zmienne w Pythonie #------------------- a = 1200 - 300 print(a) a += 1 print(a)
Teraz otrzymasz:
900 901 |
Instrukcja print( ) wyświetla wartość przypisaną zmiennej, tzn. to, co zmienna wskazuje. Pierwsza wartość 900 odnosi się do wyniku wyrażenia 1200 - 300, który komputer wyliczył najpierw. Następnie operator "+=" zwiększa tę wartość o 1. Wynik tego zwiększenia zostaje zapisany w nowym miejscu w pamięci i jego adres trafia do zmiennej a. Teraz zmienna a wskazuje wartość 901. Poprzednie 900 nie jest już potrzebne, zatem Python usuwa je z pamięci, czyli sprząta śmieci. Druga instrukcja print( ) ponownie wyświetla to, na co wskazuje zmienna a, lecz tym razem jest to nowa wartość 901.
W Pythonie zmienna może wskazywać dowolny obiekt. Istnieje specjalna funkcja type(zmienna), która zwraca nam informację o typie wskazywanych przez zmienną danych. Uruchom program:
# Zmienne w Pythonie #------------------- a = "Alicja" print(a,type(a))
Zostanie wyświetlony wiersz tekstu:
Alicja <class 'str'> |
Tekst "Alicja" jest obiektem, na który wskazuje zmienna a. Kolejny napis jest wynikiem zwróconym przez funkcję type(a). Informuje on o typie obiektu wskazywanego przez zmienną a. Słowo class oznacza tu obiekt, Język Python jest językiem obiektowym. Słowo 'str' jest skrótem angielskiego słowa string, które oznacza tu ciąg znaków, czyli tekst. A zatem zmienna a wskazuje tekst.
Dopisz do programu kolejne dwie instrukcje i uruchom go:
# Zmienne w Pythonie #------------------- a = "Alicja" print(a,type(a)) a = 1250 print(a,type(a))
Wynikiem będą dwa wiersze:
Alicja <class 'str'> 1250 <class 'int'> |
Pierwszy wiersz jest taki sam jak poprzednio i odnosi się on do sytuacji, gdy zmienna a wskazuje tekst "Alicja". Następnie program przypisuje zmiennej a wartość 1250. Tutaj funkcja type(a) zwróci: <class 'int'>. Słowo class oznacza obiekt, a 'int' pochodzi od angielskiego integer, czyli liczba całkowita. Dopisz do programu kolejne dwie instrukcje i uruchom go:
# Zmienne w Pythonie #------------------- a = "Alicja" print(a,type(a)) a = 1250 print(a,type(a)) a = 3.1415 print(a,type(a))
Wynikiem będą trzy wiersze:
Alicja <class 'str'> 1250 <class 'int'> 3.1415 <class 'float'> |
Za trzecim razem przypisujemy zmiennej a liczbę 3.1415 (fragment liczby π). Tym razem wynikiem funkcji type(a) jest <class 'float'>. Słowo float pochodzi od angielskiego floating point number (liczba zmiennoprzecinkowa, czyli liczba rzeczywista, która może mieć wartość ułamkową, zatem nie jest liczbą całkowitą).
Wynika z tego co następuje: w języku Python zmienne tworzymy przez przypisanie za pomocą operatora przypisania "=". Zmienna może wskazywać różnego rodzaju obiekty w pamięci. Informację o rodzaju obiektu wskazywanego przez zmienną otrzymujemy przy pomocy funkcji type(zmienna):
Informację możemy przypisywać do zmiennych przy pomocy funkcji input( ). Przypomnijmy, input( ) odczytuje tekst wprowadzany przez użytkownika przy pomocy klawiatury. Naciskane klawisze są zapamiętywane do momentu naciśnięcia klawisza Enter. Wtedy zapamiętany tekst funkcja input( ) zwraca jako wynik. Tekst ten komputer może zapamiętać i przypisać zmiennej. Uruchom poniższy program:
# Zmienne w Pythonie
#-------------------
imie = input("Jak masz na imię? ")
print("Witaj,",imie,"!")
Jak masz na imię? Kazio Witaj, Kazio ! |
Program odczytuje tekst z klawiatury za pomocą funkcji input( ). Do funkcji można przesłać w parametrze krótki tekst, który zostanie wyświetlony, po czym funkcja odczytuje tekst z klawiatury aż do momentu naciśnięcia klawisza Enter. Wtedy odczytany tekst zostaje zwrócony jako wynik funkcji input( ). Tekst ten komputer zapamiętuje w pamięci, a następnie operator "=" tworzy zmienną imię i umieszcza w niej adres obszaru przechowującego odczytany tekst. W ten sposób zmienna imię staje się równoważna ze wskazywanym tekstem. Instrukcja print( ) wyświetla powitanie wraz z tekstem wskazanym przez zmienną imię.
Kolejny program oblicza pole i obwód prostokąta. Wzory poznałeś na matematyce:
| a |
|
pole = a · b obwód = 2(a + b) |
| b |
Wpisz i uruchom program:
# Zmienne w Pythonie
#-------------------
print("Pole i obwód prostokąta")
print("-----------------------")
a = input("bok a = ")
b = input("bok b = ")
pole = a * b
obwod = 2 * (a + b)
print("pole :", pole)
print("obwod :", obwód)
Otrzymasz:
| Pole i obwód prostokąta ----------------------- bok a = 10 bok b = 20 Traceback (most recent call last): File "F:\prj\python\p001\001.py", line 8, in <module> pole = a * b ~~^~~ TypeError: can't multiply sequence by non-int of type 'str' |
Jeśli na wydruku pojawi się czerwony tekst zamiast wyniku, to znaczy to, iż wystąpił błąd. W przedostatnim wierszu Python pokazuje ci instrukcję, w której doszło do błędu. Tutaj jest to instrukcja:
czyli przy wyliczaniu pola. W ostatnim wierszu znajduje się informacja o rodzaju błędu:
Błąd ten spowodowany był tym, iż funkcja input( ) zwraca tekst, czyli ciąg znaków, nawet jeżeli wprowadzisz liczbę. Np. 20 zostanie zwrócone jako tekst złożony z dwóch cyfr '2' i '0'. Tekst nie jest liczbą, dlatego Python nie wie jak wykonać mnożenie tekst razy tekst. Tekst należy najpierw zmienić w liczbę. Załóżmy, że wystarczają nam liczby całkowite. Użyjemy funkcji int(tekst), która zmienia zapis liczby całkowitej (np. '2' '0') w wartość całkowitą. W tym celu zmodyfikuj program:
# Zmienne w Pythonie
#-------------------
print("Pole i obwód prostokąta")
print("-----------------------")
a = int(input("bok a = "))
b = int(input("bok b = "))
pole = a * b
obwód = 2 * (a + b)
print("pole :", pole)
print("obwód :", obwód)
| Pole i obwód prostokąta ----------------------- bok a = 10 bok b = 20 pole : 200 obwód : 60 |
Uruchom ponownie program i jako długość boku a wpisz 10.5:
| Pole i obwód prostokąta ----------------------- bok a = 10.5 Traceback (most recent call last): File "F:\prj\python\p001\001.py", line 6, in <module> a = int(input("bok a = ")) ValueError: invalid literal for int() with base 10: '10.5' |
Znów pojawił się czerwony tekst błędu. W przedostatnim wierszu mamy instrukcję, w której wystąpił błąd:
Czyli przy odczycie długości boku a.
Ostatni wiersz opisuje ten błąd:
Błąd ten oznacza, iż otrzymany tekst w funkcji int( ) nie przedstawia liczby całkowitej. Zapis 10.5 oznacza liczbę rzeczywistą. Zatem funkcja int( ) nie może przekształcić tego zapisu w wartość całkowitą. Aby wszystko zaczęło należycie pracować, musimy zmienić funkcję int( ) na float( ). Funkcja float( ) zamienia zapis tekstowy liczby rzeczywistej w wartość rzeczywistą:
# Zmienne w Pythonie
#-------------------
print("Pole i obwód prostokąta")
print("-----------------------")
a = float(input("bok a = "))
b = float(input("bok b = "))
pole = a * b
obwód = 2 * (a + b)
print("pole :", pole)
print("obwód :", obwód)
| Pole i obwód prostokąta ----------------------- bok a = 10.5 bok b = 20.4 pole : 214.2 obwód : 61.8 |
Teraz wszystko działa prawidłowo. Pamiętaj, aby liczby rzeczywiste wprowadzać z kropką jako przecinek dziesiętny. Jest to standardowy zapis anglosaski.
 |
Zespół Przedmiotowy Chemii-Fizyki-Informatyki w I Liceum Ogólnokształcącym im. Kazimierza Brodzińskiego w Tarnowie ul. Piłsudskiego 4 ©2026 mgr Jerzy Wałaszek |
Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone pod warunkiem podania źródła oraz niepobierania za to pieniędzy.
Pytania proszę przesyłać na adres email:
Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.