Fungsi ord() Pada Python

Halo semuanya! Ketika kita berbicara tentang pemrograman di Python, pasti ada banyak sekali fitur dan fungsi bawaan yang dapat membantu kita menyelesaikan berbagai tugas. Salah satu fungsi yang cukup sederhana namun sangat bermanfaat adalah ord(). Mungkin kalian sudah sering mendengar atau bahkan memakai fungsi ord() ini, tapi ada juga yang masih bertanya-tanya, "Apa sih sebenarnya fungsi ord() itu?" atau "Bagaimana cara menggunakannya dalam situasi nyata?". Nah, artikel ini akan mengupas tuntas tentang fungsi ord() dengan gaya semi-santai, disertai berbagai contoh penerapan di bermacam-macam kasus. Jadi, silakan duduk santai dan mari kita mulai!

Apa Itu ord()?

Fungsi ord() merupakan salah satu built-in function yang ada di Python. Secara sederhana, ord() berfungsi untuk mengembalikan nilai numerik (dalam format integer) yang mewakili karakter Unicode tertentu. Dengan kata lain, kalau kita memberi ord() sebuah karakter (misalnya huruf, angka, simbol, emoji, dan sebagainya), ia akan memberi kita "kode angka" yang merepresentasikan karakter tersebut di dalam sistem Unicode.

Contoh singkatnya begini: jika kita memanggil ord('A'), kita akan mendapatkan angka 65. Angka 65 adalah kode ASCII atau Unicode untuk karakter 'A'. Begitu juga jika kita memanggil ord('a'), maka hasilnya adalah 97.

Karena ord() hanya menerima satu karakter (atau lebih tepatnya satu buah string berukuran 1 karakter), kita tidak bisa langsung memasukkan string yang panjang ke dalam fungsi tersebut. Jika kita mencoba ord("ABC"), Python akan memunculkan error. Artinya, ord() ini memang dikhususkan untuk mengonversi satu karakter tunggal menjadi nilai numeriknya.

Kenapa Fungsi ord() Penting?

Sekilas mungkin terdengar sepele: "Oh, ord() cuma mengubah huruf ke angka. Buat apa?" Tapi sebenarnya, ada banyak sekali skenario di mana kita butuh nilai numerik dari suatu karakter. Misalnya:

1. Pembuatan algoritma enkripsi-dekripsi sederhana. Kita bisa mengubah huruf menjadi angka, lalu memodifikasi angka tersebut sebelum akhirnya mengonversinya kembali ke bentuk karakter (dengan chr()).
2. Pembuatan sistem validasi input. Kita dapat memeriksa karakter apa saja yang diizinkan, misalnya karakter alfanumerik saja, dengan memanfaatkan rentang nilai ASCII/Unicode.
3. Analisis teks atau pemrosesan string tingkat lanjut, seperti mencoba mencari perbedaan huruf kapital dan huruf kecil, menghitung jarak antar karakter, dan sebagainya.
4. Penerapan logika sorting khusus. Kadang kala, kita ingin mengurutkan karakter bukan hanya sekadar abjad, tetapi berdasarkan kode spesifik (misalnya Unicode). Menggunakan ord() dapat memudahkan kita untuk membandingkan karakter satu sama lain.

Masih banyak contoh lain yang dapat kita eksplorasi. Intinya, karena semua karakter di komputer disimpan dengan representasi numerik, fungsi ord() sangat membantu kita untuk menjembatani pemetaan antara karakter dan nilai integer tersebut.

Contoh Dasar Penggunaan ord()

Mari kita mulai dari contoh yang paling sederhana. Kita akan melihat kode berikut:

print(ord('A'))  # Output: 65
print(ord('B'))  # Output: 66
print(ord('a'))  # Output: 97
print(ord('0'))  # Output: 48

Pada contoh di atas, kita memanggil ord() dengan berbagai karakter yang berbeda. Hasilnya:

• ord('A') memberi hasil 65.
• ord('B') memberi hasil 66.
• ord('a') memberi hasil 97.
• ord('0') memberi hasil 48.

Mengapa '0' hasilnya 48? Karena dalam tabel ASCII (dan Unicode), karakter '0' berada di kode 48, '1' di kode 49, '2' di kode 50, dan seterusnya.

Membandingkan Karakter dengan ord()

