# Nakafa Learning Content

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/id/materi/ai-ds/pemrograman-ai/pemformatan-string
Source: https://raw.githubusercontent.com/nakafaai/nakafa.com/refs/heads/main/packages/contents/material/lesson/ai-ds/ai-programming/string-formatting/id.mdx

Cara memakai format(), f-string, lebar kolom, perataan, presisi angka, tanda, dan penanganan error saat membentuk teks Python.

---

## Konsep Dasar dan Kontrol Lebar

Pemformatan string mengatur tampilan data dalam program Python. Bayangkan menyusun data dalam tabel yang rapi, setiap kolom memiliki lebar konsisten. Python menyediakan metode `format()` dan f-strings untuk mengontrol tampilan output.

Sintaks dasar replacement field adalah `{name : width}`, dimana `name` menentukan argumen dan `width` mengatur lebar minimum output. Ketika width lebih kecil dari panjang string asli, Python tetap menampilkan string lengkap.

### Tipe Format untuk Sistem Bilangan

| Tipe format | Simbol | Contoh input | Output | Kegunaan |
|-------------|---------|--------------|--------|----------|
| Desimal | `d` | `45` | `45` | Default untuk integer |
| Biner | `b` | `45` | `101101` | Representasi bit |
| Oktal | `o` | `45` | `55` | Sistem Unix |
| Heksadesimal | `x/X` | `45` | `2d/2D` | Pemrograman tingkat rendah |

File: width_and_types.py
```python
# Width control dengan berbagai format
print('|{0:15}|'.format('xxx'))     # Output: |xxx            |
print('a = {0:6d}'.format(45))      # Output: a =     45
print('a = {0:10b}'.format(45))     # Output: a =     101101
print('a = {0:6x}'.format(45))      # Output: a =     2d

# Width lebih kecil dari string - tidak dipotong
print('|{0:1}|'.format('xxx'))      # Output: |xxx|
```

## Pengaturan Posisi dan Karakter Pengisi

### Opsi Perataan

Component: Mermaid
Props:
- title: Lebar Format Menentukan Posisi Teks
- description: Bandingkan rata kiri, kanan, dan tengah saat teks yang sama ditempatkan dalam lebar tetap.
```mermaid

  flowchart TD
      A["String masukan: 'xxx'"] --> B["Pilihan perataan"]

      B --> C["< (rata kiri)"]
      B --> D["> (rata kanan)"]
      B --> E["^ (tengah)"]

      C --> F["'xxx            '"]
      D --> G["'            xxx'"]
      E --> H["'      xxx      '"]

```

| Simbol | Nama | Perilaku | Default untuk |
|--------|------|----------|---------------|
| `<` | Rata kiri | Teks di kiri, padding di kanan | String, objek |
| `>` | Rata kanan | Teks di kanan, padding di kiri | Angka |
| `^` | Tengah | Teks di tengah, padding merata | - |

### Karakter Pengisi dan Format Lanjutan

Karakter pengisi menentukan karakter untuk mengisi ruang kosong. Default-nya adalah spasi, tetapi bisa diganti dengan karakter apa pun kecuali `{` dan `}`.

File: alignment_fill.py
```python
# Basic alignment
print('|{0:<15}|'.format('xxx'))    # Output: |xxx            |
print('|{0:>15}|'.format('xxx'))    # Output: |            xxx|
print('|{0:^15}|'.format('xxx'))    # Output: |      xxx      |

# Custom fill characters
print('|{0:-<15}|'.format('xxx'))   # Output: |xxx------------|
print('|{0:*>15}|'.format('xxx'))   # Output: |************xxx|
print('|{0:^^15}|'.format('xxx'))   # Output: |^^^^^^xxx^^^^^^|

# Decimal formatting
x = 123.98
print('x = {0:12f}'.format(x))      # Output: x =   123.980000
print('x = {0:12e}'.format(x))      # Output: x = 1.239800e+02
```

## Metode Referensi Argumen

Python menyediakan tiga cara mereferensikan argumen dalam replacement fields, masing-masing dengan aturan berbeda.

Component: Mermaid
Props:
- title: Placeholder Memilih Nilai dari Argumen
- description: Lihat bagaimana referensi posisi, nama, dan indeks memilih nilai untuk setiap placeholder format.
```mermaid

  flowchart TD
      A["Pemformatan String"] --> B["Metode Referensi Argumen"]

      B --> C["Numbered: {0} {1}"]
      B --> D["Keyword: {name}"]
      B --> E["Automatic: {}"]

      C --> F["Eksplisit dan bisa diulang"]
      D --> G["Mudah dibaca dan fleksibel"]
      E --> H["Sederhana tetapi berurutan"]

```

### Perbandingan Metode Referensi

| Metode | Sintaks | Kelebihan | Batasan |
|--------|---------|-----------|---------|
| Numbered | `{0}, {1}` | Kontrol eksplisit, bisa diulang | Harus sesuai jumlah argumen |
| Keyword | `{name}, {age}` | Mudah dibaca, fleksibel | Nama harus cocok |
| Automatic | `{}, {}` | Sintaks sederhana | Tidak bisa dicampur dengan numbered |

