3. Variabel dan Tipe Data Dasar

Di Bab 2, kamu sudah belajar cara menulis program sederhana yang mencetak teks, menerima input, dan melakukan operasi dasar. Namun, program-program itu punya keterbatasan besar: program tersebut tidak bisa menyimpan informasi untuk digunakan nanti atau bekerja dengan berbagai jenis data dengan cara yang lebih canggih. Di bab ini, kamu akan belajar bagaimana Python menyimpan dan mengelola informasi menggunakan variabel dan tipe data (data types).

Anggap variabel seperti kotak berlabel yang menyimpan informasi. Sama seperti kamu mungkin memakai kotak berlabel untuk mengorganisasi barang di rumah, Python memakai variabel untuk mengorganisasi dan mengelola data di program kamu. Namun tidak semua data itu sama—angka secara fundamental berbeda dengan teks, dan Python perlu tahu jenis data apa yang sedang ia kerjakan. Di sinilah tipe data berperan.

Di akhir bab ini, kamu akan memahami:

• Cara membuat dan memberi nama variabel dengan benar
• Apa itu tipe data dan mengapa itu penting
• Cara bekerja dengan angka, teks, dan nilai logika
• Cara mengonversi antar berbagai tipe data
• Bagaimana Python merepresentasikan data secara internal

Konsep-konsep ini adalah fondasi untuk semua hal lain yang akan kamu lakukan di Python, jadi kita akan membahasnya secara menyeluruh dengan banyak contoh praktis.

3.1) Penamaan dan Pembuatan Variabel

3.1.1) Apa Itu Variabel dan Mengapa Penting

Variabel adalah nama yang merujuk pada sebuah nilai yang disimpan di memori komputer kamu. Saat kamu membuat variabel, kamu pada dasarnya membuat label yang menunjuk ke sepotong data. Ini memungkinkan kamu untuk:

1. Menyimpan informasi untuk digunakan nanti di program kamu
2. Mereferensikan nilai yang sama berkali-kali tanpa mengetik ulang
3. Memperbarui nilai saat program berjalan
4. Membuat kode mudah dibaca dengan memakai nama yang bermakna, bukan nilai mentah

Mari lihat contoh konkret. Tanpa variabel, jika kamu ingin menghitung luas persegi panjang, kamu mungkin menulis:

# without_variables.py
print("Rectangle area:", 15 * 8)

Ini berfungsi, tetapi bagaimana kalau kamu perlu memakai dimensi ini berkali-kali? Dan 15 dan 8 itu merepresentasikan apa? Dengan variabel, kode menjadi lebih jelas dan fleksibel:

# with_variables.py
length = 15
width = 8
area = length * width
print("Rectangle area:", area)  # Output: Rectangle area: 120

Sekarang kodenya terdokumentasi sendiri—siapa pun yang membacanya bisa langsung paham bahwa kita menghitung luas persegi panjang dengan dimensi tertentu. Jika kita perlu mengubah dimensinya, kita hanya mengubah penugasan variabel di bagian atas.

3.1.2) Membuat Variabel dengan Assignment

Di Python, kamu membuat variabel dengan menggunakan operator assignment (=). Sintaks dasarnya:

variable_name = value

Tanda = bukan berarti "sama dengan" dalam arti matematika. Sebaliknya, ini berarti "berikan nilai di sebelah kanan ke nama di sebelah kiri." Ini perbedaan yang sangat penting. Saat Python melihat pernyataan ini, ia akan:

1. Mengevaluasi ekspresi di sisi kanan =
2. Membuat atau memperbarui nama variabel di sisi kiri
3. Membuat nama itu merujuk ke nilai hasil evaluasi tersebut

Berikut beberapa contoh pembuatan variabel:

# creating_variables.py
age = 25
temperature = 72.5
name = "Alice"
is_student = True
 
print(age)          # Output: 25
print(temperature)  # Output: 72.5
print(name)         # Output: Alice
print(is_student)   # Output: True

Perhatikan bahwa kita tidak perlu mendeklarasikan tipe data apa yang akan dipegang setiap variabel—Python menentukannya secara otomatis berdasarkan nilai yang kamu berikan. Ini disebut dynamic typing, dan membuat Python sangat fleksibel dan mudah digunakan.

Kamu juga bisa membuat beberapa variabel dalam satu baris menggunakan multiple assignment:

# multiple_assignment.py
x, y, z = 10, 20, 30
print(x)  # Output: 10
print(y)  # Output: 20
print(z)  # Output: 30
 
# You can even assign the same value to multiple variables
a = b = c = 100
print(a, b, c)  # Output: 100 100 100

Bentuk pertama (disebut tuple unpacking—kita akan mempelajari tuple di Bab 14) memberikan setiap nilai ke variabel yang sesuai secara berurutan. Bentuk kedua memberikan nilai yang sama ke ketiga variabel.

3.1.3) Aturan dan Konvensi Penamaan Variabel

Python memiliki aturan khusus tentang apa yang membuat nama variabel menjadi valid. Beberapa di antaranya adalah syarat (wajib diikuti), sementara yang lain adalah konvensi (pedoman agar kode lebih mudah dibaca dan konsisten dengan kode Python lain).

Syarat (Wajib Diikuti):

1. Harus diawali dengan huruf (a-z, A-Z) atau underscore (_): Nama variabel tidak boleh diawali dengan angka.
2. Boleh berisi huruf, angka, dan underscore: Setelah karakter pertama, kamu bisa memakai huruf, angka, dan underscore dalam kombinasi apa pun.
3. Tidak boleh mengandung spasi atau karakter khusus: Spasi, tanda minus, dan kebanyakan tanda baca tidak diizinkan.
4. Tidak boleh berupa keyword Python: Python memakai kata-kata tertentu untuk dirinya sendiri (seperti if, for, while, def, dll.).
5. Case-sensitive: age, Age, dan AGE adalah tiga variabel yang berbeda.

Berikut contoh nama variabel yang valid dan tidak valid:

# valid_names.py
# Valid variable names
user_age = 30
firstName = "John"
total_2024 = 1000
_private = "hidden"
x = 5
MAX_SIZE = 100
 
# Invalid variable names (these will cause errors)
# 2nd_place = "silver"      # Error: starts with digit
# user-name = "alice"       # Error: contains hyphen
# total amount = 500        # Error: contains space
# class = "Python 101"      # Error: 'class' is a keyword

Konvensi (Sebaiknya Diikuti untuk Keterbacaan):

1. Gunakan huruf kecil dengan underscore untuk variabel biasa: Gaya ini disebut snake_case dan merupakan standar di Python.

   python

   user_age = 25
   total_price = 99.99
   is_valid = True

2. Gunakan HURUF BESAR untuk konstanta: Nilai yang seharusnya tidak berubah selama program berjalan.

   python

   MAX_ATTEMPTS = 3
   PI = 3.14159
   DEFAULT_COLOR = "blue"

3. Gunakan nama yang deskriptif: Nama variabel sebaiknya jelas menunjukkan apa yang diwakilinya.

   python

   # Good: clear and descriptive
   student_count = 30
   average_temperature = 72.5
    
   # Poor: unclear abbreviations
   sc = 30
   avg_tmp = 72.5
    
   # Poor: too generic
   x = 30
   data = 72.5

4. Hindari nama satu huruf kecuali untuk kasus tertentu: Huruf tunggal seperti i, j, k bisa diterima untuk counter pada loop (yang akan kita pelajari di Bab 11), dan x, y, z boleh dipakai untuk koordinat. Selain itu, gunakan nama yang deskriptif.

