#tipe data Boolean #Menghitung luas segitiga menggunakan fungsi.

print(True)
import math
#tipe data String
print("Ayo belajar Python") def LuasSegitigaabc(a, b, c):
print('Belajar Python Sangat Mudah') return 0.5 * a * b * math.sin(c)

#tipe data Integer a = int(input("a = "))

print(20) b = int(input("b = "))
c = float(input("c = "))
#tipe data Float L = LuasSegitigaabc(a, b, c)
print(3.14)
print("Luas segitiganya adalah", L)
Pertemuan ke-3
========== GAYA MODULAR ==========
========== PENGENALAN KODE PERINTAH SEDERHANA PADA PYTHON ==========
Gaya modular: Pembagian/penguraian masalah yang besar menjadi beberapa bagian
#Pengenalan kode perintah sederhana pada Python. yang lebih kecil.

a = input("Masukkan nama Anda: ") Contoh: Mencari luas persegi

print("Halo", a, "apa kabar?") def LuasABCD(p, l):

return p * l
==========
def LuasPersegi(s):
Masukkan nama Anda: Michael return LuasABCD(s, s)
Halo Michael apa kabar?
========== VARIABEL GLOBAL DAN LOKAL ==========
========== PERHITUNGAN LUAS LINGKARAN ==========
#Variabel global: Variabel yang dapat diakses dari semua fungsi, karena terletak di
#Menghitung luas lingkaran. luar fungsi.
#Variabel lokal: Variabel yang hanya dapat diakses di dalam fungsi tempat ia berada
a = input("Masukkan jari-jari lingkaran = ") saja.
b = int(a) #Variabel build-in: Variabel yang sudah ada di dalam Python.
L = 3.14 * b**2 #Pada Python, urutan pengaksesan variabel (scope) dikenal dengan sebutan LGB
(local, global, and build-in).
print("Luasnya adalah", L)
Nama = "Petani"
#Cara 2 menghitung luas lingkaran. Versi = "1.0.0"
#Cara 2 ini menggunakan modul mathematics berupa math.pi (phi) sehingga hasil #Ini merupakan variabel global.
perhitungannya akan lebih detail/tepat.
#Selain itu, penggunaan fungsi int() juga dapat diringkas seperti berikut. def Help():
Nama = "Programku"
import math Versi = "1.0.2"
#Ini merupakan variabel lokal.
a = int(input("Masukkan jari-jari lingkaran = ")) print("Nama: ", Nama)
L = math.pi * a**2 print("Versi: ", Versi)

print("Luasnya adalah", L) #Memanggil variabel global.

print("Nama: ", Nama)
========== print("Versi: ", Versi)

Masukkan jari-jari lingkaran = 7 #Memanggil fungsi help.

Luasnya adalah 153.86 Help()
Masukkan jari-jari lingkaran = 7
Luasnya adalah 153.93804002589985 ==========

========== FUNGSI TRIGONOMETRI ========== Nama: Petani

Versi: 1.0.0
>>> #Di Python, kita dapat mencari nilai dari fungsi trigonometri, tetapi harus diubah Nama: Programku
dahulu dari derajat ke radian. Versi: 1.0.2
>>> import math
>>> a = 30 ========== ASSIGNMENT - SURFACE AREA OF SPHERE ==========
>>> math.radians(a)
0.5235987755982988 #The Program of Finding the Surface Area of Sphere
>>> math.sin(math.radians(a))
0.49999999999999994 print("THE PROGRAM OF FINDING THE SURFACE AREA OF SPHERE")
print("=================================================")
========== PERHITUNGAN LUAS SEGITIGA ==========
import math
#Menghitung luas segitiga.
def SurfaceAreaofSphere (r):
import math return 4*math.pi*r**2

a = int(input("a = ")) r = float(input("Insert the radius of sphere = "))

b = int(input("b = ")) A = SurfaceAreaofSphere (r)
c = float(input("c = "))
L = 0.5 * a * b * math.sin(c) print("So, the surface area of sphere is =", A)

print("Luas segitiganya adalah", L) ========== ASSIGNMENT - VOLUME OF SPHERE ==========

========== #The Program of Finding the Volume of Sphere

