Learning Python - Syntax & Program Structure

#Introduction

After understanding Python's architecture in episode 2, now it's time to write real code. Episode 3 builds the syntax foundation you'll use throughout the series: built-in data types, operators, control flow, functions, and comprehensions.

#Built-in Data Types

#Data Type Groups

Python provides built-in data types that cover almost every need:

• Numeric: int and float for integers and fractions.
• Sequence: str, list, tuple, and range.
• Mapping: dict for key-value pairs.
• Set: set and frozenset for unique collections.
• Boolean: bool for True and False values.

You can check a data type with the type function:

Memeriksa tipe data

angka = 42
pecahan = 3.14
teks = "Python"
daftar = [1, 2, 3]
pasangan = {"kunci": "nilai"}
 
print(type(angka))
print(type(teks))
print(type(daftar))
print(type(pasangan))

The call type(angka) returns the type of each value.

#Basic Operators

#Arithmetic Operators

Python supports a complete set of arithmetic operators, including a few that set it apart from other languages:

Operator aritmetika

a = 17
b = 5
 
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

The output of a // b is floor division, a % b is the remainder, and a ** b is exponentiation. Note that / always returns a float, while // returns an integer.

#Control Flow

#if-elif-else Branching

Control flow governs the order of execution. Branching uses if, elif, and else:

Percabangan

nilai = 85
 
if nilai >= 90:
    predikat = "A"
elif nilai >= 80:
    predikat = "B"
else:
    predikat = "C"
 
print(predikat)

The block if nilai >= 90: checks conditions in sequence. Python uses indentation to define code blocks, not curly braces like C. Consistent indentation is very important.

#for and while Loops

Loops use for to iterate collections and while for conditions:

Pengulangan

for i in range(3):
    print(i)
 
total = 0
while total < 5:
    total += 1
 
print(total)

for i in range(3) iterates the numbers 0 through 2. range is evaluated lazily, so it's memory-efficient.

#Functions

#Defining and Calling Functions

Functions wrap reusable logic. The syntax uses the def keyword:

Fungsi dengan default parameter

def sapa(nama, sapaan="Halo"):
    return f"{sapaan}, {nama}!"
 
print(sapa("Arman"))
print(sapa("Arman", sapaan="Selamat pagi"))

The function sapa takes the required nama and sapaan with a default value. Calling sapa("Arman", sapaan="Selamat pagi") uses keyword arguments, which makes the code clearer at the call site.

#Docstrings

Every public function should be documented with a docstring — a string literal placed right below the function definition:

Fungsi dengan docstring

def luas_persegi(sisi):
    """Menghitung luas persegi.
 
    Argumen:
        sisi (float): panjang sisi persegi.
 
    Returns:
        float: luas persegi.
    """
    return sisi * sisi
 
print(luas_persegi(4))

The docstring """Menghitung luas persegi...""" can be read via luas_persegi.__doc__ or tools like help(). This is part of documentation that we'll explore more deeply in episode 19.

#Comprehensions

#List Comprehension

Comprehensions are a concise way to build collections from an iterable:

List comprehension

angka = [1, 2, 3, 4, 5]
 
kuadrat = [n * n for n in angka]
genap = [n for n in angka if n % 2 == 0]
 
print(kuadrat)
print(genap)

[n for n in angka if n % 2 == 0] produces a new list containing the even numbers. Comprehensions read like natural language and are more concise than manual loops. The same pattern applies to dict and set — {n: n * n for n in angka} builds a dict, while {n for n in range(10) if n % 2 == 0} builds a set.

#Naming Best Practices

#PEP 8 Conventions

Python has naming conventions governed by PEP 8:

• Functions and variables: lowercase with underscores, e.g. hitung_total.
• Classes: CamelCase, e.g. PenggunaService.
• Constants: UPPERCASE, e.g. MAKS_RETRY.

#Closing

Key takeaways:

• Built-in data types include int, float, str, list, tuple, dict, and set.
• Python uses indentation to define code blocks.
• if-elif-else and for-while are the basic control flow structures.
• Functions are wrapped with the def keyword and can have default parameters.
• List comprehensions condense collection building.
• PEP 8 naming conventions keep team code consistent.

In the next episode, episode 4, we'll cover advanced functions and functional tools — positional and keyword arguments, *args and **kwargs, the mutable default trap, higher-order functions, lambda, functools, and iterator utilities. Your syntax foundation will be put straight to the test with deeper patterns!