Kegunaan lain dari ord() adalah saat kita ingin membandingkan karakter berdasarkan urutan ASCII atau Unicode-nya. Misalnya, kita ingin tahu apakah sebuah huruf datang sebelum huruf lain dalam urutan abjad. Kita bisa melakukan ini:

char1 = 'A'
char2 = 'B'

if ord(char1) < ord(char2):
    print(f"{char1} lebih kecil dari {char2} berdasarkan nilai ord()")
else:
    print(f"{char1} tidak lebih kecil dari {char2}")

Kita tahu bahwa ord('A') adalah 65, sedangkan ord('B') adalah 66, sehingga 65 < 66 bernilai True. Hasilnya adalah "A lebih kecil dari B berdasarkan nilai ord()". Contoh sederhana ini berguna ketika kita perlu membuat logika sorting manual, walaupun sebenarnya Python sudah punya built-in sorting yang canggih. Namun, memahami urutan ordinal ini kadang tetap bermanfaat.

Pemrosesan Karakter Non-ASCII

Salah satu keunggulan Python versi 3.x adalah ia telah mendukung Unicode secara penuh. Artinya, ord() bisa kita gunakan bukan cuma untuk karakter ASCII (A-Z, a-z, 0-9, dan simbol ASCII), tapi juga untuk berbagai karakter lain seperti huruf aksara non-Latin, emoji, dan sebagainya. Contoh:

print(ord('é'))    # Output: 233
print(ord('ä½ '))    # Output: 20320  (huruf Mandarin "ni" = kamu)
print(ord('€'))    # Output: 8364  (simbol euro)
print(ord('🙂'))   # Output: 128578 (emoji smiling face)

Dari sini, kita bisa lihat bahwa setiap karakter apa pun (yang valid dalam Unicode) memiliki nilai numerik unik. Kita sering menyebutnya sebagai code point. Karena itu, ord() menjadi amat penting jika kita bekerja dengan data teks yang mungkin memuat karakter-karakter di luar A-Z, misalnya bahasa Arab, Jepang, Korea, atau pun simbol-simbol mata uang internasional.

Pemanfaatan ord() dalam String Looping

Bayangkan kalian punya sebuah string dan ingin tahu nilai ordinal dari setiap karakter di dalamnya. Misalnya kita punya string "Hello" dan ingin mencetak semua nilai ord() karakter per karakter. Kita bisa menulis skrip sederhana seperti ini:

my_string = "Hello"
for ch in my_string:
    print(ch, "=", ord(ch))

Output yang dihasilkan akan seperti berikut:

H = 72
e = 101
l = 108
l = 108
o = 111

Dengan demikian, kita bisa mendapatkan pandangan yang lebih jelas tentang bagaimana komputer merepresentasikan string. Ini bisa sangat membantu untuk debugging ketika kita mencoba memahami perbedaan antara huruf kapital dan huruf kecil, atau jika kita berurusan dengan karakter spesial yang terlihat sama tetapi sebenarnya berbeda kode (misalnya karakter spasi biasa dan karakter non-breaking space).

Konversi Kebalikan: chr()

Tak lengkap rasanya membahas ord() tanpa menyinggung chr(). Sebagai pasangan kebalikan, chr() berfungsi untuk mengubah nilai integer (kode Unicode) menjadi karakter yang sesuai. Jadi, jika kita melakukan:

print(chr(65))   # Output: A
print(chr(97))   # Output: a
print(chr(128578))  # Output: 🙂

Maka kita mendapatkan karakter-karakter yang sesuai. Kombinasi ord() dan chr() sering dipakai dalam banyak skenario, termasuk untuk enkripsi Caesar Cipher sederhana, di mana kita bisa menambahkan atau mengurangi nilai ordinalnya lalu mengubahnya kembali ke bentuk karakter.

Contoh Implementasi Enkripsi Caesar Sederhana

Mari kita lihat contoh bagaimana ord() (dan chr()) bisa membantu kita membuat skema enkripsi Caesar Cipher sederhana. Ide dasarnya adalah: setiap huruf akan digeser beberapa langkah di abjad. Misalnya, jika kita menggeser 3 langkah, maka 'A' akan menjadi 'D', 'B' menjadi 'E', dan seterusnya.

Namun, untuk kesederhanaan, kita hanya akan mempertimbangkan huruf kapital A-Z. Kode ASCII untuk 'A' sampai 'Z' adalah 65 sampai 90. Berikut kode contohnya:

