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

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.

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 <= 10     # chain: 1 < 5 and 5 <= 10
True
>>> 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.

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.

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

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.