📦 Mainīgie un datu tipi

Python ir dinamiski tipizēta valoda – mainīgā tipu nav jānorāda, to nosaka automātiski. Valoda piedāvā bagātīgu iebūvēto tipu kopu.

python

Mainīgo deklarēšana

Python mainīgos izveido, vienkārši piešķirot vērtību. Nav vajadzīgas atslēgvārds kā var vai let.

ℹ️ Nosaukumu konvencija

Python izmanto snake_case (apakšsvītra starp vārdiem), nevis camelCase. Piemēram: mans_mainigais, lietotaja_vards.

Teksts

# Vienkārša piešķiršana
vards = "Anna"
vecums = 25
augstums = 1.68
ir_students = True

# Vairāku mainīgo piešķiršana vienā rindā
x, y, z = 1, 2, 3
print(x, y, z)  # 1 2 3

# Viena vērtība vairākiem mainīgajiem
a = b = c = 0
print(a, b, c)  # 0 0 0

# Mainīgā pārrakstīšana – pat ar citu tipu!
mainigais = 42
print(mainigais)        # 42
mainigais = "teksts"
print(mainigais)        # teksts
mainigais = [1, 2, 3]
print(mainigais)        # [1, 2, 3]

# Mainīgo nosaukumos: mazie burti + apakšsvītra
lietotaja_vards = "Jānis"
maksimala_atlaize = 0.30
_privats = "parasti privāts"

Pamata datu tipi

Tips	Piemērs	Apraksts
int	42, -7, 0	Veseli skaitļi (neierobežots izmērs)
float	3.14, -0.5	Decimālskaitļi (64-bitu)
str	"teksts"	Teksta virkne (nemainīga)
bool	True, False	Patiesuma vērtība
None	None	Tukša vērtība (nav nekas)
list	[1, 2, 3]	Mainīgs saraksts
tuple	(1, 2, 3)	Nemainīgs saraksts
dict	{"a": 1}	Atslēga-vērtība pāri
set	{1, 2, 3}	Unikālu vērtību kopa

Teksts

# ===============================
# int – veseli skaitļi
# ===============================
skaits = 42
negatīvs = -17
liels = 1_000_000         # Atdalītājs lasāmībai
binārs = 0b1010           # Binārs (= 10)
heks = 0xFF               # Heksadecimāls (= 255)

print(type(skaits))       # <class "int">
print(isinstance(skaits, int))  # True

# ===============================
# float – decimālskaitļi
# ===============================
cena = 19.99
pi = 3.14159
zinātne = 1.5e10          # 1.5 × 10^10 = 15000000000.0
maza = 2.5e-3             # 0.0025

print(type(cena))         # <class "float">

# Peldošā komata precizitāte
print(0.1 + 0.2)          # 0.30000000000000004 (IEEE 754!)
print(round(0.1 + 0.2, 2))  # 0.3

# ===============================
# str – teksta virknes
# ===============================
vienkarsa = "Sveiki"
dubulta = 'Pasaule'
triju_pediņu = """Šis
ir daudzrindu
teksts"""

# f-string (formatēšana)
vards = "Marta"
f_string = f"Sveika, {vards}! 2 + 2 = {2 + 2}"
print(f_string)           # Sveika, Marta! 2 + 2 = 4

print(type(vards))        # <class "str">

# ===============================
# bool – patiesuma vērtība
# ===============================
patiess = True
nepatiess = False

print(type(patiess))      # <class "bool">
print(int(True))          # 1
print(int(False))         # 0

# ===============================
# None – "tukšums" (kā null)
# ===============================
rezultats = None
print(rezultats)          # None
print(type(rezultats))    # <class "NoneType">
print(rezultats is None)  # True

Tipa konversija

Teksts

# Uz int
print(int("42"))        # 42
print(int(3.9))         # 3 (nogriezts, nevis noapaļots!)
print(int(True))        # 1
print(int(False))       # 0

# Uz float
print(float("3.14"))    # 3.14
print(float(10))        # 10.0
print(float("1e3"))     # 1000.0

# Uz str
print(str(42))          # "42"
print(str(True))        # "True"
print(str(3.14))        # "3.14"

# Uz bool
print(bool(0))          # False
print(bool(""))         # False
print(bool(None))       # False
print(bool([]))         # False
print(bool(1))          # True
print(bool("teksts"))   # True
print(bool([1, 2]))     # True

# Droša konvertēšana ar kļūdu apstrādi
teksts = "abc"
try:
    skaitlis = int(teksts)
except ValueError:
    print(f"'{teksts}' nav derīgs skaitlis!")

# type() un isinstance()
x = 42.0
print(type(x))                    # <class "float">
print(type(x) == float)           # True
print(isinstance(x, (int, float))) # True – pārbauda vairākus tipus

Type hints (Python 3.5+)

Python atļauj pievienot tipa norādījumus – tas uzlabo koda lasāmību un IDE atbalstu, bet nespiež tipu izpildes laikā.

Teksts

from typing import Optional, Union

# Mainīgo type hints
vards: str = "Anna"
vecums: int = 25
cena: float = 19.99
ir_aktīvs: bool = True

# Funkciju type hints
def sveicinat(vards: str) -> str:
    return f"Sveicināts, {vards}!"

def dalīt(a: float, b: float) -> Optional[float]:
    """Atgriež None, ja b == 0"""
    if b == 0:
        return None
    return a / b

def aprakstīt(vērtība: Union[int, str]) -> str:
    """Pieņem vai int vai str"""
    return f"Vērtība: {vērtība} (tips: {type(vērtība).__name__})"

print(sveicinat("Marta"))       # Sveicināts, Marta!
print(dalīt(10, 3))             # 3.3333...
print(dalīt(10, 0))             # None
print(aprakstīt(42))            # Vērtība: 42 (tips: int)

Konstantes

Python tehniski neatbalsta patiesās konstantes. Konvencija: LIELIE_BURTI nozīmē, ka vērtību nedrīkst mainīt.

🎓 Ko mācīties tālāk?

Nākamajā sadaļā aplūkosim Python operatorus – aritmētiskos, salīdzināšanas un loģiskos operatorus.

Teksts

# Konstanšu konvencija – visi lielie burti
PI = 3.14159265358979
GRAVITĀCIJA = 9.81
MAKS_MĒĢINĀJUMI = 3
DATUBĀZES_URL = "postgresql://localhost/mana_db"

# Parasti constants.py failā
# Tad importē: from constants import PI, MAKS_MĒĢINĀJUMI

def aplis_laukums(r: float) -> float:
    return PI * r ** 2

print(aplis_laukums(5))   # 78.539...

# Python 3.8+: Final no typing (labāka prakse)
from typing import Final

VERSIJA: Final = "1.0.0"
MAKS_IZMĒRS: Final[int] = 100