5. Jangan gunakan nama yang menimpa fungsi bawaan (built-in): Walaupun Python mengizinkan, hindari nama seperti list, str, int, print, dll., karena itu adalah nama fungsi bawaan.

Mari lihat contoh praktis yang menunjukkan praktik penamaan yang baik:

# good_naming.py
# Constants at the top
SALES_TAX_RATE = 0.08
DISCOUNT_THRESHOLD = 100
 
# Descriptive variable names
item_price = 75.00
quantity = 3
subtotal = item_price * quantity
 
# Clear boolean variable
qualifies_for_discount = subtotal >= DISCOUNT_THRESHOLD
 
if qualifies_for_discount:
    discount = subtotal * 0.10
    subtotal = subtotal - discount
    print("Discount applied: $", discount)
 
tax = subtotal * SALES_TAX_RATE
total = subtotal + tax
 
print("Subtotal: $", subtotal)
print("Tax: $", tax)
print("Total: $", total)
# Output:
# Subtotal: $ 202.5
# Tax: $ 16.2
# Total: $ 218.7

Perhatikan bagaimana nama variabel membuat kode ini terdokumentasi sendiri. Bahkan tanpa komentar, kamu bisa memahami apa yang dihitung program.

3.1.4) Menggunakan Variabel dalam Ekspresi

Setelah kamu membuat variabel, kamu bisa menggunakannya di mana pun kamu akan memakai nilai yang diwakilinya. Python akan otomatis mengganti dengan nilai saat ini dari variabel itu ketika mengevaluasi ekspresi:

# using_variables.py
# Create some variables
hours_worked = 40
hourly_rate = 25.50
 
# Use variables in calculations
gross_pay = hours_worked * hourly_rate
print("Gross pay:", gross_pay)  # Output: Gross pay: 1020.0
 
# Use variables in other expressions
bonus = gross_pay * 0.10
total_pay = gross_pay + bonus
print("Total with bonus:", total_pay)  # Output: Total with bonus: 1122.0
 
# Use variables in strings (we'll learn more about this in Chapter 5)
message = "You worked " + str(hours_worked) + " hours"
print(message)  # Output: You worked 40 hours

Variabel juga bisa digunakan dengan fungsi-fungsi yang sudah kamu pelajari di Bab 2:

# variables_with_functions.py
name = input("What is your name? ")
age = input("What is your age? ")
 
greeting = "Hello, " + name + "!"
print(greeting)
 
age_next_year = int(age) + 1
print("Next year you will be", age_next_year, "years old.")
# If user enters "Alice" and "25":
# Output: Hello, Alice!
# Output: Next year you will be 26 years old.

Contoh ini juga menunjukkan konsep penting: fungsi input() selalu mengembalikan teks (sebuah string), jadi jika kamu ingin melakukan operasi matematika dengannya, kamu perlu mengonversinya ke angka terlebih dahulu. Kita akan membahas proses konversi ini secara rinci nanti di bab ini (Bagian 3.7).

3.2) Assignment dan Reassignment Variabel

3.2.1) Memahami Assignment

Saat kamu memberikan nilai ke variabel, Python membuat koneksi antara nama variabel dan nilai di memori. Penting untuk dipahami bahwa variabel tidak "mengandung" nilai secara fisik—melainkan, itu adalah nama yang merujuk ke atau menunjuk ke nilai yang disimpan di tempat lain di memori.

Bayangkan seperti sebuah catatan tempel dengan nama tertulis di atasnya, ditempelkan ke sebuah kotak yang berisi nilai sebenarnya. Variabel (catatan tempel) bukan nilai itu sendiri—ia hanya menunjukkan di mana nilai itu disimpan. Saat kamu melakukan reassignment, kamu memindahkan catatan tempel untuk menunjuk ke kotak lain, bukan mengubah isi kotak asli.

Pembedaan ini menjadi penting saat kita membicarakan reassignment. Mari kita lihat apa yang terjadi ketika kamu melakukan assignment dan reassignment variabel:

# assignment_basics.py
x = 10
print(x)  # Output: 10
 
# Reassign x to a new value
x = 20
print(x)  # Output: 20
 
# The old value (10) is gone; x now refers to 20

Berikut yang terjadi langkah demi langkah:

1. x = 10: Python membuat nilai integer 10 di memori dan membuat nama x merujuk ke sana
2. print(x): Python mencari apa yang dirujuk x (10) dan mencetaknya
3. x = 20: Python membuat nilai integer 20 di memori dan membuat x merujuk ke nilai baru ini
4. print(x): Python mencari apa yang sekarang dirujuk x (20) dan mencetaknya

Nilai asli 10 masih ada sementara di memori, tetapi karena tidak ada variabel yang lagi merujuk ke sana, manajemen memori otomatis Python (disebut garbage collection) pada akhirnya akan membersihkannya.

3.2.2) Reassignment dan Memperbarui Variabel

Salah satu pola paling umum dalam pemrograman adalah memperbarui variabel berdasarkan nilai saat ini. Misalnya, kamu mungkin ingin menambah counter, menambah total berjalan, atau memodifikasi nilai berdasarkan perhitungan:

# updating_variables.py
score = 0
print("Initial score:", score)  # Output: Initial score: 0
 
# Add 10 points
score = score + 10
print("After first update:", score)  # Output: After first update: 10
 
# Add 5 more points
score = score + 5
print("After second update:", score)  # Output: After second update: 15
 
# Double the score
score = score * 2
print("After doubling:", score)  # Output: After doubling: 30

Mari kita uraikan apa yang terjadi pada score = score + 10:

1. Python mengevaluasi sisi kanan: score + 10
2. Ia mencari nilai saat ini dari score (0)
3. Ia menghitung 0 + 10, menghasilkan 10
4. Ia memberikan nilai baru ini (10) ke score
5. Sekarang score merujuk ke 10, bukan 0

Pola ini begitu umum sehingga Python menyediakan operator singkat untuk itu, yang akan kita pelajari di Bab 4 (Bagian 4.3). Namun untuk saat ini, penting untuk memahami bentuk lengkapnya karena bentuk itu dengan jelas menunjukkan urutan operasi: sisi kanan dievaluasi sepenuhnya, lalu hasilnya diberikan ke sisi kiri.

3.2.3) Variabel Itu Independen

Saat kamu memberikan satu variabel ke variabel lain, Python menyalin referensi, bukan menyalin nilai itu sendiri (untuk tipe sederhana seperti angka dan string). Namun, untuk tipe-tipe dasar yang kita pelajari di bab ini, variabel berperilaku independen setelah assignment:

# independent_variables.py
a = 10
b = a  # b now refers to the same value as a (10)
print("a:", a)  # Output: a: 10
print("b:", b)  # Output: b: 10
 
# Change a
a = 20
print("After changing a:")
print("a:", a)  # Output: a: 20
print("b:", b)  # Output: b: 10 (unchanged!)

Saat kita menulis b = a, kita membuat b merujuk ke nilai yang sama yang sedang dirujuk a saat itu (10). Ketika kemudian kita mengubah a untuk merujuk ke 20, b tidak terpengaruh—ia masih merujuk ke 10.

Perilaku ini lurus untuk angka dan string, tetapi menjadi lebih kompleks dengan koleksi seperti list dan dictionary. Kita akan membahas ini dengan tuntas di Bab 17 ketika membahas model objek Python dan semantik referensi.

3.2.4) Menggunakan Variabel sebelum Assignment

Salah satu kesalahan umum pemula adalah mencoba menggunakan variabel sebelum variabel itu diberi nilai. Python akan menimbulkan NameError jika kamu melakukan ini:

# undefined_variable.py
print(total)  # Error: NameError: name 'total' is not defined

Error ini muncul karena Python tidak tahu total merujuk ke apa—kamu belum membuatnya. Perbaikannya sederhana: berikan nilai ke variabel sebelum digunakan:

# defined_variable.py
total = 0  # Initialize the variable first
print(total)  # Output: 0
 
# Now we can update it
total = total + 10
print(total)  # Output: 10

Pola inisialisasi variabel (memberinya nilai awal) sebelum digunakan adalah hal mendasar dalam pemrograman. Kita akan sering menemukannya di sepanjang buku ini, terutama saat bekerja dengan counter dan accumulator di dalam loop (Bab 10).

3.2.5) Menukar Nilai Variabel

Operasi yang umum adalah menukar nilai dua variabel. Di banyak bahasa pemrograman, ini butuh variabel sementara:

# swap_with_temp.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap using a temporary variable
temp = x    # Save x's value
x = y       # Put y's value in x
y = temp    # Put saved value in y
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Namun, Python menyediakan cara yang lebih elegan dengan simultaneous assignment:

# swap_pythonic.py
x = 10
y = 20
print("Before swap: x =", x, ", y =", y)  # Output: Before swap: x = 10 , y = 20
 
# Swap in one line
x, y = y, x
 
print("After swap: x =", x, ", y =", y)  # Output: After swap: x = 20 , y = 10

Ini bekerja karena Python mengevaluasi seluruh sisi kanan (y, x) sebelum melakukan assignment apa pun. Jadi ia membuat struktur sementara yang berisi nilai y dan x, lalu membongkar (unpack) nilai-nilai itu ke x dan y masing-masing. Ini contoh bagus dari filosofi Python untuk membuat operasi umum menjadi sederhana dan mudah dibaca.

3.3) Konsep Tipe Data (Data Types) dan type()

3.3.1) Apa Itu Tipe Data?

Tipe data (atau cukup type) menentukan jenis data apa yang direpresentasikan oleh sebuah nilai dan operasi apa yang dapat dilakukan terhadapnya. Anggap tipe data sebagai kategori yang memberi tahu Python bagaimana menafsirkan dan bekerja dengan berbagai jenis informasi.

Misalnya:

• Angka 42 adalah integer (bilangan bulat)
• Angka 3.14 adalah floating-point number (bilangan dengan titik desimal)
• Teks "Hello" adalah string (urutan karakter)
• Nilai True adalah boolean (nilai logika benar/salah)

Mengapa tipe data penting? Karena tipe yang berbeda mendukung operasi yang berbeda:

# type_operations.py
# You can add numbers
result1 = 10 + 5
print(result1)  # Output: 15
 
# You can also "add" strings (concatenation)
result2 = "Hello" + " " + "World"
print(result2)  # Output: Hello World
 
# But you can't add a number and a string directly
# result3 = 10 + "5"  # Error: TypeError: unsupported operand type(s)

Error pada contoh terakhir terjadi karena Python tidak tahu bagaimana menambahkan angka dan string—mereka adalah dua tipe data yang secara fundamental berbeda. Haruskah Python mengonversi angka menjadi teks lalu menggabungkannya? Atau mengonversi teks ke angka lalu menjumlahkannya? Python mengharuskan kamu secara eksplisit menyatakan yang kamu inginkan dengan mengonversi salah satu nilai agar tipenya sama dengan yang lain (kita akan mempelajari caranya di Bagian 3.7).

3.3.2) Menggunakan type() untuk Mengecek Tipe Data

Python menyediakan fungsi bawaan type() yang memberi tahu kamu tipe dari sebuah nilai atau variabel. Ini sangat berguna untuk memahami data dan melakukan debugging:

# checking_types.py
# Check types of literal values
print(type(42))        # Output: <class 'int'>
print(type(3.14))      # Output: <class 'float'>
print(type("Hello"))   # Output: <class 'str'>
print(type(True))      # Output: <class 'bool'>
 
# Check types of variables
age = 25
name = "Alice"
temperature = 98.6
is_valid = False
 
print(type(age))         # Output: <class 'int'>
print(type(name))        # Output: <class 'str'>
print(type(temperature)) # Output: <class 'float'>
print(type(is_valid))    # Output: <class 'bool'>

Output <class 'int'> berarti "nilai ini milik kelas (tipe) bernama int." Di Python, tipe sebenarnya adalah kelas (kita akan mempelajari kelas secara detail di Bagian VIII), tapi untuk sekarang, kamu bisa menganggap kedua istilah ini bisa dipertukarkan.

3.3.3) Dynamic Typing di Python

Python adalah bahasa dengan dynamic typing, yang berarti:

1. Variabel tidak punya tipe tetap: Satu variabel bisa merujuk ke nilai dengan tipe berbeda di waktu yang berbeda
2. Tipe ditentukan saat runtime: Python menentukan tipe ketika program dijalankan, bukan saat kamu menulis kode
3. Kamu tidak mendeklarasikan tipe secara eksplisit: Berbeda dengan beberapa bahasa lain, kamu tidak perlu berkata "variabel ini akan menyimpan integer"

Berikut contoh dynamic typing secara nyata:

# dynamic_typing.py
x = 42
print(x, "is of type", type(x))  # Output: 42 is of type <class 'int'>
 
x = "Hello"
print(x, "is of type", type(x))  # Output: Hello is of type <class 'str'>
 
x = 3.14
print(x, "is of type", type(x))  # Output: 3.14 is of type <class 'float'>

Perhatikan bagaimana x dapat merujuk ke nilai dengan tipe berbeda di titik berbeda dalam program. Python tidak protes—ia hanya memperbarui tipe apa yang sedang dirujuk x.

Walaupun fleksibilitas ini nyaman, ini juga berarti kamu harus berhati-hati. Jika kamu mengira sebuah variabel menyimpan angka padahal sebenarnya menyimpan string, kamu bisa mendapatkan error yang tidak kamu duga:

# type_confusion.py
value = "100"  # This is a string, not a number!
 
# Trying to do math with it will fail
# result = value + 50  # Error: TypeError: can only concatenate str to str
 
# You need to convert it first
result = int(value) + 50
print(result)  # Output: 150

Inilah mengapa memahami tipe data itu krusial—membantu kamu memprediksi operasi apa yang akan berhasil dan menangkap kesalahan sebelum menyebabkan error.

3.3.4) Sekilas Tipe Bawaan Python

Python memiliki beberapa tipe data bawaan. Di bab ini, kita akan fokus pada yang paling mendasar:

Di bab ini, kita akan membahas:

• int: Bilangan bulat (integer)
• float: Bilangan floating-point (bilangan dengan titik desimal)
• str: String (teks)
• bool: Nilai boolean (True dan False)
• NoneType: Nilai spesial None

Kita akan menyebut sekilas bilangan complex (bilangan dengan komponen imajiner), tapi itu jarang dibutuhkan dalam pemrograman sehari-hari. Tipe koleksi (seperti list, tuple, dictionary, dan set) sangat penting sehingga kita menyediakan bab-bab khusus untuk mereka di Bagian IV.

3.3.5) Pengecekan Tipe dalam Praktik

Memahami tipe menjadi sangat penting saat bekerja dengan input pengguna atau data dari sumber eksternal. Ingat bahwa input() selalu mengembalikan string, bahkan jika pengguna mengetik angka:

# input_types.py
user_input = input("Enter a number: ")
print("You entered:", user_input)
print("Type:", type(user_input))  # Output: Type: <class 'str'>
 
