<!DOCTYPE html>
<html lang="sl">
<head>
  <meta charset="utf-8" />
  <title></title>
  <link rel="stylesheet" type="text/css" href="/css/codeq.css" />
  <link rel="stylesheet" type="text/css" href="../../style.css" />
</head>
<body>

<h2>Pogoji</h2>

<p>Zdaj pa povejmo nekaj splošnejšega o pogojih. Kakšni vse so lahko? Najprej,
    pogoj je izraz. Torej nekaj, kar se da izračunati (po naši garažni
    definiciji izraza). Doslej so bili vsi naši izrazi nekako številski,
    aritmetični: v njih so nastopala števila in le-ta smo seštevali, množili,
    odštevali in kar se še takega dela s števili. Pogoji pa so logični izrazi.
    (V resnici se "logičnost" in "številskost" lahko poljubno prepletata, a to
    bomo mimogrede odkrili sproti.)</p>

<p>Rezultat logičnega izraza je logična vrednost. Logične vrednosti niso števila
    (torej niso <code>int</code> ali <code>float</code>) in niso nizi, torej so
    nekaj četrtega. Podatkovni tip, ki hrani logične vrednosti, se imenuje
    <code>bool</code> (iz Boolean, po slovensko Booleov). Medtem ko je
    različnih števil (<code>int</code>, <code>float</code>) kar veliko,
    ima tip <code>bool</code> lahko le eno od dveh
    vrednosti, <code>True</code> ali <code>False</code>. Tudi <code>True</code>
    in <code>False</code> rezervirani besedi. </p>

<p>S števili že znamo računati. Z nizi tudi malo. Kako pa računamo z logičnimi
    vrednostmi? Menda jih ne moremo kar tako seštevati in odštevati?</p>

<p>Za zdaj se delajmo, da ne. Kasneje bomo videli, da zna Python z logičnimi
    izrazi početi še to in ono zanimivo reč, ki pa za začetnika niso tako
    pomembne.</p>

<p>Za logične izraze so nam na voljo trije operatorji: <code>or</code>,
    <code>and</code> in <code>not</code>.

<pre>
>>> True and True
True
>>> True and False
False
>>> False or True
True
>>> not False
True
>>> False or not False
True
</pre>

<p>(<code>and</code>, <code>or</code> in <code>not</code> so rezervirane besede.</p>

<p>Operator <code>not</code> ima prednost pred <code>and</code>,
    <code>and</code> pa pred <code>or</code>. Spet si lahko pomagamo z
    oklepaji: <code>a or b and c</code> pomeni isto kot
    <code>a or (b and c)</code> in bo resničen (<code>True</code>), če je resničen
    <code>a</code> ali pa sta resnična <code>b</code> in <code>c</code>. Izraz
    <code>(a or b) and c</code> pa bo resničen, če sta resnična <code>a</code>
    ali <code>b</code> (ali oba), poleg tega pa nujno še <code>c</code>. Pri
    tem seveda predpostavljamo, da <code>a</code>, <code>b</code> in
    <code>c</code> vsebujejo logične vrednosti.</p>

<p>Da bo reč lažje razumljiva, jo potrenirajmo na prav tem izrazu, vendar tako,
    da namesto <code>a</code>, <code>b</code> in <code>c</code> oziroma namesto
    "golih" <code>True</code> in <code>False</code> pišemo bolj "konkretne"
    izraze.</p>

<pre>
>>> 352 > 0
True
>>> 5 < 3
False
>>> 352 > 0 or 5 < 3
True
>>> 352 > 0 or 5 > 3
True
>>> 352 > 0 and 5 > 3
True
>>> 352 > 0 and 5 < 3
False
>>> 352 > 0 and not 5 < 3
True
>>> 10 > 8 or 352 > 0 and 5 < 3
True
>>> 10 > 8 or (352 > 0 and 5 < 3)
True
>>> (10 > 8 or 352 > 0) and 5 < 3
False
>>> (10 > 8 or 352 > 0) and not 5 < 3
True
</pre>

<p>Operatorja &gt; in &lt; pričakujeta na levi in desni neke reči, ki jih je
    mogoče primerjati; zadovoljna nista le s števili, temveč tudi z, recimo,
    nizi (primerjala jih bosta po abecedi), ne moreta pa primerjati števila z
    nizom. Njun rezultat je logična vrednost. Za "večje ali enako" in "manjše
    ali enako" uporabimo <code>&gt;=</code> in <code>&lt;=</code>.</p>

<p>Če želimo preveriti enakost dveh števil (ali, v splošnem, enakost dveh
    stvari), uporabimo dvojni enačaj, <code>==</code>. Enojni enačaj je dobil
    svojo zadolžitev prejšnjo uro, namenjen je namreč prirejanju. Ali sta dve
    stvari različni, preverimo z <code>!=</code>.</p>

<pre>>>> 1 + 1 == 2
True
>>> 1 + 1 != 2
False</pre>
</p>

<p>Ne zamenjujte dvojnih in enojnih enačajev. Če pomotoma napišemo (a to se nam
    bo rekdo zgodilo),</p>
<pre> a == 1 + 1</pre>
<p>s tem nismo priredili <code>a</code>-ju dvojke, temveč smo le preverili, ali je
    enak 2. Pogostejša napaka pa bo</p>
<pre> if a = 1:
    print("Vrednost a je ena")</pre>
<p>Ta program pa je sintaktično nepravilen, saj Python za <code>if</code>
pričakuje pogoj, mi pa smo napisali prireditveni stavek.</p>



<p>Zdaj pa Pythonova posebnost, ki je v drugih jezikih ne bo: operatorje smemo nizati. Izraz
    <code>10 &lt; T &lt; 20</code> je resničen, če je <code>T</code> med 10 in
    20. Izraz <code>10 &lt; T1 &lt; T2 &lt; 20</code> je resničen, če sta
    <code>T1</code> in <code>T2</code> med 10 in 20, pri čemer je
    <code>T1</code> manjši od <code>T2</code>. Izraz
    <code>T1 &lt; 10 &lt; T2</code> je resničen, če je <code>T1</code> manjši
    od 10, <code>T2</code> pa večji od deset.
    <code>10 &lt; T1 == T2 &lt; 20</code> je resničen, če sta
    <code>T1</code> in <code>T2</code> enaka in sta nekje med 10 in 20.</p>

<p>Če se torej končno vrnemo k suhcem in debeluhom: če bi se hoteli
    skoncentrirati le na te, ki so ravno pravšnji, bi lahko napisali,
    recimo</p>

<pre>if bmi > 18.5 and bmi < 25:
    print("Čestitamo, ravno pravšnji ste.")</pre>

<p>Če kdo napiše</p>

<pre>if (bmi > 18.5) and (bmi < 25):
    print("Čestitamo, ravno pravšnji ste.")</pre>

<p>ali celo</p>

<pre>if ((bmi > 18.5) and (bmi < 25)):
    print("Čestitamo, ravno pravšnji ste.")</pre>

<p>Ga bomo čudno gledali (((kdor hoče oklepaje, naj gre raje programirat v
<a href="http://xkcd.com/297/">Lisp</a>))). Prav po Pythonovsko pa se reče:</p>

<pre>if 18.5 < bmi < 25:
    print("Čestitamo, ravno pravšnji ste.")</pre>


</body>
</html>