# Waendeshaji wa Python: hesabu, // na %, ulinganisho, and/or/not na python round

URL: https://skillaria.top/sw/guides/python/waendeshaji-python-round

Operesheni / katika Python daima hutoa float, // ni sehemu nzima iliyozungushwa chini, % ni mabaki, ** ni nguvu. Kazi round(x, n) inazungusha hadi tarakimu n kwa njia ya benki: round(2.5) ni 2, na round(3.5) ni 4; kuzungusha juu na chini hadi namba nzima hufanywa na math.ceil na math.floor, na thamani kamili ya namba ni abs.

Waendeshaji wa Python ni alama zinazogeuza thamani kuwa thamani mpya: `+` hujumlisha, `//` hugawanya kwa nambari nzima, `and` huunganisha masharti. Hapa chini kuna orodha kamili ya waendeshaji kwa mifano, tofauti kati ya `/` na `//`, mantiki ya `and`, `or`, `not`, na kazi za kuzungusha: python round, `math.ceil`, `math.floor` na `abs`. Mifano yote unaweza kuiweka kwenye REPL na kuikagua.

## Orodha ya waendeshaji wa Python

Waendeshaji wamegawanywa kwa kazi zao. Si lazima kukariri jedwali zima: katika msimbo halisi mara nyingi utakutana na hesabu, ulinganisho na viunganishi vya kimantiki.

| Kundi | Waendeshaji | Mfano |
| --- | --- | --- |

| Hesabu | `+ - * / // % **` | `7 // 2` → 3 |

| Ulinganisho | `== != < > <= >=` | `3 < 5` → True |

| Kimantiki | `and or not` | `not True` → False |

| Utambulisho | `is`, `is not` | `x is None` |

| Umiliki | `in`, `not in` | `"ka" in "kahawa"` → True |

| Kupeana thamani | `= += -= *= /= //= %= **=` | `total += 250` |

| Walrus | `:=` | `if (n := len(s)) > 10:` |

| Bitwise | `& | ^ ~ << >>` | `5 & 3` → 1 |

## Waendeshaji wa hesabu

Kujumlisha, kutoa na kuzidisha vinafanya kazi kama shuleni. Ikiwa katika usemi kuna angalau `float` moja, matokeo nayo ni `float`: `2 + 1.0` inatoa `3.0`. Namba nzima katika Python hazifuriki — `2 ** 100` itahesabiwa kwa usahihi, bila kujali tarakimu ngapi zitatokea.

```
>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951
```

### Nguvu katika Python: opereta **

Kupandisha nguvu kunaandikwa kwa nyota mbili, si `^`: alama `^` katika Python inamaanisha «XOR» ya bitwise, kwa hiyo `2 ^ 3` itarudisha 1, si 8. Nguvu ya sehemu inatoa mzizi: `9 ** 0.5` ni `3.0`. Pia kuna kazi `pow(x, y)` — kitu kile kile, pamoja na hoja ya tatu kwa mabaki: `pow(2, 10, 1000)` itarudisha 24.

Zingatia kipaumbele: `**` inatekelezwa kabla ya ishara ya kutoa ya kipengele kimoja, kwa hiyo `-2 ** 2` ni `-4`. Ikiwa unataka mraba wa namba hasi, andika mabano: `(-2) ** 2`.

## Kugawanya katika Python: /, // na %

Katika Python kuna aina mbili za kugawanya, na hili ndilo chanzo kikuu cha mshangao kwa wanaoanza. Kugawanya kwa kawaida `/` daima hurudisha `float`, hata kama mgawanyo ni kamili. Kugawanya kwa nambari nzima `//` huondoa sehemu ya desimali, na `%` hurudisha mabaki.

```
>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1
```

### Kugawanya kwa nambari nzima // na mabaki %: mazoezi

Jozi ya `//` na `%` inatatua matatizo ya aina «ni mara ngapi kamili na nini kimebaki». Katika kozi, kifuatiliaji cha matumizi kinahifadhi fedha kwa senti ili kisipoteze usahihi, na kugawanya kiasi kuwa sarafu kuu na senti:

