Fungsi Utama main dalam Python

Ketika membuat program Python, kode dapat ditulis langsung pada bagian utama berkas atau dikelompokkan ke dalam fungsi. Pada program sederhana, penulisan kode secara langsung mungkin tidak menjadi masalah. Namun, ketika program semakin besar, penggunaan struktur yang lebih teratur menjadi penting.

Sebelum mempelajari materi tentang Fungsi Utama main dalam Python, terlebih dahulu pelajari materi tentang: Rekursi dalam Python, Modul dalam Python, dan Paket dalam Python.

Salah satu pola yang sering digunakan adalah:
if __name__ == "__main__":
...

Pola tersebut digunakan untuk menentukan bagian kode yang dijalankan ketika sebuah berkas Python dijalankan secara langsung.

Dalam Python, tidak terdapat fungsi `main()` yang wajib digunakan seperti pada beberapa bahasa pemrograman lain. Namun, fungsi bernama `main()` dapat dibuat sebagai kebiasaan untuk mengatur bagian utama program.

Contoh:
def main():
print("Program utama")
if __name__ == "__main__":
main()

Hasil:
Program utama

Pengertian main pada Python

`main` dapat digunakan sebagai nama fungsi yang berisi bagian utama dari sebuah program.

Contoh:
def main():
print("Selamat belajar Python")
print("Program sedang berjalan")
main()

Fungsi `main()` pada contoh tersebut tidak mempunyai keistimewaan khusus dari Python. Nama `main` hanyalah nama fungsi yang dipilih oleh pemrogram. Artinya, kode berikut juga dapat dibuat:
def jalankan_program():
print("Program berjalan")
jalankan_program()

Keduanya dapat dijalankan. Namun, nama `main()` sering digunakan sebagai kebiasaan untuk menunjukkan bagian utama program.

Alasan Menggunakan Fungsi main

Penggunaan `main()` membantu membuat struktur program lebih teratur.

Beberapa manfaatnya:

• Memisahkan bagian utama program dari fungsi lainnya.
• Membuat kode lebih mudah dibaca.
• Memudahkan pengembangan program.
• Membantu menghindari kode yang langsung berjalan ketika modul diimpor.
• Mempermudah penggunaan kembali fungsi dari modul lain.
• Membuat struktur program lebih jelas.

Contoh tanpa `main()`:
nama = input("Nama: ")
print("Halo", nama)

Program langsung menjalankan perintah tersebut.

Contoh dengan `main()`:
def main():
nama = input("Nama: ")
print("Halo", nama)
if __name__ == "__main__":
main()

Struktur program menjadi lebih jelas.

Memahami **name**

Untuk memahami:
if __name__ == "__main__":

perlu memahami variabel khusus bernama `__name__`. Python secara otomatis menyediakan `__name__` pada setiap modul. Nilainya bergantung pada bagaimana modul tersebut digunakan. 

Jika berkas Python dijalankan secara langsung, nilai:
__name__

akan menjadi:
__main__

Jika berkas digunakan sebagai modul oleh program lain, nilainya biasanya menjadi nama modul tersebut.

Contoh **name**

Buat sebuah berkas:
contoh.py

Isinya:
print(__name__)

Jika `contoh.py` dijalankan langsung:
__main__

Hal ini terjadi karena berkas tersebut merupakan program yang sedang dijalankan.

Menggunakan if **name** == "**main**"

Pola yang umum digunakan:
if __name__ == "__main__":
print("Program utama dijalankan")

Ketika berkas dijalankan langsung, kondisi tersebut bernilai benar sehingga perintah dijalankan.

Contoh lengkap:
def salam():
print("Halo")
if __name__ == "__main__":
salam()

Hasil ketika berkas dijalankan langsung:
Halo

Kondisi Modul Diimpor

Misalnya terdapat dua berkas:
contoh.py
utama.py

Isi `contoh.py`:
print("Modul sedang dimuat")
def salam():
print("Halo")

Isi `utama.py`:
import contoh
contoh.salam()

Ketika `utama.py` dijalankan, perintah `print()` pada `contoh.py` juga akan dijalankan karena bagian tersebut berada di luar fungsi atau pemeriksaan `__name__`.

Hasil:
Modul sedang dimuat
Halo

Hal ini menunjukkan mengapa pemeriksaan `__name__` berguna.

Menghindari Kode Berjalan Saat Diimpor

Kode yang hanya ingin dijalankan ketika berkas dieksekusi secara langsung dapat ditempatkan di dalam:
if __name__ == "__main__":