def caesar_encrypt(plaintext, shift):
    encrypted_text = ""
    for ch in plaintext:
        # Cek apakah karakter adalah huruf kapital (A-Z)
        if 'A' <= ch <= 'Z':
            # Konversi karakter ke ord()
            original_ord = ord(ch)
            # Geser nilainya
            shifted_ord = original_ord + shift
            # Pastikan tetap dalam range A-Z
            if shifted_ord > ord('Z'):
                shifted_ord = shifted_ord - 26
            # Konversi kembali ke karakter
            encrypted_text += chr(shifted_ord)
        else:
            # Jika bukan huruf kapital, biarkan apa adanya
            encrypted_text += ch
    return encrypted_text

# Contoh penggunaan
plaintext = "HELLO WORLD"
shift = 3
encrypted = caesar_encrypt(plaintext, shift)
print("Plaintext:", plaintext)
print("Encrypted:", encrypted)

Dalam contoh di atas, kita menggeser setiap huruf kapital sebanyak 3 langkah. Sehingga H akan menjadi K, E menjadi H, L menjadi O, dan seterusnya. Kita bisa mengembangkannya lebih lanjut untuk huruf kecil, angka, atau simbol lain jika diinginkan. Tetapi gambaran utamanya, kita menggunakan ord() untuk mendapatkan nilai integer dan memanipulasi nilai tersebut.

Validasi Input Berdasarkan ord()

Dalam beberapa kasus, kita mungkin ingin membatasi input pengguna supaya hanya boleh berisi karakter tertentu. Misalnya, kita hanya memperbolehkan karakter alfanumerik (A-Z, a-z, 0-9). Nah, dengan bantuan ord(), kita bisa melakukan pengecekan. Misalnya begini:

user_input = input("Masukkan teks: ")

is_valid = True
for ch in user_input:
    code = ord(ch)
    # Karakter '0' sampai '9' (48-57)
    # Karakter 'A' sampai 'Z' (65-90)
    # Karakter 'a' sampai 'z' (97-122)
    if not ((48 <= code <= 57) or (65 <= code <= 90) or (97 <= code <= 122)):
        is_valid = False
        break

if is_valid:
    print("Input valid!")
else:
    print("Input mengandung karakter terlarang!")

Dengan logika semacam ini, kita bisa mengontrol jenis karakter apa saja yang diizinkan masuk. Jika ada karakter yang jatuh di luar rentang yang kita tetapkan, maka kita beri peringatan bahwa input tidak valid. Tentu saja, di dunia nyata kita mungkin akan menggunakan fungsi string seperti .isalnum() atau .isalpha() dan sebagainya, tetapi memahami ord() tetap berguna agar kita tahu apa yang sebenarnya terjadi di balik layar.

Menampilkan Semua Karakter dalam Rentang Tertentu

Kita juga bisa reverse engineering pemakaian ord() dengan pasangan chr(). Sebagai contoh, jika kita ingin menampilkan semua karakter ASCII dari 32 sampai 126 (yang biasanya dianggap sebagai karakter ASCII yang dapat dicetak atau printable ASCII), kita bisa menulis:

for i in range(32, 127):
    print(i, "=", chr(i))

Dengan mempraktekkan ini, kita akan melihat aneka karakter seperti spasi (32), simbol-simbol tanda baca, hingga angka, huruf, dan sebagainya, sampai ~ (126). Ini adalah cara mudah untuk memahami bagaimana tabel ASCII atau subset Unicode bekerja.

Aplikasi Kreatif: Membuat Gradien Karakter

Meski terdengar sepele, kita bisa menggunakan ord() untuk membuat semacam "gradien" karakter di terminal. Misalnya, kita ingin menampilkan huruf dari A sampai Z secara bertahap di satu baris, lalu turun ke baris berikutnya. Meskipun mungkin tidak banyak gunanya di kehidupan nyata, ini salah satu latihan yang menarik untuk pemula, agar terbiasa dengan ord() dan chr(). Contohnya:

for i in range(ord('A'), ord('Z') + 1):
    print(chr(i) * (i - ord('A') + 1))

Pada kode di atas, range(ord('A'), ord('Z') + 1) akan menghasilkan daftar angka dari 65 hingga 90. Lalu kita konversi i kembali ke karakter dengan chr(i). Akhirnya, kita cetak karakter itu sebanyak (i - ord('A') + 1) kali. Alhasil, kita akan melihat:

A
BB
CCC
DDDD
EEEEE
...

