slovarnik 1.0.0
Slovenian vocabulary layer for Python
License: MIT
Requires Python: >=3.8
Keywords: slovenian, localization, education, python

# slovarnik - Pythonov wrapper za slovenski jezik

Pythonova knjižnica, ki omogoča programiranje v slovenskem jeziku. Zagotavlja slovenske aliase za vgrajene funkcije, podatkovne tipe, kontrolne strukture in izjeme.

## Namestitev

```bash
pip install slovarnik
```

Ali klonirajte repozitorij in ga namestite lokalno:

```bash
git clone https://github.com/LolekLiam/slovarnik.git
cd slovarnik
pip install -e .
```

## Uporaba

```python
from slovarnik import *

# Osnovne funkcije
izpis("Pozdravljen, svet!")

# Podatkovni tipi
stevilo = celo(42)
besedilo = niz("Hello")
seznam_stevil = seznam([1, 2, 3, 4, 5])

# Pogojni stavki
če(stevilo > 10).potem(lambda: izpis("Veliko")).sicer(lambda: izpis("Malo"))
```

## Značilnosti

### 1. Podatkovni tipi

Slovenske alternative za Pythonove vgrajene tipe:

```python
logično    # bool
slovar     # dict
realno     # float
celo       # int
seznam     # list
množica    # set
niz        # str
terka      # tuple
```

**Primer:**
```python
starost = celo(25)
ime = niz("Ana")
ocene = seznam([5, 4, 5, 3, 4])
koordinate = terka((10.5, 20.3))
```

### 2. Vgrajene funkcije

Vse Pythonove vgrajene funkcije so na voljo v slovenščini:

```python
# Matematične operacije
absolutno(-5)           # abs(-5) → 5
največ(1, 5, 3)        # max(1, 5, 3) → 5
najmanj(1, 5, 3)       # min(1, 5, 3) → 1
vsota([1, 2, 3, 4])    # sum([1, 2, 3, 4]) → 10
zaokroži(3.7)          # round(3.7) → 4

# Delo s podatki
dolžina([1, 2, 3])     # len([1, 2, 3]) → 3
urejeno([3, 1, 2])     # sorted([3, 1, 2]) → [1, 2, 3]
obratno([1, 2, 3])     # reversed([1, 2, 3])
enumeriraj(['a', 'b']) # enumerate(['a', 'b'])

# Vhod/izhod
vnos("Vpiši ime: ")    # input("Vpiši ime: ")
izpis("Sporočilo")     # print("Sporočilo")
odpri("datoteka.txt")  # open("datoteka.txt")

# Pretvorbe
binarno(10)            # bin(10) → '0b1010'
šestnajstiško(255)     # hex(255) → '0xff'
osmiško(8)             # oct(8) → '0o10'
```

### 3. Kontrolne strukture

#### Pogojni stavki (če/sicer_če/sicer)

```python
def pozdravi():
    izpis("Dober dan!")

def nasvidenje():
    izpis("Nasvidenje!")

starost = 20

če(starost >= 18).potem(pozdravi).sicer(nasvidenje)
```

**Večkratni pogoji:**
```python
ocena = 85

def odlicno():
    izpis("Odlično!")

def prav_dobro():
    izpis("Prav dobro!")

def zadostno():
    izpis("Zadostno!")

če(ocena >= 90).potem(odlicno)\
  .sicer_če(ocena >= 75).potem(prav_dobro)\
  .sicer(zadostno)
```

#### Zanka dokler (while)

```python
def izpisi_stevec():
    izpis(stevec[0])
    stevec[0] += 1

stevec = [0]
dokler(lambda: stevec[0] < 5).ponavljaj(izpisi_stevec)
# Izpiše: 0, 1, 2, 3, 4
```

#### Zanka za (for)

