Typ danych określa, jakiego rodzaju wartość przechowuje zmienna oraz jakie operacje można na niej wykonać. Python jest językiem dynamicznie typowanym – nie musisz deklarować typu zmiennej, interpreter sam go rozpoznaje na podstawie przypisanej wartości.

Podstawowe typy danych w Pythonie:

Numeryczne - int, float
Tekstowe - str (string)
Sekwencyjne - list, tuple, range
Mapujące - dict (dictionary)
Zbiory - set, frozenset
Logiczne - bool (True/False)
Specjalne - None

Sprawdzanie typu zmiennej

Funkcja type()

Funkcja type() zwraca typ zmiennej.

# Różne typy zmiennych
liczba_calkowita = 10
liczba_zmiennoprzecinkowa = 3.14
tekst = "Hello"
lista = [1, 2, 3]
prawda = True

# Sprawdzanie typów
print(type(liczba_calkowita))           # <class 'int'>
print(type(liczba_zmiennoprzecinkowa))  # <class 'float'>
print(type(tekst))                      # <class 'str'>
print(type(lista))                      # <class 'list'>
print(type(prawda))                     # <class 'bool'>

Funkcja isinstance()

Funkcja isinstance() sprawdza, czy zmienna jest instancją danego typu.

x = 10

# Sprawdzanie czy x jest typu int
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False
print(isinstance(x, str))    # False

# Sprawdzanie wielu typów na raz
y = 3.14
print(isinstance(y, (int, float)))  # True (y jest float)

Typy numeryczne – int i float

Python ma tylko dwa podstawowe typy numeryczne, w przeciwieństwie do innych języków (Java, C++), które mają więcej (long, double, short itp.).

int – liczby całkowite

# Liczby całkowite
liczba = 1
print(type(liczba))  # <class 'int'>

# Python automatycznie obsługuje bardzo duże liczby
# (w innych językach to byłby long lub BigInteger)
duza_liczba = 9223372036854775807
print(type(duza_liczba))  # <class 'int'> - nadal int!

# Liczby ujemne
ujemna = -50
print(type(ujemna))  # <class 'int'>

float – liczby zmiennoprzecinkowe

# Liczby zmiennoprzecinkowe
number2 = 1.44
print(type(number2))  # <class 'float'>

# Bardzo precyzyjne liczby (w innych językach to byłby double)
double = 10.12345678910
print(type(double))  # <class 'float'> - nadal float!

# Notacja naukowa
wielka = 1.5e10  # 1.5 * 10^10 = 15000000000.0
print(wielka)
print(type(wielka))  # <class 'float'>

Automatyczna konwersja typów

Python automatycznie konwertuje typ gdy wykonujesz operacje na różnych typach numerycznych.

number = 1        # int
number2 = 1.44    # float

# Dodajemy int + float
result = number + number2
print(result)        # 2.44
print(type(result))  # <class 'float'>

# Reguła: int + float = float

Czytelny zapis dużych liczb

Dla czytelności możesz używać podkreślnika _ w dużych liczbach.

# Trudny do odczytania
trudny = 95256987128

# Czytelniejszy zapis
czytelny = 95_256_987_128

print(czytelny)  # 95256987128
# Podkreślniki są ignorowane, służą tylko czytelności

# Różne sposoby formatowania
milion = 1_000_000
miliard = 1_000_000_000
pi_dokladne = 3.141_592_653_589

Stringi – łańcuchy znaków

W Pythonie nie ma typu char (pojedynczy znak) jak w C++ czy Javie. Wszystko to stringi.

Tworzenie stringów

# Cudzysłowy podwójne
string1 = "Hello, World!"

# Apostrofy (cudzysłowy pojedyncze)
string2 = 'Hello, World!'

# Nie ma różnicy między " a '
print(type(string1))  # <class 'str'>
print(type(string2))  # <class 'str'>

Stringi wieloliniowe

Używaj potrójnych cudzysłowów lub apostrofów dla tekstów wieloliniowych.

# Potrójne cudzysłowy
tekst1 = """To jest długi tekst,
który rozciąga się
na wiele linii."""