a=3 print("THE PROGRAM OF FINDING THE VOLUME OF SPHERE")

b=5 print("===========================================")
c = 3.14
Luas segitiganya adalah 0.011944896873651212 import math

========== PERHITUNGAN LUAS SEGITIGA MENGGUNAKAN FUNGSI ========== def VolumeofSphere (r):
return 4/3*math.pi*r**3
 n = 8 #Tambahkan satu buah variabel untuk menentukan range pengulangan (berapa
r = float(input("Insert the radius of sphere = ")) kali pengulangan).
V = VolumeofSphere (r) #Jika akan dibuat segitiga, maka nilai n = 3.
#Jika akan dibuat persegi/segi-4, maka nilai n = 4.
print("So, the volume of sphere is =", V) #Jika akan dibuat segi-n, maka nilai n = n.

========== ASSIGNMENT - ROOTS OF QUADRATIC EQUATION ========== for i in range(n): #Maksudnya perintah akan diulang sebanyak n kali.
MW.fd(100)
#The Program of Finding The Roots of Quadratic Equation MW.lt(360/n) #Ini rumus sederhana besar sudut belok antara 2 sisi poligon
terdekat.
print("THE PROGRAM OF FINDING THE ROOTS OF QUADRATIC EQUATION")
print("======================================================") MW.hideturtle()
print("Suppose the quadratic equation like this, ax**2 + bx + c") turtle.mainloop()

import math ========== PEMBUATAN POLIGON/SEGI-N 2 ==========

def x1 (a, b, c): #Cara 2 membuat poligon/segi-n dengan modul turtle memanfaatkan metode
return (-b + math.sqrt((b**2) - (4*a*c)))/(2*a) pengulangan/iterasi.
#Cara 2 ini menggunakan fungsi pembuat poligon (cara ini disebut enkapsulasi).
def x2 (a, b, c):
return (-b - math.sqrt((b**2) - (4*a*c)))/(2*a) import turtle
MW = turtle.Turtle()
a = int(input("Insert the value of a = ")) print(MW)
b = int(input("Insert the value of b = "))
c = int(input("Insert the value of c = ")) def BuatPoligon(sisi, panjang):
x1 = x1 (a, b, c) for i in range(sisi):
x2 = x2 (a, b, c) MW.fd(panjang)
MW.lt(360/sisi)
print("So, the roots of the quadratic equation is x1 =", x1, "and x2 =", x2)
BuatPoligon(8, 100)
Pertemuan ke-4
MW.hideturtle()
========== PENGENALAN TURTLE ========== turtle.mainloop()

