Typy Danych - Klasyfikacja Odkryć

Witaj ponownie w obozie! Wczoraj wpisałem "12" + 5 i zamiast 17 dostałem błąd, bo "12" to tekst, a 5 to liczba. Każdy dobry badacz musi umieć klasyfikować swoje odkrycia, a w Pythonie te "gatunki" nazywamy typami danych.

Podstawowe typy danych w Pythonie

W dżungli spotykamy różne formy życia - zwierzęta, rośliny, owady. Podobnie w Pythonie mamy różne typy danych.

1. int (Integer) - Liczby całkowite

Liczby całkowite opisują wszystko, co liczymy na sztuki: członków zespołu, dni marszu, okazy. Mogą być ujemne i bardzo duże:

1# Liczby całkowite - jak liczba odkrytych gatunków
2species_count = 42
3expedition_day = 7
4team_members = 5
5
6# Mogą być ujemne
7temperature_drop = -5
8depth_below_sea = -100
9
10# Python 3 obsługuje bardzo duże liczby!
11huge_number = 999999999999999999999

Python sam przydziela pamięć dużym liczbom, więc huge_number się nie przepełni. Int nigdy nie ma kropki.

2. float (Float) - Liczby zmiennoprzecinkowe

Pomiary rzadko wychodzą równe: temperatura czy dystans mają część dziesiętną. Do nich służy float, zapisywany z kropką albo naukowo:

1# Liczby z częścią dziesiętną
2temperature = 32.5
3humidity = 78.3
4distance_km = 15.7
5
6# Notacja naukowa
7speed_of_light = 3e8  # 3 * 10^8 = 300000000.0 (float!)
8tiny_number = 1.5e-10  # 0.00000000015

Zapis 3e8 zawsze daje float, nawet gdy wynik jest okrągły. Floaty bywają nieprecyzyjne na końcowych miejscach: 0.1 + 0.2 to 0.30000000000000004.

3. str (String) - Teksty

Nazwy, opisy i notatki to teksty. String zamykamy w cudzysłowach pojedynczych lub podwójnych, a dłuższy opis w potrójnych:

1# Tekst w cudzysłowach pojedynczych lub podwójnych
2explorer_name = "Darwin"
3location = 'Serengeti'
4
5# Multi-line stringi (potrójne cudzysłowy)
6description = """
7To jest dłuższy opis
8obejmujący wiele linii
9tekstu.
10"""
11
12# Escape characters
13message = "Darwin powiedział: \"Eksplorujmy!\""
14path = "C:\\Users\\Darwin\\jungle"  # Windows path
15
16# Raw string (ignoruje escape)
17path_raw = r"C:\Users\Darwin\jungle"

Ukośnik wsteczny zmienia znaczenie następnego znaku: \" wstawia cudzysłów do napisu, a para ukośników daje jeden. Litera r wyłącza tę zamianę, co ułatwia ścieżki Windows.

4. bool (Boolean) - Wartości logiczne

Czy teren jest bezpieczny? Czy znaleźliśmy wodę? Na takie pytania odpowiada bool, który ma tylko dwie wartości:

1# Tylko dwie wartości: True lub False
2is_dangerous = True
3found_water = False
4is_raining = True
5
6# Wynik porównania to bool
7temperature = 35
8is_hot = temperature > 30  # True
9
10age = 15
11is_adult = age >= 18  # False

Porównania zawsze zwracają bool, dlatego 5 > 3 daje True. Wielkość liter ma znaczenie: true małą literą to dla Pythona nieznana nazwa.

Sprawdzanie typu danych - type()

Gdy nie wiesz, z jakim gatunkiem masz do czynienia, zapytaj Pythona. Funkcja type() zwraca typ wartości:

1# Funkcja type() pokazuje typ zmiennej
2species_count = 42
3print(type(species_count))  # <class 'int'>
4
5temperature = 32.5
6print(type(temperature))  # <class 'float'>
7
8name = "Darwin"
9print(type(name))  # <class 'str'>
10
11is_safe = True
12print(type(is_safe))  # <class 'bool'>
13
14# Praktyczne użycie
15data = 42
16if type(data) == int:
17    print("To jest liczba całkowita!")

Wynik <class 'int'> czytamy: "wartość należy do klasy int". W warunkach polecam jednak isinstance(data, int), bo uwzględnia typy pokrewne.