Dan seterusnya hingga Z. Ini hanya contoh kecil, tapi dapat memberikan inspirasi bagaimana ord() dan chr() bisa digunakan untuk berbagai efek tekstual.

Mengecek Karakter "Unik" atau "Spesial"

Terkadang saat kita mengambil data dari sumber eksternal (misalnya teks dari file CSV, input pengguna, atau hasil scraping web), kita menemukan karakter-karakter aneh. Terkesan sama dengan spasi biasa, ternyata setelah dicek nilai ord()-nya, ia bukan spasi (32) melainkan non-breaking space (160) atau karakter lain yang mirip. Untuk mendeteksi hal seperti ini, kita bisa dengan mudah memeriksa ord(ch) dan melihat apakah ia berada di luar range normal.

Contoh:

def detect_strange_characters(text):
    for ch in text:
        if ord(ch) > 127:
            print(f"Karakter '{ch}' dengan kode {ord(ch)} terdeteksi sebagai karakter non-ASCII.")

Dengan menggunakan fungsi semacam ini, kita bisa mengetahui di mana saja karakter asing berada dan kemudian memutuskan bagaimana menanganinya (menghapus, mengonversi, atau mengganti dengan karakter lain).

Penggunaan ord() dalam Logika Pengolahan File

Bayangkan kita memiliki file biner dan kita membacanya byte demi byte, lalu ingin mengetahui apakah byte tersebut merepresentasikan karakter ASCII yang bisa dicetak atau tidak. Meskipun dalam praktek nyata lebih sering menggunakan library yang lebih khusus, memahami ord() di konteks ini tetap bermanfaat. Misalnya:

with open("sample.bin", "rb") as f:
    byte = f.read(1)
    while byte:
        # byte di sini bertipe bytes (panjang 1)
        ch = byte.decode("latin-1", errors="ignore")  # atau decoding lain
        if ch.strip():
            print(ch, ord(ch))
        byte = f.read(1)

Tentunya, decoding file biner langsung ke string bisa berisiko menimbulkan error. Kita bisa mengatasi itu dengan parameter errors="ignore" seperti contoh di atas, atau kita deteksi dulu apakah byte tersebut termasuk rentang tertentu sebelum mendecode. Tapi ord() tetap menjadi alat inti ketika kita ingin memeriksa atau memanipulasi representasi byte/karakter.

Trik Sederhana Mengubah Huruf Besar Menjadi Huruf Kecil Menggunakan ord()

Kalau kita benar-benar mau "menyelami" bagaimana komputer mengubah huruf kapital ke huruf kecil, kita bisa gunakan logika ord() dan chr(). Tentu, Python sudah menyediakan metode .lower() dan .upper(). Namun, sebagai latihan:

def to_lowercase(text):
    result = ""
    for ch in text:
        if 'A' <= ch <= 'Z':
            # Kode ASCII 'A' = 65, 'Z' = 90
            # 'a' = 97, 'z' = 122
            result += chr(ord(ch) + 32)
        else:
            result += ch
    return result

print(to_lowercase("HELLO WORLD!"))  # hello world!

Cara kerjanya sederhana: Jika karakter adalah huruf besar (A-Z), kita tambahkan 32 ke nilai ord() karena selisih antara 'A' (65) dan 'a' (97) adalah 32. Setelah itu, kita konversi kembali menjadi karakter dengan chr(). Hasilnya adalah string yang sudah dikonversi ke huruf kecil.

Penggunaan ord() pada Bahasa Pemrograman Lain

Sedikit intermezzo: fungsi serupa ord() ada di banyak bahasa pemrograman lain, meskipun namanya mungkin berbeda. Misalnya di C++ kita bisa menggunakan casting (int)'A' untuk mendapatkan angka 65, atau di Java kita pakai (int) 'A'. Di beberapa bahasa, fungsi semacam ini dinamai asc() (seperti di bahasa Visual Basic). Prinsipnya sama: kita sedang menanyakan "Apa nilai integer yang mewakili karakter ini?"

Namun, Python adalah salah satu bahasa yang sangat menekankan kemudahan dalam berurusan dengan string Unicode. Jadi, ord() di Python tidak hanya berhenti pada 256 atau 65535, ia bisa mencapai kode Unicode di atas 1 juta, sesuai dengan standar Unicode terbaru.

Kapan Kita Harus Mempertimbangkan Karakter Multi-Byte?