#Turtle: Suatu modul pada Python yang digunakan untuk membuat semacam gambar ========== PEMBUATAN LINGKARAN ==========
grafis.
#Metode membuat gambar grafis di sini dilakukan secara step-by-step (sistematis). #Membuat lingkaran dengan modul turtle.
#Cara pembuatan lingkaran harus melibatkan fungsi pembuat poligon.
import turtle #Lingkaran dapat didefinisikan sebagai segi tak terhingga.
MW = turtle.Turtle() #Misalkan kita namai sang turtle MW.
print(MW) import turtle
#Kode perintah di atas merupakan susunan kode perintah awal yang wajib ada, yang import math
berfungsi untuk memanggil modul turtle. MW = turtle.Turtle()
print(MW)
#Selanjutnya kita tinggal menyusun kode-kode perintah selanjutnya untuk menyuruh
sang turtle berjalan agar membentuk suatu gambar grafis. def BuatPoligon(sisi, panjang):
MW.fd(100) #Perintah fd(x) ini menyuruh turtle maju ke depan sejauh x piksel. for i in range(sisi):
MW.fd(-100) #Jika -x, berarti mundur ke belakang sejauh x piksel. MW.fd(panjang)
MW.lt(90) #Perintah lt(x) ini menyuruh turtle belok ke kiri sebesar x derajat. MW.lt(360/sisi)
MW.fd(100)
MW.rt(135) #Perintah rt(x) ini menyuruh turtle belok ke kanan sebesar x derajat. def BuatLingkaran(r):
Berlaku rt(x) = lt(-x). keliling = 2 * math.pi * r
MW.fd(200) sisi = 360 #Jumlah sisinya ditentukan secara bebas, mendekati tak terhingga.
MW.rt(90) panjang = keliling / sisi
MW.fd(50) BuatPoligon(sisi, panjang)
#Perhatikan 3 rangkaian perintah di bawah.
MW.pu() BuatLingkaran(200)
MW.fd(100)
MW.pd() MW.hideturtle()
#Tiga rangkaian perintah tersebut menyuruh turtle pindah dari posisi sebelumnya turtle.mainloop()
sejauh yang diinginkan.
MW.circle(50, 180)#Perintah circle(r, sudut) menyuruh turtle melakukan gerak ========== PEMBUATAN LINGKARAN 2 ==========
melingkar dengan jari-jari r dan sudut tertentu.
MW.lt(45) #Cara 2 membuat lingkaran dengan modul turtle.
MW.fd(100) #Cara 2 ini melibatkan fungsi pembuat arc.
MW.circle(100, 270)
MW.circle(100, -180) import turtle
MW.pu() import math
MW.fd(-50) MW = turtle.Turtle()
MW.pd() print(MW)
MW.circle(50, 90)
def BuatPolyline(n, panjang, sudut):
MW.hideturtle() #Perintah ini untuk menghilangkan turtle setelah menyelesaikan for i in range(n):
semua rangkaian perjalannnya. MW.fd(panjang)
turtle.mainloop() #Perintah ini untuk menunggu user melakukan sesuatu setelah MW.lt(sudut)
seluruh perintah sebelumnya telah terselesaikan (misalnya menutup jendela turtle).
Selain turtle.mainloop(), dapat juga digunakan turtle.done(). def BuatPoligon(sisi, panjang):
sudut = 360 / sisi
========== PEMBUATAN POLIGON/SEGI-N ========== BuatPolyline(n, panjang, sudut)

#Membuat poligon/segi-n dengan modul turtle memanfaatkan metode def BuatArc(r, sudut):
pengulangan/iterasi. panjang_arc = 2 * math.pi * r * sudut / 360
#Metode pengulangan/iterasi ini akan dijelaskan lebih lanjut pada pertemuan n = int(panjang_arc / 3) + 1
selanjutnya. panjang2 = panjang_arc / n
sudut2 = float(sudut) / n
import turtle BuatPolyline(n, panjang2, sudut2)
MW = turtle.Turtle()
print(MW) def BuatLingkaran(r):
BuatArc(r, 360)
BuatLingkaran(200) n=3

