# Cheat sheet ng Python: syntax, mga utos at built-in na function sa mga talahanayan

URL: https://skillaria.top/tl/guides/python/cheat-sheet-python-sintaks

Ang syntax ng Python ay nakabatay sa indentation sa halip na curly braces: ang bloke sa ilalim ng colon ay nakaurong nang 4 na espasyo. Pundasyon nito ang mga variable na walang deklarasyon ng uri, mga kondisyong if/elif/else, mga loop na for at while, mga function na def, at mga built-in na function gaya ng print, len, range, input, type, pati mga method ng string, list, at dictionary.

Pinagsasama ng cheat sheet na ito sa iisang pahina ang lahat ng kailangan mo sa unang mga buwan: syntax ng Python, mga loop, built-in na function, method ng string, list, at dictionary, at mga utos sa terminal. Bawat talahanayan ay maikling sanggunian na may gumaganang halimbawa na maaaring ipasok agad sa REPL.

## Mga batayan ng syntax ng Python

Ang pangunahing katangian ng wika ay ang mga bloke na tinutukoy ng indentation, hindi ng mga panaklong. Pagkatapos ng linyang may colon (`if`, `for`, `def`, `class`), ang mga sumusunod na linya ay nakaurong nang 4 na espasyo. Hindi puwedeng paghaluin ang tab at espasyo — makakakuha ka ng `IndentationError`.

| Konstruksyon | Halimbawa | Paliwanag |
| --- | --- | --- |

| Komento | `# teksto` | lahat ng nasa pagitan ng # at dulo ng linya ay binabalewala |

| Variable | `age = 25` | walang deklarasyon ng uri, tinutukoy ito ng halaga |

| Sabay-sabay na assignment | `a, b = 1, 2` | unpacking; pagpapalitan ng halaga: `a, b = b, a` |

| Output | `print("Kumusta", name)` | pinaghihiwalay ng espasyo ang mga argumento |

| Input | `s = input("Pangalan: ")` | laging nagbabalik ng string |

| f-string | `f"{name}: {price:.2f}"` | pagpapalit ng expression at format |

| Type annotation | `count: int = 0` | pahiwatig para sa IDE at mga checker, hindi sinusuri sa pagpapatakbo |

| Walang laman na bloke | `pass` | placeholder kung saan kailangan ng syntax ang katawan |

| Import | `from math import sqrt` | pag-uugnay ng module o pangalan mula rito |

### Mga uri ng data

| Uri | Literal | Nababago |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | hindi |

| `float` | `3.14`, `1e-3` | hindi |

| `bool` | `True`, `False` | hindi |

| `str` | `"teksto"`, `'teksto'`, `"""maraming linya"""` | hindi |

| `list` | `[1, 2, 3]` | oo |

| `tuple` | `(1, 2)`, `(1,)` | hindi |

| `dict` | `{"a": 1}` | oo |

| `set` | `{1, 2}`, walang laman — `set()` | oo |

| `NoneType` | `None` | — |

### Mga operator

| Grupo | Mga operator | Halimbawa → resulta |
| --- | --- | --- |

| Aritmetika | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Paghahambing | `== != < > <= >=` | `1 < x < 10` — chain ng paghahambing |

| Lohika | `and or not` | `x or "default"` |

| Pagiging kasapi | `in`, `not in` | `"a" in "abc"` → True |

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

| Assignment | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Mga kondisyon at pattern matching

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "matanda" if age >= 18 else "bata"   # ternary operator

match command:
    case "start":
        print("Sinisimulan")
    case "stop" | "exit":
        print("Hinihinto")
    case _:
        print("Hindi kilalang utos")
```

Maling halaga ang `False`, `None`, `0`, walang laman na string, at walang laman na koleksyon, kaya sa halip na `if len(items) > 0`, isinusulat lang na `if items`.

## Mga loop sa Python: syntax ng for at while

### Loop na for

Syntax ng for loop sa Python: `for variable in sequence:` at ang katawan na may indentation. Umiikot ang loop sa anumang iterable — string, list, dictionary, file, o `range`.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["mansanas", "peras"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### Loop na while

```
attempts = 3
while attempts > 0:
    password = input("Password: ")
    if password == "secret":
        print("Matagumpay ang pag-login")
        break
    attempts -= 1
else:
    print("Naubos ang mga pagsubok")   # tumatakbo kung walang naganap na break