# Even if user types "42", it's still a string!
# To use it as a number, convert it:
number = int(user_input)
print("As a number:", number)
print("Type:", type(number))  # Output: Type: <class 'int'>
 
# Now we can do math with it
doubled = number * 2
print("Doubled:", doubled)

Saat kamu menjalankan program ini dan memasukkan 42, kamu akan melihat:

Enter a number: 42
You entered: 42
Type: <class 'str'>
As a number: 42
Type: <class 'int'>
Doubled: 84

Ini menunjukkan poin penting: string "42" dan integer 42 adalah dua hal yang berbeda di Python, meskipun tampak mirip saat dicetak. String adalah urutan dua karakter ('4' dan '2'), sementara integer adalah nilai numerik yang bisa dipakai dalam operasi matematika.

3.4) Bilangan Integer dan Floating-Point

3.4.1) Integer (int)

Integer (tipe int) adalah bilangan bulat tanpa titik desimal. Integer bisa positif, negatif, atau nol, dan di Python 3, ukurannya bisa sangat besar—hanya dibatasi oleh memori komputer kamu.

# integers.py
# Positive integers
age = 25
year = 2024
population = 8000000000
 
# Negative integers
temperature = -15
debt = -5000
 
# Zero
balance = 0
 
# Very large integers (Python handles these easily)
huge_number = 123456789012345678901234567890
print(huge_number)  # Output: 123456789012345678901234567890
print(type(huge_number))  # Output: <class 'int'>

Python mengizinkan kamu menulis angka besar dengan underscore untuk keterbacaan. Underscore diabaikan oleh Python tetapi membuat angka lebih mudah dibaca manusia:

# readable_numbers.py
# These are all the same number
million = 1000000
million = 1_000_000  # Much easier to read!
 
# Works with any size
population = 8_000_000_000
national_debt = 31_000_000_000_000
 
print(million)      # Output: 1000000 (underscores not shown in output)
print(population)   # Output: 8000000000

Kamu juga bisa menulis integer dalam basis bilangan berbeda dengan awalan khusus:

# number_bases.py
# Binary (base 2) - prefix 0b
binary = 0b1010  # This is 10 in decimal
print(binary)  # Output: 10
 
# Octal (base 8) - prefix 0o
octal = 0o12  # This is 10 in decimal
print(octal)  # Output: 10
 
# Hexadecimal (base 16) - prefix 0x
hexadecimal = 0xFF  # This is 255 in decimal
print(hexadecimal)  # Output: 255

Basis alternatif ini berguna di konteks tertentu (seperti bekerja dengan warna di web design atau pemrograman tingkat rendah), tetapi untuk pemrograman sehari-hari, kamu biasanya memakai integer desimal biasa.

3.4.2) Bilangan Floating-Point (float)

Floating-point number (tipe float) adalah angka dengan titik desimal. Float digunakan untuk merepresentasikan bilangan real—nilai yang tidak harus bulat:

# floats.py
# Numbers with decimal points
price = 19.99
temperature = 98.6
pi = 3.14159
 
# Very small numbers
electron_mass = 0.00000000000000000000000000000091093837
 
# Very large numbers
speed_of_light = 299792458.0
 
print(price)           # Output: 19.99
print(temperature)     # Output: 98.6
print(electron_mass)   # Output: 9.1093837e-31 (scientific notation)
print(speed_of_light)  # Output: 299792458.0

Perhatikan bahwa float yang sangat kecil atau sangat besar ditampilkan dalam scientific notation (notasi ilmiah atau eksponensial). Notasi 9.1093837e-31 berarti "9.1093837 × 10⁻³¹" atau "9.1093837 dibagi 10 pangkat 31".

Kamu juga bisa menulis float dengan scientific notation secara langsung:

# scientific_notation.py
# These are equivalent
avogadro = 602214076000000000000000.0
avogadro = 6.02214076e23  # Much more readable!
 
# Small numbers
planck = 0.000000000000000000000000000000000662607015
planck = 6.62607015e-34  # Much more readable!
 
print(avogadro)  # Output: 6.02214076e+23
print(planck)    # Output: 6.62607015e-34

Huruf e (atau E) berarti "eksponen." Angka setelah e memberi tahu berapa banyak posisi desimal harus digeser (positif berarti ke kanan, negatif berarti ke kiri).

3.4.3) Integer vs Float: Perbedaan Penting

Walaupun integer dan float sama-sama merepresentasikan angka, ada perbedaan penting:

1. Presisi dan Representasi:

Integer bersifat eksak—nilai 42 persis 42, tanpa aproksimasi. Float, sebaliknya, adalah aproksimasi karena cara komputer menyimpan bilangan desimal dalam biner:

# float_precision.py
# This might surprise you!
result = 0.1 + 0.2
print(result)  # Output: 0.30000000000000004
 
# The result isn't exactly 0.3 due to floating-point representation
print(result == 0.3)  # Output: False

Ini bukan bug—ini adalah keterbatasan fundamental dari representasi bilangan desimal di komputer. Kita akan membahas ini lebih detail di Bab 4 (Bagian 4.10), tapi untuk sekarang, cukup sadar bahwa perhitungan float mungkin tidak sepenuhnya presisi.

2. Operasi dan Hasil:

Saat kamu melakukan operasi dengan integer dan float, Python mengikuti aturan khusus:

# int_float_operations.py
# Integer operations
int_result = 10 + 5
print(int_result, type(int_result))  # Output: 15 <class 'int'>
 
# Float operations
float_result = 10.0 + 5.0
print(float_result, type(float_result))  # Output: 15.0 <class 'float'>
 
# Mixed operations: result is always float
mixed_result = 10 + 5.0
print(mixed_result, type(mixed_result))  # Output: 15.0 <class 'float'>
 
# Division always returns float, even with integers
division_result = 10 / 5
print(division_result, type(division_result))  # Output: 2.0 <class 'float'>

Aturan kunci: setiap operasi yang melibatkan setidaknya satu float akan menghasilkan float. Ini masuk akal karena float bisa merepresentasikan rentang nilai yang lebih luas (termasuk bilangan tidak bulat), jadi Python "mempromosikan" hasilnya ke tipe yang lebih umum.

3. Memori dan Performa:

Integer menggunakan lebih sedikit memori dan lebih cepat dihitung dibanding float. Untuk kebanyakan program, perbedaan ini tidak terasa, tapi bisa penting di aplikasi yang sangat sensitif performa atau saat berurusan dengan dataset yang sangat besar.

3.4.4) Kapan Menggunakan int vs float

Berikut panduan praktis memilih antara integer dan float:

Gunakan integer ketika:

• Menghitung objek diskrit (orang, benda, iterasi)
• Merepresentasikan kuantitas eksak yang tidak bisa pecahan (jumlah murid, jumlah klik)
• Bekerja dengan indeks atau posisi dalam urutan
• Membutuhkan aritmetika yang tepat

# use_integers.py
student_count = 30  # Can't have 30.5 students
page_number = 42    # Can't be on page 42.7
loop_counter = 0    # Counting iterations

Gunakan float ketika:

• Merepresentasikan pengukuran (suhu, jarak, berat)
• Bekerja dengan uang (meski harus hati-hati dengan presisi—akan dibahas di Bab 4)
• Menghitung rasio, persentase, atau rata-rata
• Nilai perkiraan dapat diterima

# use_floats.py
temperature = 72.5     # Temperature can be fractional
price = 19.99          # Money amounts have cents
average_score = 87.3   # Averages are often fractional
percentage = 0.15      # 15% as a decimal