Konwersja między typami (Type Casting)

Czasem musimy zmienić typ danych - jak tłumaczenie między językami.

String → Int/Float

Najczęściej liczba przychodzi jako tekst, na przykład z input(). Funkcje int() i float() tłumaczą ją na liczbę:

1# String → Int
2age_text = "25"
3age = int(age_text)
4print(age + 5)  # 30
5
6# String → Float
7temperature_text = "32.5"
8temperature = float(temperature_text)
9print(temperature + 2.5)  # 35.0
10
11# UWAGA! Błąd jeśli string nie jest liczbą
12# bad_conversion = int("abc")  # ValueError!
13# int("42.5")  # też ValueError - int() nie przyjmuje kropki
14
15print(int(float("42.5")))  # 42

int() przyjmuje tylko zapis liczby całkowitej, więc tekst z kropką przepuść najpierw przez float(), jak w ostatniej linii.

Int/Float → String

W drugą stronę działa str(). Przydaje się, gdy łączymy liczbę z tekstem operatorem +, który nie miesza typów:

1# Int → String
2species_count = 42
3count_text = str(species_count)
4print("Odkryto " + count_text + " gatunki")  # Konkatenacja stringów
5
6# Float → String
7temperature = 32.5
8temp_text = str(temperature)
9message = f"Temperatura: {temp_text}°C"

Bez str() linia z + zakończyłaby się TypeError. W f-stringu konwersja dzieje się sama.

Int ↔ Float

Między liczbami przechodzimy w obie strony, ale kierunek z float do int ucina część dziesiętną:

1# Int → Float
2whole_number = 10
3decimal_number = float(whole_number)  # 10.0
4
5# Float → Int (obcina część dziesiętną!)
6decimal = 15.7
7whole = int(decimal)  # 15 (NIE 16!)
8
9decimal2 = 15.2
10whole2 = int(decimal2)  # 15

int() nie zaokrągla, tylko odcina wszystko po kropce. Zaokrąglenie da round(15.7), czyli 16.

Bool konwersje

Każdą wartość można zapytać, czy jest "prawdziwa". Zero i pusty tekst to False, a każda inna liczba i każdy niepusty tekst to True:

1# Liczby → Bool
2# 0 = False, wszystkie inne = True
3print(bool(0))    # False
4print(bool(1))    # True
5print(bool(-5))   # True
6print(bool(100))  # True
7
8# String → Bool
9# Pusty string = False, niepusty = True
10print(bool(""))       # False
11print(bool("Darwin")) # True
12print(bool(" "))      # True (spacja to znak!)
13
14# Bool → Int
15print(int(True))   # 1
16print(int(False))  # 0

True to 1, a False to 0, bo bool jest odmianą int. Stąd hierarchia bool → int → float: działanie na int i float daje float.

Operacje specyficzne dla typów

Operacje na liczbach (int, float)

Liczby obsługują siedem podstawowych działań. Zwróć uwagę na dwa rodzaje dzielenia i potęgowanie podwójną gwiazdką:

1# Podstawowe operacje
2a = 10
3b = 3
4
5print(a + b)   # 13 (dodawanie)
6print(a - b)   # 7  (odejmowanie)
7print(a * b)   # 30 (mnożenie)
8print(a / b)   # 3.333... (dzielenie - ZAWSZE float!)
9print(a // b)  # 3 (dzielenie całkowite)
10print(a % b)   # 1 (reszta z dzielenia - modulo)
11print(a ** b)  # 1000 (potęgowanie: 10^3)
12
13# Operacje na floatach
14x = 5.5
15y = 2.5
16print(x + y)   # 8.0
17print(x * y)   # 13.75
18
19# Mieszanie int i float → wynik to float
20mixed = 10 + 5.5  # 15.5 (float)

Nawet 10 / 2 daje 5.0. Operator // odcina resztę, a % zwraca właśnie ją, stąd 3 i 1.

Operacje na stringach

Tekst ma własne narzędzia: łączenie, powtarzanie, długość, wielkie litery, indeksy i wycinanie fragmentów:

1# Konkatenacja (łączenie)
2first_name = "Charles"
3last_name = "Darwin"
4full_name = first_name + " " + last_name
5print(full_name)  # Charles Darwin
6
7# Powtarzanie
8jungle_cry = "Help! " * 3
9print(jungle_cry)  # Help! Help! Help!
10
11# Długość stringu
12name = "Darwin"
13print(len(name))  # 6
14
15# Indeksowanie (od 0!)
16text = "Python"
17print(text[0])   # P
18print(text[1])   # y
19print(text[-1])  # n (ostatni znak)
20print(text.upper())  # PYTHON
21
22# Slicing (wycinanie)
23word = "Expedition"
24print(word[0:4])   # Expe
25print(word[4:])    # dition
26print(word[:4])    # Expe
27print(word[::2])   # Epdto (co drugi znak)

Indeksy liczymy od zera, ujemne od końca. W wycinku [0:4] pierwszy numer się wlicza, drugi nie. upper() zwraca nowy napis, text się nie zmienia.

None - specjalny typ

None to specjalna wartość oznaczająca "brak wartości", jak pusta pułapka. Funkcje z def poznasz dokładniej za kilka lekcji:

1# None - jak puste pudełko
2treasure = None
3print(treasure)  # None
4print(type(treasure))  # <class 'NoneType'>
5
6# Użycie w praktyce
7def find_species(name):
8    if name == "Python regius":
9        return "Znaleziono!"
10    return None  # Nie znaleziono
11
12result = find_species("Unknown")
13if result is None:
14    print("Gatunek nieznany")

Brak wyniku sprawdzamy przez is None. None to nie zero ani pusty tekst, tylko osobny typ.

Praktyczny przykład - Kalkulator ekspedycji

Połączmy konwersje i działania. Program pyta o trzy wartości, zamienia je na właściwe typy i liczy średnią prędkość:

1print("=== Kalkulator Ekspedycji ===\n")
2
3# Zbieramy dane
4distance_text = input("Dystans (km): ")
5time_text = input("Czas (godziny): ")
6team_size_text = input("Rozmiar zespołu: ")
7
8# Konwertujemy na odpowiednie typy
9distance = float(distance_text)
10time = float(time_text)
11team_size = int(team_size_text)
12
13# Obliczenia
14avg_speed = distance / time
15distance_per_person = distance / team_size
16
17# Wyświetlamy wyniki
18print("\n--- WYNIKI ---")
19print(f"Średnia prędkość: {avg_speed:.2f} km/h")
20print(f"Dystans na osobę: {distance_per_person:.2f} km")
21print(f"Typ distance: {type(distance)}")
22print(f"Typ team_size: {type(team_size)}")

Zapis {avg_speed:.2f} pokazuje dwa miejsca po przecinku zamiast 4.666666666666667. Zmienia tylko wydruk, nie samą liczbę.

Zadanie praktyczne

Stwórz program, który:

1. Pyta o temperaturę w Fahrenheitach
2. Konwertuje na Celsjusze: C = (F - 32) × 5/9
3. Wyświetla wynik
4. Informuje czy jest gorąco (>30°C), normalnie (15-30°C), czy zimno (<15°C)

1# Kalkulator konwersji Fahrenheit → Celsius
2
3# TODO: Pobierz temperaturę w Fahrenheitach
4fahrenheit = float(input("Temperatura w Fahrenheitach: "))
5
6# TODO: Oblicz Celsjusze: C = (F - 32) × 5/9
7celsius = (fahrenheit - 32) * 5 / 9
8
9# TODO: Wyświetl wynik
10print(f"{fahrenheit}°F = {celsius:.1f}°C")
11
12# TODO: Sprawdź czy gorąco (>30), normalnie (15-30), czy zimno (<15)
13if celsius > 30:
14    print("Gorąco w dżungli!")
15elif celsius >= 15:
16    print("Przyjemna temperatura")
17else:
18    print("Zimno jak na dżunglę!")

Podsumowanie

Przed przejściem dalej upewnij się, że:

• Znasz typy int, float, str, bool i None
• Sprawdzasz typ przez type() i konwertujesz typy
• Znasz różnicę między / a //
• Rozumiesz indeksowanie stringów

W następnej lekcji Darwin pokaże Ci operatory - narzędzia matematyczne i logiczne badacza!

Pamiętaj: typ to gatunek danej - zanim coś z nią zrobisz, sprawdź, do jakiego gatunku należy.