Meskipun ord() berurusan dengan kode karakter (code point), kadang kita juga harus waspada dengan isu encoding kalau kita bicara format penyimpanan file, terutama UTF-8. Namun, di level Python, jika kita sudah memegang string (tipe str di Python 3), maka setiap karakter dianggap sebagai Unicode code point tunggal. ord() akan memberi kita integer yang benar-benar unik untuk karakter tersebut.

Jadi, kendala multi-byte umumnya lebih muncul ketika kita membaca atau menulis data ke file, atau mungkin saat mentransmisikan data di jaringan dengan format tertentu. Python menutupi banyak kerumitan itu melalui penanganan string yang high-level. Tapi, tetap penting bagi kita untuk tahu apa yang terjadi di balik layar, terutama jika berurusan dengan bahasa yang karakternya bisa membutuhkan beberapa byte dalam encoding (seperti bahasa Asia, simbol-simbol khusus, dan sebagainya).

Mengetahui Batasan ord()

ord() hanya menerima satu karakter sebagai argumen. Jadi, kalau kita mencoba:

ord("AB")

Kita akan dapat error. Kita butuh memanggil ord() per karakter, misalnya dengan loop. Jika kita tidak sengaja memanggil ord() pada string yang berisi lebih dari satu karakter, Python akan menegur kita dengan TypeError.

Selain itu, jika kita memasukkan string kosong, misalnya ord(""), itu juga akan error karena memang tidak ada karakter di sana.

Studi Kasus: Analisis Frekuensi Karakter

Sebagai contoh penerapan yang sedikit lebih luas, kita bisa menggunakan ord() untuk menganalisis frekuensi kemunculan setiap karakter dalam suatu teks. Ide sederhananya adalah kita membaca string, lalu kita petakan setiap code point (atau langsung tiap karakter) ke dalam sebuah penghitungan frekuensi.

def character_frequency(text):
    freq = {}
    for ch in text:
        freq[ch] = freq.get(ch, 0) + 1
    return freq

sample_text = "Hello, World!"
result = character_frequency(sample_text)
for ch, count in result.items():
    print(repr(ch), "=", count)

Sebenarnya, kita tidak mutlak butuh ord() untuk implementasi ini, karena kita bisa langsung menyimpan karakter sebagai kunci. Namun, kalau kita ingin menyimpan integer code point-nya saja, kita bisa memodifikasi kodenya sedikit:

def character_frequency_by_ord(text):
    freq = {}
    for ch in text:
        cp = ord(ch)
        freq[cp] = freq.get(cp, 0) + 1
    return freq

sample_text = "Hello, World!"
result_ord = character_frequency_by_ord(sample_text)
for cp, count in result_ord.items():
    print(cp, "=", chr(cp), "=", count)

Cara kedua ini memungkinkan kita bekerja murni dengan angka, yang kadang berguna jika kita ingin membandingkan kode-kode tertentu atau melakukan manipulasi lanjut.

Memadukan ord() dengan List Comprehension

Kita tahu bahwa Python memiliki list comprehension yang cukup canggih untuk manipulasi data secara ringkas. Kita bisa memanfaatkan ord() di dalam list comprehension untuk, misalnya, mengubah sebuah string menjadi daftar kode ordinalnya. Contoh:

text = "Python"
ordinal_list = [ord(ch) for ch in text]
print(ordinal_list)  # [80, 121, 116, 104, 111, 110]

Sekarang kita punya ordinal_list yang berisi [80, 121, 116, 104, 111, 110]. Jika ingin kembali menjadi string, kita tinggal gunakan chr():

original_text = ''.join(chr(num) for num in ordinal_list)
print(original_text)  # Python

Teknik ini cukup sering digunakan misalnya untuk keperluan encoding custom, enkripsi ringan, atau sekadar analisis struktur string.

Menangani Teks Berukuran Besar

Jika kita berurusan dengan teks raksasa (misalnya ribuan karakter) dan kita perlu melakukan konversi ord() di setiap karakter, kita harus mempertimbangkan efisiensi. Biasanya, memanggil ord() berulang kali bukan masalah berarti karena ord() cukup cepat. Namun, jika kita memiliki operasi yang lebih kompleks setelah ord(), kita perlu memastikan algoritma kita efisien, mungkin dengan memanfaatkan list comprehension atau generator expressions, dan menghindari manipulasi string yang mahal dalam loop.

Apa Perbedaan ASCII dan Unicode?