```python
def izpisi_i(i):
    izpis(i)

# Od 0 do 4
za(0, lambda i: i < 5, lambda i: i + 1).ponavljaj(izpisi_i)

# Korak 2
za(0, lambda i: i < 10, lambda i: i + 2).ponavljaj(izpisi_i)
# Izpiše: 0, 2, 4, 6, 8

# Obratno štetje
za(10, lambda i: i > 0, lambda i: i - 1).ponavljaj(izpisi_i)
```

### 4. Obravnava izjem (poskusi/ujemi/drugače/končno)

#### Osnovni poskusi-ujemi

```python
def deli():
    rezultat = 10 / 0
    izpis(rezultat)

def obdelaj_napako(e):
    izpis(f"Napaka: {e}")

poskusi(deli)\
  .ujemi(NapakaDeljenjaNičle, obdelaj_napako)\
  .končaj()
```

#### Večkratne izjeme

```python
def tvegana_operacija():
    # Nekaj, kar bi lahko sprožilo različne izjeme
    pass

poskusi(tvegana_operacija)\
  .ujemi(NapakaDeljenjaNičle, lambda e: izpis("Deljenje z nič!"))\
  .ujemi(NapakaVrednosti, lambda e: izpis("Napačna vrednost!"))\
  .ujemi(NapakaTipa, lambda e: izpis("Napačen tip!"))\
  .končaj()
```

#### Blok drugače (else)

Izvede se, če **ni** bilo izjeme:

```python
def uspesna_operacija():
    izpis("Vse v redu")

def ce_uspe():
    izpis("Operacija uspešna!")

poskusi(uspesna_operacija)\
  .ujemi(Izjema, lambda e: izpis("Napaka!"))\
  .drugače(ce_uspe)\
  .končaj()
```

#### Blok končno (finally)

Izvede se **vedno**, ne glede na to, ali je bila izjema:

```python
def odpri_datoteko():
    izpis("Odpiranje datoteke...")
    # Operacije z datoteko

def zapri_datoteko():
    izpis("Zapiranje datoteke...")

poskusi(odpri_datoteko)\
  .ujemi(NapakaVhodIzhod, lambda e: izpis("Napaka pri I/O"))\
  .končno(zapri_datoteko)
```

#### Popoln primer

```python
def opravi_delo():
    izpis("Delam...")
    rezultat = 100 / 5
    izpis(f"Rezultat: {rezultat}")

def obdelaj_deljenje(e):
    izpis("Napaka pri deljenju!")

def uspeh():
    izpis("Ni bilo napak!")

def pocisti():
    izpis("Čiščenje virov...")

poskusi(opravi_delo)\
  .ujemi(NapakaDeljenjaNičle, obdelaj_deljenje)\
  .drugače(uspeh)\
  .končno(pocisti)
```

### 5. Izjeme

Vse Pythonove izjeme so na voljo v slovenščini:

```python
# Pogosto uporabljene izjeme
Izjema                      # Exception
NapakaVrednosti             # ValueError
NapakaTipa                  # TypeError
NapakaAtributa              # AttributeError
NapakaIndeksa               # IndexError
NapakaKljuča                # KeyError
NapakaDeljenjaNičle         # ZeroDivisionError
NapakaVhodIzhod             # IOError
NapakaDatotekaNeObstaja     # FileNotFoundError
NapakaDatotekaObstaja       # FileExistsError

# Sistemske izjeme
TipkovničnaPrekinitev       # KeyboardInterrupt
NapakaSpomina               # MemoryError
NapakaSistema               # SystemError
IzhodSistema                # SystemExit

# Mrežne izjeme
NapakaPovezave              # ConnectionError
NapakaIztek                 # TimeoutError
NapakaZavrnjenePovezave     # ConnectionRefusedError

# In še veliko več...
```

**Primer uporabe:**
```python
def preveri_starost(starost):
    if starost < 0:
        raise NapakaVrednosti("Starost ne more biti negativna")
    izpis(f"Starost: {starost}")

poskusi(lambda: preveri_starost(-5))\
  .ujemi(NapakaVrednosti, lambda e: izpis(f"Napaka: {e}"))\
  .končaj()
```

## Napredni primeri

### Primer 1: Kalkulator