Contoh:
def salam():
print("Halo")
if __name__ == "__main__":
salam()

Sekarang jika berkas tersebut diimpor:
import contoh

fungsi `salam()` tersedia, tetapi pemanggilan:
salam()

yang berada di dalam blok `if __name__ == "__main__":` tidak dijalankan secara otomatis. Hal ini sangat berguna ketika sebuah berkas berfungsi sebagai modul sekaligus dapat dijalankan sebagai program.

Membuat Fungsi main

Fungsi `main()` dapat digunakan untuk menampung bagian utama program.

Contoh:
def main():
nama = input("Masukkan nama: ")
print("Halo", nama)
if __name__ == "__main__":
main()

Struktur tersebut dapat dibaca seperti berikut:

1. Fungsi `main()` dibuat.
2. Fungsi berisi proses utama program.
3. Python memeriksa nilai `__name__`.
4. Jika berkas dijalankan langsung, kondisi bernilai benar.
5. Fungsi `main()` dipanggil.

Membuat Program dengan Beberapa Fungsi

Penggunaan `main()` akan lebih terasa manfaatnya ketika program mempunyai beberapa fungsi.

Contoh:
def input_data():
nama = input("Nama: ")
return nama
def tampilkan_data(nama):
print("Nama:", nama)
def main():
nama = input_data()
tampilkan_data(nama)
if __name__ == "__main__":
main()

Program mempunyai tiga fungsi:

• `input_data()` untuk menerima data.
• `tampilkan_data()` untuk menampilkan data.
• `main()` untuk mengatur alur utama.

Struktur seperti ini lebih mudah dikembangkan dibandingkan menulis seluruh perintah secara langsung.

Fungsi main dengan Nilai Return

Fungsi `main()` juga dapat menghasilkan nilai.

Contoh:
def main():
angka = 10
return angka
if __name__ == "__main__":
hasil = main()
print(hasil)

Hasil:
10

Dengan demikian, `main()` tidak harus hanya menampilkan data. Fungsi tersebut juga dapat mengembalikan nilai.

main dengan Argumen

Fungsi `main()` juga dapat menerima argumen seperti fungsi Python lainnya.

Contoh:
def main(nama):
print("Halo", nama)
if __name__ == "__main__":
main("Budi")

Hasil:
Halo Budi

Tidak ada aturan khusus yang mengharuskan `main()` tidak memiliki parameter. Struktur tersebut tetap merupakan fungsi Python biasa.

main dengan Data dari Fungsi Lain

Fungsi `main()` dapat mengatur beberapa fungsi sekaligus.

Contoh:
def tambah(a, b):
return a + b
def kurang(a, b):
return a - b
def main():
hasil_tambah = tambah(10, 5)
hasil_kurang = kurang(10, 5)
print("Penjumlahan:", hasil_tambah)
print("Pengurangan:", hasil_kurang)
if __name__ == "__main__":
main()

Hasil:
Penjumlahan: 15
Pengurangan: 5

Fungsi `main()` bertugas mengatur jalannya program.

Fungsi main dan Modul

Salah satu alasan penting menggunakan `main()` adalah ketika sebuah berkas juga akan digunakan sebagai modul.

Contoh:
def tambah(a, b):
return a + b
def main():
print(tambah(10, 20))
if __name__ == "__main__":
main()

Jika berkas dijalankan langsung:
30

Jika berkas diimpor oleh program lain:
import matematika

fungsi `tambah()` dapat digunakan:
hasil = matematika.tambah(5, 10)
print(hasil)

Hasil:
15

Fungsi `main()` tidak otomatis dijalankan ketika modul diimpor.

Contoh Struktur Program

Sebuah program Python sederhana dapat memiliki struktur:
program.py

Isi:
def fungsi_satu():
print("Fungsi satu")
def fungsi_dua():
print("Fungsi dua")
def main():
fungsi_satu()
fungsi_dua()
if __name__ == "__main__":
main()

Struktur tersebut menunjukkan pembagian yang jelas:
fungsi_satu()
↓
fungsi_dua()
↓
main()
↓
program dijalankan

Contoh Program Pengolahan Nilai

Berikut contoh program yang menggunakan beberapa fungsi dan `main()`.
def hitung_rata_rata(nilai):
return sum(nilai) / len(nilai)
def tentukan_status(nilai):
if nilai >= 75:
return "Lulus"
return "Belum Lulus"
def main():
nilai = [80, 85, 90]
rata_rata = hitung_rata_rata(nilai)
status = tentukan_status(rata_rata)
print("Nilai rata-rata:", rata_rata)
print("Status:", status)
if __name__ == "__main__":
main()