# Potrójne apostrofy (to samo)
tekst2 = '''To jest długi tekst,
który rozciąga się
na wiele linii.'''

print(tekst1)

Stringi są niemutowalne

Ważne: Stringi w Pythonie są niemutowalne (immutable) – nie możesz zmienić ich zawartości. Musisz stworzyć nowy string.

tekst = "Hello"

# ŹLE - to nie zadziała
# tekst[0] = "h"  # TypeError: 'str' object does not support item assignment

# DOBRZE - tworzysz nowy string
tekst = "hello"  # Przypisujesz nowy string
print(tekst)

# Modyfikacja przez utworzenie nowego stringa
tekst = "Hello"
nowy_tekst = tekst.lower()  # Tworzy nowy string
print(nowy_tekst)  # hello
print(tekst)       # Hello (oryginalny się nie zmienił)

Łączenie stringów i liczb

Uwaga: Nie możesz łączyć operatorem + stringów z liczbami. Musisz dokonać rzutowania.

zmienna_int = 100
zmienna_string = "dolarów"

# ŹLE - błąd!
# print("Mam " + zmienna_int + " " + zmienna_string)  # TypeError

# DOBRZE - rzutowanie na string
print("Mam " + str(zmienna_int) + " " + zmienna_string)

# LEPIEJ - f-string (nie wymaga rzutowania)
print(f"Mam {zmienna_int} {zmienna_string}")

Boolean – True/False

Typ bool przechowuje wartość logiczną: True (prawda) lub False (fałsz).

# Deklaracja
logic_true = True
logic_false = False

print(logic_true)   # True
print(logic_false)  # False
print(type(logic_true))  # <class 'bool'>

Wartości „prawdziwe” i „fałszywe”

W Pythonie różne wartości są automatycznie konwertowane na True lub False.

• False
• None
• 0 (zero)
• 0.0 (zero float)
• "" (pusty string)
• [] (pusta lista)
• () (pusta krotka)
• {} (pusty słownik lub zestaw)

Wszystkie inne wartości to True:

# Wartości False
print(bool(False))  # False
print(bool(None))   # False
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False

# Wartości True
print(bool(True))   # True
print(bool(1))      # True
print(bool("tekst"))# True
print(bool([1]))    # True (lista niepusta)

None – brak wartości

None to specjalny typ reprezentujący brak wartości. To nie to samo co 0, False ani pusty string.

# Deklaracja
message = None
print(message)  # None
print(type(message))  # <class 'NoneType'>

# Później możesz przypisać wartość
message = "Teraz mam wartość"
print(message)

# None != False
print(None == False)  # False
print(None == 0)      # False
print(None == "")     # False

# Sprawdzanie czy zmienna jest None
if message is None:
    print("Brak wiadomości")

Praktyczne zastosowanie:

def find_user(user_id):
    # Szukamy użytkownika...
    if user_id == 1:
        return {"name": "Jan", "age": 25}
    else:
        return None  # Nie znaleziono

user = find_user(5)
if user is None:
    print("Użytkownik nie znaleziony")
else:
    print(f"Znaleziono: {user['name']}")

Rzutowanie typów (casting)

Rzutowanie to konwersja wartości z jednego typu na inny.

int() – konwersja na liczbę całkowitą

# String → int
age = "25"
age = int(age)
print(age)        # 25
print(type(age))  # <class 'int'>

# Float → int (ucina część dziesiętną)
pi = 3.14
pi_int = int(pi)
print(pi_int)  # 3

# Bool → int
print(int(True))   # 1
print(int(False))  # 0

float() – konwersja na liczbę zmiennoprzecinkową

# String → float
price = "19.99"
price = float(price)
print(price)       # 19.99
print(type(price)) # <class 'float'>

# Int → float
liczba = 10
liczba_float = float(liczba)
print(liczba_float)  # 10.0

str() – konwersja na string

# Int → string
age = 25
age_str = str(age)
print(age_str)       # "25"
print(type(age_str)) # <class 'str'>

# Float → string
pi = 3.14
pi_str = str(pi)
print(pi_str)  # "3.14"