```

| Utos | Ano ang ginagawa |
| --- | --- |

| `break` | lumalabas sa loop nang maaga |

| `continue` | lumilipat sa susunod na iterasyon |

| `else` ng loop | tumatakbo kung natapos ang loop nang walang `break` |

| `range(stop)`, `range(start, stop, step)` | sunod-sunod na numero, hindi kasama ang `stop` |

### List comprehensions

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # generator expression
```

## Mga function

```
def greet(name: str, greeting: str = "Kumusta") -> str:
    """Nagbabalik ng pagbati."""
    return f"{greeting}, {name}!"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Ana"))                  # Kumusta, Ana!
print(greet("Ana", greeting="Hi"))   # Hi, Ana!
```

| Elemento | Kahulugan |
| --- | --- |

| `def f(a, b=1)` | parameter na may default na halaga |

| `*args` | anumang bilang ng positional argument (tuple) |

| `**kwargs` | anumang bilang ng named argument (dictionary) |

| `return` | nagbabalik ng halaga; kung wala ito, magbabalik ang function ng `None` |

| `lambda x: ...` | maikling anonymous na function na isang expression lang |

| `global`, `nonlocal` | pagbabago ng variable mula sa mas labas na scope |

Huwag gumamit ng nababagong default na halaga gaya ng `def f(items=[])`: ginagawa ang list nang isang beses at naiipon sa pagitan ng mga tawag. Ang tama ay `items=None` at sa loob, `if items is None: items = []`.

## Mga built-in na function ng Python

Magagamit ang mga built-in na function ng Python nang walang import. Ito ang mga pangunahing function na halos nasa bawat script.

| Function | Ano ang ginagawa | Halimbawa → resulta |
| --- | --- | --- |

| `print()` | nagpi-print ng mga halaga | `print(1, 2, sep="-")` → 1-2 |

| `input()` | bumabasa ng string mula sa keyboard | `int(input())` |

| `len()` | haba ng koleksyon o string | `len("abc")` → 3 |

| `type()` | uri ng object | `type(3.0)` → <class 'float'> |

| `isinstance()` | pagsusuri ng uri | `isinstance(5, int)` → True |

| `int() float() str() bool()` | conversion ng uri | `int("42")` → 42 |

| `list() tuple() set() dict()` | paggawa ng koleksyon | `list("ab")` → ['a', 'b'] |

| `range()` | saklaw ng mga numero | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | mga pares na (index, elemento) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | pinagdudugtong ang mga sequence nang pares-pares | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | kabuuan, pinakamaliit, pinakamalaki | `max([3, 7, 1])` → 7 |

| `abs() round()` | absolute value at pag-round | `round(3.14159, 2)` → 3.14 |

| `sorted()` | bagong nakaayos na list | `sorted(words, key=len, reverse=True)` |

| `reversed()` | iterator sa baligtad na pagkakasunod | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | ilapat ang function / salain | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | kahit isa / lahat ay totoo | `all(x > 0 for x in nums)` |

| `open()` | nagbubukas ng file | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | tulong at listahan ng attribute | `help(str.split)`, `dir(list)` |

| `id() hash()` | identifier at hash ng object | `hash("a")` |

Ang pinakamadaling python reference ay laging nasa kamay mo — ang function na `help()` sa REPL: ipapakita ng `help(dict)` ang lahat ng method ng dictionary na may paglalarawan, at ang `dir(obj)` ay ang listahan ng magagamit na pangalan.

## Mga method ng string

Syntax ng string sa Python: hindi nababago ang string, at bawat method ay nagbabalik ng bagong string. Gumagana ang mga slice gaya ng sa list: `s[1:4]`, `s[::-1]` — pagbaligtad.

