Interpolasi String Python: Panduan Pemula

Misalkan Anda ingin menampilkan nama dan profesi seseorang. Anda bisa menulis program sederhana seperti berikut.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)Didukung oleh

   My name is Mark, I am 7 years old and my profession is Astronaut.Didukung oleh

Pendekatan tersebut kurang ringkas dan kurang mudah dibaca. Untungnya, interpolasi string menawarkan solusi yang lebih baik. Teknik ini memungkinkan variabel, ekspresi, atau keluaran fungsi disisipkan langsung ke dalam string, sehingga manipulasi string menjadi dinamis dan menghilangkan kebutuhan penggabungan manual.

Dengan pendekatan interpolasi string, kita dapat menulis ulang kode sebagai berikut.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)Didukung oleh

   My name is Mark, I am 7 years old and my profession is Astronaut.Didukung oleh

Versi dengan interpolasi string memungkinkan penyematan ekspresi langsung di dalam string tanpa menggunakan penggabungan yang berantakan. Seperti yang Anda lihat, ini jauh lebih bersih.

Interpolasi String Dasar di Python

Ada beberapa teknik interpolasi string yang tersedia di Python. Metode yang paling umum direkomendasikan adalah formatted string literals, atau f-strings, yang tersedia sejak Python 3.6.

Metode lain yang umum ditemui pada kode yang lebih lama dari Python 3.6 adalah metode .format(). Meskipun metode ini lebih panjang daripada f-strings, sesekali ia memiliki keunggulan tersendiri (rincian di bawah).

Terakhir, Anda mungkin menemui pemformatan bergaya % pada kode warisan (legacy).

Menggunakan f-strings (Python 3.6+)

f-strings (formatted string literal) adalah cara yang kuat dan ringkas untuk memformat string di Python. Diperkenalkan pada Python 3.6, ia menyediakan cara yang mudah dibaca dan efisien untuk menyisipkan variabel, ekspresi, dan pemanggilan fungsi langsung ke dalam string.

Contoh sederhana sintaks dasar f-string adalah sebagai berikut.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)Didukung oleh

   My name is Mark.Didukung oleh

Dalam kode ini, variabel output_string diberi f-string. Awalan f sebelum tanda kutip pembuka menunjukkan bahwa string mendukung ekspresi yang disematkan. Variabel name dievaluasi dan nilainya disisipkan ke dalam string, menghasilkan keluaran: "My name is Mark."

Tidak hanya nilai variabel, perhitungan atau ekspresi pun dapat disisipkan ke dalam f-strings. Perhatikan contoh ini.

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Didukung oleh

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.Didukung oleh

Ekspresi math.sqrt(a ** 2 + b ** 2) dievaluasi langsung di dalam string, sehingga tidak perlu menghitung nilainya secara terpisah sebelum menyisipkannya ke dalam string.

Menggunakan metode .format()

Seperti f-strings, metode .format() memungkinkan penyisipan variabel dan ekspresi ke dalam string. Sintaks dasar metode .format() adalah sebagai berikut.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)Didukung oleh

   My name is Mark.Didukung oleh

Kurung kurawal {} berfungsi sebagai placeholder, menandakan bahwa nilai sebuah variabel akan disisipkan ke string pada posisi tersebut. Nilai variabel spesifik yang disisipkan ke placeholder ditentukan oleh argumen yang diberikan ke metode .format().

Argumen posisional

Apa yang terjadi jika Anda memerlukan beberapa placeholder untuk beberapa variabel? Pertimbangkan kode berikut.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Didukung oleh

   My name is Mark and I am 7 years old.Didukung oleh

Dalam contoh ini, dibutuhkan dua variabel, name dan age. Akibatnya, string menyertakan dua placeholder, dan variabel disisipkan dalam urutan yang sama seperti kemunculannya di metode .format(). Argumen-argumen ini disebut *positional* arguments karena penempatannya di string ditentukan oleh posisinya dalam daftar argumen metode.

Placeholder berindeks dan bernama

