Hai sobat ayamkoding, pada kesempatan saat ini kita akan membuat program python untuk menghitung luas dari suatu bangun segitiga.
Okay, sebelumnya kita telah membahas tentang program menghitung luas persegi panjang dengan menggunakan python.
Apakah kamu sudah tahu apa itu bangun segitiga?
Yuhuuuu… Segitiga merupakan bangun datar yang mempunyai sisi sebanyak tiga.
Rumus segitiga yang akan digunakan adalah rumus:
L = 1/2 x alas x tinggi
Sehingga, kita akan membutuhkan nilai dari alas dan tinggi dari segitiga untuk melakukan perhitungan luas bangun tersebut.
Penasaran dengan cara implementasi menggunakan kode python?
Mari kita coba dengan berbagai macam cara.
Pertama, kita akan membuat program python untuk menghitung luas segitiga dari cara yang paling sederhana.
Alur kerjanya, hanya melakukan input alas dan tinggi.
Kemudian, dilakukan perhitungan luas dan hasilnya akan ditampilkan ke dalam layar kamu.
# -----------------------------------------
# Program Python Menghitung Luas Segitiga
# ~ Menggunakan Cara Sederhana ~
# -----------------------------------------
print("Program Python Untuk Menghitung Luas Segitiga")
print("---------------------------------------------")
# perintah untuk memasukkan alas segitiga
alas = float(input("Masukkan nilai dari alas : "))
# perintah untuk memasukkan tinggi segitiga
tinggi = float(input("Masukkan nilai dari tinggi : "))
# menghitung luas dari segitiga dengan rumus sederhana
luas = 0.5 * alas * tinggi
# menampilkan hasil dari perhitungan luas
print("---------------------------------------------")
print(f"Hasil dari perhitungan luas segitiga adalah {luas:.2f}")
Output:
(Eksperimen 1: alas 10 dan tinggi 5)
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas : 10
Masukkan nilai dari tinggi : 5
---------------------------------------------
Hasil dari perhitungan luas segitiga adalah 25.00(Eksperimen 2: alas 15 dan tinggi 6)
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas : 15
Masukkan nilai dari tinggi : 6
---------------------------------------------
Hasil dari perhitungan luas segitiga adalah 45.00Penjelasan:
1. Perintah untuk memasukkan nilai alas dari suatu segitiga. Disimpan ke dalam variabel alas.
alas = float(input("Masukkan nilai dari alas : "))2. Perintah untuk memasukkan nilai tinggi dari suatu segitiga. Disimpan ke dalam variabel tinggi.
tinggi = float(input("Masukkan nilai dari tinggi : "))3. Menampilkan hasil perhitungan dari luas segitiga ke layar kamu. Hasil ditampilkan ke dalam dua desimal di belakang koma.
print("---------------------------------------------")
print(f"Hasil dari perhitungan luas segitiga adalah {luas:.2f}")Program di atas berjalan dengan baik.
Lantas, bagaimana kalo kita memasukkan alas atau tinggi tersebut bernilai negatif? Mari kita coba.
(Eksperimen 3: alas -20 dan tinggi 10) – Hasil program tidak sesuai
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas : -20
Masukkan nilai dari tinggi : 10
---------------------------------------------
Hasil dari perhitungan luas segitiga adalah -100.00Tidak mungkin, bahwa luas dari segitiga bernilai negatif sehingga ini membuat logic error walaupun program berjalan dengan baik. Maka kita perlu melakukan penanganan nilai input negatif tersebut.
Kedua,
Mari kita kembangkan lagi program python menghitung luas segitiga dengan tambahan menangani nilai yang inputnya kurang dari nol.
Secara garis besar, jika nilai alas dan tinggi kurang dari atau sama dengan nol maka tidak akan dilakukan perhitungan luas segitiga.
# -------------------------------------------
# Program Python Menghitung Luas Segitiga
# ~ Menggunakan Cara Sederhana
# ~ Handling Error Nilai Tidak Valid
# -------------------------------------------
print("Program Python Untuk Menghitung Luas Segitiga")
print("---------------------------------------------")
# perintah untuk memasukkan alas segitiga
alas = float(input("Masukkan nilai dari alas : "))
# perintah untuk memasukkan tinggi segitiga
tinggi = float(input("Masukkan nilai dari tinggi : "))
"""
* Kondisional if...else... untuk menangani nilai kurang dari 0
* Jika nilai tidak memenuhi maka akan muncul pesan
* Jika nilai tersebut valid maka dilakukan perhitungan luas
"""
print("----------------------------------------------")
if alas <= 0 or tinggi <= 0:
print("Nilai alas atau tinggi harus lebih dari 0")
else:
# menghitung luas segitiga menggunakan rumus
# nilai tersebut disimpan ke dalam variabel `luas`
luas = 0.5 * alas * tinggi
# menampilkan nilai perhitungan luas segitiga
print(f"Hasil dari perhitungan luas segitiga adalah {luas:.2f}")
Output:
(Eksperimen 1: alas 8 dan tinggi 9)
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas : 8
Masukkan nilai dari tinggi : 9
----------------------------------------------
Hasil dari perhitungan luas segitiga adalah 36.00(Eksperimen 2: alas -20 dan tinggi 20) – Sesuai ekspektasi
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas : -20
Masukkan nilai dari tinggi : 20
----------------------------------------------
Nilai alas atau tinggi harus lebih dari 0Penjelasan:
1. Perintah untuk memasukkan input nilai alas maupun tinggi dari bangun segitiga.
alas = float(input("Masukkan nilai dari alas : "))
tinggi = float(input("Masukkan nilai dari tinggi : "))2. Kondisi if … untuk menangani jika nilai dari alas atau tinggi kurang dari sama dengan nol maka tidak akan dilakukan perhitungan luas.
if alas <= 0 or tinggi <= 0:
print("Nilai alas atau tinggi harus lebih dari 0")
...3. Masuk ke kondisi else… maka akan dilakukan perhitungan luas segitiga. Hasil perhitungan tersebut disimpan ke dalam variabel dengan nama luas
...
else:
luas = 0.5 * alas * tinggi4. Menampilkan hasil perhitungan dari luas segitiga ke layar.
...
print(f"Hasil dari perhitungan luas segitiga adalah {luas:.2f}")Kita kembangkan program sebelumnya menggunakan function untuk mempermudah dan dapat digunakan kembali ketika dipanggil.
Kali ini kita akan membuat function python baru dengan nama hitung_luas_segitiga yang mana punya dua parameter mewakili alas dan tinggi.
# ---------------------------------------
# Program Python Menghitung Luas Segitiga
# ~ Menggunakan Custom Function ~
# ---------------------------------------
print("Program Python Untuk Menghitung Luas Segitiga")
print("---------------------------------------------")
# membuat function hitung luas dengan parameter a dan t
# jika parameter a dan t kurang dari 0 maka akan mendapatkan value error
# jia parameter memenuhi maka dilakukan return perhitungan luas
def hitung_luas_segitiga(a, t):
if a <= 0 or t <= 0:
raise ValueError("Nilai alas atau tinggi harus lebih dari 0")
return 0.5 * a * t
# perintah try...except... untuk handling error saat program dijalankan
try:
# perintah untuk memasukkan nilai alas
alas = float(input("Masukkan nilai dari alas segitiga : "))
# perintah untuk memasukkan nilai tinggi
tinggi = float(input("Masukkan nilai dari tinggi segitiga : "))
# pemanggilan function `hitung_luas_segitiga` dengan nilai argument alas dan tinggi
luas = hitung_luas_segitiga(alas, tinggi)
# menampilkan hasil perhitungan luas segitiga ke layar
print("---------------------------------------------")
print(f"Hasil dari luas segitiga adalah {luas:.2f}")
except ValueError as error:
# menampilkan pesan jika terjadi error
print("---------------------------------------------")
print("Error:", error)
Output:
(Eksperimen 1: alas 10 dan tinggi 20)
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas segitiga : 10
Masukkan nilai dari tinggi segitiga : 20
---------------------------------------------
Hasil dari luas segitiga adalah 100.00(Eksperimen 2: alas -5 dan tinggi 10)
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai dari alas segitiga : -5
Masukkan nilai dari tinggi segitiga : 10
---------------------------------------------
Error: Nilai alas atau tinggi harus lebih dari 0Penjelasan:
1. Membuat function baru dengan nama hitung_luas_segitiga menggunakan parameter pertama a mewakili alas dan parameter kedua t yang mewakili tinggi. Jika nilai dari a atau t kurang dari sama dengan nol maka akan mendapatkan error. Jika memenuhi maka nilai akan dikembalikan dengan perkalian rumus segitiga secara umum.
...
def hitung_luas_segitiga(a, t):
if a <= 0 or t <= 0:
raise ValueError("Nilai alas atau tinggi harus lebih dari 0")
return 0.5 * a * t
...2. Menggunakan try…except… untuk menangani jika terjadi kesalahan ketika program dijalankan.
try:
...
except ValueError as err:
...
3. Perintah untuk memasukkan nilai alas segitiga
alas = float(input("Masukkan nilai dari alas segitiga : "))4. Perintah untuk memasukkan nilai tinggi segitiga
tinggi = float(input("Masukkan nilai dari tinggi segitiga : "))5. Pemanggilan function hitung_luas_segitiga serta memasukkan nilai variabel alas dan tinggi sebagai argument. Hasil nilai tersebut disimpan ke dalam variabel luas.
luas = hitung_luas_segitiga(alas, tinggi)6. Menampilkan hasil perhitungan segitiga pada layar.
print("---------------------------------------------")
print(f"Hasil dari luas segitiga adalah {luas:.2f}")7. Jika program dijalankan terjadi error, misalnya nilai alas dan tinggi tidak sesuai maka akan muncul pesan error.
...
except ValueError as error:
print("---------------------------------------------")
print("Error:", error)Okay, selanjutnya kita kembangkan lagi dengan menggunakan konsep pemrograman berorientasi objek.
Apakah kamu sudah paham dengan konsep OOP?
Jadi, Konsep OOP (Object-Oriented Programming) dalam Python adalah paradigma pemrograman yang berfokus pada penggunaan objek dan kelas untuk mengatur kode.
Penggunaan OOP bertujuan untuk membuat program lebih modular, terstruktur, dan mudah di-maintenance.
Kali ini kita akan membuat class baru dengan nama Segitiga yang mempunyai atribut alas dan tinggi.
Mari kita coba program menghitung luas lingkaran dengan menggunakan OOP berikut ini.
# -----------------------------------------
# Program Python Menghitung Luas Segitiga
# ~ Menggunakan Konsep OOP ~
# -----------------------------------------
print("Program Python Untuk Menghitung Luas Segitiga")
print("---------------------------------------------")
# membuat class baru dengan nama Segitiga
class Segitiga:
# method untuk inisialisasi atribut dari class
# jika parameter a atau t nilainya kurang dari sama dengan 0 maka akan error
def __init__(self, a, t):
if a <= 0 or t <= 0:
raise ValueError("Nilai alas dan tinggi harus lebih dari 0")
# nilai parameter a akan disimpan dalam atribut `alas` dari objek
self.alas = a
# nilai parameter t akan disimpan dalam atribut `tinggi` dari objek
self.tinggi = t
# method untuk hitung luas yang akan return nilai dari 1/2 * alas * tinggi
def hitung_luas(self):
return 0.5 * self.alas * self.tinggi
# penggunakan try...except... untuk menangani handling error
try:
# perintah untuk memasukkan nilai alas segitiga
alas = float(input("Masukkan nilai alas segitiga : "))
# perintah untuk memasukkan nilai tinggi segitiga
tinggi = float(input("Masukkan nilai tinggi segitiga : "))
# membuat objek baru dari class Segitiga dengan nama `bangun_datar_segitiga`
# variabel alas dan tinggi dijadikan argumen dari class tersebut
bangun_datar_segitiga = Segitiga(alas, tinggi)
# memanggil method `hitung_luas()` dan disimpan ke variabel luas
luas = bangun_datar_segitiga.hitung_luas()
# hasil perhitungan akan ditampilkan ke dalam layar
print("--------------------------------------")
print(f"Hasil perhitungan luas adalah {luas}")
except ValueError as err:
# jika terjadi error maka akan menampilkan pesan error pada layar
print("--------------------------------------")
print("Error:", err)
Output:
(Eksperimen 1 – alas 10 dan tinggi 20) -> bisa dihitung
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai alas segitiga : 10
Masukkan nilai tinggi segitiga : 20
--------------------------------------
Hasil perhitungan luas adalah 100.0(Eksperimen 2 – alas 10 dan tinggi -20) -> akan muncul error
Program Python Untuk Menghitung Luas Segitiga
---------------------------------------------
Masukkan nilai alas segitiga : 10
Masukkan nilai tinggi segitiga : -20
--------------------------------------
Error: Nilai alas dan tinggi harus lebih dari 0Penjelasan:
1. Membuat class baru dengan nama Segitiga yang akan digunakan sebagai blueprint objek
...
class Segitiga:
...2. Membuat method khusus __init__ yang dipanggil secara otomatis ketika objek dari class ini dibuat. Method ini menerima 2 parameter selain self yakni a dan t (mewakili alas dan tinggi). Terdapat juga validasi jika alas atau tinggi kurang dari sama dengan nol maka akan dijadikan error.
...
class Segitiga:
def __init__(self, a, t):
if a <= 0 or t <= 0:
raise ValueError("Nilai alas dan tinggi harus lebih dari 0")
self.alas = a
self.tinggi = t
...3. Membuat method baru dengan nama hitung_luas yang akan mengembalikan nilai dalam bentuk rumus perhitungan luas segitiga.
...
class Segitiga:
...
def hitung_luas(self):
return 0.5 * self.alas * self.tinggi
...4. Menggunakan try…except… untuk menangani suatu error ketika program python menghitung luas segitiga tersebut dijalankan.
...
try:
...
except ValueError as err:
print("--------------------------------------")
print("Error:", err)5. Di dalam try, kita lakukan input masukkan data untuk alas dan tinggi serta disimpan ke variabel.
...
try:
alas = float(input("Masukkan nilai alas segitiga : "))
tinggi = float(input("Masukkan nilai tinggi segitiga : "))
...6. Membuat objek baru dengan nama bangun_datar_segitiga dari class Segitiga yang berisi argument pertama yakni alas dan argument kedua yakni tinggi. Nilai tersebut berasal dari inputan yang telah dilakukan sebelumnya.
...
bangun_datar_segitiga = Segitiga(alas, tinggi)
...7. Pada objek bangun_datar_segitiga kita panggil method tersebut untuk melakukan perhitungan luas. Nilai tersebut juga akan disimpan ke dalam variabel luas
luas = bangun_datar_segitiga.hitung_luas()8. Menampilkan hasil perhitungan luas segitiga tersebut ke dalam layar.
print("--------------------------------------")
print(f"Hasil perhitungan luas adalah {luas}")Program di atas hanya berlaku jika alas dan tingginya diketahui.
Bagaimana kalo kita ingin menghitung segitiga sembarang yang hanya diketahui ketiga sisinya?
Untuk menghitung luas dari segitiga sembarang, kita bisa gunakan rumus Heron:
L = √(s x (s – a) x (s – b) x (s – c))
s = 1/2 dari keliling lingkaran
a, b, c merupakan sisi yang diketahui
Mari kita coba perhitungan tersebut menggunakan python.
# -------------------------------------------------
# Program Python Menghitung Luas Segitiga Sembarang
# ~ Menghitung Luas Jika Diketahui Ketiga Sisinya ~
# -------------------------------------------------
# import built-in `math` python untuk pemanggilan akar (root)
import math
print("Program Python Menghitung Luas Segitiga Sembarang")
print("-------------------------------------------------")
# membuat class baru dengan nama SegitigaSembarang
class SegitigaSembarang:
# method inisialisasi setiap atribut dari objek
# berisi tiga parameter x, y, z yang mewakili nilai dari setiap sisi segitiga
def __init__(self, x, y, z):
if x <= 0 or y <= 0 or z <= 0:
raise ValueError("Nilai sisi segitiga harus lebih dari nol!")
self.s1 = x
self.s2 = y
self.s3 = z
# method untuk melakukan pengecekan bahwa setiap sisi segitiga valid
# syarat terbentuknya segitiga
# return dalam bentuk boolean (True/False)
# jika True maka segitiga valid dan bisa dihitung
# jika False maka segitiga tidak bisa dihitung
def is_valid_segitiga(self)->bool:
return (
self.s1 + self.s2 > self.s3 and
self.s1 + self.s3 > self.s2 and
self.s2 + self.s3 > self.s1
)
# method untuk menghitung luas segitiga dengan heron formula
# return nilai luas tersebut dalam bentuk tipe data float
def hitung_luas_segitiga(self)->float:
# menghitung nilai keliling dibagi dengan dua dan disimpan ke variabel s
s = (self.s1 + self.s2 + self.s3) / 2
# luas -> menggunakan heron formula bisa dihitung dengan rumus berikut,
# L = √(s x (s - s1) x (s - s2) x (s - s3))
luas = math.sqrt(s* (s - self.s1) * (s - self.s2) * (s - self.s3))
# membalikkan nilai hasil perhitungan luas
return luas
# menggunakan try... except ... untuk handling error jika program dijalankan
try:
# perintah untuk memasukkan nilai setiap sisi dari segitiga
s1 = float(input("Masukkan nilai sisi pertama : "))
s2 = float(input("Masukkan nilai sisi kedua : "))
s3 = float(input("Masukkan nilai sisi ketiga : "))
# membuat objek baru dari class SegitigaSembarang dengan nama bangun_segitiga
# berisi tiga argument dari sisi-sisi segitiga
bangun_segitiga = SegitigaSembarang(s1, s2, s3)
print("------------------------------------------------")
# melakukan pengecekan terhadap segitiga apakah valid atau tidak
# jika segitiga tersebut valid maka dilakukan perhitungan luas
if (bangun_segitiga.is_valid_segitiga()):
# pemanggilan method hitung_luas_segitiga() untuk menghitung luas dari objek bangun_segitiga
luas = bangun_segitiga.hitung_luas_segitiga()
# menampilkan hasil perhitungan luas segitiga ke layar
print(f"Hasil perhitungan luas segitiga adalah {luas:.2f}")
else:
# menampilkan informasi bahwa segitiga tersebut tidak valid
print("Segitiga tidak valid & tidak bisa dihitung!")
except ValueError as err:
# menampikan pesan error jika atribut objek tidak valid
print("------------------------------------------------")
print("Error:", err)
Output:
(Eksperimen 1 –> sisi pertama = 10, sisi kedua = 10, dan sisi ketiga = 10) – Bisa dihitung
Program Python Menghitung Luas Segitiga Sembarang
-------------------------------------------------
Masukkan nilai sisi pertama : 10
Masukkan nilai sisi kedua : 10
Masukkan nilai sisi ketiga : 10
------------------------------------------------
Hasil perhitungan luas segitiga adalah 43.30(Eksperimen 2 –> sisi pertama = -6, sisi kedua = 8, dan sisi ketiga = 3) – Sisi harus lebih dari nol
Program Python Menghitung Luas Segitiga Sembarang
-------------------------------------------------
Masukkan nilai sisi pertama : -6
Masukkan nilai sisi kedua : 8
Masukkan nilai sisi ketiga : 3
------------------------------------------------
Error: Nilai sisi segitiga harus lebih dari nol!(Eksperimen 3 –> sisi pertama = 6, sisi kedua = 8, dan sisi ketiga = 10) – Bisa dihitung
Program Python Menghitung Luas Segitiga Sembarang
-------------------------------------------------
Masukkan nilai sisi pertama : 6
Masukkan nilai sisi kedua : 8
Masukkan nilai sisi ketiga : 10
------------------------------------------------
Hasil perhitungan luas segitiga adalah 24.00Penjelasan:
1. Pemanggilan library built-in python yang akan digunakan untuk menghitung nilai akar
import math2. Membuat class baru dengan nama SegitigaSembarang
...
class SegitigaSembarang:
...3. Method khusus dari class SegitigaSembarang untuk inisialisasi atribut yang berisi tiga sisi. Sisi tersebut diwakilkan oleh parameter x, y, dan z. Jika salah satu dari sisi kurang dari atau sama dengan nol maka akan mendapatkan error.
...
class SegitigaSembarang:
def __init__(self, x, y, z):
if x <= 0 or y <= 0 or z <= 0:
raise ValueError("Nilai sisi segitiga harus lebih dari nol!")
self.s1 = x
self.s2 = y
self.s3 = z
...4. Method is_valid_segitiga() ini digunakan untuk melakukan pengecekan apakah termasuk segitiga yang bisa terbentuk atau tidak.
Return dari method ini dalam bentuk boolean (True/False).
Method ini seperti pengecekan teorema pertidaksamaan dari segitiga, yang mana jumlah kedua sisi segitiga selalu lebih besar dari sisi ketiga.
...
def is_valid_segitiga(self)->bool:
return (
self.s1 + self.s2 > self.s3 and
self.s1 + self.s3 > self.s2 and
self.s2 + self.s3 > self.s1
)
...5. Membuat method hitung_luas_segitiga() untuk melakukan perhitungan dari segitiga.
Return dari method ini dalam bentuk float.
s merupakan setengah dari keliling segitiga.
Untuk menghitung luas, kita bisa menggunakan rumus Heron.
...
class SegitigaSembarang:
...
def hitung_luas_segitiga(self)->float:
s = (self.s1 + self.s2 + self.s3) / 2
luas = math.sqrt(s* (s - self.s1) * (s - self.s2) * (s - self.s3))
return luas
...
6. Menggunakan try…except... untuk menangani error ketika program dijalankan.
try:
...
except ValueError as err:
print("------------------------------------------------")
print("Error:", err)7. Perintah untuk memasukkan tiga sisi dari segitiga
try:
s1 = float(input("Masukkan nilai sisi pertama : "))
s2 = float(input("Masukkan nilai sisi kedua : "))
s3 = float(input("Masukkan nilai sisi ketiga : "))
...8. Membuat objek baru dari class SegitigaSembarang dan berisi argument dari ketiga sisi segitiga.
...
bangun_segitiga = SegitigaSembarang(s1, s2, s3)
...9. Pengecekan apakah segitiga dapat dibentuk atau tidak dari ketiga sisi tersebut.
Jika True, maka dilakukan perhitungan luas dengan pemanggilan method hitung_luas_segitiga(). Dan hasilnya akan ditampilkan pada layar.
Jika False, maka tidak dilakukan perhitungan luas dan langsung memberikan informasi bahwa segitiga tersebut tidak valid.
...
if (bangun_segitiga.is_valid_segitiga()):
luas = bangun_segitiga.hitung_luas_segitiga()
print(f"Hasil perhitungan luas segitiga adalah {luas:.2f}")
else:
print("Segitiga tidak valid & tidak bisa dihitung!")
...Demikian artikel mengenai program python untuk melakukan perhitungan luas segitiga dengan berbagai macam cara.
Tentunya, kamu bisa coba dengan cara sendiri sesuai dengan kebutuhan yang ada.
Semoga tulisan mengenai tutorial python untuk menghitung luas dari bangun segitiga ini menjadi bermanfaat.
Terima kasih dan happy coding! 🚀