Sedikit latar belakang: ASCII (American Standard Code for Information Interchange) adalah sistem pengkodean karakter yang lebih tua dan terbatas. Hanya mendukung karakter dari 0 sampai 127 (total 128 karakter), meliputi huruf A-Z, a-z, angka 0-9, beberapa simbol, dan karakter kontrol.

Sedangkan Unicode adalah standar yang lebih modern dan luas, yang dimaksudkan untuk mencakup seluruh karakter dari hampir semua sistem penulisan di dunia. Dalam Unicode, karakter bisa memiliki kode bernilai jauh lebih besar daripada 127. Python 3 menggunakan Unicode secara native untuk string, sehingga ord() di Python akan mencerminkan code point Unicode, bukan hanya kode ASCII.

Meski begitu, untuk karakter-karakter dasar (A-Z, a-z, 0-9, dll.) kodenya tetap sama dengan ASCII, sehingga ord('A') adalah 65, ord('a') adalah 97, dan seterusnya.

Kapan Kita Tidak Perlu ord()?

Tidak selalu kita memerlukan ord(). Banyak operasi string di Python bisa kita lakukan tanpa perlu mengonversi karakter ke ord(). Contohnya:

• Mengecek apakah karakter adalah digit? Kita bisa gunakan ch.isdigit().
• Mengecek apakah karakter adalah huruf kapital? Kita bisa gunakan ch.isupper().
• Mengubah huruf kapital menjadi huruf kecil? Kita bisa gunakan ch.lower().

Fungsi-fungsi str bawaan ini seringkali lebih mudah digunakan dan lebih "pythonik." Namun, ord() tetap menjadi solusi saat kita benar-benar perlu nilai integer dari sebuah karakter untuk melakukan manipulasi atau analisis yang tidak bisa dilakukan dengan fungsi-fungsi bawaan tersebut.

Ringkasan Penggunaan ord()

Untuk merangkum semua pembahasan di atas, berikut ini ringkasan poin penting seputar ord():

1. Fungsi Dasar: ord(c) mengonversi karakter c (harus tunggal) menjadi nilai integer yang mewakili code point Unicode.
2. Pembanding Karakter: Dapat digunakan untuk membandingkan karakter atau mengurutkan mereka berdasarkan nilai numeriknya.
3. Non-ASCII: ord() di Python 3 mendukung karakter Unicode secara penuh, sehingga kita bisa mendapatkan nilai code point untuk karakter internasional, emoji, dan simbol-simbol lain.
4. Konversi Balik: chr() adalah kebalikan dari ord(), mengubah integer menjadi karakter Unicode.
5. Penerapan: Cocok untuk enkripsi, validasi input, analisis string, dan manipulasi teks yang memerlukan pemetaan karakter ke nilai numerik.
6. Pentingnya Pemahaman: Meskipun banyak hal bisa kita selesaikan dengan fungsi built-in lain (.isalpha(), .isdigit(), .lower(), dsb.), mengerti cara kerja ord() memberi kita kemampuan kontrol yang lebih rendah (low-level) atas data teks.

Catatan Penting

Pada dasarnya, ord() mungkin terlihat sederhana, tetapi fungsinya sangat mendasar dan esensial dalam pemrograman Python yang berurusan dengan teks maupun karakter. Dengan ord(), kita dapat memahami bahwa setiap karakter yang kita lihat di layar memiliki representasi numerik yang unik. Konsep ini menjembatani antara dunia manusia—yang memahami teks dan simbol—dan dunia komputer—yang pada akhirnya semuanya bermuara pada angka.

Berbekal pemahaman ini, kita bisa melakukan banyak hal: mulai dari enkripsi sederhana dengan Caesar Cipher, memvalidasi input dengan rentang ASCII/Unicode tertentu, hingga menganalisis file biner dan karakter-karakter unik. Ingatlah bahwa ord() hanya bekerja pada satu karakter, dan jika kita memiliki string yang lebih panjang, kita perlu melakukan loop atau teknik lain untuk memprosesnya karakter per karakter.

Terakhir, jangan lupakan pasangan setianya, chr(), yang berguna untuk mengonversi angka (code point) kembali menjadi karakter. Keduanya sangat membantu dalam banyak skenario, terutama yang memerlukan pemahaman mendalam tentang bagaimana data teks direpresentasikan secara internal.

Baca Juga :

• int()
• bytearray()
• bytes()