Python, gets mo na?

Ang Python ay nagbabasa ng code mo mula itaas pababa, isang line sa isang pagkakataon. Parang recipe: step 1 muna bago step 2. Ang print() ay nagpapakita ng kahit ano sa screen (output). Ang mga line na nagsisimula sa # ay comment: notes mo lang 'yan para sa sarili mo, hindi pinapatakbo ng Python.

Isipin mo ang variable bilang name tag na idinidikit sa isang value. Kapag sinabi mong edad = 18, gumawa ang Python ng value na 18 at idinikit ang tag na edad doon.

Importante: ang = sa Python ay hindi "equals" na parang sa math. Ang ibig sabihin niya ay "i-assign": kunin ang value sa kanan, idikit sa pangalan sa kaliwa. Kaya valid ang edad = edad + 1 (sa math, imposible 'yan!).

x = 10
y = x
x = 99
print(y)

Bawat value sa Python ay may type. Ito ang nagsasabi kung ano ang pwede mong gawin sa kanya: pwedeng i-add ang dalawang number, pero ang dalawang text ay pinagdudugtong. Para malaman ang type, gamitin ang type().

edad = input("Edad mo? ")   # "18" (str)
edad = int(edad)              # 18 (int)
print(edad + 1)               # 19

print("5" + 5)

Ang string ay parang hilera ng mga kahon, isang letter bawat kahon. Bawat kahon may index (address). Nagsisimula ang bilang sa 0, hindi sa 1. Pwede ka ring magbilang mula sa dulo gamit ang negative index: -1 ang huling letter.

s = "Python"
print(len(s))        # 6
print(s.upper())     # PYTHON
print(s.lower())     # python
print(s[::-1])       # nohtyP  (baliktad!)
print("th" in s)     # True

name = "Ana"
yr = 1
# f-string: ilagay ang variable sa {}
print(f"Hi {name}, year {yr} ka na!")
# Hi Ana, year 1 ka na!

Ang list ay naka-ayos na koleksyon ng values sa loob ng [ ], hiwalay sa comma. Parang strings din: may index na nagsisimula sa 0. Ang pagkakaiba, pwede mong baguhin ang laman ng list: magdagdag, magtanggal, mag-ayos.

grades = [88, 92, 75]
print(grades[0])     # 88  (una)
print(grades[-1])    # 75  (huli)
grades[1] = 95       # palitan ang index 1
print(grades)        # [88, 95, 75]
print(sum(grades))   # 258

Sa list, hinahanap mo ang laman gamit ang number (index). Sa dictionary, hinahanap mo gamit ang key, parang student record: key → value. Nakasulat ito sa { }.

student = {"name": "Ana", "course": "BSCS", "year": 1, "scholar": True}

Ang if ay nagtatanong ng tanong na True o False ang sagot. Kapag True, tatakbo ang block sa ilalim niya. Ang mga elif ay chine-check isa-isa, mula taas pababa, at titigil sa unang True. Kapag walang True, ang else ang tatakbo.

Ang for loop ay dumadaan sa bawat item ng isang list (o string, o range), isa-isa. Sa bawat ikot, ang loop variable ay idinidikit sa susunod na item.

Kapag gusto mo lang umulit ng ilang beses, gamitin ang range(). Gumagawa ito ng sunod-sunod na numbers. Pareho ang rule sa slicing: hindi kasama ang stop.

tulog = 3
while tulog > 0:
    print("5 minutes pa...")
    tulog = tulog - 1
print("Gising na!")

for n in range(1, 10):
    if n == 3:
        continue   # skip si 3
    if n == 6:
        break      # tigil na sa 6
    print(n)
# 1 2 4 5

Ang function ay grupo ng code na may pangalan. Isusulat mo minsan gamit ang def, tapos tatawagin mo kahit ilang beses. Pumapasok ang data sa parameters, at lumalabas ang sagot gamit ang return.

def greet(name, course="BSCS"):
    return f"Hi {name} ng {course}!"

print(greet("Ana"))           # default course
print(greet("Ben", "BSIT"))   # may sariling course

Normal ang errors, kahit sa mga senior dev. Ang error message ay clue, hindi insulto. Basahin mula sa pinakababa: doon nakasulat ang type ng error at ang line number.

if edad > 18
    print("Adult")

for x in range(3):
print(x)

pangalan = "Ana"
print(Pangalan)

edad = input("Edad? ")
print(edad + 1)

nums = [10, 20, 30]
print(nums[3])

grades = []
print(sum(grades) / len(grades))

Anim na tanong lang. Pumili ng sagot para makita agad kung tama, at bakit.

Oras na para sa totoong program: ang scientific_calculator.py. Nagbubukas siya ng window na may 53 keys, ipinapakita niya ang sagot habang nagta-type ka pa lang, at may history siya ng mga na-compute mo. Mga 1,300 lines siya, pero gawa siya sa mga natutunan mo na: strings, lists, dicts, tuples, if/elif, loops at functions, plus tatlong bagong idea na makikilala mo na rin soon: classes, exceptions at recursion.

Pagkatapos ng lesson na 'to, dapat kaya mo na siyang patakbuhin sa sarili mong computer, gamitin ang bawat key, at ipaliwanag sa iba kung paano siya gumagana.

APatakbuhin sa computer mo

1. Mag-install ng Python 3.

   I-download sa python.org. Sa Windows, i-tick ang “Add python.exe to PATH” sa unang screen ng installer. Tkinter ang gamit ng calculator para gumawa ng window, at kasama na 'yan sa Python, kaya wala ka nang ibang kailangang i-install.

2. Ilagay ang dalawang file sa iisang folder.

   Halimbawa sa Documents\calculator, at nasa loob ang scientific_calculator.py (ang app) at test_scientific_calculator.py (ang tests niya).

3. Magbukas ng terminal sa folder na 'yon.

   Sa Windows: buksan ang folder sa File Explorer, i-click ang address bar, i-type ang cmd, tapos Enter. Sa VS Code: File → Open Folder…, tapos Terminal → New Terminal.

4. Patakbuhin ang calculator.

   > python scientific_calculator.py

   Lalabas ang window. Isara mo lang siya gaya ng ibang window kapag tapos ka na.

5. Patakbuhin ang tests (optional, pero ang sarap sa feeling).

   > python -m unittest -v
   test_ans_holds_last_result (…EngineTest…) ... ok
   test_arithmetic_and_precedence (…EngineTest…) ... ok
   … 41 pa …
   ----------------------------------------------------------------------
   Ran 43 tests in 4.2s
   
   OK

   Isang test ang bawat line. Kapag OK sa dulo, ibig sabihin tama lahat ng sagot na chineck ng tests.

Kapag may problema

BGamitin: tour ng window

1 2 3 4 5 6 7 8 9 10

1. 1Status chips. Ang DEG o RAD ay ang angle mode. Lumalabas ang M 3.14159 habang may naka-save sa memory.
2. 2Ipakita / itago ang history. Lumiliit ang window kapag nakatago.
3. 3Huling na-compute, tulad ng 2π×sin(30) =. Dito rin lumalabas nang pula ang mga error.
4. 4Ang display. Dito ka mag-type o gamitin ang mga key. Pwede mong i-click sa loob para i-edit ang kahit anong parte. Lumiliit ang font kapag mahaba na.
5. 5Live preview. Lumalabas na ang sagot habang nagta-type ka, bago mo pa pindutin ang =.
6. 6Scientific keys: trig, powers, roots, logs at constants.
7. 7Memory keys para mag-save ng number para mamaya.
8. 8Number pad kasama ang apat na operator, brackets, clear at backspace.
9. 9Equals: kino-compute ang sagot.
10. 10History. Naka-save dito ang bawat sagot, pinakabago sa itaas. I-click ang isa para gamitin ulit.

Ano ang ginagawa ng bawat key

Mga keyboard shortcut

CPaano siya gumagana

Ang big picture

Hindi kailanman ginagalaw ng engine ang window. Kaya kayang i-check ng tests ang mahigit isandaang sagot sa ilang segundo nang hindi binubuksan ang window, at kaya rin pwedeng gamitin ulit ang parehong engine sa website. (Ginagawa 'yan ng page na 'to: JavaScript copy ng engine ang tumatakbo sa lab sa ibaba.)

Mapa ng file

Sundan ang isang calculation

Paano niya nalalaman na × muna bago +?

Hagdan ng mga function ang parser. Bawat baitang ay may hawak na isang grupo ng operator, tapos hinihingi niya sa baitang sa ilalim ang mga piraso sa magkabilang side. Mas mahigpit ang kapit ng mas mababang baitang, kaya sila ang unang nako-compute. PEMDAS siya na isinulat bilang code.

def expr(self):
    value = self.term()
    while True:
        if self._accept("+"):
            value += self.term()
        elif self._accept("-"):
            value -= self.term()
        else:
            return value

Mga alam mo na, nasa loob ng calculator

KEY_STYLES = {
    "digit": {"faces": ("#252a37", "#2f3545", "#3a4153"),
              "text": "#f3f5fa"},
    "operator": {"faces": ("#2a2552", "#342e64", "#3e3777"),
                 "text": "#c9c1ff"},
    ...
}
face = style["faces"][STATES.index(state)]

_POSTFIX = {
    "!": _factorial,
    "%": lambda value: value / 100,
    "²": lambda value: _power(value, 2.0),
    ...
}
value = _POSTFIX[text](value)

def complete_parentheses(expression):
    return expression + ")" * max(
        expression.count("(") - expression.count(")"), 0)

tokens = []
pos = 0
while pos < len(text):
    if text[pos].isspace():
        pos += 1
        continue
    match = _TOKEN_RE.match(text, pos)
    ...
    tokens.append((kind, match.group()))
    pos = match.end()

self.history.append((expression, value))

# ↑ key: umatras sa list
position = len(self.history) - 1
text = self.history[position][0]

if head.endswith("+"):
    return head[:-1] + "−" + number
if head.endswith(("−", "-")):
    ...
return head + "−" + number

Mga bagong idea na makikilala mo next

class ScientificEngine:
    def __init__(self):
        self.degrees = True
        self.ans = 0.0

engine = ScientificEngine()
engine.evaluate("2+3")   # 5.0, at 5.0 na rin ang engine.ans

try:
    result = _Parser(tokens, self).parse()
except ZeroDivisionError:
    raise CalculatorError("Cannot divide by zero") from None

self.bind("<ButtonRelease-1>", self._on_release)
self.entry.bind("<Return>", ...)
self.entry_var.trace_add("write", self._on_text_change)
...
CalculatorApp().mainloop()

Paano iginuguhit ang window

Plain na rectangle lang ang normal na button ng Tkinter, kaya ang calculator mismo ang gumuguhit ng mga key niya. Bawat key ay isang larawan ng rounded rectangle, plus ang text niya, at nakalagay ang 53 keys sa iisang malaking canvas. Galing sa kaunting geometry ang makinis na corners: para sa bawat pixel malapit sa corner, sukatin kung gaano siya kalayo sa gitna ng bilog sa corner. Kapag kalahati ng pixel ang nasa loob ng bilog, kalahating halo ng kulay ng key at ng background ang kulay niya.

def _coverage(distance, radius):
    """How much of a pixel lies inside the circle (0 to 1)."""
    return min(max(radius - distance + 0.5, 0.0), 1.0)

Tests: code na nagche-check ng code

def test_superscripts_are_postfix_operators(self):
    self.assertResults({
        "3²5": 45,   # (3²)·5, not 3^25
        "2²³": 64,   # (2²)³
        "3²!": 362880,
    })

Mga bug na nahuli ng testing

Bago natapos ang calculator, nakahanap ng 12 bugs ang maingat na review plus 120,000 random na test input. Ilan sa kanila:

Naging bagong test ang bawat bug, kaya hindi na siya tahimik na makakabalik.

DIpaliwanag sa iba

Ang 30-second version

Ang 2-minute demo

1. Magbukas ng terminal at i-run ang python scientific_calculator.py.Isang Python file lang siya, at ang gamit lang niya ay kung ano ang kasama na sa Python.
2. I-type ang 2+3×4. Ituro ang preview na = 14.Sinusunod niya ang order of operations, at ipinapakita na niya ang sagot bago ko pa pindutin ang equals.
3. Pindutin ang =, tapos i-type ang ×2.Kapag tinuloy ko pagkatapos ng equals, sa sagot siya nagpapatuloy, na tinatawag na Ans.
4. I-type ang sin(30 at pindutin ang =.Siya na ang nagsasara ng bracket. Degrees ang ibig sabihin ng DEG; itong button ang lumilipat sa radians.
5. I-type ang 1÷0 at pindutin ang =.Message ang lumalabas kapag may error, hindi nagka-crash. Sa code, 'yan ang try at except.
6. I-click ang isang sagot sa history panel.Naka-save sa isang list ang bawat sagot, at kapag kinlick ko, magagamit ko ulit.
7. Buksan ang code sa _tokenize, tapos sa expr.Hinahati muna ang text sa tokens. Tapos ang parser ay parang hagdan ng mga function, isa sa bawat level ng order of operations.
8. I-run ang python -m unittest -v.Chine-check ng 43 tests na 'to ang mahigit isandaang sagot sa ilang segundo, kaya alam kong walang nasira kapag may binago ako.

Mga posibleng itanong sa 'yo