MW.hideturtle() if n < 3:
turtle.mainloop() print("Lebih kecil")
elif n > 3:
========== PEMBUATAN BUNGA DI BUKU THINK PYTHON 2ND EDITION HALAMAN print("Lebih besar")
37 FIGURE 4.1 ========== else:
print("Sama dengan")
#Membuat bunga di Buku Think Python 2nd Edition halaman 37 Figure 4.1 print("Selesai")
menggunakan modul turtle.
========== PENENTUAN BILANGAN GENAP ATAU GANJIL ==========
import turtle
import math n=8
MW = turtle.Turtle()
print(MW) if n % 2 == 0:
#Pernyataan a % b == c ini menyatakan bahwa a dibagi b bersisa c.
def BuatPolyline(n, panjang, sudut): print("Genap")
for i in range(n): else:
MW.fd(panjang) print("Ganjil")
MW.lt(sudut)
========== PENENTUAN BILANGAN GENAP POSITIF ATAU NEGATIF ATAU GANJIL
def BuatArc(r, sudut): POSITIF ATAU NEGATIF ==========
panjang_arc = 2 * math.pi * r * sudut / 360
n = int(panjang_arc / 4) + 3 n = int(input("Masukkan suatu bilangan bulat: "))
panjang2 = panjang_arc / n
sudut2 = float(sudut) / n if n % 2 == 0:
MW.lt(sudut2 / 2) if n > 0:
BuatPolyline(n, panjang2, sudut2) print("Genap positif")
MW.rt(sudut2 / 2) elif n < 0:
print("Genap negatif")
def Petal(r, sudut): else:
for i in range(2): print("Nol")
BuatArc(r, sudut) elif n > 0:
MW.lt(180-sudut) print("Ganjil positif")
else:
def BuatBunga(n, r, sudut): print("Ganjil negatif")
for i in range(n):
Petal(r, sudut) ========== PENENTUAN GRADE NILAI ==========
MW.lt(360/n)
n = 40
def Pindah(jarak):
MW.pu() if n >= 90:
MW.fd(jarak) print("A")
MW.pd() elif n >= 80:
print("A-")
Pindah(-100) elif n >= 70:
BuatBunga(7, 60, 60) print("B+")
elif n >= 60:
Pindah(100) print("B")
BuatBunga(10, 40, 80) elif n >= 50:
print("B-")
Pindah(100) elif n >= 40:
BuatBunga(20, 140, 20) print("C+")
elif n >= 30:
MW.hideturtle() print("C")
turtle.mainloop() elif n >= 20:
print("C-")
Pertemuan ke-5 elif n >= 10:
print("D")
========== ITERATION ========== else:
print("E")
#Iteration: Proses menjalankan suatu pernyataan/perintah secara berulang mengikuti print("Selesai")
suatu interval/range.
========== KRITERIA 3 SISI DAPAT DIBENTUK SEBUAH SEGITIGA ==========
n = 10
#Kriteria 3 sisi dapat dibentuk sebuah segitiga.
#Akan dimunculkan variabel kontinu i (dimulai dari 0, 1, 2, ...) secara berulang sejauh
interval/range n. a = int(input("Masukkan panjang sisi a = "))
for i in range(n): b = int(input("Masukkan panjang sisi b = "))
print(i) c = int(input("Masukkan panjang sisi c = "))

========== ITERATION 2 ========== if a <= b + c and b <= a + c and c <= a + b:

print("Bisa dibentuk segitiga")
#Akan dimunculkan variabel kontinu i secara berulang mengikuti interval/range yang else:
dirincikan. print("Tidak bisa dibentuk segitiga")

n = 10 ========== PENENTUAN FAKTORIAL, FIBONACCI, DAN FPB ==========

for i in range(n+1, 1, -3): def Faktorial(n):