3.5) Literal String dan Boolean (Sekilas)

Di bagian ini, kita akan mengenalkan dua tipe data fundamental lain: string dan boolean. Kita akan membahas string jauh lebih dalam di Bab 5 dan 6, dan boolean secara detail di Bab 7, tetapi kamu butuh pemahaman dasar tentang keduanya sekarang untuk menulis program sederhana sekalipun.

3.5.1) Dasar-Dasar String

String (tipe str) adalah urutan karakter—pada dasarnya, teks. Kamu membuat string dengan menempatkan teks di dalam tanda kutip. Python menerima tanda kutip tunggal (') maupun ganda ("):

# string_basics.py
# Single quotes
name = 'Alice'
message = 'Hello, World!'
 
# Double quotes (exactly equivalent)
name = "Alice"
message = "Hello, World!"
 
# Print them
print(name)     # Output: Alice
print(message)  # Output: Hello, World!
print(type(name))  # Output: <class 'str'>

Tanda kutip tunggal dan ganda bekerja sama persis—pilih saja yang kamu suka, tapi konsistenlah di dalam kode. Banyak programmer Python lebih suka tanda kutip ganda karena lebih umum di bahasa pemrograman lain, tapi tanda kutip tunggal sama validnya.

Mengapa ada keduanya? Alasan utamanya adalah kemudahan saat string kamu berisi tanda kutip:

# quotes_in_strings.py
# Use double quotes when string contains single quotes
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# Use single quotes when string contains double quotes
speech = 'She said, "Hello!"'
print(speech)  # Output: She said, "Hello!"
 
# Or use escape sequences (we'll learn more in Chapter 5)
sentence = 'It\'s a beautiful day!'  # \' means a literal single quote
speech = "She said, \"Hello!\""     # \" means a literal double quote

String bisa kosong (tidak mengandung karakter sama sekali):

# empty_string.py
empty = ""
also_empty = ''
 
print(empty)            # Output: (nothing—it's empty!)
print(len(empty))       # Output: 0 (we'll learn about len() later)
print(type(empty))      # Output: <class 'str'>

Kamu bisa menggabungkan string menggunakan operator + (disebut concatenation):

# string_concatenation.py
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name
print(full_name)  # Output: John Doe
 
# Be careful: you can't concatenate strings and numbers directly
age = 25
# message = "I am " + age + " years old"  # Error: TypeError
 
# Convert the number to a string first
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

Kita akan mengeksplorasi string jauh lebih lengkap di Bab 5 dan 6, termasuk escape sequence, method string, formatting, dan pemrosesan teks. Untuk sekarang, cukup ingat bahwa string merepresentasikan teks dan dibuat dengan tanda kutip.

3.5.2) Dasar-Dasar Boolean

Boolean (tipe bool) adalah nilai logika yang bisa berupa True atau False. Ini adalah dua nilai boolean satu-satunya di Python, dan digunakan untuk merepresentasikan benar dan salah dalam operasi logika:

# boolean_basics.py
# Boolean literals
is_sunny = True
is_raining = False
 
print(is_sunny)         # Output: True
print(is_raining)       # Output: False
print(type(is_sunny))   # Output: <class 'bool'>

Penting: Nilai boolean True dan False harus dikapitalisasi persis seperti itu. Python bersifat case-sensitive, jadi true, TRUE, false, dan FALSE tidak akan berfungsi:

# boolean_case.py
correct = True    # Correct
# wrong = true    # Error: NameError: name 'true' is not defined
# wrong = TRUE    # Error: NameError: name 'TRUE' is not defined

Boolean biasanya berasal dari perbandingan atau operasi logika:

# boolean_from_comparisons.py
age = 25
 
# Comparison operators produce boolean results
is_adult = age >= 18
print(is_adult)  # Output: True
 
is_senior = age >= 65
print(is_senior)  # Output: False
 
# You can use booleans in conditions (we'll learn more in Chapter 8)
if is_adult:
    print("You can vote!")  # Output: You can vote!
 
if is_senior:
    print("You get a senior discount!")  # (no output—condition is False)

Operator perbandingan umum yang menghasilkan boolean:

• == : sama dengan
• != : tidak sama dengan
• < : kurang dari
• > : lebih dari
• <= : kurang dari atau sama dengan
• >= : lebih dari atau sama dengan

# comparison_operators.py
x = 10
y = 20
 
print(x == y)   # Output: False (10 is not equal to 20)
print(x != y)   # Output: True (10 is not equal to 20)
print(x < y)    # Output: True (10 is less than 20)
print(x > y)    # Output: False (10 is not greater than 20)
print(x <= 10)  # Output: True (10 is less than or equal to 10)
print(y >= 20)  # Output: True (20 is greater than or equal to 20)

Catatan penting: Jangan bingungkan = (assignment) dengan == (perbandingan):

• x = 10 berarti "berikan nilai 10 ke x"
• x == 10 berarti "cek apakah x sama dengan 10" (menghasilkan True atau False)

# assignment_vs_comparison.py
x = 10        # Assignment: x now refers to 10
result = (x == 10)  # Comparison: is x equal to 10?
print(result)  # Output: True
 
# This is a common mistake for beginners:
# if x = 10:  # Error: SyntaxError (can't use assignment in if condition)
if x == 10:   # Correct: comparison
    print("x is 10")  # Output: x is 10

Kita akan mengeksplorasi boolean jauh lebih detail di Bab 7, termasuk operator logika (and, or, not), truthiness dan falsiness, dan bagaimana Python memakai boolean dalam kondisi. Untuk sekarang, cukup ingat bahwa boolean merepresentasikan nilai True/False dan biasanya berasal dari perbandingan.

3.5.3) String dan Boolean dalam Konteks

Mari lihat bagaimana string dan boolean bekerja bersama dalam contoh praktis sederhana:

# strings_booleans_example.py
# Get user input
name = input("What is your name? ")
age_input = input("What is your age? ")
 
# Convert age to integer
age = int(age_input)
 
# Create boolean conditions
is_adult = age >= 18
is_child = age < 13
 
# Build messages using strings
if is_adult:
    status = "adult"
else:
    status = "minor"
 
# Combine everything in output
print("Hello, " + name + "!")
print("You are an " + status + ".")
 
if is_child:
    print("You are a child.")
 
# When user enters "Alice" and "16":
# Output: Hello, Alice!
# Output: You are a minor.

Contoh ini menunjukkan bagaimana tipe data berbeda bekerja bersama: string untuk teks, integer untuk angka, dan boolean untuk keputusan logika. Interaksi antar tipe ini adalah dasar dari semua pemrograman.

3.6) Nilai None dan Kegunaannya

3.6.1) Apa Itu None?

Python memiliki nilai khusus bernama None (tipe NoneType) yang merepresentasikan ketiadaan nilai. Ini cara Python mengatakan "tidak ada apa-apa di sini" atau "ini belum punya nilai."

# none_basics.py
result = None
print(result)        # Output: None
print(type(result))  # Output: <class 'NoneType'>

None bukan nol, bukan string kosong, dan bukan False—ini nilai yang berbeda yang secara spesifik berarti "tidak ada nilai":

# none_vs_others.py
x = None
y = 0
z = ""
w = False
 
print(x)  # Output: None
print(y)  # Output: 0
print(z)  # Output: (empty—nothing prints)
print(w)  # Output: False
 
# They're all different types
print(type(x))  # Output: <class 'NoneType'>
print(type(y))  # Output: <class 'int'>
print(type(z))  # Output: <class 'str'>
print(type(w))  # Output: <class 'bool'>