Sebagai variasi dari konsep placeholder, perhatikan contoh ini.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Didukung oleh

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Didukung oleh

Di sini, kita menggunakan kembali nilai variabel age dua kali. Menyertakan variabel yang sama berkali-kali seperti ini terasa canggung dan mengurangi keterbacaan. Adakah cara untuk menggunakan kembali variabel dalam string yang diformat dengan metode .format() tanpa mengulanginya? Ada, yaitu dengan *placeholder berindeks*.

name = 'Mark'
age = 7


# Use indexed placeholders
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)Didukung oleh

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Didukung oleh

Dalam contoh ini, kita secara eksplisit mendefinisikan urutan variabel di dalam kurung kurawal, mengikuti indexing berbasis nol di Python. Selain itu, kita menggunakan kembali variabel pada indeks 1 alih-alih mengulanginya.

Sebagai alternatif dari pengindeksan posisional, Anda juga dapat menggunakan argumen bernama, di mana setiap argumen diberi nama.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))Didukung oleh

   My name is Mark and I am 7 years old.Didukung oleh

Argumen bernama dievaluasi di dalam kurung kurawal yang menyebutkan namanya. Akibatnya, placeholder {name} digantikan dengan nilai "Mark", dan placeholder {age} digantikan dengan 30.

Menggunakan operator %

Metode terakhir untuk interpolasi string adalah operator %. Fungsinya mirip dengan perintah printf() di C. Penggunaannya sudah usang dan sangat tidak dianjurkan, lebih baik menggunakan f-strings atau metode .format(). Metode ini disebutkan di sini karena Anda mungkin menemukannya dalam basis kode warisan.

Format dasar operator % adalah: "format string" % values. String format berisi placeholder, seperti %s untuk string, yang akan digantikan oleh nilai. Misalnya, contoh berikut mencetak "Hello, Mark."

'Hello %s' % 'Mark'Didukung oleh

   'Hello Mark'Didukung oleh

Specifier format umum lainnya ditunjukkan pada tabel berikut.

Operator % memiliki banyak keterbatasan. Salah satunya, ia kurang mudah dibaca dibandingkan f-strings. Perhatikan kode berikut.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Didukung oleh

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Didukung oleh

Apakah kode ini jelas sekilas? Mungkin tidak. Ada banyak pemindaian visual bolak-balik dari placeholder ke variabel yang mengisinya. Mudah membuat bingung (atau pusing) dengan semua pemindaian bolak-balik tersebut.

Sekarang, perhatikan kode ekuivalen yang menggunakan f-strings.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Didukung oleh

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Didukung oleh

Tidak diperlukan pemindaian dan tidak ada string format yang membingungkan. Kodenya bersih, mudah dipahami, dan mudah ditulis. Anda dapat mempelajari kiat lainnya untuk menulis kode yang jelas dan teroptimasi melalui Python Programming skill track DataCamp. 

Teknik Interpolasi String Python Lanjutan

Setelah memahami dasar-dasarnya, mari kita lihat beberapa penggunaan lanjutan dari interpolasi string Python. 

Interpolasi string multiline di Python

f-strings juga dapat digunakan untuk konten multiline dengan menggunakan penanda f bersama tanda kutip tiga (tunggal atau ganda). Teks dapat ditulis di beberapa baris, dan akan muncul pada keluaran persis sebagaimana diformat.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Didukung oleh

   Name: Mark

   Profession: Astronaut

   Age: 7Didukung oleh

 String multiline juga dapat dibuat menggunakan metode .format().

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Didukung oleh

   Name: Mark

   Profession: Astronaut

   Age: 7Didukung oleh

Kasus penggunaan interpolasi string multiline

Mengapa Anda ingin menggunakan interpolasi string multiline? Ada banyak penggunaan untuk interpolasi string multiline. Berikut beberapa kasus penggunaannya:

• Menghasilkan email atau pesan multiline
• Logging dan debugging
• Menghasilkan kueri SQL secara dinamis

Menghasilkan email atau pesan multiline