| Method | Halimbawa → resulta |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"bata".replace("b", "k")` → 'kata' |

| `find() index()` | `"hello".find("l")` → 2; kung wala — -1 (sa `index` — error) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Mga utos ng list sa Python

Ang list ay nababagong, nakaayos na koleksyon. Karamihan ng method ay nagbabago ng list sa mismong lugar at nagbabalik ng `None`, kaya ang `a = a.sort()` ay karaniwang pagkakamali.

| Operasyon | Ano ang ginagawa | Halimbawa |
| --- | --- | --- |

| `append(x)` | nagdaragdag sa dulo | `a.append(4)` |

| `extend(iter)` | nagdaragdag ng lahat ng elemento | `a.extend([5, 6])` |

| `insert(i, x)` | nagsisingit sa index | `a.insert(0, "first")` |

| `remove(x)` | nagbubura ng unang paglitaw ng halaga | `a.remove(3)` |

| `pop(i)` | nagbubura at nagbabalik ng elemento (default ang huli) | `last = a.pop()` |

| `clear()` | nililinis ang list | `a.clear()` |

| `index(x)` | index ng unang paglitaw | `a.index("b")` |

| `count(x)` | bilang ng paglitaw | `a.count(1)` |

| `sort()` | nag-aayos sa mismong lugar | `a.sort(key=str.lower)` |

| `reverse()` | binabaligtad sa mismong lugar | `a.reverse()` |

| `copy()` | shallow na kopya | `b = a.copy()` |

| `del a[i]` | pagbura ayon sa index o slice | `del a[1:3]` |

| Mga slice | `a[start:stop:step]` | `a[-1]` — ang huli, `a[:3]` — unang tatlo |

## Mga utos ng dictionary sa Python

| Operasyon | Ano ang ginagawa | Halimbawa |
| --- | --- | --- |

| `d[key]` | halaga ayon sa susi, kung walang susi — `KeyError` | `d["name"]` |

| `get(key, default)` | halaga o kapalit | `d.get("age", 0)` |

| `d[key] = value` | magdagdag o magbago | `d["city"] = "Maynila"` |

| `keys() values() items()` | mga susi, halaga, pares | `for k, v in d.items():` |

| `update()` | pagsasama sa ibang dictionary | `d.update({"a": 1})` |

| `d1 | d2` | bagong pinagsamang dictionary | `merged = defaults | user` |

| `pop(key, default)` | magbura at magbalik ng halaga | `d.pop("tmp", None)` |

| `popitem()` | magbura ng huling idinagdag na pares | `d.popitem()` |

| `setdefault(key, value)` | ibalik ang halaga, o gumawa kung walang susi | `d.setdefault("tags", []).append("py")` |

| `key in d` | pagsuri kung may susi | `if "name" in d:` |

| `dict.fromkeys()` | dictionary mula sa mga susi na may iisang halaga | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | laki at pagbura | `del d["old"]` |

### Mga tuple at set

| Operasyon | Halimbawa → resulta |
| --- | --- |

| Unpacking ng tuple | `x, y = (3, 4)` |

| Magdagdag sa set | `s.add(5)`, magbura — `s.discard(5)` |

| Union / intersection | `{1, 2} | {2, 3}` → {1, 2, 3}; `{1, 2} & {2, 3}` → {2} |

| Difference | `{1, 2} - {2}` → {1} |

| Pag-alis ng duplicate sa list | `list(dict.fromkeys(items))` — pinananatili ang pagkakasunod |

## Mga exception at file

```
try:
    number = int(input("Numero: "))
except ValueError as err:
    print("Hindi ito numero:", err)
else:
    print("Tagumpay")