3.6.2) Kapan None Digunakan

None muncul di beberapa situasi umum:

1. Sebagai placeholder untuk nilai yang akan diisi nanti:

# none_placeholder.py
# Initialize variables that will be assigned later
user_name = None
user_age = None
 
# Later in the program, after getting user input:
user_name = input("Enter your name: ")
user_age = int(input("Enter your age: "))
 
print("Name:", user_name)
print("Age:", user_age)

2. Sebagai nilai kembali (return) default fungsi yang tidak secara eksplisit mengembalikan apa pun:

Fungsi (function) yang akan kita pelajari di Bab 19 bisa mengembalikan nilai. Jika sebuah fungsi tidak secara eksplisit mengembalikan apa pun, Python otomatis mengembalikan None:

# none_from_function.py
# The print() function returns None
result = print("Hello!")  # Output: Hello!
print(result)             # Output: None
print(type(result))       # Output: <class 'NoneType'>

Ini mungkin terlihat aneh, tapi berguna. Artinya setiap fungsi mengembalikan sesuatu, bahkan jika sesuatu itu adalah "tidak ada nilai bermakna."

3. Untuk merepresentasikan data opsional atau hilang:

# none_optional.py
# Representing optional middle name
first_name = "John"
middle_name = None  # No middle name
last_name = "Doe"
 
if middle_name is None:
    full_name = first_name + " " + last_name
else:
    full_name = first_name + " " + middle_name + " " + last_name
 
print(full_name)  # Output: John Doe

3.6.3) Mengecek None

Untuk mengecek apakah sebuah nilai adalah None, gunakan operator is (bukan ==):

# checking_none.py
value = None
 
# Correct way: use 'is'
if value is None:
    print("Value is None")  # Output: Value is None
 
# Also correct: use 'is not'
if value is not None:
    print("Value has a value")
else:
    print("Value is None")  # Output: Value is None
 
# While == works, 'is' is preferred for None
if value == None:  # This works but is not idiomatic Python
    print("Value is None")  # Output: Value is None

Mengapa memakai is alih-alih ==? Operator is mengecek apakah dua nama merujuk ke objek yang persis sama di memori (kita akan mempelajari ini lebih jauh di Bab 17). Karena hanya ada satu objek None di Python, is lebih efisien dan lebih tepat untuk pengecekan ini. Menggunakan is None adalah idiom Python standar.

3.6.4) None dalam Penggunaan Praktis

Berikut contoh praktis yang menunjukkan betapa bergunanya None di program nyata:

# none_practical.py
# Simulate looking up a user's age
# (In real programs, we'd use functions and dictionaries from later chapters)
 
user_name = input("Enter a name (Alice, Bob, or Charlie): ")
 
# Check each name and assign age or None
if user_name == "Alice":
    user_age = 25
elif user_name == "Bob":
    user_age = 30
elif user_name == "Charlie":
    user_age = 35
else:
    user_age = None  # User not found
 
# Check if we found the user
if user_age is not None:
    print(user_name, "is", user_age, "years old")
else:
    print(user_name, "not found")
 
# When user enters "Alice":
# Output: Alice is 25 years old
# When user enters "David":
# Output: David not found

Di contoh ini, None jelas menunjukkan "user tidak ditemukan," yang berbeda dari menemukan user dengan umur 0 (yang merupakan umur valid untuk bayi baru lahir).

3.6.5) None vs Nilai Kosong

Penting untuk membedakan None dari nilai kosong:

# none_vs_empty.py
# These are all different
nothing = None
zero = 0
empty_string = ""
# Note: We'll learn about lists in Chapter 13
# empty_list = []
 
print(nothing is None)       # Output: True
print(zero is None)          # Output: False
print(empty_string is None)  # Output: False
 
# None means "no value"
# 0 means "the number zero"
# "" means "text with no characters"

Masing-masing merepresentasikan konsep yang berbeda:

• None: ketiadaan nilai
• 0: nilai numerik spesifik (nol)
• "": string yang ada tetapi tidak berisi karakter

Memahami perbedaan ini akan membantu kamu menulis program yang lebih jelas dan benar.

3.7) Konversi Tipe Dasar dengan int(), float(), dan str()

3.7.1) Mengapa Konversi Tipe Diperlukan

Seperti yang sudah kita lihat, Python punya aturan ketat tentang operasi apa yang bekerja dengan tipe apa. Kamu tidak bisa menambahkan angka dan string, mengalikan string dengan float, atau melakukan operasi matematika pada teks. Saat kamu perlu memakai sebuah nilai sebagai tipe lain, kamu harus mengonversinya secara eksplisit.

Konversi tipe (juga disebut type casting) adalah proses mengubah nilai dari satu tipe ke tipe lain. Python menyediakan fungsi bawaan untuk konversi paling umum:

• int(): Mengonversi ke integer
• float(): Mengonversi ke bilangan floating-point
• str(): Mengonversi ke string

Mari kita bahas masing-masing secara detail.

3.7.2) Mengonversi ke Integer dengan int()

Fungsi int() mengonversi sebuah nilai ke integer. Berikut penggunaan utamanya:

Mengonversi float ke integer:

# float_to_int.py
# int() truncates (cuts off) the decimal part
x = int(3.14)
y = int(3.99)
z = int(-2.7)
 
print(x)  # Output: 3 (not 4—it doesn't round!)
print(y)  # Output: 3 (not 4—it truncates!)
print(z)  # Output: -2 (truncates toward zero)

Penting: int() tidak melakukan pembulatan—ia hanya membuang bagian desimal (truncates toward zero). Ini sering membingungkan pemula yang mengira int(3.9) akan menghasilkan 4.

Mengonversi string ke integer:

Ini sangat umum saat bekerja dengan input pengguna:

# string_to_int.py
# Convert string containing a number
age_str = "25"
age_int = int(age_str)
 
print(age_str, type(age_str))  # Output: 25 <class 'str'>
print(age_int, type(age_int))  # Output: 25 <class 'int'>
 
# Now we can do math with it
next_year = age_int + 1
print("Next year:", next_year)  # Output: Next year: 26
 
# Practical example with input()
user_age = int(input("Enter your age: "))
print("In 10 years, you'll be", user_age + 10)

Apa yang terjadi pada konversi tidak valid?

Jika kamu mencoba mengonversi string yang tidak merepresentasikan integer valid, Python akan menimbulkan ValueError:

# invalid_int_conversion.py
# These work
print(int("123"))    # Output: 123
print(int("-456"))   # Output: -456
print(int("  789 ")) # Output: 789 (whitespace is ignored)
 
# These don't work
# print(int("12.5"))   # Error: ValueError: invalid literal for int()
# print(int("hello"))  # Error: ValueError: invalid literal for int()
# print(int("12 34"))  # Error: ValueError: invalid literal for int()

Kita akan belajar cara menangani error ini dengan baik di Bab 27 saat membahas exception handling. Untuk sekarang, cukup sadar bahwa kamu perlu memastikan string berisi representasi integer yang valid sebelum mengonversi.

Mengonversi boolean ke integer:

Boolean bisa dikonversi ke integer, di mana True menjadi 1 dan False menjadi 0:

# bool_to_int.py
print(int(True))   # Output: 1
print(int(False))  # Output: 0
 
# This is sometimes useful in calculations
is_premium = True
is_student = False
 
# Calculate discount (10% for premium, 5% for students)
discount = int(is_premium) * 0.10 + int(is_student) * 0.05
print("Discount:", discount)  # Output: Discount: 0.1