```python
def kalkulator():
    a = realno(vnos("Prvo število: "))
    operacija = vnos("Operacija (+, -, *, /): ")
    b = realno(vnos("Drugo število: "))
    
    če(operacija == "+").potem(lambda: izpis(f"Rezultat: {a + b}"))\
      .sicer_če(operacija == "-").potem(lambda: izpis(f"Rezultat: {a - b}"))\
      .sicer_če(operacija == "*").potem(lambda: izpis(f"Rezultat: {a * b}"))\
      .sicer_če(operacija == "/").potem(lambda: izpis(f"Rezultat: {a / b}"))\
      .sicer(lambda: izpis("Neznana operacija"))

def obdelaj_napako(e):
    izpis(f"Napaka: {e}")

poskusi(kalkulator)\
  .ujemi(NapakaDeljenjaNičle, lambda e: izpis("Ne moreš deliti z nič!"))\
  .ujemi(NapakaVrednosti, lambda e: izpis("Vpiši veljavno število!"))\
  .končaj()
```

### Primer 2: Obdelava seznama

```python
seznam_imen = seznam(["Ana", "Bor", "Cvetka", "David"])

def izpisi_ime(i):
    izpis(f"{i + 1}. {seznam_imen[i]}")

# Izpiši vsa imena
za(0, lambda i: i < dolžina(seznam_imen), lambda i: i + 1).ponavljaj(izpisi_ime)

# Filtriraj imena, ki se začnejo z 'A'
filtrirano = filtriraj(lambda ime: ime[0] == 'A', seznam_imen)
izpis(f"Imena z A: {seznam(filtrirano)}")

# Seštej dolžine imen
vsota_dolzin = vsota(zemljevid(dolžina, seznam_imen))
izpis(f"Skupna dolžina vseh imen: {vsota_dolzin}")
```

### Primer 3: Branje datoteke

```python
def preberi_datoteko():
    datoteka = odpri("besedilo.txt", "r")
    vsebina = datoteka.read()
    izpis(vsebina)
    datoteka.close()

def zapri_datoteko():
    izpis("Datoteka zaprta")

poskusi(preberi_datoteko)\
  .ujemi(NapakaDatotekaNeObstaja, lambda e: izpis("Datoteka ne obstaja!"))\
  .ujemi(NapakaPravic, lambda e: izpis("Ni dovoljenja za branje!"))\
  .končno(zapri_datoteko)
```

## Opombe

### Zakaj so potrebne lambde/funkcije?

Ta knjižnica uporablja funkcije kot argumente za odloženo izvajanje kode. To je nujno zaradi načina, kako Python deluje:

```python
# ❌ To se izvede TAKOJ (napačno)
če(True).potem(izpis("Hello"))

# ✅ To se izvede, ko je pogoj izpolnjen (pravilno)
če(True).potem(lambda: izpis("Hello"))

# ✅ Ali z imenovano funkcijo (priporočeno za daljšo kodo)
def pozdravi():
    izpis("Hello")
    izpis("Welcome!")

če(True).potem(pozdravi)
```

Za enostavne primere uporabljajte lambde, za kompleksnejšo logiko pa definirajte funkcije.

## Prispevanje

Prispevki so dobrodošli! Prosim:

1. Forkajte repozitorij
2. Ustvarite svojo feature vejo (`git checkout -b feature/izboljsava`)
3. Commitajte spremembe (`git commit -am 'Dodaj novo funkcionalnost'`)
4. Pušajte na vejo (`git push origin feature/izboljsava`)
5. Ustvarite Pull Request

## Licenca

MIT License - poglejte LICENSE datoteko za podrobnosti.

## Avtor

Liam Starič

## Zahvale

- Pythonova skupnost za navdih
- Vsi, ki so prispevali k prevajanju in testiranju

---

**Opomba:** Ta projekt je izobraževalnega značaja in je namenjen učenju programiranja v slovenščini. Za produkcijske projekte priporočamo uporabo standardnega angleškega Pythona.