Hasil:
Nilai rata-rata: 85.0
Status: Lulus

Program tersebut memiliki pembagian tugas:

• `hitung_rata_rata()` menghitung nilai rata-rata.
• `tentukan_status()` menentukan status.
• `main()` mengatur alur program.

Contoh Program dengan Input Pengguna

Fungsi `main()` juga dapat mengatur program interaktif.
def hitung_luas(panjang, lebar):
return panjang * lebar
def main():
panjang = float(input("Masukkan panjang: "))
lebar = float(input("Masukkan lebar: "))
luas = hitung_luas(panjang, lebar)
print("Luas:", luas)
if __name__ == "__main__":
main()

Contoh hasil:
Masukkan panjang: 10
Masukkan lebar: 5
Luas: 50.0

Bagian input dan pengaturan program berada di dalam `main()`.

main dan Program yang Lebih Besar

Pada program yang lebih besar, `main()` dapat menjadi titik awal alur program.

Misalnya:
def login():
pass
def tampilkan_menu():
pass
def proses_pilihan():
pass
def main():
login()
tampilkan_menu()
proses_pilihan()
if __name__ == "__main__":
main()

Struktur ini membuat alur program mudah dilihat. Program dimulai dari:
main()
↓
login()
↓
tampilkan_menu()
↓
proses_pilihan()

Setiap fungsi mempunyai tanggung jawab tertentu.

Keuntungan Menggunakan main

Beberapa keuntungan penggunaan fungsi `main()` adalah:

satu, Struktur program lebih jelas.
Pembaca dapat mengetahui bagian utama program.

dua, Mudah digunakan sebagai modul.
Kode utama tidak otomatis berjalan ketika berkas diimpor.

tiga, Mudah diuji.
Fungsi-fungsi dapat diuji secara terpisah.

empat, Kode lebih mudah dikembangkan.
Program dapat dibagi menjadi beberapa fungsi.

lima, Mengurangi kode yang berjalan saat import.
Hanya kode yang diperlukan yang dijalankan ketika modul digunakan.

enam, Membantu pengelolaan program.
Fungsi `main()` dapat digunakan sebagai pengatur alur utama.

Fungsi main Wajib Digunakan

Jawabannya adalah tidak. Python tidak mewajibkan penggunaan fungsi `main()`.

Program berikut tetap valid:
print("Halo Python")

Program juga dapat dibuat menggunakan:
def main():
print("Halo Python")
if __name__ == "__main__":
main()

Keduanya dapat dijalankan. Perbedaannya terletak pada struktur dan pengelolaan kode. Untuk program yang sangat sederhana, penggunaan `main()` mungkin tidak diperlukan. Untuk program yang lebih besar, pola tersebut dapat membantu membuat struktur lebih teratur.

Perbedaan main() dan **main**

Kedua istilah tersebut sering membingungkan.

main()

`main()` adalah nama fungsi yang dibuat oleh pemrogram.

Contoh:
def main():
print("Program utama")

Python tidak memberikan perlakuan khusus hanya karena fungsi tersebut bernama `main`.

**main**

`__main__` adalah nilai khusus yang digunakan pada:
if __name__ == "__main__":

Ketika sebuah berkas dijalankan langsung, nilai `__name__` menjadi `__main__`.

Ringkasnya:
main() → nama fungsi
__main__ → nilai khusus pada __name__

Kesalahan yang Sering Terjadi

Berikut dijelaskan beberapa bentuk kesalahan yang sering terjadi.

satu, Menganggap main() wajib.

Python tidak mengharuskan setiap program mempunyai `main()`. Fungsi tersebut digunakan sebagai pola pengorganisasian kode.

dua, Salah menulis **main**.

Penulisan yang benar:
if __name__ == "__main__":

Perhatikan penggunaan dua garis bawah sebelum dan sesudah `name` serta `main`.

tiga, Memanggil main() di luar kondisi.

Contoh:
def main():
print("Program utama")
main()

Kode tersebut selalu menjalankan `main()` ketika berkas diproses, termasuk ketika berkas diimpor. Jika ingin mencegah hal tersebut:
def main():
print("Program utama")
if __name__ == "__main__":
main()

Tips Menggunakan Fungsi main

Beberapa kebiasaan yang dapat diterapkan:

• Gunakan `main()` untuk mengatur alur utama program.
• Letakkan fungsi pendukung sebelum `main()`.
• Gunakan `if __name__ == "__main__":` untuk menjalankan `main()`.
• Hindari menempatkan terlalu banyak proses dalam `main()`.
• Pecah proses besar menjadi beberapa fungsi.
• Gunakan parameter dan `return` untuk mengirim data antar fungsi.
• Gunakan nama fungsi yang menjelaskan tugasnya.
• Pisahkan fungsi pengolahan data dari bagian utama program.

Contoh Struktur Program yang Baik

Berikut salah satu pola yang mudah dipahami:
def input_data():
return input("Masukkan nama: ")

def proses_data(nama):
return nama.upper()

def tampilkan_hasil(hasil):
print("Hasil:", hasil)

def main():
nama = input_data()
hasil = proses_data(nama)
tampilkan_hasil(hasil)

if __name__ == "__main__":
main()

Alurnya:
main()
↓
input_data()
↓
proses_data()
↓
tampilkan_hasil()

Pembagian seperti ini membuat setiap fungsi mempunyai tugas yang jelas.

Latihan Pemahaman

Berikut diberikan beberapa contoh latihan pemahaman yang dapat langsung dipraktikkan oleh pengguna.

Latihan 1

Buat program dengan fungsi:
input_nama()
sapa()
main()

Ketentuan:

• `input_nama()` meminta nama.
• `sapa()` menerima nama dan menampilkan sapaan.
• `main()` mengatur alur program.
• Gunakan `if __name__ == "__main__":`.

Latihan 2

Buat program penghitung luas persegi panjang.

Gunakan fungsi:
hitung_luas()
main()

Fungsi `main()` harus:

1. Meminta panjang.
2. Meminta lebar.
3. Memanggil `hitung_luas()`.
4. Menampilkan hasil.

Latihan 3

Buat sebuah modul bernama `nilai.py`.

Isi modul:

• Fungsi `hitung_rata_rata()`.
• Fungsi `tentukan_status()`.
• Fungsi `main()`.

Gunakan:
if __name__ == "__main__":
main()

Kemudian buat program lain yang mengimpor fungsi dari `nilai.py`.

Ringkasan Materi

Beberapa hal penting yang perlu diingat:

• Python tidak mewajibkan fungsi `main()`.
• `main()` merupakan nama fungsi yang biasanya digunakan untuk menampung alur utama program.
• `__name__` merupakan variabel khusus yang tersedia pada setiap modul.
• Ketika berkas dijalankan langsung, nilai `__name__` adalah `__main__`.
• `if __name__ == "__main__":` digunakan untuk menjalankan kode tertentu ketika berkas dijalankan langsung.
• Fungsi `main()` dapat mengatur beberapa fungsi lainnya.
• Fungsi `main()` dapat menerima parameter.
• Fungsi `main()` dapat mengembalikan nilai.
• Penggunaan `main()` membantu membuat struktur program lebih teratur.
• Pemeriksaan `__name__` membantu mencegah kode utama berjalan otomatis ketika modul diimpor.
• `main()` dan `__main__` merupakan dua hal yang berbeda.
• `main()` adalah nama fungsi.
• `__main__` merupakan nilai khusus yang berkaitan dengan `__name__`.

Kesimpulan

Fungsi `main()` merupakan pola yang sering digunakan untuk mengatur bagian utama sebuah program Python. Meskipun Python tidak mewajibkan adanya fungsi bernama `main()`, penggunaannya dapat membantu membuat kode lebih terstruktur, terutama ketika program sudah terdiri dari banyak fungsi dan modul.

Bagian yang sangat penting untuk dipahami adalah:
if __name__ == "__main__":
main()

Pola tersebut memastikan fungsi `main()` dijalankan ketika berkas Python dieksekusi secara langsung. Ketika berkas yang sama digunakan sebagai modul, bagian tersebut tidak dijalankan secara otomatis.

Dengan memahami `main()`, `__name__`, dan `__main__`, program Python dapat disusun dengan struktur yang lebih rapi. Konsep ini juga menjadi dasar penting sebelum mempelajari pembuatan modul, paket, pustaka, dan proyek Python yang lebih besar.

Artikel ini akan dibaca oleh: Deva Halilintar Putra Pamungkas, Devandra Ferdinand Dharmansyah, Devy Setyaningrum, Diana Dwi Novianingrum, dan Difa Yuristika Bilqist.

Location: Kota Semarang, Jawa Tengah, Indonesia

Berbagi :