Namun, menggunakan boolean langsung dalam aritmetika umumnya tidak disarankan karena membuat kode kurang jelas. Kita akan membahas ini lebih jauh di Bab 7.

3.7.3) Mengonversi ke Float dengan float()

Fungsi float() mengonversi sebuah nilai ke bilangan floating-point:

Mengonversi integer ke float:

# int_to_float.py
x = float(42)
y = float(-17)
z = float(0)
 
print(x, type(x))  # Output: 42.0 <class 'float'>
print(y, type(y))  # Output: -17.0 <class 'float'>
print(z, type(z))  # Output: 0.0 <class 'float'>

Mengonversi string ke float:

# string_to_float.py
# Convert string containing decimal number
price_str = "19.99"
price_float = float(price_str)
 
print(price_str, type(price_str))    # Output: 19.99 <class 'str'>
print(price_float, type(price_float))  # Output: 19.99 <class 'float'>
 
# Strings without decimal points work too
x = float("42")
print(x, type(x))  # Output: 42.0 <class 'float'>
 
# Scientific notation strings work
big = float("1.5e10")
print(big)  # Output: 15000000000.0

Konversi tidak valid:

Seperti int(), float() menimbulkan ValueError untuk string yang tidak valid:

# invalid_float_conversion.py
# These work
print(float("3.14"))      # Output: 3.14
print(float("  2.5  "))   # Output: 2.5 (whitespace ignored)
print(float("-0.5"))      # Output: -0.5
print(float("inf"))       # Output: inf (infinity)
 
# These don't work
# print(float("hello"))   # Error: ValueError
# print(float("1.2.3"))   # Error: ValueError

Mengonversi boolean ke float:

# bool_to_float.py
print(float(True))   # Output: 1.0
print(float(False))  # Output: 0.0

3.7.4) Mengonversi ke String dengan str()

Fungsi str() mengonversi nilai apa pun ke representasi string-nya:

Mengonversi angka ke string:

# number_to_string.py
# Convert integer
age = 25
age_str = str(age)
print(age_str, type(age_str))  # Output: 25 <class 'str'>
 
# Convert float
price = 19.99
price_str = str(price)
print(price_str, type(price_str))  # Output: 19.99 <class 'str'>
 
# Now we can concatenate with other strings
message = "The price is $" + price_str
print(message)  # Output: The price is $19.99

Ini sangat berguna saat membangun pesan:

# building_messages.py
name = "Alice"
age = 25
height = 5.6
 
# Without str(), this would cause an error
# message = "Name: " + name + ", Age: " + age  # Error!
 
# With str(), it works
message = "Name: " + name + ", Age: " + str(age) + ", Height: " + str(height)
print(message)  # Output: Name: Alice, Age: 25, Height: 5.6

Mengonversi boolean ke string:

# bool_to_string.py
is_valid = True
is_error = False
 
print(str(is_valid))  # Output: True
print(str(is_error))  # Output: False
 
# Useful in messages
status = "Status: " + str(is_valid)
print(status)  # Output: Status: True

Mengonversi None ke string:

# none_to_string.py
value = None
value_str = str(value)
print(value_str)        # Output: None
print(type(value_str))  # Output: <class 'str'>
 
# The string "None" is different from the value None
print(value is None)      # Output: True
print(value_str is None)  # Output: False
print(value_str == "None")  # Output: True

3.7.5) Pola Konversi dalam Praktik

Berikut contoh lengkap yang menunjukkan pola konversi umum:

# conversion_patterns.py
# Get user input (always strings)
name = input("Enter your name: ")
age_str = input("Enter your age: ")
height_str = input("Enter your height in feet: ")
 
# Convert to appropriate types
age = int(age_str)
height = float(height_str)
 
# Perform calculations
age_in_months = age * 12
height_in_inches = height * 12
 
# Convert back to strings for output
print("Hello, " + name + "!")
print("You are " + str(age_in_months) + " months old.")
print("Your height is " + str(height_in_inches) + " inches.")
 
# Alternative: use multiple arguments to print() (no conversion needed)
print("Hello,", name + "!")
print("You are", age_in_months, "months old.")
print("Your height is", height_in_inches, "inches.")
 
# When user enters "Alice", "25", and "5.5":
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.
# Output: Hello, Alice!
# Output: You are 300 months old.
# Output: Your height is 66.0 inches.

Perhatikan bagaimana print() dengan banyak argumen (dipisah koma) secara otomatis mengonversi nilai ke string dan menambahkan spasi di antaranya. Ini sering lebih nyaman daripada konversi dan penggabungan string manual.

3.7.6) Diagram Alur Konversi

Berikut representasi visual dari konversi tipe yang umum:

Poin penting tentang konversi:

• int → float: Selalu aman, menambahkan .0
• float → int: Membuang bagian desimal (tidak membulatkan)
• Any → str: Selalu aman, mengonversi ke representasi teks
• str → int/float: Hanya berfungsi jika string merepresentasikan angka valid
• bool → int/float: True menjadi 1/1.0, False menjadi 0/0.0

3.7.7) Kesalahan Umum dalam Konversi

Berikut beberapa kesalahan umum pemula terkait konversi tipe:

Kesalahan 1: Lupa mengonversi input pengguna

# conversion_mistake1.py
# Wrong: trying to do math with string
age = input("Enter your age: ")
# next_year = age + 1  # Error: TypeError
 
# Right: convert first
age = int(input("Enter your age: "))
next_year = age + 1
print("Next year:", next_year)

Kesalahan 2: Mengonversi saat tidak perlu

# conversion_mistake2.py
# Unnecessary: print() handles conversion automatically
age = 25
print("Age:", age)  # This works fine
 
# No need for:
print("Age:", str(age))  # Unnecessary str() conversion

Kesalahan 3: Mencoba mengonversi string yang tidak valid

# conversion_mistake3.py
# This will crash if user enters non-numeric input
# age = int(input("Enter your age: "))  # Crashes on "twenty"
 
# We'll learn to handle this safely in Chapter 27

Kesalahan 4: Mengira int() melakukan pembulatan

# conversion_mistake4.py
# Wrong expectation: int() truncates, doesn't round
x = int(3.7)
print(x)  # Output: 3 (not 4!)
 
# If you want rounding, use round()
x = round(3.7)
print(x)  # Output: 4

3.8) Mendapatkan Representasi String dengan str() dan repr()

3.8.1) Perbedaan str() dan repr()

Python menyediakan dua cara untuk mendapatkan representasi string dari sebuah objek: str() dan repr(). Walaupun tampak mirip, keduanya punya tujuan berbeda:

• str(): Membuat representasi string yang "ramah," mudah dibaca manusia
• repr(): Membuat representasi string "resmi," tidak ambigu, ditujukan untuk developer

Untuk tipe sederhana seperti angka, keduanya sering sama, tapi untuk tipe lain bisa sangat berbeda:

# str_vs_repr.py
# For numbers, they're usually the same
x = 42
print(str(x))   # Output: 42
print(repr(x))  # Output: 42
 
# For strings, they differ
text = "Hello"
print(str(text))   # Output: Hello
print(repr(text))  # Output: 'Hello' (includes quotes!)
 
# For strings with special characters, repr() shows escape sequences
message = "Hello\nWorld"
print(str(message))   # Output: Hello
                      #         World (newline is interpreted)
print(repr(message))  # Output: 'Hello\nWorld' (shows the \n literally)

3.8.2) Kapan Menggunakan str()

Gunakan str() ketika kamu ingin representasi yang mudah dibaca untuk pengguna akhir:

# using_str.py
price = 19.99
quantity = 3
 