#Range tersebut mengindikasikan n+1 >= i > 1, dengan setiap pengulangannya if n == 0:
dikurangi dengan 3. return 1
print(i) else:
return n*Faktorial(n-1)
========== PERBANDINGAN - MENGGUNAKAN PERNYATAAN (IF), (ELIF), DAN (ELSE)
========== def Fib(n):
if n == 0 or n == 1:
#Pernyataan (if): Jika ... maka .... return n
#Pernyataan (elif): Di luar kondisi (if), jika ... maka .... else:
#Pernyataan (else): Di luar kondisi (if) dan (elif), jika yang lain maka .... return Fib(n-1) + Fib(n-2)
def FPB(a, b): #Angka 10**-4 mencerminkan angka yang mendekati 0 (tidak harus -4, boleh
if b == 0: juga -5, -6, -7, ...).
return a #Angka 10**-4 ini akan dijelaskan lebih lanjut di mata kuliah Metode Numerik.
else: return x
return FPB(b, a%b)
print(AkarKuadrat(2))
n=5
a = 16 ========== ASSIGNMENT - GAME OF GUESSING NUMBER ==========
b = 24
#The Program of Making the Game of Guessing Number
print(Faktorial(n))
print(Fib(n)) #1. Game introduction
print(FPB(a, b)) print("WELCOME TO THE GAME OF GUESSING NUMBER")
print(" ")
Pertemuan ke-6 print("Game instructions:")
print("1. A secret number has been selected by the system by choosing a number
========== DEFINISI PERKALIAN ========== randomly.")
print("2. You must guess that secret number by inserting the guess number.")
#Definisi perkalian a x b: Menjumlahkan nilai b yang muncul sebanyak a kali. print("3. Remember that the range of number is from 1 to 100.")
print("4. After you insert the guess number, the system will make a decision for your
def Kali(a, b): guess number.")
Hasil = 0 print("5. You'll be given an indicator if your guess number is greater or less than the
for i in range(a): secret number.")
Hasil += b print("6. You must guess until your guess number is equal to the secret number.")
return Hasil print("7. After you win, you'll be given an indicator of the number of times you
#Hasil += b itu identik dengan Hasil = Hasil + b. guessing.")
#Hasil -= b itu identik dengan Hasil = Hasil - b. print(" ")
#Hasil *= b itu identik dengan Hasil = Hasil * b. print("Good luck!")
#Hasil /= b itu identik dengan Hasil = Hasil / b. print(" ")
print("Let's play the game!")
print(Kali(4, 5)) print(" ")

========== DEFINISI PERKALIAN 2 - MENGGUNAKAN PERNYATAAN (WHILE) #2. Importing random module
========== import random

#Ada cara lain mendefinisikan perkalian menggunakan pernyataan (while). #3. Gameplay
#Pernyataan (while): Ketika pernyataan (while) masih terpenuhi, perintah akan def GuessNumber():
dikerjakan terus secara berulang, dan akan berhenti ketika pernyataan (while) sudah SecretNumber = random.randint(1, 100)
tidak terpenuhi. #Pernyataan (random.randint(a, b)) ini menyatakan bahwa sistem akan memilih
suatu angka secara acak dengan interval dari 1 sampai 100.
def Kali(a, b): GuessNumber = int(input("Insert your guess number: "))
Hasil = 0 count = 0
i=0 while SecretNumber != GuessNumber:
while i < a: #Simbol (!=) ini identik dengan pernyataan tidak sama dengan.
Hasil += b count += 1
i += 1 if GuessNumber < 1 or GuessNumber > 100:
return Hasil print("Your guess number is out of range. Try again!")
elif GuessNumber > SecretNumber:
print(Kali(4, 5)) print("Your guess number is too large. Try again!")
else:
========== DEFINISI PEMBAGIAN ========== print("Your guess number is too small. Try again!")
GuessNumber = int(input("Insert your guess number: "))
#Definisi pembagian: Menghitung berapa kali pengurangan a dengan b sampai a print("Yeah! Your guess number is equal to the secret number. The secret number
habis (a = 0). is", SecretNumber, ".")
totalcount = count + 1
def Bagi (a, b): print("The number of times you guessing is", totalcount, ".")
Hasil = 0 print("Congratulations!")
while a > 0: print(" ")
a -= b print("Do you want to play again?")
Hasil += 1 print("Y = Yes, let's play again!")
return Hasil print("N = No, I want to exit the game.")

print(Bagi(132, 6)) #4. Retry or exit the game

GuessNumber()
========== DEFINISI PEMBAGIAN BERSISA ========== choice = input("Pick your choice (Y/N): ")
while choice == "Y" or choice != "N":
#Definisi pembagian bersisa: Menghitung berapa kali pengurangan a dengan b if choice == "Y":
sampai a bersisa dan a <= b. print(" ")
print("Let's play again!")
def Bagi (a, b): print(" ")
Hasil = 0 GuessNumber()
while a >= b: choice = input("Pick your choice (Y/N): ")
a -= b else:
Hasil += 1 print("Invalid choice! Choose (Y) or (N)!")
return (Hasil, a) choice = input("Pick your choice (Y/N): ")

print(Bagi(135, 6)) Pertemuan ke-7

========== DEFINISI AKAR KUADRAT ========== ========== PENGENALAN STRING ==========

#Di Python tidak ada cara yang bisa mencari akar kuadrat secara tepat/sah 100%. Jadi >>> S1 = "Michael"
cara mencarinya dengan menggunakan sistem praduga (mendekati nilai pastinya). >>> S2 = "Wijaya"
>>> print(S1+S2)
def AkarKuadrat(a): MichaelWijaya
x=1 >>> print(S2+S1) #Penjumlahan string tidak bersifat komutatif.
while abs(x - a/x) > 10**-4: WijayaMichael
x = (x+a / x) / 2 >>> print(S1*5)
#Pernyataan (abs): Nilai absolute/mutlak. MichaelMichaelMichaelMichaelMichael
#Hasil (x - a/x) diusahakan mendekati 0 (x = a/x atau a = x*x). >>> print(5*S1) #Perkalian string bersifat komutatif.
MichaelMichaelMichaelMichaelMichael
>>> print(S1+" "+S2) #Jika ingin menambahkan spasi antar string. return True
Michael Wijaya
>>> S1[0] #Jika ingin mencari karakter pertama dari string (urutannya dimulai dari [0], print(CekPal('a man a plan a canal panama'))
[1], [2], ...).
'M' ========== PENGENALAN FUNGSI ORD() DAN CHR() ==========
>>> S1[4]
'a' >>> print(ord("A")) #Fungsi ord() berfungsi untuk mengembalikan kode bilangan
>>> len(S1) #Pernyataan (len) ini menyatakan panjang dari string (jumlah karakter unicode dari sebuah karakter string.
termasuk spasi, tanda baca, dsb). 65
7 >>> print(ord("B"))
>>> S1[8] #Jika kita menginput perintah mencari karakter ke-n dari suatu string, 66
tetapi nilai n yang diinput ada di luar interval dari jumlah karakter string tersebut, >>> print(ord("C"))
maka output perintah tersebut akan memunculkan pesan error. 67
Traceback (most recent call last): >>> print(ord("0"))
File "<pyshell#10>", line 1, in <module> 48
S1[8] #Jika kita menginput perintah mencari karakter ke-n dari suatu string, tetapi >>> print(ord("1"))
nilai n yang diinput ada di luar interval dari jumlah karakter string tersebut, maka 49
output perintah tersebut akan memunculkan pesan error. >>> print(ord("2"))
IndexError: string index out of range 50
>>> S1[7] >>> print(ord("9"))
Traceback (most recent call last): 57
File "<pyshell#11>", line 1, in <module> >>> print(chr(65)) #Fungsi chr() berfungsi untuk mengembalikan karakter unicode
S1[7] dari bilangan integer.
IndexError: string index out of range A
>>> S3 = "Namaku Febby." >>> print(chr(70))
>>> len(S3) F
13 >>> print(chr(48))
>>> S3[6] 0
'' >>> print(chr(57))
>>> S3[len(S3)-1] #Jika ingin mencari karakter terakhir dari suatu string. 9
'.'
>>> S3[-1] #Cara lain mencari karakter terakhir dari suatu string. ========== BERHITUNG DENGAN MEMANFAATKAN FUNGSI ORD() ==========
'.'
>>> S3[-4] #Dimulai dari -1, -2, -3, ..., itu merupakan urutan karakter ke-n tetapi #Berhitung dengan memanfaatkan fungsi ord().
dimulai dari belakang (jalan mundur).
'b' def Calculate(s):
Hasil = 0
========== PENULISAN SUSUNAN KARAKTER STRING ========== for i in s:
Hasil *= 10
#Penulisan susunan karakter string. Hasil += ord(i) - ord("0")
return Hasil
Fruit = "Banana"
print(Calculate("153") + 8)
index = 0
#Pernyataan (index) ini menyatakan karakter ke-n dari string tersebut.

#Cara 1 menuliskan susunan karakter string.

while index < len(Fruit):
print(Fruit[index])
index = index + 1

#Cara 2 menuliskan susunan karakter string.

for index in range(len(Fruit)):
print(Fruit[index])

#Cara 3 menuliskan susunan karakter string.

for i in Fruit:
print(i)

========== PENGECEKAN PALINDROM ==========

#Palindrom: Suatu susunan kata, frasa, angka, atau karakter lainnya yang dapat
dibaca secara sama baik dari depan maupun belakang.
#Pengecekan Palindrom meliputi pengecekan semua karakter, termasuk spasi, tanda
baca, dsb.

def CekPal(s):
for index in range(len(s)//2):
if s[index] != s[-(index+1)]:
return False
return True

print(CekPal("kasur rusak"))

========== PENGECEKAN PALINDROM 2 ==========

#Pengecekan Palindrom jika ingin spasi diabaikan.

def CekPal(s):
Kiri = 0
Kanan = len(s)-1
while Kiri < Kanan:
while s[Kiri] == ' ':
Kiri += 1
while s[Kanan] == ' ':
Kanan -= 1
if s[Kiri] != s[Kanan]:
return False
Kiri += 1
Kanan -= 1