# List → string
lista = [1, 2, 3]
lista_str = str(lista)
print(lista_str)  # "[1, 2, 3]"

list(), tuple(), set() – konwersje kolekcji

# String → lista (rozdziela na znaki)
tekst = "Python"
lista = list(tekst)
print(lista)  # ['P', 'y', 't', 'h', 'o', 'n']

# Lista → krotka
lista = [1, 2, 3]
krotka = tuple(lista)
print(krotka)  # (1, 2, 3)

# Lista → zestaw (usuwa duplikaty)
owoce = ['jabłka', 'pomarańcze', 'jabłka', 'gruszki']
owoce_set = set(owoce)
print(owoce_set)  # {'jabłka', 'pomarańcze', 'gruszki'}

# Zestaw → lista
z powrotem = list(owoce_set)
print(z_powrotem)

Ćwiczenia

Sprawdzanie typów

1. Stwórz zmienną przechowującą swoją ulubioną liczbę i wyświetl jej typ używając funkcji type().
2. Stwórz trzy zmienne: jedna z liczbą całkowitą, druga z liczbą zmiennoprzecinkową, trzecia z tekstem. Wyświetl typ każdej z nich.
3. Stwórz zmienną z wartością True i sprawdź jej typ. Następnie przypisz do tej samej zmiennej liczbę 1 i ponownie sprawdź typ.
4. Używając funkcji isinstance() sprawdź, czy zmienna zawierająca wartość 3.14 jest typu float. Wynik wyświetl w konsoli.
5. Stwórz zmienną z wartością None. Sprawdź jej typ i użyj isinstance() aby potwierdzić, że nie jest to typ bool.

Typy numeryczne

1. Stwórz dwie zmienne: jedną z liczbą całkowitą 10, drugą z liczbą zmiennoprzecinkową 3.5. Dodaj je do siebie i sprawdź typ wyniku.
2. Zapisz liczbę 1 000 000 (milion) w czytelny sposób używając podkreślników i wyświetl ją w konsoli.
3. Oblicz 2 do potęgi 16 i sprawdź typ wyniku.
4. Podziel liczbę 17 przez 5 używając dzielenia zwykłego (/) i dzielenia całkowitego (//). Porównaj wyniki i ich typy.
5. Znajdź resztę z dzielenia liczby 25 przez 7 używając operatora modulo.

Stringi

1. Stwórz zmienną zawierającą twoje imię i nazwisko jako jeden string. Wyświetl ją w konsoli.
2. Stwórz string wieloliniowy zawierający krótki wiersz (minimum 3 linijki) używając potrójnych cudzysłowów.
3. Stwórz zmienną z tekstem „Python” i spróbuj zmienić pierwszą literę na małą „p” poprzez indeksowanie. Opisz co się stało.
4. Połącz trzy stringi: swoje imię, spację i swoje nazwisko używając operatora +.
5. Stwórz string „Hello” i powtórz go 5 razy używając operatora *.

Boolean i None

1. Stwórz trzy zmienne: jedną z wartością True, drugą z wartością False, trzecią z wartością None. Wyświetl typ każdej z nich.
2. Sprawdź wartość bool() dla następujących wartości i wyświetl wyniki: 0, 1, „”, „tekst”, [], [1, 2], {}, None.
3. Stwórz zmienną z wartością None. Sprawdź czy jest równa None używając operatora „is”.
4. Stwórz zmienną is_student = True. Użyj operatora „not” aby wyświetlić przeciwną wartość logiczną.
5. Porównaj None == False i None is False. Wyświetl oba wyniki i wyjaśnij różnicę.

Rzutowanie typów

1. Stwórz zmienną string „123” i przekształć ją na liczbę całkowitą. Wyświetl wynik i jego typ.
2. Stwórz zmienną z liczbą zmiennoprzecinkową 3.14 i przekształć ją na string. Wyświetl wynik i jego typ.
3. Stwórz zmienną z liczbą 5.99 i przekształć ją na int. Wyświetl wynik (zaobserwuj co się stało z częścią dziesiętną).
4. Przekształć True na int i False na int. Wyświetl oba wyniki.