# Mga operator sa Python: aritmetika, paghahati //, round, ceil, floor at abs na may mga halimbawa

URL: https://skillaria.top/tl/guides/python/mga-operator-ng-python

Palaging nagbibigay ng float ang / sa Python, ang // ay naghahati nang buo at nagro-round pababa, ang % ay natitira, at ang ** ay power. Ang round(x, n) ay nagro-round sa n decimal na may banker's rounding: round(2.5) ay 2, at round(3.5) ay 4; pataas at pababa sa integer ay math.ceil at math.floor, at ang absolute value ay abs.

Ang mga operator sa Python ay mga simbolo na gumagawa ng bagong halaga mula sa mga halaga: ang `+` ay nagdaragdag, ang `//` ay naghahati nang buo, at ang `and` ay nagpapares ng mga kondisyon. Sa ibaba, kumpletong listahan ng mga operator na may halimbawa, ang pagkakaiba ng `/` at `//`, ang lohika ng `and`, `or`, at `not`, at ang mga function ng pag-round: python round, `math.ceil`, `math.floor`, at `abs`. Maaaring kopyahin ang lahat ng halimbawa sa REPL at subukan.

## Listahan ng mga operator sa Python

Hinahati ang mga operator ayon sa layunin. Hindi kailangang kabisaduhin ang buong talahanayan: sa totoong code, pinakamadalas ang aritmetika, paghahambing, at mga lohikal na pagdurugtong.

| Grupo | Mga operator | Halimbawa |
| --- | --- | --- |

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

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

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

| Pagkakakilanlan | `is`, `is not` | `x is None` |

| Pagiging kasapi | `in`, `not in` | `"ka" in "kape"` → True |

| Assignment | `= += -= *= /= //= %= **=` | `total += 250` |

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

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

## Mga operator sa aritmetika

Gumagana ang pagdaragdag, pagbabawas, at pagmumultiply gaya ng sa paaralan. Kung may kahit isang `float` sa expression, `float` din ang resulta: ang `2 + 1.0` ay nagbibigay ng `3.0`. Hindi nag-o-overflow ang mga integer sa Python — ang `2 ** 100` ay kakalkulahin nang tumpak, gaano man karami ang digit.

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

### Power sa Python: ang operator na **

Ang power ay dalawang asterisk, hindi `^`: sa Python, ang `^` ay bitwise na «exclusive OR», kaya ang `2 ^ 3` ay magbibigay ng 1, hindi 8. Ang fractional na exponent ay nagbibigay ng ugat: ang `9 ** 0.5` ay `3.0`. May function din na `pow(x, y)` — parehong resulta, at may pangatlong argumento para sa natitira: ang `pow(2, 10, 1000)` ay magbibigay ng 24.

Tandaan ang precedence: unahin ang `**` kaysa unary minus, kaya ang `-2 ** 2` ay `-4`. Kung kailangan ang parisukat ng negatibong numero, maglagay ng panaklong: `(-2) ** 2`.

## Paghahati sa Python: /, // at %

Dalawang uri ng paghahati ang mayroon sa Python, at ito ang pangunahing pinagmumulan ng sorpresa para sa mga baguhan. Ang karaniwang paghahati na `/` ay laging nagbabalik ng `float`, kahit buo ang hati. Ang integer division na `//` ay inaalis ang decimal na bahagi, at ang `%` ay nagbabalik ng natitira.

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

### Integer division na // at natitirang %: praktika

Nilulutas ng pares na `//` at `%` ang mga tanong na «ilang buo at ilan ang natira». Sa kurso, iniimbak ng expense tracker ang pera sa sentimo para hindi mawala ang katumpakan, at hinahati ang halaga sa piso at sentimo:

```
centavos = 125050         # iniimbak ang pera sa sentimo
pesos = centavos // 100   # 1250 — buong piso
cents = centavos % 100    # 50 — natira
print(pesos, cents)       # 1250 50

print(40 // 7, "linggo at", 40 % 7, "araw")   # 5 linggo at 5 araw
```