Misalkan Anda mengirimkan surat undangan massal kepada banyak undangan untuk sebuah konferensi teknologi.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)Didukung oleh

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event TeamDidukung oleh

Dengan f-strings, membuat surat template menjadi sederhana dan efisien. Untuk mengubah nama, acara, atau tanggal, cukup ubah di variabelnya dan string akan berubah secara otomatis.

Logging dan debugging

String multiline berguna untuk mencetak pesan galat ke log.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)Didukung oleh

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.Didukung oleh

Metode ini menjaga pesan log tetap terstruktur dan mempermudah debugging dengan log yang diformat dengan baik.

Menghasilkan kueri SQL secara dinamis

Kueri SQL dapat dibangun secara dinamis menggunakan string multiline.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)Didukung oleh

   SELECT *

   FROM users

   WHERE email = '[email protected]';Didukung oleh

Metode ini membuat kueri SQL mudah dibaca dan mempertahankan indentasi. Selain itu, ini menghilangkan kebutuhan menggunakan + untuk penggabungan string.

Kasus penggunaan lainnya meliputi:

• Menulis kontrak terformat
• Membuat dokumen Markdown atau $\LaTeX$
• Template HTML/XML multiline
• Menghasilkan respons API atau teks mirip JSON

Keunggulan interpolasi string multiline

Seperti yang kita lihat, ada beberapa keunggulan interpolasi string multiline.

• Interpolasi string mempertahankan pemformatan tanpa perlu karakter escape \n. 
• Interpolasi string meningkatkan keterbacaan dibandingkan pemformatan satu baris. 
• Interpolasi string mengurangi kekacauan saat bekerja dengan teks terstruktur (misalnya, log, kueri, laporan). 
• Interpolasi string memungkinkan pembuatan teks dinamis tanpa merusak indentasi. 

Memformat angka dan nilai khusus

Untuk mengendalikan jumlah tempat desimal yang ditampilkan menggunakan f-string, gunakan sintaks: f'{value:.nf}', di mana value adalah angka pecahan (floating-point), n adalah jumlah tempat desimal, dan f (yang setelah .) menandakan pemformatan float.

Sebagai ilustrasi, kode berikut menampilkan $\pi$ dengan jumlah desimal yang berbeda.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')Didukung oleh

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Didukung oleh

Pemformatan dengan metode .format() serupa.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))Didukung oleh

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Didukung oleh

Anda dapat menggunakan f-string untuk memformat persentase dengan menggunakan sintaks :.nf yang dikombinasikan dengan %, di mana n adalah jumlah tempat desimal.

score = 0.875
print(f"Success rate: {score:.2%}")Didukung oleh

   Success rate: 87.50%Didukung oleh

Anda dapat menggunakan f-string untuk memformat mata uang dengan menggunakan :, untuk pemisah ribuan dan .nf untuk mengendalikan jumlah desimal. Anda juga dapat menyertakan simbol mata uang seperti $, €, atau £ langsung di dalam string.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")Didukung oleh

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Didukung oleh

Menggunakan f-strings dengan dictionary dan list

Untuk menggunakan f-strings dengan dictionary di Python, akses nilai dictionary di dalam kurung kurawal menggunakan notasi kurung siku (dict['key']) atau dengan membongkar (unpack) dictionary menggunakan **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")Didukung oleh

   My name is Alice, I am 30 years old, and I live in New York.Didukung oleh

Alih-alih mengakses setiap key secara manual, Anda dapat membongkar dictionary ke dalam f-string seperti berikut.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))Didukung oleh

   My name is Alice and I am 7 years old.Didukung oleh

Untuk menghindari galat karena key yang hilang, gunakan get() saat mengakses dictionary.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Didukung oleh

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Error: key 'city' is missing

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'Didukung oleh

print(f"City: {person.get('city', 'Not specified')}")Didukung oleh

   City: Not specifiedDidukung oleh

Kelebihan dan Kekurangan Metode Interpolasi String

