Semiclon

Co jsou proměnné?

Proměnné jsou základním stavebním kamenem každého programu. Můžete si je představit jako pojmenované kontejnery, do kterých ukládáte data. V Pythonu je vytvoření proměnné velmi jednoduché - stačí jí dát název a přiřadit jí hodnotu pomocí operátoru přiřazení (=).

# Vytvoření proměnné
jmeno = "Karel"
vek = 25
vyska = 182.5

# Výpis hodnot proměnných
print(jmeno)
print(vek)
print(vyska)

Pravidla pro pojmenování proměnných

Při pojmenovávání proměnných v Pythonu je třeba dodržovat následující pravidla:

• Název proměnné může obsahovat písmena, číslice a podtržítko (_).
• Název proměnné musí začínat písmenem nebo podtržítkem, ne číslicí.
• Názvy proměnných rozlišují velká a malá písmena (case-sensitive). To znamená, že 'jmeno', 'Jmeno' a 'JMENO' jsou tři různé proměnné.
• Nelze použít Python klíčová slova jako názvy proměnných (např. 'if', 'for', 'while', 'def', 'class', atd.).

Konvence v Pythonu doporučuje používat tzv. "snake_case" pro pojmenování proměnných - to znamená, že všechna písmena jsou malá a slova jsou oddělena podtržítkem:

moje_promenna = 42
prvni_jmeno = "Karel"
posledni_jmeno = "Novák"

Základní datové typy v Pythonu

Python má několik základních datových typů, které se používají pro různé druhy dat. Nejběžnější jsou:

1. Celá čísla (int)

Celá čísla jsou v Pythonu reprezentována typem `int`. Mohou být kladná, záporná nebo nula a nemají desetinnou část.

a = 5
b = -10
c = 0

print(type(a))  # Výstup: 

2. Čísla s plovoucí desetinnou čárkou (float)

Čísla s desetinnou částí jsou v Pythonu reprezentována typem `float`.

x = 3.14
y = -0.001
z = 2.0

print(type(x))  # Výstup: 

3. Řetězce (str)