File: argument_methods.py
```python
# Numbered fields - kontrol eksplisit
print('{2} - {0} - {1}'.format('first', 'second', 'third'))
# Output: third - first - second

# Keyword fields - menggunakan nama
print('{name} is {age} years old'.format(name='Alice', age=25))
# Output: Alice is 25 years old

# Automatic numbering - urutan berurutan
print('{} + {} = {}'.format(5, 3, 8))
# Output: 5 + 3 = 8

# Error handling
try:
  print('{a} - {b}'.format(a='xxx'))  # Akan error
except KeyError as e:
  print(f"KeyError: {e}")  # Output: KeyError: 'b'

try:
  print('{0} - {1}'.format('xxx'))    # Akan error
except IndexError as e:
  print(f"IndexError: {e}")  # Output: IndexError: Replacement index 1 out of range for positional args tuple
```

## Kontrol Presisi dan Spesifikasi Tanda

### Presisi untuk Angka Desimal

Presisi mengontrol jumlah digit desimal atau digit signifikan dalam tampilan angka.

| Tipe format | Perilaku presisi | Contoh |
|-------------|-------------------|--------|
| `f/F` | Tempat desimal | `{:.2f}` → `123.99` |
| `e/E` | Tempat desimal dalam eksponensial | `{:.2e}` → `1.24e+02` |
| `g/G` | Digit signifikan | `{:.3g}` → `124` |

### Opsi Tanda

Component: Mermaid
Props:
- title: Tanda yang Muncul pada Angka
- description: Bandingkan tanda plus, minus, dan spasi agar keluaran angka positif dan negatif terbaca konsisten.
```mermaid

  flowchart TD
      A["Angka masukan"] --> B{"Pilihan tanda"}

      B --> C["+ (selalu tampilkan)"]
      B --> D["- (default)"]
      B --> E["spasi (untuk positif)"]

      C --> F["+100, -200"]
      D --> G["100, -200"]
      E --> H["' 100', '-200'"]

```

Pada baris spasi, simbolnya memang satu karakter kosong di dalam format specifier, seperti pada `{: d}`. Karena karakter itu tidak terlihat, tabel menamainya sebagai spasi literal.

| Simbol | Perilaku | Contoh |
|--------|----------|--------|
| `+` | Selalu tampilkan tanda | `+100`, `-200` |
| `-` | Hanya tanda negatif (default) | `100`, `-200` |
| spasi literal | Menyisakan satu spasi sebelum angka positif | `' 100'`, `'-200'` |

File: precision_sign.py
```python
# Precision control
print('x = {0:.3f}'.format(123.98765))     # Output: x = 123.988
print('x = {0:12.2e}'.format(1.987e-10))   # Output: x =     1.99e-10
print('x = {0:.3g}'.format(1.123456))      # Output: x = 1.12

# Sign specification
numbers = [-100, 200, -300]
print('Default:', ['{:d}'.format(n) for n in numbers])
# Output: Default: ['-100', '200', '-300']
print('Always sign:', ['{:+d}'.format(n) for n in numbers])
# Output: Always sign: ['-100', '+200', '-300']
print('Space positive:', ['{: d}'.format(n) for n in numbers])
# Output: Space positive: ['-100', ' 200', '-300']

# Rounding behavior
print('Tiny number f: {0:12f}'.format(1.1e-10))  # Output: Tiny number f:     0.000000
print('Tiny number g: {0:12g}'.format(1.1e-10))  # Output: Tiny number g:      1.1e-10
```

## F-Strings dan Template Dinamis

### F-Strings dan Versi Python

F-strings tersedia sejak Python `3.6+` dan menyediakan sintaks paling sederhana dengan evaluasi ekspresi langsung. Lebih cepat dan mudah dibaca dibandingkan `format()`.

### Template Format Dinamis

Template format dapat menggunakan variabel untuk specification, berguna ketika format ditentukan secara dinamis.

File: fstrings_dynamic.py
```python
# F-strings - sintaks sederhana
name, age = 'Alice', 25
print(f'{name} is {age} years old')           # Output: Alice is 25 years old
print(f'Next year: {name} will be {age + 1}') # Output: Next year: Alice will be 26

# Dynamic format templates
value, width, fill, align = 'data', 12, '-', '^'
template = '|{val:{f}{a}{w}}|'
result = template.format(val=value, w=width, f=fill, a=align)
print(result)                                 # Output: |----data----|

# Comparison - same output, different methods
x = 123.456
print('Old style: %8.2f' % x)                # Output: Old style:   123.46
print('Format method: {0:8.2f}'.format(x))   # Output: Format method:   123.46
print(f'F-string: {x:8.2f}')                 # Output: F-string:   123.46

# Complex f-string with format spec
import math
radius = 5.7
print(f'Area: {math.pi * radius**2:.2f} cm²') # Output: Area: 102.07 cm²
```

### Pola Lengkap Spesifikasi Format

Component: Mermaid
Props:
- title: Urutan di Dalam Spesifikasi Format
- description: Baca urutan fill, align, width, precision, dan type agar mini-language format tidak terlihat acak.
```mermaid

  flowchart TD
      A["Spesifikasi format"] --> B["Urutan komponen"]

      B --> C[": (mulai)"]
      C --> D["fill (karakter pengisi)"]
      D --> E["align (posisi: < > ^)"]
      E --> F["sign (tanda: + - spasi)"]
      F --> G["width (lebar minimum)"]
      G --> H[".prec (presisi desimal)"]
      H --> I["type (tipe: d b o x f e g)"]

      J["Contoh Lengkap"] --> K["{nilai:*^+10.2f}"]
      K --> L["komponen format"]

```

Format specification mengikuti pola `{name:fill align sign width .prec type}` dimana setiap komponen opsional dan memiliki fungsi spesifik untuk mengontrol tampilan output.