# Create user-friendly messages
message = "Total: $" + str(price * quantity)
print(message)  # Output: Total: $59.97
 
# str() is what print() uses automatically
print("Total: $", price * quantity)  # Output: Total: $ 59.97

Fungsi str() dirancang untuk menghasilkan output yang masuk akal bagi manusia, meskipun mungkin kehilangan sedikit detail teknis. Saat kamu memanggil print(), Python otomatis memanggil str() pada nilai yang kamu berikan.

3.8.3) Kapan Menggunakan repr()

Gunakan repr() ketika kamu butuh representasi yang tidak ambigu, biasanya untuk debugging:

# using_repr.py
# Debugging: see exactly what's in a variable
text = "Hello\nWorld"
print("Debug info:", repr(text))  # Output: Debug info: 'Hello\nWorld'
 
# Compare two similar-looking strings
str1 = "42"
str2 = "42 "  # Has trailing space
 
print(str1)       # Output: 42
print(str2)       # Output: 42  (space not obvious)
print(repr(str1)) # Output: '42'
print(repr(str2)) # Output: '42 ' (space is visible!)

Fungsi repr() dirancang untuk menunjukkan persis apa yang dilihat Python, termasuk detail yang mungkin tidak terlihat di output normal. Ini membuatnya sangat berharga untuk debugging.

3.8.4) Tujuan repr(): Representasi yang Bisa Dibuat Ulang

Idealnya, repr() sebaiknya menghasilkan string yang, jika kamu berikan ke interpreter Python, akan membuat ulang objek aslinya. Untuk tipe dasar, ini berfungsi:

# repr_recreate.py
# For numbers
x = 42
x_repr = repr(x)
print(x_repr)  # Output: 42
 
# You could use this to recreate x
x_recreated = eval(x_repr)  # eval() evaluates a string as Python code
print(x_recreated)  # Output: 42
 
# For strings
text = "Hello"
text_repr = repr(text)
print(text_repr)  # Output: 'Hello'
 
# This could recreate the string
text_recreated = eval(text_repr)
print(text_recreated)  # Output: Hello

Catatan penting: Fungsi eval() mengeksekusi sebuah string sebagai kode Python. Kita menyebutnya di sini untuk menjelaskan tujuan repr(), tetapi jangan pernah memakai eval() pada input yang tidak terpercaya—itu berisiko keamanan. Kita akan membahas alternatif yang lebih aman di bab-bab selanjutnya.

3.8.5) Contoh Praktis str() dan repr()

Contoh 1: Debugging masalah string

# debugging_strings.py
# User input might have unexpected whitespace
user_input = "  Alice  "
 
print("User entered:", user_input)         # Output: User entered:   Alice  
print("Debug view:", repr(user_input))     # Output: Debug view: '  Alice  '
 
# Now the extra spaces are obvious!
cleaned = user_input.strip()  # Remove leading/trailing whitespace
print("Cleaned:", repr(cleaned))  # Output: Cleaned: 'Alice'

Contoh 2: Membandingkan tipe yang berbeda

# comparing_types.py
# These look similar but are different
num = 42
text = "42"
 
print("Number:", num)       # Output: Number: 42
print("Text:", text)        # Output: Text: 42
 
print("Number repr:", repr(num))   # Output: Number repr: 42
print("Text repr:", repr(text))    # Output: Text repr: '42'
 
# repr() makes the difference clear
print("Are they equal?", num == text)  # Output: Are they equal? False

3.8.6) str() dan repr() dengan Tipe Lain

Mari lihat bagaimana str() dan repr() bekerja dengan tipe yang sudah kita pelajari:

# str_repr_types.py
# Integers
x = 42
print("int str:", str(x))    # Output: int str: 42
print("int repr:", repr(x))  # Output: int repr: 42
 
# Floats
y = 3.14159
print("float str:", str(y))   # Output: float str: 3.14159
print("float repr:", repr(y)) # Output: float repr: 3.14159
 
# Booleans
b = True
print("bool str:", str(b))   # Output: bool str: True
print("bool repr:", repr(b)) # Output: bool repr: True
 
# None
n = None
print("None str:", str(n))   # Output: None str: None
print("None repr:", repr(n)) # Output: None repr: None
 
# Strings (where they differ most)
s = "Hello\nWorld"
print("string str:", str(s))   # Output: string str: Hello
                                #                     World
print("string repr:", repr(s)) # Output: string repr: 'Hello\nWorld'

3.8.7) Hal-Hal Penting yang Perlu Diingat

Gunakan str() ketika:

• Membuat output untuk pengguna akhir
• Membuat pesan yang ditampilkan ke user
• Memformat data untuk ditampilkan
• Kamu ingin output yang ramah dan mudah dibaca

Gunakan repr() ketika:

• Melakukan debugging kode
• Mencatat (logging) informasi teknis
• Kamu perlu melihat persis apa yang ada di sebuah variabel
• Kamu ingin representasi yang tidak ambigu

Ingat:

• print() otomatis memakai str() pada argumennya
• Untuk kebanyakan tipe dasar, str() dan repr() menghasilkan hasil yang mirip
• Untuk string, repr() menyertakan tanda kutip dan menampilkan escape sequence
• repr() dirancang agar tidak ambigu dan (idealnya) bisa dipakai untuk membuat ulang objek

Ringkasan Bab

Di bab ini, kamu telah mempelajari konsep fundamental tentang variabel dan tipe data di Python. Mari kita rangkum poin-poin utamanya:

Variabel:

• Variabel adalah nama yang merujuk ke nilai di memori
• Dibuat dengan assignment: variable_name = value
• Bisa di-reassign ke nilai baru kapan saja
• Harus mengikuti aturan penamaan dan sebaiknya mengikuti konvensi
• Gunakan nama yang deskriptif agar kode terdokumentasi sendiri

Tipe Data:

• Setiap nilai di Python punya tipe
• Gunakan type() untuk mengecek tipe nilai
• Python menggunakan dynamic typing—variabel bisa merujuk ke tipe berbeda di waktu yang berbeda
• Tipe yang berbeda mendukung operasi yang berbeda

Tipe Dasar:

• int: Bilangan bulat (positif, negatif, atau nol), ukuran arbitrer
• float: Bilangan dengan titik desimal, mungkin memiliki keterbatasan presisi
• str: Teks yang diapit tanda kutip (tunggal atau ganda)
• bool: Nilai logika True atau False
• None: Nilai khusus yang merepresentasikan ketiadaan nilai

Konversi Tipe:

• int(): Konversi ke integer (memotong float, mengurai string)
• float(): Konversi ke bilangan floating-point
• str(): Konversi ke string (selalu berfungsi)
• Konversi bisa gagal untuk input yang tidak valid (menimbulkan ValueError)

Representasi String:

• str(): Representasi yang mudah dibaca manusia untuk pengguna akhir
• repr(): Representasi yang tidak ambigu untuk developer/debugging
• print() memakai str() secara otomatis

Konsep-konsep ini menjadi fondasi untuk semua hal lain di Python. Setiap program yang kamu tulis akan menggunakan variabel untuk menyimpan data, dan memahami tipe data membantu kamu memprediksi operasi apa yang akan berhasil dan error apa yang mungkin terjadi.

Di bab berikutnya, kita akan membangun di atas fondasi ini dengan mengeksplorasi cara bekerja dengan angka secara detail, termasuk operasi aritmetika, prioritas operator (operator precedence), dan pola perhitungan numerik yang umum. Kamu akan belajar cara melakukan perhitungan, bekerja dengan fungsi matematika, dan menangani keunikan aritmetika floating-point.