```
cents = 125050            # tunahifadhi fedha kwa senti
main = cents // 100       # 1250 — sarafu kuu nzima
rest = cents % 100        # 50 — mabaki
print(main, rest)         # 1250 50

print(40 // 7, "wiki na", 40 % 7, "siku")   # 5 wiki na 5 siku
```

Operesheni zote mbili kwa pamoja hutolewa na kazi iliyojengwa ndani `divmod`: `divmod(125050, 100)` inatoa tuple `(1250, 50)`. Mabaki pia ni rahisi kukagua kama namba ni shufwa: `n % 2 == 0` ni kweli kwa namba shufwa.

### Namba hasi: // inazungusha chini

Opereta `//` hauondoi tu desimali, bali unazungusha chini, kuelekea minus infinity. Kwa namba chanya hakuna tofauti, kwa hasi kuna. Ishara ya mabaki `%` katika Python ni ile ile ya kigawanyaji, kwa hiyo daima kuna usawa `a == (a // b) * b + a % b`.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # kuondoa desimali, si kuzungusha chini
-3
```

### Kugawanya kwa sifuri: kosa gani

Kugawanya kwa sifuri kwa mojawapo ya waendeshaji hao watatu husababisha kighairi `ZeroDivisionError`. Hili linatumika kwa namba nzima na za desimali. Unaweza kulikamata kwa `try/except` au kukagua kigawanyaji mapema.

```
>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0
```

## Waendeshaji wa ulinganisho

Ulinganisho hurudisha `True` au `False`. Usawa unakaguliwa kwa alama mbili `==`, na `=` moja ni kupeana thamani. Nyuzi zinalinganishwa herufi kwa herufi kwa misimbo ya herufi, kwa hiyo `"B" < "a"` ni kweli: herufi kubwa zinakuja kabla ya ndogo.

```
>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 > 0.1 + 0.2 == 0.3
False
```

Minyororo ya ulinganisho kama `0 <= x < 100` ni kipengele rahisi cha Python: hakuna haja ya kuandika `and`. Na mstari wa mwisho unakukumbusha kuhusu makosa ya namba za desimali: `0.1 + 0.2` inatoa `0.30000000000000004`. Namba za desimali zilinganishe kwa `math.isclose(a, b)`, na fedha zihifadhiwe kwa senti au kwa `Decimal`.

## Waendeshaji wa kimantiki and, or, not

Waendeshaji wa kimantiki katika Python wanaandikwa kwa maneno, si kwa alama `&&` na `||` kama katika lugha nyingine. `and` ni kweli wakati pande zote mbili ni kweli, `or` — wakati angalau moja ni kweli, na `not` hugeuza thamani.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

Kipaumbele: kwanza `not`, kisha `and`, kisha `or`. Usemi `True or False and False` ni `True`, kwa sababu `and` inahesabiwa kwanza. Katika masharti magumu weka mabano — ni wazi zaidi kwako na kwa wenzako.

### and na or zinarudisha nini hasa

`and` na `or` hazirudishi lazima `True` au `False`, bali moja ya operandi. `or` inatoa thamani ya kwanza ya kweli (au ya mwisho ikiwa hakuna kweli), `and` — ya kwanza ya uongo (au ya mwisho). Thamani za uongo ni `0`, `0.0`, nyuzi tupu, makusanyo matupu, `None` na `False`.

```
>>> name = ""
>>> name or "Mgeni"
'Mgeni'
>>> 5 and 0
0
>>> not ""
True
```

Hesabu ni ya uvivu: ikiwa matokeo yako wazi kutoka upande wa kushoto, upande wa kulia haufanyiwi hesabu. Ndiyo maana `count and total / count` haitaanguka kwa kugawanya kwa sifuri wakati `count == 0`. Opereta `not`, tofauti na nyingine mbili, daima hurudisha `bool`.

## Waendeshaji is na in

`==` inalinganisha thamani, na `is` inakagua kama majina mawili yanaelekeza kwenye kitu kile kile. Vikapu viwili tupu ni sawa, lakini si kitu kimoja. Mahali pekee ambapo `is` inahitajika kila wakati ni kukagua `None`: `if x is None`.

```
>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True
```

Usilinganishe namba na nyuzi kwa `is`: wakati mwingine «inafanya kazi» kutokana na kuhifadhi vitu kwenye kumbukumbu ya ndani, lakini matokeo yanategemea utekelezaji, na Python inatoa `SyntaxWarning` kwa miundo kama `x is 5`.

Opereta `in` hukagua kuwepo: nyuzi ndogo ndani ya nyuzi, kipengele ndani ya orodha, ufunguo ndani ya kamusi. `not in` ni ukaguzi wa kinyume.

```
>>> "kahawa" in "kahawa ya kuchukua"
True
>>> "chakula" in {"chakula": 450, "teksi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## Waendeshaji wa kupeana thamani na walrus :=

Waendeshaji mchanganyiko `+=`, `-=`, `*=`, `//=` na mengine ni mafupi: `total += 250` maana yake ni `total = total + 250`. Katika Python hakuna `++` wala `--`: `x++` itasababisha kosa la sintaksia.

Opereta wa walrus `:=` (jina lake linatokana na kufanana na macho na meno ya walrus) hupeana thamani ndani ya usemi wenyewe. Ni muhimu pale thamani inapohitajika kuangaliwa na kutumika baadaye:

```
items = ["kahawa", "teksi", "chakula cha mchana", "sinema"]
if (n := len(items)) > 3:
    print(f"Matumizi mengi sana: {n}")

while (line := input("Kiasi: ")) != "":
    print(int(line) * 2)
```

Bila walrus ingebidi kuita `len` mara mbili au kutoa upeanaji kwenye mstari tofauti. Usiutumie kupita kiasi: ikiwa mstari umekuwa mgumu kusomeka, upeanaji wa kawaida ni bora.

## Kuzungusha katika Python: round, ceil, floor

Kwa kuzungusha Python ina kazi iliyojengwa ndani `round` na kazi za moduli `math`. Zinatatua kazi tofauti, na kuzichanganya ni kosa la kawaida.

| Kazi | Inafanya nini | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | kwa karibu zaidi, nusu — kwa namba shufwa | 2 | -2 | 3 |

| `math.floor(x)` | chini, kuelekea minus infinity | 2 | -3 | 2 |

| `math.ceil(x)` | juu, kuelekea plus infinity | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | kuondoa desimali, kuelekea sifuri | 2 | -2 | 2 |

### Kazi round katika Python na kuzungusha kwa njia ya benki

Kazi `round(x, n)` inazungusha hadi `n` tarakimu baada ya alama ya desimali; bila hoja ya pili inarudisha `int` nzima. Mtego mkuu: python round inazungusha kwa njia ya benki — nusu kwenda namba shufwa iliyo karibu. Kwa hiyo `round(2.5)` inatoa 2, na `round(3.5)` — 4. Hivyo makosa ya kuzungusha hayakusanyiki upande mmoja katika hesabu kubwa.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # hadi mamia
1200
>>> round(2.675, 2)     # si 2.68: kwa mfumo wa binary ni 2.67499...
2.67
```

Ikiwa unahitaji kuzungusha kwa mazoea ya shule «nusu juu», kwa mfano kwenye risiti, tumia `Decimal` pamoja na hali `ROUND_HALF_UP`. Namba ipitishe kama nyuzi, ili usirithi makosa ya `float`:

```
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')
```

Pia kuna kanuni moja kutoka kozi: zungusha tu wakati wa kuonyesha. Kwa uchapishaji mzuri hauhitaji `round` — f-string inatosha: `f"{amount:.2f}"` itaonyesha tarakimu mbili, na namba yenyewe inabaki sahihi.

### math.ceil na math.floor: kuzungusha juu na chini

`math.ceil` inahitajika pale «upungufu» hauruhusiwi: mabasi mangapi ya kukodi, kurasa ngapi kwenye matokeo. `math.floor` — pale tunapohesabu vitengo kamili pekee. Kazi zote mbili zinarudisha `int`.

```
import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # mabasi 3
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil bila math, kwa mbinu ya //
```

Katika moduli `math` kuna kazi nyingine muhimu: `math.sqrt` (mzizi), `math.isclose` (kulinganisha desimali), `math.pi`, `math.gcd`. Katika Python 3.15 kumeongezwa submoduli `math.integer` (PEP 791) kwa hesabu za namba nzima: ndani yake kuna `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, `perm`, na `math.gcd` ya zamani pamoja na nyingine zinaendelea kufanya kazi.

## Kazi abs: thamani kamili ya namba

`abs(x)` inarudisha thamani kamili — umbali kutoka sifuri bila ishara. Haihitaji kuingiza moduli, kazi ipo ndani ya lugha. Inafanya kazi kwa namba nzima, za desimali na hata changamano: kwa `3+4j` itarudisha urefu wa vekta, `5.0`.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # tulitofautiana kwa kiasi gani
320
```

Matumizi ya kawaida ni tofauti bila kuzingatia mwelekeo, na ulinganisho wenye uvumilivu: `abs(a - b) < 0.001`. Kwa namba za desimali `math.isclose` ni salama zaidi, kwa sababu inazingatia ukubwa wa namba.

## Kipaumbele cha waendeshaji

Usemi unapokuwa na waendeshaji kadhaa, Python huwatekeleza kwa kipaumbele — kutoka cha juu hadi cha chini:

1. `**`
2. ishara za kipengele kimoja `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. mabadiliko ya bitwise na operesheni zake
6. ulinganisho, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

Hivyo, `2 + 3 * 4` ni 14, na `(2 + 3) * 4` ni 20. Ukiwa na shaka, weka mabano: mabano ya ziada hayagharimu chochote, lakini kosa la kipaumbele hutafutwa kwa muda mrefu.

## Makosa ya kawaida na waendeshaji

| Kosa | Kinachotokea | Jinsi ya kufanya sahihi |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: hii ni kupeana thamani | `if x == 5:` |

| `2 ^ 3` badala ya nguvu | XOR ya bitwise, matokeo 1 | `2 ** 3` |

| kutarajia nambari nzima kutoka `8 / 2` | unapata `4.0` | `8 // 2` |

| `x == 1 or 2` | daima ni kweli: `or 2` | `x in (1, 2)` |

| kutarajia 3 kutoka `round(2.5)` | kuzungusha kwa benki kunatoa 2 | `Decimal` na `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## Hitimisho

Kumbuka jambo kuu: `/` daima hutoa float, `//` huzungusha chini, `%` hurudisha mabaki yenye ishara ya kigawanyaji, na nguvu ni `**`. Viunganishi `and`, `or`, `not` huandikwa kwa maneno na kuhesabiwa kwa uvivu, na `is` inahitajika kukagua `None`. Kazi python round inazungusha kwa njia ya benki, kwa kuzungusha juu na chini kuna `math.ceil` na `math.floor`, na thamani kamili ya namba inatolewa na `abs`. Katika kozi waendeshaji haya yanafanyiwa mazoezi — kwenye kifuatiliaji cha matumizi, ambapo fedha zinahifadhiwa kwa senti.

## FAQ

**Nawezaje kuzungusha namba kwenye Python hadi tarakimu mbili baada ya alama ya desimali?**

Tumia round(x, 2). Ikiwa unataka tu kuonyesha namba vizuri, tumia f-string f"{x:.2f}", ambayo haibadilishi thamani yenyewe.

**Kwa nini round(0.5) katika Python inarudisha 0?**

Kwa sababu round inazungusha nusu kwenda namba shufwa iliyo karibu, na 0 ni shufwa; vivyo hivyo round(1.5) na round(2.5) zinatoa 2.

**Nawezaje kupata sehemu nzima ya mgawanyo katika Python?**

Kwa opereta //: 17 // 5 inatoa 3. Kwa namba hasi huzungusha chini, kwa hiyo -17 // 5 inatoa -4; ikiwa unataka kuondoa desimali kuelekea sifuri, tumia int(-17 / 5).

**Je, Python ina opereta wa masharti (ternary)?**

Ndiyo, ni usemi wa masharti: thamani_ikiwa_kweli if sharti else thamani_ikiwa_uongo, kwa mfano "shufwa" if n % 2 == 0 else "isiyo shufwa".

**Kuna tofauti gani kati ya & na and katika Python?**

and ni opereta wa kimantiki wenye hesabu ya uvivu, na & ni AND ya bitwise kwa namba na muungano wa seti kwa seti; katika masharti ya if tumia and.


---
Source: Skillaria.Top (https://skillaria.top)