Řetězce jsou sekvence znaků. V Pythonu jsou reprezentovány typem `str` a mohou být ohraničeny jednoduchými (') nebo dvojitými (") uvozovkami.

jmeno = "Karel"
prijmeni = 'Novák'
cela_veta = "Toto je věta s 'uvozovkami'."

print(type(jmeno))  # Výstup: 

4. Booleovské hodnoty (bool)

Booleovské hodnoty mohou nabývat pouze dvou hodnot: `True` (pravda) nebo `False` (nepravda). Používají se zejména v podmínkách a logických operacích.

je_slunecno = True
prsi = False

print(type(je_slunecno))  # Výstup: 

5. Seznamy (list)

Seznamy jsou uspořádané kolekce prvků, které mohou být různých datových typů. Jsou ohraničeny hranatými závorkami [] a prvky jsou odděleny čárkami.

cisla = [1, 2, 3, 4, 5]
mix = [1, "text", 3.14, True]

print(type(cisla))  # Výstup: 

6. N-tice (tuple)

N-tice jsou podobné seznamům, ale jsou neměnné - to znamená, že po vytvoření nelze n-tici změnit. Jsou ohraničeny kulatými závorkami () a prvky jsou odděleny čárkami.

souradnice = (10, 20)
rgb = (255, 0, 0)

print(type(souradnice))  # Výstup: 

7. Slovníky (dict)

Slovníky jsou kolekce párů klíč-hodnota. Jsou ohraničeny složenými závorkami {} a každý pár klíč-hodnota je oddělený čárkou. Klíč a hodnota jsou odděleny dvojtečkou (:).

osoba = {
    "jmeno": "Karel",
    "vek": 25,
    "mesto": "Praha"
}

print(type(osoba))  # Výstup: 

8. Množiny (set)

Množiny jsou neuspořádané kolekce unikátních prvků. Jsou ohraničeny složenými závorkami {} (jako slovníky) nebo lze použít funkci `set()`.

barvy = {"červená", "zelená", "modrá"}
cisla = set([1, 2, 2, 3, 3, 3])  # Výsledek: {1, 2, 3}

print(type(barvy))  # Výstup: 

Dynamické typování v Pythonu

Python je dynamicky typovaný jazyk, což znamená, že nemusíte explicitně deklarovat typ proměnné při jejím vytvoření. Typ proměnné je automaticky určen podle hodnoty, která je jí přiřazena, a může se změnit, pokud přiřadíte proměnné novou hodnotu jiného typu.

x = 5       # x je nyní typu int
print(type(x))  # Výstup: 

x = "hello"  # x je nyní typu str
print(type(x))  # Výstup: 

x = 3.14     # x je nyní typu float
print(type(x))  # Výstup: 

Převod mezi datovými typy

V Pythonu můžete převádět hodnoty mezi různými datovými typy pomocí vestavěných funkcí, jako jsou `int()`, `float()`, `str()`, `list()`, `tuple()`, `dict()` a `set()`.

# Převod na int
a = int(3.14)  # a = 3
b = int("5")   # b = 5

# Převod na float
c = float(5)      # c = 5.0
d = float("3.14")  # d = 3.14

# Převod na str
e = str(42)       # e = "42"
f = str(3.14)     # f = "3.14"

# Převod na list
g = list("hello")  # g = ['h', 'e', 'l', 'l', 'o']
h = list((1, 2, 3))  # h = [1, 2, 3]

# Převod na tuple
i = tuple([1, 2, 3])  # i = (1, 2, 3)

# Převod na set
j = set([1, 2, 2, 3, 3, 3])  # j = {1, 2, 3}

Operace s datovými typy

Operace s čísly

Python podporuje všechny běžné aritmetické operace:

# Základní aritmetické operace
a = 10
b = 3

soucet = a + b      # 13
rozdil = a - b      # 7
soucin = a * b      # 30
podil = a / b       # 3.3333...
celociselny_podil = a // b  # 3
zbytek = a % b      # 1
mocnina = a ** b    # 1000 (10^3)

Operace s řetězci

Řetězce v Pythonu podporují konkatenaci (spojování) pomocí operátoru '+' a opakování pomocí operátoru '*'.

# Konkatenace řetězců
jmeno = "Karel"
prijmeni = "Novák"
cele_jmeno = jmeno + " " + prijmeni  # "Karel Novák"

# Opakování řetězce
opakuj = "ha" * 3  # "hahaha"

# Délka řetězce
delka = len(cele_jmeno)  # 11

# Indexování a řezání řetězce
prvni_pismeno = jmeno[0]  # "K"
posledni_pismeno = jmeno[-1]  # "l"
podretezec = jmeno[1:3]  # "ar"

Operace se seznamy

Seznamy v Pythonu podporují mnoho operací, včetně přidávání, odebírání a úpravy prvků.

# Vytvoření seznamu
cisla = [1, 2, 3, 4, 5]

# Přidání prvku na konec seznamu
cisla.append(6)  # [1, 2, 3, 4, 5, 6]

# Vložení prvku na určitou pozici
cisla.insert(2, 2.5)  # [1, 2, 2.5, 3, 4, 5, 6]

# Odstranění prvku
cisla.remove(2.5)  # [1, 2, 3, 4, 5, 6]

# Odstranění prvku podle indexu
del cisla[0]  # [2, 3, 4, 5, 6]

# Získání a odstranění posledního prvku
posledni = cisla.pop()  # posledni = 6, cisla = [2, 3, 4, 5]

# Délka seznamu
delka = len(cisla)  # 4

# Indexování a řezání seznamu
prvni = cisla[0]  # 2
podseznamu = cisla[1:3]  # [3, 4]

# Spojování seznamů
seznam1 = [1, 2, 3]
seznam2 = [4, 5, 6]
spojeny = seznam1 + seznam2  # [1, 2, 3, 4, 5, 6]

# Kontrola, zda je prvek v seznamu
je_v_seznamu = 3 in seznam1  # True

Operace se slovníky

Slovníky vám umožňují ukládat páry klíč-hodnota a rychle vyhledávat hodnoty pomocí klíčů.

# Vytvoření slovníku
osoba = {
    "jmeno": "Karel",
    "vek": 25,
    "mesto": "Praha"
}

# Přístup k hodnotám
jmeno = osoba["jmeno"]  # "Karel"

# Přidání nebo úprava hodnoty
osoba["vek"] = 26
osoba["povolani"] = "programátor"

# Odstranění páru klíč-hodnota
del osoba["mesto"]

# Kontrola, zda klíč existuje
existuje = "jmeno" in osoba  # True

# Získání všech klíčů a hodnot
klice = osoba.keys()
hodnoty = osoba.values()
polozky = osoba.items()  # Vrátí páry (klíč, hodnota)

Praktický příklad

Nyní si ukážeme praktický příklad, který kombinuje různé datové typy k vytvoření jednoduchého programu pro evidenci studentů a jejich známek.

# Evidence studentů a jejich známek

# Seznam studentů (slovníky obsahující informace o každém studentovi)
studenti = [
    {
        "jmeno": "Karel Novák",
        "vek": 20,
        "obor": "Informatika",
        "znamky": [1, 2, 1, 1, 3]
    },
    {
        "jmeno": "Jana Svobodová",
        "vek": 19,
        "obor": "Ekonomie",
        "znamky": [1, 1, 2, 1, 1]
    },
    {
        "jmeno": "Petr Dvořák",
        "vek": 21,
        "obor": "Matematika",
        "znamky": [2, 3, 1, 2, 2]
    }
]

# Výpis informací o studentech
print("Seznam studentů:")
for student in studenti:
    prumer = sum(student["znamky"]) / len(student["znamky"])
    print(f"{student['jmeno']}, {student['vek']} let, obor: {student['obor']}, průměr: {prumer:.2f}")

# Přidání nového studenta
novy_student = {
    "jmeno": "Lucie Černá",
    "vek": 20,
    "obor": "Fyzika",
    "znamky": [1, 2, 2, 1, 2]
}
studenti.append(novy_student)

# Nalezení studenta s nejlepším průměrem
nejlepsi_prumer = float('inf')  # Začínáme s "nekonečně" velkým průměrem
nejlepsi_student = None

for student in studenti:
    prumer = sum(student["znamky"]) / len(student["znamky"])
    if prumer < nejlepsi_prumer:  # Menší průměr = lepší výsledek
        nejlepsi_prumer = prumer
        nejlepsi_student = student

print(f"\nStudent s nejlepším průměrem: {nejlepsi_student['jmeno']} ({nejlepsi_prumer:.2f})")

Shrnutí

V tomto článku jste se naučili:

• Co jsou proměnné a jak je vytvářet
• Pravidla pro pojmenování proměnných
• Základní datové typy v Pythonu: int, float, str, bool, list, tuple, dict a set
• Dynamické typování v Pythonu
• Jak převádět mezi různými datovými typy
• Základní operace s různými datovými typy
• Použití datových typů v praktickém příkladu

Pochopení proměnných a datových typů je klíčové pro efektivní programování v Pythonu. V dalším článku se podíváme na podmínky a cykly, které vám umožní řídit tok vašeho programu.