finally:
    print("Laging tumatakbo")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("linya\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| Exception | Kailan ito lumilitaw |
| --- | --- |

| `SyntaxError`, `IndentationError` | error sa syntax o indentation |

| `NameError` | hindi natukoy ang pangalan (typo) |

| `TypeError` | operasyon sa hindi angkop na uri: `"1" + 1` |

| `ValueError` | tamang uri, pero maling halaga: `int("abc")` |

| `IndexError`, `KeyError` | walang ganoong index o susi |

| `FileNotFoundError` | hindi nakita ang file |

| `ZeroDivisionError` | paghahati sa zero |

## Mga class

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name}: Aw!"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Bantay").bark())   # Bantay: Aw!
print(Point(1, 2))            # Point(x=1, y=2)
```

## Mga built-in na module ng Python

Kasama ng interpreter ang standard library — sapat na ang `import`.

| Module | Para saan | Halimbawa |
| --- | --- | --- |

| `math` | matematika | `math.sqrt(16)` → 4.0 |

| `random` | random na numero | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | petsa at oras | `datetime.date.today()` |

| `pathlib` | mga path at file | `Path("data").glob("*.csv")` |

| `os`, `sys` | sistema, environment variable, argumento | `os.environ.get("HOME")`, `sys.argv` |

| `json` | pagbasa at pagsulat ng JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | mga talahanayan ng CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | mga kombinasyon at chain ng iterator | `itertools.chain(a, b)` |

| `re` | regular expression | `re.findall(r"\d+", s)` |

| `time` | pag-pause at pagsukat ng oras | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | asynchronous na code | `asyncio.run(main())` |

Sa Python 3.15, lumitaw ang lazy import (PEP 810): ang `lazy import pandas as pd` ay ipinagpapaliban ang pag-load ng module hanggang sa unang paggamit nito, kaya mas mabilis mag-start ang script na may mabibigat na dependency.

## Mga utos ng Python sa terminal

Hiwalay na grupo ng mga tanong ang «python commands» — ito ang mga utos para patakbuhin ang interpreter at mag-install ng library. Sa Windows, kadalasang `python` o `py` ang isinusulat sa halip na `python3`.

| Utos | Ano ang ginagawa |
| --- | --- |

| `python3 --version` | ipakita ang bersyon |

| `python3` | buksan ang interactive na console na REPL (labas — `exit()`) |

| `python3 script.py` | patakbuhin ang file |

| `python3 -c "print(2 + 2)"` | patakbuhin ang isang linya |

| `python3 -m venv .venv` | gumawa ng virtual environment |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | i-activate ang environment (Linux, macOS / Windows) |

| `python3 -m pip install requests` | mag-install ng package |

| `pip list`, `pip freeze > requirements.txt` | listahan ng mga package at pag-save nito |

| `pip install -r requirements.txt` | mag-install ng dependencies mula sa file |

| `python3 -m http.server 8000` | simpleng web server sa kasalukuyang folder |

| `uv init`, `uv add requests`, `uv run main.py` | proyekto, dependency, at pagpapatakbo gamit ang uv |

## Mga karaniwang pagkakamali ng mga baguhan

- **Paghahambing gamit ang `=`** — sa kondisyon, kailangan ang `==`; ang iisang `=` ay assignment.
- **Nakalimutang colon** pagkatapos ng `if`, `for`, `def` — nagdudulot ng `SyntaxError`.
- **Pagdaragdag ng string at numero**: `"Edad: " + 25` ay error; isulat ang `f"Edad: {25}"`.
- **Pagbabago ng list habang umiikot** — umikot sa kopya gamit ang `for x in a[:]` o bumuo ng bagong list.
- **`input()` ay nagbabalik ng string** — para sa aritmetika, balutin ito ng `int()` o `float()`.

## Buod

Nakasandig ang syntax ng Python sa indentation, colon, at isang maliit na hanay ng konstruksyon: mga kondisyon, loop na for at while, function, at class. Idagdag ang dalawampung built-in na function at mga method ng string, list, at dictionary — at masasakop mo na ang karamihan sa araw-araw na gawain. I-save ang cheat sheet, at kapag nasanay ka na sa mga talahanayan, lumipat sa mga module at asynchronous na programming; hakbang-hakbang na ipinaliwanag ang lahat ng ito sa praktika sa kursong «Python 3.15: mula baguhan hanggang propesyonal».

## FAQ

**Ilang espasyo ang dapat gamitin sa indentation sa Python?**

Ayon sa PEP 8, 4 na espasyo bawat antas. Ang mahalaga ay pare-pareho ito sa buong bloke at hindi hinahaluan ng tab.

**Ano ang pagkakaiba ng list at tuple?**

Nababago ang list, maaari itong dagdagan at ayusin sa mismong lugar; hindi nababago ang tuple, kaya angkop itong maging susi ng dictionary at para sa mga nakapirming set ng halaga.

**Paano makikita ang lahat ng method ng isang object sa Python?**

Tawagin ang dir(obj) para sa listahan ng mga pangalan at help(obj) para sa paglalarawan — halimbawa, ang help(str) ay magpapakita ng lahat ng method ng string.

**Ano ang pagkakaiba ng sort() at sorted()?**

Inaayos ng method na list.sort() ang mismong list at nagbabalik ng None, habang ang function na sorted() ay nagbabalik ng bagong list at gumagana sa anumang iterable.

**Kailangan ba ng semicolon sa dulo ng linya?**

Hindi. Puwede ang semicolon para sa ilang utos sa iisang linya, pero sa karaniwang code, isinusulat ang bawat instruksyon sa sariling linya.


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