Pareho ang dalawang operasyon na ibinibigay ng built-in na `divmod`: ang `divmod(125050, 100)` ay nagbibigay ng tuple na `(1250, 50)`. Kapaki-pakinabang din ang natitira sa pagsuri ng pagiging even: ang `n % 2 == 0` ay totoo para sa mga even na numero.

### Mga negatibong numero: // ay nagro-round pababa

Hindi lang basta inaalis ng `//` ang decimal — nagro-round ito pababa, papunta sa negative infinity. Walang pagkakaiba ito sa mga positibong numero, pero may pagkakaiba sa mga negatibo. Ang sign ng natitira sa `%` sa Python ay kapareho ng sign ng divisor, kaya laging totoo ang `a == (a // b) * b + a % b`.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # alisin ang decimal, hindi pababa ang pag-round
-3
```

### Paghahati sa zero: anong error

Ang paghahati sa zero gamit ang alinman sa tatlong operator ay nagdudulot ng exception na `ZeroDivisionError`. Pareho ito sa integer at decimal na numero. Maaari itong saluhin gamit ang `try/except`, o suriin nang maaga ang divisor.

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

## Mga operator ng paghahambing

Nagbabalik ng `True` o `False` ang mga paghahambing. Sinusuri ang pagkakapantay sa pamamagitan ng dalawang `==`; ang iisang `=` ay assignment. Inihahambing ang mga string nang character by character ayon sa code ng mga character, kaya totoo ang `"B" < "a"`: nauuna ang malalaking titik sa maliliit.

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

Kapaki-pakinabang sa Python ang mga chain ng paghahambing gaya ng `0 <= x < 100` — hindi na kailangan ang `and`. Ang huling linya naman ay paalala tungkol sa error ng decimal na numero: ang `0.1 + 0.2` ay nagbibigay ng `0.30000000000000004`. Ihambing ang mga fractional na numero gamit ang `math.isclose(a, b)`, at iimbak ang pera sa sentimo o sa `Decimal`.

## Mga lohikal na operator na and, or, not

Isinusulat ang mga lohikal na operator sa Python bilang mga salita, hindi bilang `&&` at `||` gaya sa ibang wika. Totoo ang `and` kapag totoo ang parehong bahagi, ang `or` kapag totoo ang kahit isa, at binabaliktad ng `not` ang halaga.

| 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 |

Precedence: nauuna ang `not`, sumunod ang `and`, pagkatapos ang `or`. Ang expression na `True or False and False` ay `True`, dahil unang kinakalkula ang `and`. Sa kumplikadong kondisyon, maglagay ng panaklong — mas malinaw ito sa iyo at sa mga katrabaho.

### Ano talaga ang ibinabalik ng and at or

Hindi laging `True` o `False` ang ibinabalik ng `and` at `or`, kundi isa sa mga operand. Ang `or` ay nagbibigay ng unang totoong halaga (o ang huli, kung wala talagang totoo), at ang `and` ay nagbibigay ng unang maling halaga (o ang huli). Maling halaga ang `0`, `0.0`, walang laman na string, walang laman na koleksyon, `None`, at `False`.

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

Lazy ang pagkalkula: kung malinaw ang resulta mula sa kaliwang bahagi, hindi kinakalkula ang kanan. Kaya ang `count and total / count` ay hindi babagsak sa paghahati sa zero kapag `count == 0`. Ang `not`, hindi tulad ng dalawa, ay laging nagbabalik ng `bool`.

## Mga operator na is at in

Inihahambing ng `==` ang mga halaga, at sinusuri ng `is` kung ang dalawang pangalan ay tumuturo sa iisang object. Magkapantay ang dalawang magkaibang walang lamang basket, pero hindi sila iisang object. Ang tanging lugar kung saan palaging kailangan ang `is` ay ang pagsuri sa `None`: `if x is None`.

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

Huwag ihambing ang mga numero at string gamit ang `is`: minsan ay «gumagana» ito dahil sa internal na caching ng mga object, pero nakadepende ito sa implementasyon, at naglalabas ang Python ng `SyntaxWarning` sa mga konstruksyon gaya ng `x is 5`.

Sinusuri ng `in` kung may laman: substring sa string, elemento sa list, susi sa dictionary. Ang `not in` ay ang kabaligtad.

```
>>> "kape" in "kape na may gatas"
True
>>> "pagkain" in {"pagkain": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## Mga assignment operator at ang walrus operator :=

Ang mga pinagsamang operator na `+=`, `-=`, `*=`, `//=`, at iba pa ay shortcut: ang `total += 250` ay nangangahulugang `total = total + 250`. Walang `++` at `--` sa Python: ang `x++` ay magdudulot ng syntax error.

Ang walrus operator na `:=` (tinawag sa ganoong pangalan dahil kahawig ito ng mata at pangil ng walrus) ay nag-a-assign ng halaga mismo sa loob ng expression. Kapaki-pakinabang ito kapag kailangan ang halaga para suriin at gamitin pagkatapos:

```
items = ["kape", "taxi", "tanghalian", "sine"]
if (n := len(items)) > 3:
    print(f"Sobrang daming gastos: {n}")

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

Kung wala ang walrus, kailangang tawagin nang dalawang beses ang `len` o ilagay ang assignment sa hiwalay na linya. Huwag itong abusuhin: kung hindi na mabasa ang linya, mas mabuti ang ordinaryong assignment.

## Pag-round sa Python: round, ceil, floor

May built-in na function na `round` para sa pag-round sa Python, at may mga function ang module na `math`. Magkakaiba ang problemang nilulutas ng bawat isa, at madalas ang pagkalito sa pagitan ng mga ito ang pagkakamali.

| Function | Ano ang ginagawa | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | sa pinakamalapit, ang kalahati ay papunta sa even | 2 | -2 | 3 |

| `math.floor(x)` | pababa, papunta sa negative infinity | 2 | -3 | 2 |

| `math.ceil(x)` | pataas, papunta sa positive infinity | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | alisin ang decimal, papunta sa zero | 2 | -2 | 2 |

### Ang round sa Python at banker's rounding

Ang `round(x, n)` ay nagro-round sa `n` na decimal; kapag walang pangalawang argumento, nagbabalik ito ng buong `int`. Ang pangunahing bitag: ang python round ay nagro-round gaya ng «banker's rounding» — ang kalahati ay papunta sa pinakamalapit na even na numero. Kaya ang `round(2.5)` ay 2, at ang `round(3.5)` ay 4. Sa ganitong paraan, hindi naiipon ang error ng pag-round sa iisang direksyon sa malalaking kalkulasyon.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # hanggang sa daan-daan
1200
>>> round(2.675, 2)     # hindi 2.68: sa binary, ito ay 2.67499...
2.67
```

Kung kailangan ang pamilyar na pag-round sa paaralan na «kalahati pataas», halimbawa sa resibo, gamitin ang `Decimal` na may mode na `ROUND_HALF_UP`. Ipasa ang numero bilang string para hindi makuha ang error ng `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')
```

May isa pang tuntunin mula sa kurso: mag-round lamang kapag nagpi-print. Para sa magandang output, hindi kailangan ang `round` — sapat na ang f-string: ipapakita ng `f"{amount:.2f}"` ang dalawang decimal, habang nananatiling tumpak ang mismong numero.

### math.ceil at math.floor: pag-round pataas at pababa

Kailangan ang `math.ceil` kapag hindi katanggap-tanggap ang «kulang»: ilang bus ang oorderin, ilang pahina ang kailangan sa resulta. Ang `math.floor` naman ay kapag tanging buong yunit lamang ang binibilang. Parehong nagbabalik ng `int` ang dalawang function.

```
import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 na bus
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil nang walang math, sa pamamagitan ng //
```

May iba pang kapaki-pakinabang na function ang module na `math`: `math.sqrt` (ugat), `math.isclose` (paghahambing ng mga fraction), `math.pi`, `math.gcd`. Sa Python 3.15, lumitaw ang submodule na `math.integer` (PEP 791) para sa integer math: may `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, at `perm` dito, habang patuloy na gumagana ang lumang `math.gcd` at iba pa.

## Function na abs: absolute value

Ibinabalik ng `abs(x)` ang absolute value — ang distansya mula sa zero nang walang sign. Hindi kailangan ng import, built-in ang function. Gumagana ito sa integer, decimal, at maging sa complex na numero: para sa `3+4j`, ibinabalik nito ang haba ng vector, na `5.0`.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # gaano tayo lumihis
320
```

Karaniwang gamit nito ang pagkakaiba nang walang direksyon at paghahambing na may tolerance: `abs(a - b) < 0.001`. Para sa mga fraction, mas maaasahan ang `math.isclose`, dahil isinasaalang-alang nito ang laki ng mga numero.

## Precedence ng mga operator

Kapag maraming operator sa isang expression, sinusunod ng Python ang precedence — mula sa pinakamataas hanggang sa pinakamababa:

1. `**`
2. unary `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. bitwise shift at operasyon
6. paghahambing, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

Kaya ang `2 + 3 * 4` ay 14, at ang `(2 + 3) * 4` ay 20. Kapag nag-aalinlangan, maglagay ng panaklong: walang halaga ang sobrang panaklong, pero matagal makita ang error sa precedence.

## Mga karaniwang pagkakamali sa mga operator

| Pagkakamali | Ano ang nangyayari | Tamang paraan |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: assignment ito | `if x == 5:` |

| `2 ^ 3` sa halip na power | bitwise XOR, resulta 1 | `2 ** 3` |

| umaasa ng integer mula sa `8 / 2` | nakukuha ang `4.0` | `8 // 2` |

| `x == 1 or 2` | laging totoo: `or 2` | `x in (1, 2)` |

| umaasa ng 3 mula sa `round(2.5)` | banker's rounding ay nagbibigay ng 2 | `Decimal` na may `ROUND_HALF_UP` |

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

## Buod

Tandaan ang pangunahin: laging nagbibigay ng float ang `/`, nagro-round pababa ang `//`, ang `%` ay nagbabalik ng natitira na may sign ng divisor, at ang power ay `**`. Ang `and`, `or`, `not` ay isinusulat bilang mga salita at lazy na kinakalkula; kailangan ang `is` sa pagsuri ng `None`. Nagro-round sa even ang python round; para sa pag-round pataas at pababa, may `math.ceil` at `math.floor`, at ang absolute value ay `abs`. Sa kurso, tinatalakay ang mga operator na ito sa praktika — sa expense tracker, kung saan iniimbak ang pera sa sentimo.

## FAQ

**Paano mag-round sa Python ng numero hanggang dalawang decimal?**

Gamitin ang round(x, 2), at kung gusto lang ng magandang output, ang f-string na f"{x:.2f}", na hindi nagbabago sa mismong halaga.

**Bakit nagbabalik ng 0 ang round(0.5) sa Python?**

Dahil nagro-round ang round sa pinakamalapit na even na numero para sa kalahati, at ang 0 ay even; ganoon din ang round(1.5) at round(2.5) na nagbibigay ng 2.

**Paano makukuha ang buong bahagi ng paghahati sa Python?**

Gamit ang //: ang 17 // 5 ay magbibigay ng 3. Sa mga negatibong numero, nagro-round ito pababa, kaya ang -17 // 5 ay -4; kung gusto mong alisin ang decimal papunta sa zero, gamitin ang int(-17 / 5).

**May ternary operator ba sa Python?**

Oo, ito ay conditional expression: halaga_kung_totoo if kondisyon else halaga_kung_mali, halimbawa "even" if n % 2 == 0 else "odd".

**Ano ang pagkakaiba ng & at and sa Python?**

Ang and ay lohikal na operator na may lazy na pagkalkula, at ang & ay bitwise AND para sa mga numero at intersection para sa mga set; sa mga kondisyon ng if, gamitin ang and.


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