Lause (programmeerimine)

Programmid koosnevad **lausetest**, mis on sarnased loomuliku keele käskiva kõneviisi lausetega. Lausetes annab programmeerija mingi korralduse. Lihtsamate lausete puhul on lauseks üks rida koodi ning kui programm käivitada täidab programm laused sellises järjekorras, nagu need on programmitekstis esitatud.
Nagu ka loomulikus keeles moodustatakse laused omakorda sõnadest ja fraasidest. Ka programmides pannakse laused kokku väiksematest keele elementidest, millest kõige olulisemad on avaldised.

**Näiteid lihtsatest lausetest [[Python (programmeerimiskeel)|Pythonis]]**

```python3
y = 123
```


```python3
x = 456
```


```python3
print("Näide")
```


```python3
print(x)
```


Enamikus programmeerimiskeeltes nimetatakse kõiki vaadeldavaid programmikonstruktsioone **liitlauseteks**, kuna nende kehad koosnevad teistest suvalist liiki lausetest.
Näiteks saab kasutada tingimuslause kehas lisaks lihtlausele ka korduslauset, mille kehas on omakorda kasutatud tingimuslauset, mille kehas on veel üks tingimuslause jne.

**Pythoni liitlausete näiteid**

```python3
hinne = int(input("Sisestage punktisumma: ")

if hinne >= 90:
    print("Sinu hinne on A")
elif 80 <= hinne < 90:
    print("Sinu hinne on B")
elif 70 <= hinne < 80:
    print("Sinu hinne on C")
elif 60 <= hinne < 70:
    print("Sinu hinne on D")
elif 50 <= hinne < 60:
    print("Sinu hinne on E")
elif 50 < hinne_kontroll:
    print("Sinu hinne on F")
```


## Lausetüüpe
### Omistuslause
Muutuja defineerimist (näiteks **x = 2 + 3**, üldisemalt **<muutuja nimi> = <avaldis>**) nimetatakse **omistuslauseks**. Tegemist on siiski lausega, seega kirjutatakse ta omaette reale. Muutuja kasutamine see-eest (näiteks **x** lauses **print(x)**) on avaldis, mis esineb lause või suurema avaldise sees.

**Pythoni omistuslausete näiteid**

```python3
x = 2 + 3
```


```python3
y = 0
```


```python3
n2ide = "avaldis"
```


```python3
teinen2ide = "asdf" + "ghij" + "1"
```


```python3
y = y + 1
```


```python3
z = x + y
```


### Import-lause

Moodulid on programmeerimiskeeltes olevad grupid, kuhu on jaotatud teemade kaupa erinevad käsud. Käskude mooduliteks jaotamine tagab parema organiseeritavuse. Funktsioone saab teha programmi jaoks kättesaadavaks kasutades **import**-lauset.

Mooduleid saab importida erinevatel viisidel- kas importida terve mooduli käsud (terve mooduli importimisel kasutatakse funktsiooninimede asemel tärni), ainult valitud käsud ühest moodulist või importida moodul ise. Mooduli enda importimisel peab kirjutama soovitud funktsiooni nime koos mooduli nimega.

**Näide moodulist ainult valitud käskude importimisest**


```python3
from math import sin, cos, pi

print(sin(0.3))
print(cos(0.3))
print(round(pi, 2))
```


**Näide importides kõik mooduli käsud**


```python3
from math import *

print(sin(0.3))
print(cos(0.3))
print(round(pi, 2))
```


**Näide importides ainult mooduli enda**


```python3
import math

print(math.sin(0.3))
print(math.cos(0.3))
print(round(math.pi, 2))
```


### Tingimuslause ehk if-lause
Enamikus mittetriviaalsetes programmides tuleb teatud hetkel teha valik, kuidas oma programmi jätkata. Enamik programme võimaldab programmeerijal taolised ettetulevad dilemmad panna kirja **[[tingimuslause]]** ehk **valikulause** ehk **if**-lause abil.

Tingimuslause komponentideks on päis (**if**-i ja **tingimusega** rida), then-haru (päisele (näiteks Pythonis paremale nihutatud) järgnevad read), võtmesõna **else** ning **else**-haru (mis on näiteks Pythonis samuti järgneval real ja paremale nihutatud).

Tingimuslause peaharus olevad laused täidetakse ainult siis, kui päises esitatud tingimus kehtib. Kui tingimuslauses on ka **else**-haru, siis seal olevad laused täidetakse juhul, kui tingimus ei kehti. Nii saab muuta programme paindlikumaks, pannes need käituma erinevalt olenevalt olukorrast.

Tingimusi saab (muuhulgas) moodustada järgmiste **operaatoritega**:

* , = (sobivad arvude võrdlemiseks)
* topeltvõrdusmärk (==) (tähistab võrdsust nii arvude kui ka sõnede puhul)
* != (tähistab mittevõrdsust nii arvude kui ka sõnede puhul)

**Pythoni tingimuslausete näiteid**

```python3
x = 1
if x > 0:
    print("x on nullist suurem")
else:
    print("x on null või nullist väiksem")
```


### Korduslaused
Korduslause ehk tsükli puhul täidetakse vastavalt päisele kehas olevad laused - neid laused täidetakse 0 või rohkem korda. Tingimuslausega sarnaselt kontrollitakse **while**-lause korral kõigepealt kehas olevate lausete täitmist, päises antud tingimusi. Erinevalt tingimuslausest, kontrollitakse tingimust uuesti (NB! peale keha täitmist) ning kehtivuse korral täidetakse lauses olevad kehad uuesti. Selline protsess jätkub seni, kuniks tingimus enam ei kehti. Protsesse, kus ühte ja sama toimingut mitu korda järjest teha tuleb, saab kirjeldada korduslausega. Korduste arvu programmi kirjutamisel ei pruugi ette teada.

Lisaks **while**-tsüklile on ka **for**-tsükkel. **For**-tsükkel on tihedalt seotud järjenditega.
**For**-tsükkel sarnaneb kuju poolest **while**-tsükliga, kuna mõlemal on esimesel real päis, mis määrab korduste aluse, ning edasi tuleb taandreaga tsükli keha. 

**For**-tsükli kordused sõltuvad ettantud järjendist. Igal **for**-tsükli kordusel küsitakse järjendist üks element, seejärel salvestatakse selle väärtus tsüklimuutujasse ning seejärel läbitakse tsükli kehas olevad laused. Elemente loetakse järjendist ühekaupa ja selles järjekorras, milles nad järjendis on. Tsüklit läbitakse nii mitu korda, kui on järjendis elemente.

**Pythoni korduslausete näiteid**

```python3
x = 1
while x <= 10:
    print("x on", x)
    x = x + 1
```


```python3
while True:
    try:
        laius = int(input("Sisesta maailma laius: "))
        break
    except ValueError:
        print("Vigane sisend!")
```



```python3
a = []
for i in range(10):
    a.append(i)

print(a)
```


## Viited