Seperti yang telah kita lihat, f-strings dan metode .format() sama-sama berguna untuk interpolasi string. Mari kita bandingkan kelebihan dan kekurangan masing-masing metode.

Kapan sebaiknya Anda menggunakan .format() alih-alih f-strings?

Kesalahan Umum dan Praktik Terbaik

Di bawah ini, Anda dapat menemukan beberapa metode pemecahan masalah dan kiat utama untuk menggunakan interpolasi string Python. 

Menghindari kesalahan sintaks dengan kurung kurawal

Ada banyak kesalahan sintaks yang bisa terjadi saat menggunakan interpolasi string yang melibatkan kurung kurawal.

• Pastikan setiap { memiliki pasangan }

print('Hello, my name is {name!'}Didukung oleh

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('Didukung oleh

Untungnya, galatnya jelas dan perbaikannya mudah.

• Gunakan {{ dan }} untuk menampilkan { } literal

Apa yang terjadi jika Anda ingin mencetak kurung kurawal di dalam string yang diinterpolasi? Apa pun di dalam kurung kurawal akan (berusaha) dievaluasi.

print(f'Set notation: {a, b, c}')Didukung oleh

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not definedDidukung oleh

Python menafsirkan a, b, c di dalam kurung kurawal sebagai tuple, dan berusaha menemukan nilai yang terkait dengan a. Karena tidak ada variabel tersebut, Python memunculkan KeyError. Perbaikannya adalah menggunakan kurung kurawal ganda {{}}.

print("Set notation: {{a, b, c}}")Didukung oleh

   Set notation: {{a, b, c}}

Perbandingan performa: f-strings vs .format()

Mari bandingkan performa f-strings dan .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Measure .format() performance
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")Didukung oleh

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsDidukung oleh

Seperti yang Anda lihat, dari sisi efisiensi, sebaiknya memilih f-strings dibandingkan .format().

Praktik terbaik untuk interpolasi string yang bersih dan mudah dibaca

Agar pemformatan string Anda jelas, efisien, dan mudah dipelihara, ikuti praktik terbaik berikut saat menggunakan string terinterpolasi.

• Utamakan f-strings untuk keterbacaan (Python 3.6+)

# Recommended
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Didukung oleh

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Didukung oleh

• Gunakan placeholder bernama untuk kejelasan

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Didukung oleh

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Didukung oleh

• Jaga string multiline tetap mudah dibaca.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)Didukung oleh

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  Didukung oleh

• Gunakan f-strings dalam logging untuk debugging yang lebih baik

Python 3.8 dan yang lebih baru mendukung = untuk debugging di f-strings.

value = 42


# Output: value = 42
print(f"{value = }") Didukung oleh

   value = 42Didukung oleh

Kesimpulan

Interpolasi string adalah fitur kuat di Python yang membuat pemformatan string lebih bersih, lebih mudah dibaca, dan lebih efisien. Di antara metode yang tersedia, f-strings adalah pendekatan yang paling modern dan direkomendasikan, dengan performa, kejelasan, dan fleksibilitas yang lebih baik dibandingkan metode lama seperti .format() dan % formatting. 

Dengan mengikuti praktik terbaik, seperti menggunakan placeholder bernama, mengendalikan presisi desimal, merapikan teks demi keterbacaan, serta menangani key dictionary yang hilang dengan baik, Anda dapat menulis pemformatan string di Python yang bersih, profesional, dan mudah dipelihara. 

Baik Anda membuat laporan terformat, pesan multiline, atau keluaran data terstruktur, f-strings menyediakan cara yang sederhana namun kuat untuk mengintegrasikan variabel dan ekspresi secara mulus. Mengadopsi f-strings tidak hanya akan meningkatkan kualitas kode Anda tetapi juga efisiensinya. 

Untuk informasi lebih lanjut tentang interpolasi string Python, lihat sumber daya DataCamp berikut:

• f-string Formatting in Python tutorial
• Python Append String: 6 Essential Concatenation Techniques
• Python Programming skill track
• Python Fundamentals skill track
• Introduction to Data Science in Python course